@qrlwallet/connect 0.1.0 → 2.0.0

package/dist/index.mjs

@@ -5,81 +5,142 @@ 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;
@@ -165,149 +226,292 @@ 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.
    */
@@ -329,17 +533,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.settlePendingJoin(reconnectChannelId, { result });
           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;
-          }
+          this.settlePendingJoin(reconnectChannelId, { error: reconnectErr });
           error("Socket", `Rejoin failed: ${reconnectErr.message}`);
           this.emit("error", reconnectErr);
         });
@@ -363,7 +561,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 +592,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 +602,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 +622,20 @@ 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
+            });
           } else {
             error("Socket", `Failed to join channel: ${response.error}`);
             reject(new Error(response.error || "Failed to join channel"));
@@ -443,6 +672,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 +686,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 +706,256 @@ 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()}`;
 }
-function parseConnectionURI(uri) {
+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;
+}
+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.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()) {
+      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.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 +965,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 +975,15 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
         this.walletPresent = true;
         log("ConnectionManager", "Wallet joined channel");
         this.clearUnresponsiveTimer();
-        if (this.keyExchange.areKeysExchanged()) {
+        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 */) {
+          if (this.keyExchange?.areKeysExchanged() && (this.status === "connected" /* CONNECTED */ || this.status === "reconnecting" /* RECONNECTING */)) {
             this.setStatus("waiting" /* WAITING */);
           }
           log("ConnectionManager", "Wallet left channel");
@@ -621,15 +992,14 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     });
   }
   setupKeyExchangeListeners() {
+    if (!this.keyExchange) return;
     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({
+      this.failedReconnects = 0;
+      void this.persistSession();
+      void this.sendEncrypted({
         type: "originator_info" /* ORIGINATOR_INFO */,
         originatorInfo: {
           ...this.dappMetadata,
@@ -638,16 +1008,24 @@ 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.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 +1035,51 @@ 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;
+    }
     this.socketClient.connect();
     try {
       const { bufferedMessages } = await this.socketClient.joinChannel(this.channelId);
       for (const msg of bufferedMessages) {
-        this.handleRelayMessage(msg);
+        this.enqueueRelayMessage(msg);
       }
-      if (this.keyExchange.areKeysExchanged() && this.walletPresent) {
-        this.setStatus("connected" /* CONNECTED */);
-      } else if (this.keyExchange.areKeysExchanged()) {
-        this.setStatus("waiting" /* WAITING */);
+      await this.messageQueue;
+      if (this.keyExchange?.areKeysExchanged()) {
+        this.setStatus(this.walletPresent ? "connected" /* CONNECTED */ : "waiting" /* WAITING */);
       } else {
-        this.sendSYN();
+        this.setStatus("waiting" /* WAITING */);
       }
       return true;
     } catch (err) {
@@ -708,10 +1089,10 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     }
   }
   /**
-   * Send a JSON-RPC request to the wallet.
+   * 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 +1101,88 @@ 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.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.walletPresent = false;
+    await this.flushTerminate();
+    this.socketClient.leaveChannel();
+    this.socketClient.disconnect();
+    this.setStatus("disconnected" /* DISCONNECTED */);
+    this.clearSession();
+    this.connectedAccounts = [];
+  }
+  // ── 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 */) {
+      if (this.keyExchange?.areKeysExchanged() && this.status !== "connected" /* CONNECTED */) {
         this.failedReconnects = 0;
         this.setStatus("connected" /* CONNECTED */);
       }
@@ -737,16 +1190,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 +1209,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 +1237,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 +1253,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 +1269,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 +1292,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 +1304,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 +1355,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
@@ -1202,33 +1554,44 @@ 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();
+    await this.connectionManager.disconnect();
   }
 };
 export {
+  BLOB_LEN,
+  CID_LEN,
   ConnectionManager,
   ConnectionStatus,
   DEFAULT_RELAY_URL,
-  ECIESClient,
+  FP_LEN,
   KeyExchange,
   KeyExchangeMessageType,
   MessageType,
+  PROTOCOL_VERSION,
   QRLConnectProvider as QRLConnect,
   QRLConnectProvider,
   RESTRICTED_METHODS,
   SocketClient,
   UNRESTRICTED_METHODS,
+  cidFromString,
+  cidRandom,
+  cidToString,
+  computeFingerprint,
+  fingerprintEquals,
   generateConnectionURI,
   getAppStoreUrl,
   isMobileBrowser,