@qrlwallet/connect 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1236 @@
+// src/QRLConnectProvider.ts
+import EventEmitter4 from "eventemitter3";
+
+// src/ConnectionManager.ts
+import EventEmitter3 from "eventemitter3";
+import { v4 as uuidv4 } from "uuid";
+
+// src/ECIESClient.ts
+import { PrivateKey, decrypt, encrypt } from "eciesjs";
+
+// src/utils/logger.ts
+var debugEnabled = false;
+function setDebug(enabled) {
+  debugEnabled = enabled;
+}
+function log(tag, ...args) {
+  if (debugEnabled) {
+    console.log(`[QRLConnect:${tag}]`, ...args);
+  }
+}
+function warn(tag, ...args) {
+  console.warn(`[QRLConnect:${tag}]`, ...args);
+}
+function error(tag, ...args) {
+  console.error(`[QRLConnect:${tag}]`, ...args);
+}
+
+// src/ECIESClient.ts
+function toBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function fromBase64(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+var ECIESClient = class {
+  constructor(existingPrivateKey) {
+    if (existingPrivateKey) {
+      this.privateKey = PrivateKey.fromHex(existingPrivateKey);
+      log("ECIES", "Restored from existing private key");
+    } else {
+      this.privateKey = new PrivateKey();
+      log("ECIES", "Generated new ECIES keypair");
+    }
+  }
+  /** Get public key as hex string */
+  getPublicKey() {
+    return this.privateKey.publicKey.toHex();
+  }
+  /** Get private key as hex string (for session persistence) */
+  getPrivateKeyHex() {
+    return this.privateKey.toHex();
+  }
+  /** Encrypt a string message for the given public key. Returns base64. */
+  encrypt(data, otherPublicKey) {
+    const encoded = new TextEncoder().encode(data);
+    const encrypted = encrypt(otherPublicKey, encoded);
+    return toBase64(encrypted);
+  }
+  /** Decrypt a base64-encoded message using our private key. */
+  decrypt(encryptedBase64) {
+    const encryptedBytes = fromBase64(encryptedBase64);
+    const decrypted = decrypt(this.privateKey.toHex(), encryptedBytes);
+    return new TextDecoder().decode(decrypted);
+  }
+};
+
+// src/KeyExchange.ts
+import EventEmitter from "eventemitter3";
+
+// src/config.ts
+var DEFAULT_RELAY_URL = "https://qrlwallet.com";
+var RELAY_PATH = "/relay";
+var PROTOCOL_VERSION = 1;
+var SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var STORAGE_KEY_PREFIX = "@qrlwallet/connect";
+var REQUEST_TIMEOUT_MS = 5 * 60 * 1e3;
+var WALLET_UNRESPONSIVE_MS = 30 * 1e3;
+var RESTRICTED_METHODS = /* @__PURE__ */ new Set([
+  "qrl_requestAccounts",
+  "qrl_sendTransaction",
+  "qrl_signTransaction",
+  "qrl_sign",
+  "personal_sign",
+  "qrl_signTypedData",
+  "qrl_signTypedData_v3",
+  "qrl_signTypedData_v4",
+  "wallet_addQrlChain",
+  "wallet_switchQrlChain"
+]);
+var UNRESTRICTED_METHODS = /* @__PURE__ */ new Set([
+  "qrl_chainId",
+  "qrl_blockNumber",
+  "qrl_getBalance",
+  "qrl_getTransactionCount",
+  "qrl_getBlockByNumber",
+  "qrl_getBlockByHash",
+  "qrl_getTransactionByHash",
+  "qrl_getTransactionReceipt",
+  "qrl_call",
+  "qrl_estimateGas",
+  "qrl_gasPrice",
+  "qrl_getCode",
+  "qrl_getStorageAt",
+  "qrl_getLogs",
+  "qrl_getBlockTransactionCountByHash",
+  "qrl_getBlockTransactionCountByNumber",
+  "qrl_getTransactionByBlockHashAndIndex",
+  "qrl_getTransactionByBlockNumberAndIndex",
+  "qrl_accounts",
+  "net_version",
+  "net_listening",
+  "net_peerCount",
+  "web3_clientVersion",
+  "web3_sha3",
+  "qrl_syncing",
+  "qrl_coinbase",
+  "qrl_mining",
+  "qrl_hashrate",
+  "qrl_protocolVersion",
+  "qrl_getUncleCountByBlockHash",
+  "qrl_getUncleCountByBlockNumber",
+  "qrl_getUncleByBlockHashAndIndex",
+  "qrl_getUncleByBlockNumberAndIndex",
+  "qrl_getFilterChanges",
+  "qrl_getFilterLogs",
+  "qrl_newBlockFilter",
+  "qrl_newFilter",
+  "qrl_newPendingTransactionFilter",
+  "qrl_uninstallFilter"
+]);
+
+// src/types.ts
+var KeyExchangeMessageType = /* @__PURE__ */ ((KeyExchangeMessageType2) => {
+  KeyExchangeMessageType2["SYN"] = "key_handshake_SYN";
+  KeyExchangeMessageType2["SYNACK"] = "key_handshake_SYNACK";
+  KeyExchangeMessageType2["ACK"] = "key_handshake_ACK";
+  return KeyExchangeMessageType2;
+})(KeyExchangeMessageType || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["KEY_EXCHANGE"] = "key_exchange";
+  MessageType2["JSONRPC"] = "jsonrpc";
+  MessageType2["WALLET_INFO"] = "wallet_info";
+  MessageType2["ORIGINATOR_INFO"] = "originator_info";
+  MessageType2["TERMINATE"] = "terminate";
+  MessageType2["PING"] = "ping";
+  MessageType2["READY"] = "ready";
+  return MessageType2;
+})(MessageType || {});
+var ConnectionStatus = /* @__PURE__ */ ((ConnectionStatus2) => {
+  ConnectionStatus2["DISCONNECTED"] = "disconnected";
+  ConnectionStatus2["CONNECTING"] = "connecting";
+  ConnectionStatus2["WAITING"] = "waiting";
+  ConnectionStatus2["KEY_EXCHANGE"] = "key_exchange";
+  ConnectionStatus2["CONNECTED"] = "connected";
+  ConnectionStatus2["RECONNECTING"] = "reconnecting";
+  return ConnectionStatus2;
+})(ConnectionStatus || {});
+
+// src/KeyExchange.ts
+var KeyExchange = class extends EventEmitter {
+  constructor(ecies, isOriginator, otherPublicKey) {
+    super();
+    this.otherPublicKey = null;
+    this.keysExchanged = false;
+    this.awaitingSynAck = false;
+    this.awaitingAck = false;
+    this.step = "key_handshake_SYN" /* SYN */;
+    this.ecies = ecies;
+    this.isOriginator = isOriginator;
+    if (otherPublicKey) {
+      this.otherPublicKey = otherPublicKey;
+      this.keysExchanged = true;
+      log("KeyExchange", "Restored with existing other public key");
+    }
+  }
+  /** Get the SYN message to start the handshake (originator/dApp side). */
+  createSYN() {
+    this.step = "key_handshake_SYN" /* SYN */;
+    this.awaitingSynAck = true;
+    this.emit("step_change", this.step);
+    return {
+      type: "key_handshake_SYN" /* SYN */,
+      pubkey: this.ecies.getPublicKey(),
+      v: PROTOCOL_VERSION
+    };
+  }
+  /**
+   * Process an incoming key exchange message.
+   * Returns a response message to send back, or null if handshake is complete.
+   */
+  onMessage(message) {
+    log("KeyExchange", `Received ${message.type}, isOriginator=${this.isOriginator}`);
+    switch (message.type) {
+      case "key_handshake_SYN" /* SYN */: {
+        if (this.isOriginator) {
+          warn("KeyExchange", "Originator received SYN - ignoring");
+          return null;
+        }
+        if (message.pubkey) {
+          this.otherPublicKey = message.pubkey;
+        }
+        this.step = "key_handshake_SYNACK" /* SYNACK */;
+        this.awaitingAck = true;
+        this.emit("step_change", this.step);
+        return {
+          type: "key_handshake_SYNACK" /* SYNACK */,
+          pubkey: this.ecies.getPublicKey(),
+          v: PROTOCOL_VERSION
+        };
+      }
+      case "key_handshake_SYNACK" /* SYNACK */: {
+        if (!this.isOriginator) {
+          warn("KeyExchange", "Non-originator received SYNACK - ignoring");
+          return null;
+        }
+        if (message.pubkey) {
+          this.otherPublicKey = message.pubkey;
+        }
+        if (!this.awaitingSynAck) {
+          return {
+            type: "key_handshake_ACK" /* ACK */,
+            v: PROTOCOL_VERSION
+          };
+        }
+        this.awaitingSynAck = false;
+        this.step = "key_handshake_ACK" /* ACK */;
+        if (!this.keysExchanged) {
+          this.keysExchanged = true;
+          this.emit("keys_exchanged");
+        }
+        this.emit("step_change", this.step);
+        return {
+          type: "key_handshake_ACK" /* ACK */,
+          v: PROTOCOL_VERSION
+        };
+      }
+      case "key_handshake_ACK" /* ACK */: {
+        if (this.isOriginator) {
+          warn("KeyExchange", "Originator received ACK - ignoring");
+          return null;
+        }
+        if (!this.awaitingAck) {
+          return null;
+        }
+        this.awaitingAck = false;
+        if (!this.keysExchanged) {
+          this.keysExchanged = true;
+          this.emit("keys_exchanged");
+        }
+        log("KeyExchange", "Key exchange complete (wallet side)");
+        return null;
+      }
+      default:
+        warn("KeyExchange", `Unknown key exchange type: ${message.type}`);
+        return null;
+    }
+  }
+  /** Encrypt a message for the counterparty. */
+  encryptMessage(data) {
+    if (!this.otherPublicKey) {
+      throw new Error("Cannot encrypt: key exchange not complete");
+    }
+    return this.ecies.encrypt(data, this.otherPublicKey);
+  }
+  /** Decrypt a message from the counterparty. */
+  decryptMessage(encryptedBase64) {
+    return this.ecies.decrypt(encryptedBase64);
+  }
+  /** Reset key exchange state for a fresh handshake (e.g. new QR code). */
+  reset() {
+    this.otherPublicKey = null;
+    this.keysExchanged = false;
+    this.awaitingSynAck = false;
+    this.awaitingAck = false;
+    this.step = "key_handshake_SYN" /* SYN */;
+    log("KeyExchange", "Reset for fresh handshake");
+  }
+  areKeysExchanged() {
+    return this.keysExchanged;
+  }
+  getOtherPublicKey() {
+    return this.otherPublicKey;
+  }
+  getCurrentStep() {
+    return this.step;
+  }
+};
+
+// src/SocketClient.ts
+import { io } from "socket.io-client";
+import EventEmitter2 from "eventemitter3";
+var SocketClient = class extends EventEmitter2 {
+  constructor(relayUrl, clientType) {
+    super();
+    this.socket = null;
+    this.channelId = null;
+    this.seq = 0;
+    this.pendingJoin = null;
+    this.relayUrl = relayUrl;
+    this.clientType = clientType;
+  }
+  /**
+   * Connect to the relay server.
+   */
+  connect() {
+    if (this.socket?.connected) return;
+    log("Socket", `Connecting to ${this.relayUrl}`);
+    this.socket = io(this.relayUrl, {
+      path: RELAY_PATH,
+      transports: ["websocket", "polling"],
+      reconnection: true,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 3e4,
+      reconnectionAttempts: Infinity,
+      timeout: 2e4
+    });
+    this.socket.on("connect", () => {
+      log("Socket", "Connected to relay");
+      this.emit("connected");
+      if (this.channelId) {
+        const reconnectChannelId = this.channelId;
+        this.joinChannelNow(reconnectChannelId).then((result) => {
+          if (this.pendingJoin && this.pendingJoin.channelId === reconnectChannelId) {
+            this.pendingJoin.resolve(result);
+            this.pendingJoin = null;
+          }
+          this.emit("reconnected");
+        }).catch((err) => {
+          const reconnectErr = err instanceof Error ? err : new Error(String(err));
+          if (this.pendingJoin && this.pendingJoin.channelId === reconnectChannelId) {
+            this.pendingJoin.reject(reconnectErr);
+            this.pendingJoin = null;
+          }
+          error("Socket", `Rejoin failed: ${reconnectErr.message}`);
+          this.emit("error", reconnectErr);
+        });
+      }
+    });
+    this.socket.on("disconnect", (reason) => {
+      log("Socket", `Disconnected: ${reason}`);
+      this.emit("disconnected", reason);
+    });
+    this.socket.on("message", (data) => {
+      log("Socket", `Message received in channel ${data.id}`);
+      this.emit("message", data);
+    });
+    this.socket.on("participants_changed", (data) => {
+      log("Socket", `Participants changed: ${data.event}`);
+      this.emit("participants_changed", data);
+    });
+    this.socket.on("connect_error", (err) => {
+      warn("Socket", `Connection error: ${err.message}`);
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Join a relay channel.
+   */
+  async joinChannel(channelId) {
+    if (!this.socket) {
+      throw new Error("Socket not initialized. Call connect() before joinChannel()");
+    }
+    this.channelId = channelId;
+    if (this.socket.connected) {
+      return this.joinChannelNow(channelId);
+    }
+    if (this.pendingJoin) {
+      if (this.pendingJoin.channelId === channelId) {
+        return this.pendingJoin.promise;
+      }
+      this.pendingJoin.reject(new Error("Join request superseded by a newer channel"));
+      this.pendingJoin = null;
+    }
+    let resolvePending;
+    let rejectPending;
+    const promise = new Promise((resolve, reject) => {
+      resolvePending = resolve;
+      rejectPending = reject;
+    });
+    this.pendingJoin = {
+      channelId,
+      promise,
+      resolve: resolvePending,
+      reject: rejectPending
+    };
+    return promise;
+  }
+  joinChannelNow(channelId) {
+    return new Promise((resolve, reject) => {
+      if (!this.socket?.connected) {
+        reject(new Error("Socket not connected"));
+        return;
+      }
+      this.socket.emit(
+        "join_channel",
+        { channelId, clientType: this.clientType },
+        (response) => {
+          if (response.success) {
+            log("Socket", `Joined channel ${channelId}`);
+            resolve({ bufferedMessages: response.bufferedMessages || [] });
+          } else {
+            error("Socket", `Failed to join channel: ${response.error}`);
+            reject(new Error(response.error || "Failed to join channel"));
+          }
+        }
+      );
+    });
+  }
+  /**
+   * Send a message through the relay.
+   */
+  sendMessage(data) {
+    return new Promise((resolve, reject) => {
+      if (!this.socket?.connected) {
+        reject(new Error("Socket not connected"));
+        return;
+      }
+      const dataWithSeq = { ...data, seq: this.seq++ };
+      this.socket.emit(
+        "message",
+        dataWithSeq,
+        (response) => {
+          if (response?.success) {
+            resolve({ success: true, buffered: response.buffered });
+          } else {
+            reject(new Error(response?.error || "Failed to send message"));
+          }
+        }
+      );
+    });
+  }
+  /**
+   * Leave the current channel.
+   */
+  leaveChannel() {
+    if (this.pendingJoin) {
+      this.pendingJoin.reject(new Error("Channel left before join completed"));
+      this.pendingJoin = null;
+    }
+    if (this.socket?.connected && this.channelId) {
+      this.socket.emit("leave_channel", { channelId: this.channelId });
+    }
+    this.channelId = null;
+  }
+  /**
+   * Disconnect from the relay.
+   */
+  disconnect() {
+    if (this.pendingJoin) {
+      this.pendingJoin.reject(new Error("Socket disconnected before join completed"));
+      this.pendingJoin = null;
+    }
+    this.channelId = null;
+    this.seq = 0;
+    if (this.socket) {
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+  isConnected() {
+    return this.socket?.connected ?? false;
+  }
+  getChannelId() {
+    return this.channelId;
+  }
+};
+
+// src/utils/qrUri.ts
+function generateConnectionURI(params) {
+  const searchParams = new URLSearchParams({
+    channelId: params.channelId,
+    pubKey: params.pubKey,
+    name: params.name,
+    url: params.url,
+    chainId: params.chainId,
+    relay: params.relayUrl
+  });
+  if (params.icon) {
+    searchParams.set("icon", params.icon);
+  }
+  return `qrlconnect://?${searchParams.toString()}`;
+}
+function parseConnectionURI(uri) {
+  try {
+    const queryString = uri.replace(/^qrlconnect:\/?\/?/, "");
+    const params = new URLSearchParams(queryString);
+    const channelId = params.get("channelId");
+    const pubKey = params.get("pubKey");
+    const name = params.get("name");
+    const url = params.get("url");
+    const chainId = params.get("chainId");
+    const relayUrl = params.get("relay");
+    if (!channelId || !pubKey || !name || !url || !chainId || !relayUrl) {
+      return null;
+    }
+    return {
+      channelId,
+      pubKey,
+      name,
+      url,
+      icon: params.get("icon") || void 0,
+      chainId,
+      relayUrl
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/ConnectionManager.ts
+var DAPP_PARTICIPANT_CONFLICT_ERROR_MSG = "dapp participant is already connected";
+var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
+  constructor(options) {
+    super();
+    this.status = "disconnected" /* DISCONNECTED */;
+    this.connectedAccounts = [];
+    this.unresponsiveTimer = null;
+    this.synRetryTimer = null;
+    this.failedReconnects = 0;
+    this.synSent = false;
+    this.synAttempts = 0;
+    this.walletPresent = false;
+    this.dappMetadata = options.dappMetadata;
+    this.relayUrl = options.relayUrl || DEFAULT_RELAY_URL;
+    this.chainId = options.chainId || "0x0";
+    this.storageKey = options.storageKey || `${STORAGE_KEY_PREFIX}:session`;
+    const session = this.loadSession();
+    if (session) {
+      this.channelId = session.channelId;
+      this.ecies = new ECIESClient(session.privateKey);
+      this.keyExchange = new KeyExchange(
+        this.ecies,
+        true,
+        // dApp is always originator
+        session.otherPublicKey || void 0
+      );
+      this.connectedAccounts = session.connectedAccounts;
+      log("ConnectionManager", `Restored session for channel ${this.channelId}`);
+    } else {
+      this.channelId = uuidv4();
+      this.ecies = new ECIESClient();
+      this.keyExchange = new KeyExchange(this.ecies, true);
+    }
+    this.socketClient = new SocketClient(this.relayUrl, "dapp");
+    this.setupSocketListeners();
+    this.setupKeyExchangeListeners();
+  }
+  setupSocketListeners() {
+    this.socketClient.on("connected", () => {
+      if (this.status === "reconnecting" /* RECONNECTING */) {
+        this.failedReconnects = 0;
+        log("ConnectionManager", "Reconnected to relay");
+      }
+    });
+    this.socketClient.on("reconnected", () => {
+      if (this.keyExchange.areKeysExchanged()) {
+        if (this.walletPresent) {
+          this.setStatus("connected" /* CONNECTED */);
+          this.failedReconnects = 0;
+        } else {
+          this.setStatus("waiting" /* WAITING */);
+        }
+        this.synAttempts = 0;
+        this.clearSynRetryTimer();
+      } else {
+        this.sendSYN();
+      }
+    });
+    this.socketClient.on("disconnected", (_reason) => {
+      this.walletPresent = false;
+      this.synSent = false;
+      this.clearSynRetryTimer();
+      if (this.status === "connected" /* CONNECTED */) {
+        this.setStatus("reconnecting" /* RECONNECTING */);
+        this.failedReconnects++;
+        if (this.failedReconnects >= _ConnectionManager.MAX_RECONNECT_FAILURES) {
+          this.emit("connection_lost");
+        }
+      }
+    });
+    this.socketClient.on("message", (data) => {
+      this.handleRelayMessage(data);
+    });
+    this.socketClient.on("error", (err) => {
+      this.emit("error", err);
+    });
+    this.socketClient.on("participants_changed", (data) => {
+      if (data.event === "join" && data.clientType === "wallet") {
+        this.walletPresent = true;
+        log("ConnectionManager", "Wallet joined channel");
+        this.clearUnresponsiveTimer();
+        if (this.keyExchange.areKeysExchanged()) {
+          this.failedReconnects = 0;
+          this.setStatus("connected" /* CONNECTED */);
+        } else if (!this.synSent) {
+          this.sendSYN();
+        }
+      }
+      if (data.event === "disconnect" || data.event === "leave") {
+        if (data.clientType === "wallet" || !data.clientType) {
+          this.walletPresent = false;
+          if (!this.keyExchange.areKeysExchanged()) {
+            this.synSent = false;
+            this.clearSynRetryTimer();
+          } else if (this.status === "connected" /* CONNECTED */ || this.status === "reconnecting" /* RECONNECTING */) {
+            this.setStatus("waiting" /* WAITING */);
+          }
+          log("ConnectionManager", "Wallet left channel");
+        }
+      }
+    });
+  }
+  setupKeyExchangeListeners() {
+    this.keyExchange.on("keys_exchanged", () => {
+      log("ConnectionManager", "Key exchange complete");
+      this.setStatus("connected" /* CONNECTED */);
+      this.walletPresent = true;
+      this.synSent = false;
+      this.synAttempts = 0;
+      this.clearSynRetryTimer();
+      this.saveSession();
+      this.sendEncrypted({
+        type: "originator_info" /* ORIGINATOR_INFO */,
+        originatorInfo: {
+          ...this.dappMetadata,
+          chainId: this.chainId
+        }
+      });
+    });
+  }
+  /**
+   * Generate the connection URI and start listening for wallet connection.
+   */
+  async getConnectionURI(retryOnConflict = true) {
+    this.setStatus("connecting" /* CONNECTING */);
+    this.keyExchange.reset();
+    this.walletPresent = false;
+    this.synSent = false;
+    this.synAttempts = 0;
+    this.clearSynRetryTimer();
+    this.socketClient.connect();
+    try {
+      await this.socketClient.joinChannel(this.channelId);
+    } catch (err) {
+      if (retryOnConflict && this.isDappParticipantConflictError(err)) {
+        warn(
+          "ConnectionManager",
+          "Channel already has an active dApp participant. Rotating to a fresh channel."
+        );
+        this.resetForNewChannel();
+        return this.getConnectionURI(false);
+      }
+      this.setStatus("disconnected" /* DISCONNECTED */);
+      throw err;
+    }
+    this.setStatus("waiting" /* WAITING */);
+    const uri = generateConnectionURI({
+      channelId: this.channelId,
+      pubKey: this.ecies.getPublicKey(),
+      name: this.dappMetadata.name,
+      url: this.dappMetadata.url,
+      icon: this.dappMetadata.icon,
+      chainId: this.chainId,
+      relayUrl: this.relayUrl
+    });
+    log("ConnectionManager", `Generated connection URI for channel ${this.channelId}`);
+    return uri;
+  }
+  /**
+   * Reconnect to an existing session.
+   */
+  async reconnect() {
+    const session = this.loadSession();
+    if (!session) return false;
+    this.setStatus("reconnecting" /* RECONNECTING */);
+    this.walletPresent = false;
+    this.synSent = false;
+    this.synAttempts = 0;
+    this.clearSynRetryTimer();
+    this.socketClient.connect();
+    try {
+      const { bufferedMessages } = await this.socketClient.joinChannel(this.channelId);
+      for (const msg of bufferedMessages) {
+        this.handleRelayMessage(msg);
+      }
+      if (this.keyExchange.areKeysExchanged() && this.walletPresent) {
+        this.setStatus("connected" /* CONNECTED */);
+      } else if (this.keyExchange.areKeysExchanged()) {
+        this.setStatus("waiting" /* WAITING */);
+      } else {
+        this.sendSYN();
+      }
+      return true;
+    } catch (err) {
+      error("ConnectionManager", "Reconnect failed:", err);
+      this.setStatus("disconnected" /* DISCONNECTED */);
+      return false;
+    }
+  }
+  /**
+   * Send a JSON-RPC request to the wallet.
+   */
+  sendJsonRpc(request) {
+    if (!this.keyExchange.areKeysExchanged()) {
+      throw new Error("Not connected: key exchange not complete");
+    }
+    this.sendEncrypted({
+      type: "jsonrpc" /* JSONRPC */,
+      jsonrpc: "2.0",
+      id: request.id,
+      method: request.method,
+      params: request.params
+    });
+    this.startUnresponsiveTimer();
+  }
+  /**
+   * Handle an incoming relay message.
+   */
+  handleRelayMessage(data) {
+    if (data.clientType === "wallet") {
+      this.walletPresent = true;
+      if (this.keyExchange.areKeysExchanged() && this.status !== "connected" /* CONNECTED */) {
+        this.failedReconnects = 0;
+        this.setStatus("connected" /* CONNECTED */);
+      }
+    }
+    const message = data.message;
+    if (typeof message === "object" && message !== null) {
+      const msg = message;
+      if (msg.type === "key_handshake_SYN" /* SYN */ || msg.type === "key_handshake_SYNACK" /* SYNACK */ || msg.type === "key_handshake_ACK" /* ACK */) {
+        this.handleKeyExchangeMessage(
+          msg
+        );
+        return;
+      }
+    }
+    if (typeof message === "string" && this.keyExchange.areKeysExchanged()) {
+      try {
+        const decrypted = this.keyExchange.decryptMessage(message);
+        const parsed = JSON.parse(decrypted);
+        this.handleDecryptedMessage(parsed);
+      } catch (err) {
+        error("ConnectionManager", "Failed to decrypt message:", err);
+      }
+    }
+  }
+  handleKeyExchangeMessage(msg) {
+    this.setStatus("key_exchange" /* KEY_EXCHANGE */);
+    const response = this.keyExchange.onMessage(msg);
+    if (response) {
+      this.sendPlaintext(response);
+    }
+  }
+  handleDecryptedMessage(msg) {
+    this.clearUnresponsiveTimer();
+    const type = msg.type;
+    switch (type) {
+      case "wallet_info" /* WALLET_INFO */: {
+        const info = msg;
+        const nextAccounts = info.accounts || [];
+        const nextChainId = info.chainId || this.chainId;
+        const accountsChanged = !this.areArraysEqual(this.connectedAccounts, nextAccounts);
+        const chainChanged = this.chainId !== nextChainId;
+        this.connectedAccounts = nextAccounts;
+        this.chainId = nextChainId;
+        this.saveSession();
+        this.emit("wallet_info", {
+          accounts: this.connectedAccounts,
+          chainId: this.chainId
+        });
+        if (accountsChanged) {
+          this.emit("accounts_changed", this.connectedAccounts);
+        }
+        if (chainChanged) {
+          this.emit("chain_changed", this.chainId);
+        }
+        break;
+      }
+      case "jsonrpc" /* JSONRPC */: {
+        const response = msg;
+        this.emit("jsonrpc_response", response);
+        break;
+      }
+      case "terminate" /* TERMINATE */: {
+        log("ConnectionManager", "Received terminate from wallet");
+        this.disconnect();
+        break;
+      }
+      default:
+        log("ConnectionManager", `Unhandled message type: ${type}`);
+    }
+  }
+  /** Send a plaintext (unencrypted) message through the relay. */
+  sendPlaintext(message) {
+    this.socketClient.sendMessage({
+      id: this.channelId,
+      clientType: "dapp",
+      message
+    }).catch((err) => {
+      error("ConnectionManager", "Failed to send plaintext:", err);
+    });
+  }
+  /** Send an encrypted message through the relay. */
+  sendEncrypted(message) {
+    try {
+      const encrypted = this.keyExchange.encryptMessage(JSON.stringify(message));
+      this.socketClient.sendMessage({
+        id: this.channelId,
+        clientType: "dapp",
+        message: encrypted
+      }).catch((err) => {
+        error("ConnectionManager", "Failed to send encrypted:", err);
+      });
+    } catch (err) {
+      error("ConnectionManager", "Encryption failed:", err);
+    }
+  }
+  startUnresponsiveTimer() {
+    this.clearUnresponsiveTimer();
+    this.unresponsiveTimer = setTimeout(() => {
+      warn("ConnectionManager", "Wallet appears unresponsive");
+    }, WALLET_UNRESPONSIVE_MS);
+  }
+  clearUnresponsiveTimer() {
+    if (this.unresponsiveTimer) {
+      clearTimeout(this.unresponsiveTimer);
+      this.unresponsiveTimer = null;
+    }
+  }
+  sendSYN() {
+    if (!this.socketClient.isConnected()) {
+      return;
+    }
+    if (this.synAttempts >= _ConnectionManager.MAX_SYN_ATTEMPTS) {
+      this.synSent = false;
+      this.emit("error", new Error("Key exchange timed out waiting for wallet response"));
+      return;
+    }
+    try {
+      const syn = this.keyExchange.createSYN();
+      this.sendPlaintext(syn);
+      this.synSent = true;
+      this.synAttempts++;
+      this.scheduleSynRetry();
+      log("ConnectionManager", "Sent SYN key exchange message");
+    } catch (err) {
+      error("ConnectionManager", "Failed to send SYN:", err);
+    }
+  }
+  scheduleSynRetry() {
+    this.clearSynRetryTimer();
+    this.synRetryTimer = setTimeout(() => {
+      this.synRetryTimer = null;
+      if (this.keyExchange.areKeysExchanged()) {
+        return;
+      }
+      this.synSent = false;
+      if (!this.walletPresent || !this.socketClient.isConnected()) {
+        return;
+      }
+      this.sendSYN();
+    }, _ConnectionManager.SYN_RETRY_MS);
+  }
+  clearSynRetryTimer() {
+    if (this.synRetryTimer) {
+      clearTimeout(this.synRetryTimer);
+      this.synRetryTimer = null;
+    }
+  }
+  setStatus(status) {
+    if (this.status !== status) {
+      this.status = status;
+      this.emit("status_changed", status);
+    }
+  }
+  isDappParticipantConflictError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return msg.toLowerCase().includes(DAPP_PARTICIPANT_CONFLICT_ERROR_MSG);
+  }
+  areArraysEqual(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+  getStatus() {
+    return this.status;
+  }
+  getAccounts() {
+    return this.connectedAccounts;
+  }
+  getChainId() {
+    return this.chainId;
+  }
+  getChannelId() {
+    return this.channelId;
+  }
+  /** Check if a stored session exists (without loading/restoring it). */
+  hasStoredSession() {
+    if (typeof localStorage === "undefined") return false;
+    try {
+      const raw = localStorage.getItem(this.storageKey);
+      if (!raw) return false;
+      const session = JSON.parse(raw);
+      return Date.now() - session.createdAt <= SESSION_TTL_MS;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Reset the connection and create a new channel for a fresh pairing.
+   * Disconnects any existing session, generates a new channel ID and keys.
+   */
+  resetForNewChannel() {
+    this.clearUnresponsiveTimer();
+    this.clearSynRetryTimer();
+    this.synSent = false;
+    this.synAttempts = 0;
+    this.walletPresent = false;
+    if (this.keyExchange.areKeysExchanged()) {
+      try {
+        this.sendEncrypted({ type: "terminate" /* TERMINATE */ });
+      } catch {
+      }
+    }
+    this.socketClient.leaveChannel();
+    this.socketClient.disconnect();
+    this.clearSession();
+    this.connectedAccounts = [];
+    this.channelId = uuidv4();
+    this.ecies = new ECIESClient();
+    this.keyExchange = new KeyExchange(this.ecies, true);
+    this.socketClient = new SocketClient(this.relayUrl, "dapp");
+    this.setupSocketListeners();
+    this.setupKeyExchangeListeners();
+    this.setStatus("disconnected" /* DISCONNECTED */);
+  }
+  /** Disconnect and clean up. */
+  disconnect() {
+    this.clearUnresponsiveTimer();
+    this.clearSynRetryTimer();
+    this.synSent = false;
+    this.synAttempts = 0;
+    this.walletPresent = false;
+    if (this.keyExchange.areKeysExchanged()) {
+      try {
+        this.sendEncrypted({ type: "terminate" /* TERMINATE */ });
+      } catch {
+      }
+    }
+    this.socketClient.leaveChannel();
+    this.socketClient.disconnect();
+    this.setStatus("disconnected" /* DISCONNECTED */);
+    this.clearSession();
+    this.connectedAccounts = [];
+  }
+  // --- Session persistence ---
+  saveSession() {
+    if (typeof localStorage === "undefined") return;
+    const session = {
+      channelId: this.channelId,
+      privateKey: this.ecies.getPrivateKeyHex(),
+      otherPublicKey: this.keyExchange.getOtherPublicKey(),
+      dappMetadata: this.dappMetadata,
+      connectedAccounts: this.connectedAccounts,
+      chainId: this.chainId,
+      createdAt: Date.now(),
+      lastActivity: Date.now()
+    };
+    localStorage.setItem(this.storageKey, JSON.stringify(session));
+  }
+  loadSession() {
+    if (typeof localStorage === "undefined") return null;
+    try {
+      const raw = localStorage.getItem(this.storageKey);
+      if (!raw) return null;
+      const session = JSON.parse(raw);
+      if (Date.now() - session.createdAt > SESSION_TTL_MS) {
+        this.clearSession();
+        return null;
+      }
+      return session;
+    } catch {
+      return null;
+    }
+  }
+  clearSession() {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(this.storageKey);
+  }
+};
+_ConnectionManager.MAX_RECONNECT_FAILURES = 5;
+_ConnectionManager.SYN_RETRY_MS = 5e3;
+_ConnectionManager.MAX_SYN_ATTEMPTS = 6;
+var ConnectionManager = _ConnectionManager;
+
+// src/utils/platform.ts
+function isMobileBrowser() {
+  if (typeof navigator === "undefined") return false;
+  return /Android|iPhone|iPad|iPod|Opera Mini|IEMobile|WPDesktop/i.test(navigator.userAgent);
+}
+function getAppStoreUrl() {
+  if (typeof navigator !== "undefined" && /android/i.test(navigator.userAgent)) {
+    return "https://play.google.com/store/apps/details?id=com.chiefdg.myqrlwallet";
+  }
+  return "https://apps.apple.com/app/myqrlwallet/id6742219498";
+}
+
+// src/QRLConnectProvider.ts
+var requestCounter = 0;
+var QRLConnectProvider = class extends EventEmitter4 {
+  constructor(options) {
+    super();
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.isQRLConnect = true;
+    this.options = options;
+    if (options.debug) {
+      setDebug(true);
+    }
+    this.connectionManager = new ConnectionManager({
+      dappMetadata: options.dappMetadata,
+      relayUrl: options.relayUrl,
+      chainId: options.chainId,
+      storageKey: options.storageKey
+    });
+    this.setupConnectionListeners();
+    if (options.autoReconnect !== false) {
+      this.connectionManager.reconnect();
+    }
+  }
+  setupConnectionListeners() {
+    this.connectionManager.on("status_changed", (status) => {
+      log("Provider", `Connection status: ${status}`);
+      this.emit("statusChanged", status);
+      if (status === "connected" /* CONNECTED */) {
+        this.emit("connect", { chainId: this.connectionManager.getChainId() });
+      }
+      if (status === "disconnected" /* DISCONNECTED */) {
+        this.emit("disconnect", {
+          code: 4900,
+          message: "Disconnected from QRL Wallet"
+        });
+      }
+    });
+    this.connectionManager.on("accounts_changed", (accounts) => {
+      this.emit("accountsChanged", accounts);
+    });
+    this.connectionManager.on("chain_changed", (chainId) => {
+      this.emit("chainChanged", chainId);
+    });
+    this.connectionManager.on("jsonrpc_response", (response) => {
+      const pending = this.pendingRequests.get(response.id);
+      if (!pending) {
+        warn("Provider", `No pending request for id ${response.id}`);
+        return;
+      }
+      this.pendingRequests.delete(response.id);
+      if (response.error) {
+        pending.reject(new Error(response.error.message || "Request failed"));
+      } else {
+        pending.resolve(response.result);
+      }
+    });
+    this.connectionManager.on("wallet_info", (info) => {
+      for (const [id, pending] of this.pendingRequests) {
+        if (pending.method === "qrl_requestAccounts" || pending.method === "qrl_accounts") {
+          pending.resolve(info.accounts);
+          this.pendingRequests.delete(id);
+        }
+      }
+    });
+    this.connectionManager.on("error", (err) => {
+      warn("Provider", `ConnectionManager error: ${err.message}`);
+      this.emit("message", { type: "error", data: err.message });
+    });
+    this.connectionManager.on("connection_lost", () => {
+      for (const [, pending] of this.pendingRequests) {
+        pending.reject(new Error("Connection to QRL Wallet lost"));
+      }
+      this.pendingRequests.clear();
+    });
+  }
+  /**
+   * Generate a connection URI for QR code display or deep link redirect.
+   */
+  async getConnectionURI() {
+    return this.connectionManager.getConnectionURI();
+  }
+  /**
+   * Check if the current browser is mobile.
+   */
+  isMobile() {
+    return isMobileBrowser();
+  }
+  /**
+   * Get the app store URL for the QRL Wallet app.
+   */
+  getAppStoreUrl() {
+    return getAppStoreUrl();
+  }
+  /**
+   * EIP-1193 request method.
+   */
+  async request(args) {
+    const { method, params } = args;
+    if (method === "qrl_chainId") {
+      return this.connectionManager.getChainId();
+    }
+    if (method === "qrl_accounts") {
+      const accounts = this.connectionManager.getAccounts();
+      if (accounts.length > 0) return accounts;
+    }
+    if (!RESTRICTED_METHODS.has(method) && !UNRESTRICTED_METHODS.has(method)) {
+      throw new Error(`Unsupported method: ${method}`);
+    }
+    if (this.connectionManager.getStatus() !== "connected" /* CONNECTED */) {
+      throw new Error("Not connected to QRL Wallet");
+    }
+    const id = ++requestCounter;
+    return new Promise((resolve, reject) => {
+      const pending = {
+        id,
+        method,
+        params,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      };
+      this.pendingRequests.set(id, pending);
+      const timeout = setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`Request timeout: ${method} (${REQUEST_TIMEOUT_MS}ms)`));
+        }
+      }, REQUEST_TIMEOUT_MS);
+      const originalResolve = pending.resolve;
+      const originalReject = pending.reject;
+      pending.resolve = (result) => {
+        clearTimeout(timeout);
+        originalResolve(result);
+      };
+      pending.reject = (error2) => {
+        clearTimeout(timeout);
+        originalReject(error2);
+      };
+      this.connectionManager.sendJsonRpc({
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      });
+    });
+  }
+  /**
+   * Get the current connection status.
+   */
+  getStatus() {
+    return this.connectionManager.getStatus();
+  }
+  /**
+   * Get connected accounts.
+   */
+  getAccounts() {
+    return this.connectionManager.getAccounts();
+  }
+  /**
+   * Get the channel ID for this connection.
+   */
+  getChannelId() {
+    return this.connectionManager.getChannelId();
+  }
+  /**
+   * Check if connected and keys exchanged.
+   */
+  isConnected() {
+    return this.connectionManager.getStatus() === "connected" /* CONNECTED */;
+  }
+  /**
+   * Check if a stored session exists that can be reconnected.
+   */
+  hasStoredSession() {
+    return this.connectionManager.hasStoredSession();
+  }
+  /**
+   * Reset the connection and start a fresh pairing with a new channel.
+   * Use this when the user wants to create a new connection instead of
+   * reconnecting to an existing session.
+   */
+  async newConnection() {
+    for (const [, pending] of this.pendingRequests) {
+      pending.reject(new Error("Connection reset"));
+    }
+    this.pendingRequests.clear();
+    this.connectionManager.resetForNewChannel();
+    return this.getConnectionURI();
+  }
+  /**
+   * Disconnect from wallet and clean up.
+   */
+  disconnect() {
+    for (const [, pending] of this.pendingRequests) {
+      pending.reject(new Error("Disconnected"));
+    }
+    this.pendingRequests.clear();
+    this.connectionManager.disconnect();
+  }
+};
+export {
+  ConnectionManager,
+  ConnectionStatus,
+  DEFAULT_RELAY_URL,
+  ECIESClient,
+  KeyExchange,
+  KeyExchangeMessageType,
+  MessageType,
+  QRLConnectProvider as QRLConnect,
+  QRLConnectProvider,
+  RESTRICTED_METHODS,
+  SocketClient,
+  UNRESTRICTED_METHODS,
+  generateConnectionURI,
+  getAppStoreUrl,
+  isMobileBrowser,
+  parseConnectionURI
+};