@qrlwallet/connect 0.1.0 → 3.0.0

package/dist/index.mjs

@@ -5,94 +5,153 @@ import EventEmitter4 from "eventemitter3";
 import EventEmitter3 from "eventemitter3";
 import { v4 as uuidv4 } from "uuid";
 
-// src/ECIESClient.ts
-import { PrivateKey, decrypt, encrypt } from "eciesjs";
+// src/KeyExchange.ts
+import EventEmitter from "eventemitter3";
 
-// src/utils/logger.ts
-var debugEnabled = false;
-function setDebug(enabled) {
-  debugEnabled = enabled;
+// src/PQCrypto.ts
+import { ml_kem768 } from "@noble/post-quantum/ml-kem.js";
+var textEncoder = new TextEncoder();
+var LABEL = textEncoder.encode("pq-pair/v1");
+var LABEL_AEAD_SUFFIX = textEncoder.encode(" aead");
+var DIR_DAPP_TX = new Uint8Array([0, 0, 0, 1]);
+var DIR_WALLET_TX = new Uint8Array([0, 0, 0, 2]);
+var ML_KEM_768_CT_LEN = 1088;
+var AEAD_KEY_LEN = 32;
+function subtle() {
+  const c = globalThis.crypto;
+  if (!c || !c.subtle) {
+    throw new Error("PQCrypto: WebCrypto SubtleCrypto is not available in this environment");
+  }
+  return c.subtle;
 }
-function log(tag, ...args) {
-  if (debugEnabled) {
-    console.log(`[QRLConnect:${tag}]`, ...args);
-  }
+function bs(u) {
+  return u;
 }
-function warn(tag, ...args) {
-  console.warn(`[QRLConnect:${tag}]`, ...args);
+function kemKeygen() {
+  const { publicKey, secretKey } = ml_kem768.keygen();
+  return { pk: publicKey, sk: secretKey };
 }
-function error(tag, ...args) {
-  console.error(`[QRLConnect:${tag}]`, ...args);
+function kemEncaps(pk) {
+  const { cipherText, sharedSecret } = ml_kem768.encapsulate(pk);
+  return { ct: cipherText, ss: sharedSecret };
+}
+function kemDecaps(sk, ct) {
+  return ml_kem768.decapsulate(ct, sk);
+}
+async function transcriptHash(cid, pk, ct) {
+  const buf = concat(LABEL, cid, pk, ct);
+  return new Uint8Array(await subtle().digest("SHA-256", bs(buf)));
+}
+async function deriveAeadKey(ss, htx) {
+  const ikm = await subtle().importKey("raw", bs(ss), "HKDF", false, ["deriveKey"]);
+  const info = concat(LABEL, LABEL_AEAD_SUFFIX, htx);
+  return subtle().deriveKey(
+    { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(32), info: bs(info) },
+    ikm,
+    { name: "AES-GCM", length: 256 },
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+async function importRawAeadKey(raw) {
+  if (raw.length !== AEAD_KEY_LEN) {
+    throw new Error(`PQCrypto: raw AEAD key must be ${AEAD_KEY_LEN} bytes`);
+  }
+  return subtle().importKey("raw", bs(raw), { name: "AES-GCM", length: 256 }, true, [
+    "encrypt",
+    "decrypt"
+  ]);
+}
+async function exportRawAeadKey(key) {
+  const buf = await subtle().exportKey("raw", key);
+  return new Uint8Array(buf);
+}
+function nonce(dir, seq) {
+  if (dir.length !== 4) {
+    throw new Error("PQCrypto: direction tag must be 4 bytes");
+  }
+  const n = new Uint8Array(12);
+  n.set(dir, 0);
+  new DataView(n.buffer, n.byteOffset, n.byteLength).setBigUint64(4, BigInt(seq), true);
+  return n;
+}
+function aad(htx, seq) {
+  const out = new Uint8Array(htx.length + 8);
+  out.set(htx, 0);
+  new DataView(out.buffer, out.byteOffset, out.byteLength).setBigUint64(
+    htx.length,
+    BigInt(seq),
+    true
+  );
+  return out;
+}
+async function seal(key, dir, seq, htx, pt) {
+  const ct = await subtle().encrypt(
+    { name: "AES-GCM", iv: bs(nonce(dir, seq)), additionalData: bs(aad(htx, seq)) },
+    key,
+    bs(pt)
+  );
+  return new Uint8Array(ct);
+}
+async function open(key, dir, seq, htx, ct) {
+  const pt = await subtle().decrypt(
+    { name: "AES-GCM", iv: bs(nonce(dir, seq)), additionalData: bs(aad(htx, seq)) },
+    key,
+    bs(ct)
+  );
+  return new Uint8Array(pt);
+}
+function zeroize(b) {
+  b.fill(0);
+}
+function concat(...parts) {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
 }
-
-// src/ECIESClient.ts
 function toBase64(bytes) {
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
+  const CHUNK = 32768;
+  let bin = "";
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    const slice = bytes.subarray(i, i + CHUNK);
+    bin += String.fromCharCode.apply(null, slice);
   }
-  return btoa(binary);
+  return btoa(bin);
 }
-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;
+function fromBase64(b64) {
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function constantTimeEquals(a, b) {
+  if (a.length !== b.length) return false;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) d |= a[i] ^ b[i];
+  return d === 0;
 }
-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 PROTOCOL_VERSION = 2;
 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 RECONNECT_WALLET_PROBE_MS = 12 * 1e3;
 var RESTRICTED_METHODS = /* @__PURE__ */ new Set([
   "qrl_requestAccounts",
   "qrl_sendTransaction",
   "qrl_signTransaction",
-  "qrl_sign",
-  "personal_sign",
+  "qrl_signMessage",
   "qrl_signTypedData",
-  "qrl_signTypedData_v3",
-  "qrl_signTypedData_v4",
   "wallet_addQrlChain",
   "wallet_switchQrlChain"
 ]);
@@ -165,154 +224,300 @@ var ConnectionStatus = /* @__PURE__ */ ((ConnectionStatus2) => {
   return ConnectionStatus2;
 })(ConnectionStatus || {});
 
+// 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/KeyExchange.ts
+var textEncoder2 = new TextEncoder();
+var textDecoder = new TextDecoder();
+var HELLO_WALLET = textEncoder2.encode("hello/wallet/v1");
+var HELLO_DAPP = textEncoder2.encode("hello/dapp/v1");
 var KeyExchange = class extends EventEmitter {
-  constructor(ecies, isOriginator, otherPublicKey) {
+  constructor(isOriginator, restored) {
     super();
-    this.otherPublicKey = null;
-    this.keysExchanged = false;
+    this.keypair = null;
+    this.session = null;
+    this.step = "key_handshake_SYN" /* SYN */;
     this.awaitingSynAck = false;
     this.awaitingAck = false;
-    this.step = "key_handshake_SYN" /* SYN */;
-    this.ecies = ecies;
+    this.keysExchanged = false;
     this.isOriginator = isOriginator;
-    if (otherPublicKey) {
-      this.otherPublicKey = otherPublicKey;
+    if (restored) {
+      this.session = restored;
       this.keysExchanged = true;
-      log("KeyExchange", "Restored with existing other public key");
+      this.step = "key_handshake_ACK" /* ACK */;
+      log("KeyExchange", "Hydrated from persisted session");
     }
   }
-  /** Get the SYN message to start the handshake (originator/dApp side). */
-  createSYN() {
+  /**
+   * Originator (dApp) side: begin a fresh handshake by generating an
+   * ephemeral ML-KEM-768 keypair. Returns pk to embed in the QR URI.
+   */
+  initiate() {
+    if (!this.isOriginator) {
+      throw new Error("KeyExchange: responder cannot initiate");
+    }
+    this.resetInternal(false);
+    this.keypair = kemKeygen();
     this.step = "key_handshake_SYN" /* SYN */;
     this.awaitingSynAck = true;
     this.emit("step_change", this.step);
+    return this.keypair.pk;
+  }
+  /**
+   * Originator: handle a SYNACK received over the relay.
+   * Returns an ACK wire message to send, or null if the SYNACK was a
+   * duplicate (handshake already complete).
+   */
+  async onSynAck(cid, msg) {
+    if (!this.isOriginator) {
+      warn("KeyExchange", "Responder received SYNACK \u2014 ignoring");
+      return null;
+    }
+    if (!this.awaitingSynAck || !this.keypair) {
+      return null;
+    }
+    this.awaitingSynAck = false;
+    const ct = fromBase64(msg.ct);
+    const c0 = fromBase64(msg.c0);
+    if (ct.length !== ML_KEM_768_CT_LEN) {
+      throw new Error(`KeyExchange: bad ct length ${ct.length}`);
+    }
+    const ss = kemDecaps(this.keypair.sk, ct);
+    const htx = await transcriptHash(cid, this.keypair.pk, ct);
+    const key = await deriveAeadKey(ss, htx);
+    let hello;
+    try {
+      hello = await open(key, DIR_WALLET_TX, 0, htx, c0);
+    } catch {
+      throw new Error(
+        "KeyExchange: wallet hello AEAD tag failed (tampered SYNACK, wrong QR, or protocol mismatch)"
+      );
+    }
+    if (!constantTimeEquals(hello, HELLO_WALLET)) {
+      throw new Error("KeyExchange: wallet hello mismatch");
+    }
+    zeroize(ss);
+    zeroize(this.keypair.sk);
+    this.keypair = null;
+    const c1 = await seal(key, DIR_DAPP_TX, 0, htx, HELLO_DAPP);
+    this.session = {
+      cid,
+      key,
+      htx,
+      sendDir: DIR_DAPP_TX,
+      recvDir: DIR_WALLET_TX,
+      sendSeq: 1,
+      recvSeq: 1
+    };
+    this.keysExchanged = true;
+    this.step = "key_handshake_ACK" /* ACK */;
+    this.emit("keys_exchanged");
+    this.emit("step_change", this.step);
     return {
-      type: "key_handshake_SYN" /* SYN */,
-      pubkey: this.ecies.getPublicKey(),
+      type: "key_handshake_ACK" /* ACK */,
+      c1: toBase64(c1),
       v: PROTOCOL_VERSION
     };
   }
   /**
-   * Process an incoming key exchange message.
-   * Returns a response message to send back, or null if handshake is complete.
+   * Responder (wallet) side: begin handshake from a scanned QR.
+   * Returns the SYNACK wire message to emit on the relay.
    */
-  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;
+  async receiveQR(cid, pk) {
+    if (this.isOriginator) {
+      throw new Error("KeyExchange: originator cannot consume a QR");
     }
+    this.resetInternal(false);
+    const { ct, ss } = kemEncaps(pk);
+    const htx = await transcriptHash(cid, pk, ct);
+    const key = await deriveAeadKey(ss, htx);
+    const c0 = await seal(key, DIR_WALLET_TX, 0, htx, HELLO_WALLET);
+    zeroize(ss);
+    this.session = {
+      cid,
+      key,
+      htx,
+      sendDir: DIR_WALLET_TX,
+      recvDir: DIR_DAPP_TX,
+      sendSeq: 1,
+      recvSeq: 1
+    };
+    this.awaitingAck = true;
+    this.step = "key_handshake_SYNACK" /* SYNACK */;
+    this.emit("step_change", this.step);
+    return {
+      type: "key_handshake_SYNACK" /* SYNACK */,
+      ct: toBase64(ct),
+      c0: toBase64(c0),
+      v: PROTOCOL_VERSION
+    };
   }
-  /** Encrypt a message for the counterparty. */
-  encryptMessage(data) {
-    if (!this.otherPublicKey) {
-      throw new Error("Cannot encrypt: key exchange not complete");
+  /**
+   * Responder: verify an incoming ACK and finalize the session.
+   * Duplicates are silently ignored (handshake is idempotent).
+   */
+  async onAck(msg) {
+    if (this.isOriginator) {
+      warn("KeyExchange", "Originator received ACK \u2014 ignoring");
+      return;
     }
-    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). */
+    if (!this.awaitingAck) {
+      return;
+    }
+    if (!this.session) {
+      throw new Error("KeyExchange: onAck called without a session");
+    }
+    this.awaitingAck = false;
+    const c1 = fromBase64(msg.c1);
+    let hello;
+    try {
+      hello = await open(this.session.key, DIR_DAPP_TX, 0, this.session.htx, c1);
+    } catch {
+      throw new Error("KeyExchange: dApp hello AEAD tag failed");
+    }
+    if (!constantTimeEquals(hello, HELLO_DAPP)) {
+      throw new Error("KeyExchange: dApp hello mismatch");
+    }
+    this.keysExchanged = true;
+    this.step = "key_handshake_ACK" /* ACK */;
+    this.emit("keys_exchanged");
+  }
+  /** Encrypt a string for the counterparty. Returns base64. */
+  async encryptMessage(data) {
+    if (!this.session) {
+      throw new Error("KeyExchange: cannot encrypt \u2014 session not established");
+    }
+    const pt = textEncoder2.encode(data);
+    const ct = await seal(
+      this.session.key,
+      this.session.sendDir,
+      this.session.sendSeq,
+      this.session.htx,
+      pt
+    );
+    this.session.sendSeq++;
+    return toBase64(ct);
+  }
+  /** Decrypt a base64 ciphertext from the counterparty. */
+  async decryptMessage(b64) {
+    if (!this.session) {
+      throw new Error("KeyExchange: cannot decrypt \u2014 session not established");
+    }
+    const ct = fromBase64(b64);
+    const pt = await open(
+      this.session.key,
+      this.session.recvDir,
+      this.session.recvSeq,
+      this.session.htx,
+      ct
+    );
+    this.session.recvSeq++;
+    return textDecoder.decode(pt);
+  }
+  /** Reset all state for a fresh handshake. Zeroes any live secret-key buffer. */
   reset() {
-    this.otherPublicKey = null;
+    this.resetInternal(true);
+  }
+  resetInternal(emit) {
+    if (this.keypair) {
+      zeroize(this.keypair.sk);
+      this.keypair = null;
+    }
+    this.session = null;
     this.keysExchanged = false;
     this.awaitingSynAck = false;
     this.awaitingAck = false;
     this.step = "key_handshake_SYN" /* SYN */;
-    log("KeyExchange", "Reset for fresh handshake");
+    if (emit) this.emit("step_change", this.step);
   }
   areKeysExchanged() {
     return this.keysExchanged;
   }
-  getOtherPublicKey() {
-    return this.otherPublicKey;
+  getSession() {
+    return this.session;
   }
   getCurrentStep() {
     return this.step;
   }
+  /** Export the current session as a JSON-safe persisted record. */
+  async exportPersisted() {
+    if (!this.session) return null;
+    return {
+      cid: toBase64(this.session.cid),
+      kAeadRaw: toBase64(await exportRawAeadKey(this.session.key)),
+      htx: toBase64(this.session.htx),
+      sendDir: toBase64(this.session.sendDir),
+      recvDir: toBase64(this.session.recvDir),
+      sendSeq: this.session.sendSeq,
+      recvSeq: this.session.recvSeq
+    };
+  }
+  /** Rehydrate a Session from its persisted form. */
+  static async sessionFromPersisted(p) {
+    const key = await importRawAeadKey(fromBase64(p.kAeadRaw));
+    return {
+      cid: fromBase64(p.cid),
+      key,
+      htx: fromBase64(p.htx),
+      sendDir: fromBase64(p.sendDir),
+      recvDir: fromBase64(p.recvDir),
+      sendSeq: p.sendSeq,
+      recvSeq: p.recvSeq
+    };
+  }
 };
 
 // src/SocketClient.ts
 import { io } from "socket.io-client";
 import EventEmitter2 from "eventemitter3";
+var PENDING_JOIN_TIMEOUT_MS = 2e4;
 var SocketClient = class extends EventEmitter2 {
   constructor(relayUrl, clientType) {
     super();
     this.socket = null;
     this.channelId = null;
+    // The dApp's own PK (base64) that must be uploaded with every join
+    // attempt so the relay can bind it to the channel. Wallet-side leaves
+    // this undefined.
+    this.publicKeyBase64 = null;
     this.seq = 0;
     this.pendingJoin = null;
     this.relayUrl = relayUrl;
     this.clientType = clientType;
   }
+  /**
+   * dApp-only: stash the PK so it gets uploaded on every join_channel
+   * attempt (including auto-rejoins after reconnect).
+   */
+  setPublicKey(publicKeyBase64) {
+    if (this.clientType !== "dapp") {
+      throw new Error("SocketClient.setPublicKey is only valid for dApp clients");
+    }
+    this.publicKeyBase64 = publicKeyBase64;
+  }
   /**
    * Connect to the relay server.
    */
   connect() {
-    if (this.socket?.connected) return;
+    if (this.socket) {
+      if (!this.socket.connected) this.socket.connect();
+      return;
+    }
     log("Socket", `Connecting to ${this.relayUrl}`);
     this.socket = io(this.relayUrl, {
       path: RELAY_PATH,
@@ -329,17 +534,11 @@ var SocketClient = class extends EventEmitter2 {
       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");
+          this.settlePendingJoin(reconnectChannelId, { result });
+          this.emit("reconnected", result);
         }).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;
-          }
+          this.settlePendingJoin(reconnectChannelId, { error: reconnectErr });
           error("Socket", `Rejoin failed: ${reconnectErr.message}`);
           this.emit("error", reconnectErr);
         });
@@ -363,7 +562,24 @@ var SocketClient = class extends EventEmitter2 {
     });
   }
   /**
-   * Join a relay channel.
+   * Resolve or reject the currently-pending `joinChannel` promise, if it
+   * matches the given channelId. Clears the watchdog timer on settle so
+   * it doesn't fire after the fact.
+   */
+  settlePendingJoin(channelId, outcome) {
+    if (!this.pendingJoin || this.pendingJoin.channelId !== channelId) return;
+    clearTimeout(this.pendingJoin.watchdog);
+    const pending = this.pendingJoin;
+    this.pendingJoin = null;
+    if ("result" in outcome) {
+      pending.resolve(outcome.result);
+    } else {
+      pending.reject(outcome.error);
+    }
+  }
+  /**
+   * Join a relay channel. Resolves with any buffered messages plus the
+   * dApp's public key bound to the channel (for wallet joins).
    */
   async joinChannel(channelId) {
     if (!this.socket) {
@@ -377,6 +593,7 @@ var SocketClient = class extends EventEmitter2 {
       if (this.pendingJoin.channelId === channelId) {
         return this.pendingJoin.promise;
       }
+      clearTimeout(this.pendingJoin.watchdog);
       this.pendingJoin.reject(new Error("Join request superseded by a newer channel"));
       this.pendingJoin = null;
     }
@@ -386,11 +603,17 @@ var SocketClient = class extends EventEmitter2 {
       resolvePending = resolve;
       rejectPending = reject;
     });
+    const watchdog = setTimeout(() => {
+      this.settlePendingJoin(channelId, {
+        error: new Error(`joinChannel timed out after ${PENDING_JOIN_TIMEOUT_MS}ms`)
+      });
+    }, PENDING_JOIN_TIMEOUT_MS);
     this.pendingJoin = {
       channelId,
       promise,
       resolve: resolvePending,
-      reject: rejectPending
+      reject: rejectPending,
+      watchdog
     };
     return promise;
   }
@@ -400,13 +623,22 @@ var SocketClient = class extends EventEmitter2 {
         reject(new Error("Socket not connected"));
         return;
       }
+      const payload = { channelId, clientType: this.clientType };
+      if (this.clientType === "dapp" && this.publicKeyBase64) {
+        payload.publicKey = this.publicKeyBase64;
+      }
       this.socket.emit(
         "join_channel",
-        { channelId, clientType: this.clientType },
+        payload,
         (response) => {
           if (response.success) {
             log("Socket", `Joined channel ${channelId}`);
-            resolve({ bufferedMessages: response.bufferedMessages || [] });
+            resolve({
+              bufferedMessages: response.bufferedMessages || [],
+              channelPublicKey: response.channelPublicKey ?? null,
+              participants: response.participants || [],
+              terminated: response.terminated === true
+            });
           } else {
             error("Socket", `Failed to join channel: ${response.error}`);
             reject(new Error(response.error || "Failed to join channel"));
@@ -443,6 +675,7 @@ var SocketClient = class extends EventEmitter2 {
    */
   leaveChannel() {
     if (this.pendingJoin) {
+      clearTimeout(this.pendingJoin.watchdog);
       this.pendingJoin.reject(new Error("Channel left before join completed"));
       this.pendingJoin = null;
     }
@@ -456,6 +689,7 @@ var SocketClient = class extends EventEmitter2 {
    */
   disconnect() {
     if (this.pendingJoin) {
+      clearTimeout(this.pendingJoin.watchdog);
       this.pendingJoin.reject(new Error("Socket disconnected before join completed"));
       this.pendingJoin = null;
     }
@@ -475,111 +709,267 @@ var SocketClient = class extends EventEmitter2 {
   }
 };
 
+// src/utils/base45.ts
+var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+var DECODE = (() => {
+  const table = new Int8Array(128).fill(-1);
+  for (let i = 0; i < ALPHABET.length; i++) {
+    table[ALPHABET.charCodeAt(i)] = i;
+  }
+  return table;
+})();
+function decodeChar(charCode) {
+  if (charCode < 0 || charCode >= 128) return -1;
+  return DECODE[charCode];
+}
+function base45Encode(bytes) {
+  const n = bytes.length;
+  let out = "";
+  let i = 0;
+  while (i + 2 <= n) {
+    const v = bytes[i] << 8 | bytes[i + 1];
+    const c2 = Math.floor(v / 2025);
+    const r = v - c2 * 2025;
+    const c1 = Math.floor(r / 45);
+    const c0 = r - c1 * 45;
+    out += ALPHABET[c0] + ALPHABET[c1] + ALPHABET[c2];
+    i += 2;
+  }
+  if (i < n) {
+    const v = bytes[i];
+    const c1 = Math.floor(v / 45);
+    const c0 = v - c1 * 45;
+    out += ALPHABET[c0] + ALPHABET[c1];
+  }
+  return out;
+}
+function base45Decode(s) {
+  const len = s.length;
+  if (len === 0) return new Uint8Array(0);
+  const full = Math.floor(len / 3);
+  const tail = len - full * 3;
+  if (tail !== 0 && tail !== 2) {
+    throw new Error("base45: invalid input length");
+  }
+  const outLen = full * 2 + (tail === 2 ? 1 : 0);
+  const out = new Uint8Array(outLen);
+  for (let g = 0; g < full; g++) {
+    const d0 = decodeChar(s.charCodeAt(g * 3));
+    const d1 = decodeChar(s.charCodeAt(g * 3 + 1));
+    const d2 = decodeChar(s.charCodeAt(g * 3 + 2));
+    if (d0 < 0 || d1 < 0 || d2 < 0) {
+      throw new Error("base45: invalid character");
+    }
+    const v = d0 + d1 * 45 + d2 * 2025;
+    if (v > 65535) {
+      throw new Error("base45: decoded group exceeds 0xFFFF");
+    }
+    out[g * 2] = v >> 8 & 255;
+    out[g * 2 + 1] = v & 255;
+  }
+  if (tail === 2) {
+    const d0 = decodeChar(s.charCodeAt(full * 3));
+    const d1 = decodeChar(s.charCodeAt(full * 3 + 1));
+    if (d0 < 0 || d1 < 0) {
+      throw new Error("base45: invalid character");
+    }
+    const v = d0 + d1 * 45;
+    if (v > 255) {
+      throw new Error("base45: decoded byte exceeds 0xFF");
+    }
+    out[outLen - 1] = v;
+  }
+  return out;
+}
+
 // 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()}`;
+var MAGIC = new Uint8Array([80, 81, 80, 50]);
+var FP_LABEL = new TextEncoder().encode("pq-fp/v2");
+var CID_LEN = 16;
+var FP_LEN = 32;
+var BLOB_LEN = 4 + CID_LEN + FP_LEN;
+function bs2(u) {
+  return u;
+}
+async function computeFingerprint(cid, pk) {
+  if (cid.length !== CID_LEN) {
+    throw new Error(`qrUri: cid must be ${CID_LEN} bytes`);
+  }
+  const c = globalThis.crypto;
+  if (!c || !c.subtle) {
+    throw new Error("qrUri: WebCrypto SubtleCrypto is not available");
+  }
+  const buf = new Uint8Array(FP_LABEL.length + cid.length + pk.length);
+  buf.set(FP_LABEL, 0);
+  buf.set(cid, FP_LABEL.length);
+  buf.set(pk, FP_LABEL.length + cid.length);
+  const digest = await c.subtle.digest("SHA-256", bs2(buf));
+  return new Uint8Array(digest);
+}
+function fingerprintEquals(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+async function generateConnectionURI(cid, pk, relayUrl) {
+  if (cid.length !== CID_LEN) {
+    throw new Error(`qrUri: cid must be ${CID_LEN} bytes (got ${cid.length})`);
+  }
+  const fp = await computeFingerprint(cid, pk);
+  const blob = new Uint8Array(BLOB_LEN);
+  blob.set(MAGIC, 0);
+  blob.set(cid, 4);
+  blob.set(fp, 4 + CID_LEN);
+  const params = new URLSearchParams({ q: base45Encode(blob) });
+  if (relayUrl) params.set("r", relayUrl);
+  return `qrlconnect://?${params.toString()}`;
+}
+var PQP1_MAGIC = new Uint8Array([80, 81, 80, 49]);
+function startsWith(buf, prefix) {
+  if (buf.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (buf[i] !== prefix[i]) return false;
+  }
+  return true;
 }
-function parseConnectionURI(uri) {
+async function parseConnectionURI(uri) {
+  if (typeof uri !== "string" || uri.length === 0) {
+    throw new Error("qrUri: empty URI");
+  }
+  if (!/^qrlconnect:/i.test(uri)) {
+    throw new Error("qrUri: not a qrlconnect URI");
+  }
+  let params;
   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
-    };
+    const swapped = new URL(uri.replace(/^qrlconnect:\/?\/?/i, "https://qrlconnect/"));
+    params = swapped.searchParams;
   } catch {
-    return null;
+    throw new Error("qrUri: malformed URI");
+  }
+  if (params.has("channelId") || params.has("pubKey")) {
+    throw new Error(
+      "qrUri: legacy v1 URI detected \u2014 this wallet and this dApp must both run protocol v2"
+    );
+  }
+  const q = params.get("q");
+  if (!q) {
+    throw new Error("qrUri: missing q parameter");
+  }
+  let blob;
+  try {
+    blob = base45Decode(q);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`qrUri: base45 decode failed: ${msg}`);
+  }
+  if (blob.length !== BLOB_LEN) {
+    if (blob.length === 1208 && startsWith(blob, PQP1_MAGIC)) {
+      throw new Error("qrUri: legacy PQP1 URI detected \u2014 regenerate the QR with a v2.0+ dApp SDK");
+    }
+    throw new Error(`qrUri: expected ${BLOB_LEN}-byte blob, got ${blob.length}`);
+  }
+  if (!startsWith(blob, MAGIC)) {
+    throw new Error("qrUri: bad PQP2 magic");
+  }
+  const cid = blob.slice(4, 4 + CID_LEN);
+  const fp = blob.slice(4 + CID_LEN, 4 + CID_LEN + FP_LEN);
+  const relayUrl = params.get("r") || void 0;
+  return { cid, fp, relayUrl };
+}
+function cidToString(cid) {
+  if (cid.length !== CID_LEN) {
+    throw new Error(`cidToString: expected ${CID_LEN}-byte cid`);
+  }
+  let hex = "";
+  for (let i = 0; i < CID_LEN; i++) {
+    hex += cid[i].toString(16).padStart(2, "0");
+  }
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function cidFromString(s) {
+  const hex = s.replace(/-/g, "");
+  if (!/^[0-9a-f]{32}$/i.test(hex)) {
+    throw new Error("cidFromString: not a 128-bit hex string");
+  }
+  const out = new Uint8Array(CID_LEN);
+  for (let i = 0; i < CID_LEN; i++) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
   }
+  return out;
+}
+function cidRandom() {
+  const c = globalThis.crypto;
+  if (!c || typeof c.getRandomValues !== "function") {
+    throw new Error("qrUri: crypto.getRandomValues is not available");
+  }
+  return c.getRandomValues(new Uint8Array(CID_LEN));
 }
 
 // src/ConnectionManager.ts
 var DAPP_PARTICIPANT_CONFLICT_ERROR_MSG = "dapp participant is already connected";
+var TERMINATE_SEND_TIMEOUT_MS = 800;
 var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
   constructor(options) {
     super();
+    this.keyExchange = null;
     this.status = "disconnected" /* DISCONNECTED */;
     this.connectedAccounts = [];
     this.unresponsiveTimer = null;
-    this.synRetryTimer = null;
+    this.reconnectProbeTimer = null;
     this.failedReconnects = 0;
-    this.synSent = false;
-    this.synAttempts = 0;
     this.walletPresent = false;
+    this.pendingRestore = null;
+    this.messageQueue = Promise.resolve();
     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}`);
+    const stored = this.readStoredSession();
+    if (stored) {
+      this.channelId = stored.channelId;
+      this.connectedAccounts = stored.connectedAccounts;
+      this.chainId = stored.chainId;
+      this.dappMetadata = stored.dappMetadata;
+      this.pendingRestore = stored;
+      log("ConnectionManager", `Found persisted 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();
   }
+  // ── Setup ──────────────────────────────────────────────────
   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()) {
+    this.socketClient.on("reconnected", (result) => {
+      if (result?.terminated) {
+        log("ConnectionManager", "Channel terminated, observed on auto-reconnect");
+        this.handleSessionTerminated();
+        return;
+      }
+      if (result) {
+        this.walletPresent = result.participants.includes("wallet");
+      }
+      if (this.keyExchange?.areKeysExchanged()) {
         if (this.walletPresent) {
+          this.clearReconnectProbe();
           this.setStatus("connected" /* CONNECTED */);
           this.failedReconnects = 0;
         } else {
           this.setStatus("waiting" /* WAITING */);
+          this.armReconnectProbe();
         }
-        this.synAttempts = 0;
-        this.clearSynRetryTimer();
       } else {
-        this.sendSYN();
+        this.setStatus("waiting" /* WAITING */);
       }
     });
-    this.socketClient.on("disconnected", (_reason) => {
+    this.socketClient.on("disconnected", () => {
       this.walletPresent = false;
-      this.synSent = false;
-      this.clearSynRetryTimer();
       if (this.status === "connected" /* CONNECTED */) {
         this.setStatus("reconnecting" /* RECONNECTING */);
         this.failedReconnects++;
@@ -589,7 +979,7 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       }
     });
     this.socketClient.on("message", (data) => {
-      this.handleRelayMessage(data);
+      this.enqueueRelayMessage(data);
     });
     this.socketClient.on("error", (err) => {
       this.emit("error", err);
@@ -599,20 +989,21 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
         this.walletPresent = true;
         log("ConnectionManager", "Wallet joined channel");
         this.clearUnresponsiveTimer();
-        if (this.keyExchange.areKeysExchanged()) {
+        this.clearReconnectProbe();
+        if (this.keyExchange?.areKeysExchanged()) {
           this.failedReconnects = 0;
           this.setStatus("connected" /* CONNECTED */);
-        } else if (!this.synSent) {
-          this.sendSYN();
         }
       }
+      if (data.event === "close") {
+        log("ConnectionManager", "Wallet closed the channel (explicit terminate)");
+        this.handleSessionTerminated();
+        return;
+      }
       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 */) {
+          if (this.keyExchange?.areKeysExchanged() && (this.status === "connected" /* CONNECTED */ || this.status === "reconnecting" /* RECONNECTING */)) {
             this.setStatus("waiting" /* WAITING */);
           }
           log("ConnectionManager", "Wallet left channel");
@@ -621,15 +1012,15 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     });
   }
   setupKeyExchangeListeners() {
+    if (!this.keyExchange) return;
     this.keyExchange.on("keys_exchanged", () => {
       log("ConnectionManager", "Key exchange complete");
+      this.clearReconnectProbe();
       this.setStatus("connected" /* CONNECTED */);
       this.walletPresent = true;
-      this.synSent = false;
-      this.synAttempts = 0;
-      this.clearSynRetryTimer();
-      this.saveSession();
-      this.sendEncrypted({
+      this.failedReconnects = 0;
+      void this.persistSession();
+      void this.sendEncrypted({
         type: "originator_info" /* ORIGINATOR_INFO */,
         originatorInfo: {
           ...this.dappMetadata,
@@ -638,16 +1029,25 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       });
     });
   }
+  // ── Public API ─────────────────────────────────────────────
   /**
-   * Generate the connection URI and start listening for wallet connection.
+   * Generate a new v2 connection URI. Rotates channel id and keypair.
+   * Returns a `qrlconnect://?q=…` URI safe for QR-rendering or deep-link.
    */
   async getConnectionURI(retryOnConflict = true) {
     this.setStatus("connecting" /* CONNECTING */);
-    this.keyExchange.reset();
+    this.clearReconnectProbe();
+    this.pendingRestore = null;
     this.walletPresent = false;
-    this.synSent = false;
-    this.synAttempts = 0;
-    this.clearSynRetryTimer();
+    if (this.keyExchange) {
+      this.keyExchange.reset();
+    } else {
+      this.keyExchange = new KeyExchange(true);
+      this.setupKeyExchangeListeners();
+    }
+    const pk = this.keyExchange.initiate();
+    this.channelId = uuidv4();
+    this.socketClient.setPublicKey(toBase64(pk));
     this.socketClient.connect();
     try {
       await this.socketClient.joinChannel(this.channelId);
@@ -657,48 +1057,73 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
           "ConnectionManager",
           "Channel already has an active dApp participant. Rotating to a fresh channel."
         );
-        this.resetForNewChannel();
+        this.channelId = uuidv4();
         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}`);
+    const uri = await generateConnectionURI(
+      cidFromString(this.channelId),
+      pk,
+      this.relayUrl === DEFAULT_RELAY_URL ? void 0 : this.relayUrl
+    );
+    log("ConnectionManager", `Generated v2 connection URI for channel ${this.channelId}`);
     return uri;
   }
   /**
    * Reconnect to an existing session.
+   * Returns false if there is nothing to restore.
    */
   async reconnect() {
-    const session = this.loadSession();
-    if (!session) return false;
+    if (!this.pendingRestore) return false;
     this.setStatus("reconnecting" /* RECONNECTING */);
     this.walletPresent = false;
-    this.synSent = false;
-    this.synAttempts = 0;
-    this.clearSynRetryTimer();
+    try {
+      const session = await KeyExchange.sessionFromPersisted(this.pendingRestore.keyExchange);
+      this.keyExchange = new KeyExchange(true, session);
+      this.setupKeyExchangeListeners();
+    } catch (err) {
+      error("ConnectionManager", "Failed to hydrate persisted session:", err);
+      this.clearSession();
+      this.pendingRestore = null;
+      this.setStatus("disconnected" /* DISCONNECTED */);
+      return false;
+    }
+    return this.joinAndSettle();
+  }
+  /**
+   * (Re)open the socket, join the persisted channel, drain buffered relay
+   * messages, and settle status. Shared by the cold-restore reconnect() and
+   * the warm resume() path whose socket was torn down by the reconnect probe.
+   * Assumes channelId and a hydrated keyExchange are already in place, and
+   * that the caller has reset walletPresent + set RECONNECTING status.
+   */
+  async joinAndSettle() {
     this.socketClient.connect();
     try {
-      const { bufferedMessages } = await this.socketClient.joinChannel(this.channelId);
+      const { bufferedMessages, participants, terminated } = await this.socketClient.joinChannel(
+        this.channelId
+      );
+      if (terminated) {
+        log("ConnectionManager", "Stored session was terminated by the wallet; dropping it");
+        this.handleSessionTerminated();
+        return false;
+      }
+      if (participants.includes("wallet")) {
+        this.walletPresent = true;
+      }
       for (const msg of bufferedMessages) {
-        this.handleRelayMessage(msg);
+        this.enqueueRelayMessage(msg);
       }
-      if (this.keyExchange.areKeysExchanged() && this.walletPresent) {
+      await this.messageQueue;
+      if (this.keyExchange?.areKeysExchanged() && this.walletPresent) {
+        this.clearReconnectProbe();
         this.setStatus("connected" /* CONNECTED */);
-      } else if (this.keyExchange.areKeysExchanged()) {
-        this.setStatus("waiting" /* WAITING */);
       } else {
-        this.sendSYN();
+        this.setStatus("waiting" /* WAITING */);
+        this.armReconnectProbe();
       }
       return true;
     } catch (err) {
@@ -708,10 +1133,69 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     }
   }
   /**
-   * Send a JSON-RPC request to the wallet.
+   * Nudge the connection back to life after the dApp tab / wallet app was
+   * backgrounded. Idempotent and safe to call from visibilitychange / online
+   * / pageshow handlers. If a restored session has not yet been hydrated,
+   * runs the full reconnect(); otherwise just re-opens the socket, whose
+   * own connect handler re-joins the channel and drains the relay buffer.
+   */
+  resume() {
+    if (this.status === "connected" /* CONNECTED */) return;
+    if (this.pendingRestore && !this.keyExchange?.areKeysExchanged()) {
+      void this.reconnect();
+      return;
+    }
+    if (this.channelId && this.keyExchange?.areKeysExchanged()) {
+      if (this.socketClient.getChannelId()) {
+        this.socketClient.connect();
+      } else {
+        this.setStatus("reconnecting" /* RECONNECTING */);
+        this.walletPresent = false;
+        void this.joinAndSettle();
+      }
+    }
+  }
+  /**
+   * A session was terminated for good (wallet sent a relay 'close', or the
+   * join ack reported a tombstone). Clear local state and surface
+   * DISCONNECTED so the consumer drops to a fresh-pairing UI.
+   */
+  handleSessionTerminated() {
+    this.clearReconnectProbe();
+    this.clearUnresponsiveTimer();
+    this.walletPresent = false;
+    this.pendingRestore = null;
+    this.keyExchange = null;
+    this.socketClient.leaveChannel();
+    this.socketClient.disconnect();
+    this.clearSession();
+    this.setStatus("disconnected" /* DISCONNECTED */);
+  }
+  armReconnectProbe() {
+    this.clearReconnectProbe();
+    this.reconnectProbeTimer = setTimeout(() => {
+      this.reconnectProbeTimer = null;
+      if (this.walletPresent) return;
+      warn(
+        "ConnectionManager",
+        `No wallet rejoined within ${RECONNECT_WALLET_PROBE_MS}ms; treating reconnect as dead`
+      );
+      this.socketClient.leaveChannel();
+      this.socketClient.disconnect();
+      this.setStatus("disconnected" /* DISCONNECTED */);
+    }, RECONNECT_WALLET_PROBE_MS);
+  }
+  clearReconnectProbe() {
+    if (this.reconnectProbeTimer) {
+      clearTimeout(this.reconnectProbeTimer);
+      this.reconnectProbeTimer = null;
+    }
+  }
+  /**
+   * Send a JSON-RPC request to the wallet (async, fire-and-forget).
    */
   sendJsonRpc(request) {
-    if (!this.keyExchange.areKeysExchanged()) {
+    if (!this.keyExchange?.areKeysExchanged()) {
       throw new Error("Not connected: key exchange not complete");
     }
     this.sendEncrypted({
@@ -720,16 +1204,93 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       id: request.id,
       method: request.method,
       params: request.params
+    }).catch((err) => {
+      error("ConnectionManager", "Failed to send JSON-RPC:", err);
     });
     this.startUnresponsiveTimer();
   }
+  getStatus() {
+    return this.status;
+  }
+  getAccounts() {
+    return this.connectedAccounts;
+  }
+  getChainId() {
+    return this.chainId;
+  }
+  getChannelId() {
+    return this.channelId;
+  }
+  /** Check (sync) if a persisted session exists and has not expired. */
+  hasStoredSession() {
+    if (typeof localStorage === "undefined") return false;
+    try {
+      const raw = localStorage.getItem(this.storageKey);
+      if (!raw) return false;
+      const session = JSON.parse(raw);
+      if (session.version !== 2) return false;
+      return Date.now() - session.createdAt <= SESSION_TTL_MS;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Best-effort TERMINATE delivery before we tear the socket down. Without
+   * awaiting, the socket.disconnect() below would win the race against the
+   * outbound emit, the wallet would only see `participants_changed:
+   * disconnect` and enter its stale-session grace period instead of an
+   * instant disconnect. Mirrors the wallet side's pattern.
+   */
+  async flushTerminate() {
+    if (!this.keyExchange?.areKeysExchanged()) return;
+    const send = this.sendEncrypted({ type: "terminate" /* TERMINATE */ }).catch(() => {
+    });
+    const timeout = new Promise((resolve) => setTimeout(resolve, TERMINATE_SEND_TIMEOUT_MS));
+    await Promise.race([send, timeout]);
+  }
   /**
-   * Handle an incoming relay message.
+   * Reset to a fresh channel + keypair. Sends TERMINATE to any live peer,
+   * drops the persisted session, and prepares a clean state for
+   * getConnectionURI() to be called again.
    */
-  handleRelayMessage(data) {
+  async resetForNewChannel() {
+    this.clearUnresponsiveTimer();
+    this.clearReconnectProbe();
+    this.walletPresent = false;
+    await this.flushTerminate();
+    this.socketClient.leaveChannel();
+    this.socketClient.disconnect();
+    this.clearSession();
+    this.connectedAccounts = [];
+    this.pendingRestore = null;
+    this.channelId = uuidv4();
+    this.keyExchange = null;
+    this.socketClient = new SocketClient(this.relayUrl, "dapp");
+    this.setupSocketListeners();
+    this.setStatus("disconnected" /* DISCONNECTED */);
+  }
+  async disconnect() {
+    this.clearUnresponsiveTimer();
+    this.clearReconnectProbe();
+    this.walletPresent = false;
+    await this.flushTerminate();
+    this.socketClient.leaveChannel();
+    this.socketClient.disconnect();
+    this.setStatus("disconnected" /* DISCONNECTED */);
+    this.clearSession();
+    this.connectedAccounts = [];
+    this.pendingRestore = null;
+    this.keyExchange = null;
+  }
+  // ── Internals ──────────────────────────────────────────────
+  enqueueRelayMessage(data) {
+    this.messageQueue = this.messageQueue.then(() => this.handleRelayMessage(data)).catch((err) => error("ConnectionManager", "messageQueue handler error:", err));
+  }
+  async handleRelayMessage(data) {
     if (data.clientType === "wallet") {
       this.walletPresent = true;
-      if (this.keyExchange.areKeysExchanged() && this.status !== "connected" /* CONNECTED */) {
+      this.clearReconnectProbe();
+      if (this.keyExchange?.areKeysExchanged() && this.status !== "connected" /* CONNECTED */) {
         this.failedReconnects = 0;
         this.setStatus("connected" /* CONNECTED */);
       }
@@ -737,16 +1298,18 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     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
-        );
+      if (msg.type === "key_handshake_SYNACK" /* SYNACK */) {
+        await this.handleSynAck(message);
+        return;
+      }
+      if (msg.type === "key_handshake_SYN" /* SYN */ || msg.type === "key_handshake_ACK" /* ACK */) {
+        warn("ConnectionManager", `Unexpected ${msg.type} on dApp side \u2014 ignoring`);
         return;
       }
     }
-    if (typeof message === "string" && this.keyExchange.areKeysExchanged()) {
+    if (typeof message === "string" && this.keyExchange?.areKeysExchanged()) {
       try {
-        const decrypted = this.keyExchange.decryptMessage(message);
+        const decrypted = await this.keyExchange.decryptMessage(message);
         const parsed = JSON.parse(decrypted);
         this.handleDecryptedMessage(parsed);
       } catch (err) {
@@ -754,9 +1317,18 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       }
     }
   }
-  handleKeyExchangeMessage(msg) {
+  async handleSynAck(msg) {
+    if (!this.keyExchange) return;
     this.setStatus("key_exchange" /* KEY_EXCHANGE */);
-    const response = this.keyExchange.onMessage(msg);
+    let response;
+    try {
+      response = await this.keyExchange.onSynAck(cidFromString(this.channelId), msg);
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      error("ConnectionManager", "SYNACK processing failed:", e);
+      this.emit("error", e);
+      return;
+    }
     if (response) {
       this.sendPlaintext(response);
     }
@@ -773,17 +1345,13 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
         const chainChanged = this.chainId !== nextChainId;
         this.connectedAccounts = nextAccounts;
         this.chainId = nextChainId;
-        this.saveSession();
+        void this.persistSession();
         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);
-        }
+        if (accountsChanged) this.emit("accounts_changed", this.connectedAccounts);
+        if (chainChanged) this.emit("chain_changed", this.chainId);
         break;
       }
       case "jsonrpc" /* JSONRPC */: {
@@ -793,14 +1361,13 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       }
       case "terminate" /* TERMINATE */: {
         log("ConnectionManager", "Received terminate from wallet");
-        this.disconnect();
+        void 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,
@@ -810,20 +1377,16 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       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);
+  async sendEncrypted(message) {
+    if (!this.keyExchange?.areKeysExchanged()) {
+      throw new Error("sendEncrypted: not connected");
     }
+    const encrypted = await this.keyExchange.encryptMessage(JSON.stringify(message));
+    await this.socketClient.sendMessage({
+      id: this.channelId,
+      clientType: "dapp",
+      message: encrypted
+    });
   }
   startUnresponsiveTimer() {
     this.clearUnresponsiveTimer();
@@ -837,46 +1400,6 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       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;
@@ -889,105 +1412,44 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
   }
   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;
-    }
+    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() {
+  // ── Persistence ────────────────────────────────────────────
+  async persistSession() {
     if (typeof localStorage === "undefined") return;
+    if (!this.keyExchange) return;
+    const persistedKex = await this.keyExchange.exportPersisted();
+    if (!persistedKex) return;
     const session = {
+      version: 2,
       channelId: this.channelId,
-      privateKey: this.ecies.getPrivateKeyHex(),
-      otherPublicKey: this.keyExchange.getOtherPublicKey(),
+      keyExchange: persistedKex,
       dappMetadata: this.dappMetadata,
       connectedAccounts: this.connectedAccounts,
       chainId: this.chainId,
-      createdAt: Date.now(),
+      createdAt: this.pendingRestore?.createdAt ?? Date.now(),
       lastActivity: Date.now()
     };
-    localStorage.setItem(this.storageKey, JSON.stringify(session));
+    try {
+      localStorage.setItem(this.storageKey, JSON.stringify(session));
+    } catch (err) {
+      warn("ConnectionManager", "localStorage.setItem failed:", err);
+    }
   }
-  loadSession() {
+  readStoredSession() {
     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();
+      if (session.version !== 2) {
+        log("ConnectionManager", "Dropping legacy (pre-v2) session from storage");
+        localStorage.removeItem(this.storageKey);
+        return null;
+      }
+      if (!session.createdAt || Date.now() - session.createdAt > SESSION_TTL_MS) {
+        localStorage.removeItem(this.storageKey);
         return null;
       }
       return session;
@@ -1001,8 +1463,6 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
   }
 };
 _ConnectionManager.MAX_RECONNECT_FAILURES = 5;
-_ConnectionManager.SYN_RETRY_MS = 5e3;
-_ConnectionManager.MAX_SYN_ATTEMPTS = 6;
 var ConnectionManager = _ConnectionManager;
 
 // src/utils/platform.ts
@@ -1019,10 +1479,29 @@ function getAppStoreUrl() {
 
 // src/QRLConnectProvider.ts
 var requestCounter = 0;
+var QRL_CONNECT_PROVIDER_INFO = {
+  name: "MyQRLWallet (Mobile)",
+  rdns: "com.qrlwallet.connect",
+  icon: "data:image/png;base64,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"
+};
+var EIP6963_ANNOUNCE_EVENT = "eip6963:announceProvider";
+var EIP6963_REQUEST_EVENT = "eip6963:requestProvider";
+function generateUuid() {
+  if (typeof globalThis !== "undefined" && globalThis.crypto?.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
+  const r = (n) => Math.floor(Math.random() * n);
+  const hex = (n, len) => n.toString(16).padStart(len, "0");
+  return `${hex(r(4294967296), 8)}-${hex(r(65536), 4)}-${hex(16384 | r(4096), 4)}-${hex(32768 | r(16384), 4)}-${hex(r(4294967296), 8)}${hex(r(65536), 4)}`;
+}
 var QRLConnectProvider = class extends EventEmitter4 {
   constructor(options) {
     super();
     this.pendingRequests = /* @__PURE__ */ new Map();
+    this.eip6963Detail = null;
+    this.eip6963RequestListener = null;
+    this.resumeListener = null;
+    this.resumeDebounce = null;
     this.isQRLConnect = true;
     this.options = options;
     if (options.debug) {
@@ -1038,6 +1517,81 @@ var QRLConnectProvider = class extends EventEmitter4 {
     if (options.autoReconnect !== false) {
       this.connectionManager.reconnect();
     }
+    this.setupResumeListeners();
+    if (options.announceProvider !== false) {
+      this.startEip6963Announce();
+    }
+  }
+  startEip6963Announce() {
+    if (typeof window === "undefined" || typeof CustomEvent === "undefined") {
+      return;
+    }
+    const overrides = this.options.providerInfo ?? {};
+    this.eip6963Detail = Object.freeze({
+      info: Object.freeze({
+        uuid: generateUuid(),
+        name: overrides.name ?? QRL_CONNECT_PROVIDER_INFO.name,
+        icon: overrides.icon ?? QRL_CONNECT_PROVIDER_INFO.icon,
+        rdns: overrides.rdns ?? QRL_CONNECT_PROVIDER_INFO.rdns
+      }),
+      provider: this
+    });
+    const announce = () => {
+      if (!this.eip6963Detail) return;
+      window.dispatchEvent(new CustomEvent(EIP6963_ANNOUNCE_EVENT, { detail: this.eip6963Detail }));
+    };
+    this.eip6963RequestListener = announce;
+    window.addEventListener(EIP6963_REQUEST_EVENT, announce);
+    announce();
+  }
+  /**
+   * Re-open the relay socket when the dApp tab regains focus or the network
+   * comes back. Debounced because visibilitychange + online can fire together.
+   * No-op when already connected (ConnectionManager.resume guards that).
+   */
+  setupResumeListeners() {
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    if (this.resumeListener) return;
+    const resume = () => {
+      if (typeof document !== "undefined" && document.visibilityState === "hidden") return;
+      if (this.resumeDebounce) clearTimeout(this.resumeDebounce);
+      this.resumeDebounce = setTimeout(() => {
+        this.resumeDebounce = null;
+        this.connectionManager.resume();
+      }, 300);
+    };
+    this.resumeListener = resume;
+    document.addEventListener("visibilitychange", resume);
+    window.addEventListener("online", resume);
+    window.addEventListener("pageshow", resume);
+  }
+  /**
+   * Remove the foreground/online resume listeners. Called on disconnect so a
+   * torn-down session can't be silently revived by a later tab focus; the
+   * listeners are re-armed by getConnectionURI()/newConnection() if the same
+   * provider is re-paired. Safe in any env.
+   */
+  teardownResumeListeners() {
+    if (typeof window !== "undefined" && typeof document !== "undefined" && this.resumeListener) {
+      document.removeEventListener("visibilitychange", this.resumeListener);
+      window.removeEventListener("online", this.resumeListener);
+      window.removeEventListener("pageshow", this.resumeListener);
+    }
+    this.resumeListener = null;
+    if (this.resumeDebounce) {
+      clearTimeout(this.resumeDebounce);
+      this.resumeDebounce = null;
+    }
+  }
+  /**
+   * Stop announcing this provider over EIP-6963. Safe to call from any env.
+   */
+  stopEip6963Announce() {
+    if (typeof window !== "undefined" && this.eip6963RequestListener) {
+      window.removeEventListener(EIP6963_REQUEST_EVENT, this.eip6963RequestListener);
+    }
+    this.eip6963RequestListener = null;
+    this.eip6963Detail = null;
   }
   setupConnectionListeners() {
     this.connectionManager.on("status_changed", (status) => {
@@ -1095,6 +1649,7 @@ var QRLConnectProvider = class extends EventEmitter4 {
    * Generate a connection URI for QR code display or deep link redirect.
    */
   async getConnectionURI() {
+    this.setupResumeListeners();
     return this.connectionManager.getConnectionURI();
   }
   /**
@@ -1202,35 +1757,420 @@ var QRLConnectProvider = class extends EventEmitter4 {
       pending.reject(new Error("Connection reset"));
     }
     this.pendingRequests.clear();
-    this.connectionManager.resetForNewChannel();
+    await this.connectionManager.resetForNewChannel();
     return this.getConnectionURI();
   }
   /**
-   * Disconnect from wallet and clean up.
+   * Disconnect from wallet and clean up. Returns once the TERMINATE has
+   * either been flushed to the relay or the 800ms best-effort window has
+   * elapsed — the wallet gets an instant disconnect instead of landing in
+   * its stale-session grace period.
    */
-  disconnect() {
+  async disconnect() {
     for (const [, pending] of this.pendingRequests) {
       pending.reject(new Error("Disconnected"));
     }
     this.pendingRequests.clear();
-    this.connectionManager.disconnect();
+    this.teardownResumeListeners();
+    await this.connectionManager.disconnect();
   }
 };
+
+// src/signing/ctx.ts
+var SCHEME_VERSION_MSG = "QRL-SIGN-MSG-v1";
+var SCHEME_VERSION_TYPED = "QRL-SIGN-TYPED-v1";
+var SCHEME_TAG_MSG = new TextEncoder().encode(SCHEME_VERSION_MSG);
+var SCHEME_TAG_TYPED = new TextEncoder().encode(SCHEME_VERSION_TYPED);
+var DIGEST_LEN = 64;
+
+// src/signing/messageDigest.ts
+import { shake256 } from "@noble/hashes/sha3.js";
+
+// src/signing/bytes.ts
+function hexToBytes(hex) {
+  if (typeof hex !== "string") throw new Error("hex must be a string");
+  if (!/^0x([0-9a-fA-F]{2})*$/.test(hex)) {
+    throw new Error("hex must be 0x-prefixed even-length");
+  }
+  const n = (hex.length - 2) / 2;
+  const out = new Uint8Array(n);
+  for (let i = 0; i < n; i++) {
+    out[i] = parseInt(hex.slice(2 + i * 2, 4 + i * 2), 16);
+  }
+  return out;
+}
+function bytesToHex(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new Error("bytes must be a Uint8Array");
+  }
+  let s = "0x";
+  for (const v of bytes) s += v.toString(16).padStart(2, "0");
+  return s;
+}
+function concatBytes(...parts) {
+  return concatBytesArr(parts);
+}
+function concatBytesArr(parts) {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    out.set(p, off);
+    off += p.length;
+  }
+  return out;
+}
+
+// src/signing/messageDigest.ts
+function computeMessageDigest(messageBytes) {
+  if (!(messageBytes instanceof Uint8Array)) {
+    throw new Error("messageBytes must be a Uint8Array");
+  }
+  return shake256(concatBytes(SCHEME_TAG_MSG, messageBytes), { dkLen: DIGEST_LEN });
+}
+
+// src/signing/typedData.ts
+import { shake256 as shake2562 } from "@noble/hashes/sha3.js";
+var SLOT = 32;
+var ATOMIC_RE = /^(?:(address|bool|string|bytes)|(u?int)(\d+)|bytes(\d+)|(.+?)\[(\d*)\])$/;
+var MAX_TYPE_DEPTH = 12;
+function parseFieldType(type, types, depth = 0) {
+  if (depth > MAX_TYPE_DEPTH) throw new Error(`type nesting too deep: ${type}`);
+  if (Object.prototype.hasOwnProperty.call(types, type)) {
+    return { kind: "ref", name: type };
+  }
+  const m = ATOMIC_RE.exec(type);
+  if (!m) throw new Error(`unknown type: ${type}`);
+  const [, atomic, intKind, intWidthStr, bytesWidthStr, innerType, sizeStr] = m;
+  if (atomic) return { kind: atomic };
+  if (intKind) {
+    const width = Number(intWidthStr);
+    if (!Number.isInteger(width) || width < 8 || width > 256 || width % 8 !== 0) {
+      throw new Error(`invalid int width: ${type}`);
+    }
+    return { kind: intKind === "uint" ? "uintN" : "intN", width };
+  }
+  if (bytesWidthStr) {
+    const width = Number(bytesWidthStr);
+    if (!Number.isInteger(width) || width < 1 || width > 32) {
+      throw new Error(`invalid bytesN width: ${type}`);
+    }
+    return { kind: "bytesN", width };
+  }
+  if (innerType !== void 0) {
+    parseFieldType(innerType, types, depth + 1);
+    const size = sizeStr ? Number(sizeStr) : void 0;
+    if (sizeStr && (!Number.isInteger(size) || size <= 0)) {
+      throw new Error(`invalid array size: ${type}`);
+    }
+    return { kind: "array", inner: innerType, size };
+  }
+  throw new Error(`unhandled type: ${type}`);
+}
+function baseTypeName(type) {
+  return type.replace(/(\[\d*\])+$/, "");
+}
+function collectDependencies(primary, types) {
+  if (!Object.prototype.hasOwnProperty.call(types, primary)) {
+    throw new Error(`unknown primary type: ${primary}`);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (name, path) => {
+    if (path.includes(name)) {
+      throw new Error(`cyclic type reference: ${[...path, name].join(" -> ")}`);
+    }
+    if (visited.has(name)) return;
+    visited.add(name);
+    for (const f of types[name]) {
+      const base = baseTypeName(f.type);
+      if (Object.prototype.hasOwnProperty.call(types, base)) {
+        visit(base, [...path, name]);
+      }
+      parseFieldType(f.type, types);
+    }
+  };
+  visit(primary, []);
+  return visited;
+}
+function validateTypeMap(types) {
+  for (const [name, def] of Object.entries(types)) {
+    if (!Array.isArray(def) || def.length === 0) {
+      throw new Error(`empty or invalid struct: ${name}`);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const f of def) {
+      if (!f || typeof f.name !== "string" || !f.name) {
+        throw new Error(`bad field in ${name}`);
+      }
+      if (typeof f.type !== "string" || !f.type) {
+        throw new Error(`bad field type in ${name}.${f.name}`);
+      }
+      if (seen.has(f.name)) {
+        throw new Error(`duplicate field "${f.name}" in ${name}`);
+      }
+      seen.add(f.name);
+    }
+  }
+}
+function encodeType(primary, types) {
+  const deps = collectDependencies(primary, types);
+  const others = [...deps].filter((n) => n !== primary).sort();
+  return [primary, ...others].map((name) => {
+    const fields = types[name];
+    const inner = fields.map((f) => `${f.type} ${f.name}`).join(",");
+    return `${name}(${inner})`;
+  }).join("");
+}
+function typeHash(primary, types) {
+  return shake2562(new TextEncoder().encode(encodeType(primary, types)), { dkLen: DIGEST_LEN });
+}
+function parseQAddress(addr) {
+  if (typeof addr !== "string" || !/^Q[0-9a-fA-F]{40}$/.test(addr)) {
+    throw new Error(`invalid Q-address: ${String(addr)}`);
+  }
+  return hexToBytes("0x" + addr.slice(1).toLowerCase());
+}
+function padLeft32(bytes) {
+  if (bytes.length > SLOT) throw new Error("cannot pad: bytes > 32");
+  const out = new Uint8Array(SLOT);
+  out.set(bytes, SLOT - bytes.length);
+  return out;
+}
+function padRight32(bytes) {
+  if (bytes.length > SLOT) throw new Error("cannot pad: bytes > 32");
+  const out = new Uint8Array(SLOT);
+  out.set(bytes, 0);
+  return out;
+}
+function bigIntToSlot(value, width, signed) {
+  if (signed) {
+    const limit = 1n << BigInt(width - 1);
+    if (value >= limit || value < -limit) {
+      throw new Error(`int${width} out of range: ${value}`);
+    }
+  } else {
+    if (value < 0n) throw new Error(`uint${width} negative: ${value}`);
+    const limit = 1n << BigInt(width);
+    if (value >= limit) throw new Error(`uint${width} out of range: ${value}`);
+  }
+  const slotMask = (1n << 256n) - 1n;
+  const repr = value < 0n ? value + (1n << 256n) & slotMask : value;
+  const out = new Uint8Array(SLOT);
+  let v = repr;
+  for (let i = SLOT - 1; i >= 0; i--) {
+    out[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return out;
+}
+function parseIntValue(v, typeLabel) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "string") {
+    if (/^-?0x[0-9a-fA-F]+$/i.test(v)) {
+      const isNegative = v.startsWith("-");
+      const abs = BigInt(isNegative ? v.slice(1) : v);
+      return isNegative ? -abs : abs;
+    }
+    if (!/^-?(0|[1-9]\d*)$/.test(v)) {
+      throw new Error(`invalid ${typeLabel} string: ${v}`);
+    }
+    return BigInt(v);
+  }
+  if (typeof v === "number") {
+    if (!Number.isInteger(v) || !Number.isSafeInteger(v)) {
+      throw new Error(`unsafe ${typeLabel} number: ${v}, pass as string`);
+    }
+    return BigInt(v);
+  }
+  throw new Error(`unsupported ${typeLabel} value: ${typeof v}`);
+}
+function encodeField(type, value, types) {
+  const parsed = parseFieldType(type, types);
+  switch (parsed.kind) {
+    case "ref":
+      if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`struct field expects object: ${type}`);
+      }
+      return hashStruct(parsed.name, value, types);
+    case "address":
+      if (typeof value !== "string") {
+        throw new Error(`address field expects string: ${typeof value}`);
+      }
+      return padLeft32(parseQAddress(value));
+    case "bool":
+      if (typeof value !== "boolean") {
+        throw new Error(`bool field expects boolean: ${typeof value}`);
+      }
+      return padLeft32(new Uint8Array([value ? 1 : 0]));
+    case "string":
+      if (typeof value !== "string") {
+        throw new Error(`string field expects string: ${typeof value}`);
+      }
+      return shake2562(new TextEncoder().encode(value), { dkLen: DIGEST_LEN });
+    case "bytes":
+      if (typeof value !== "string") {
+        throw new Error(`bytes field expects 0x-hex string: ${typeof value}`);
+      }
+      return shake2562(hexToBytes(value), { dkLen: DIGEST_LEN });
+    case "uintN":
+      return bigIntToSlot(parseIntValue(value, `uint${parsed.width}`), parsed.width, false);
+    case "intN":
+      return bigIntToSlot(parseIntValue(value, `int${parsed.width}`), parsed.width, true);
+    case "bytesN": {
+      if (typeof value !== "string") {
+        throw new Error(`bytes${parsed.width} expects 0x-hex string: ${typeof value}`);
+      }
+      const raw = hexToBytes(value);
+      if (raw.length !== parsed.width) {
+        throw new Error(`bytes${parsed.width} requires ${parsed.width} bytes, got ${raw.length}`);
+      }
+      return padRight32(raw);
+    }
+    case "array": {
+      if (!Array.isArray(value)) {
+        throw new Error(`array field expects array: ${typeof value}`);
+      }
+      if (parsed.size !== void 0 && value.length !== parsed.size) {
+        throw new Error(`fixed array ${type} requires length ${parsed.size}, got ${value.length}`);
+      }
+      const chunks = value.map((v) => encodeField(parsed.inner, v, types));
+      return shake2562(concatBytesArr(chunks), { dkLen: DIGEST_LEN });
+    }
+  }
+}
+function hashStruct(primary, data, types) {
+  const fields = types[primary];
+  if (!fields) throw new Error(`unknown struct: ${primary}`);
+  const expected = new Set(fields.map((f) => f.name));
+  for (const k of Object.keys(data)) {
+    if (!expected.has(k)) throw new Error(`unknown field in ${primary}: ${k}`);
+  }
+  const parts = [typeHash(primary, types)];
+  for (const f of fields) {
+    if (!(f.name in data)) throw new Error(`missing field ${primary}.${f.name}`);
+    parts.push(encodeField(f.type, data[f.name], types));
+  }
+  return shake2562(concatBytesArr(parts), { dkLen: DIGEST_LEN });
+}
+var RESERVED_DOMAIN_FIELDS = {
+  name: "string",
+  version: "string",
+  chainId: "uint256",
+  verifyingContract: "address",
+  salt: "bytes32"
+};
+function validateDomainTypes(types) {
+  const def = types.QRLDomain;
+  if (!def) throw new Error("QRLDomain type is required");
+  let hasName = false;
+  for (const f of def) {
+    const expected = RESERVED_DOMAIN_FIELDS[f.name];
+    if (!expected) {
+      throw new Error(
+        `QRLDomain field "${f.name}" not in reserved set (name, version, chainId, verifyingContract, salt)`
+      );
+    }
+    if (f.type !== expected) {
+      throw new Error(`QRLDomain field "${f.name}" must be type "${expected}", got "${f.type}"`);
+    }
+    if (f.name === "name") hasName = true;
+  }
+  if (!hasName) throw new Error("QRLDomain.name is required");
+}
+function validatePayloadReachability(primary, types) {
+  const reachable = /* @__PURE__ */ new Set();
+  for (const root of ["QRLDomain", primary]) {
+    for (const t of collectDependencies(root, types)) reachable.add(t);
+  }
+  for (const k of Object.keys(types)) {
+    if (!reachable.has(k)) throw new Error(`unused referenced type: ${k}`);
+  }
+}
+function computeTypedDataDigest(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("invalid typed data payload");
+  }
+  validateTypeMap(payload.types);
+  validateDomainTypes(payload.types);
+  validatePayloadReachability(payload.primaryType, payload.types);
+  const domainHash = hashStruct("QRLDomain", payload.domain, payload.types);
+  const messageHash = hashStruct(payload.primaryType, payload.message, payload.types);
+  return shake2562(concatBytes(SCHEME_TAG_TYPED, domainHash, messageHash), { dkLen: DIGEST_LEN });
+}
+
+// src/signing/verify.ts
+import * as mldsa from "@theqrl/mldsa87";
+function bytesOrHex(v) {
+  if (v instanceof Uint8Array) return v;
+  if (typeof v === "string") return hexToBytes(v);
+  throw new Error("expected Uint8Array or 0x-hex string");
+}
+function verifyMessage({
+  signature,
+  publicKey,
+  messageBytes
+}) {
+  try {
+    const sig = bytesOrHex(signature);
+    const pk = bytesOrHex(publicKey);
+    const msg = bytesOrHex(messageBytes);
+    const digest = computeMessageDigest(msg);
+    return mldsa.cryptoSignVerify(sig, digest, pk, SCHEME_TAG_MSG);
+  } catch {
+    return false;
+  }
+}
+function verifyTypedData({ signature, publicKey, payload }) {
+  try {
+    const sig = bytesOrHex(signature);
+    const pk = bytesOrHex(publicKey);
+    const digest = computeTypedDataDigest(payload);
+    return mldsa.cryptoSignVerify(sig, digest, pk, SCHEME_TAG_TYPED);
+  } catch {
+    return false;
+  }
+}
 export {
+  BLOB_LEN,
+  CID_LEN,
   ConnectionManager,
   ConnectionStatus,
   DEFAULT_RELAY_URL,
-  ECIESClient,
+  DIGEST_LEN,
+  FP_LEN,
   KeyExchange,
   KeyExchangeMessageType,
   MessageType,
+  PROTOCOL_VERSION,
   QRLConnectProvider as QRLConnect,
   QRLConnectProvider,
+  QRL_CONNECT_PROVIDER_INFO,
   RESTRICTED_METHODS,
+  SCHEME_TAG_MSG,
+  SCHEME_TAG_TYPED,
+  SCHEME_VERSION_MSG,
+  SCHEME_VERSION_TYPED,
   SocketClient,
   UNRESTRICTED_METHODS,
+  bytesToHex,
+  cidFromString,
+  cidRandom,
+  cidToString,
+  computeFingerprint,
+  computeMessageDigest,
+  computeTypedDataDigest,
+  concatBytes,
+  encodeField,
+  encodeType,
+  fingerprintEquals,
   generateConnectionURI,
   getAppStoreUrl,
+  hashStruct,
+  hexToBytes,
   isMobileBrowser,
-  parseConnectionURI
+  parseConnectionURI,
+  typeHash,
+  verifyMessage,
+  verifyTypedData
 };