@qrlwallet/connect 3.2.0 → 4.0.0

package/dist/index.mjs

@@ -109,14 +109,115 @@ function constantTimeEquals(a, b) {
   return d === 0;
 }
 
+// src/config.ts
+var DEFAULT_RELAY_URL = "https://qrlwallet.com";
+var RELAY_PATH = "/relay";
+var PROTOCOL_VERSION = 3;
+var PAIRING_CAPABILITY_LEN = 32;
+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 MAX_JSON_RPC_ID_LENGTH = 128;
+var MAX_JSON_RPC_METHOD_LENGTH = 128;
+var MAX_RELAY_URL_LENGTH = 2048;
+var RECONNECT_WALLET_PROBE_MS = 12 * 1e3;
+var CURRENT_QRL_ADDRESS_RE = /^Q[0-9a-fA-F]{40}$/;
+function isCurrentQrlAddress(value) {
+  return typeof value === "string" && CURRENT_QRL_ADDRESS_RE.test(value);
+}
+function isExplicitLoopbackHostname(value) {
+  const hostname = value.toLowerCase();
+  return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+}
+function normalizeRelayUrl(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > MAX_RELAY_URL_LENGTH) {
+    throw new Error("Invalid relay URL");
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Invalid relay URL");
+  }
+  const isLoopback = isExplicitLoopbackHostname(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback) || url.username !== "" || url.password !== "" || url.hash !== "" || url.search !== "" || url.pathname !== "/") {
+    throw new Error("Invalid relay URL");
+  }
+  return `${url.protocol}//${url.host}`;
+}
+var RESTRICTED_METHOD_NAMES = [
+  "qrl_requestAccounts",
+  "qrl_sendTransaction",
+  "qrl_signTransaction",
+  "qrl_signMessage",
+  "qrl_signTypedData",
+  "wallet_switchQrlChain"
+];
+var UNRESTRICTED_METHOD_NAMES = [
+  "qrl_chainId",
+  "qrl_blockNumber",
+  "qrl_getBalance",
+  "qrl_getTransactionCount",
+  "qrl_getBlockByNumber",
+  "qrl_getTransactionReceipt",
+  "qrl_call",
+  "qrl_estimateGas",
+  "qrl_gasPrice",
+  "qrl_getCode",
+  "qrl_getLogs",
+  // Wallet-local authorization cache, never forwarded to hosted node RPC.
+  "qrl_accounts",
+  "net_version",
+  "net_listening"
+];
+var EXPLICITLY_UNSUPPORTED_METHOD_NAMES = [
+  "qrl_sendRawTransaction",
+  "wallet_addQrlChain",
+  "personal_sign",
+  "qrl_sign",
+  "qrl_signTypedData_v3",
+  "qrl_signTypedData_v4"
+];
+var RESTRICTED_METHOD_POLICY = new Set(RESTRICTED_METHOD_NAMES);
+var UNRESTRICTED_METHOD_POLICY = new Set(UNRESTRICTED_METHOD_NAMES);
+var EXPLICITLY_UNSUPPORTED_METHOD_POLICY = new Set(EXPLICITLY_UNSUPPORTED_METHOD_NAMES);
+var RESTRICTED_METHODS = new Set(RESTRICTED_METHOD_NAMES);
+var UNRESTRICTED_METHODS = new Set(UNRESTRICTED_METHOD_NAMES);
+var EXPLICITLY_UNSUPPORTED_METHODS = new Set(
+  EXPLICITLY_UNSUPPORTED_METHOD_NAMES
+);
+function isValidJsonRpcId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_JSON_RPC_ID_LENGTH || typeof value === "number" && Number.isSafeInteger(value);
+}
+function isValidJsonRpcMethod(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_JSON_RPC_METHOD_LENGTH && /^[A-Za-z0-9_.]+$/.test(value);
+}
+function classifyRpcMethod(method) {
+  if (EXPLICITLY_UNSUPPORTED_METHOD_POLICY.has(method)) return "unsupported";
+  if (RESTRICTED_METHOD_POLICY.has(method)) return "restricted";
+  if (UNRESTRICTED_METHOD_POLICY.has(method)) return "unrestricted";
+  return "unsupported";
+}
+
 // src/PQCrypto.ts
 var textEncoder = new TextEncoder();
-var LABEL = textEncoder.encode("pq-pair/v1");
+var LABEL = textEncoder.encode("pq-pair/v3");
 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_PK_LEN = 1184;
 var ML_KEM_768_CT_LEN = 1088;
+var SHARED_SECRET_LEN = 32;
 var AEAD_KEY_LEN = 32;
+function requireLength(name, value, expected) {
+  if (value.length !== expected) {
+    throw new Error(`PQCrypto: ${name} must be ${expected} bytes`);
+  }
+}
+function generatePairingCapability() {
+  return randomBytes(PAIRING_CAPABILITY_LEN);
+}
 function kemKeygen() {
   return mlkemKeygen();
 }
@@ -126,12 +227,30 @@ function kemEncaps(pk) {
 function kemDecaps(sk, ct) {
   return mlkemDecaps(sk, ct);
 }
-async function transcriptHash(cid, pk, ct) {
-  return sha256(concat(LABEL, cid, pk, ct));
+async function transcriptHash(cid, pk, ct, capability) {
+  requireLength("cid", cid, 16);
+  requireLength("ML-KEM public key", pk, ML_KEM_768_PK_LEN);
+  requireLength("ML-KEM ciphertext", ct, ML_KEM_768_CT_LEN);
+  requireLength("pairing capability", capability, PAIRING_CAPABILITY_LEN);
+  const preimage = concat(LABEL, cid, pk, ct, capability);
+  try {
+    return await sha256(preimage);
+  } finally {
+    zeroize(preimage);
+  }
 }
-async function deriveAeadKey(ss, htx) {
+async function deriveAeadKey(ss, htx, capability) {
+  requireLength("shared secret", ss, SHARED_SECRET_LEN);
+  requireLength("transcript hash", htx, 32);
+  requireLength("pairing capability", capability, PAIRING_CAPABILITY_LEN);
   const info = concat(LABEL, LABEL_AEAD_SUFFIX, htx);
-  return hkdfAesGcmKey(ss, new Uint8Array(32), info);
+  const salt = capability.slice();
+  try {
+    return await hkdfAesGcmKey(ss, salt, info);
+  } finally {
+    zeroize(salt);
+    zeroize(info);
+  }
 }
 async function importRawAeadKey(raw) {
   if (raw.length !== AEAD_KEY_LEN) {
@@ -190,6 +309,33 @@ function toBase64(bytes) {
   }
   return btoa(bin);
 }
+function base64EncodedLength(decodedLength) {
+  if (!Number.isSafeInteger(decodedLength) || decodedLength < 0) {
+    throw new Error("PQCrypto: decoded base64 length must be a non-negative safe integer");
+  }
+  return Math.ceil(decodedLength / 3) * 4;
+}
+var PADDED_BASE64_RE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+function isCanonicalBase64OfLength(value, decodedLength) {
+  if (typeof value !== "string" || value.length !== base64EncodedLength(decodedLength) || !PADDED_BASE64_RE.test(value)) {
+    return false;
+  }
+  let decoded = null;
+  try {
+    decoded = fromBase64(value);
+    return decoded.length === decodedLength && toBase64(decoded) === value;
+  } catch {
+    return false;
+  } finally {
+    if (decoded) zeroize(decoded);
+  }
+}
+function fromBase64Exact(value, decodedLength, fieldName = "value") {
+  if (!isCanonicalBase64OfLength(value, decodedLength)) {
+    throw new Error(`PQCrypto: ${fieldName} must encode exactly ${decodedLength} bytes`);
+  }
+  return fromBase64(value);
+}
 function fromBase64(b64) {
   const bin = atob(b64);
   const out = new Uint8Array(bin.length);
@@ -197,66 +343,6 @@ function fromBase64(b64) {
   return out;
 }
 
-// src/config.ts
-var DEFAULT_RELAY_URL = "https://qrlwallet.com";
-var RELAY_PATH = "/relay";
-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_signMessage",
-  "qrl_signTypedData",
-  "wallet_addQrlChain",
-  "wallet_switchQrlChain"
-]);
-var UNRESTRICTED_METHODS = /* @__PURE__ */ new Set([
-  "qrl_chainId",
-  "qrl_blockNumber",
-  "qrl_getBalance",
-  "qrl_getTransactionCount",
-  "qrl_getBlockByNumber",
-  "qrl_getBlockByHash",
-  "qrl_getTransactionByHash",
-  "qrl_getTransactionReceipt",
-  "qrl_call",
-  "qrl_estimateGas",
-  "qrl_gasPrice",
-  "qrl_getCode",
-  "qrl_getStorageAt",
-  "qrl_getLogs",
-  "qrl_getBlockTransactionCountByHash",
-  "qrl_getBlockTransactionCountByNumber",
-  "qrl_getTransactionByBlockHashAndIndex",
-  "qrl_getTransactionByBlockNumberAndIndex",
-  "qrl_accounts",
-  "net_version",
-  "net_listening",
-  "net_peerCount",
-  "web3_clientVersion",
-  "web3_sha3",
-  "qrl_syncing",
-  "qrl_coinbase",
-  "qrl_mining",
-  "qrl_hashrate",
-  "qrl_protocolVersion",
-  "qrl_getUncleCountByBlockHash",
-  "qrl_getUncleCountByBlockNumber",
-  "qrl_getUncleByBlockHashAndIndex",
-  "qrl_getUncleByBlockNumberAndIndex",
-  "qrl_getFilterChanges",
-  "qrl_getFilterLogs",
-  "qrl_newBlockFilter",
-  "qrl_newFilter",
-  "qrl_newPendingTransactionFilter",
-  "qrl_uninstallFilter"
-]);
-
 // src/types.ts
 var KeyExchangeMessageType = /* @__PURE__ */ ((KeyExchangeMessageType2) => {
   KeyExchangeMessageType2["SYN"] = "key_handshake_SYN";
@@ -283,6 +369,69 @@ var ConnectionStatus = /* @__PURE__ */ ((ConnectionStatus2) => {
   ConnectionStatus2["RECONNECTING"] = "reconnecting";
   return ConnectionStatus2;
 })(ConnectionStatus || {});
+var SIGNATURE_HEX_BYTES = 4627;
+var PUBLIC_KEY_HEX_BYTES = 2592;
+var DIGEST_HEX_BYTES = 64;
+var MESSAGE_RESULT_KEYS = [
+  "signature",
+  "publicKey",
+  "signer",
+  "digest",
+  "schemeVersion"
+];
+var MESSAGE_RESULT_KEYS_WITH_DESCRIPTOR = [
+  ...MESSAGE_RESULT_KEYS,
+  "descriptor"
+];
+var TYPED_RESULT_KEYS = [...MESSAGE_RESULT_KEYS, "domain"];
+var TYPED_RESULT_KEYS_WITH_DESCRIPTOR = [...TYPED_RESULT_KEYS, "descriptor"];
+function isSigningResultRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+function hasExactOwnKeys(record, expected) {
+  const keys = Reflect.ownKeys(record);
+  return keys.length === expected.length && keys.every((key) => typeof key === "string" && expected.includes(key));
+}
+function isFixedHex(value, bytes) {
+  return typeof value === "string" && value.length === bytes * 2 + 2 && /^0x[0-9a-fA-F]+$/.test(value);
+}
+function isSigningDescriptor(value) {
+  return typeof value === "string" && /^0x01[0-9a-fA-F]{4}$/.test(value);
+}
+function hasValidSigningFields(record) {
+  return isFixedHex(record.signature, SIGNATURE_HEX_BYTES) && isFixedHex(record.publicKey, PUBLIC_KEY_HEX_BYTES) && (!hasOwn(record, "descriptor") || isSigningDescriptor(record.descriptor)) && typeof record.signer === "string" && /^Q[0-9a-fA-F]{40}$/.test(record.signer) && isFixedHex(record.digest, DIGEST_HEX_BYTES);
+}
+function isQrlSignedMessageResult(value) {
+  try {
+    if (!isSigningResultRecord(value)) return false;
+    const keys = hasOwn(value, "descriptor") ? MESSAGE_RESULT_KEYS_WITH_DESCRIPTOR : MESSAGE_RESULT_KEYS;
+    return hasExactOwnKeys(value, keys) && value.schemeVersion === "QRL-SIGN-MSG-v1" && hasValidSigningFields(value);
+  } catch {
+    return false;
+  }
+}
+function isQrlSignedTypedDataResult(value) {
+  try {
+    if (!isSigningResultRecord(value)) return false;
+    const keys = hasOwn(value, "descriptor") ? TYPED_RESULT_KEYS_WITH_DESCRIPTOR : TYPED_RESULT_KEYS;
+    return hasExactOwnKeys(value, keys) && value.schemeVersion === "QRL-SIGN-TYPED-v1" && isSigningResultRecord(value.domain) && hasValidSigningFields(value);
+  } catch {
+    return false;
+  }
+}
+function isQrlSignedResult(value) {
+  return isQrlSignedMessageResult(value) || isQrlSignedTypedDataResult(value);
+}
+function hasSigningDescriptor(result) {
+  try {
+    return isQrlSignedResult(result) && hasOwn(result, "descriptor") && isSigningDescriptor(result.descriptor);
+  } catch {
+    return false;
+  }
+}
 
 // src/utils/logger.ts
 var debugEnabled = false;
@@ -306,15 +455,30 @@ 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 AES_GCM_TAG_LEN = 16;
+var SYNACK_C0_LEN = HELLO_WALLET.length + AES_GCM_TAG_LEN;
+var ACK_C1_LEN = HELLO_DAPP.length + AES_GCM_TAG_LEN;
+function snapshotSession(session) {
+  return {
+    ...session,
+    cid: session.cid.slice(),
+    htx: session.htx.slice(),
+    sendDir: session.sendDir.slice(),
+    recvDir: session.recvDir.slice()
+  };
+}
 var KeyExchange = class extends EventEmitter {
   constructor(isOriginator, restored) {
     super();
     this.keypair = null;
+    this.capability = null;
     this.session = null;
     this.step = "key_handshake_SYN" /* SYN */;
     this.awaitingSynAck = false;
     this.awaitingAck = false;
+    this.awaitingAckDelivery = false;
     this.keysExchanged = false;
+    this.stateGeneration = 0;
     // The ACK we produced for the current handshake. A wallet that lost its
     // transport right after sending SYNACK re-sends the identical SYNACK on
     // rejoin; we answer with this cached ACK so the handshake converges
@@ -324,7 +488,10 @@ var KeyExchange = class extends EventEmitter {
     this.lastAck = null;
     this.isOriginator = isOriginator;
     if (restored) {
-      this.session = restored;
+      if (restored.protocolVersion !== PROTOCOL_VERSION) {
+        throw new Error("KeyExchange: cannot restore a pre-v3 session");
+      }
+      this.session = snapshotSession(restored);
       this.keysExchanged = true;
       this.step = "key_handshake_ACK" /* ACK */;
       log("KeyExchange", "Hydrated from persisted session");
@@ -332,7 +499,9 @@ var KeyExchange = class extends EventEmitter {
   }
   /**
    * Originator (dApp) side: begin a fresh handshake by generating an
-   * ephemeral ML-KEM-768 keypair. Returns pk to embed in the QR URI.
+   * ephemeral ML-KEM-768 keypair and a fresh 32-byte pairing capability.
+   * Both returned arrays are copies; the originator retains its own secret
+   * capability until the handshake succeeds or is retired.
    */
   initiate() {
     if (!this.isOriginator) {
@@ -340,10 +509,14 @@ var KeyExchange = class extends EventEmitter {
     }
     this.resetInternal(false);
     this.keypair = kemKeygen();
+    this.capability = generatePairingCapability();
     this.step = "key_handshake_SYN" /* SYN */;
     this.awaitingSynAck = true;
     this.emit("step_change", this.step);
-    return this.keypair.pk;
+    return {
+      publicKey: this.keypair.pk.slice(),
+      capability: this.capability.slice()
+    };
   }
   /**
    * Originator: handle a SYNACK received over the relay.
@@ -355,86 +528,147 @@ var KeyExchange = class extends EventEmitter {
       warn("KeyExchange", "Responder received SYNACK - ignoring");
       return null;
     }
-    if (!this.awaitingSynAck || !this.keypair) {
+    if (!this.awaitingSynAck || !this.keypair || !this.capability) {
       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;
+    const stableCid = cid.slice();
+    const keypair = this.keypair;
+    const capability = this.capability;
+    const generation = this.stateGeneration;
+    let ss = null;
     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 (msg.v !== PROTOCOL_VERSION) {
+        throw new Error(`KeyExchange: expected protocol v${PROTOCOL_VERSION}`);
+      }
+      const ct = fromBase64Exact(msg.ct, ML_KEM_768_CT_LEN, "SYNACK ciphertext");
+      const c0 = fromBase64Exact(msg.c0, SYNACK_C0_LEN, "SYNACK wallet hello");
+      ss = kemDecaps(keypair.sk, ct);
+      const htx = await transcriptHash(stableCid, keypair.pk, ct, capability);
+      const key = await deriveAeadKey(ss, htx, capability);
+      let hello = null;
+      try {
+        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");
+        }
+      } finally {
+        if (hello) zeroize(hello);
+      }
+      if (this.stateGeneration !== generation || this.keypair !== keypair) {
+        throw new Error("KeyExchange: handshake generation changed");
+      }
+      const c1 = await seal(key, DIR_DAPP_TX, 0, htx, HELLO_DAPP);
+      if (this.stateGeneration !== generation || this.keypair !== keypair) {
+        throw new Error("KeyExchange: handshake generation changed");
+      }
+      zeroize(keypair.sk);
+      if (this.keypair === keypair) this.keypair = null;
+      zeroize(capability);
+      if (this.capability === capability) this.capability = null;
+      this.session = {
+        protocolVersion: PROTOCOL_VERSION,
+        cid: stableCid,
+        key,
+        htx,
+        sendDir: DIR_DAPP_TX.slice(),
+        recvDir: DIR_WALLET_TX.slice(),
+        sendSeq: 1,
+        recvSeq: 1
+      };
+      const ack = {
+        type: "key_handshake_ACK" /* ACK */,
+        c1: toBase64(c1),
+        v: PROTOCOL_VERSION
+      };
+      this.lastAck = { ...ack };
+      this.awaitingAckDelivery = true;
+      return ack;
+    } catch (error2) {
+      if (this.stateGeneration === generation) this.resetInternal(false);
+      throw error2;
+    } finally {
+      if (ss) zeroize(ss);
     }
-    if (!constantTimeEquals(hello, HELLO_WALLET)) {
-      throw new Error("KeyExchange: wallet hello mismatch");
+  }
+  /**
+   * Originator: publish completion only after the relay acknowledged ACK.
+   * This is deliberately separate from onSynAck() so transport ambiguity
+   * cannot leave a live or persistable one-sided session.
+   */
+  confirmOriginatorAckDelivered() {
+    if (!this.isOriginator) {
+      throw new Error("KeyExchange: responder cannot confirm originator ACK delivery");
     }
-    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
-    };
+    if (this.keysExchanged) return;
+    if (!this.awaitingAckDelivery || !this.session || !this.lastAck) {
+      throw new Error("KeyExchange: no provisional originator session to confirm");
+    }
+    this.awaitingAckDelivery = false;
     this.keysExchanged = true;
     this.step = "key_handshake_ACK" /* ACK */;
     this.emit("keys_exchanged");
     this.emit("step_change", this.step);
-    const ack = {
-      type: "key_handshake_ACK" /* ACK */,
-      c1: toBase64(c1),
-      v: PROTOCOL_VERSION
-    };
-    this.lastAck = ack;
-    return ack;
   }
   /**
    * Responder (wallet) side: begin handshake from a scanned QR.
    * Returns the SYNACK wire message to emit on the relay.
    */
-  async receiveQR(cid, pk) {
+  async receiveQR(cid, pk, capability) {
     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
-    };
+    const generation = this.stateGeneration;
+    const stableCid = cid.slice();
+    const stablePk = pk.slice();
+    if (capability.length !== PAIRING_CAPABILITY_LEN) {
+      throw new Error(`KeyExchange: capability must be ${PAIRING_CAPABILITY_LEN} bytes`);
+    }
+    const stableCapability = capability.slice();
+    let ss = null;
+    try {
+      const encapsulated = kemEncaps(stablePk);
+      const { ct } = encapsulated;
+      ss = encapsulated.ss;
+      const htx = await transcriptHash(stableCid, stablePk, ct, stableCapability);
+      const key = await deriveAeadKey(ss, htx, stableCapability);
+      const c0 = await seal(key, DIR_WALLET_TX, 0, htx, HELLO_WALLET);
+      if (this.stateGeneration !== generation) {
+        throw new Error("KeyExchange: handshake generation changed");
+      }
+      this.session = {
+        protocolVersion: PROTOCOL_VERSION,
+        cid: stableCid,
+        key,
+        htx,
+        sendDir: DIR_WALLET_TX.slice(),
+        recvDir: DIR_DAPP_TX.slice(),
+        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
+      };
+    } catch (error2) {
+      if (this.stateGeneration === generation) this.resetInternal(false);
+      throw error2;
+    } finally {
+      if (ss) zeroize(ss);
+      zeroize(stableCapability);
+    }
   }
   /**
    * Responder: verify an incoming ACK and finalize the session.
@@ -452,59 +686,101 @@ var KeyExchange = class extends EventEmitter {
       throw new Error("KeyExchange: onAck called without a session");
     }
     this.awaitingAck = false;
-    const c1 = fromBase64(msg.c1);
-    let hello;
+    const session = this.session;
+    const generation = this.stateGeneration;
     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");
+      if (msg.v !== PROTOCOL_VERSION) {
+        throw new Error(`KeyExchange: expected protocol v${PROTOCOL_VERSION}`);
+      }
+      const c1 = fromBase64Exact(msg.c1, ACK_C1_LEN, "ACK dApp hello");
+      let hello = null;
+      try {
+        try {
+          hello = await open(session.key, DIR_DAPP_TX, 0, 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");
+        }
+      } finally {
+        if (hello) zeroize(hello);
+      }
+      if (this.stateGeneration !== generation || this.session !== session) {
+        throw new Error("KeyExchange: handshake generation changed");
+      }
+      this.keysExchanged = true;
+      this.step = "key_handshake_ACK" /* ACK */;
+      this.emit("keys_exchanged");
+    } catch (error2) {
+      if (this.stateGeneration === generation) this.resetInternal(false);
+      throw error2;
     }
-    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) {
+    const session = this.session;
+    const generation = this.stateGeneration;
+    if (!session) {
       throw new Error("KeyExchange: cannot encrypt - session not established");
     }
-    const seq = this.session.sendSeq++;
+    if (session.sendSeq >= Number.MAX_SAFE_INTEGER) {
+      throw new Error("KeyExchange: send counter exhausted");
+    }
+    const seq = session.sendSeq++;
     const pt = textEncoder2.encode(data);
-    const ct = await seal(this.session.key, this.session.sendDir, seq, this.session.htx, pt);
-    return toBase64(ct);
+    try {
+      const ct = await seal(session.key, session.sendDir, seq, session.htx, pt);
+      if (this.stateGeneration !== generation || this.session !== session) {
+        throw new Error("KeyExchange: session changed while encrypting");
+      }
+      return toBase64(ct);
+    } finally {
+      zeroize(pt);
+    }
   }
   /** Decrypt a base64 ciphertext from the counterparty. */
   async decryptMessage(b64) {
-    if (!this.session) {
+    const session = this.session;
+    const generation = this.stateGeneration;
+    if (!session) {
       throw new Error("KeyExchange: cannot decrypt - session not established");
     }
+    if (session.recvSeq >= Number.MAX_SAFE_INTEGER) {
+      throw new Error("KeyExchange: receive counter exhausted");
+    }
     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);
+    let pt = null;
+    try {
+      pt = await open(session.key, session.recvDir, session.recvSeq, session.htx, ct);
+      if (this.stateGeneration !== generation || this.session !== session) {
+        throw new Error("KeyExchange: session changed while decrypting");
+      }
+      session.recvSeq++;
+      return textDecoder.decode(pt);
+    } finally {
+      if (pt) zeroize(pt);
+    }
   }
   /** Reset all state for a fresh handshake. Zeroes any live secret-key buffer. */
   reset() {
     this.resetInternal(true);
   }
   resetInternal(emit) {
+    this.stateGeneration++;
     if (this.keypair) {
       zeroize(this.keypair.sk);
       this.keypair = null;
     }
+    if (this.capability) {
+      zeroize(this.capability);
+      this.capability = null;
+    }
     this.session = null;
     this.keysExchanged = false;
     this.awaitingSynAck = false;
     this.awaitingAck = false;
+    this.awaitingAckDelivery = false;
     this.lastAck = null;
     this.step = "key_handshake_SYN" /* SYN */;
     if (emit) this.emit("step_change", this.step);
@@ -514,36 +790,55 @@ var KeyExchange = class extends EventEmitter {
   }
   /** The ACK produced for the current handshake, for duplicate-SYNACK replies. */
   getLastAck() {
-    return this.lastAck;
+    return this.lastAck ? { ...this.lastAck } : null;
   }
   getSession() {
-    return this.session;
+    return this.session ? snapshotSession(this.session) : null;
   }
   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
-    };
+    const session = this.session;
+    const generation = this.stateGeneration;
+    if (!session || !this.keysExchanged) return null;
+    const kAeadRaw = await exportRawAeadKey(session.key);
+    try {
+      if (this.stateGeneration !== generation || this.session !== session) return null;
+      return {
+        protocolVersion: PROTOCOL_VERSION,
+        cid: toBase64(session.cid),
+        kAeadRaw: toBase64(kAeadRaw),
+        htx: toBase64(session.htx),
+        sendDir: toBase64(session.sendDir),
+        recvDir: toBase64(session.recvDir),
+        sendSeq: session.sendSeq,
+        recvSeq: session.recvSeq
+      };
+    } finally {
+      zeroize(kAeadRaw);
+    }
   }
   /** Rehydrate a Session from its persisted form. */
   static async sessionFromPersisted(p) {
-    const key = await importRawAeadKey(fromBase64(p.kAeadRaw));
+    if (p.protocolVersion !== PROTOCOL_VERSION) {
+      throw new Error("KeyExchange: cannot hydrate a pre-v3 session");
+    }
+    const kAeadRaw = fromBase64Exact(p.kAeadRaw, 32, "persisted AEAD key");
+    let key;
+    try {
+      key = await importRawAeadKey(kAeadRaw);
+    } finally {
+      zeroize(kAeadRaw);
+    }
     return {
-      cid: fromBase64(p.cid),
+      protocolVersion: PROTOCOL_VERSION,
+      cid: fromBase64Exact(p.cid, 16, "persisted channel id"),
       key,
-      htx: fromBase64(p.htx),
-      sendDir: fromBase64(p.sendDir),
-      recvDir: fromBase64(p.recvDir),
+      htx: fromBase64Exact(p.htx, 32, "persisted transcript hash"),
+      sendDir: fromBase64Exact(p.sendDir, 4, "persisted send direction"),
+      recvDir: fromBase64Exact(p.recvDir, 4, "persisted receive direction"),
       sendSeq: p.sendSeq,
       recvSeq: p.recvSeq
     };
@@ -554,6 +849,20 @@ var KeyExchange = class extends EventEmitter {
 import { io } from "socket.io-client";
 import EventEmitter2 from "eventemitter3";
 var PENDING_JOIN_TIMEOUT_MS = 2e4;
+var SEND_FLUSH_TIMEOUT_MS = 600;
+var MESSAGE_ACK_TIMEOUT_MS = 15e3;
+var MAX_JOIN_BUFFERED_MESSAGES = 50;
+var MAX_JOIN_PARTICIPANTS = 1;
+var MAX_RELAY_ERROR_CHARS = 512;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseParticipants(value, expectedPeerType) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.length > MAX_JOIN_PARTICIPANTS) return null;
+  if (!value.every((participant) => participant === expectedPeerType)) return null;
+  return Array(value.length).fill(expectedPeerType);
+}
 var SocketClient = class extends EventEmitter2 {
   constructor(relayUrl, clientType) {
     super();
@@ -565,9 +874,14 @@ var SocketClient = class extends EventEmitter2 {
     this.publicKeyBase64 = null;
     this.seq = 0;
     this.pendingJoin = null;
-    this.relayUrl = relayUrl;
+    this.pendingSends = /* @__PURE__ */ new Set();
+    this.pendingJoinAttempts = /* @__PURE__ */ new Set();
+    this.relayUrl = normalizeRelayUrl(relayUrl);
     this.clientType = clientType;
   }
+  get expectedPeerType() {
+    return this.clientType === "dapp" ? "wallet" : "dapp";
+  }
   /**
    * dApp-only: stash the PK so it gets uploaded on every join_channel
    * attempt (including auto-rejoins after reconnect).
@@ -576,6 +890,9 @@ var SocketClient = class extends EventEmitter2 {
     if (this.clientType !== "dapp") {
       throw new Error("SocketClient.setPublicKey is only valid for dApp clients");
     }
+    if (!isCanonicalBase64OfLength(publicKeyBase64, ML_KEM_768_PK_LEN)) {
+      throw new Error(`SocketClient public key must be ${ML_KEM_768_PK_LEN} bytes`);
+    }
     this.publicKeyBase64 = publicKeyBase64;
   }
   /**
@@ -601,9 +918,10 @@ var SocketClient = class extends EventEmitter2 {
       this.emit("connected");
       if (this.channelId) {
         const reconnectChannelId = this.channelId;
+        const isExplicitPendingJoin = this.pendingJoin?.channelId === reconnectChannelId;
         this.joinChannelNow(reconnectChannelId).then((result) => {
           this.settlePendingJoin(reconnectChannelId, { result });
-          this.emit("reconnected", result);
+          if (!isExplicitPendingJoin) this.emit("reconnected", result);
         }).catch((err) => {
           const reconnectErr = err instanceof Error ? err : new Error(String(err));
           this.settlePendingJoin(reconnectChannelId, { error: reconnectErr });
@@ -614,20 +932,28 @@ var SocketClient = class extends EventEmitter2 {
     });
     this.socket.on("disconnect", (reason) => {
       log("Socket", `Disconnected: ${reason}`);
+      this.rejectPendingJoinAttempts(
+        new Error(`Socket disconnected before join acknowledgement: ${reason}`)
+      );
+      this.rejectPendingSends(
+        new Error(`Socket disconnected before relay acknowledgement: ${reason}`)
+      );
       this.emit("disconnected", reason);
     });
     this.socket.on("message", (data) => {
-      log("Socket", `Message received in channel ${data.id}`);
+      log("Socket", "Relay message received");
       this.emit("message", data);
     });
     this.socket.on("participants_changed", (data) => {
-      if (typeof data !== "object" || data === null) return;
-      const rec = { ...data };
-      const event = typeof rec.event === "string" ? rec.event : "";
+      if (!isRecord(data)) return;
+      const event = data.event;
+      if (event !== "join" && event !== "leave" && event !== "disconnect" && event !== "close" || data.clientType !== this.expectedPeerType) {
+        return;
+      }
       log("Socket", `Participants changed: ${event}`);
       this.emit("participants_changed", {
         event,
-        ...typeof rec.clientType === "string" ? { clientType: rec.clientType } : {}
+        clientType: this.expectedPeerType
       });
     });
     this.socket.on("connect_error", (err) => {
@@ -678,6 +1004,15 @@ var SocketClient = class extends EventEmitter2 {
       rejectPending = reject;
     });
     const watchdog = setTimeout(() => {
+      if (this.channelId === channelId) {
+        this.channelId = null;
+        const socket = this.socket;
+        if (socket) {
+          socket.removeAllListeners();
+          socket.disconnect();
+          if (this.socket === socket) this.socket = null;
+        }
+      }
       this.settlePendingJoin(channelId, {
         error: new Error(`joinChannel timed out after ${PENDING_JOIN_TIMEOUT_MS}ms`)
       });
@@ -693,57 +1028,194 @@ var SocketClient = class extends EventEmitter2 {
   }
   joinChannelNow(channelId) {
     return new Promise((resolve, reject) => {
-      if (!this.socket?.connected) {
+      const socket = this.socket;
+      if (!socket?.connected) {
         reject(new Error("Socket not connected"));
         return;
       }
+      let settled = false;
+      const abandonJoin = () => {
+        if (this.channelId !== channelId) return;
+        if (socket.connected) socket.emit("leave_channel", { channelId });
+        this.channelId = null;
+      };
+      const finish = (outcome) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(pending.timer);
+        this.pendingJoinAttempts.delete(pending);
+        if ("result" in outcome) resolve(outcome.result);
+        else reject(outcome.error);
+      };
+      const pending = {
+        timer: setTimeout(() => {
+          abandonJoin();
+          finish({
+            error: new Error(
+              `joinChannel acknowledgement timed out after ${PENDING_JOIN_TIMEOUT_MS}ms`
+            )
+          });
+        }, PENDING_JOIN_TIMEOUT_MS),
+        reject: (error2) => {
+          finish({ error: error2 });
+        }
+      };
+      this.pendingJoinAttempts.add(pending);
       const payload = { channelId, clientType: this.clientType };
       if (this.clientType === "dapp" && this.publicKeyBase64) {
         payload.publicKey = this.publicKeyBase64;
       }
-      this.socket.emit(
-        "join_channel",
-        payload,
-        (response) => {
-          if (response.success) {
-            log("Socket", `Joined channel ${channelId}`);
-            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"));
+      socket.emit("join_channel", payload, (response) => {
+        if (!isRecord(response)) {
+          abandonJoin();
+          finish({ error: new Error("Relay returned a malformed join acknowledgement") });
+          return;
+        }
+        if (response.success === true) {
+          const rawMessages = response.bufferedMessages;
+          if (rawMessages !== void 0 && !Array.isArray(rawMessages) || Array.isArray(rawMessages) && rawMessages.length > MAX_JOIN_BUFFERED_MESSAGES) {
+            abandonJoin();
+            finish({ error: new Error("Relay returned an invalid buffered message list") });
+            return;
+          }
+          const rawParticipants = response.participants;
+          const participants = parseParticipants(rawParticipants, this.expectedPeerType);
+          if (!participants) {
+            abandonJoin();
+            finish({ error: new Error("Relay returned an invalid participant list") });
+            return;
+          }
+          const rawPublicKey = response.channelPublicKey;
+          if (rawPublicKey !== void 0 && rawPublicKey !== null && !isCanonicalBase64OfLength(rawPublicKey, ML_KEM_768_PK_LEN)) {
+            abandonJoin();
+            finish({ error: new Error("Relay returned an invalid channel public key") });
+            return;
+          }
+          if (response.terminated !== void 0 && typeof response.terminated !== "boolean") {
+            abandonJoin();
+            finish({ error: new Error("Relay returned an invalid termination status") });
+            return;
           }
+          log("Socket", `Joined channel ${channelId}`);
+          finish({
+            result: {
+              bufferedMessages: Array.isArray(rawMessages) ? rawMessages.slice() : [],
+              channelPublicKey: typeof rawPublicKey === "string" ? rawPublicKey : null,
+              participants,
+              terminated: response.terminated === true
+            }
+          });
+        } else {
+          const relayError = typeof response.error === "string" ? response.error.slice(0, MAX_RELAY_ERROR_CHARS) : "Failed to join channel";
+          error("Socket", `Failed to join channel: ${relayError}`);
+          abandonJoin();
+          finish({ error: new Error(relayError) });
         }
-      );
+      });
     });
   }
+  rejectPendingJoinAttempts(error2) {
+    for (const pending of [...this.pendingJoinAttempts]) pending.reject(error2);
+  }
   /**
    * Send a message through the relay.
    */
   sendMessage(data) {
     return new Promise((resolve, reject) => {
-      if (!this.socket?.connected) {
+      const socket = this.socket;
+      if (!socket?.connected) {
         reject(new Error("Socket not connected"));
         return;
       }
       const dataWithSeq = { ...data, seq: this.seq++ };
-      this.socket.emit(
-        "message",
-        dataWithSeq,
-        (response) => {
-          if (response?.success) {
-            resolve({ success: true, buffered: response.buffered });
-          } else {
-            reject(new Error(response?.error ?? "Failed to send message"));
+      let settled = false;
+      const finish = (outcome) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(pending.timer);
+        this.pendingSends.delete(pending);
+        if ("result" in outcome) resolve(outcome.result);
+        else reject(outcome.error);
+      };
+      const pending = {
+        timer: setTimeout(() => {
+          finish({
+            error: new Error(
+              `Relay message acknowledgement timed out after ${MESSAGE_ACK_TIMEOUT_MS}ms`
+            )
+          });
+        }, MESSAGE_ACK_TIMEOUT_MS),
+        reject: (error2) => {
+          finish({ error: error2 });
+        }
+      };
+      this.pendingSends.add(pending);
+      socket.emit("message", dataWithSeq, (response) => {
+        if (!isRecord(response)) {
+          finish({ error: new Error("Relay returned a malformed message acknowledgement") });
+          return;
+        }
+        if (response.success === true) {
+          if (typeof response.buffered !== "boolean") {
+            finish({ error: new Error("Relay returned a malformed message acknowledgement") });
+            return;
           }
+          finish({ result: { success: true, buffered: response.buffered } });
+        } else {
+          const relayError = typeof response.error === "string" ? response.error.slice(0, MAX_RELAY_ERROR_CHARS) : "Failed to send message";
+          finish({ error: new Error(relayError) });
         }
-      );
+      });
+    });
+  }
+  rejectPendingSends(error2) {
+    for (const pending of [...this.pendingSends]) pending.reject(error2);
+  }
+  /**
+   * Emit an event and resolve once the relay acks it, or after a bounded
+   * flush window. Lets a caller await transmission before tearing the
+   * socket down.
+   */
+  flushEmit(event, payload) {
+    return new Promise((resolve) => {
+      if (!this.socket?.connected) {
+        resolve(false);
+        return;
+      }
+      let settled = false;
+      const done = (confirmed) => {
+        if (settled) return;
+        settled = true;
+        resolve(confirmed);
+      };
+      const timer = setTimeout(() => {
+        done(false);
+      }, SEND_FLUSH_TIMEOUT_MS);
+      this.socket.emit(event, payload, (response) => {
+        clearTimeout(timer);
+        done(isRecord(response) && response.success === true && response.terminated === true);
+      });
     });
   }
+  /**
+   * Explicitly terminate the channel on the relay (durable tombstone), as
+   * opposed to the transient leaveChannel(). Used when the session is dead
+   * in a way an encrypted TERMINATE cannot communicate (AEAD desync: the
+   * peer could not open it). Resolves once the close is flushed or the
+   * bounded window elapses, so the caller can safely disconnect afterwards.
+   */
+  closeChannel() {
+    const channelId = this.channelId;
+    this.channelId = null;
+    if (this.pendingJoin) {
+      clearTimeout(this.pendingJoin.watchdog);
+      this.pendingJoin.reject(new Error("Channel closed before join completed"));
+      this.pendingJoin = null;
+    }
+    this.rejectPendingJoinAttempts(new Error("Channel closed before join completed"));
+    if (!this.socket?.connected || !channelId) return Promise.resolve(false);
+    return this.flushEmit("close_channel", { channelId });
+  }
   /**
    * Leave the current channel.
    */
@@ -753,6 +1225,7 @@ var SocketClient = class extends EventEmitter2 {
       this.pendingJoin.reject(new Error("Channel left before join completed"));
       this.pendingJoin = null;
     }
+    this.rejectPendingJoinAttempts(new Error("Channel left before join completed"));
     if (this.socket?.connected && this.channelId) {
       this.socket.emit("leave_channel", { channelId: this.channelId });
     }
@@ -767,8 +1240,10 @@ var SocketClient = class extends EventEmitter2 {
       this.pendingJoin.reject(new Error("Socket disconnected before join completed"));
       this.pendingJoin = null;
     }
+    this.rejectPendingJoinAttempts(new Error("Socket disconnected before join completed"));
     this.channelId = null;
     this.seq = 0;
+    this.rejectPendingSends(new Error("Socket disconnected before relay acknowledgement"));
     if (this.socket) {
       this.socket.removeAllListeners();
       this.socket.disconnect();
@@ -857,38 +1332,67 @@ function base45Decode(s) {
 }
 
 // src/utils/qrUri.ts
-var MAGIC = new Uint8Array([80, 81, 80, 50]);
-var FP_LABEL = new TextEncoder().encode("pq-fp/v2");
+var MAGIC = new Uint8Array([80, 81, 80, 51]);
+var FP_LABEL = new TextEncoder().encode("pq-fp/v3");
 var CID_LEN = 16;
 var FP_LEN = 32;
-var BLOB_LEN = 4 + CID_LEN + FP_LEN;
-async function computeFingerprint(cid, pk) {
+var CAP_LEN = PAIRING_CAPABILITY_LEN;
+var BLOB_LEN = 4 + CID_LEN + FP_LEN + CAP_LEN;
+var MAX_CONNECTION_URI_LENGTH = 4096;
+async function computeFingerprint(cid, pk, capability) {
   if (cid.length !== CID_LEN) {
     throw new Error(`qrUri: cid must be ${CID_LEN} bytes`);
   }
-  const buf = new Uint8Array(FP_LABEL.length + cid.length + pk.length);
+  if (pk.length !== ML_KEM_768_PK_LEN) {
+    throw new Error(`qrUri: ML-KEM public key must be ${ML_KEM_768_PK_LEN} bytes`);
+  }
+  if (capability.length !== CAP_LEN) {
+    throw new Error(`qrUri: capability must be ${CAP_LEN} bytes`);
+  }
+  const buf = new Uint8Array(FP_LABEL.length + cid.length + pk.length + capability.length);
   buf.set(FP_LABEL, 0);
   buf.set(cid, FP_LABEL.length);
   buf.set(pk, FP_LABEL.length + cid.length);
-  return sha256(buf);
+  buf.set(capability, FP_LABEL.length + cid.length + pk.length);
+  try {
+    return await sha256(buf);
+  } finally {
+    buf.fill(0);
+  }
 }
 function fingerprintEquals(a, b) {
   return constantTimeEquals(a, b);
 }
-async function generateConnectionURI(cid, pk, relayUrl) {
+async function generateConnectionURI(cid, pk, capability, 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);
+  if (pk.length !== ML_KEM_768_PK_LEN) {
+    throw new Error(
+      `qrUri: ML-KEM public key must be ${ML_KEM_768_PK_LEN} bytes (got ${pk.length})`
+    );
+  }
+  if (capability.length !== CAP_LEN) {
+    throw new Error(`qrUri: capability must be ${CAP_LEN} bytes (got ${capability.length})`);
+  }
+  const stableCapability = capability.slice();
   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()}`;
+  try {
+    const fp = await computeFingerprint(cid, pk, stableCapability);
+    blob.set(MAGIC, 0);
+    blob.set(cid, 4);
+    blob.set(fp, 4 + CID_LEN);
+    blob.set(stableCapability, 4 + CID_LEN + FP_LEN);
+    const params = new URLSearchParams({ q: base45Encode(blob) });
+    if (relayUrl !== void 0) params.set("r", normalizeRelayUrl(relayUrl));
+    return `qrlconnect://?${params.toString()}`;
+  } finally {
+    stableCapability.fill(0);
+    blob.fill(0);
+  }
 }
 var PQP1_MAGIC = new Uint8Array([80, 81, 80, 49]);
+var PQP2_MAGIC = new Uint8Array([80, 81, 80, 50]);
 function startsWith(buf, prefix) {
   if (buf.length < prefix.length) return false;
   for (let i = 0; i < prefix.length; i++) {
@@ -900,21 +1404,38 @@ async function parseConnectionURI(uri) {
   if (typeof uri !== "string" || uri.length === 0) {
     throw new Error("qrUri: empty URI");
   }
-  if (!/^qrlconnect:/i.test(uri)) {
+  if (uri.length > MAX_CONNECTION_URI_LENGTH) {
+    throw new Error(`qrUri: URI exceeds ${MAX_CONNECTION_URI_LENGTH} characters`);
+  }
+  if (!uri.startsWith("qrlconnect:")) {
     throw new Error("qrUri: not a qrlconnect URI");
   }
+  if (!uri.startsWith("qrlconnect://?") || uri.includes("#")) {
+    throw new Error("qrUri: URI must use canonical qrlconnect://? query form");
+  }
   let params;
   try {
-    const swapped = new URL(uri.replace(/^qrlconnect:\/?\/?/i, "https://qrlconnect/"));
-    params = swapped.searchParams;
+    const parsed = new URL(uri);
+    if (parsed.protocol !== "qrlconnect:" || parsed.host !== "" || parsed.pathname !== "" || parsed.hash !== "") {
+      throw new Error("non-canonical URI components");
+    }
+    params = parsed.searchParams;
   } catch {
     throw new Error("qrUri: malformed URI");
   }
   if (params.has("channelId") || params.has("pubKey")) {
     throw new Error(
-      "qrUri: legacy v1 URI detected - this wallet and this dApp must both run protocol v2"
+      "qrUri: legacy v1 URI detected - this wallet and this dApp must both run protocol v3"
     );
   }
+  if (params.getAll("q").length > 1 || params.getAll("r").length > 1) {
+    throw new Error("qrUri: duplicate q or r parameter");
+  }
+  for (const key of params.keys()) {
+    if (key !== "q" && key !== "r") {
+      throw new Error(`qrUri: unknown parameter ${key}`);
+    }
+  }
   const q = params.get("q");
   if (!q) {
     throw new Error("qrUri: missing q parameter");
@@ -926,19 +1447,40 @@ async function parseConnectionURI(uri) {
     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 - 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");
+  try {
+    if (blob.length !== BLOB_LEN) {
+      if (blob.length === 1208 && startsWith(blob, PQP1_MAGIC)) {
+        throw new Error(
+          "qrUri: legacy PQP1 URI detected - regenerate the QR with a v4.0+ dApp SDK"
+        );
+      }
+      if (blob.length === 52 && startsWith(blob, PQP2_MAGIC)) {
+        throw new Error(
+          "qrUri: legacy PQP2 URI detected - regenerate the QR with a v4.0+ dApp SDK"
+        );
+      }
+      throw new Error(`qrUri: expected ${BLOB_LEN}-byte blob, got ${blob.length}`);
+    }
+    if (!startsWith(blob, MAGIC)) {
+      throw new Error("qrUri: bad PQP3 magic");
+    }
+    const cid = blob.slice(4, 4 + CID_LEN);
+    const fp = blob.slice(4 + CID_LEN, 4 + CID_LEN + FP_LEN);
+    const capability = blob.slice(4 + CID_LEN + FP_LEN, BLOB_LEN);
+    const r = params.get("r");
+    let relayUrl;
+    if (r !== null) {
+      if (r === "") throw new Error("qrUri: empty relay URL");
+      try {
+        relayUrl = normalizeRelayUrl(r);
+      } catch {
+        throw new Error("qrUri: invalid relay URL");
+      }
+    }
+    return { cid, fp, capability, relayUrl };
+  } finally {
+    blob.fill(0);
   }
-  const cid = blob.slice(4, 4 + CID_LEN);
-  const fp = blob.slice(4 + CID_LEN, 4 + CID_LEN + FP_LEN);
-  const r = params.get("r");
-  return { cid, fp, relayUrl: r === null || r === "" ? void 0 : r };
 }
 function cidToString(cid) {
   if (cid.length !== CID_LEN) {
@@ -965,31 +1507,196 @@ function cidRandom() {
   return randomBytes(CID_LEN);
 }
 
+// src/SessionOwnership.ts
+function getBrowserStorage() {
+  try {
+    return typeof localStorage === "undefined" ? null : localStorage;
+  } catch {
+    return null;
+  }
+}
+function getBrowserLockManager() {
+  try {
+    if (typeof navigator === "undefined") return null;
+    return navigator.locks ?? null;
+  } catch {
+    return null;
+  }
+}
+var SessionOwnership = class {
+  constructor(storageKey, lockManager) {
+    this.owned = false;
+    this.acquireInFlight = null;
+    this.releaseLock = null;
+    this.lockRequest = null;
+    this.releaseInFlight = null;
+    // Monotonic attempt identity. release() advances it before waiting for the
+    // Web Locks request, so a callback dispatched after teardown can observe
+    // cancellation and decline a late grant.
+    this.ownershipGeneration = 0;
+    this.lockName = `${storageKey}:aead-owner`;
+    this.lockManager = lockManager;
+  }
+  isOwned() {
+    return this.owned;
+  }
+  async acquire() {
+    const generation = this.ownershipGeneration;
+    if (this.releaseInFlight) await this.releaseInFlight;
+    if (generation !== this.ownershipGeneration) return false;
+    if (this.owned) return true;
+    if (this.acquireInFlight) return this.acquireInFlight;
+    const task = this.startAcquire(generation);
+    this.acquireInFlight = task;
+    try {
+      return await task;
+    } finally {
+      if (this.acquireInFlight === task) this.acquireInFlight = null;
+    }
+  }
+  startAcquire(generation) {
+    return new Promise((resolve) => {
+      let grantSettled = false;
+      const settleGrant = (granted) => {
+        if (grantSettled) return;
+        grantSettled = true;
+        resolve(granted);
+      };
+      let request;
+      try {
+        request = this.lockManager.request(
+          this.lockName,
+          { mode: "exclusive", ifAvailable: true },
+          async (lock) => {
+            if (!lock || generation !== this.ownershipGeneration) {
+              settleGrant(false);
+              return;
+            }
+            this.owned = true;
+            settleGrant(true);
+            await new Promise((release) => {
+              this.releaseLock = release;
+            });
+            this.releaseLock = null;
+            this.owned = false;
+          }
+        );
+      } catch (err) {
+        warn("SessionOwnership", "Web Lock request failed:", err);
+        settleGrant(false);
+        return;
+      }
+      this.lockRequest = request.then(() => void 0).catch((err) => {
+        warn("SessionOwnership", "Web Lock request failed:", err);
+        settleGrant(false);
+      });
+    });
+  }
+  release() {
+    this.ownershipGeneration++;
+    if (this.releaseInFlight) return this.releaseInFlight;
+    const task = this.finishRelease();
+    const tracked = task.finally(() => {
+      if (this.releaseInFlight === tracked) this.releaseInFlight = null;
+    });
+    this.releaseInFlight = tracked;
+    return tracked;
+  }
+  async finishRelease() {
+    const release = this.releaseLock;
+    this.releaseLock = null;
+    if (release) release();
+    const request = this.lockRequest;
+    if (request) await request;
+    this.owned = false;
+    this.acquireInFlight = null;
+    if (this.lockRequest === request) this.lockRequest = null;
+  }
+};
+
 // src/ConnectionManager.ts
 var DAPP_PARTICIPANT_CONFLICT_ERROR_MSG = "dapp participant is already connected";
-function isRecord(v) {
+var MAX_RELAY_CIPHERTEXT_CHARS = 256 * 1024;
+var MAX_JSON_RPC_ERROR_MESSAGE_CHARS = 1024;
+var MAX_DAPP_NAME_CHARS = 128;
+var MAX_DAPP_URL_CHARS = 2048;
+var MAX_DAPP_ICON_CHARS = 4096;
+var MAX_CHAIN_ID_CHARS = 66;
+var MAX_STORED_CLOCK_SKEW_MS = 5 * 60 * 1e3;
+var PERSISTED_CID_LEN = 16;
+var PERSISTED_AEAD_KEY_LEN = 32;
+var PERSISTED_HTX_LEN = 32;
+var PERSISTED_DIRECTION_LEN = 4;
+var MAX_CONNECTED_ACCOUNTS = 1;
+var DAPP_TX_B64 = toBase64(DIR_DAPP_TX);
+var WALLET_TX_B64 = toBase64(DIR_WALLET_TX);
+function isRecord2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function isStringArray(v) {
-  return Array.isArray(v) && v.every((x) => typeof x === "string");
+function hasUnsafeDAppNameCharacter(value) {
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code >= 127 && code <= 159 || code === 1564 || code === 6158 || code >= 8203 && code <= 8207 || code >= 8232 && code <= 8238 || code === 8288 || code >= 8294 && code <= 8297 || code === 65279) {
+      return true;
+    }
+  }
+  return false;
+}
+function canonicalChainId(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > MAX_CHAIN_ID_CHARS || !/^0x[0-9a-fA-F]+$/.test(value)) {
+    return null;
+  }
+  try {
+    return `0x${BigInt(value).toString(16)}`;
+  } catch {
+    return null;
+  }
+}
+function canonicalDAppHttpUrl(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > MAX_DAPP_URL_CHARS || value.trim() !== value) {
+    return null;
+  }
+  try {
+    const url = new URL(value);
+    const hostname = url.hostname.toLowerCase();
+    const isLoopback = isExplicitLoopbackHostname(hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback) || url.username !== "" || url.password !== "" || hostname === "") {
+      return null;
+    }
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
+function isBoundedTimestamp(value, now) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= now + MAX_STORED_CLOCK_SKEW_MS;
+}
+function isCurrentQrlAddressArray(v) {
+  return Array.isArray(v) && v.length <= MAX_CONNECTED_ACCOUNTS && v.every(isCurrentQrlAddress) && new Set(v).size === v.length;
 }
 function isRelayMessage(v) {
-  return isRecord(v) && typeof v.id === "string" && (v.clientType === "dapp" || v.clientType === "wallet") && "message" in v && (typeof v.message === "string" || typeof v.message === "object" && v.message !== null);
+  return isRecord2(v) && typeof v.id === "string" && v.id.length > 0 && v.id.length <= 128 && (v.clientType === "dapp" || v.clientType === "wallet") && "message" in v && (typeof v.message === "string" && v.message.length <= MAX_RELAY_CIPHERTEXT_CHARS || isRecord2(v.message));
 }
 var MESSAGE_TYPE_BY_VALUE = Object.fromEntries(
   Object.values(MessageType).map((m) => [m, m])
 );
 function parseJsonRpcResponse(msg) {
-  if (typeof msg.id !== "string" && typeof msg.id !== "number") return null;
+  if (msg.jsonrpc !== "2.0" || !isValidJsonRpcId(msg.id)) return null;
+  const hasResult = Object.prototype.hasOwnProperty.call(msg, "result");
+  const hasError = Object.prototype.hasOwnProperty.call(msg, "error");
+  if (hasResult === hasError) return null;
   const out = {
-    jsonrpc: typeof msg.jsonrpc === "string" ? msg.jsonrpc : "2.0",
+    jsonrpc: "2.0",
     id: msg.id
   };
-  if ("result" in msg) out.result = msg.result;
-  if (msg.error !== void 0) {
-    if (!isRecord(msg.error) || typeof msg.error.message !== "string") return null;
+  if (hasResult) out.result = msg.result;
+  if (hasError) {
+    const code = isRecord2(msg.error) ? msg.error.code : void 0;
+    if (!isRecord2(msg.error) || typeof code !== "number" || !Number.isSafeInteger(code) || typeof msg.error.message !== "string" || msg.error.message.length === 0 || msg.error.message.length > MAX_JSON_RPC_ERROR_MESSAGE_CHARS) {
+      return null;
+    }
     out.error = {
-      code: typeof msg.error.code === "number" ? msg.error.code : -32e3,
+      code,
       message: msg.error.message,
       data: msg.error.data
     };
@@ -997,18 +1704,38 @@ function parseJsonRpcResponse(msg) {
   return out;
 }
 function parsePersistedKex(v) {
-  if (!isRecord(v)) return null;
-  const { cid, kAeadRaw, htx, sendDir, recvDir, sendSeq, recvSeq } = v;
-  if (typeof cid !== "string" || typeof kAeadRaw !== "string" || typeof htx !== "string" || typeof sendDir !== "string" || typeof recvDir !== "string" || typeof sendSeq !== "number" || !Number.isInteger(sendSeq) || sendSeq < 0 || typeof recvSeq !== "number" || !Number.isInteger(recvSeq) || recvSeq < 0) {
+  if (!isRecord2(v)) return null;
+  const { protocolVersion, cid, kAeadRaw, htx, sendDir, recvDir, sendSeq, recvSeq } = v;
+  if (protocolVersion !== PROTOCOL_VERSION || typeof cid !== "string" || typeof kAeadRaw !== "string" || typeof htx !== "string" || typeof sendDir !== "string" || typeof recvDir !== "string" || typeof sendSeq !== "number" || !Number.isSafeInteger(sendSeq) || sendSeq >= Number.MAX_SAFE_INTEGER || sendSeq < 0 || typeof recvSeq !== "number" || !Number.isSafeInteger(recvSeq) || recvSeq >= Number.MAX_SAFE_INTEGER || recvSeq < 0 || !isCanonicalBase64OfLength(cid, PERSISTED_CID_LEN) || !isCanonicalBase64OfLength(kAeadRaw, PERSISTED_AEAD_KEY_LEN) || !isCanonicalBase64OfLength(htx, PERSISTED_HTX_LEN) || !isCanonicalBase64OfLength(sendDir, PERSISTED_DIRECTION_LEN) || !isCanonicalBase64OfLength(recvDir, PERSISTED_DIRECTION_LEN) || sendDir !== DAPP_TX_B64 || recvDir !== WALLET_TX_B64) {
     return null;
   }
-  return { cid, kAeadRaw, htx, sendDir, recvDir, sendSeq, recvSeq };
+  return {
+    protocolVersion: PROTOCOL_VERSION,
+    cid,
+    kAeadRaw,
+    htx,
+    sendDir,
+    recvDir,
+    sendSeq,
+    recvSeq
+  };
 }
 function parseDAppMetadata(v) {
-  if (!isRecord(v) || typeof v.name !== "string" || typeof v.url !== "string") return null;
-  const meta = { name: v.name, url: v.url };
-  if (typeof v.icon === "string") meta.icon = v.icon;
-  if (typeof v.redirectUrl === "string") meta.redirectUrl = v.redirectUrl;
+  if (!isRecord2(v) || typeof v.name !== "string" || v.name.length === 0 || v.name.length > MAX_DAPP_NAME_CHARS || v.name.trim() !== v.name || hasUnsafeDAppNameCharacter(v.name) || typeof v.url !== "string") {
+    return null;
+  }
+  const url = canonicalDAppHttpUrl(v.url);
+  if (!url) return null;
+  const meta = { name: v.name, url };
+  if (v.icon !== void 0) {
+    if (typeof v.icon !== "string" || v.icon.length > MAX_DAPP_ICON_CHARS) return null;
+    meta.icon = v.icon;
+  }
+  if (v.redirectUrl !== void 0) {
+    const redirectUrl = canonicalDAppHttpUrl(v.redirectUrl);
+    if (!redirectUrl) return null;
+    meta.redirectUrl = redirectUrl;
+  }
   return meta;
 }
 function parseStoredSession(raw) {
@@ -1018,19 +1745,32 @@ function parseStoredSession(raw) {
   } catch {
     return null;
   }
-  if (!isRecord(v) || v.version !== 3) return null;
+  if (!isRecord2(v) || v.version !== 5) return null;
   if (typeof v.channelId !== "string" || typeof v.chainId !== "string") return null;
-  if (typeof v.createdAt !== "number" || typeof v.lastActivity !== "number") return null;
+  const parsedChainId = canonicalChainId(v.chainId);
+  if (!parsedChainId || parsedChainId !== v.chainId) return null;
+  let encodedChannelId;
+  try {
+    encodedChannelId = toBase64(cidFromString(v.channelId));
+  } catch {
+    return null;
+  }
+  const now = Date.now();
+  if (!isBoundedTimestamp(v.createdAt, now) || !isBoundedTimestamp(v.lastActivity, now) || v.lastActivity < v.createdAt) {
+    return null;
+  }
   const keyExchange = parsePersistedKex(v.keyExchange);
   const dappMetadata = parseDAppMetadata(v.dappMetadata);
-  if (!keyExchange || !dappMetadata || !isStringArray(v.connectedAccounts)) return null;
+  if (keyExchange?.cid !== encodedChannelId || !dappMetadata || !isCurrentQrlAddressArray(v.connectedAccounts)) {
+    return null;
+  }
   return {
-    version: 3,
+    version: 5,
     channelId: v.channelId,
     keyExchange,
     dappMetadata,
     connectedAccounts: v.connectedAccounts,
-    chainId: v.chainId,
+    chainId: parsedChainId,
     createdAt: v.createdAt,
     lastActivity: v.lastActivity
   };
@@ -1044,15 +1784,36 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     this.connectedAccounts = [];
     this.unresponsiveTimer = null;
     this.reconnectProbeTimer = null;
+    this.restoreInFlight = null;
     this.failedReconnects = 0;
     this.walletPresent = false;
     this.pendingRestore = null;
     this.messageQueue = Promise.resolve();
     this.outboundQueue = Promise.resolve();
-    this.dappMetadata = options.dappMetadata;
-    this.relayUrl = options.relayUrl ?? DEFAULT_RELAY_URL;
-    this.chainId = options.chainId ?? "0x0";
+    this.persistenceQueue = Promise.resolve();
+    this.persistenceBroken = false;
+    this.sessionCreatedAt = Date.now();
+    this.sessionGeneration = 0;
+    this.consecutiveDecryptFailures = 0;
+    const dappMetadata = parseDAppMetadata(options.dappMetadata);
+    if (!dappMetadata) throw new Error("Invalid or unbounded dApp metadata");
+    const initialChainId = canonicalChainId(options.chainId ?? "0x0");
+    if (!initialChainId) throw new Error("Invalid chainId");
+    this.dappMetadata = dappMetadata;
+    this.relayUrl = normalizeRelayUrl(options.relayUrl ?? DEFAULT_RELAY_URL);
+    this.chainId = initialChainId;
     this.storageKey = options.storageKey ?? `${STORAGE_KEY_PREFIX}:session`;
+    this.storage = getBrowserStorage();
+    const lockManager = getBrowserLockManager();
+    this.persistenceEnabled = this.storage !== null && lockManager !== null;
+    this.sessionOwnership = this.persistenceEnabled && lockManager ? new SessionOwnership(this.storageKey, lockManager) : null;
+    if (this.storage && !this.persistenceEnabled) {
+      warn(
+        "ConnectionManager",
+        "Web Locks unavailable; disabling persisted sessions for AEAD safety"
+      );
+      this.removeStoredSession();
+    }
     const stored = this.readStoredSession();
     if (stored) {
       this.channelId = stored.channelId;
@@ -1060,6 +1821,7 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       this.chainId = stored.chainId;
       this.dappMetadata = stored.dappMetadata;
       this.pendingRestore = stored;
+      this.sessionCreatedAt = stored.createdAt;
       log("ConnectionManager", `Found persisted session for channel ${this.channelId}`);
     } else {
       this.channelId = randomUuid();
@@ -1069,50 +1831,35 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
   }
   // ── Setup ──────────────────────────────────────────────────
   setupSocketListeners() {
-    this.socketClient.on("connected", () => {
-      if (this.status === "reconnecting" /* RECONNECTING */) {
-        this.failedReconnects = 0;
-      }
-    });
-    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();
-        }
-      } else {
-        this.setStatus("waiting" /* WAITING */);
-      }
+    const socketClient = this.socketClient;
+    const isCurrentSocket = () => this.socketClient === socketClient;
+    socketClient.on("reconnected", (result) => {
+      void this.handleAutoReconnected(socketClient, result);
     });
-    this.socketClient.on("disconnected", () => {
+    socketClient.on("disconnected", () => {
+      if (!isCurrentSocket()) return;
       this.walletPresent = false;
-      if (this.status === "connected" /* CONNECTED */) {
+      if (this.keyExchange?.areKeysExchanged() && (this.status === "connected" /* CONNECTED */ || this.status === "reconnecting" /* RECONNECTING */ || this.status === "waiting" /* WAITING */)) {
         this.setStatus("reconnecting" /* RECONNECTING */);
         this.failedReconnects++;
-        if (this.failedReconnects >= _ConnectionManager.MAX_RECONNECT_FAILURES) {
+        if (this.failedReconnects === _ConnectionManager.MAX_RECONNECT_FAILURES) {
           this.emit("connection_lost");
         }
       }
     });
-    this.socketClient.on("message", (data) => {
-      this.enqueueRelayMessage(data);
+    socketClient.on("message", (data) => {
+      if (!isCurrentSocket()) return;
+      const context = this.captureSessionWorkContext();
+      if (context?.socketClient !== socketClient) return;
+      this.enqueueRelayMessage(data, context);
     });
-    this.socketClient.on("error", (err) => {
+    socketClient.on("error", (err) => {
+      if (!isCurrentSocket()) return;
       this.emit("error", err);
     });
-    this.socketClient.on("participants_changed", (data) => {
+    socketClient.on("participants_changed", (data) => {
+      if (!isCurrentSocket()) return;
+      if (data.clientType !== "wallet") return;
       if (data.event === "join" && data.clientType === "wallet") {
         this.walletPresent = true;
         log("ConnectionManager", "Wallet joined channel");
@@ -1125,97 +1872,248 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       }
       if (data.event === "close") {
         log("ConnectionManager", "Wallet closed the channel (explicit terminate)");
-        this.handleSessionTerminated();
+        this.handleSessionTerminated(true);
         return;
       }
       if (data.event === "disconnect" || data.event === "leave") {
-        if (data.clientType === "wallet" || !data.clientType) {
-          this.walletPresent = false;
-          if (this.keyExchange?.areKeysExchanged() && (this.status === "connected" /* CONNECTED */ || this.status === "reconnecting" /* RECONNECTING */)) {
-            this.setStatus("waiting" /* WAITING */);
-          }
-          log("ConnectionManager", "Wallet left channel");
+        this.walletPresent = false;
+        if (this.keyExchange?.areKeysExchanged() && (this.status === "connected" /* CONNECTED */ || this.status === "reconnecting" /* RECONNECTING */)) {
+          this.setStatus("waiting" /* WAITING */);
         }
+        log("ConnectionManager", "Wallet left channel");
       }
     });
   }
+  async handleAutoReconnected(socketClient, result) {
+    if (this.socketClient !== socketClient) return;
+    const context = this.captureSessionWorkContext();
+    if (context?.socketClient !== socketClient) return;
+    if (result.terminated) {
+      log("ConnectionManager", "Channel terminated, observed on auto-reconnect");
+      this.handleSessionTerminated(true);
+      return;
+    }
+    this.walletPresent = result.participants.includes("wallet");
+    for (const message of result.bufferedMessages) {
+      this.enqueueRelayMessage(message, context, false);
+    }
+    await this.messageQueue;
+    if (!this.isSessionWorkCurrent(context)) return;
+    if (context.keyExchange.areKeysExchanged() && this.walletPresent) {
+      this.clearReconnectProbe();
+      this.failedReconnects = 0;
+      this.setStatus("connected" /* CONNECTED */);
+    } else {
+      this.setStatus("waiting" /* WAITING */);
+      if (context.keyExchange.areKeysExchanged()) this.armReconnectProbe();
+    }
+  }
   setupKeyExchangeListeners() {
-    if (!this.keyExchange) return;
-    this.keyExchange.on("keys_exchanged", () => {
+    const keyExchange = this.keyExchange;
+    const generation = this.sessionGeneration;
+    if (!keyExchange) return;
+    keyExchange.on("keys_exchanged", () => {
+      if (this.keyExchange !== keyExchange || this.sessionGeneration !== generation) return;
       log("ConnectionManager", "Key exchange complete");
       this.clearReconnectProbe();
-      this.setStatus("connected" /* CONNECTED */);
       this.walletPresent = true;
       this.failedReconnects = 0;
-      void this.persistSession();
-      void this.sendEncrypted({
+      const originatorInfoSend = this.sendEncrypted({
         type: "originator_info" /* ORIGINATOR_INFO */,
         originatorInfo: {
           ...this.dappMetadata,
           chainId: this.chainId
         }
       });
+      this.setStatus("connected" /* CONNECTED */);
+      void originatorInfoSend.catch((err) => {
+        error("ConnectionManager", "Failed to send originator info:", err);
+      });
     });
   }
   // ── Public API ─────────────────────────────────────────────
   /**
-   * Generate a new v2 connection URI. Rotates channel id and keypair.
+   * Generate a new v3 connection URI. Rotates channel id, keypair, and the
+   * QR-only pairing capability.
    * Returns a `qrlconnect://?q=…` URI safe for QR-rendering or deep-link.
    */
   async getConnectionURI(retryOnConflict = true) {
+    const acquisitionGeneration = this.sessionGeneration;
+    if (!await this.acquireSessionOwnership()) {
+      throw new Error("This QRL Connect session is active in another browser tab");
+    }
+    if (this.sessionGeneration !== acquisitionGeneration) {
+      throw new Error("QRL Connect session changed while browser-tab ownership was pending");
+    }
+    if (retryOnConflict && (this.socketClient.getChannelId() !== null || this.pendingRestore !== null || this.keyExchange !== null)) {
+      await this.resetForNewChannel();
+    }
+    this.invalidateSessionWork();
+    this.socketClient.leaveChannel();
+    this.socketClient.disconnect();
+    this.socketClient = new SocketClient(this.relayUrl, "dapp");
+    this.setupSocketListeners();
     this.setStatus("connecting" /* CONNECTING */);
     this.clearReconnectProbe();
     this.pendingRestore = null;
     this.walletPresent = false;
-    if (this.keyExchange) {
-      this.keyExchange.reset();
-    } else {
-      this.keyExchange = new KeyExchange(true);
-      this.setupKeyExchangeListeners();
-    }
-    const pk = this.keyExchange.initiate();
-    this.channelId = randomUuid();
-    this.socketClient.setPublicKey(toBase64(pk));
-    this.socketClient.connect();
+    this.consecutiveDecryptFailures = 0;
+    const accountsWereAuthorized = this.connectedAccounts.length > 0;
+    this.connectedAccounts = [];
+    if (accountsWereAuthorized) this.emit("accounts_changed", []);
     try {
-      await this.socketClient.joinChannel(this.channelId);
+      this.removeStoredSessionOrThrow();
     } catch (err) {
-      if (retryOnConflict && this.isDappParticipantConflictError(err)) {
-        warn(
-          "ConnectionManager",
-          "Channel already has an active dApp participant. Rotating to a fresh channel."
+      this.setStatus("disconnected" /* DISCONNECTED */);
+      throw err;
+    }
+    this.persistenceBroken = false;
+    this.sessionCreatedAt = Date.now();
+    this.keyExchange = new KeyExchange(true);
+    this.setupKeyExchangeListeners();
+    const initiated = this.keyExchange.initiate();
+    const pk = initiated.publicKey;
+    const capability = initiated.capability;
+    let context = null;
+    try {
+      this.channelId = randomUuid();
+      context = this.captureSessionWorkContext();
+      if (!context) throw new Error("Failed to initialize QRL Connect session");
+      context.socketClient.setPublicKey(toBase64(pk));
+      context.socketClient.connect();
+      try {
+        await context.socketClient.joinChannel(context.channelId);
+        this.assertSessionWorkCurrent(context);
+      } catch (err) {
+        if (!this.isSessionWorkCurrent(context)) throw err;
+        if (retryOnConflict && this.isDappParticipantConflictError(err)) {
+          warn(
+            "ConnectionManager",
+            "Channel already has an active dApp participant. Rotating to a fresh channel."
+          );
+          this.channelId = randomUuid();
+          return await this.getConnectionURI(false);
+        }
+        this.invalidateSessionWork();
+        this.keyExchange = null;
+        context.socketClient.leaveChannel();
+        context.socketClient.disconnect();
+        this.setStatus("disconnected" /* DISCONNECTED */);
+        await this.releaseSessionOwnership();
+        throw err;
+      }
+      this.setStatus("waiting" /* WAITING */);
+      let uri;
+      try {
+        uri = await generateConnectionURI(
+          cidFromString(context.channelId),
+          pk,
+          capability,
+          this.relayUrl === DEFAULT_RELAY_URL ? void 0 : this.relayUrl
         );
-        this.channelId = randomUuid();
-        return this.getConnectionURI(false);
+        this.assertSessionWorkCurrent(context);
+      } catch (err) {
+        if (this.isSessionWorkCurrent(context)) {
+          this.invalidateSessionWork();
+          this.keyExchange = null;
+          context.socketClient.leaveChannel();
+          context.socketClient.disconnect();
+          this.setStatus("disconnected" /* DISCONNECTED */);
+          await this.releaseSessionOwnership();
+        }
+        throw err;
+      }
+      log("ConnectionManager", `Generated v3 connection URI for channel ${context.channelId}`);
+      return uri;
+    } catch (err) {
+      if (context ? this.isSessionWorkCurrent(context) : this.keyExchange !== null) {
+        this.invalidateSessionWork();
+        this.keyExchange = null;
+        this.socketClient.leaveChannel();
+        this.socketClient.disconnect();
+        this.setStatus("disconnected" /* DISCONNECTED */);
+        await this.releaseSessionOwnership();
       }
-      this.setStatus("disconnected" /* DISCONNECTED */);
       throw err;
+    } finally {
+      capability.fill(0);
     }
-    this.setStatus("waiting" /* WAITING */);
-    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() {
+    if (this.restoreInFlight) return this.restoreInFlight;
+    const task = this.reconnectNow().finally(() => {
+      this.restoreInFlight = null;
+    });
+    this.restoreInFlight = task;
+    return task;
+  }
+  async reconnectNow() {
+    if (this.keyExchange?.areKeysExchanged()) return true;
     if (!this.pendingRestore) return false;
+    const acquisitionGeneration = this.sessionGeneration;
+    if (!await this.acquireSessionOwnership()) {
+      this.setStatus("disconnected" /* DISCONNECTED */);
+      return false;
+    }
+    if (this.sessionGeneration !== acquisitionGeneration) return false;
+    const latest = this.readStoredSession();
+    if (!latest) {
+      this.pendingRestore = null;
+      this.connectedAccounts = [];
+      const storageInvalidated = this.clearSession();
+      if (storageInvalidated) {
+        await this.releaseSessionOwnership();
+      } else {
+        this.emit(
+          "error",
+          new Error("Unable to invalidate stored session; retaining browser-tab ownership")
+        );
+      }
+      this.setStatus("disconnected" /* DISCONNECTED */);
+      return false;
+    }
+    this.pendingRestore = latest;
+    this.channelId = latest.channelId;
+    this.connectedAccounts = latest.connectedAccounts;
+    this.chainId = latest.chainId;
+    this.dappMetadata = latest.dappMetadata;
+    this.sessionCreatedAt = latest.createdAt;
+    this.invalidateSessionWork();
+    const restoreGeneration = this.sessionGeneration;
+    const restoreChannelId = this.channelId;
+    const restoreSocketClient = this.socketClient;
     this.setStatus("reconnecting" /* RECONNECTING */);
     this.walletPresent = false;
+    this.consecutiveDecryptFailures = 0;
     try {
       const session = await KeyExchange.sessionFromPersisted(this.pendingRestore.keyExchange);
+      if (this.sessionGeneration !== restoreGeneration || this.channelId !== restoreChannelId || this.socketClient !== restoreSocketClient) {
+        return false;
+      }
       this.keyExchange = new KeyExchange(true, session);
+      this.pendingRestore = null;
       this.setupKeyExchangeListeners();
     } catch (err) {
+      if (this.sessionGeneration !== restoreGeneration || this.channelId !== restoreChannelId || this.socketClient !== restoreSocketClient) {
+        return false;
+      }
       error("ConnectionManager", "Failed to hydrate persisted session:", err);
-      this.clearSession();
+      const storageInvalidated = this.clearSession();
       this.pendingRestore = null;
+      this.connectedAccounts = [];
+      this.keyExchange = null;
+      if (storageInvalidated) {
+        await this.releaseSessionOwnership();
+      } else {
+        this.emit(
+          "error",
+          new Error("Unable to invalidate stored session; retaining browser-tab ownership")
+        );
+      }
       this.setStatus("disconnected" /* DISCONNECTED */);
       return false;
     }
@@ -1229,23 +2127,27 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
    * that the caller has reset walletPresent + set RECONNECTING status.
    */
   async joinAndSettle() {
-    this.socketClient.connect();
+    const context = this.captureSessionWorkContext();
+    if (!context) return false;
+    context.socketClient.connect();
     try {
-      const { bufferedMessages, participants, terminated } = await this.socketClient.joinChannel(
-        this.channelId
+      const { bufferedMessages, participants, terminated } = await context.socketClient.joinChannel(
+        context.channelId
       );
+      if (!this.isSessionWorkCurrent(context)) return false;
       if (terminated) {
         log("ConnectionManager", "Stored session was terminated by the wallet; dropping it");
-        this.handleSessionTerminated();
+        this.handleSessionTerminated(true);
         return false;
       }
       if (participants.includes("wallet")) {
         this.walletPresent = true;
       }
       for (const msg of bufferedMessages) {
-        this.enqueueRelayMessage(msg);
+        this.enqueueRelayMessage(msg, context, false);
       }
       await this.messageQueue;
+      if (!this.isSessionWorkCurrent(context)) return false;
       if (this.keyExchange?.areKeysExchanged() && this.walletPresent) {
         this.clearReconnectProbe();
         this.setStatus("connected" /* CONNECTED */);
@@ -1255,6 +2157,7 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       }
       return true;
     } catch (err) {
+      if (!this.isSessionWorkCurrent(context)) return false;
       error("ConnectionManager", "Reconnect failed:", err);
       this.setStatus("disconnected" /* DISCONNECTED */);
       return false;
@@ -1283,20 +2186,71 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       }
     }
   }
+  /**
+   * Make sure the socket is open and joined to the paired session's channel
+   * so an outbound request can be routed - or relay-buffered if the wallet is
+   * currently absent (its socket dies within seconds of the app
+   * backgrounding; the relay holds channel traffic for it). Revives the
+   * socket after a probe-timeout teardown and hydrates a cold stored
+   * session. Returns false when there is no session to revive (never paired,
+   * explicit disconnect, or the channel was tombstoned).
+   */
+  async ensureChannelJoined() {
+    if (this.keyExchange?.areKeysExchanged()) {
+      if (this.socketClient.isConnected() && this.socketClient.getChannelId()) {
+        return true;
+      }
+      this.setStatus("reconnecting" /* RECONNECTING */);
+      this.walletPresent = false;
+      return this.joinAndSettle();
+    }
+    if (this.pendingRestore) {
+      return this.reconnect();
+    }
+    return false;
+  }
+  /**
+   * True while a pairing exists (handshake complete, session keys in
+   * memory), even when the wallet's socket is momentarily out of the
+   * channel. Survives the reconnect-probe teardown; false after an explicit
+   * disconnect or a relay tombstone.
+   */
+  isPaired() {
+    return this.keyExchange?.areKeysExchanged() ?? false;
+  }
+  /** True while the relay roster last showed the wallet in the channel. */
+  isWalletPresent() {
+    return this.walletPresent;
+  }
   /**
    * 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() {
+  handleSessionTerminated(relayRetired) {
+    this.invalidateSessionWork();
     this.clearReconnectProbe();
     this.clearUnresponsiveTimer();
     this.walletPresent = false;
+    this.consecutiveDecryptFailures = 0;
     this.pendingRestore = null;
+    const accountsWereAuthorized = this.connectedAccounts.length > 0;
+    this.connectedAccounts = [];
+    if (accountsWereAuthorized) this.emit("accounts_changed", []);
     this.keyExchange = null;
     this.socketClient.leaveChannel();
     this.socketClient.disconnect();
-    this.clearSession();
+    const storageInvalidated = this.clearSession();
+    if (storageInvalidated) {
+      void this.releaseSessionOwnership();
+    } else {
+      this.emit(
+        "error",
+        new Error("Unable to invalidate stored session; retaining browser-tab ownership")
+      );
+    }
+    if (!relayRetired) warn("ConnectionManager", "Relay channel termination was not confirmed");
+    this.emit("session_terminated");
     this.setStatus("disconnected" /* DISCONNECTED */);
   }
   armReconnectProbe() {
@@ -1320,28 +2274,70 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     }
   }
   /**
-   * Send a JSON-RPC request to the wallet (async, fire-and-forget).
+   * Send a JSON-RPC request to the wallet. Returns the outbound send promise
+   * (settled on the relay's ack) so callers that must sequence on delivery -
+   * e.g. the provider's wallet-wake redirect, which cannot navigate away
+   * before the ciphertext reaches the relay - can await it. Callers may also
+   * ignore it: failures are logged here either way.
    */
   sendJsonRpc(request) {
     if (!this.keyExchange?.areKeysExchanged()) {
       throw new Error("Not connected: key exchange not complete");
     }
-    this.sendEncrypted({
+    if (!isValidJsonRpcId(request.id)) {
+      throw new Error("Invalid JSON-RPC request id");
+    }
+    if (!isValidJsonRpcMethod(request.method) || classifyRpcMethod(request.method) === "unsupported") {
+      throw new Error("Unsupported JSON-RPC method");
+    }
+    if (request.params !== void 0 && !Array.isArray(request.params)) {
+      throw new Error("JSON-RPC params must be an array");
+    }
+    const sent = this.sendEncrypted({
       type: "jsonrpc" /* JSONRPC */,
       jsonrpc: "2.0",
       id: request.id,
       method: request.method,
       params: request.params
-    }).catch((err) => {
+    });
+    sent.catch((err) => {
       error("ConnectionManager", "Failed to send JSON-RPC:", err);
     });
     this.startUnresponsiveTimer();
+    return sent;
   }
   getStatus() {
     return this.status;
   }
   getAccounts() {
-    return this.connectedAccounts;
+    return [...this.connectedAccounts];
+  }
+  /**
+   * Commit accounts returned by an approved qrl_requestAccounts response.
+   * WALLET_INFO alone cannot grant this authorization.
+   */
+  async authorizeAccounts(value) {
+    if (!isCurrentQrlAddressArray(value) || value.length === 0) {
+      throw new Error("qrl_requestAccounts returned an invalid account list");
+    }
+    const context = this.captureSessionWorkContext();
+    if (!context?.keyExchange.areKeysExchanged()) {
+      throw new Error("Cannot authorize accounts without an established session");
+    }
+    const nextAccounts = [...value];
+    const previousAccounts = this.connectedAccounts;
+    const changed = !this.areArraysEqual(previousAccounts, nextAccounts);
+    this.connectedAccounts = nextAccounts;
+    try {
+      await this.persistSession(context);
+      this.assertSessionWorkCurrent(context);
+    } catch (error2) {
+      if (this.isSessionWorkCurrent(context)) this.connectedAccounts = previousAccounts;
+      await this.teardownPersistenceFailedSession(error2, context);
+      throw error2;
+    }
+    if (changed) this.emit("accounts_changed", [...this.connectedAccounts]);
+    return [...this.connectedAccounts];
   }
   getChainId() {
     return this.chainId;
@@ -1351,9 +2347,9 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
   }
   /** Check (sync) if a persisted session exists and has not expired. */
   hasStoredSession() {
-    if (typeof localStorage === "undefined") return false;
+    if (!this.persistenceEnabled || !this.storage) return false;
     try {
-      const raw = localStorage.getItem(this.storageKey);
+      const raw = this.storage.getItem(this.storageKey);
       if (!raw) return false;
       const session = parseStoredSession(raw);
       if (!session) return false;
@@ -1375,6 +2371,26 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     const timeout = new Promise((resolve) => setTimeout(resolve, TERMINATE_SEND_TIMEOUT_MS));
     await Promise.race([send, timeout]);
   }
+  /**
+   * Ensure this socket is a relay participant before closing a restorable or
+   * temporarily disconnected channel. close_channel is intentionally
+   * participant-only on the relay, so a cold stored session cannot be retired
+   * by emitting the close event from an unjoined socket.
+   */
+  async prepareRelayChannelForRetirement() {
+    const socketChannelId = this.socketClient.getChannelId();
+    const fallbackChannelId = this.pendingRestore !== null || this.keyExchange !== null ? this.channelId : null;
+    const channelId = socketChannelId ?? fallbackChannelId;
+    if (!channelId) return { hadRelayChannel: false, alreadyRetired: false };
+    if (!this.socketClient.isConnected() || socketChannelId !== channelId) {
+      this.socketClient.connect();
+      const result = await this.socketClient.joinChannel(channelId);
+      if (result.terminated) {
+        return { hadRelayChannel: true, alreadyRetired: true };
+      }
+    }
+    return { hadRelayChannel: true, alreadyRetired: false };
+  }
   /**
    * Reset to a fresh channel + keypair. Sends TERMINATE to any live peer,
    * drops the persisted session, and prepares a clean state for
@@ -1384,60 +2400,118 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     this.clearUnresponsiveTimer();
     this.clearReconnectProbe();
     this.walletPresent = false;
-    await this.flushTerminate();
+    const retirement = await this.prepareRelayChannelForRetirement();
+    let relayRetired = retirement.alreadyRetired;
+    try {
+      if (!relayRetired) {
+        await this.flushTerminate();
+        relayRetired = await this.socketClient.closeChannel();
+      }
+    } catch (err) {
+      error("ConnectionManager", "Failed to tombstone reset channel:", err);
+    }
+    if (retirement.hadRelayChannel && !relayRetired) {
+      throw new Error("Unable to retire the previous relay channel");
+    }
+    this.invalidateSessionWork();
     this.socketClient.leaveChannel();
     this.socketClient.disconnect();
-    this.clearSession();
+    const storageInvalidated = this.clearSession();
+    const accountsWereAuthorized = this.connectedAccounts.length > 0;
     this.connectedAccounts = [];
+    if (accountsWereAuthorized) this.emit("accounts_changed", []);
     this.pendingRestore = null;
     this.channelId = randomUuid();
     this.keyExchange = null;
+    this.persistenceBroken = false;
+    this.sessionCreatedAt = Date.now();
     this.socketClient = new SocketClient(this.relayUrl, "dapp");
     this.setupSocketListeners();
     this.setStatus("disconnected" /* DISCONNECTED */);
+    if (!storageInvalidated) {
+      const error2 = new Error(
+        "Unable to invalidate stored session; retaining browser-tab ownership"
+      );
+      this.emit("error", error2);
+      throw error2;
+    }
   }
   async disconnect() {
     this.clearUnresponsiveTimer();
     this.clearReconnectProbe();
     this.walletPresent = false;
-    await this.flushTerminate();
+    let hadRelayChannel = this.socketClient.getChannelId() !== null || this.pendingRestore !== null || this.keyExchange !== null;
+    let relayRetired = false;
+    try {
+      const retirement = await this.prepareRelayChannelForRetirement();
+      hadRelayChannel = retirement.hadRelayChannel;
+      relayRetired = retirement.alreadyRetired;
+      if (hadRelayChannel && !relayRetired) {
+        await this.flushTerminate();
+        relayRetired = await this.socketClient.closeChannel();
+      }
+    } catch (err) {
+      error("ConnectionManager", "Failed to tombstone disconnected channel:", err);
+    }
+    if (hadRelayChannel && !relayRetired) {
+      throw new Error("Unable to retire the relay channel");
+    }
+    this.invalidateSessionWork();
     this.socketClient.leaveChannel();
     this.socketClient.disconnect();
-    this.setStatus("disconnected" /* DISCONNECTED */);
-    this.clearSession();
+    const storageInvalidated = this.clearSession();
     this.connectedAccounts = [];
     this.pendingRestore = null;
     this.keyExchange = null;
+    if (storageInvalidated) await this.releaseSessionOwnership();
+    this.setStatus("disconnected" /* DISCONNECTED */);
+    if (hadRelayChannel && !relayRetired) {
+      warn("ConnectionManager", "Disconnected channel termination was not confirmed");
+    }
+    if (!storageInvalidated) {
+      const error2 = new Error(
+        "Unable to invalidate stored session; retaining browser-tab ownership"
+      );
+      this.emit("error", error2);
+      throw error2;
+    }
   }
   // ── Internals ──────────────────────────────────────────────
-  enqueueRelayMessage(data) {
+  enqueueRelayMessage(data, context, settleConnection = true) {
     if (!isRelayMessage(data)) {
       warn("ConnectionManager", "Dropping malformed relay envelope");
       return;
     }
-    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;
-      this.clearReconnectProbe();
-      if (this.keyExchange?.areKeysExchanged() && this.status !== "connected" /* CONNECTED */) {
+    if (data.id !== context.channelId || data.clientType !== "wallet") {
+      warn("ConnectionManager", "Dropping relay envelope for the wrong channel or peer role");
+      return;
+    }
+    this.messageQueue = this.messageQueue.then(() => this.handleRelayMessage(data, context)).then(() => {
+      if (settleConnection && this.isSessionWorkCurrent(context) && context.keyExchange.areKeysExchanged() && this.walletPresent) {
         this.failedReconnects = 0;
         this.setStatus("connected" /* CONNECTED */);
       }
-    }
+    }).catch((err) => {
+      error("ConnectionManager", "messageQueue handler error:", err);
+    });
+  }
+  async handleRelayMessage(data, context) {
+    if (!this.isSessionWorkCurrent(context)) return;
+    this.walletPresent = true;
+    this.clearReconnectProbe();
     const message = data.message;
-    if (isRecord(message)) {
+    if (isRecord2(message)) {
       if (message.type === "key_handshake_SYNACK" /* SYNACK */) {
-        if (typeof message.ct === "string" && typeof message.c0 === "string") {
-          await this.handleSynAck({
-            type: "key_handshake_SYNACK" /* SYNACK */,
-            ct: message.ct,
-            c0: message.c0,
-            v: typeof message.v === "number" ? message.v : 0
-          });
+        if (isCanonicalBase64OfLength(message.ct, ML_KEM_768_CT_LEN) && isCanonicalBase64OfLength(message.c0, SYNACK_C0_LEN)) {
+          await this.handleSynAck(
+            {
+              type: "key_handshake_SYNACK" /* SYNACK */,
+              ct: message.ct,
+              c0: message.c0,
+              v: typeof message.v === "number" ? message.v : 0
+            },
+            context
+          );
         } else {
           warn("ConnectionManager", "Dropping malformed SYNACK");
         }
@@ -1448,60 +2522,157 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
         return;
       }
     }
-    if (typeof message === "string" && this.keyExchange?.areKeysExchanged()) {
+    if (typeof message === "string" && context.keyExchange.areKeysExchanged()) {
+      let decrypted;
+      try {
+        decrypted = await context.keyExchange.decryptMessage(message);
+      } catch (err) {
+        if (!this.isSessionWorkCurrent(context)) return;
+        error("ConnectionManager", "Failed to decrypt message:", err);
+        this.consecutiveDecryptFailures++;
+        if (this.consecutiveDecryptFailures >= _ConnectionManager.MAX_DECRYPT_FAILURES) {
+          await this.teardownDesyncedSession(context);
+        }
+        return;
+      }
+      if (!this.isSessionWorkCurrent(context)) return;
+      this.consecutiveDecryptFailures = 0;
+      try {
+        await this.persistSession(context);
+      } catch (err) {
+        await this.teardownPersistenceFailedSession(err, context);
+        return;
+      }
+      if (!this.isSessionWorkCurrent(context)) return;
       try {
-        const decrypted = await this.keyExchange.decryptMessage(message);
-        await this.persistSession();
         const parsed = JSON.parse(decrypted);
-        if (isRecord(parsed)) {
-          this.handleDecryptedMessage(parsed);
+        if (isRecord2(parsed)) {
+          await this.handleDecryptedMessage(parsed, context);
         } else {
           warn("ConnectionManager", "Dropping non-object decrypted payload");
         }
       } catch (err) {
-        error("ConnectionManager", "Failed to decrypt message:", err);
+        error("ConnectionManager", "Failed to handle decrypted message:", err);
       }
     }
   }
-  async handleSynAck(msg) {
-    if (!this.keyExchange) return;
+  /**
+   * The receive stream is cryptographically unrecoverable: the peer's send
+   * counter is ahead of our recv counter for good (relay buffer TTL/cap
+   * dropped a ciphertext), so every future message would fail its tag.
+   * An encrypted TERMINATE cannot communicate this (the desynced peer could
+   * not open it either); tombstone the channel on the relay instead so the
+   * wallet learns the pairing is dead even if it only re-joins later, then
+   * clear local state and surface the standard terminated teardown.
+   */
+  async teardownDesyncedSession(context) {
+    if (!this.isSessionWorkCurrent(context)) return;
+    warn("ConnectionManager", "AEAD stream desynced beyond recovery; terminating session");
+    let relayRetired = false;
+    try {
+      relayRetired = await context.socketClient.closeChannel();
+    } catch (err) {
+      error("ConnectionManager", "Failed to tombstone desynced channel:", err);
+    }
+    if (!this.isSessionWorkCurrent(context)) return;
+    this.handleSessionTerminated(relayRetired);
+  }
+  async teardownPersistenceFailedSession(cause, context = this.captureSessionWorkContext(), reason = "AEAD counter persistence failed; terminating session before further use") {
+    if (!context || !this.isSessionWorkCurrent(context)) return;
+    error("ConnectionManager", `${reason}:`, cause);
+    let relayRetired = false;
+    try {
+      relayRetired = await context.socketClient.closeChannel();
+    } catch (err) {
+      error("ConnectionManager", "Failed to tombstone unusable channel:", err);
+    }
+    if (!this.isSessionWorkCurrent(context)) return;
+    this.handleSessionTerminated(relayRetired);
+  }
+  async handleSynAck(msg, context) {
+    if (!this.isSessionWorkCurrent(context)) return;
     this.setStatus("key_exchange" /* KEY_EXCHANGE */);
     let response;
     try {
-      response = await this.keyExchange.onSynAck(cidFromString(this.channelId), msg);
+      response = await context.keyExchange.onSynAck(cidFromString(context.channelId), msg);
     } catch (err) {
+      if (!this.isSessionWorkCurrent(context)) return;
       const e = err instanceof Error ? err : new Error(String(err));
       error("ConnectionManager", "SYNACK processing failed:", e);
       this.emit("error", e);
+      let relayRetired = false;
+      try {
+        relayRetired = await context.socketClient.closeChannel();
+      } catch (closeError) {
+        error("ConnectionManager", "Failed to tombstone rejected handshake:", closeError);
+      }
+      if (this.isSessionWorkCurrent(context)) this.handleSessionTerminated(relayRetired);
       return;
     }
+    if (!this.isSessionWorkCurrent(context)) return;
     if (response) {
-      this.sendPlaintext(response);
+      try {
+        await this.sendPlaintext(response, context);
+        this.assertSessionWorkCurrent(context);
+        context.keyExchange.confirmOriginatorAckDelivered();
+      } catch (err) {
+        if (!this.isSessionWorkCurrent(context)) return;
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        error("ConnectionManager", "ACK delivery failed; retiring provisional session:", error2);
+        this.emit("error", error2);
+        let relayRetired = false;
+        try {
+          relayRetired = await context.socketClient.closeChannel();
+        } catch (closeError) {
+          error("ConnectionManager", "Failed to tombstone ambiguous handshake:", closeError);
+        }
+        if (this.isSessionWorkCurrent(context)) this.handleSessionTerminated(relayRetired);
+      }
       return;
     }
-    const cachedAck = this.keyExchange.getLastAck();
-    if (this.keyExchange.areKeysExchanged() && cachedAck) {
+    const cachedAck = context.keyExchange.getLastAck();
+    if (context.keyExchange.areKeysExchanged() && cachedAck) {
       log("ConnectionManager", "Duplicate SYNACK after handshake; re-sending cached ACK");
-      this.sendPlaintext(cachedAck);
+      try {
+        await this.sendPlaintext(cachedAck, context);
+      } catch (err) {
+        error("ConnectionManager", "Failed to re-send cached ACK:", err);
+      }
     }
   }
-  handleDecryptedMessage(msg) {
+  async handleDecryptedMessage(msg, context) {
+    if (!this.isSessionWorkCurrent(context)) return;
     this.clearUnresponsiveTimer();
     const type = typeof msg.type === "string" ? msg.type : "";
     switch (MESSAGE_TYPE_BY_VALUE[type]) {
       case "wallet_info" /* WALLET_INFO */: {
-        const nextAccounts = isStringArray(msg.accounts) ? msg.accounts : [];
-        const nextChainId = typeof msg.chainId === "string" && msg.chainId ? msg.chainId : this.chainId;
-        const accountsChanged = !this.areArraysEqual(this.connectedAccounts, nextAccounts);
-        const chainChanged = this.chainId !== nextChainId;
-        this.connectedAccounts = nextAccounts;
-        this.chainId = nextChainId;
-        void this.persistSession();
+        if (!isCurrentQrlAddressArray(msg.accounts)) {
+          warn("ConnectionManager", "Dropping wallet info with malformed account addresses");
+          break;
+        }
+        const reportedAccounts = [...msg.accounts];
+        const nextAccounts = this.connectedAccounts.length > 0 && this.areArraysEqual(this.connectedAccounts, reportedAccounts) ? this.connectedAccounts : [];
+        let nextChainId = this.chainId;
+        if (msg.chainId !== void 0) {
+          const parsedChainId = canonicalChainId(msg.chainId);
+          if (!parsedChainId || parsedChainId !== msg.chainId) {
+            warn("ConnectionManager", "Dropping wallet info with malformed chain id");
+            break;
+          }
+          nextChainId = parsedChainId;
+        }
+        const accountsChanged = !this.areArraysEqual(this.connectedAccounts, nextAccounts);
+        const chainChanged = this.chainId !== nextChainId;
+        this.connectedAccounts = [...nextAccounts];
+        this.chainId = nextChainId;
+        void this.persistSession(context).catch((err) => {
+          void this.teardownPersistenceFailedSession(err, context);
+        });
         this.emit("wallet_info", {
-          accounts: this.connectedAccounts,
+          accounts: [...this.connectedAccounts],
           chainId: this.chainId
         });
-        if (accountsChanged) this.emit("accounts_changed", this.connectedAccounts);
+        if (accountsChanged) this.emit("accounts_changed", [...this.connectedAccounts]);
         if (chainChanged) this.emit("chain_changed", this.chainId);
         break;
       }
@@ -1516,21 +2687,29 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       }
       case "terminate" /* TERMINATE */: {
         log("ConnectionManager", "Received terminate from wallet");
-        void this.disconnect();
+        let relayRetired = false;
+        try {
+          relayRetired = await context.socketClient.closeChannel();
+        } catch (err) {
+          error("ConnectionManager", "Failed to tombstone terminated channel:", err);
+        }
+        if (this.isSessionWorkCurrent(context)) this.handleSessionTerminated(relayRetired);
         break;
       }
       default:
         log("ConnectionManager", `Unhandled message type: ${type}`);
     }
   }
-  sendPlaintext(message) {
-    this.socketClient.sendMessage({
-      id: this.channelId,
+  async sendPlaintext(message, context = this.captureSessionWorkContext()) {
+    if (!context || !this.isSessionWorkCurrent(context)) {
+      throw new Error("Cannot send plaintext for a retired session");
+    }
+    await context.socketClient.sendMessage({
+      id: context.channelId,
       clientType: "dapp",
       message
-    }).catch((err) => {
-      error("ConnectionManager", "Failed to send plaintext:", err);
     });
+    this.assertSessionWorkCurrent(context);
   }
   /**
    * Serialize every encrypt+persist+send on a single outbound queue.
@@ -1541,24 +2720,53 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
    * already prevented by the synchronous seq reservation in KeyExchange.)
    */
   sendEncrypted(message) {
-    const task = this.outboundQueue.then(() => this.sendEncryptedNow(message));
+    const context = this.captureSessionWorkContext();
+    if (!context) return Promise.reject(new Error("sendEncrypted: not connected"));
+    const task = this.outboundQueue.then(() => this.sendEncryptedNow(message, context));
     this.outboundQueue = task.then(
       () => void 0,
       () => void 0
     );
     return task;
   }
-  async sendEncryptedNow(message) {
-    if (!this.keyExchange?.areKeysExchanged()) {
+  async sendEncryptedNow(message, context) {
+    if (!context.keyExchange.areKeysExchanged()) {
       throw new Error("sendEncrypted: not connected");
     }
-    const encrypted = await this.keyExchange.encryptMessage(JSON.stringify(message));
-    await this.persistSession();
-    await this.socketClient.sendMessage({
-      id: this.channelId,
-      clientType: "dapp",
-      message: encrypted
-    });
+    this.assertSessionWorkCurrent(context);
+    let encrypted;
+    try {
+      encrypted = await context.keyExchange.encryptMessage(JSON.stringify(message));
+    } catch (err) {
+      await this.teardownPersistenceFailedSession(
+        err,
+        context,
+        "Message encryption failed after counter reservation; terminating session"
+      );
+      throw err;
+    }
+    this.assertSessionWorkCurrent(context);
+    try {
+      await this.persistSession(context);
+    } catch (err) {
+      await this.teardownPersistenceFailedSession(err, context);
+      throw err;
+    }
+    this.assertSessionWorkCurrent(context);
+    try {
+      await context.socketClient.sendMessage({
+        id: context.channelId,
+        clientType: "dapp",
+        message: encrypted
+      });
+    } catch (err) {
+      await this.teardownPersistenceFailedSession(
+        err,
+        context,
+        "Relay send outcome unknown; terminating session before further use"
+      );
+      throw err;
+    }
   }
   startUnresponsiveTimer() {
     this.clearUnresponsiveTimer();
@@ -1588,40 +2796,93 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
     return true;
   }
   // ── Persistence ────────────────────────────────────────────
-  async persistSession() {
-    if (typeof localStorage === "undefined") return;
-    if (!this.keyExchange) return;
-    const persistedKex = await this.keyExchange.exportPersisted();
-    if (!persistedKex) return;
-    const session = {
-      version: 3,
+  invalidateSessionWork() {
+    this.sessionGeneration++;
+    this.keyExchange?.reset();
+    this.messageQueue = Promise.resolve();
+    this.outboundQueue = Promise.resolve();
+    this.persistenceQueue = Promise.resolve();
+  }
+  captureSessionWorkContext() {
+    if (!this.keyExchange) return null;
+    return {
+      generation: this.sessionGeneration,
       channelId: this.channelId,
+      keyExchange: this.keyExchange,
+      socketClient: this.socketClient
+    };
+  }
+  isSessionWorkCurrent(context) {
+    return context.generation === this.sessionGeneration && context.channelId === this.channelId && context.keyExchange === this.keyExchange && context.socketClient === this.socketClient;
+  }
+  assertSessionWorkCurrent(context) {
+    if (!this.isSessionWorkCurrent(context)) {
+      throw new Error("QRL Connect session changed while encrypted work was pending");
+    }
+  }
+  async acquireSessionOwnership() {
+    if (!this.persistenceEnabled) return true;
+    if (!this.sessionOwnership) return false;
+    return this.sessionOwnership.acquire();
+  }
+  async releaseSessionOwnership() {
+    await this.sessionOwnership?.release();
+  }
+  persistSession(context) {
+    const task = this.persistenceQueue.then(() => this.persistSessionNow(context));
+    this.persistenceQueue = task.then(
+      () => void 0,
+      () => void 0
+    );
+    return task;
+  }
+  async persistSessionNow(context) {
+    this.assertSessionWorkCurrent(context);
+    if (!this.persistenceEnabled || !this.storage) return;
+    if (!this.sessionOwnership?.isOwned()) {
+      throw new Error("Cannot persist AEAD counters without browser-tab ownership");
+    }
+    if (this.persistenceBroken) {
+      throw new Error("AEAD counter persistence is unavailable");
+    }
+    const persistedKex = await context.keyExchange.exportPersisted();
+    if (!persistedKex) throw new Error("Cannot export established AEAD session");
+    this.assertSessionWorkCurrent(context);
+    if (!this.sessionOwnership?.isOwned()) {
+      throw new Error("Browser-tab ownership changed while persisting AEAD counters");
+    }
+    const session = {
+      version: 5,
+      channelId: context.channelId,
       keyExchange: persistedKex,
       dappMetadata: this.dappMetadata,
       connectedAccounts: this.connectedAccounts,
       chainId: this.chainId,
-      createdAt: this.pendingRestore?.createdAt ?? Date.now(),
+      createdAt: this.sessionCreatedAt,
       lastActivity: Date.now()
     };
     try {
-      localStorage.setItem(this.storageKey, JSON.stringify(session));
+      this.storage.setItem(this.storageKey, JSON.stringify(session));
     } catch (err) {
-      warn("ConnectionManager", "localStorage.setItem failed:", err);
+      this.persistenceBroken = true;
+      this.removeStoredSession();
+      error("ConnectionManager", "Failed to persist AEAD counters:", err);
+      throw new Error("Failed to persist AEAD counters");
     }
   }
   readStoredSession() {
-    if (typeof localStorage === "undefined") return null;
+    if (!this.persistenceEnabled || !this.storage) return null;
     try {
-      const raw = localStorage.getItem(this.storageKey);
+      const raw = this.storage.getItem(this.storageKey);
       if (!raw) return null;
       const session = parseStoredSession(raw);
       if (!session) {
         log("ConnectionManager", "Dropping legacy or malformed session from storage");
-        localStorage.removeItem(this.storageKey);
+        this.removeStoredSession();
         return null;
       }
       if (Date.now() - session.createdAt > SESSION_TTL_MS) {
-        localStorage.removeItem(this.storageKey);
+        this.removeStoredSession();
         return null;
       }
       return session;
@@ -1629,452 +2890,207 @@ var _ConnectionManager = class _ConnectionManager extends EventEmitter3 {
       return null;
     }
   }
+  removeStoredSession() {
+    if (!this.storage) return true;
+    try {
+      this.storage.removeItem(this.storageKey);
+      return true;
+    } catch (removeError) {
+      try {
+        this.storage.setItem(this.storageKey, '{"version":0}');
+        warn("ConnectionManager", "localStorage.removeItem failed; invalidated record instead");
+        return true;
+      } catch (overwriteError) {
+        warn(
+          "ConnectionManager",
+          "Unable to invalidate persisted session:",
+          removeError,
+          overwriteError
+        );
+        return false;
+      }
+    }
+  }
+  removeStoredSessionOrThrow() {
+    if (!this.removeStoredSession()) {
+      throw new Error("Unable to clear the previous persisted AEAD session");
+    }
+  }
   clearSession() {
-    if (typeof localStorage === "undefined") return;
-    localStorage.removeItem(this.storageKey);
+    return this.removeStoredSession();
   }
 };
 _ConnectionManager.MAX_RECONNECT_FAILURES = 5;
+// Nonces derive from the recv counter and there is no gap tolerance, so a
+// genuinely desynced stream (peer advanced past us, e.g. the relay's
+// buffer TTL dropped a ciphertext) fails EVERY subsequent open. Two in a
+// row cannot happen on a healthy stream; requiring the second guards
+// against a one-off injected junk ciphertext killing a live session.
+_ConnectionManager.MAX_DECRYPT_FAILURES = 2;
 var ConnectionManager = _ConnectionManager;
 
-// src/utils/platform.ts
-function isMobileBrowser() {
-  if (typeof navigator === "undefined") return false;
-  return /Android|iPhone|iPad|iPod|Opera Mini|IEMobile|WPDesktop/i.test(navigator.userAgent);
-}
-function getAppStoreUrl() {
-  if (typeof navigator !== "undefined" && /android/i.test(navigator.userAgent)) {
-    return "https://play.google.com/store/apps/details?id=com.chiefdg.myqrlwallet";
+// 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/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");
   }
-  return "https://apps.apple.com/app/myqrlwallet/id6742219498";
+  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 attemptWalletRedirect(uri, timeoutMs = 1800) {
-  if (typeof window === "undefined" || typeof document === "undefined") {
-    return Promise.resolve(false);
+function bytesToHex(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new Error("bytes must be a Uint8Array");
   }
-  if (!uri.trim().toLowerCase().startsWith("qrlconnect:")) {
-    return Promise.resolve(false);
+  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 new Promise((resolve) => {
-    let settled = false;
-    const finish = (opened) => {
-      if (settled) return;
-      settled = true;
-      document.removeEventListener("visibilitychange", onVisibility);
-      window.removeEventListener("pagehide", onHide);
-      window.clearTimeout(timer);
-      resolve(opened);
-    };
-    const onVisibility = () => {
-      if (document.visibilityState === "hidden") finish(true);
-    };
-    const onHide = () => {
-      finish(true);
-    };
-    document.addEventListener("visibilitychange", onVisibility);
-    window.addEventListener("pagehide", onHide);
-    const timer = window.setTimeout(() => {
-      finish(false);
-    }, timeoutMs);
-    try {
-      window.location.href = uri;
-    } catch {
-      finish(false);
-    }
-  });
+  return out;
 }
 
-// src/QRLConnectProvider.ts
-var QRL_CONNECT_PROVIDER_INFO = {
-  name: "MyQRLWallet",
-  rdns: "com.qrlwallet.connect",
-  icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMAAAADACAYAAABS3GwHAAAAAXNSR0IArs4c6QAAH1dJREFUeF7tnXt8XGWZ+L/PmaT3JpOkrVCKgD9wFcELwgoLArIsWnDLCnIVgZ8gF1lcylVsk5xMKuXiiiKLn7L82OWiK1ZBtgpdFRDdAu4P1EVAuaNoQbrNTJJek5nzbN+TpE0nk8yZmTMzZybv/AXNe3ue9/me9/a8zyvYn9XAJNaATGLZrehWA1gArBFMag1YACZ191vhLQDWBia1BiwAk7r7rfAWAGsDk1oDFoBJ3f1WeAuAtYFJrQELwKTufiu8BcDawKTWwKQEQF0cwGGtPQjMtv6ngA8m8ViJJ6D1TsekAEDZZugu01MeHxLlIBXmi7A7ymwxKNjfdg1ohkEV3sDhj+LxG8fhN7M7eVGkPmGodwBEXRp7MpwdE7pUZBYwq96FDpHnLQqbFF2dXsf5c29hY72NCnVrC6+6TGvxOA6HK1TlQyNGUbcCh2j1I0WNnv8IbFH0+kbhG7Nc3ixDdVUpsi7tQRXp66TDE7lSYEZVNFuPlQoZ9XhePF0UX8bL9SBi3QHwxtXMnTqFOx2Rj6J2kRu6kZq1gOqrHpzV0sWaWp8S1RUA6tLQq6wAOdvf5bG/smlAlDcyaT2m9RqeKVslFSi4bgDQk4gl38VpTkzutF/+CliOX4X+clD427kuaytVY9j11A0AvS4f8zx5QMROe8I2knHLM5MhR7/a4nJpxeoMuaK6AEBdZvSqfBPhePv1D9lC8hSnqhlxeGfc5ZXK1hxObXUBwLp2PhgTecQRZoejFltKYA0IKqqrmoQTxSUdOF9EEtY8AGbLM9nJchG5quaFiYhRFNoMsyBOD+rRbct5rtC81U5f8zbzrMuU3TxeR2RetZU5WetXYTOefqolwX21poOaB6CvnUM8kTXYxW9VbU887WzuJlHVRhRRec0D0NPOGXbrs4ieDz2LfqvZ5Yxac5qreQCS7ZwtMbnd7v6EbtEFFegvhLs43gJQkNpKT5zswEWks+ZJLl0VVSvBOM2J6oPNXRxnAahwN6RclqnKEgtAhRU/XN0Oj1H9SdzlGAtAhfsh1cEyRJaEXW2WK3DYxVesvOwrXWF/KCwAFevK3BWVGYC1Ar9WYSvKXwD7hm1A5VafwgaUx0Ukqei7BPYL01FwBAAR/XFzJx+1I0C5ezSr/LIBoDyVdvSCQXhu17UM9s5jgcbkq8Ci2oFAN6ny8fQWnpwzg409MF/SnOU0SHdYmwYWgAobfHZ1ZQFAzf1XvTCeMK7VO34plwNB/hNlapXFDlS94+llTd18ZXRic3Le6/I0iBkJSv7ZKVDJKiytgLIAAF7G0/e2dfPsTsZzHo2pXUiJSPRvmQnqoIc1uTyWreFkB3eKyKdL0/xQbjsChKHFEsooFwADm3S3eTeMvfua7GCDiMwsockVyaqKxlQPberm8Ryj5i2IXBhGQ+wIEIYWSyijXAA0bNLdZlUAAH8PvQT5x82qaMbRw9pyjAA9nXzDQS4Io1oLQBhaLKGMcgFQiRFg2Hg8M48QQ4HxZwrrHvMEAKQ6+QYWAN/qyvLxKcGeC85aLgDKPgIMXS7/sQ5yVXwKT/dvpcVr5DOKXI3QUnLHWAAC2VLJeg5USxkT9Q6fBIdchVdOAPwvv2r/xkH2WrCc9SNtNwNBbwfLNYy7DRaAQCZRDwAkPJX2kAUpPwDo3S1djNmJSbmcLCp3KEwL1IPjJao0AKI/jtuDsJK6rKjMPS6fc5Cbzf52iBCUDYBRi8abW7q4OFvoZDtHSExWmbilRSlkx3Ay7iI4zDXAqOp+EHdZZE+CS+q1wjMnl7IIR75vFpAWgFH6q9AIsL1G1RXNCS6stUBZIdpM4cYbRo7XFzN99mzWqMgHQhSmeiNAgiPEq60RQJWNip7SmuCHYfRpJcsI0WYq2eyd61rfznsckTUiNIfUCm9wUBfMvYY3xkxRQjgIG5oGae4pkMuRgvx7yVMgQTPkPgcIdQpk9rJEvxnv4sxa+/rXxTaob0oraOz9E2ci0sFQ3P9SwfYym3WPtuv5Y6UBSLkchcr9Jox7KTAbyDzRQ3MdhKU6uBWRz5ZSvn9ioWz20LtFuKrFJVVSeVXKXKqhVKnZY6s1r75sgDkDyhUxOA+V4heRDt5AWt89bxkv5likGleIkn2BxNGbm10+n13+epePxVRWopTmbmF8gWJ6WFPHWFeIpMud4skZJXReWhx9IOOxYn2Sh/f5OltLKKuqWesGgGwtbn8GCfhpQBUfCby0nljbDKa1XkdvrmxJl3jqNbbsuSfpoOWOLsfUQS+NNG9btLtsyq7jyfNofHsDU+euY4D34BVahyn/uWdx5s5lytwj2Swnk8mu49WzmbZnC/LURtL984O//OK33Zye1mAArPFMoG4BCGjzNtkk14AFYJIbwGQX3wIw2S1gkstvAZjkBjDZxa9bAMyDGX9cwJQFG0lTwEJvshvEePI/tRZpGyC25wGofL52d32y5atbAPpdTsio3BFmBAQLh7kCqa+0dLF/veiibgFIuZwLcmsIh2L10tchyaFes9AoLl5IBVa1mLoFINnOHeLImVXVbn1W7pHWD8W/xJP1IF5dAvCIS8P7lZcFeXs9dFKUZFDjAuHpP8QT3FyLvj91vwbwb1W5nIgn37FvBoSPztAlfn1gQDhlnsuG8GuobIl1NwKoy7Skx68dERPK0P7Ko4GUJ/rhVre23wg2qqk7AFJL+aTE5K6SrxSWx3DqotThUeC7zeb6ppkS1fCvrgDQi5na28IqRP6mhvsk8k33LV7QtKfHz0nwg1peC9QVAKkOrlGRq+tKqAjiMOqT/9y0Rj12+lJ+H8FmBmpSXdiKv/Bt5xxicovqtj3qQKLbRKVoYCSol6Dfbe7i1FodBWreVozx9yzhEKdRvo2ye10ubEqx1HLnFVRVv7RZWD4/x/2Gcldfavk1D8CGL/LegUZWjez517xApfZoNfKbB0TQpc0u/1hrI0FN24u5DB8TVqrIu+2XvxqWP6rO4TcVkg537OWypcqtCVx9rQIgqaW8Q2PyXYT3GX+fWhUkcE/VQEJVMg66uOm33CIrx17FjKIINWk3PVfR7EzjRypykDX+aJmVwFtk9LCmZbxUC9OhmgPALHqTnSxzRK6wOz7RMv7trRFe1y16eMu1vBbRFo5qatRbmNW+1BIOpIHHFWmw8/4Id57oyuZd+ZScz2CEW1lbrhD9LvMGPX4mw34+NTd8RdkSwm6bkgQ9KZ7gobCLDrO8mrEhf+rTwRdFJGFuedVMw8PsrVorS/VXzQk+GOW1QM3YUZ/LnLTKzwXMY8/2VwsaGLo7cGFzglujCkFN2JL5+qdcFm8Ld2gOWuyvhjSg8OtG0YWz3LEvbkZBjJqwp3VXMnvKdHpGFr5RUJxtQ34NDL+AuQXVM+IJvpc/R+VT1AQAyXYucWLyFfMKTOVVZGssRQPDdwe+3exyehTvDkTeoNRlSm+Ge3Dk70rpCJu3ihpQtPlNnSq3Rm9LNPIA9Lrs7XnyIxH2qmIX2qpL0YDxGPX0spYEN5ZSTDnyRh6AVAd/DfIfKsQi39hy9FC9lKm8Ek/o/4maOJG3qWQnX0fkIuvzEzXTCd6e4cszPekBPWTucl4InrP8KSMPQE8nv3WQd5VfFWNrGHPbW1GzkFPV14FnUNZFbmEnzBy+GHSAiDSqICObB9Xq7GE9blTVk1oTPFiNvhyvzmrpJJAO3rycmVNn0C9SHW/nkW08NUG2RB9FuL95Xx7iuW0hMjuHoyFETYMj1HYhSdhPMhxNTBahvBthrlRrJ01RD726JcH1UToUi1r3jQZDejr4uIPcX5UAV+b1Q/QnONzcAE/MdnkrELURTGRiJa3P8L6Yw+miXKQisZFmVswABBXVrzUJl0UprmjF5C/ULvyL7h2ciyMrKh3gVmGTI7q8B768p8vWKH2xCtXj6PTDwQMOwOFuVfmLkB8Xz9s0z9PVr/yZRQdGaDs00gCkOvmyiCyuKADK8+roF+Iu99eL4WdbZu9S9vEa+GdUjjB/q5QRqOqj8d34myi5SFdK9rxfh+wEZuHW67LaD3JVuXnrgIge0eTyi3o1/hE9+weMHj/FkYONrithCIo+E5dt3qEuAwUbRJkyVELuopruA9DFGlQOKaqAAjMppDSjn2pdxgP5spp7CZkBFiA4NOZLXdm/Dw7C1Eb6XofX3pPH0JIue6KsBDmwEoag6Np4G++I0gszlZC7KAsYHgEeAzm4qAIKyTR0UrksnqBzvC+/eXc4leZwhHYceYfAjAqOTIVIgwqDqvqWeNwbb+BLEy06e5ZwmBPjUUScgiopIrGqbo47tEqEokZEHAB5DCgrAMNbnS9s3qof3TXHHVazcOxbyt6eQyeIceiKrM6yFrx+/E5zZiHC4rjLfbng9l3NO7gBkcvKLpio9vcyc/cb2VwEP2XJUnaZi2310AhQGQDU04tbu7k5V1t7ExzkZbhdkP2KlaVa+bYf5Cn9it7csh/tuV6O37yMPbYMysOAGdnK97MABNdtpQBA9c1mh91yTRP8ub7Hz6iPtwYGRPXSpi5uyT69Ni9q9u7LTYp8rqy7QhaAiAFgDmc87WpKkMieHqx1mTE9wz0Sk+OiOtcPrs3tez9vOsL+TS7/k53XvKugMVlpAShcq2XJUaERwMuoHtuW4D+yhTCLQ2mQ+2Hboq0sElahUEE9T29rSXB+NvDrL6bJaZNUWV0l7AgQvNMrAYAqr3uqC9u6eTarZdLTzhXiyHV1Y/wjAopmnK28rWk563daNJs1VydrEdkleC8VmFJV+/vtIjiQ1ioBAPDSgOjCeS4vZRtDXxf/piqnBGpsLSUy0760Htu8jNVZu0YGgJsRubBsUz47AgS3lAoB8AKiC+Mur+xkDC5OUlkjyMF1NwIYQVU/mX1J3d/u7SShIkssAMHttGwpKwTA7zZv1YXZ+//+oZfHHxHZtZyLwnyvy5UNPtUL4glWZI8AqXYSErMAlM2oCym4EgAI/NbbqsdmB3E1APR6rFWRt4UJwIjBi/rz7w0qJEVGHQoN+Ty1qjllhl0E/PinYf881c+1JviGBaByjoAF92HVAVD+pAwtCIv9Eo/+woswiKc/8Rzubsjwe1F6BgdZ23ItfduVsxIn9d8saHRoGoixv6PmPjQnINIc5rTEArDDHIvt24INutAM9QCAcUXwlM2oPtrQyOLZS3mhkCuUfjzUq2hypnM1npwHNCFsv8xSqE5H0lsALAC+BiacApU6AhiHNE8fUFixPsnD+3zdvKNV/K/vat6pU/i0Il+gxKmRBcACUF4AhpzQuuNvsExuJW32XYo3/R05zdqkP80+Xsy4bMs7ii3TAmABKB8Awp8yGU20dvPP5bhU43tvtvNeiXEXxkGviMtCFgALQLkASKvoOXG4eyIffGPE27vAjA1d/v830MngyF/ywbPRZf6gmscnCg8ZYwGwAJQDgC2qem1Lgq6JpiappeylDoc7wpGKHOXH8Bm5iuL5M6XfAQ9kMtzb18gvJ3pytH8p7047sgrBj7gWdEfDAmABCB0AFb0j3sn/HW+XR29iamqd71/0KYG9TajHcacv5mEJpVdV18QGuXz2cp7PeZnFnFekOUEdvkMBwZMsABaAsAH4Q0x04WyX57K//mY7N/kFdpdp3CciHyh4zq4kM+j5rb/l3lxv75ry+1xu90TOCurJaQGwAIQHwNAzQFc3jxPxzGxfelO4B+T9xeza+JMipX+bA09nPMFXc40EySXsITF5hIARtC0AFoDQAPAjHXSxIJdhPusyZb7HE/6Xv8jfdvcJYat6+tl4YtsCO2tb1Xdk6+CfPJELg6wDLAAWgFAA8C/Ue3pVvJvrs+3bxDWdPoP/p1K6S/WOu736cibDEXO+xJ+y6+t1+UtP5fEgL2haACwAoQAAvInocXGXX2YbZMrlKFTMu1jxIj/+O2XbMRLoyrjLyWPWGkMerK8gske+UcACYAEIC4BfDogeNy/HC4gpl9tQOScM49+5DPViwvtmuzyTXXayg8WIfMUCEFzr+XQVvKSQU9aCM5yn+mCLw8dzHXqlOiSF0ByyWoZi/Xi6rCVBR3bZ61zmN6qMmR5lp7MjgB0BSh4BzJTEQ5e1ddGebWAblnJM2pHVZQvrLnLPuvXeWdkOdn4kC+XPgsyaCDwLgAUgFABQPbMlYXxydvz8EORLuZIGWV7wnn+e4WLUjtAvnK16XPbF9hcvZurcVn6uyEETDe0WAAtAyQCYAjzVM1oTfDMbgGQnNznD75qFOQUa5VL6pDl4y47voytoTK31PUWPNvWOB4EFwAJQVgBSndxUrof9hiHICcDwucMDiJibZBaAAF8fuwge705wgAsxonpGc44RoKedy5yYXF/Gly2fdHKMAGYKNKeV/8wX7tyOAHYEKHkEGHJR0EuzH3/2T2XbOcUT+Va5niASYVUTeqq4bBr9kXt9MdNnN5kQLxMHt7IAWABKBsC3f/T7LV18InukNY/S9apsNKeyAUbhwpIM3Tb7WryLS7NdIt5ymdXoSV++EO4WAAtAKACI8POB6Xrc3KuMs9rOv2Qn3xPkhMKsO39qAU88PbypmzVj6mznbBz5l3zzWguABSAUAIA/eKLHteY4le1p51REbhdh+kQL0vwmvyOFmXY56GMvvsGRuV5aTHbwMxH5cL4yLQAWgLAAwPP0tNZuvp1tdH1X05ZulB+K8KHQAFDdOOjxgXnLeDG7vrVX8fYZ0+TVINMuC4AFIDwAVH/RkuCQXO7Q2165PFg9+b4Kb8s3Lcn31QbSil4bfw4318WYVAdLcKQ7yOGbBcACEBoAZiWcUT21rZvvjFkMD/npm6nQvypMCWDkOyXZfvJr5v2ijzfBUbmeGO2/mrmZKWKiPR8QpA4LgAUgPAD8kvTphkGOmXUNfx4DwdB7vGepSIfAgiAG6pc4klDNS/V6+5ZNXLHLlzE7S9mQSLKDC0TEvHHmBBlpLAAWgJABwNOMuvFlLBvv8npSWRBD/k2FQyaapuwcQUs3Ocq5TXO4d7y3dde77BvzeEpFpgVda1gALAChAjB8b/fPafS0OQl+OsFbww19cLLncYkgB+SK8+nfMlPWgd7uDHLD7OX0jFden8ucTIZ7cOSokS61I0DQMXYoXRB9FVZiSKlr4T7AaFGHIViP6okt3Tw6kRp6Xfb2PB4Wkd1zTGnw3RzgR/mCa6U6+S7IopFYoUE7044AdgQIdQQYbcQCj2U8vaC127+xNW5M0GQn3YIszQbA5E+LLmxzR4VNz0qUWk6LbuVGQc40H4pCv2QWAAtA2QAYXsD+QVQvb3a2nQa7eLlGg94OLtKhhevOi1qPR+IxXSQuG3Lkk75raPW28E8qcmKxD2hYACwAZQVgWL0DqLpbNnFTrt2bng4ucnIAgMfDAzE9fl4WACYy9AY4POPJahWmFvrVHw2TBcACUAkA/Pu7qC5t7mJ59kJ2XADg4QEZC4A5Wc40ym8QSn63zAJgAagYAIJ2N7m4JQPgMsdTed68IVbqPoMFwAJQMQAUTcRdukICwESObrMAlKoBC0DlADAvxXSFNgJYAMKz/REbCLnEkIqrtXOAnGKbNQB6XbPLF0sdAYy/T3qKvCTmobwSf3YKZEeA0EYAcz3LcVjleST9qP4yfLg49F8iyg/iORzlCl0Er7uS2Y1TuV6FmX5IIvMz9Snq3zmI8WGQ+dYbtLCvQ9DDw8JKDSF1TYwAQlLRS+Kd3DXRmXouV4ZCARiy93FqUehtZ091+JGI7J1P/XYEsCNAKCOAonfG2zhvPEe1iQyx0HOAfEZt/v7WUvaZEhNzAj2h67UFwAIQCgC5wqIEMVSTZlwAlIcGHP277IOwIOWqy5Q+5SFFDpsovQXAAhAKAI7qlU0JbghinNlp+jq5wUMuz/53VZ7C0aNbXFKFlvuqy7QW5Tcw8TTIAmABCAUA4L/Mqe1c1wSkDfYYtpnHr1/C/IZGeRQdet1xp5+Sdhz9xGyXH5p/D1LuyNqgbwlLvJgkbFiU4J8OuwgeLzKcx1oVeduwEY6vUdUHcfhXzC6QQybt5V6oNjioCpoZpKXR4RKdIHqDSSeqyx3hcY+h4Fe5yjVl+ovjNLNo4EjgErMnlK9T7QhgR4DtI8CmrXrsrtfy2mgLN45nvUEBGCIkox6bRHJ7fvpl+zdd/G3LmQiNeb9R/hkCW/AYGHeHyZwyDN2DnGoc5IK6RlsALABDGlCex9OF8WWYcCLbfwaAlPIyyJ55R4C8lhytBP67Bp6e09bN7TvJDJJqJyExWRLkLKEoqUS1v5eZu9/I5qLylyFTvtGyDFUGK7IS5wDAS7JVFzZfy0ujW+W6OJ/P8KA4ckxkFRRMjTulGrmdo6qLWhOsygagr5OEShkBUNX+fgtAoK6rCADKy+LpwuasQFNmUZnq5DZBPhOosTWSyAfArC8yelC8m6fGjAAd3CWOnG5HgAh0aEUAEPodRxc2dYyNs5layieJiXn8ouB4PhFQ35gm7LibqU/HXd4vQ2uMHdM+RXpdkiDhv2s2UoudAgU3jQoBoJ6nn25J8K3s7cZ1VzK/cbo8BLwreKujndJsLXlbObR1OU+Mcc5rZ3/HkafLKoEFILh6KwGA/wn09OF4gqPHfBHNW18dfEaRFSLEgrc8milNVGkVXfkrOOMjLunsVvZ2cLGK3FTW1lsAgqu3EgAMtyatg3pQyzX8Ort1eh6NqV1YIkhH2V58DK6SklKq0hNz9NAmF3OnYKffepemmHIPyMdKqiRfZgtAPg1lz0nlMeDg4LmKS6mqqzb0c0qu7bk3L2fmtFl0qifnOg7xkb324mqqfC6BAU91TczjwqZlmCuVY37JJRwuDfIgMKOsLbQABFdvBUeAbcEb/MXwyc0uJsDsmJ9ezNRknL8Uh0tRFokjYtoX6S1Sc+SGvuDAP+JwX/aLkiNCGtl6W3gakXcG750iU1oAgiuukgAMtUqfHhAOncgL0/e5uYEZPX2c1ugwLwP7IGV4Bim4mnZOaRoorBN4LZPhv1ti23a3XHSCUI1Tkhm+5sTk/LJtfY5uoQUgeM9WHACzP47++6atfHbX5SY25/i/nS6mjBv7LbisoaUcNSTlc6LzH/Pr4HQVuYUQrlkGksECEEhNQ99jf1+6MmuAnVrl6bc3xThnftYLjMFbHv2U3zmJ2DHv4SPq+TfIKjeTswAEN45qAeD7rIneoxmua+nmV8FbXDspezr8MO6LRaS8i95slVgAghtJtQDwW+g/Rcobnqrb2sVt2WcEwaWITkpfn0v5IDHuVJF9io0rWpJEFoDg6qsqACPN9KM86P9XjxUNaZ6YNXXbI9QuW4NLUeWUCskvsHtsOvuqcqIipwvMGPLMrsLPAhBc6ZEAYEdzzcnpWoW3QJ8R5QmHsaepwaUrX8rtoagd9lI4DJVdBXYDP5xKdX8WgOD6jxgA2xtupkNR2vjJpdFR74sV/HZA8B4qIqUFILjSogpAcAmqm7Jq05yJxLYABDcKC0BwXdVMSgtA8K7yAejkMUTK7gsUvFU2ZSkaUHRTXGgTly2llBNm3qpsBgQRwACQ7OSnMUc+XGsOaEHkm5xp9JV1Pey7z9ejs5MWXQCGriV+VUQuroifyuS0yIpKLaJrmnblI3I+gxWteILKIg1Abwfn4sgKC0BUzKW0dgj6gybhE5LjQk5pJRefO7IAGJFSSziQmPxXrV9GKb576iinf7qu3XHzXFTWfeRqShlpAIzHYrKDPzgiC6qpJFt3KBrYguoZ8QT3TvR+cig1FVBIpAEwciQ7uVFE/sFOgwro1YglHYrfSDLj6F/NyXEls5rNjTwAPe0cKo6sFphVTUXZuovXwBAAel9LghOKL6U8OSMPQP81zM1skfsRDimPCmyp5daACplG9IBZLuUNu1KEIJEHwMjU4/L3DnKTnQYV0cNRyKJ6T3MXp0Vp8TuilpoAQG9iau96ngTZLwr9adsQXAMKKRE9Me7ycPBclUtZEwAYdaxfwsFOTB4UIV459diaStKA2e709PaX3uTCA2+NzuHXaJlqBgB1aUjBF0Wl04TEL6ljbOaya2DIbVyfUTi8mOeeyt7A4QpqBgB/LXAVzTKVR8SR99v1QKVMpLh6VPl9rFE/2tSeOxhXcaWGn6umADDi97vMS3vcjshx5v9rToDw+zB6Jaqm1eOk+POskpVkotfAHS2qSfvZ4LLLoCercXivmBfZ7S9CGtD/QTil2eWRfLGJotDomjWedS7zG5TlIJ8cHdOyZgWKgjWU0gb//TN93vM4z0SkE3eC99JKqSfkvDVtL4+4NLzPY7Eg1/nL4qjH6wy58yJTnDF91bviczlPPh8dX/8g+qlpAEYE7GlnfxEWI3K8QGsQwW2aEDSgbFb0CXW4bf16vheliy5BpasLAIyw+hWm9/Wx27aAVuercpEg00bcqEeiJNSNsEF7txzphp56VRH9oedxIw6/irv01sJ8P5c66s4m/MC159GQmsup0sCxiOyB0qZKswgzUaZplCI6l8NIQyhTzLQGBkT8J01Tah7sVv29Oqz20jzU1s3voujaUKjodQdAtgKSLnFJ00YDzQqzxGNqxqv9J48K7eiC0zvoFIetXobNoqQGlU2tL7A26tuahcpZ9wBMoJDJLHsQO4l6/K8gMuRNY40gr4psgnrWgAWgnnvXypZXAxaAvCqyCepZAxaAeu5dK1teDVgA8qrIJqhnDVgA6rl3rWx5NfC/zGV/wHfd+nEAAAAASUVORK5CYII="
-};
-var EIP6963_ANNOUNCE_EVENT = "eip6963:announceProvider";
-var EIP6963_REQUEST_EVENT = "eip6963:requestProvider";
-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;
-    // Random per-instance prefix keeps request ids unique across page loads.
-    // A bare counter restarts at 1 on reload, and the relay buffers messages
-    // for 5 minutes, so a stale buffered response could otherwise be matched
-    // to a fresh request that drew the same small id.
-    this.requestIdPrefix = randomUuid().slice(0, 8);
-    this.requestCounter = 0;
-    this.isQRLConnect = true;
-    this.options = options;
-    if (options.debug) {
-      setDebug(true);
-    }
-    this.connectionManager = new ConnectionManager({
-      dappMetadata: options.dappMetadata,
-      relayUrl: options.relayUrl,
-      chainId: options.chainId,
-      storageKey: options.storageKey
-    });
-    this.setupConnectionListeners();
-    if (options.autoReconnect !== false) {
-      void this.connectionManager.reconnect();
-    }
-    this.setupResumeListeners();
-    if (options.announceProvider !== false) {
-      this.startEip6963Announce();
+// src/signing/typedData.ts
+var SLOT = 32;
+var TYPED_DATA_LIMITS = Object.freeze({
+  maxTypes: 32,
+  maxFieldsPerType: 32,
+  maxTotalFields: 256,
+  maxTypeGraphDepth: 12,
+  maxArrayNesting: 12,
+  maxArrayLength: 256,
+  maxEncodedValues: 2048,
+  maxDynamicBytes: 16 * 1024,
+  maxIdentifierLength: 64,
+  maxFieldTypeLength: 128
+});
+function isMessageObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactOwnKeys2(value, expected) {
+  const keys = Object.keys(value);
+  return keys.length === expected.length && expected.every((key) => keys.includes(key));
+}
+function isTypedField(value) {
+  return isMessageObject(value) && hasExactOwnKeys2(value, ["name", "type"]) && typeof value.name === "string" && typeof value.type === "string";
+}
+function isTypeMap(value) {
+  if (!isMessageObject(value)) return false;
+  let typeCount = 0;
+  for (const name in value) {
+    if (!Object.prototype.hasOwnProperty.call(value, name)) continue;
+    typeCount++;
+    if (typeCount > TYPED_DATA_LIMITS.maxTypes) return false;
+    const def = value[name];
+    if (!Array.isArray(def) || def.length > TYPED_DATA_LIMITS.maxFieldsPerType || !def.every(isTypedField)) {
+      return false;
     }
   }
-  startEip6963Announce() {
-    if (typeof window === "undefined" || typeof CustomEvent === "undefined") {
-      return;
-    }
-    const overrides = this.options.providerInfo ?? {};
-    this.eip6963Detail = Object.freeze({
-      info: Object.freeze({
-        uuid: randomUuid(),
-        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();
+  return true;
+}
+function parsePayload(payload) {
+  if (!isMessageObject(payload)) throw new Error("invalid typed data payload");
+  if (!hasExactOwnKeys2(payload, ["types", "primaryType", "domain", "message"])) {
+    throw new Error("typed data payload contains unknown top-level fields");
+  }
+  const { types, primaryType, domain, message } = payload;
+  if (!isTypeMap(types)) throw new Error("typed data types must be a struct map");
+  if (typeof primaryType !== "string") throw new Error("typed data primaryType must be a string");
+  if (!isMessageObject(domain)) throw new Error("typed data domain must be an object");
+  if (!isMessageObject(message)) throw new Error("typed data message must be an object");
+  return { types, primaryType, domain, message };
+}
+var ATOMIC_RE = /^(?:(address|bool|string|bytes)|(u?int)(\d+)|bytes(\d+)|(.+?)\[(\d*)\])$/;
+var IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var UNSAFE_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function consumeValue(budget) {
+  budget.remainingValues--;
+  if (budget.remainingValues < 0) throw new Error("typed data contains too many encoded values");
+}
+function assertIdentifier(value, label) {
+  if (!IDENTIFIER_RE.test(value) || value.length > TYPED_DATA_LIMITS.maxIdentifierLength || UNSAFE_OBJECT_KEYS.has(value)) {
+    throw new Error(`invalid ${label}: ${value}`);
   }
-  /**
-   * 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);
+}
+function parseFieldType(type, types, depth = 0) {
+  if (depth > TYPED_DATA_LIMITS.maxArrayNesting) {
+    throw new Error(`type nesting too deep: ${type}`);
   }
-  /**
-   * 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);
+  if (type.length > TYPED_DATA_LIMITS.maxFieldTypeLength) {
+    throw new Error(`field type too long: ${type}`);
+  }
+  const m = ATOMIC_RE.exec(type);
+  if (m) {
+    const [, atomic, intKind, intWidthStr, bytesWidthStr, innerType, sizeStr] = m;
+    if (atomic === "address" || atomic === "bool" || atomic === "string" || atomic === "bytes") {
+      return { kind: atomic };
     }
-    this.resumeListener = null;
-    if (this.resumeDebounce) {
-      clearTimeout(this.resumeDebounce);
-      this.resumeDebounce = null;
+    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 };
     }
-  }
-  /**
-   * 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) => {
-      log("Provider", `Connection status: ${status}`);
-      this.emit("statusChanged", status);
-      if (status === "connected" /* CONNECTED */) {
-        this.emit("connect", { chainId: this.connectionManager.getChainId() });
-      }
-      if (status === "disconnected" /* DISCONNECTED */) {
-        this.emit("disconnect", {
-          code: 4900,
-          message: "Disconnected from QRL Wallet"
-        });
-      }
-    });
-    this.connectionManager.on("accounts_changed", (accounts) => {
-      this.emit("accountsChanged", accounts);
-    });
-    this.connectionManager.on("chain_changed", (chainId) => {
-      this.emit("chainChanged", chainId);
-    });
-    this.connectionManager.on("jsonrpc_response", (response) => {
-      const pending = this.pendingRequests.get(response.id);
-      if (!pending) {
-        warn("Provider", `No pending request for id ${response.id}`);
-        return;
+    if (bytesWidthStr) {
+      const width = Number(bytesWidthStr);
+      if (!Number.isInteger(width) || width < 1 || width > 32) {
+        throw new Error(`invalid bytesN width: ${type}`);
       }
-      this.pendingRequests.delete(response.id);
-      if (response.error) {
-        pending.reject(new Error(response.error.message || "Request failed"));
-      } else {
-        pending.resolve(response.result);
-      }
-    });
-    this.connectionManager.on("wallet_info", (info) => {
-      for (const [id, pending] of this.pendingRequests) {
-        if (pending.method === "qrl_requestAccounts" || pending.method === "qrl_accounts") {
-          pending.resolve(info.accounts);
-          this.pendingRequests.delete(id);
-        }
-      }
-    });
-    this.connectionManager.on("error", (err) => {
-      warn("Provider", `ConnectionManager error: ${err.message}`);
-      this.emit("message", { type: "error", data: err.message });
-    });
-    this.connectionManager.on("connection_lost", () => {
-      for (const [, pending] of this.pendingRequests) {
-        pending.reject(new Error("Connection to QRL Wallet lost"));
-      }
-      this.pendingRequests.clear();
-    });
-  }
-  /**
-   * Generate a connection URI for QR code display or deep link redirect.
-   */
-  async getConnectionURI() {
-    this.setupResumeListeners();
-    return this.connectionManager.getConnectionURI();
-  }
-  /**
-   * Check if the current browser is mobile.
-   */
-  isMobile() {
-    return isMobileBrowser();
-  }
-  /**
-   * Get the app store URL for the QRL Wallet app.
-   */
-  getAppStoreUrl() {
-    return getAppStoreUrl();
-  }
-  /**
-   * EIP-1193 request method.
-   */
-  async request(args) {
-    const { method, params } = args;
-    if (method === "qrl_chainId") {
-      return this.connectionManager.getChainId();
-    }
-    if (method === "qrl_accounts") {
-      const accounts = this.connectionManager.getAccounts();
-      if (accounts.length > 0) return accounts;
-    }
-    if (!RESTRICTED_METHODS.has(method) && !UNRESTRICTED_METHODS.has(method)) {
-      throw new Error(`Unsupported method: ${method}`);
-    }
-    if (this.connectionManager.getStatus() !== "connected" /* CONNECTED */) {
-      throw new Error("Not connected to QRL Wallet");
+      return { kind: "bytesN", width };
     }
-    const id = `${this.requestIdPrefix}-${++this.requestCounter}`;
-    return new Promise((resolve, reject) => {
-      const pending = {
-        id,
-        method,
-        params,
-        resolve,
-        reject,
-        timestamp: Date.now()
-      };
-      this.pendingRequests.set(id, pending);
-      const timeout = setTimeout(() => {
-        if (this.pendingRequests.has(id)) {
-          this.pendingRequests.delete(id);
-          reject(new Error(`Request timeout: ${method} (${REQUEST_TIMEOUT_MS}ms)`));
+    if (innerType !== void 0) {
+      parseFieldType(innerType, types, depth + 1);
+      if (sizeStr) {
+        const size = Number(sizeStr);
+        if (!Number.isSafeInteger(size) || size <= 0 || size > TYPED_DATA_LIMITS.maxArrayLength) {
+          throw new Error(`invalid array size: ${type}`);
         }
-      }, REQUEST_TIMEOUT_MS);
-      const originalResolve = pending.resolve;
-      const originalReject = pending.reject;
-      pending.resolve = (result) => {
-        clearTimeout(timeout);
-        originalResolve(result);
-      };
-      pending.reject = (error2) => {
-        clearTimeout(timeout);
-        originalReject(error2);
-      };
-      this.connectionManager.sendJsonRpc({
-        jsonrpc: "2.0",
-        id,
-        method,
-        params
-      });
-    });
-  }
-  /**
-   * Get the current connection status.
-   */
-  getStatus() {
-    return this.connectionManager.getStatus();
-  }
-  /**
-   * Get connected accounts.
-   */
-  getAccounts() {
-    return this.connectionManager.getAccounts();
-  }
-  /**
-   * Get the channel ID for this connection.
-   */
-  getChannelId() {
-    return this.connectionManager.getChannelId();
-  }
-  /**
-   * Check if connected and keys exchanged.
-   */
-  isConnected() {
-    return this.connectionManager.getStatus() === "connected" /* CONNECTED */;
-  }
-  /**
-   * Check if a stored session exists that can be reconnected.
-   */
-  hasStoredSession() {
-    return this.connectionManager.hasStoredSession();
-  }
-  /**
-   * Reset the connection and start a fresh pairing with a new channel.
-   * Use this when the user wants to create a new connection instead of
-   * reconnecting to an existing session.
-   */
-  async newConnection() {
-    for (const [, pending] of this.pendingRequests) {
-      pending.reject(new Error("Connection reset"));
-    }
-    this.pendingRequests.clear();
-    await this.connectionManager.resetForNewChannel();
-    return this.getConnectionURI();
-  }
-  /**
-   * 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.
-   */
-  async disconnect() {
-    for (const [, pending] of this.pendingRequests) {
-      pending.reject(new Error("Disconnected"));
+        return { kind: "array", inner: innerType, size };
+      }
+      return { kind: "array", inner: innerType };
     }
-    this.pendingRequests.clear();
-    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/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 shake256Digest(concatBytes(SCHEME_TAG_MSG, messageBytes), DIGEST_LEN);
-}
-
-// src/signing/typedData.ts
-var SLOT = 32;
-function isMessageObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-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 === "address" || atomic === "bool" || atomic === "string" || atomic === "bytes") {
-    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);
-    if (sizeStr) {
-      const size = Number(sizeStr);
-      if (!Number.isInteger(size) || size <= 0) {
-        throw new Error(`invalid array size: ${type}`);
-      }
-      return { kind: "array", inner: innerType, size };
-    }
-    return { kind: "array", inner: innerType };
-  }
-  throw new Error(`unhandled type: ${type}`);
+  throw new Error(`unknown type: ${type}`);
+}
+function isReservedAtomicTypeName(name) {
+  if (/^(?:address|bool|string|bytes)$/.test(name)) return true;
+  const intMatch = /^(?:u?int)(\d+)$/.exec(name);
+  if (intMatch) {
+    const width = Number(intMatch[1]);
+    return Number.isInteger(width) && width >= 8 && width <= 256 && width % 8 === 0;
+  }
+  const bytesMatch = /^bytes(\d+)$/.exec(name);
+  if (bytesMatch) {
+    const width = Number(bytesMatch[1]);
+    return Number.isInteger(width) && width >= 1 && width <= 32;
+  }
+  return false;
 }
 function baseTypeName(type) {
   return type.replace(/(\[\d*\])+$/, "");
@@ -2085,6 +3101,9 @@ function collectDependencies(primary, types) {
   }
   const visited = /* @__PURE__ */ new Set();
   const visit = (name, path) => {
+    if (path.length > TYPED_DATA_LIMITS.maxTypeGraphDepth) {
+      throw new Error(`type graph nesting too deep: ${[...path, name].join(" -> ")}`);
+    }
     if (path.includes(name)) {
       throw new Error(`cyclic type reference: ${[...path, name].join(" -> ")}`);
     }
@@ -2104,16 +3123,30 @@ function collectDependencies(primary, types) {
   return visited;
 }
 function validateTypeMap(types) {
-  for (const [name, def] of Object.entries(types)) {
+  const entries = Object.entries(types);
+  if (entries.length === 0 || entries.length > TYPED_DATA_LIMITS.maxTypes) {
+    throw new Error(`typed data must contain 1-${TYPED_DATA_LIMITS.maxTypes} struct types`);
+  }
+  let totalFields = 0;
+  for (const [name, def] of entries) {
+    assertIdentifier(name, "struct name");
+    if (name !== "QRLDomain" && isReservedAtomicTypeName(name)) {
+      throw new Error(`struct name is reserved by an atomic type: ${name}`);
+    }
     const defUnknown = def;
-    if (!Array.isArray(defUnknown) || def.length === 0) {
+    if (!Array.isArray(defUnknown) || def.length === 0 || def.length > TYPED_DATA_LIMITS.maxFieldsPerType) {
       throw new Error(`empty or invalid struct: ${name}`);
     }
+    totalFields += def.length;
+    if (totalFields > TYPED_DATA_LIMITS.maxTotalFields) {
+      throw new Error("typed data contains too many fields");
+    }
     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}`);
       }
+      assertIdentifier(f.name, `field name in ${name}`);
       if (typeof f.type !== "string" || !f.type) {
         throw new Error(`bad field type in ${name}.${f.name}`);
       }
@@ -2125,6 +3158,7 @@ function validateTypeMap(types) {
   }
 }
 function encodeType(primary, types) {
+  validateTypeMap(types);
   const deps = collectDependencies(primary, types);
   const others = [...deps].filter((n) => n !== primary).sort();
   return [primary, ...others].map((name) => {
@@ -2179,6 +3213,7 @@ function bigIntToSlot(value, width, signed) {
 function parseIntValue(v, typeLabel) {
   if (typeof v === "bigint") return v;
   if (typeof v === "string") {
+    if (v.length > 80) throw new Error(`${typeLabel} value is too long`);
     if (/^-?0x[0-9a-fA-F]+$/i.test(v)) {
       const isNegative = v.startsWith("-");
       const abs = BigInt(isNegative ? v.slice(1) : v);
@@ -2197,14 +3232,18 @@ function parseIntValue(v, typeLabel) {
   }
   throw new Error(`unsupported ${typeLabel} value: ${typeof v}`);
 }
-function encodeField(type, value, types) {
+function encodeFieldWithBudget(type, value, types, budget, depth) {
+  if (depth > TYPED_DATA_LIMITS.maxTypeGraphDepth + TYPED_DATA_LIMITS.maxArrayNesting) {
+    throw new Error(`value nesting too deep: ${type}`);
+  }
+  consumeValue(budget);
   const parsed = parseFieldType(type, types);
   switch (parsed.kind) {
     case "ref":
       if (!isMessageObject(value)) {
         throw new Error(`struct field expects object: ${type}`);
       }
-      return hashStruct(parsed.name, value, types);
+      return hashStructWithBudget(parsed.name, value, types, budget, depth + 1);
     case "address":
       if (typeof value !== "string") {
         throw new Error(`address field expects string: ${typeof value}`);
@@ -2215,15 +3254,26 @@ function encodeField(type, value, types) {
         throw new Error(`bool field expects boolean: ${typeof value}`);
       }
       return padLeft32(new Uint8Array([value ? 1 : 0]));
-    case "string":
+    case "string": {
       if (typeof value !== "string") {
         throw new Error(`string field expects string: ${typeof value}`);
       }
-      return shake256Digest(new TextEncoder().encode(value), DIGEST_LEN);
+      if (value.length > TYPED_DATA_LIMITS.maxDynamicBytes) {
+        throw new Error("string field exceeds typed data byte limit");
+      }
+      const encoded = new TextEncoder().encode(value);
+      if (encoded.length > TYPED_DATA_LIMITS.maxDynamicBytes) {
+        throw new Error("string field exceeds typed data byte limit");
+      }
+      return shake256Digest(encoded, DIGEST_LEN);
+    }
     case "bytes":
       if (typeof value !== "string") {
         throw new Error(`bytes field expects 0x-hex string: ${typeof value}`);
       }
+      if (value.length > TYPED_DATA_LIMITS.maxDynamicBytes * 2 + 2) {
+        throw new Error("bytes field exceeds typed data byte limit");
+      }
       return shake256Digest(hexToBytes(value), DIGEST_LEN);
     case "uintN":
       return bigIntToSlot(parseIntValue(value, `uint${parsed.width}`), parsed.width, false);
@@ -2233,6 +3283,9 @@ function encodeField(type, value, types) {
       if (typeof value !== "string") {
         throw new Error(`bytes${parsed.width} expects 0x-hex string: ${typeof value}`);
       }
+      if (value.length !== parsed.width * 2 + 2) {
+        throw new Error(`bytes${parsed.width} requires ${parsed.width} bytes`);
+      }
       const raw = hexToBytes(value);
       if (raw.length !== parsed.width) {
         throw new Error(`bytes${parsed.width} requires ${parsed.width} bytes, got ${raw.length}`);
@@ -2243,28 +3296,62 @@ function encodeField(type, value, types) {
       if (!Array.isArray(value)) {
         throw new Error(`array field expects array: ${typeof value}`);
       }
+      if (value.length > TYPED_DATA_LIMITS.maxArrayLength) {
+        throw new Error(`array ${type} exceeds length limit`);
+      }
       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));
+      const chunks = value.map(
+        (v) => encodeFieldWithBudget(parsed.inner, v, types, budget, depth + 1)
+      );
       return shake256Digest(concatBytesArr(chunks), DIGEST_LEN);
     }
   }
 }
-function hashStruct(primary, data, types) {
+function encodeField(type, value, types) {
+  validateTypeMap(types);
+  return encodeFieldWithBudget(
+    type,
+    value,
+    types,
+    { remainingValues: TYPED_DATA_LIMITS.maxEncodedValues },
+    0
+  );
+}
+function hashStructWithBudget(primary, data, types, budget, depth) {
+  consumeValue(budget);
   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)) {
+  let ownFieldCount = 0;
+  for (const k in data) {
+    if (!Object.prototype.hasOwnProperty.call(data, k)) continue;
+    ownFieldCount++;
+    if (ownFieldCount > TYPED_DATA_LIMITS.maxEncodedValues) {
+      throw new Error("typed data object contains too many fields");
+    }
     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));
+    if (!Object.prototype.hasOwnProperty.call(data, f.name)) {
+      throw new Error(`missing field ${primary}.${f.name}`);
+    }
+    parts.push(encodeFieldWithBudget(f.type, data[f.name], types, budget, depth + 1));
   }
   return shake256Digest(concatBytesArr(parts), DIGEST_LEN);
 }
+function hashStruct(primary, data, types) {
+  validateTypeMap(types);
+  return hashStructWithBudget(
+    primary,
+    data,
+    types,
+    { remainingValues: TYPED_DATA_LIMITS.maxEncodedValues },
+    0
+  );
+}
 var RESERVED_DOMAIN_FIELDS = {
   name: "string",
   version: "string",
@@ -2300,59 +3387,947 @@ function validatePayloadReachability(primary, types) {
   }
 }
 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);
+  const parsed = parsePayload(payload);
+  validateTypeMap(parsed.types);
+  assertIdentifier(parsed.primaryType, "primary type");
+  if (parsed.primaryType === "QRLDomain") {
+    throw new Error("QRLDomain cannot be the primary type");
+  }
+  validateDomainTypes(parsed.types);
+  validatePayloadReachability(parsed.primaryType, parsed.types);
+  const budget = { remainingValues: TYPED_DATA_LIMITS.maxEncodedValues };
+  const domainHash = hashStructWithBudget("QRLDomain", parsed.domain, parsed.types, budget, 0);
+  const messageHash = hashStructWithBudget(
+    parsed.primaryType,
+    parsed.message,
+    parsed.types,
+    budget,
+    0
+  );
   return shake256Digest(concatBytes(SCHEME_TAG_TYPED, domainHash, messageHash), DIGEST_LEN);
 }
 
-// src/signing/verify.ts
-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");
+// src/utils/platform.ts
+function isMobileBrowser() {
+  if (typeof navigator === "undefined") return false;
+  return /Android|iPhone|iPad|iPod|Opera Mini|IEMobile|WPDesktop/i.test(navigator.userAgent);
 }
-function verifyMessage({
-  signature,
-  publicKey,
-  messageBytes
+function getAppStoreUrl() {
+  if (typeof navigator !== "undefined" && /android/i.test(navigator.userAgent)) {
+    return "https://play.google.com/store/apps/details?id=com.chiefdg.myqrlwallet";
+  }
+  return "https://apps.apple.com/app/myqrlwallet/id6742219498";
+}
+function attemptWalletRedirect(uri, timeoutMs = 1800) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return Promise.resolve(false);
+  }
+  if (!uri.trim().toLowerCase().startsWith("qrlconnect:")) {
+    return Promise.resolve(false);
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (opened) => {
+      if (settled) return;
+      settled = true;
+      document.removeEventListener("visibilitychange", onVisibility);
+      window.removeEventListener("pagehide", onHide);
+      window.clearTimeout(timer);
+      resolve(opened);
+    };
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") finish(true);
+    };
+    const onHide = () => {
+      finish(true);
+    };
+    document.addEventListener("visibilitychange", onVisibility);
+    window.addEventListener("pagehide", onHide);
+    const timer = window.setTimeout(() => {
+      finish(false);
+    }, timeoutMs);
+    try {
+      window.location.href = uri;
+    } catch {
+      finish(false);
+    }
+  });
+}
+
+// src/QRLConnectProvider.ts
+var QRL_CONNECT_PROVIDER_INFO = {
+  name: "MyQRLWallet",
+  rdns: "com.qrlwallet.connect",
+  icon: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMAAAADACAYAAABS3GwHAAAAAXNSR0IArs4c6QAAH1dJREFUeF7tnXt8XGWZ+L/PmaT3JpOkrVCKgD9wFcELwgoLArIsWnDLCnIVgZ8gF1lcylVsk5xMKuXiiiKLn7L82OWiK1ZBtgpdFRDdAu4P1EVAuaNoQbrNTJJek5nzbN+TpE0nk8yZmTMzZybv/AXNe3ue9/me9/a8zyvYn9XAJNaATGLZrehWA1gArBFMag1YACZ191vhLQDWBia1BiwAk7r7rfAWAGsDk1oDFoBJ3f1WeAuAtYFJrQELwKTufiu8BcDawKTWwKQEQF0cwGGtPQjMtv6ngA8m8ViJJ6D1TsekAEDZZugu01MeHxLlIBXmi7A7ymwxKNjfdg1ohkEV3sDhj+LxG8fhN7M7eVGkPmGodwBEXRp7MpwdE7pUZBYwq96FDpHnLQqbFF2dXsf5c29hY72NCnVrC6+6TGvxOA6HK1TlQyNGUbcCh2j1I0WNnv8IbFH0+kbhG7Nc3ixDdVUpsi7tQRXp66TDE7lSYEZVNFuPlQoZ9XhePF0UX8bL9SBi3QHwxtXMnTqFOx2Rj6J2kRu6kZq1gOqrHpzV0sWaWp8S1RUA6tLQq6wAOdvf5bG/smlAlDcyaT2m9RqeKVslFSi4bgDQk4gl38VpTkzutF/+CliOX4X+clD427kuaytVY9j11A0AvS4f8zx5QMROe8I2knHLM5MhR7/a4nJpxeoMuaK6AEBdZvSqfBPhePv1D9lC8hSnqhlxeGfc5ZXK1hxObXUBwLp2PhgTecQRZoejFltKYA0IKqqrmoQTxSUdOF9EEtY8AGbLM9nJchG5quaFiYhRFNoMsyBOD+rRbct5rtC81U5f8zbzrMuU3TxeR2RetZU5WetXYTOefqolwX21poOaB6CvnUM8kTXYxW9VbU887WzuJlHVRhRRec0D0NPOGXbrs4ieDz2LfqvZ5Yxac5qreQCS7ZwtMbnd7v6EbtEFFegvhLs43gJQkNpKT5zswEWks+ZJLl0VVSvBOM2J6oPNXRxnAahwN6RclqnKEgtAhRU/XN0Oj1H9SdzlGAtAhfsh1cEyRJaEXW2WK3DYxVesvOwrXWF/KCwAFevK3BWVGYC1Ar9WYSvKXwD7hm1A5VafwgaUx0Ukqei7BPYL01FwBAAR/XFzJx+1I0C5ezSr/LIBoDyVdvSCQXhu17UM9s5jgcbkq8Ci2oFAN6ny8fQWnpwzg409MF/SnOU0SHdYmwYWgAobfHZ1ZQFAzf1XvTCeMK7VO34plwNB/hNlapXFDlS94+llTd18ZXRic3Le6/I0iBkJSv7ZKVDJKiytgLIAAF7G0/e2dfPsTsZzHo2pXUiJSPRvmQnqoIc1uTyWreFkB3eKyKdL0/xQbjsChKHFEsooFwADm3S3eTeMvfua7GCDiMwsockVyaqKxlQPberm8Ryj5i2IXBhGQ+wIEIYWSyijXAA0bNLdZlUAAH8PvQT5x82qaMbRw9pyjAA9nXzDQS4Io1oLQBhaLKGMcgFQiRFg2Hg8M48QQ4HxZwrrHvMEAKQ6+QYWAN/qyvLxKcGeC85aLgDKPgIMXS7/sQ5yVXwKT/dvpcVr5DOKXI3QUnLHWAAC2VLJeg5USxkT9Q6fBIdchVdOAPwvv2r/xkH2WrCc9SNtNwNBbwfLNYy7DRaAQCZRDwAkPJX2kAUpPwDo3S1djNmJSbmcLCp3KEwL1IPjJao0AKI/jtuDsJK6rKjMPS6fc5Cbzf52iBCUDYBRi8abW7q4OFvoZDtHSExWmbilRSlkx3Ay7iI4zDXAqOp+EHdZZE+CS+q1wjMnl7IIR75vFpAWgFH6q9AIsL1G1RXNCS6stUBZIdpM4cYbRo7XFzN99mzWqMgHQhSmeiNAgiPEq60RQJWNip7SmuCHYfRpJcsI0WYq2eyd61rfznsckTUiNIfUCm9wUBfMvYY3xkxRQjgIG5oGae4pkMuRgvx7yVMgQTPkPgcIdQpk9rJEvxnv4sxa+/rXxTaob0oraOz9E2ci0sFQ3P9SwfYym3WPtuv5Y6UBSLkchcr9Jox7KTAbyDzRQ3MdhKU6uBWRz5ZSvn9ioWz20LtFuKrFJVVSeVXKXKqhVKnZY6s1r75sgDkDyhUxOA+V4heRDt5AWt89bxkv5likGleIkn2BxNGbm10+n13+epePxVRWopTmbmF8gWJ6WFPHWFeIpMud4skZJXReWhx9IOOxYn2Sh/f5OltLKKuqWesGgGwtbn8GCfhpQBUfCby0nljbDKa1XkdvrmxJl3jqNbbsuSfpoOWOLsfUQS+NNG9btLtsyq7jyfNofHsDU+euY4D34BVahyn/uWdx5s5lytwj2Swnk8mu49WzmbZnC/LURtL984O//OK33Zye1mAArPFMoG4BCGjzNtkk14AFYJIbwGQX3wIw2S1gkstvAZjkBjDZxa9bAMyDGX9cwJQFG0lTwEJvshvEePI/tRZpGyC25wGofL52d32y5atbAPpdTsio3BFmBAQLh7kCqa+0dLF/veiibgFIuZwLcmsIh2L10tchyaFes9AoLl5IBVa1mLoFINnOHeLImVXVbn1W7pHWD8W/xJP1IF5dAvCIS8P7lZcFeXs9dFKUZFDjAuHpP8QT3FyLvj91vwbwb1W5nIgn37FvBoSPztAlfn1gQDhlnsuG8GuobIl1NwKoy7Skx68dERPK0P7Ko4GUJ/rhVre23wg2qqk7AFJL+aTE5K6SrxSWx3DqotThUeC7zeb6ppkS1fCvrgDQi5na28IqRP6mhvsk8k33LV7QtKfHz0nwg1peC9QVAKkOrlGRq+tKqAjiMOqT/9y0Rj12+lJ+H8FmBmpSXdiKv/Bt5xxicovqtj3qQKLbRKVoYCSol6Dfbe7i1FodBWreVozx9yzhEKdRvo2ye10ubEqx1HLnFVRVv7RZWD4/x/2Gcldfavk1D8CGL/LegUZWjez517xApfZoNfKbB0TQpc0u/1hrI0FN24u5DB8TVqrIu+2XvxqWP6rO4TcVkg537OWypcqtCVx9rQIgqaW8Q2PyXYT3GX+fWhUkcE/VQEJVMg66uOm33CIrx17FjKIINWk3PVfR7EzjRypykDX+aJmVwFtk9LCmZbxUC9OhmgPALHqTnSxzRK6wOz7RMv7trRFe1y16eMu1vBbRFo5qatRbmNW+1BIOpIHHFWmw8/4Id57oyuZd+ZScz2CEW1lbrhD9LvMGPX4mw34+NTd8RdkSwm6bkgQ9KZ7gobCLDrO8mrEhf+rTwRdFJGFuedVMw8PsrVorS/VXzQk+GOW1QM3YUZ/LnLTKzwXMY8/2VwsaGLo7cGFzglujCkFN2JL5+qdcFm8Ld2gOWuyvhjSg8OtG0YWz3LEvbkZBjJqwp3VXMnvKdHpGFr5RUJxtQ34NDL+AuQXVM+IJvpc/R+VT1AQAyXYucWLyFfMKTOVVZGssRQPDdwe+3exyehTvDkTeoNRlSm+Ge3Dk70rpCJu3ihpQtPlNnSq3Rm9LNPIA9Lrs7XnyIxH2qmIX2qpL0YDxGPX0spYEN5ZSTDnyRh6AVAd/DfIfKsQi39hy9FC9lKm8Ek/o/4maOJG3qWQnX0fkIuvzEzXTCd6e4cszPekBPWTucl4InrP8KSMPQE8nv3WQd5VfFWNrGHPbW1GzkFPV14FnUNZFbmEnzBy+GHSAiDSqICObB9Xq7GE9blTVk1oTPFiNvhyvzmrpJJAO3rycmVNn0C9SHW/nkW08NUG2RB9FuL95Xx7iuW0hMjuHoyFETYMj1HYhSdhPMhxNTBahvBthrlRrJ01RD726JcH1UToUi1r3jQZDejr4uIPcX5UAV+b1Q/QnONzcAE/MdnkrELURTGRiJa3P8L6Yw+miXKQisZFmVswABBXVrzUJl0UprmjF5C/ULvyL7h2ciyMrKh3gVmGTI7q8B768p8vWKH2xCtXj6PTDwQMOwOFuVfmLkB8Xz9s0z9PVr/yZRQdGaDs00gCkOvmyiCyuKADK8+roF+Iu99eL4WdbZu9S9vEa+GdUjjB/q5QRqOqj8d34myi5SFdK9rxfh+wEZuHW67LaD3JVuXnrgIge0eTyi3o1/hE9+weMHj/FkYONrithCIo+E5dt3qEuAwUbRJkyVELuopruA9DFGlQOKaqAAjMppDSjn2pdxgP5spp7CZkBFiA4NOZLXdm/Dw7C1Eb6XofX3pPH0JIue6KsBDmwEoag6Np4G++I0gszlZC7KAsYHgEeAzm4qAIKyTR0UrksnqBzvC+/eXc4leZwhHYceYfAjAqOTIVIgwqDqvqWeNwbb+BLEy06e5ZwmBPjUUScgiopIrGqbo47tEqEokZEHAB5DCgrAMNbnS9s3qof3TXHHVazcOxbyt6eQyeIceiKrM6yFrx+/E5zZiHC4rjLfbng9l3NO7gBkcvKLpio9vcyc/cb2VwEP2XJUnaZi2310AhQGQDU04tbu7k5V1t7ExzkZbhdkP2KlaVa+bYf5Cn9it7csh/tuV6O37yMPbYMysOAGdnK97MABNdtpQBA9c1mh91yTRP8ub7Hz6iPtwYGRPXSpi5uyT69Ni9q9u7LTYp8rqy7QhaAiAFgDmc87WpKkMieHqx1mTE9wz0Sk+OiOtcPrs3tez9vOsL+TS7/k53XvKugMVlpAShcq2XJUaERwMuoHtuW4D+yhTCLQ2mQ+2Hboq0sElahUEE9T29rSXB+NvDrL6bJaZNUWV0l7AgQvNMrAYAqr3uqC9u6eTarZdLTzhXiyHV1Y/wjAopmnK28rWk563daNJs1VydrEdkleC8VmFJV+/vtIjiQ1ioBAPDSgOjCeS4vZRtDXxf/piqnBGpsLSUy0760Htu8jNVZu0YGgJsRubBsUz47AgS3lAoB8AKiC+Mur+xkDC5OUlkjyMF1NwIYQVU/mX1J3d/u7SShIkssAMHttGwpKwTA7zZv1YXZ+//+oZfHHxHZtZyLwnyvy5UNPtUL4glWZI8AqXYSErMAlM2oCym4EgAI/NbbqsdmB3E1APR6rFWRt4UJwIjBi/rz7w0qJEVGHQoN+Ty1qjllhl0E/PinYf881c+1JviGBaByjoAF92HVAVD+pAwtCIv9Eo/+woswiKc/8Rzubsjwe1F6BgdZ23ItfduVsxIn9d8saHRoGoixv6PmPjQnINIc5rTEArDDHIvt24INutAM9QCAcUXwlM2oPtrQyOLZS3mhkCuUfjzUq2hypnM1npwHNCFsv8xSqE5H0lsALAC+BiacApU6AhiHNE8fUFixPsnD+3zdvKNV/K/vat6pU/i0Il+gxKmRBcACUF4AhpzQuuNvsExuJW32XYo3/R05zdqkP80+Xsy4bMs7ii3TAmABKB8Awp8yGU20dvPP5bhU43tvtvNeiXEXxkGviMtCFgALQLkASKvoOXG4eyIffGPE27vAjA1d/v830MngyF/ywbPRZf6gmscnCg8ZYwGwAJQDgC2qem1Lgq6JpiappeylDoc7wpGKHOXH8Bm5iuL5M6XfAQ9kMtzb18gvJ3pytH8p7047sgrBj7gWdEfDAmABCB0AFb0j3sn/HW+XR29iamqd71/0KYG9TajHcacv5mEJpVdV18QGuXz2cp7PeZnFnFekOUEdvkMBwZMsABaAsAH4Q0x04WyX57K//mY7N/kFdpdp3CciHyh4zq4kM+j5rb/l3lxv75ry+1xu90TOCurJaQGwAIQHwNAzQFc3jxPxzGxfelO4B+T9xeza+JMipX+bA09nPMFXc40EySXsITF5hIARtC0AFoDQAPAjHXSxIJdhPusyZb7HE/6Xv8jfdvcJYat6+tl4YtsCO2tb1Xdk6+CfPJELg6wDLAAWgFAA8C/Ue3pVvJvrs+3bxDWdPoP/p1K6S/WOu736cibDEXO+xJ+y6+t1+UtP5fEgL2haACwAoQAAvInocXGXX2YbZMrlKFTMu1jxIj/+O2XbMRLoyrjLyWPWGkMerK8gske+UcACYAEIC4BfDogeNy/HC4gpl9tQOScM49+5DPViwvtmuzyTXXayg8WIfMUCEFzr+XQVvKSQU9aCM5yn+mCLw8dzHXqlOiSF0ByyWoZi/Xi6rCVBR3bZ61zmN6qMmR5lp7MjgB0BSh4BzJTEQ5e1ddGebWAblnJM2pHVZQvrLnLPuvXeWdkOdn4kC+XPgsyaCDwLgAUgFABQPbMlYXxydvz8EORLuZIGWV7wnn+e4WLUjtAvnK16XPbF9hcvZurcVn6uyEETDe0WAAtAyQCYAjzVM1oTfDMbgGQnNznD75qFOQUa5VL6pDl4y47voytoTK31PUWPNvWOB4EFwAJQVgBSndxUrof9hiHICcDwucMDiJibZBaAAF8fuwge705wgAsxonpGc44RoKedy5yYXF/Gly2fdHKMAGYKNKeV/8wX7tyOAHYEKHkEGHJR0EuzH3/2T2XbOcUT+Va5niASYVUTeqq4bBr9kXt9MdNnN5kQLxMHt7IAWABKBsC3f/T7LV18InukNY/S9apsNKeyAUbhwpIM3Tb7WryLS7NdIt5ymdXoSV++EO4WAAtAKACI8POB6Xrc3KuMs9rOv2Qn3xPkhMKsO39qAU88PbypmzVj6mznbBz5l3zzWguABSAUAIA/eKLHteY4le1p51REbhdh+kQL0vwmvyOFmXY56GMvvsGRuV5aTHbwMxH5cL4yLQAWgLAAwPP0tNZuvp1tdH1X05ZulB+K8KHQAFDdOOjxgXnLeDG7vrVX8fYZ0+TVINMuC4AFIDwAVH/RkuCQXO7Q2165PFg9+b4Kb8s3Lcn31QbSil4bfw4318WYVAdLcKQ7yOGbBcACEBoAZiWcUT21rZvvjFkMD/npm6nQvypMCWDkOyXZfvJr5v2ijzfBUbmeGO2/mrmZKWKiPR8QpA4LgAUgPAD8kvTphkGOmXUNfx4DwdB7vGepSIfAgiAG6pc4klDNS/V6+5ZNXLHLlzE7S9mQSLKDC0TEvHHmBBlpLAAWgJABwNOMuvFlLBvv8npSWRBD/k2FQyaapuwcQUs3Ocq5TXO4d7y3dde77BvzeEpFpgVda1gALAChAjB8b/fPafS0OQl+OsFbww19cLLncYkgB+SK8+nfMlPWgd7uDHLD7OX0jFden8ucTIZ7cOSokS61I0DQMXYoXRB9FVZiSKlr4T7AaFGHIViP6okt3Tw6kRp6Xfb2PB4Wkd1zTGnw3RzgR/mCa6U6+S7IopFYoUE7044AdgQIdQQYbcQCj2U8vaC127+xNW5M0GQn3YIszQbA5E+LLmxzR4VNz0qUWk6LbuVGQc40H4pCv2QWAAtA2QAYXsD+QVQvb3a2nQa7eLlGg94OLtKhhevOi1qPR+IxXSQuG3Lkk75raPW28E8qcmKxD2hYACwAZQVgWL0DqLpbNnFTrt2bng4ucnIAgMfDAzE9fl4WACYy9AY4POPJahWmFvrVHw2TBcACUAkA/Pu7qC5t7mJ59kJ2XADg4QEZC4A5Wc40ym8QSn63zAJgAagYAIJ2N7m4JQPgMsdTed68IVbqPoMFwAJQMQAUTcRdukICwESObrMAlKoBC0DlADAvxXSFNgJYAMKz/REbCLnEkIqrtXOAnGKbNQB6XbPLF0sdAYy/T3qKvCTmobwSf3YKZEeA0EYAcz3LcVjleST9qP4yfLg49F8iyg/iORzlCl0Er7uS2Y1TuV6FmX5IIvMz9Snq3zmI8WGQ+dYbtLCvQ9DDw8JKDSF1TYwAQlLRS+Kd3DXRmXouV4ZCARiy93FqUehtZ091+JGI7J1P/XYEsCNAKCOAonfG2zhvPEe1iQyx0HOAfEZt/v7WUvaZEhNzAj2h67UFwAIQCgC5wqIEMVSTZlwAlIcGHP277IOwIOWqy5Q+5SFFDpsovQXAAhAKAI7qlU0JbghinNlp+jq5wUMuz/53VZ7C0aNbXFKFlvuqy7QW5Tcw8TTIAmABCAUA4L/Mqe1c1wSkDfYYtpnHr1/C/IZGeRQdet1xp5+Sdhz9xGyXH5p/D1LuyNqgbwlLvJgkbFiU4J8OuwgeLzKcx1oVeduwEY6vUdUHcfhXzC6QQybt5V6oNjioCpoZpKXR4RKdIHqDSSeqyx3hcY+h4Fe5yjVl+ovjNLNo4EjgErMnlK9T7QhgR4DtI8CmrXrsrtfy2mgLN45nvUEBGCIkox6bRHJ7fvpl+zdd/G3LmQiNeb9R/hkCW/AYGHeHyZwyDN2DnGoc5IK6RlsALABDGlCex9OF8WWYcCLbfwaAlPIyyJ55R4C8lhytBP67Bp6e09bN7TvJDJJqJyExWRLkLKEoqUS1v5eZu9/I5qLylyFTvtGyDFUGK7IS5wDAS7JVFzZfy0ujW+W6OJ/P8KA4ckxkFRRMjTulGrmdo6qLWhOsygagr5OEShkBUNX+fgtAoK6rCADKy+LpwuasQFNmUZnq5DZBPhOosTWSyAfArC8yelC8m6fGjAAd3CWOnG5HgAh0aEUAEPodRxc2dYyNs5layieJiXn8ouB4PhFQ35gm7LibqU/HXd4vQ2uMHdM+RXpdkiDhv2s2UoudAgU3jQoBoJ6nn25J8K3s7cZ1VzK/cbo8BLwreKujndJsLXlbObR1OU+Mcc5rZ3/HkafLKoEFILh6KwGA/wn09OF4gqPHfBHNW18dfEaRFSLEgrc8milNVGkVXfkrOOMjLunsVvZ2cLGK3FTW1lsAgqu3EgAMtyatg3pQyzX8Ort1eh6NqV1YIkhH2V58DK6SklKq0hNz9NAmF3OnYKffepemmHIPyMdKqiRfZgtAPg1lz0nlMeDg4LmKS6mqqzb0c0qu7bk3L2fmtFl0qifnOg7xkb324mqqfC6BAU91TczjwqZlmCuVY37JJRwuDfIgMKOsLbQABFdvBUeAbcEb/MXwyc0uJsDsmJ9ezNRknL8Uh0tRFokjYtoX6S1Sc+SGvuDAP+JwX/aLkiNCGtl6W3gakXcG750iU1oAgiuukgAMtUqfHhAOncgL0/e5uYEZPX2c1ugwLwP7IGV4Bim4mnZOaRoorBN4LZPhv1ti23a3XHSCUI1Tkhm+5sTk/LJtfY5uoQUgeM9WHACzP47++6atfHbX5SY25/i/nS6mjBv7LbisoaUcNSTlc6LzH/Pr4HQVuYUQrlkGksECEEhNQ99jf1+6MmuAnVrl6bc3xThnftYLjMFbHv2U3zmJ2DHv4SPq+TfIKjeTswAEN45qAeD7rIneoxmua+nmV8FbXDspezr8MO6LRaS8i95slVgAghtJtQDwW+g/Rcobnqrb2sVt2WcEwaWITkpfn0v5IDHuVJF9io0rWpJEFoDg6qsqACPN9KM86P9XjxUNaZ6YNXXbI9QuW4NLUeWUCskvsHtsOvuqcqIipwvMGPLMrsLPAhBc6ZEAYEdzzcnpWoW3QJ8R5QmHsaepwaUrX8rtoagd9lI4DJVdBXYDP5xKdX8WgOD6jxgA2xtupkNR2vjJpdFR74sV/HZA8B4qIqUFILjSogpAcAmqm7Jq05yJxLYABDcKC0BwXdVMSgtA8K7yAejkMUTK7gsUvFU2ZSkaUHRTXGgTly2llBNm3qpsBgQRwACQ7OSnMUc+XGsOaEHkm5xp9JV1Pey7z9ejs5MWXQCGriV+VUQuroifyuS0yIpKLaJrmnblI3I+gxWteILKIg1Abwfn4sgKC0BUzKW0dgj6gybhE5LjQk5pJRefO7IAGJFSSziQmPxXrV9GKb576iinf7qu3XHzXFTWfeRqShlpAIzHYrKDPzgiC6qpJFt3KBrYguoZ8QT3TvR+cig1FVBIpAEwciQ7uVFE/sFOgwro1YglHYrfSDLj6F/NyXEls5rNjTwAPe0cKo6sFphVTUXZuovXwBAAel9LghOKL6U8OSMPQP81zM1skfsRDimPCmyp5daACplG9IBZLuUNu1KEIJEHwMjU4/L3DnKTnQYV0cNRyKJ6T3MXp0Vp8TuilpoAQG9iau96ngTZLwr9adsQXAMKKRE9Me7ycPBclUtZEwAYdaxfwsFOTB4UIV459diaStKA2e709PaX3uTCA2+NzuHXaJlqBgB1aUjBF0Wl04TEL6ljbOaya2DIbVyfUTi8mOeeyt7A4QpqBgB/LXAVzTKVR8SR99v1QKVMpLh6VPl9rFE/2tSeOxhXcaWGn6umADDi97vMS3vcjshx5v9rToDw+zB6Jaqm1eOk+POskpVkotfAHS2qSfvZ4LLLoCercXivmBfZ7S9CGtD/QTil2eWRfLGJotDomjWedS7zG5TlIJ8cHdOyZgWKgjWU0gb//TN93vM4z0SkE3eC99JKqSfkvDVtL4+4NLzPY7Eg1/nL4qjH6wy58yJTnDF91bviczlPPh8dX/8g+qlpAEYE7GlnfxEWI3K8QGsQwW2aEDSgbFb0CXW4bf16vheliy5BpasLAIyw+hWm9/Wx27aAVuercpEg00bcqEeiJNSNsEF7txzphp56VRH9oedxIw6/irv01sJ8P5c66s4m/MC159GQmsup0sCxiOyB0qZKswgzUaZplCI6l8NIQyhTzLQGBkT8J01Tah7sVv29Oqz20jzU1s3voujaUKjodQdAtgKSLnFJ00YDzQqzxGNqxqv9J48K7eiC0zvoFIetXobNoqQGlU2tL7A26tuahcpZ9wBMoJDJLHsQO4l6/K8gMuRNY40gr4psgnrWgAWgnnvXypZXAxaAvCqyCepZAxaAeu5dK1teDVgA8qrIJqhnDVgA6rl3rWx5NfC/zGV/wHfd+nEAAAAASUVORK5CYII="
+};
+var EIP6963_ANNOUNCE_EVENT = "eip6963:announceProvider";
+var EIP6963_REQUEST_EVENT = "eip6963:requestProvider";
+function isRecordObj(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isUnknownArray(v) {
+  return Array.isArray(v);
+}
+function parseInflightRecord(v) {
+  if (!isRecordObj(v)) return null;
+  const { id, method, ts } = v;
+  if (!isValidJsonRpcId(id) || !isValidJsonRpcMethod(method)) return null;
+  if (typeof ts !== "number" || !Number.isFinite(ts)) return null;
+  if (v.expectedChainId !== void 0 && typeof v.expectedChainId !== "string") return null;
+  return { id, method, ts, expectedChainId: v.expectedChainId };
+}
+function canonicalChainId2(value) {
+  if (typeof value !== "string" || value.length > 66 || !/^0x[0-9a-fA-F]+$/.test(value)) {
+    throw new Error("wallet_switchQrlChain requires a 0x-prefixed chainId");
+  }
+  return `0x${BigInt(value).toString(16)}`;
+}
+function requestedSwitchChainId(params) {
+  if (params?.length !== 1) {
+    throw new Error("wallet_switchQrlChain requires one chain configuration object");
+  }
+  const request = params?.[0];
+  if (!isRecordObj(request)) {
+    throw new Error("wallet_switchQrlChain requires one chain configuration object");
+  }
+  return canonicalChainId2(request.chainId);
+}
+var TRANSACTION_FIELDS = /* @__PURE__ */ new Set(["from", "to", "value", "gas", "data"]);
+var QRL_TRANSACTION_MAX_DATA_BYTES = 128 * 1024;
+var QRL_TRANSACTION_MAX_QUANTITY_HEX_DIGITS = 64;
+var RPC_QUANTITY_RE = /^0x(?:0|[1-9a-fA-F][0-9a-fA-F]*)$/;
+function validateRpcQuantity(value, field) {
+  if (field === "gas" && typeof value === "number") {
+    if (Number.isSafeInteger(value) && value >= 0) return;
+    throw new Error("transaction gas must be a non-negative safe integer");
+  }
+  if (typeof value !== "string" || value.length > QRL_TRANSACTION_MAX_QUANTITY_HEX_DIGITS + 2 || !RPC_QUANTITY_RE.test(value)) {
+    throw new Error(`transaction ${field} must be a canonical 0x quantity`);
+  }
+  if (field === "gas" && BigInt(value) > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error("transaction gas exceeds the wallet safe-integer limit");
+  }
+}
+function validateTransactionRequest(method, params, authorizedAccount) {
+  if (params?.length !== 1 || !isRecordObj(params[0])) {
+    throw new Error(`${method} requires exactly one transaction object`);
+  }
+  const tx = params[0];
+  const unsupported = Object.keys(tx).find((field) => !TRANSACTION_FIELDS.has(field));
+  if (unsupported) throw new Error(`transaction field is not supported: ${unsupported}`);
+  if (!isCurrentQrlAddress(tx.from)) {
+    throw new Error("transaction from must be a valid Q-address");
+  }
+  if (tx.from !== authorizedAccount) {
+    throw new Error("transaction from is not the authorized account");
+  }
+  if (!isCurrentQrlAddress(tx.to)) {
+    throw new Error("transaction to must be a valid Q-address");
+  }
+  if ("value" in tx) validateRpcQuantity(tx.value, "value");
+  if ("gas" in tx) validateRpcQuantity(tx.gas, "gas");
+  if ("data" in tx && (typeof tx.data !== "string" || tx.data.length > QRL_TRANSACTION_MAX_DATA_BYTES * 2 + 2 || !/^0x(?:[0-9a-fA-F]{2})*$/.test(tx.data))) {
+    throw new Error("transaction data must be bounded 0x-prefixed bytes");
+  }
+}
+function snapshotRequestParams(params) {
+  if (params === void 0) return void 0;
+  try {
+    const encoded = JSON.stringify(params);
+    if (typeof encoded !== "string") throw new Error("params did not serialize");
+    const snapshot = JSON.parse(encoded);
+    if (!isUnknownArray(snapshot)) throw new Error("params must serialize to an array");
+    return snapshot;
+  } catch (error2) {
+    const detail = error2 instanceof Error ? error2.message : String(error2);
+    throw new Error(`Request params must be JSON-serializable: ${detail}`);
+  }
+}
+function validateRestrictedRequest(method, params, authorizedAccounts) {
+  if (method === "qrl_requestAccounts") {
+    if (params !== void 0 && params.length !== 0) {
+      throw new Error("qrl_requestAccounts does not accept parameters");
+    }
+    return void 0;
+  }
+  if (method === "wallet_switchQrlChain") {
+    return requestedSwitchChainId(params);
+  }
+  const authorizedAccount = authorizedAccounts[0];
+  if (!authorizedAccount || authorizedAccounts.length !== 1) {
+    throw new Error("No authorized account: call qrl_requestAccounts first");
+  }
+  if (method === "qrl_sendTransaction" || method === "qrl_signTransaction") {
+    validateTransactionRequest(method, params, authorizedAccount);
+    return void 0;
+  }
+  if (method === "qrl_signMessage") {
+    if (params?.length !== 2) {
+      throw new Error("qrl_signMessage requires [signer, messageHex]");
+    }
+    const [signer, messageHex] = params;
+    if (!isCurrentQrlAddress(signer)) {
+      throw new Error("qrl_signMessage requires a valid Q-address signer");
+    }
+    if (signer !== authorizedAccount) {
+      throw new Error("qrl_signMessage signer is not the authorized account");
+    }
+    if (typeof messageHex !== "string" || messageHex.length > TYPED_DATA_LIMITS.maxDynamicBytes * 2 + 2 || !/^0x([0-9a-fA-F]{2})*$/.test(messageHex)) {
+      throw new Error("qrl_signMessage requires bounded 0x-prefixed bytes");
+    }
+    return void 0;
+  }
+  if (method !== "qrl_signTypedData") return void 0;
+  if (params?.length !== 2) {
+    throw new Error("qrl_signTypedData requires [signer, payload]");
+  }
+  if (!isCurrentQrlAddress(params[0])) {
+    throw new Error("qrl_signTypedData requires a valid Q-address signer");
+  }
+  if (params[0] !== authorizedAccount) {
+    throw new Error("qrl_signTypedData signer is not the authorized account");
+  }
+  computeTypedDataDigest(params[1]);
+  return void 0;
+}
+function requiresAuthorizedAccount(method) {
+  return method === "qrl_sendTransaction" || method === "qrl_signTransaction" || method === "qrl_signMessage" || method === "qrl_signTypedData";
+}
+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.orphanedRequests = /* @__PURE__ */ new Map();
+    // Random per-instance prefix keeps request ids unique across page loads.
+    // A bare counter restarts at 1 on reload, and the relay buffers messages
+    // for 5 minutes, so a stale buffered response could otherwise be matched
+    // to a fresh request that drew the same small id.
+    this.requestIdPrefix = randomUuid().slice(0, 8);
+    this.requestCounter = 0;
+    // Cancels work that is still awaiting channel restoration and therefore has
+    // no pendingRequests entry yet. Without this barrier, disconnect() or
+    // newConnection() could miss that request and let it cross into a later
+    // channel once the stale ensureChannelJoined() promise settled.
+    this.requestGeneration = 0;
+    this.requestCancellationMessage = "Connection changed while request was pending";
+    this.lifecycleTransition = null;
+    this.disconnectInFlight = null;
+    this.restrictedRequestActive = false;
+    this.restrictedRequestQueue = [];
+    this.isQRLConnect = true;
+    this.options = options;
+    this.inflightKey = `${options.storageKey ?? `${STORAGE_KEY_PREFIX}:session`}:inflight`;
+    for (const rec of this.readInflight()) {
+      this.orphanedRequests.set(rec.id, {
+        method: rec.method,
+        expectedChainId: rec.expectedChainId
+      });
+    }
+    if (options.debug) {
+      setDebug(true);
+    }
+    this.connectionManager = new ConnectionManager({
+      dappMetadata: options.dappMetadata,
+      relayUrl: options.relayUrl,
+      chainId: options.chainId,
+      storageKey: options.storageKey
+    });
+    this.setupConnectionListeners();
+    if (options.autoReconnect !== false) {
+      void 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: randomUuid(),
+        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) => {
+      log("Provider", `Connection status: ${status}`);
+      this.emit("statusChanged", status);
+      if (status === "connected" /* CONNECTED */) {
+        this.emit("connect", { chainId: this.connectionManager.getChainId() });
+      }
+      if (status === "disconnected" /* DISCONNECTED */) {
+        this.emit("disconnect", {
+          code: 4900,
+          message: "Disconnected from QRL Wallet"
+        });
+      }
+    });
+    this.connectionManager.on("accounts_changed", (accounts) => {
+      this.emit("accountsChanged", accounts);
+    });
+    this.connectionManager.on("chain_changed", (chainId) => {
+      this.emit("chainChanged", chainId);
+    });
+    this.connectionManager.on("jsonrpc_response", (response) => {
+      void this.handleJsonRpcResponse(response);
+    });
+    this.connectionManager.on("error", (err) => {
+      warn("Provider", `ConnectionManager error: ${err.message}`);
+      this.emit("message", { type: "error", data: err.message });
+    });
+    this.connectionManager.on("connection_lost", () => {
+      this.cancelAllRequests(new Error("Connection to QRL Wallet lost"));
+    });
+    this.connectionManager.on("session_terminated", () => {
+      this.cancelAllRequests(new Error("Session terminated by wallet"));
+      this.clearAllInflight();
+    });
+  }
+  async handleJsonRpcResponse(response) {
+    const pending = this.pendingRequests.get(response.id);
+    if (!pending) {
+      const orphan = this.orphanedRequests.get(response.id);
+      if (!orphan) {
+        warn("Provider", `No pending request for id ${response.id}`);
+        return;
+      }
+      this.settleInflight(response.id);
+      if (!response.error && orphan.method === "qrl_requestAccounts") {
+        try {
+          const accounts = await this.connectionManager.authorizeAccounts(response.result);
+          this.emit("late_response", { id: response.id, method: orphan.method, result: accounts });
+        } catch (error2) {
+          this.emit("late_response", {
+            id: response.id,
+            method: orphan.method,
+            error: {
+              code: -32e3,
+              message: error2 instanceof Error ? error2.message : "Invalid account approval response"
+            }
+          });
+        }
+        return;
+      }
+      if (!response.error && orphan.method === "wallet_switchQrlChain" && (!orphan.expectedChainId || !this.isCurrentChain(orphan.expectedChainId))) {
+        this.emit("late_response", {
+          id: response.id,
+          method: orphan.method,
+          error: {
+            code: -32e3,
+            message: `Wallet reported success but did not switch to requested chain ${orphan.expectedChainId ?? "(unknown)"}`
+          }
+        });
+        return;
+      }
+      this.emit("late_response", {
+        id: response.id,
+        method: orphan.method,
+        ...response.error ? { error: response.error } : { result: response.result }
+      });
+      return;
+    }
+    this.pendingRequests.delete(response.id);
+    if (response.error) {
+      pending.reject(new Error(response.error.message || "Request failed"));
+      return;
+    }
+    try {
+      if (pending.method === "qrl_requestAccounts") {
+        const accounts = await this.connectionManager.authorizeAccounts(response.result);
+        pending.resolve(accounts);
+        return;
+      }
+      if (pending.method === "wallet_switchQrlChain") {
+        const requested = pending.expectedChainId;
+        if (!requested) {
+          throw new Error("Missing wallet_switchQrlChain postcondition");
+        }
+        if (!this.isCurrentChain(requested)) {
+          throw new Error(
+            `Wallet reported success but did not switch to requested chain ${requested}`
+          );
+        }
+      }
+      pending.resolve(response.result);
+    } catch (error2) {
+      pending.reject(error2 instanceof Error ? error2 : new Error(String(error2)));
+    }
+  }
+  cancelAllRequests(error2) {
+    this.requestGeneration++;
+    this.requestCancellationMessage = error2.message;
+    for (const [, pending] of this.pendingRequests) pending.reject(error2);
+    this.pendingRequests.clear();
+    for (const queued of this.restrictedRequestQueue) queued.reject(error2);
+    this.restrictedRequestQueue = [];
+  }
+  assertRequestGeneration(generation) {
+    if (generation !== this.requestGeneration) {
+      throw new Error(this.requestCancellationMessage);
+    }
+  }
+  isCurrentChain(expected) {
+    try {
+      return canonicalChainId2(this.connectionManager.getChainId()) === expected;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Generate a connection URI for QR code display or deep link redirect.
+   */
+  async getConnectionURI() {
+    if (this.lifecycleTransition) {
+      throw new Error("Connection lifecycle transition is already in progress");
+    }
+    this.lifecycleTransition = "reset";
+    this.cancelAllRequests(new Error("Connection reset"));
+    this.clearAllInflight();
+    try {
+      this.setupResumeListeners();
+      return await this.connectionManager.getConnectionURI();
+    } finally {
+      this.lifecycleTransition = null;
+    }
+  }
+  /**
+   * Check if the current browser is mobile.
+   */
+  isMobile() {
+    return isMobileBrowser();
+  }
+  /**
+   * Get the app store URL for the QRL Wallet app.
+   */
+  getAppStoreUrl() {
+    return getAppStoreUrl();
+  }
+  /**
+   * EIP-1193 request method.
+   */
+  async request(args) {
+    const { method, params } = args;
+    if (!isValidJsonRpcMethod(method)) {
+      throw new Error("Invalid JSON-RPC method");
+    }
+    if (this.lifecycleTransition) {
+      throw new Error(this.requestCancellationMessage);
+    }
+    if (method === "qrl_chainId") {
+      return this.connectionManager.getChainId();
+    }
+    if (method === "qrl_accounts") {
+      return this.connectionManager.getAccounts();
+    }
+    const policy = classifyRpcMethod(method);
+    if (policy === "unsupported") {
+      throw new Error(`Unsupported method: ${method}`);
+    }
+    const stableParams = snapshotRequestParams(params);
+    const generation = this.requestGeneration;
+    if (policy === "restricted") {
+      if (requiresAuthorizedAccount(method) && this.connectionManager.getAccounts().length === 0) {
+        throw new Error("No authorized account: call qrl_requestAccounts first");
+      }
+      const expectedChainId = validateRestrictedRequest(
+        method,
+        stableParams,
+        this.connectionManager.getAccounts()
+      );
+      return this.enqueueRestrictedRequest(method, stableParams, expectedChainId, generation);
+    }
+    return this.performRequest(method, stableParams, false, void 0, generation);
+  }
+  /**
+   * Keep at most one approval-bound request active. Wallet approval screens
+   * are a serial human interaction, and request-id ordering must remain
+   * stable even when a dApp fires several signing calls concurrently.
+   */
+  enqueueRestrictedRequest(method, params, expectedChainId, generation) {
+    if (!this.restrictedRequestActive) {
+      this.restrictedRequestActive = true;
+      return this.runRestrictedRequest(method, params, expectedChainId, generation);
+    }
+    return new Promise((resolve, reject) => {
+      this.restrictedRequestQueue.push({
+        method,
+        params,
+        expectedChainId,
+        generation,
+        resolve,
+        reject
+      });
+    });
+  }
+  runRestrictedRequest(method, params, expectedChainId, generation) {
+    const task = this.performRequest(method, params, true, expectedChainId, generation);
+    void task.then(
+      () => {
+        this.finishRestrictedRequest();
+      },
+      () => {
+        this.finishRestrictedRequest();
+      }
+    );
+    return task;
+  }
+  finishRestrictedRequest() {
+    const next = this.restrictedRequestQueue.shift();
+    if (!next) {
+      this.restrictedRequestActive = false;
+      return;
+    }
+    const task = this.runRestrictedRequest(
+      next.method,
+      next.params,
+      next.expectedChainId,
+      next.generation
+    );
+    void task.then(next.resolve, next.reject);
+  }
+  async performRequest(method, params, restricted, expectedChainId, generation) {
+    this.assertRequestGeneration(generation);
+    if (this.connectionManager.getStatus() !== "connected" /* CONNECTED */) {
+      if (method === "qrl_requestAccounts" && this.connectionManager.isPaired() && this.connectionManager.getAccounts().length > 0) {
+        return this.connectionManager.getAccounts();
+      }
+      const joined = await this.connectionManager.ensureChannelJoined();
+      this.assertRequestGeneration(generation);
+      if (!joined) {
+        throw new Error("Not connected to QRL Wallet");
+      }
+    }
+    if (this.requestCounter >= Number.MAX_SAFE_INTEGER) {
+      throw new Error("JSON-RPC request id counter exhausted");
+    }
+    const id = `${this.requestIdPrefix}-${++this.requestCounter}`;
+    return new Promise((resolve, reject) => {
+      const pending = {
+        id,
+        method,
+        params,
+        expectedChainId,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      };
+      this.pendingRequests.set(id, pending);
+      const timeout = setTimeout(() => {
+        const timedOut = this.pendingRequests.get(id);
+        if (!timedOut) return;
+        this.pendingRequests.delete(id);
+        timedOut.reject(new Error(`Request timeout: ${method} (${REQUEST_TIMEOUT_MS}ms)`));
+      }, REQUEST_TIMEOUT_MS);
+      const originalResolve = pending.resolve;
+      const originalReject = pending.reject;
+      pending.resolve = (result) => {
+        clearTimeout(timeout);
+        this.settleInflight(id);
+        originalResolve(result);
+      };
+      pending.reject = (error2) => {
+        clearTimeout(timeout);
+        this.settleInflight(id);
+        originalReject(error2);
+      };
+      if (restricted) {
+        this.persistInflight(id, method, expectedChainId);
+      }
+      let sent;
+      try {
+        sent = this.connectionManager.sendJsonRpc({
+          jsonrpc: "2.0",
+          id,
+          method,
+          params
+        });
+      } catch (err) {
+        this.pendingRequests.delete(id);
+        pending.reject(err instanceof Error ? err : new Error(String(err)));
+        return;
+      }
+      sent.catch((err) => {
+        const failed = this.pendingRequests.get(id);
+        if (!failed) return;
+        this.pendingRequests.delete(id);
+        failed.reject(err instanceof Error ? err : new Error(String(err)));
+      });
+      if (this.shouldRedirectToWallet(method)) {
+        void sent.then(
+          () => attemptWalletRedirect(this.walletWakeUri()),
+          () => void 0
+        );
+      }
+    });
+  }
+  /**
+   * Redirect only for calls the user must approve, on mobile, and only when
+   * the wallet is actually absent from the channel: right after pairing its
+   * socket lingers and a pointless app flash would be jarring.
+   *
+   * qrl_requestAccounts is excluded even though it is restricted: dApps call
+   * it on page load to restore a session, so it can run with no user gesture
+   * (an unsolicited "Open in MyQRLWallet?" sheet on load) and pairing UIs
+   * already own their own deep-link step.
+   */
+  shouldRedirectToWallet(method) {
+    return this.options.walletRedirectOnRequest !== false && classifyRpcMethod(method) === "restricted" && method !== "qrl_requestAccounts" && isMobileBrowser() && !this.connectionManager.isWalletPresent();
+  }
+  // ── In-flight persistence (survive the return-redirect reload) ──────
+  readInflight() {
+    if (typeof localStorage === "undefined") return [];
+    try {
+      const raw = localStorage.getItem(this.inflightKey);
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return [];
+      const now = Date.now();
+      const records = [];
+      for (const v of parsed) {
+        const rec = parseInflightRecord(v);
+        if (rec && now - rec.ts <= REQUEST_TIMEOUT_MS) records.push(rec);
+      }
+      return records;
+    } catch {
+      return [];
+    }
+  }
+  writeInflight(records) {
+    if (typeof localStorage === "undefined") return;
+    try {
+      if (records.length === 0) {
+        localStorage.removeItem(this.inflightKey);
+      } else {
+        localStorage.setItem(this.inflightKey, JSON.stringify(records));
+      }
+    } catch {
+    }
+  }
+  persistInflight(id, method, expectedChainId) {
+    const records = this.readInflight().filter((r) => r.id !== id);
+    records.push({ id, method, ts: Date.now(), expectedChainId });
+    this.writeInflight(records);
+  }
+  settleInflight(id) {
+    this.orphanedRequests.delete(id);
+    this.writeInflight(this.readInflight().filter((r) => r.id !== id));
+  }
+  clearAllInflight() {
+    this.orphanedRequests.clear();
+    this.writeInflight([]);
+  }
+  /**
+   * Wake URI for the wallet app. Carries no pairing payload: the app
+   * foregrounds on any `qrlconnect:` URL and re-joins its sessions (draining
+   * the buffered request); the cid lets a future wallet jump straight to the
+   * right approval.
+   *
+   * MUST stay query-only (no host/path). The mobile app routes deep links
+   * with expo-router, which maps anything after the scheme to an in-app
+   * route: `qrlconnect://resume?...` lands on the "+not-found" screen and
+   * unmounts the WebView, so the wake achieves nothing. The hostless form
+   * routes to the WebView tab exactly like the pairing URIs
+   * (`qrlconnect://?q=...`), which is the whole point of the wake.
+   */
+  walletWakeUri() {
+    return `qrlconnect://?wake=${encodeURIComponent(this.connectionManager.getChannelId())}`;
+  }
+  /**
+   * Get the current connection status.
+   */
+  getStatus() {
+    return this.connectionManager.getStatus();
+  }
+  /**
+   * Get connected accounts.
+   */
+  getAccounts() {
+    return this.connectionManager.getAccounts();
+  }
+  /**
+   * Get the channel ID for this connection.
+   */
+  getChannelId() {
+    return this.connectionManager.getChannelId();
+  }
+  /**
+   * Check if connected and keys exchanged.
+   */
+  isConnected() {
+    return this.connectionManager.getStatus() === "connected" /* CONNECTED */;
+  }
+  /**
+   * Check if a stored session exists that can be reconnected.
+   */
+  hasStoredSession() {
+    return this.connectionManager.hasStoredSession();
+  }
+  /**
+   * True while a pairing exists (keys exchanged), even when the wallet app
+   * is backgrounded and its socket is out of the channel. Combine with
+   * getStatus() to tell "wallet away, session intact" (paired + WAITING)
+   * apart from "waiting for a first scan" in pairing UIs.
+   */
+  isPaired() {
+    return this.connectionManager.isPaired();
+  }
+  /** True while the wallet is actually present in the relay channel. */
+  isWalletPresent() {
+    return this.connectionManager.isWalletPresent();
+  }
+  /**
+   * Reset the connection and start a fresh pairing with a new channel.
+   * Use this when the user wants to create a new connection instead of
+   * reconnecting to an existing session.
+   */
+  async newConnection() {
+    if (this.lifecycleTransition) {
+      throw new Error("Connection lifecycle transition is already in progress");
+    }
+    this.lifecycleTransition = "reset";
+    this.cancelAllRequests(new Error("Connection reset"));
+    this.clearAllInflight();
+    try {
+      await this.connectionManager.resetForNewChannel();
+      this.setupResumeListeners();
+      return await this.connectionManager.getConnectionURI();
+    } finally {
+      this.lifecycleTransition = null;
+    }
+  }
+  /**
+   * 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() {
+    if (this.disconnectInFlight) return this.disconnectInFlight;
+    if (this.lifecycleTransition) {
+      return Promise.reject(new Error("Connection lifecycle transition is already in progress"));
+    }
+    this.lifecycleTransition = "disconnect";
+    this.cancelAllRequests(new Error("Disconnected"));
+    this.clearAllInflight();
+    this.teardownResumeListeners();
+    const task = Promise.resolve().then(() => this.connectionManager.disconnect()).finally(() => {
+      this.lifecycleTransition = null;
+      if (this.disconnectInFlight === task) this.disconnectInFlight = null;
+    });
+    this.disconnectInFlight = task;
+    return task;
+  }
+};
+
+// src/signing/messageDigest.ts
+function computeMessageDigest(messageBytes) {
+  if (!(messageBytes instanceof Uint8Array)) {
+    throw new Error("messageBytes must be a Uint8Array");
+  }
+  return shake256Digest(concatBytes(SCHEME_TAG_MSG, messageBytes), DIGEST_LEN);
+}
+
+// src/signing/verify.ts
+var ML_DSA_87_DESCRIPTOR_TYPE = 1;
+var ML_DSA_DESCRIPTOR_BYTES = 3;
+var ML_DSA_87_PUBLIC_KEY_BYTES = 2592;
+var ML_DSA_87_SIGNATURE_BYTES = 4627;
+var CURRENT_QRL_ADDRESS_BYTES = 20;
+function bytesOrHex(v) {
+  if (v instanceof Uint8Array) return new Uint8Array(v);
+  if (typeof v === "string") return hexToBytes(v);
+  throw new Error("expected Uint8Array or 0x-hex string");
+}
+function fixedBytesOrHex(value, expectedBytes) {
+  if (value instanceof Uint8Array) {
+    return value.length === expectedBytes ? new Uint8Array(value) : void 0;
+  }
+  if (typeof value !== "string" || value.length !== expectedBytes * 2 + 2 || !/^0x[0-9a-fA-F]+$/.test(value)) {
+    return void 0;
+  }
+  return hexToBytes(value);
+}
+function verifyMessageBytes(signature, publicKey, messageBytes) {
+  const digest = computeMessageDigest(messageBytes);
+  return mldsaVerify(signature, digest, publicKey, SCHEME_TAG_MSG);
+}
+function verifyTypedDataBytes(signature, publicKey, payload) {
+  const digest = computeTypedDataDigest(payload);
+  return mldsaVerify(signature, digest, publicKey, SCHEME_TAG_TYPED);
+}
+function verifyMessageSignature({
+  signature,
+  publicKey,
+  messageBytes
 }) {
   try {
-    const sig = bytesOrHex(signature);
-    const pk = bytesOrHex(publicKey);
+    const sig = fixedBytesOrHex(signature, ML_DSA_87_SIGNATURE_BYTES);
+    const pk = fixedBytesOrHex(publicKey, ML_DSA_87_PUBLIC_KEY_BYTES);
+    if (!sig || !pk) return false;
     const msg = bytesOrHex(messageBytes);
-    const digest = computeMessageDigest(msg);
-    return mldsaVerify(sig, digest, pk, SCHEME_TAG_MSG);
+    return verifyMessageBytes(sig, pk, msg);
   } catch {
     return false;
   }
 }
-function verifyTypedData({ signature, publicKey, payload }) {
+function verifyTypedDataSignature({
+  signature,
+  publicKey,
+  payload
+}) {
   try {
-    const sig = bytesOrHex(signature);
-    const pk = bytesOrHex(publicKey);
-    const digest = computeTypedDataDigest(payload);
-    return mldsaVerify(sig, digest, pk, SCHEME_TAG_TYPED);
+    const sig = fixedBytesOrHex(signature, ML_DSA_87_SIGNATURE_BYTES);
+    const pk = fixedBytesOrHex(publicKey, ML_DSA_87_PUBLIC_KEY_BYTES);
+    if (!sig || !pk) return false;
+    return verifyTypedDataBytes(sig, pk, payload);
   } catch {
     return false;
   }
 }
+function publicKeyMatchesSigner(expectedSigner, descriptor, publicKey) {
+  if (!isCurrentQrlAddress(expectedSigner)) return false;
+  if (descriptor[0] !== ML_DSA_87_DESCRIPTOR_TYPE) {
+    return false;
+  }
+  const addressBytes = shake256Digest(
+    concatBytes(descriptor, publicKey),
+    CURRENT_QRL_ADDRESS_BYTES
+  );
+  const derived = `Q${bytesToHex(addressBytes).slice(2)}`;
+  return derived.toLowerCase() === expectedSigner.toLowerCase();
+}
+function verifyMessageForSigner({
+  expectedSigner,
+  descriptor,
+  signature,
+  publicKey,
+  messageBytes
+}) {
+  try {
+    if (descriptor === void 0) return false;
+    const descriptorBytes = fixedBytesOrHex(descriptor, ML_DSA_DESCRIPTOR_BYTES);
+    const publicKeyBytes = fixedBytesOrHex(publicKey, ML_DSA_87_PUBLIC_KEY_BYTES);
+    const signatureBytes = fixedBytesOrHex(signature, ML_DSA_87_SIGNATURE_BYTES);
+    if (!descriptorBytes || !publicKeyBytes || !signatureBytes) return false;
+    const message = bytesOrHex(messageBytes);
+    return publicKeyMatchesSigner(expectedSigner, descriptorBytes, publicKeyBytes) && verifyMessageBytes(signatureBytes, publicKeyBytes, message);
+  } catch {
+    return false;
+  }
+}
+function verifyTypedDataForSigner({
+  expectedSigner,
+  descriptor,
+  signature,
+  publicKey,
+  payload
+}) {
+  try {
+    if (descriptor === void 0) return false;
+    const descriptorBytes = fixedBytesOrHex(descriptor, ML_DSA_DESCRIPTOR_BYTES);
+    const publicKeyBytes = fixedBytesOrHex(publicKey, ML_DSA_87_PUBLIC_KEY_BYTES);
+    const signatureBytes = fixedBytesOrHex(signature, ML_DSA_87_SIGNATURE_BYTES);
+    if (!descriptorBytes || !publicKeyBytes || !signatureBytes) return false;
+    return publicKeyMatchesSigner(expectedSigner, descriptorBytes, publicKeyBytes) && verifyTypedDataBytes(signatureBytes, publicKeyBytes, payload);
+  } catch {
+    return false;
+  }
+}
+function verifyMessage(params) {
+  return verifyMessageSignature(params);
+}
+function verifyTypedData(params) {
+  return verifyTypedDataSignature(params);
+}
 export {
   BLOB_LEN,
+  CAP_LEN,
   CID_LEN,
   ConnectionManager,
   ConnectionStatus,
   DEFAULT_RELAY_URL,
   DIGEST_LEN,
+  EXPLICITLY_UNSUPPORTED_METHODS,
   FP_LEN,
   KeyExchange,
   KeyExchangeMessageType,
+  MAX_CONNECTION_URI_LENGTH,
+  MAX_JSON_RPC_ID_LENGTH,
+  MAX_JSON_RPC_METHOD_LENGTH,
+  MAX_RELAY_URL_LENGTH,
+  ML_DSA_87_PUBLIC_KEY_BYTES,
+  ML_DSA_87_SIGNATURE_BYTES,
+  ML_DSA_DESCRIPTOR_BYTES,
   MessageType,
+  PAIRING_CAPABILITY_LEN,
   PROTOCOL_VERSION,
   QRLConnectProvider as QRLConnect,
   QRLConnectProvider,
@@ -2363,12 +4338,14 @@ export {
   SCHEME_VERSION_MSG,
   SCHEME_VERSION_TYPED,
   SocketClient,
+  TYPED_DATA_LIMITS,
   UNRESTRICTED_METHODS,
   attemptWalletRedirect,
   bytesToHex,
   cidFromString,
   cidRandom,
   cidToString,
+  classifyRpcMethod,
   computeFingerprint,
   computeMessageDigest,
   computeTypedDataDigest,
@@ -2378,11 +4355,22 @@ export {
   fingerprintEquals,
   generateConnectionURI,
   getAppStoreUrl,
+  hasSigningDescriptor,
   hashStruct,
   hexToBytes,
   isMobileBrowser,
+  isQrlSignedMessageResult,
+  isQrlSignedResult,
+  isQrlSignedTypedDataResult,
+  isValidJsonRpcId,
+  isValidJsonRpcMethod,
+  normalizeRelayUrl,
   parseConnectionURI,
   typeHash,
   verifyMessage,
-  verifyTypedData
+  verifyMessageForSigner,
+  verifyMessageSignature,
+  verifyTypedData,
+  verifyTypedDataForSigner,
+  verifyTypedDataSignature
 };