@metamask/connect-multichain 0.1.0

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

@@ -0,0 +1,2564 @@
+/* Node.js ES build */
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/domain/errors/base.ts
+var BaseErr;
+var init_base = __esm({
+  "src/domain/errors/base.ts"() {
+    "use strict";
+    BaseErr = class extends Error {
+      constructor(message, code) {
+        super(message);
+        this.message = message;
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/domain/errors/rpc.ts
+var _RPCHttpErr, RPCHttpErr, _RPCReadonlyResponseErr, RPCReadonlyResponseErr, _RPCReadonlyRequestErr, RPCReadonlyRequestErr, _RPCInvokeMethodErr, RPCInvokeMethodErr;
+var init_rpc = __esm({
+  "src/domain/errors/rpc.ts"() {
+    "use strict";
+    init_base();
+    _RPCHttpErr = class _RPCHttpErr extends BaseErr {
+      constructor(rpcEndpoint, method, httpStatus) {
+        super(
+          `RPCErr${_RPCHttpErr.code}: ${httpStatus} on ${rpcEndpoint} for method ${method}`,
+          _RPCHttpErr.code
+        );
+        this.rpcEndpoint = rpcEndpoint;
+        this.method = method;
+        this.httpStatus = httpStatus;
+      }
+    };
+    _RPCHttpErr.code = 50;
+    RPCHttpErr = _RPCHttpErr;
+    _RPCReadonlyResponseErr = class _RPCReadonlyResponseErr extends BaseErr {
+      constructor(reason) {
+        super(
+          `RPCErr${_RPCReadonlyResponseErr.code}: RPC Client response reason ${reason}`,
+          _RPCReadonlyResponseErr.code
+        );
+        this.reason = reason;
+      }
+    };
+    _RPCReadonlyResponseErr.code = 51;
+    RPCReadonlyResponseErr = _RPCReadonlyResponseErr;
+    _RPCReadonlyRequestErr = class _RPCReadonlyRequestErr extends BaseErr {
+      constructor(reason) {
+        super(
+          `RPCErr${_RPCReadonlyRequestErr.code}: RPC Client fetch reason ${reason}`,
+          _RPCReadonlyRequestErr.code
+        );
+        this.reason = reason;
+      }
+    };
+    _RPCReadonlyRequestErr.code = 52;
+    RPCReadonlyRequestErr = _RPCReadonlyRequestErr;
+    _RPCInvokeMethodErr = class _RPCInvokeMethodErr extends BaseErr {
+      constructor(reason) {
+        super(
+          `RPCErr${_RPCInvokeMethodErr.code}: RPC Client invoke method reason (${reason})`,
+          _RPCInvokeMethodErr.code
+        );
+        this.reason = reason;
+      }
+    };
+    _RPCInvokeMethodErr.code = 53;
+    RPCInvokeMethodErr = _RPCInvokeMethodErr;
+  }
+});
+
+// src/domain/errors/index.ts
+var init_errors = __esm({
+  "src/domain/errors/index.ts"() {
+    "use strict";
+    init_rpc();
+  }
+});
+
+// src/domain/events/index.ts
+import { EventEmitter as EventEmitter3 } from "eventemitter3";
+var _emitter, EventEmitter;
+var init_events = __esm({
+  "src/domain/events/index.ts"() {
+    "use strict";
+    EventEmitter = class {
+      constructor() {
+        __privateAdd(this, _emitter, new EventEmitter3());
+      }
+      /**
+       * Emits an event with the specified name and arguments.
+       *
+       * @template TEventName - The name of the event to emit (must be a key of TEvents)
+       * @param eventName - The name of the event to emit
+       * @param eventArg - The arguments to pass to the event handlers
+       */
+      emit(eventName, ...eventArg) {
+        __privateGet(this, _emitter).emit(eventName, ...eventArg);
+      }
+      /**
+       * Registers an event handler for the specified event.
+       *
+       * @template TEventName - The name of the event to listen for (must be a key of TEvents)
+       * @param eventName - The name of the event to listen for
+       * @param handler - The function to call when the event is emitted
+       * @returns Nothing
+       */
+      on(eventName, handler) {
+        __privateGet(this, _emitter).on(eventName, handler);
+        return () => {
+          this.off(eventName, handler);
+        };
+      }
+      /**
+       * Removes a specific event handler for the specified event.
+       *
+       * @template TEventName - The name of the event to remove the handler from (must be a key of TEvents)
+       * @param eventName - The name of the event to remove the handler from
+       * @param handler - The specific handler function to remove
+       */
+      off(eventName, handler) {
+        __privateGet(this, _emitter).off(eventName, handler);
+      }
+    };
+    _emitter = new WeakMap();
+  }
+});
+
+// src/domain/logger/index.ts
+import debug from "debug";
+function isNamespaceEnabled(debugValue, namespace) {
+  return debugValue.includes(namespace) || debugValue.includes("metamask-sdk:*") || debugValue.includes("*");
+}
+var createLogger, enableDebug, isEnabled;
+var init_logger = __esm({
+  "src/domain/logger/index.ts"() {
+    "use strict";
+    createLogger = (namespace = "metamask-sdk", color = "214") => {
+      const logger5 = debug(namespace);
+      logger5.color = color;
+      return logger5;
+    };
+    enableDebug = (namespace = "metamask-sdk") => {
+      debug.enable(namespace);
+    };
+    isEnabled = (namespace, storage) => __async(null, null, function* () {
+      var _a;
+      if ("process" in globalThis && ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.DEBUG)) {
+        const { DEBUG } = process.env;
+        return isNamespaceEnabled(DEBUG, namespace);
+      }
+      const storageDebug = yield storage.getDebug();
+      if (storageDebug) {
+        return isNamespaceEnabled(storageDebug, namespace);
+      }
+      return false;
+    });
+  }
+});
+
+// src/domain/multichain/api/constants.ts
+var infuraRpcUrls, RPC_HANDLED_METHODS, SDK_HANDLED_METHODS;
+var init_constants = __esm({
+  "src/domain/multichain/api/constants.ts"() {
+    "use strict";
+    infuraRpcUrls = {
+      // ###### Ethereum ######
+      // Mainnet
+      "eip155:1": "https://mainnet.infura.io/v3/",
+      // Goerli
+      "eip155:5": "https://goerli.infura.io/v3/",
+      // Sepolia 11155111
+      "eip155:11155111": "https://sepolia.infura.io/v3/",
+      // ###### Linea ######
+      // Mainnet Alpha
+      "eip155:59144": "https://linea-mainnet.infura.io/v3/",
+      // Testnet ( linea goerli )
+      "eip155:59140": "https://linea-goerli.infura.io/v3/",
+      // ###### Polygon ######
+      // Mainnet
+      "eip155:137": "https://polygon-mainnet.infura.io/v3/",
+      // Mumbai
+      "eip155:80001": "https://polygon-mumbai.infura.io/v3/",
+      // ###### Optimism ######
+      // Mainnet
+      "eip155:10": "https://optimism-mainnet.infura.io/v3/",
+      // Goerli
+      "eip155:420": "https://optimism-goerli.infura.io/v3/",
+      // ###### Arbitrum ######
+      // Mainnet
+      "eip155:42161": "https://arbitrum-mainnet.infura.io/v3/",
+      // Goerli
+      "eip155:421613": "https://arbitrum-goerli.infura.io/v3/",
+      // ###### Palm ######
+      // Mainnet
+      "eip155:11297108109": "https://palm-mainnet.infura.io/v3/",
+      // Testnet
+      "eip155:11297108099": "https://palm-testnet.infura.io/v3/",
+      // ###### Avalanche C-Chain ######
+      // Mainnet
+      "eip155:43114": "https://avalanche-mainnet.infura.io/v3/",
+      // Fuji
+      "eip155:43113": "https://avalanche-fuji.infura.io/v3/",
+      // // ###### NEAR ######
+      // // Mainnet
+      // 'near:mainnet': `https://near-mainnet.infura.io/v3/`,
+      // // Testnet
+      // 'near:testnet': `https://near-testnet.infura.io/v3/`,
+      // ###### Aurora ######
+      // Mainnet
+      "eip155:1313161554": "https://aurora-mainnet.infura.io/v3/",
+      // Testnet
+      "eip155:1313161555": "https://aurora-testnet.infura.io/v3/",
+      // ###### StarkNet ######
+      // Mainnet
+      //
+      // 'starknet:SN_MAIN': `https://starknet-mainnet.infura.io/v3/`,
+      // // Goerli
+      // 'starknet:SN_GOERLI': `https://starknet-goerli.infura.io/v3/`,
+      // // Goerli 2
+      // 'starknet:SN_GOERLI2': `https://starknet-goerli2.infura.io/v3/`,
+      // ###### Celo ######
+      // Mainnet
+      "eip155:42220": "https://celo-mainnet.infura.io/v3/",
+      // Alfajores Testnet
+      "eip155:44787": "https://celo-alfajores.infura.io/v3/"
+    };
+    RPC_HANDLED_METHODS = /* @__PURE__ */ new Set([
+      "eth_blockNumber",
+      "eth_gasPrice",
+      "eth_maxPriorityFeePerGas",
+      "eth_blobBaseFee",
+      "eth_feeHistory",
+      "eth_getBalance",
+      "eth_getCode",
+      "eth_getStorageAt",
+      "eth_call",
+      "eth_estimateGas",
+      "eth_getLogs",
+      "eth_getProof",
+      "eth_getTransactionCount",
+      "eth_getBlockByNumber",
+      "eth_getBlockByHash",
+      "eth_getBlockTransactionCountByNumber",
+      "eth_getBlockTransactionCountByHash",
+      "eth_getUncleCountByBlockNumber",
+      "eth_getUncleCountByBlockHash",
+      "eth_getTransactionByHash",
+      "eth_getTransactionByBlockNumberAndIndex",
+      "eth_getTransactionByBlockHashAndIndex",
+      "eth_getTransactionReceipt",
+      "eth_getUncleByBlockNumberAndIndex",
+      "eth_getUncleByBlockHashAndIndex",
+      "eth_getFilterChanges",
+      "eth_getFilterLogs",
+      "eth_newBlockFilter",
+      "eth_newFilter",
+      "eth_newPendingTransactionFilter",
+      "eth_sendRawTransaction",
+      "eth_syncing",
+      "eth_uninstallFilter"
+    ]);
+    SDK_HANDLED_METHODS = /* @__PURE__ */ new Set(["eth_accounts", "eth_chainId"]);
+  }
+});
+
+// src/domain/multichain/api/infura.ts
+function getInfuraRpcUrls(infuraAPIKey) {
+  return Object.keys(infuraRpcUrls).reduce((acc, key) => {
+    const typedKey = key;
+    acc[typedKey] = `${infuraRpcUrls[typedKey]}${infuraAPIKey}`;
+    return acc;
+  }, {});
+}
+var init_infura = __esm({
+  "src/domain/multichain/api/infura.ts"() {
+    "use strict";
+    init_constants();
+  }
+});
+
+// src/domain/multichain/index.ts
+function getTransportType(type) {
+  switch (type) {
+    case "browser":
+      return "browser" /* Browser */;
+    case "mwp":
+      return "mwp" /* MPW */;
+    default:
+      return "unknown" /* UNKNOWN */;
+  }
+}
+var TransportType, MultichainCore;
+var init_multichain = __esm({
+  "src/domain/multichain/index.ts"() {
+    "use strict";
+    init_events();
+    init_constants();
+    init_infura();
+    TransportType = /* @__PURE__ */ ((TransportType2) => {
+      TransportType2["Browser"] = "browser";
+      TransportType2["MPW"] = "mwp";
+      TransportType2["UNKNOWN"] = "unknown";
+      return TransportType2;
+    })(TransportType || {});
+    MultichainCore = class extends EventEmitter {
+      constructor(options) {
+        super();
+        this.options = options;
+      }
+    };
+  }
+});
+
+// src/domain/platform/index.ts
+import { parse } from "bowser";
+function isNotBrowser() {
+  var _a;
+  if (typeof window === "undefined") {
+    return true;
+  }
+  if (!(window == null ? void 0 : window.navigator)) {
+    return true;
+  }
+  if (typeof global !== "undefined" && ((_a = global == null ? void 0 : global.navigator) == null ? void 0 : _a.product) === "ReactNative") {
+    return true;
+  }
+  return (navigator == null ? void 0 : navigator.product) === "ReactNative";
+}
+function isReactNative() {
+  var _a;
+  const hasWindowNavigator = typeof window !== "undefined" && window.navigator !== void 0;
+  const nav = hasWindowNavigator ? window.navigator : void 0;
+  if (!nav) {
+    return false;
+  }
+  return hasWindowNavigator && ((_a = window.navigator) == null ? void 0 : _a.product) === "ReactNative";
+}
+function isMetaMaskMobileWebView() {
+  return typeof window !== "undefined" && // @ts-expect-error ReactNativeWebView should be defined
+  Boolean(window.ReactNativeWebView) && Boolean(window.navigator.userAgent.endsWith("MetaMaskMobile"));
+}
+function isMobile() {
+  var _a, _b;
+  const browser = parse(window.navigator.userAgent);
+  return ((_a = browser == null ? void 0 : browser.platform) == null ? void 0 : _a.type) === "mobile" || ((_b = browser == null ? void 0 : browser.platform) == null ? void 0 : _b.type) === "tablet";
+}
+function getPlatformType() {
+  if (isReactNative()) {
+    return "react-native" /* ReactNative */;
+  }
+  if (isNotBrowser()) {
+    return "nodejs" /* NonBrowser */;
+  }
+  if (isMetaMaskMobileWebView()) {
+    return "in-app-browser" /* MetaMaskMobileWebview */;
+  }
+  if (isMobile()) {
+    return "web-mobile" /* MobileWeb */;
+  }
+  return "web-desktop" /* DesktopWeb */;
+}
+function isMetamaskExtensionInstalled() {
+  var _a;
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return Boolean((_a = window.ethereum) == null ? void 0 : _a.isMetaMask);
+}
+function isSecure() {
+  const platformType = getPlatformType();
+  return isReactNative() || platformType === "web-mobile" /* MobileWeb */;
+}
+function hasExtension() {
+  return __async(this, null, function* () {
+    return detectionPromise;
+  });
+}
+var PlatformType, detectionPromise;
+var init_platform = __esm({
+  "src/domain/platform/index.ts"() {
+    "use strict";
+    PlatformType = /* @__PURE__ */ ((PlatformType2) => {
+      PlatformType2["NonBrowser"] = "nodejs";
+      PlatformType2["MetaMaskMobileWebview"] = "in-app-browser";
+      PlatformType2["DesktopWeb"] = "web-desktop";
+      PlatformType2["MobileWeb"] = "web-mobile";
+      PlatformType2["ReactNative"] = "react-native";
+      return PlatformType2;
+    })(PlatformType || {});
+    detectionPromise = (() => __async(null, null, function* () {
+      const pt = getPlatformType();
+      if (pt === "nodejs" /* NonBrowser */ || pt === "react-native" /* ReactNative */) {
+        return Promise.resolve(false);
+      }
+      return new Promise((resolve) => {
+        const providers = [];
+        const handler = (event) => {
+          var _a, _b;
+          if ((_b = (_a = event == null ? void 0 : event.detail) == null ? void 0 : _a.info) == null ? void 0 : _b.rdns) {
+            providers.push(event.detail);
+          }
+        };
+        window.addEventListener("eip6963:announceProvider", handler);
+        window.dispatchEvent(new Event("eip6963:requestProvider"));
+        setTimeout(() => {
+          window.removeEventListener("eip6963:announceProvider", handler);
+          const hasMetaMask = providers.some(
+            (provider) => {
+              var _a;
+              return ((_a = provider == null ? void 0 : provider.info) == null ? void 0 : _a.rdns) === "io.metamask";
+            }
+          );
+          resolve(hasMetaMask);
+        }, 300);
+      });
+    }))();
+  }
+});
+
+// src/domain/store/adapter.ts
+var StoreAdapter;
+var init_adapter = __esm({
+  "src/domain/store/adapter.ts"() {
+    "use strict";
+    StoreAdapter = class {
+      constructor(options) {
+        this.options = options;
+      }
+    };
+  }
+});
+
+// src/domain/store/client.ts
+var StoreClient;
+var init_client = __esm({
+  "src/domain/store/client.ts"() {
+    "use strict";
+    StoreClient = class {
+    };
+  }
+});
+
+// src/domain/store/index.ts
+var init_store = __esm({
+  "src/domain/store/index.ts"() {
+    "use strict";
+    init_adapter();
+    init_client();
+  }
+});
+
+// src/domain/ui/types.ts
+var Modal;
+var init_types = __esm({
+  "src/domain/ui/types.ts"() {
+    "use strict";
+    Modal = class {
+      // eslint-disable-next-line @typescript-eslint/parameter-properties
+      constructor(options) {
+        this.options = options;
+      }
+      get isMounted() {
+        return this.instance !== void 0;
+      }
+      get data() {
+        if (typeof this.options === "object" && this.options && "link" in this.options) {
+          return this.options.link;
+        }
+        if (typeof this.options === "object" && this.options && "otpCode" in this.options) {
+          return this.options.otpCode;
+        }
+        throw new Error("Invalid options");
+      }
+      set data(data) {
+        if (typeof this.options === "object" && this.options && "link" in this.options) {
+          this.options.link = data;
+        }
+        if (typeof this.options === "object" && this.options && "otpCode" in this.options) {
+          this.options.otpCode = data;
+        }
+      }
+    };
+  }
+});
+
+// src/domain/ui/index.ts
+var init_ui = __esm({
+  "src/domain/ui/index.ts"() {
+    "use strict";
+    init_types();
+  }
+});
+
+// src/domain/utils/index.ts
+function getVersion() {
+  return "0.0.0";
+}
+var init_utils = __esm({
+  "src/domain/utils/index.ts"() {
+    "use strict";
+  }
+});
+
+// src/domain/index.ts
+var init_domain = __esm({
+  "src/domain/index.ts"() {
+    "use strict";
+    init_errors();
+    init_events();
+    init_logger();
+    init_multichain();
+    init_platform();
+    init_store();
+    init_ui();
+    init_utils();
+  }
+});
+
+// src/ui/qr.ts
+function preloadQR() {
+  return __async(this, null, function* () {
+    if (encodeQRImpl) {
+      return;
+    }
+    const mod = yield import("@paulmillr/qr");
+    encodeQRImpl = mod.default;
+  });
+}
+function encodeQRSync(input) {
+  if (!encodeQRImpl) {
+    throw new Error("QR module not preloaded. Call preloadQR() first.");
+  }
+  return encodeQRImpl(input, "ascii");
+}
+var encodeQRImpl;
+var init_qr = __esm({
+  "src/ui/qr.ts"() {
+    "use strict";
+    encodeQRImpl = null;
+  }
+});
+
+// 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;
+  } else {
+    return remainingSeconds % 60 === 0;
+  }
+}
+var init_utils2 = __esm({
+  "src/ui/modals/base/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/ui/modals/base/AbstractInstallModal.ts
+var logger3, AbstractInstallModal;
+var init_AbstractInstallModal = __esm({
+  "src/ui/modals/base/AbstractInstallModal.ts"() {
+    "use strict";
+    init_domain();
+    init_utils2();
+    logger3 = createLogger("metamask-sdk:ui");
+    AbstractInstallModal = class extends Modal {
+      constructor() {
+        super(...arguments);
+        this.expirationInterval = null;
+        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;
+        }
+      }
+      updateExpiresIn(expiresIn) {
+        if (expiresIn >= 0 && this.instance) {
+          this.instance.expiresIn = expiresIn;
+        }
+      }
+      startExpirationCheck(connectionRequest) {
+        this.stopExpirationCheck();
+        let currentConnectionRequest = connectionRequest;
+        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) && this.lastLoggedCountdown !== remainingSeconds) {
+            const formattedTime = formatRemainingTime(remainingMs);
+            logger3(
+              `[UI: InstallModal-nodejs()] QR code expires in: ${formattedTime} (${remainingSeconds}s)`
+            );
+            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
+              );
+              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}`
+              );
+            }
+          } else {
+            const generateQRCode = yield this.options.generateQRCode(
+              currentConnectionRequest
+            );
+            this.renderQRCode(generateQRCode, currentConnectionRequest);
+          }
+        }), 1e3);
+      }
+      stopExpirationCheck() {
+        if (this.expirationInterval) {
+          clearInterval(this.expirationInterval);
+          this.expirationInterval = null;
+          logger3(
+            "[UI: InstallModal-nodejs()] \u{1F6D1} Stopped QR code expiration checking"
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/ui/modals/node/install.ts
+var logger4, InstallModal;
+var init_install = __esm({
+  "src/ui/modals/node/install.ts"() {
+    "use strict";
+    init_domain();
+    init_qr();
+    init_AbstractInstallModal();
+    init_utils2();
+    logger4 = createLogger("metamask-sdk:ui");
+    InstallModal = class extends AbstractInstallModal {
+      displayQRWithCountdown(qrCodeLink, expiresInMs) {
+        const isExpired = expiresInMs <= 0;
+        const formattedTime = formatRemainingTime(expiresInMs);
+        const qrCode = encodeQRSync(qrCodeLink);
+        console.clear();
+        console.log(qrCode);
+        if (isExpired) {
+          console.log("EXPIRED - Generating new QR code...");
+        } else {
+          console.log(`EXPIRES IN: ${formattedTime}`);
+        }
+      }
+      renderQRCode(link, connectionRequest) {
+        const { sessionRequest } = connectionRequest;
+        const expiresIn = sessionRequest.expiresAt - Date.now();
+        const expiresInSeconds = Math.floor(expiresIn / 1e3);
+        const shouldLog = shouldLogCountdown(expiresInSeconds);
+        const formattedTime = formatRemainingTime(expiresIn);
+        this.startExpirationCheck(connectionRequest);
+        this.displayQRWithCountdown(link, expiresIn);
+        if (shouldLog) {
+          logger4(
+            `[UI: InstallModal-nodejs()] QR code expires in: ${formattedTime} (${expiresIn}ms)`
+          );
+        }
+      }
+      mount() {
+        if (!this.link) {
+          throw new Error("Session request is required");
+        }
+        const { link, connectionRequest } = this;
+        this.renderQRCode(link, connectionRequest);
+      }
+      unmount() {
+        console.clear();
+        this.stopExpirationCheck();
+      }
+    };
+  }
+});
+
+// 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/node/otp.ts
+var OTPCodeModal;
+var init_otp = __esm({
+  "src/ui/modals/node/otp.ts"() {
+    "use strict";
+    init_AbstractOTPModal();
+    OTPCodeModal = class extends AbstractOTPCodeModal {
+      mount() {
+      }
+      unmount() {
+      }
+    };
+  }
+});
+
+// src/ui/modals/node/index.ts
+var node_exports = {};
+__export(node_exports, {
+  InstallModal: () => InstallModal,
+  OTPCodeModal: () => OTPCodeModal
+});
+var init_node = __esm({
+  "src/ui/modals/node/index.ts"() {
+    "use strict";
+    init_install();
+    init_otp();
+  }
+});
+
+// src/store/adapters/node.ts
+var node_exports2 = {};
+__export(node_exports2, {
+  StoreAdapterNode: () => StoreAdapterNode
+});
+var StoreAdapterNode;
+var init_node2 = __esm({
+  "src/store/adapters/node.ts"() {
+    "use strict";
+    init_domain();
+    StoreAdapterNode = class extends StoreAdapter {
+      constructor() {
+        super(...arguments);
+        this.platform = "node";
+        this.storage = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        return __async(this, null, function* () {
+          var _a;
+          return (_a = this.storage.get(key)) != null ? _a : null;
+        });
+      }
+      set(key, value) {
+        return __async(this, null, function* () {
+          this.storage.set(key, value);
+        });
+      }
+      delete(key) {
+        return __async(this, null, function* () {
+          this.storage.delete(key);
+        });
+      }
+    };
+  }
+});
+
+// src/multichain/index.ts
+import { analytics } 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_logger();
+init_multichain();
+init_platform();
+
+// src/multichain/rpc/requestRouter.ts
+init_domain();
+
+// src/multichain/utils/index.ts
+init_domain();
+import { deflate } from "pako";
+import {
+  parseCaipAccountId,
+  parseCaipChainId
+} from "@metamask/utils";
+function base64Encode(str) {
+  if (typeof btoa !== "undefined") {
+    return btoa(str);
+  } else if (typeof Buffer !== "undefined") {
+    return Buffer.from(str).toString("base64");
+  }
+  throw new Error("No base64 encoding method available");
+}
+function compressString(str) {
+  const compressed = deflate(str);
+  const binaryString = String.fromCharCode.apply(null, Array.from(compressed));
+  return base64Encode(binaryString);
+}
+function getDappId(dapp) {
+  var _a, _b;
+  if (typeof window === "undefined" || typeof window.location === "undefined") {
+    return (_b = (_a = dapp == null ? void 0 : dapp.name) != null ? _a : dapp == null ? void 0 : dapp.url) != null ? _b : "N/A";
+  }
+  return window.location.hostname;
+}
+function openDeeplink(options, deeplink, universalLink) {
+  const { mobile } = options;
+  const useDeeplink = mobile && mobile.useDeeplink !== void 0 ? mobile.useDeeplink : true;
+  if (useDeeplink) {
+    if (typeof window !== "undefined") {
+      window.location.href = deeplink;
+    }
+  } else if (typeof document !== "undefined") {
+    const link = document.createElement("a");
+    link.href = universalLink;
+    link.target = "_self";
+    link.rel = "noreferrer noopener";
+    link.click();
+  }
+}
+function getOptionalScopes(scopes) {
+  return scopes.reduce(
+    (prev, scope) => __spreadProps(__spreadValues({}, prev), {
+      [scope]: {
+        methods: [],
+        notifications: [],
+        accounts: []
+      }
+    }),
+    {}
+  );
+}
+var extractFavicon = () => {
+  var _a;
+  if (typeof document === "undefined") {
+    return void 0;
+  }
+  let favicon;
+  const nodeList = document.getElementsByTagName("link");
+  for (let i = 0; i < nodeList.length; i++) {
+    if (nodeList[i].getAttribute("rel") === "icon" || nodeList[i].getAttribute("rel") === "shortcut icon") {
+      favicon = (_a = nodeList[i].getAttribute("href")) != null ? _a : void 0;
+    }
+  }
+  return favicon;
+};
+function setupInfuraProvider(options) {
+  var _a, _b;
+  const infuraAPIKey = (_a = options.api) == null ? void 0 : _a.infuraAPIKey;
+  if (!infuraAPIKey) {
+    return options;
+  }
+  const urlsWithToken = getInfuraRpcUrls(infuraAPIKey);
+  if ((_b = options.api) == null ? void 0 : _b.readonlyRPCMap) {
+    options.api.readonlyRPCMap = __spreadValues(__spreadValues({}, options.api.readonlyRPCMap), urlsWithToken);
+  } else if (options.api) {
+    options.api.readonlyRPCMap = urlsWithToken;
+  }
+  return options;
+}
+function setupDappMetadata(options) {
+  var _a;
+  const platform = getPlatformType();
+  const isBrowser = platform === "web-desktop" /* DesktopWeb */ || platform === "web-mobile" /* MobileWeb */ || platform === "in-app-browser" /* MetaMaskMobileWebview */;
+  if (!((_a = options.dapp) == null ? void 0 : _a.url)) {
+    if (isBrowser) {
+      options.dapp = __spreadProps(__spreadValues({}, options.dapp), {
+        url: `${window.location.protocol}//${window.location.host}`
+      });
+    } else {
+      throw new Error("You must provide dapp url");
+    }
+  }
+  const BASE_64_ICON_MAX_LENGTH = 163400;
+  const urlPattern = /^(http|https):\/\/[^\s]*$/;
+  if (options.dapp) {
+    if ("iconUrl" in options.dapp) {
+      if (options.dapp.iconUrl && !urlPattern.test(options.dapp.iconUrl)) {
+        console.warn(
+          "Invalid dappMetadata.iconUrl: URL must start with http:// or https://"
+        );
+        options.dapp.iconUrl = void 0;
+      }
+    }
+    if ("base64Icon" in options.dapp) {
+      if (options.dapp.base64Icon && options.dapp.base64Icon.length > BASE_64_ICON_MAX_LENGTH) {
+        console.warn(
+          "Invalid dappMetadata.base64Icon: Base64-encoded icon string length must be less than 163400 characters"
+        );
+        options.dapp.base64Icon = void 0;
+      }
+    }
+    if (options.dapp.url && !urlPattern.test(options.dapp.url)) {
+      console.warn(
+        "Invalid dappMetadata.url: URL must start with http:// or https://"
+      );
+    }
+    const favicon = extractFavicon();
+    if (favicon && !("iconUrl" in options.dapp) && !("base64Icon" in options.dapp)) {
+      const faviconUrl = `${window.location.protocol}//${window.location.host}${favicon}`;
+      options.dapp.iconUrl = faviconUrl;
+    }
+  }
+  return options;
+}
+function isSameScopesAndAccounts(currentScopes, proposedScopes, walletSession, proposedCaipAccountIds) {
+  const isSameScopes = currentScopes.every((scope) => proposedScopes.includes(scope)) && proposedScopes.every((scope) => currentScopes.includes(scope));
+  if (!isSameScopes) {
+    return false;
+  }
+  const existingAccountIds = Object.values(
+    walletSession.sessionScopes
+  ).filter(({ accounts }) => Boolean(accounts)).flatMap(({ accounts }) => accounts != null ? accounts : []);
+  const allProposedAccountsIncluded = proposedCaipAccountIds.every(
+    (proposedAccountId) => existingAccountIds.includes(proposedAccountId)
+  );
+  return allProposedAccountsIncluded;
+}
+function getValidAccounts(caipAccountIds) {
+  return caipAccountIds.reduce(
+    (caipAccounts, caipAccountId) => {
+      try {
+        return [...caipAccounts, parseCaipAccountId(caipAccountId)];
+      } catch (err) {
+        const stringifiedAccountId = JSON.stringify(caipAccountId);
+        console.error(`Invalid CAIP account ID: ${stringifiedAccountId}`, err);
+        return caipAccounts;
+      }
+    },
+    []
+  );
+}
+function addValidAccounts(optionalScopes, validAccounts) {
+  var _a;
+  if (!optionalScopes || !(validAccounts == null ? void 0 : validAccounts.length)) {
+    return optionalScopes;
+  }
+  const result = Object.fromEntries(
+    Object.entries(optionalScopes).map(([scope, scopeData]) => {
+      var _a2, _b, _c;
+      return [
+        scope,
+        {
+          methods: [...(_a2 = scopeData == null ? void 0 : scopeData.methods) != null ? _a2 : []],
+          notifications: [...(_b = scopeData == null ? void 0 : scopeData.notifications) != null ? _b : []],
+          accounts: [...(_c = scopeData == null ? void 0 : scopeData.accounts) != null ? _c : []]
+        }
+      ];
+    })
+  );
+  const accountsByChain = /* @__PURE__ */ new Map();
+  for (const account of validAccounts) {
+    const chainKey = `${account.chain.namespace}:${account.chain.reference}`;
+    const accountId = `${account.chainId}:${account.address}`;
+    if (!accountsByChain.has(chainKey)) {
+      accountsByChain.set(chainKey, []);
+    }
+    (_a = accountsByChain.get(chainKey)) == null ? void 0 : _a.push(accountId);
+  }
+  for (const [scopeKey, scopeData] of Object.entries(result)) {
+    if (!(scopeData == null ? void 0 : scopeData.accounts)) {
+      continue;
+    }
+    try {
+      const scope = scopeKey;
+      const scopeDetails = parseCaipChainId(scope);
+      const chainKey = `${scopeDetails.namespace}:${scopeDetails.reference}`;
+      const matchingAccounts = accountsByChain.get(chainKey);
+      if (matchingAccounts) {
+        const existingAccounts = new Set(scopeData.accounts);
+        const newAccounts = matchingAccounts.filter(
+          (account) => !existingAccounts.has(account)
+        );
+        scopeData.accounts.push(...newAccounts);
+      }
+    } catch (error) {
+      console.error(`Invalid scope format: ${scopeKey}`, error);
+    }
+  }
+  return result;
+}
+
+// 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;
+  }
+  /**
+   * Routes the request to a configured 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.fetch(rpcEndpoint, body, "POST", this.getHeaders(rpcEndpoint));
+      const response = yield this.parseResponse(rpcRequest);
+      return response;
+    });
+  }
+  getRpcEndpoint(scope) {
+    var _a, _b, _c, _d, _e;
+    let infuraAPIKey = (_b = (_a = this.config) == null ? void 0 : _a.api) == null ? void 0 : _b.infuraAPIKey;
+    let readonlyRPCMap = (_e = (_d = (_c = this.config) == null ? void 0 : _c.api) == null ? void 0 : _d.readonlyRPCMap) != null ? _e : {};
+    if (infuraAPIKey) {
+      const urlsWithToken = getInfuraRpcUrls(infuraAPIKey);
+      if (readonlyRPCMap) {
+        readonlyRPCMap = __spreadValues(__spreadValues({}, urlsWithToken), readonlyRPCMap);
+      } else {
+        readonlyRPCMap = urlsWithToken;
+      }
+    }
+    const rpcEndpoint = readonlyRPCMap[scope];
+    if (!rpcEndpoint) {
+      throw new MissingRpcEndpointErr(`No RPC endpoint found for scope ${scope}`);
+    }
+    return rpcEndpoint;
+  }
+  fetch(endpoint, body, method, headers) {
+    return __async(this, null, function* () {
+      try {
+        const response = yield fetch(endpoint, {
+          method,
+          headers,
+          body
+        });
+        if (!response.ok) {
+          throw new RPCHttpErr(endpoint, method, response.status);
+        }
+        return response;
+      } catch (error) {
+        if (error instanceof RPCHttpErr) {
+          throw error;
+        }
+        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);
+      }
+    });
+  }
+  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/rpc/requestRouter.ts
+var RequestRouter = class {
+  constructor(transport, rpcClient, config) {
+    this.transport = transport;
+    this.rpcClient = rpcClient;
+    this.config = config;
+  }
+  /**
+   * 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.
+   */
+  invokeMethod(options) {
+    return __async(this, null, function* () {
+      const method = options.request.method;
+      if (RPC_HANDLED_METHODS.has(method)) {
+        return this.handleWithRpcNode(options);
+      }
+      if (SDK_HANDLED_METHODS.has(method)) {
+        return this.handleWithSdkState(options);
+      }
+      return this.handleWithWallet(options);
+    });
+  }
+  /**
+   * Forwards the request directly to the wallet via the transport.
+   */
+  handleWithWallet(options) {
+    return __async(this, null, function* () {
+      try {
+        const request = this.transport.request({
+          method: "wallet_invokeMethod",
+          params: options
+        });
+        const { ui, mobile } = this.config;
+        const { preferDesktop = false } = ui != null ? ui : {};
+        const secure = isSecure();
+        const shouldOpenDeeplink = secure && !preferDesktop;
+        if (shouldOpenDeeplink) {
+          setTimeout(() => {
+            if (mobile == null ? void 0 : mobile.preferredOpenLink) {
+              mobile.preferredOpenLink(METAMASK_DEEPLINK_BASE, "_self");
+            } else {
+              openDeeplink(this.config, METAMASK_DEEPLINK_BASE, METAMASK_CONNECT_BASE_URL);
+            }
+          }, 10);
+        }
+        const response = yield request;
+        if (response.error) {
+          throw new RPCInvokeMethodErr(`RPC Request failed with code ${response.error.code}: ${response.error.message}`);
+        }
+        return response.result;
+      } catch (error) {
+        throw new RPCInvokeMethodErr(error.message);
+      }
+    });
+  }
+  /**
+   * Routes the request to a configured RPC node.
+   */
+  handleWithRpcNode(options) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.rpcClient.request(options);
+      } catch (error) {
+        if (error instanceof MissingRpcEndpointErr) {
+          return this.handleWithWallet(options);
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Responds directly from the SDK's session state.
+   */
+  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);
+    });
+  }
+};
+
+// src/multichain/transports/default/index.ts
+import {
+  getDefaultTransport
+} from "@metamask/multichain-api-client";
+var DEFAULT_REQUEST_TIMEOUT = 60 * 1e3;
+var _notificationCallbacks, _transport, _defaultRequestOptions, _DefaultTransport_instances, notifyCallbacks_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
+    });
+  }
+  connect(options) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g;
+      yield __privateGet(this, _transport).connect();
+      const sessionRequest = yield this.request(
+        { method: "wallet_getSession" },
+        __privateGet(this, _defaultRequestOptions)
+      );
+      if (sessionRequest.error) {
+        throw new Error(sessionRequest.error.message);
+      }
+      let walletSession = sessionRequest.result;
+      if (walletSession && options) {
+        const currentScopes = Object.keys(
+          (_a = walletSession == null ? void 0 : walletSession.sessionScopes) != null ? _a : {}
+        );
+        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 (!hasSameScopesAndAccounts) {
+          yield this.request(
+            { method: "wallet_revokeSession", params: walletSession },
+            __privateGet(this, _defaultRequestOptions)
+          );
+          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 },
+            __privateGet(this, _defaultRequestOptions)
+          );
+          if (response.error) {
+            throw 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 },
+          __privateGet(this, _defaultRequestOptions)
+        );
+        if (response.error) {
+          throw new Error(response.error.message);
+        }
+        walletSession = response.result;
+      }
+      __privateMethod(this, _DefaultTransport_instances, notifyCallbacks_fn).call(this, {
+        method: "wallet_sessionChanged",
+        params: walletSession
+      });
+    });
+  }
+  disconnect() {
+    return __async(this, null, function* () {
+      __privateGet(this, _notificationCallbacks).clear();
+      return __privateGet(this, _transport).disconnect();
+    });
+  }
+  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);
+    };
+  }
+};
+_notificationCallbacks = new WeakMap();
+_transport = new WeakMap();
+_defaultRequestOptions = new WeakMap();
+_DefaultTransport_instances = new WeakSet();
+notifyCallbacks_fn = function(data) {
+  for (const cb of __privateGet(this, _notificationCallbacks)) {
+    try {
+      cb(data);
+    } catch (err) {
+      console.log("[WindowPostMessageTransport] notifyCallbacks error:", err);
+    }
+  }
+};
+
+// src/multichain/transports/mwp/index.ts
+init_domain();
+import { SessionStore } from "@metamask/mobile-wallet-protocol-core";
+import {
+  TransportTimeoutError
+} from "@metamask/multichain-api-client";
+var DEFAULT_REQUEST_TIMEOUT2 = 60 * 1e3;
+var CONNECTION_GRACE_PERIOD = 60 * 1e3;
+var DEFAULT_CONNECTION_TIMEOUT = DEFAULT_REQUEST_TIMEOUT2 + CONNECTION_GRACE_PERIOD;
+var SESSION_STORE_KEY = "cache_wallet_getSession";
+var CACHED_METHOD_LIST = [
+  "wallet_getSession",
+  "wallet_createSession",
+  "wallet_sessionChanged"
+];
+var CACHED_RESET_METHOD_LIST = ["wallet_revokeSession"];
+var logger = createLogger("metamask-sdk:transport");
+var MWPTransport = class {
+  constructor(dappClient, kvstore, options = {
+    requestTimeout: DEFAULT_REQUEST_TIMEOUT2,
+    connectionTimeout: DEFAULT_CONNECTION_TIMEOUT
+  }) {
+    this.dappClient = dappClient;
+    this.kvstore = kvstore;
+    this.options = options;
+    this.__reqId = 0;
+    this.__pendingRequests = /* @__PURE__ */ new Map();
+    this.notificationCallbacks = /* @__PURE__ */ new Set();
+    this.dappClient.on("message", this.handleMessage.bind(this));
+    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;
+  }
+  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);
+    }
+  }
+  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) {
+            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
+            });
+            clearTimeout(request.timeout);
+            this.notifyCallbacks(notification);
+            request.resolve(requestWithName);
+            this.pendingRequests.delete(messagePayload.id);
+          }
+        } else {
+          this.notifyCallbacks(message.data);
+        }
+      }
+    }
+  }
+  onResumeSuccess(resumeResolve, resumeReject, options) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g;
+      try {
+        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(
+            (_a = walletSession == null ? void 0 : walletSession.sessionScopes) != null ? _a : {}
+          );
+          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 (!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;
+        }
+        this.notifyCallbacks({
+          method: "wallet_sessionChanged",
+          params: walletSession
+        });
+        return resumeResolve();
+      } catch (err) {
+        return resumeReject(err);
+      }
+    });
+  }
+  connect(options) {
+    return __async(this, null, function* () {
+      const { dappClient, kvstore } = this;
+      const sessionStore = new SessionStore(kvstore);
+      let session;
+      try {
+        const [activeSession] = yield sessionStore.list();
+        if (activeSession) {
+          logger("active session found", activeSession);
+          session = activeSession;
+        }
+      } catch (e) {
+      }
+      let timeout;
+      const connectionPromise = new Promise((resolve, reject) => {
+        let connection;
+        if (session) {
+          connection = new Promise((resumeResolve, resumeReject) => {
+            var _a;
+            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((_a = session == null ? void 0 : session.id) != null ? _a : "");
+            }
+          });
+        } else {
+          connection = new Promise(
+            (resolveConnection, rejectConnection) => {
+              var _a, _b;
+              const optionalScopes = addValidAccounts(
+                getOptionalScopes((_a = options == null ? void 0 : options.scopes) != null ? _a : []),
+                getValidAccounts((_b = options == null ? void 0 : options.caipAccountIds) != null ? _b : [])
+              );
+              const sessionRequest = {
+                optionalScopes
+              };
+              const request = {
+                jsonrpc: "2.0",
+                id: `${this.__reqId++}`,
+                method: "wallet_createSession",
+                params: sessionRequest
+              };
+              this.dappClient.on("message", (message) => __async(this, null, function* () {
+                if (typeof message === "object" && message !== null) {
+                  if ("data" in message) {
+                    const messagePayload = message.data;
+                    if (messagePayload.method === "wallet_createSession" || messagePayload.method === "wallet_sessionChanged") {
+                      if (messagePayload.error) {
+                        return rejectConnection(messagePayload.error);
+                      }
+                      this.notifyCallbacks(message.data);
+                      yield this.storeWalletSession(
+                        request,
+                        messagePayload
+                      );
+                      return resolveConnection();
+                    }
+                  }
+                }
+              }));
+              dappClient.connect({ mode: "trusted", initialPayload: request }).catch(rejectConnection);
+            }
+          );
+        }
+        timeout = setTimeout(() => {
+          reject(new TransportTimeoutError());
+        }, this.options.connectionTimeout);
+        connection.then(resolve).catch(reject);
+      });
+      return connectionPromise.finally(() => {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      });
+    });
+  }
+  /**
+   * Disconnects from the Mobile Wallet Protocol
+   *
+   * @returns Nothing
+   */
+  disconnect() {
+    return __async(this, null, function* () {
+      if (typeof window !== "undefined" && typeof window.removeEventListener !== "undefined" && this.windowFocusHandler) {
+        window.removeEventListener("focus", this.windowFocusHandler);
+        this.windowFocusHandler = void 0;
+      }
+      return this.dappClient.disconnect();
+    });
+  }
+  /**
+   * Checks if the transport is connected
+   *
+   * @returns True if transport is connected, false otherwise
+   */
+  isConnected() {
+    return this.dappClient.state === "CONNECTED";
+  }
+  fetchCachedWalletSession(request) {
+    return __async(this, null, function* () {
+      var _a;
+      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: (_a = walletSession.params) != null ? _a : walletSession.result,
+            method: request.method
+          };
+        }
+      }
+    });
+  }
+  storeWalletSession(request, response) {
+    return __async(this, null, function* () {
+      if (CACHED_METHOD_LIST.includes(request.method)) {
+        yield this.kvstore.set(SESSION_STORE_KEY, JSON.stringify(response));
+      } else if (CACHED_RESET_METHOD_LIST.includes(request.method)) {
+        yield this.kvstore.delete(SESSION_STORE_KEY);
+      }
+    });
+  }
+  request(payload, options) {
+    return __async(this, null, function* () {
+      const request = __spreadValues({
+        jsonrpc: "2.0",
+        id: `${this.__reqId++}`
+      }, payload);
+      const cachedWalletSession = yield this.fetchCachedWalletSession(request);
+      if (cachedWalletSession) {
+        this.notifyCallbacks(cachedWalletSession);
+        return cachedWalletSession;
+      }
+      return new Promise((resolve, reject) => {
+        var _a;
+        const timeout = setTimeout(() => {
+          this.rejectRequest(request.id, new TransportTimeoutError());
+        }, (_a = options == null ? void 0 : options.timeout) != null ? _a : this.options.requestTimeout);
+        this.pendingRequests.set(request.id, {
+          request,
+          method: request.method,
+          resolve: (response) => __async(this, null, function* () {
+            if (CACHED_METHOD_LIST.includes(request.method)) {
+              yield this.storeWalletSession(request, response);
+            }
+            return resolve(response);
+          }),
+          reject,
+          timeout
+        });
+        this.dappClient.sendRequest(request).catch(reject);
+      });
+    });
+  }
+  onNotification(callback) {
+    this.notificationCallbacks.add(callback);
+    return () => {
+      this.notificationCallbacks.delete(callback);
+    };
+  }
+};
+
+// src/multichain/transports/mwp/KeyManager.ts
+import { decrypt, encrypt, PrivateKey } 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");
+    });
+  }
+};
+var keymanager = new KeyManager();
+
+// src/multichain/index.ts
+var logger2 = createLogger("metamask-sdk:core");
+var MultichainSDK = class _MultichainSDK extends MultichainCore {
+  constructor(options) {
+    var _a, _b, _c, _d, _e, _f;
+    const withInfuraRPCMethods = setupInfuraProvider(options);
+    const withDappMetadata = setupDappMetadata(withInfuraRPCMethods);
+    const allOptions = __spreadProps(__spreadValues({}, withDappMetadata), {
+      ui: __spreadProps(__spreadValues({}, withDappMetadata.ui), {
+        preferExtension: (_a = withDappMetadata.ui.preferExtension) != null ? _a : true,
+        preferDesktop: (_b = withDappMetadata.ui.preferDesktop) != null ? _b : false,
+        headless: (_c = withDappMetadata.ui.headless) != null ? _c : false
+      }),
+      analytics: __spreadProps(__spreadValues({}, (_d = options.analytics) != null ? _d : {}), {
+        enabled: (_f = (_e = options.analytics) == null ? void 0 : _e.enabled) != null ? _f : true,
+        integrationType: "unknown"
+      })
+    });
+    super(allOptions);
+    this.__provider = void 0;
+    this.__transport = void 0;
+    this.__dappClient = void 0;
+    this.__state = "pending";
+  }
+  get state() {
+    return this.__state;
+  }
+  set state(value) {
+    var _a, _b;
+    this.__state = value;
+    (_b = (_a = this.options.transport) == null ? void 0 : _a.onNotification) == null ? void 0 : _b.call(_a, {
+      method: "stateChanged",
+      params: value
+    });
+  }
+  get provider() {
+    if (!this.__provider) {
+      throw new Error("Provider not initialized, establish connection first");
+    }
+    return this.__provider;
+  }
+  get transport() {
+    if (!this.__transport) {
+      throw new Error("Transport not initialized, establish connection first");
+    }
+    return this.__transport;
+  }
+  get dappClient() {
+    if (!this.__dappClient) {
+      throw new Error("DappClient not initialized, establish connection first");
+    }
+    return this.__dappClient;
+  }
+  get storage() {
+    return this.options.storage;
+  }
+  get sdkInfo() {
+    var _a;
+    return `Sdk/Javascript SdkVersion/${getVersion()} Platform/${getPlatformType()} dApp/${(_a = this.options.dapp.url) != null ? _a : this.options.dapp.name} dAppTitle/${this.options.dapp.name}`;
+  }
+  static create(options) {
+    return __async(this, null, function* () {
+      const instance = new _MultichainSDK(options);
+      const isEnabled2 = yield isEnabled(
+        "metamask-sdk:core",
+        instance.options.storage
+      );
+      if (isEnabled2) {
+        enableDebug("metamask-sdk:core");
+      }
+      yield instance.init();
+      return instance;
+    });
+  }
+  setupAnalytics() {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (!((_a = this.options.analytics) == null ? void 0 : _a.enabled)) {
+        return;
+      }
+      const platform = getPlatformType();
+      const isBrowser = platform === "in-app-browser" /* MetaMaskMobileWebview */ || platform === "web-desktop" /* DesktopWeb */ || platform === "web-mobile" /* MobileWeb */;
+      const isReactNative2 = platform === "react-native" /* ReactNative */;
+      if (!isBrowser && !isReactNative2) {
+        return;
+      }
+      const version = getVersion();
+      const dappId = getDappId(this.options.dapp);
+      const anonId = yield this.storage.getAnonId();
+      const { integrationType } = (_b = this.options.analytics) != null ? _b : {
+        integrationType: ""
+      };
+      analytics.setGlobalProperty("sdk_version", version);
+      analytics.setGlobalProperty("dapp_id", dappId);
+      analytics.setGlobalProperty("anon_id", anonId);
+      analytics.setGlobalProperty("platform", platform);
+      analytics.setGlobalProperty("integration_type", integrationType);
+      analytics.enable();
+    });
+  }
+  onTransportNotification(payload) {
+    return __async(this, null, function* () {
+      var _a;
+      if (typeof payload === "object" && payload !== null && "method" in payload) {
+        this.emit(payload.method, (_a = payload.params) != null ? _a : payload.result);
+      }
+    });
+  }
+  getStoredTransport() {
+    return __async(this, null, function* () {
+      const { ui } = this.options;
+      const { preferExtension = true } = ui;
+      const transportType = yield this.storage.getTransport();
+      const hasExtensionInstalled = yield hasExtension();
+      if (transportType) {
+        if (transportType === "browser" /* Browser */) {
+          if (hasExtensionInstalled && preferExtension) {
+            const apiTransport = new DefaultTransport();
+            this.__transport = apiTransport;
+            this.listener = apiTransport.onNotification(
+              this.onTransportNotification.bind(this)
+            );
+            return apiTransport;
+          }
+        } else if (transportType === "mwp" /* MPW */) {
+          const { adapter: kvstore } = this.options.storage;
+          const dappClient = yield this.createDappClient();
+          const apiTransport = new MWPTransport(dappClient, kvstore);
+          this.__dappClient = dappClient;
+          this.__transport = apiTransport;
+          this.listener = apiTransport.onNotification(
+            this.onTransportNotification.bind(this)
+          );
+          return apiTransport;
+        }
+        yield this.storage.removeTransport();
+      }
+      return void 0;
+    });
+  }
+  setupTransport() {
+    return __async(this, null, function* () {
+      const transport = yield this.getStoredTransport();
+      if (transport) {
+        if (!this.transport.isConnected()) {
+          this.state = "connecting";
+          yield this.transport.connect();
+        }
+        this.state = "connected";
+        if (this.transport instanceof MWPTransport) {
+          yield this.storage.setTransport("mwp" /* MPW */);
+        } else {
+          yield this.storage.setTransport("browser" /* Browser */);
+        }
+      } else {
+        this.state = "loaded";
+      }
+    });
+  }
+  init() {
+    return __async(this, null, function* () {
+      var _a;
+      try {
+        if (typeof window !== "undefined" && ((_a = window.mmsdk) == null ? void 0 : _a.isInitialized)) {
+          logger2("MetaMaskSDK: init already initialized");
+        } else {
+          yield this.setupAnalytics();
+          yield this.setupTransport();
+          analytics.track("sdk_initialized", {});
+          if (typeof window !== "undefined") {
+            window.mmsdk = this;
+          }
+        }
+      } catch (error) {
+        yield this.storage.removeTransport();
+        this.state = "pending";
+        logger2("MetaMaskSDK error during initialization", error);
+      }
+    });
+  }
+  createDappClient() {
+    return __async(this, null, function* () {
+      const { adapter: kvstore } = this.options.storage;
+      const sessionstore = new SessionStore2(kvstore);
+      const websocket = (
+        // eslint-disable-next-line no-negated-condition
+        typeof window !== "undefined" ? WebSocket : (yield import("ws")).WebSocket
+      );
+      const transport = yield WebSocketTransport.create({
+        url: MWP_RELAY_URL,
+        kvstore,
+        websocket
+      });
+      const dappClient = new DappClient({ transport, sessionstore, keymanager });
+      return dappClient;
+    });
+  }
+  setupMWP() {
+    return __async(this, null, function* () {
+      if (this.__transport instanceof MWPTransport) {
+        return;
+      }
+      const { adapter: kvstore } = this.options.storage;
+      const dappClient = yield this.createDappClient();
+      this.__dappClient = dappClient;
+      const apiTransport = new MWPTransport(dappClient, kvstore);
+      this.__transport = apiTransport;
+      this.listener = this.transport.onNotification(
+        this.onTransportNotification.bind(this)
+      );
+      yield this.storage.setTransport("mwp" /* MPW */);
+    });
+  }
+  onBeforeUnload() {
+    return __async(this, null, function* () {
+      var _a;
+      if ((_a = this.options.ui.factory.modal) == null ? void 0 : _a.isMounted) {
+        yield this.storage.removeTransport();
+      }
+    });
+  }
+  createBeforeUnloadListener() {
+    if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
+      window.addEventListener("beforeunload", this.onBeforeUnload.bind(this));
+    }
+    return () => {
+      if (typeof window !== "undefined" && typeof window.removeEventListener !== "undefined") {
+        window.removeEventListener(
+          "beforeunload",
+          this.onBeforeUnload.bind(this)
+        );
+      }
+    };
+  }
+  showInstallModal(desktopPreferred, scopes, caipAccountIds) {
+    return __async(this, null, function* () {
+      var _a;
+      (_a = this.__beforeUnloadListener) != null ? _a : this.__beforeUnloadListener = this.createBeforeUnloadListener();
+      return new Promise((resolve, reject) => {
+        this.options.ui.factory.renderInstallModal(
+          desktopPreferred,
+          () => __async(this, null, function* () {
+            if (this.dappClient.state === "CONNECTED" || this.dappClient.state === "CONNECTING") {
+              yield this.dappClient.disconnect();
+            }
+            return new Promise((resolveConnectionRequest) => {
+              this.dappClient.on(
+                "session_request",
+                (sessionRequest) => {
+                  resolveConnectionRequest({
+                    sessionRequest,
+                    metadata: {
+                      dapp: this.options.dapp,
+                      sdk: {
+                        version: getVersion(),
+                        platform: getPlatformType()
+                      }
+                    }
+                  });
+                }
+              );
+              this.transport.connect({ scopes, caipAccountIds }).then(() => {
+                var _a2;
+                this.options.ui.factory.unload();
+                (_a2 = this.options.ui.factory.modal) == null ? void 0 : _a2.unmount();
+                this.state = "connected";
+                return this.storage.setTransport("mwp" /* MPW */);
+              }).catch((error) => {
+                if (error instanceof ProtocolError) {
+                  if (error.code !== ErrorCode.REQUEST_EXPIRED) {
+                    this.state = "disconnected";
+                    reject(error);
+                  }
+                } else {
+                  this.state = "disconnected";
+                  reject(error);
+                }
+              });
+            });
+          }),
+          (error) => __async(this, null, function* () {
+            if (!error) {
+              yield this.storage.setTransport("mwp" /* MPW */);
+              resolve();
+            } else {
+              yield this.storage.removeTransport();
+              reject(error);
+            }
+          })
+        );
+      });
+    });
+  }
+  setupDefaultTransport() {
+    return __async(this, null, function* () {
+      this.state = "connecting";
+      yield this.storage.setTransport("browser" /* Browser */);
+      const transport = new DefaultTransport();
+      this.listener = transport.onNotification(
+        this.onTransportNotification.bind(this)
+      );
+      this.__transport = transport;
+      return transport;
+    });
+  }
+  deeplinkConnect(scopes, caipAccountIds) {
+    return __async(this, null, function* () {
+      return new Promise((resolve, reject) => __async(this, null, function* () {
+        this.dappClient.on("message", (payload) => {
+          var _a, _b, _c;
+          const data = payload.data;
+          if (typeof data === "object" && data !== null) {
+            if ("method" in data && data.method === "wallet_createSession") {
+              if (data.error) {
+                this.state = "loaded";
+                return reject(data.error);
+              }
+              const session = (_a = data.params) != null ? _a : data.result;
+              if (session) {
+                (_c = (_b = this.options.transport) == null ? void 0 : _b.onNotification) == null ? void 0 : _c.call(_b, payload.data);
+                this.emit("wallet_sessionChanged", session);
+              }
+            }
+          }
+        });
+        let timeout;
+        if (!this.transport.isConnected()) {
+          this.dappClient.once(
+            "session_request",
+            (sessionRequest) => {
+              var _a;
+              const connectionRequest = {
+                sessionRequest,
+                metadata: {
+                  dapp: this.options.dapp,
+                  sdk: { version: getVersion(), platform: getPlatformType() }
+                }
+              };
+              const deeplink = this.options.ui.factory.createDeeplink(connectionRequest);
+              const universalLink = this.options.ui.factory.createUniversalLink(connectionRequest);
+              if ((_a = this.options.mobile) == null ? void 0 : _a.preferredOpenLink) {
+                this.options.mobile.preferredOpenLink(deeplink, "_self");
+              } else {
+                openDeeplink(this.options, deeplink, universalLink);
+              }
+            }
+          );
+        } else {
+          timeout = setTimeout(() => {
+            var _a;
+            const deeplink = this.options.ui.factory.createDeeplink();
+            const universalLink = this.options.ui.factory.createUniversalLink();
+            if ((_a = this.options.mobile) == null ? void 0 : _a.preferredOpenLink) {
+              this.options.mobile.preferredOpenLink(deeplink, "_self");
+            } else {
+              openDeeplink(this.options, deeplink, universalLink);
+            }
+          }, 250);
+        }
+        this.transport.connect({ scopes, caipAccountIds }).then(resolve).catch((error) => {
+          this.storage.removeTransport();
+          reject(error);
+        }).finally(() => {
+          if (timeout) {
+            clearTimeout(timeout);
+          }
+        });
+      }));
+    });
+  }
+  handleConnection(promise) {
+    return __async(this, null, function* () {
+      this.state = "connecting";
+      return promise.then(() => {
+        this.state = "connected";
+      }).catch((error) => {
+        this.state = "disconnected";
+        return Promise.reject(error);
+      });
+    });
+  }
+  connect(scopes, caipAccountIds) {
+    return __async(this, null, function* () {
+      var _a;
+      const { ui } = this.options;
+      const platformType = getPlatformType();
+      const isWeb = platformType === "in-app-browser" /* MetaMaskMobileWebview */ || platformType === "web-desktop" /* DesktopWeb */;
+      const { preferExtension = true, preferDesktop = false } = ui;
+      const secure = isSecure();
+      const hasExtensionInstalled = yield hasExtension();
+      if (((_a = this.__transport) == null ? void 0 : _a.isConnected()) && !secure) {
+        return this.handleConnection(
+          this.__transport.connect({ scopes, caipAccountIds }).then(() => {
+            if (this.__transport instanceof MWPTransport) {
+              return this.storage.setTransport("mwp" /* MPW */);
+            } else {
+              return this.storage.setTransport("browser" /* Browser */);
+            }
+          })
+        );
+      }
+      if (isWeb && hasExtensionInstalled && preferExtension) {
+        const defaultTransport = yield this.setupDefaultTransport();
+        return this.handleConnection(
+          defaultTransport.connect({ scopes, caipAccountIds })
+        );
+      }
+      yield this.setupMWP();
+      const isDesktopPreferred = hasExtensionInstalled ? preferDesktop : !preferExtension || preferDesktop;
+      if (secure && !isDesktopPreferred) {
+        return this.handleConnection(
+          this.deeplinkConnect(scopes, caipAccountIds)
+        );
+      }
+      return this.handleConnection(
+        this.showInstallModal(isDesktopPreferred, scopes, caipAccountIds)
+      );
+    });
+  }
+  emit(event, args) {
+    var _a, _b;
+    (_b = (_a = this.options.transport) == null ? void 0 : _a.onNotification) == null ? void 0 : _b.call(_a, { method: event, params: args });
+    super.emit(event, args);
+  }
+  disconnect() {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      (_a = this.listener) == null ? void 0 : _a.call(this);
+      (_b = this.__beforeUnloadListener) == null ? void 0 : _b.call(this);
+      yield (_c = this.__transport) == null ? void 0 : _c.disconnect();
+      yield this.storage.removeTransport();
+      this.emit("wallet_sessionChanged", void 0);
+      this.emit("stateChanged", "disconnected");
+      this.listener = void 0;
+      this.__beforeUnloadListener = void 0;
+      this.__transport = void 0;
+      this.__provider = void 0;
+      this.__dappClient = void 0;
+    });
+  }
+  invokeMethod(request) {
+    return __async(this, null, function* () {
+      var _a;
+      const { sdkInfo, transport, options } = this;
+      (_a = this.__provider) != null ? _a : this.__provider = getMultichainClient({ transport });
+      const rpcClient = new RpcClient(options, sdkInfo);
+      const requestRouter = new RequestRouter(transport, rpcClient, options);
+      return requestRouter.invokeMethod(request);
+    });
+  }
+};
+
+// src/store/index.ts
+import * as uuid from "uuid";
+
+// src/domain/errors/storage.ts
+init_base();
+var _StorageGetErr = class _StorageGetErr extends BaseErr {
+  constructor(platform, key, reason) {
+    super(
+      `StorageErr${_StorageGetErr.code}: ${platform} storage get error in key: ${key} - ${reason}`,
+      _StorageGetErr.code
+    );
+    this.platform = platform;
+    this.key = key;
+    this.reason = reason;
+  }
+};
+_StorageGetErr.code = 60;
+var StorageGetErr = _StorageGetErr;
+var _StorageSetErr = class _StorageSetErr extends BaseErr {
+  constructor(platform, key, reason) {
+    super(
+      `StorageErr${_StorageSetErr.code}: ${platform} storage set error in key: ${key} - ${reason}`,
+      _StorageSetErr.code
+    );
+    this.platform = platform;
+    this.key = key;
+    this.reason = reason;
+  }
+};
+_StorageSetErr.code = 61;
+var StorageSetErr = _StorageSetErr;
+var _StorageDeleteErr = class _StorageDeleteErr extends BaseErr {
+  constructor(platform, key, reason) {
+    super(
+      `StorageErr${_StorageDeleteErr.code}: ${platform} storage delete error in key: ${key} - ${reason}`,
+      _StorageDeleteErr.code
+    );
+    this.platform = platform;
+    this.key = key;
+    this.reason = reason;
+  }
+};
+_StorageDeleteErr.code = 62;
+var StorageDeleteErr = _StorageDeleteErr;
+
+// src/store/index.ts
+init_multichain();
+init_client();
+var Store = class extends StoreClient {
+  constructor(adapter) {
+    super();
+    this.adapter = adapter;
+  }
+  getTransport() {
+    return __async(this, null, function* () {
+      try {
+        const transport = yield this.adapter.get("multichain-transport");
+        if (!transport) {
+          return null;
+        }
+        return getTransportType(transport);
+      } catch (err) {
+        throw new StorageGetErr(
+          this.adapter.platform,
+          "multichain-transport",
+          err.message
+        );
+      }
+    });
+  }
+  setTransport(transport) {
+    return __async(this, null, function* () {
+      try {
+        yield this.adapter.set("multichain-transport", transport);
+      } catch (err) {
+        throw new StorageSetErr(
+          this.adapter.platform,
+          "multichain-transport",
+          err.message
+        );
+      }
+    });
+  }
+  removeTransport() {
+    return __async(this, null, function* () {
+      try {
+        yield this.adapter.delete("multichain-transport");
+      } catch (err) {
+        throw new StorageDeleteErr(
+          this.adapter.platform,
+          "multichain-transport",
+          err.message
+        );
+      }
+    });
+  }
+  getAnonId() {
+    return __async(this, null, function* () {
+      try {
+        const anonId = yield this.adapter.get("anonId");
+        if (anonId) {
+          return anonId;
+        }
+        const newAnonId = uuid.v4();
+        yield this.adapter.set("anonId", newAnonId);
+        return newAnonId;
+      } catch (err) {
+        throw new StorageGetErr(this.adapter.platform, "anonId", err.message);
+      }
+    });
+  }
+  getExtensionId() {
+    return __async(this, null, function* () {
+      try {
+        return yield this.adapter.get("extensionId");
+      } catch (err) {
+        throw new StorageGetErr(
+          this.adapter.platform,
+          "extensionId",
+          err.message
+        );
+      }
+    });
+  }
+  setAnonId(anonId) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.adapter.set("anonId", anonId);
+      } catch (err) {
+        throw new StorageSetErr(this.adapter.platform, "anonId", err.message);
+      }
+    });
+  }
+  setExtensionId(extensionId) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.adapter.set("extensionId", extensionId);
+      } catch (err) {
+        throw new StorageSetErr(
+          this.adapter.platform,
+          "extensionId",
+          err.message
+        );
+      }
+    });
+  }
+  removeExtensionId() {
+    return __async(this, null, function* () {
+      try {
+        return yield this.adapter.delete("extensionId");
+      } catch (err) {
+        throw new StorageDeleteErr(
+          this.adapter.platform,
+          "extensionId",
+          err.message
+        );
+      }
+    });
+  }
+  removeAnonId() {
+    return __async(this, null, function* () {
+      try {
+        return yield this.adapter.delete("anonId");
+      } catch (err) {
+        throw new StorageDeleteErr(this.adapter.platform, "anonId", err.message);
+      }
+    });
+  }
+  getDebug() {
+    return __async(this, null, function* () {
+      try {
+        return yield this.adapter.get("DEBUG");
+      } catch (err) {
+        throw new StorageGetErr(this.adapter.platform, "DEBUG", err.message);
+      }
+    });
+  }
+};
+
+// src/ui/index.ts
+import MetaMaskOnboarding from "@metamask/onboarding";
+init_domain();
+init_qr();
+var __instance;
+function preload() {
+  return __async(this, null, function* () {
+    __instance != null ? __instance : __instance = yield import(
+      // Use a non-literal specifier to avoid Vite static analysis of deep imports
+      // and gracefully handle absence of the Stencil loader in this package build.
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      "@metamask/multichain-ui".concat("/dist/loader/index.js")
+      // Prefer ESM loader in browsers
+    ).then((loader) => __async(null, null, function* () {
+      if (typeof (loader == null ? void 0 : loader.defineCustomElements) === "function") {
+        loader.defineCustomElements();
+      }
+      return Promise.resolve(loader);
+    })).catch((error) => __async(null, null, function* () {
+      console.error(`Gracefully Failed to load modal customElements:`, error);
+      return Promise.resolve(void 0);
+    }));
+  });
+}
+var ModalFactory = class {
+  /**
+   * Creates a new modal factory instance.
+   *
+   * @param options - The modals configuration object
+   */
+  constructor(options) {
+    this.options = options;
+    this.platform = getPlatformType();
+    this.validateModals();
+  }
+  validateModals() {
+    const requiredModals = ["InstallModal", "OTPCodeModal"];
+    const missingModals = requiredModals.filter(
+      (modal) => !this.options[modal]
+    );
+    if (missingModals.length > 0) {
+      throw new Error(`Missing required modals: ${missingModals.join(", ")}`);
+    }
+  }
+  unload(error) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      (_a = this.modal) == null ? void 0 : _a.unmount();
+      yield (_b = this.successCallback) == null ? void 0 : _b.call(this, error);
+    });
+  }
+  /**
+   * Determines if the current platform is a mobile native environment.
+   * Currently only includes React Native.
+   */
+  get isMobile() {
+    return this.platform === "react-native" /* ReactNative */;
+  }
+  /**
+   * Determines if the current platform is a Node.js environment.
+   * Used for server-side or non-browser environments.
+   */
+  get isNode() {
+    return this.platform === "nodejs" /* NonBrowser */;
+  }
+  /**
+   * Determines if the current platform is a web environment.
+   * Includes desktop web, MetaMask mobile webview, and mobile web.
+   */
+  get isWeb() {
+    return this.platform === "web-desktop" /* DesktopWeb */ || this.platform === "in-app-browser" /* MetaMaskMobileWebview */ || this.platform === "web-mobile" /* MobileWeb */;
+  }
+  getContainer() {
+    return typeof document === "undefined" ? void 0 : document.createElement("div");
+  }
+  getMountedContainer() {
+    if (typeof document === "undefined") {
+      return void 0;
+    }
+    const container = this.getContainer();
+    if (container) {
+      document.body.appendChild(container);
+    }
+    return container;
+  }
+  createDeeplink(connectionRequest) {
+    if (!connectionRequest) {
+      return `${METAMASK_DEEPLINK_BASE}`;
+    }
+    const json = JSON.stringify(connectionRequest);
+    const compressed = compressString(json);
+    const urlEncoded = encodeURIComponent(compressed);
+    return `${METAMASK_DEEPLINK_BASE}/mwp?p=${urlEncoded}&c=1`;
+  }
+  createUniversalLink(connectionRequest) {
+    if (!connectionRequest) {
+      return `${METAMASK_CONNECT_BASE_URL}`;
+    }
+    const json = JSON.stringify(connectionRequest);
+    const compressed = compressString(json);
+    const urlEncoded = encodeURIComponent(compressed);
+    return `${METAMASK_CONNECT_BASE_URL}/mwp?p=${urlEncoded}&c=1`;
+  }
+  onCloseModal(shouldTerminate = true) {
+    return __async(this, null, function* () {
+      return this.unload(
+        shouldTerminate ? new Error("User closed modal") : void 0
+      );
+    });
+  }
+  onStartDesktopOnboarding() {
+    new MetaMaskOnboarding().startOnboarding();
+  }
+  renderInstallModal(preferDesktop, createConnectionRequest, successCallback) {
+    return __async(this, null, function* () {
+      var _a;
+      (_a = this.modal) == null ? void 0 : _a.unmount();
+      yield Promise.all([preload(), preloadQR()]);
+      this.successCallback = successCallback;
+      const parentElement = this.getMountedContainer();
+      const connectionRequest = yield createConnectionRequest();
+      const qrCodeLink = this.createDeeplink(connectionRequest);
+      const modal = new this.options.InstallModal({
+        expiresIn: (connectionRequest.sessionRequest.expiresAt - Date.now()) / 1e3,
+        connectionRequest,
+        parentElement,
+        preferDesktop,
+        link: qrCodeLink,
+        sdkVersion: getVersion(),
+        generateQRCode: (request) => __async(this, null, function* () {
+          return this.createDeeplink(request);
+        }),
+        onClose: this.onCloseModal.bind(this),
+        startDesktopOnboarding: this.onStartDesktopOnboarding.bind(this),
+        createConnectionRequest
+      });
+      this.modal = modal;
+      modal.mount();
+    });
+  }
+  renderOTPCodeModal(createOTPCode, successCallback, updateOTPCode) {
+    return __async(this, null, function* () {
+      var _a;
+      (_a = this.modal) == null ? void 0 : _a.unmount();
+      yield Promise.all([preload(), preloadQR()]);
+      this.successCallback = successCallback;
+      const container = this.getMountedContainer();
+      const otpCode = yield createOTPCode();
+      const modal = new this.options.OTPCodeModal({
+        parentElement: container,
+        sdkVersion: getVersion(),
+        otpCode,
+        onClose: this.onCloseModal.bind(this),
+        createOTPCode,
+        updateOTPCode: (otpCode2) => updateOTPCode(otpCode2, modal)
+      });
+      this.modal = modal;
+      modal.mount();
+    });
+  }
+};
+
+// src/index.node.ts
+init_domain();
+var createMetamaskConnect = (options) => __async(null, null, function* () {
+  const uiModules = yield Promise.resolve().then(() => (init_node(), node_exports));
+  let storage;
+  if (!options.storage) {
+    const { StoreAdapterNode: StoreAdapterNode2 } = yield Promise.resolve().then(() => (init_node2(), node_exports2));
+    const adapter = new StoreAdapterNode2();
+    storage = new Store(adapter);
+  } else {
+    storage = options.storage;
+  }
+  const factory = new ModalFactory(uiModules);
+  return MultichainSDK.create(__spreadProps(__spreadValues({}, options), {
+    storage,
+    ui: __spreadProps(__spreadValues({}, options.ui), {
+      factory
+    })
+  }));
+});
+export {
+  EventEmitter,
+  Modal,
+  MultichainCore,
+  PlatformType,
+  RPCHttpErr,
+  RPCInvokeMethodErr,
+  RPCReadonlyRequestErr,
+  RPCReadonlyResponseErr,
+  RPC_HANDLED_METHODS,
+  SDK_HANDLED_METHODS,
+  StoreAdapter,
+  StoreClient,
+  TransportType,
+  createLogger,
+  createMetamaskConnect,
+  enableDebug,
+  getInfuraRpcUrls,
+  getPlatformType,
+  getTransportType,
+  getVersion,
+  hasExtension,
+  infuraRpcUrls,
+  isEnabled,
+  isMetamaskExtensionInstalled,
+  isSecure
+};
+//# sourceMappingURL=connect-multichain.mjs.map