@qrlwallet/connect 5.0.3 → 5.1.1

package/dist/index.js

@@ -59,8 +59,10 @@ __export(index_exports, {
   RESTRICTED_METHODS: () => RESTRICTED_METHODS,
   SCHEME_TAG_MSG: () => SCHEME_TAG_MSG,
   SCHEME_TAG_TYPED: () => SCHEME_TAG_TYPED,
+  SCHEME_TAG_TYPED_V2: () => SCHEME_TAG_TYPED_V2,
   SCHEME_VERSION_MSG: () => SCHEME_VERSION_MSG,
   SCHEME_VERSION_TYPED: () => SCHEME_VERSION_TYPED,
+  SCHEME_VERSION_TYPED_V2: () => SCHEME_VERSION_TYPED_V2,
   SocketClient: () => SocketClient,
   TYPED_DATA_LIMITS: () => TYPED_DATA_LIMITS,
   UNRESTRICTED_METHODS: () => UNRESTRICTED_METHODS,
@@ -94,6 +96,8 @@ __export(index_exports, {
   parseConnectionURI: () => parseConnectionURI,
   qip55AddressFromBytes: () => qip55AddressFromBytes,
   typeHash: () => typeHash,
+  typedDataSchemeTag: () => typedDataSchemeTag,
+  typedDataSchemeVersion: () => typedDataSchemeVersion,
   verifyMessage: () => verifyMessage,
   verifyMessageForSigner: () => verifyMessageForSigner,
   verifyMessageSignature: () => verifyMessageSignature,
@@ -566,7 +570,7 @@ 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);
+    return hasExactOwnKeys(value, keys) && (value.schemeVersion === "QRL-SIGN-TYPED-v1" || value.schemeVersion === "QRL-SIGN-TYPED-v2") && isSigningResultRecord(value.domain) && hasValidSigningFields(value);
   } catch {
     return false;
   }
@@ -3081,8 +3085,10 @@ var ConnectionManager = _ConnectionManager;
 // src/signing/ctx.ts
 var SCHEME_VERSION_MSG = "QRL-SIGN-MSG-v1";
 var SCHEME_VERSION_TYPED = "QRL-SIGN-TYPED-v1";
+var SCHEME_VERSION_TYPED_V2 = "QRL-SIGN-TYPED-v2";
 var SCHEME_TAG_MSG = new TextEncoder().encode(SCHEME_VERSION_MSG);
 var SCHEME_TAG_TYPED = new TextEncoder().encode(SCHEME_VERSION_TYPED);
+var SCHEME_TAG_TYPED_V2 = new TextEncoder().encode(SCHEME_VERSION_TYPED_V2);
 var DIGEST_LEN = 64;
 
 // src/signing/bytes.ts
@@ -3122,7 +3128,14 @@ function concatBytesArr(parts) {
 }
 
 // src/signing/typedData.ts
-var SLOT = 32;
+var SLOT_BYTES = Object.freeze({
+  [SCHEME_VERSION_TYPED]: 32,
+  [SCHEME_VERSION_TYPED_V2]: 64
+});
+var SCHEME_TAGS = Object.freeze({
+  [SCHEME_VERSION_TYPED]: SCHEME_TAG_TYPED,
+  [SCHEME_VERSION_TYPED_V2]: SCHEME_TAG_TYPED_V2
+});
 var TYPED_DATA_LIMITS = Object.freeze({
   maxTypes: 32,
   maxFieldsPerType: 32,
@@ -3174,21 +3187,30 @@ function parsePayload(payload) {
 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 newBudget(schemeVersion) {
+  return {
+    remainingValues: TYPED_DATA_LIMITS.maxEncodedValues,
+    slot: SLOT_BYTES[schemeVersion]
+  };
+}
 function consumeValue(budget) {
   budget.remainingValues--;
   if (budget.remainingValues < 0) throw new Error("typed data contains too many encoded values");
 }
+function inputPreview(value) {
+  return value.length > 32 ? `${value.slice(0, 32)}... (length ${value.length})` : value;
+}
 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}`);
+    throw new Error(`invalid ${label}: ${inputPreview(value)}`);
   }
 }
 function parseFieldType(type, types, depth = 0) {
   if (depth > TYPED_DATA_LIMITS.maxArrayNesting) {
-    throw new Error(`type nesting too deep: ${type}`);
+    throw new Error(`type nesting too deep: ${inputPreview(type)}`);
   }
   if (type.length > TYPED_DATA_LIMITS.maxFieldTypeLength) {
-    throw new Error(`field type too long: ${type}`);
+    throw new Error(`field type too long: ${inputPreview(type)}`);
   }
   const m = ATOMIC_RE.exec(type);
   if (m) {
@@ -3199,14 +3221,14 @@ function parseFieldType(type, types, depth = 0) {
     if (intKind) {
       const width = Number(intWidthStr);
       if (!Number.isInteger(width) || width < 8 || width > 256 || width % 8 !== 0) {
-        throw new Error(`invalid int width: ${type}`);
+        throw new Error(`invalid int width: ${inputPreview(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}`);
+        throw new Error(`invalid bytesN width: ${inputPreview(type)}`);
       }
       return { kind: "bytesN", width };
     }
@@ -3215,7 +3237,7 @@ function parseFieldType(type, types, depth = 0) {
       if (sizeStr) {
         const size = Number(sizeStr);
         if (!Number.isSafeInteger(size) || size <= 0 || size > TYPED_DATA_LIMITS.maxArrayLength) {
-          throw new Error(`invalid array size: ${type}`);
+          throw new Error(`invalid array size: ${inputPreview(type)}`);
         }
         return { kind: "array", inner: innerType, size };
       }
@@ -3225,7 +3247,7 @@ function parseFieldType(type, types, depth = 0) {
   if (Object.prototype.hasOwnProperty.call(types, type)) {
     return { kind: "ref", name: type };
   }
-  throw new Error(`unknown type: ${type}`);
+  throw new Error(`unknown type: ${inputPreview(type)}`);
 }
 function isReservedAtomicTypeName(name) {
   if (/^(?:address|bool|string|bytes)$/.test(name)) return true;
@@ -3242,24 +3264,35 @@ function isReservedAtomicTypeName(name) {
   return false;
 }
 function baseTypeName(type) {
-  return type.replace(/(\[\d*\])+$/, "");
+  let end = type.length;
+  while (end > 0 && type[end - 1] === "]") {
+    let start = end - 2;
+    while (start >= 0) {
+      const code = type.charCodeAt(start);
+      if (code < 48 || code > 57) break;
+      start--;
+    }
+    if (start < 0 || type[start] !== "[") break;
+    end = start;
+  }
+  return type.slice(0, end);
 }
 function collectDependencies(primary, types) {
   if (!Object.prototype.hasOwnProperty.call(types, primary)) {
-    throw new Error(`unknown primary type: ${primary}`);
+    throw new Error(`unknown primary type: ${inputPreview(primary)}`);
   }
   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(" -> ")}`);
+      throw new Error(`type graph nesting too deep: ${inputPreview([...path, name].join(" -> "))}`);
     }
     if (path.includes(name)) {
-      throw new Error(`cyclic type reference: ${[...path, name].join(" -> ")}`);
+      throw new Error(`cyclic type reference: ${inputPreview([...path, name].join(" -> "))}`);
     }
     if (visited.has(name)) return;
     visited.add(name);
     const def = types[name];
-    if (!def) throw new Error(`unknown type: ${name}`);
+    if (!def) throw new Error(`unknown type: ${inputPreview(name)}`);
     for (const f of def) {
       const base = baseTypeName(f.type);
       if (Object.prototype.hasOwnProperty.call(types, base)) {
@@ -3280,11 +3313,11 @@ function validateTypeMap(types) {
   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}`);
+      throw new Error(`struct name is reserved by an atomic type: ${inputPreview(name)}`);
     }
     const defUnknown = def;
     if (!Array.isArray(defUnknown) || def.length === 0 || def.length > TYPED_DATA_LIMITS.maxFieldsPerType) {
-      throw new Error(`empty or invalid struct: ${name}`);
+      throw new Error(`empty or invalid struct: ${inputPreview(name)}`);
     }
     totalFields += def.length;
     if (totalFields > TYPED_DATA_LIMITS.maxTotalFields) {
@@ -3293,14 +3326,17 @@ function validateTypeMap(types) {
     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}`);
+        throw new Error(`bad field in ${inputPreview(name)}`);
       }
-      assertIdentifier(f.name, `field name in ${name}`);
+      assertIdentifier(f.name, `field name in ${inputPreview(name)}`);
       if (typeof f.type !== "string" || !f.type) {
-        throw new Error(`bad field type in ${name}.${f.name}`);
+        throw new Error(`bad field type in ${inputPreview(name)}.${inputPreview(f.name)}`);
+      }
+      if (f.type.length > TYPED_DATA_LIMITS.maxFieldTypeLength) {
+        throw new Error(`field type too long: ${inputPreview(f.type)}`);
       }
       if (seen.has(f.name)) {
-        throw new Error(`duplicate field "${f.name}" in ${name}`);
+        throw new Error(`duplicate field "${inputPreview(f.name)}" in ${inputPreview(name)}`);
       }
       seen.add(f.name);
     }
@@ -3312,7 +3348,7 @@ function encodeType(primary, types) {
   const others = [...deps].filter((n) => n !== primary).sort();
   return [primary, ...others].map((name) => {
     const fields = types[name];
-    if (!fields) throw new Error(`unknown type: ${name}`);
+    if (!fields) throw new Error(`unknown type: ${inputPreview(name)}`);
     const inner = fields.map((f) => `${f.type} ${f.name}`).join(",");
     return `${name}(${inner})`;
   }).join("");
@@ -3320,44 +3356,46 @@ function encodeType(primary, types) {
 function typeHash(primary, types) {
   return shake256Digest(new TextEncoder().encode(encodeType(primary, types)), DIGEST_LEN);
 }
-function parseQAddress(addr) {
+function parseQAddress(addr, slot) {
   if (!isCurrentQrlAddress(addr)) {
-    throw new Error(`invalid Q-address: ${String(addr)}`);
+    throw new Error(`invalid Q-address: ${inputPreview(String(addr))}`);
   }
   const bytes = hexToBytes("0x" + addr.slice(1).toLowerCase());
-  if (bytes.length > SLOT) {
+  if (bytes.length > slot) {
     throw new Error("qrl_signTypedData v1 does not support QIP-55 address fields");
   }
   return bytes;
 }
-function padLeft32(bytes) {
-  if (bytes.length > SLOT) throw new Error("cannot pad: bytes > 32");
-  const out = new Uint8Array(SLOT);
-  out.set(bytes, SLOT - bytes.length);
+function padLeft(bytes, slot) {
+  if (bytes.length > slot) throw new Error(`cannot pad: bytes > ${slot}`);
+  const out = new Uint8Array(slot);
+  out.set(bytes, slot - bytes.length);
   return out;
 }
-function padRight32(bytes) {
-  if (bytes.length > SLOT) throw new Error("cannot pad: bytes > 32");
-  const out = new Uint8Array(SLOT);
+function padRight(bytes, slot) {
+  if (bytes.length > slot) throw new Error(`cannot pad: bytes > ${slot}`);
+  const out = new Uint8Array(slot);
   out.set(bytes, 0);
   return out;
 }
-function bigIntToSlot(value, width, signed) {
+function bigIntToSlot(value, width, signed, slot) {
   if (signed) {
     const limit = 1n << BigInt(width - 1);
     if (value >= limit || value < -limit) {
-      throw new Error(`int${width} out of range: ${value}`);
+      throw new Error(`int${width} out of range: ${inputPreview(String(value))}`);
     }
   } else {
-    if (value < 0n) throw new Error(`uint${width} negative: ${value}`);
+    if (value < 0n) throw new Error(`uint${width} negative: ${inputPreview(String(value))}`);
     const limit = 1n << BigInt(width);
-    if (value >= limit) throw new Error(`uint${width} out of range: ${value}`);
+    if (value >= limit)
+      throw new Error(`uint${width} out of range: ${inputPreview(String(value))}`);
   }
-  const slotMask = (1n << 256n) - 1n;
-  const repr = value < 0n ? value + (1n << 256n) & slotMask : value;
-  const out = new Uint8Array(SLOT);
+  const slotBits = BigInt(slot * 8);
+  const slotMask = (1n << slotBits) - 1n;
+  const repr = value < 0n ? value + (1n << slotBits) & slotMask : value;
+  const out = new Uint8Array(slot);
   let v = repr;
-  for (let i = SLOT - 1; i >= 0; i--) {
+  for (let i = slot - 1; i >= 0; i--) {
     out[i] = Number(v & 0xffn);
     v >>= 8n;
   }
@@ -3373,7 +3411,7 @@ function parseIntValue(v, typeLabel) {
       return isNegative ? -abs : abs;
     }
     if (!/^-?(0|[1-9]\d*)$/.test(v)) {
-      throw new Error(`invalid ${typeLabel} string: ${v}`);
+      throw new Error(`invalid ${typeLabel} string: ${inputPreview(v)}`);
     }
     return BigInt(v);
   }
@@ -3387,26 +3425,26 @@ function parseIntValue(v, typeLabel) {
 }
 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}`);
+    throw new Error(`value nesting too deep: ${inputPreview(type)}`);
   }
   consumeValue(budget);
   const parsed = parseFieldType(type, types);
   switch (parsed.kind) {
     case "ref":
       if (!isMessageObject(value)) {
-        throw new Error(`struct field expects object: ${type}`);
+        throw new Error(`struct field expects object: ${inputPreview(type)}`);
       }
       return hashStructWithBudget(parsed.name, value, types, budget, depth + 1);
     case "address":
       if (typeof value !== "string") {
         throw new Error(`address field expects string: ${typeof value}`);
       }
-      return padLeft32(parseQAddress(value));
+      return padLeft(parseQAddress(value, budget.slot), budget.slot);
     case "bool":
       if (typeof value !== "boolean") {
         throw new Error(`bool field expects boolean: ${typeof value}`);
       }
-      return padLeft32(new Uint8Array([value ? 1 : 0]));
+      return padLeft(new Uint8Array([value ? 1 : 0]), budget.slot);
     case "string": {
       if (typeof value !== "string") {
         throw new Error(`string field expects string: ${typeof value}`);
@@ -3429,9 +3467,19 @@ function encodeFieldWithBudget(type, value, types, budget, depth) {
       }
       return shake256Digest(hexToBytes(value), DIGEST_LEN);
     case "uintN":
-      return bigIntToSlot(parseIntValue(value, `uint${parsed.width}`), parsed.width, false);
+      return bigIntToSlot(
+        parseIntValue(value, `uint${parsed.width}`),
+        parsed.width,
+        false,
+        budget.slot
+      );
     case "intN":
-      return bigIntToSlot(parseIntValue(value, `int${parsed.width}`), parsed.width, true);
+      return bigIntToSlot(
+        parseIntValue(value, `int${parsed.width}`),
+        parsed.width,
+        true,
+        budget.slot
+      );
     case "bytesN": {
       if (typeof value !== "string") {
         throw new Error(`bytes${parsed.width} expects 0x-hex string: ${typeof value}`);
@@ -3443,17 +3491,19 @@ function encodeFieldWithBudget(type, value, types, budget, depth) {
       if (raw.length !== parsed.width) {
         throw new Error(`bytes${parsed.width} requires ${parsed.width} bytes, got ${raw.length}`);
       }
-      return padRight32(raw);
+      return padRight(raw, budget.slot);
     }
     case "array": {
       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`);
+        throw new Error(`array ${inputPreview(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}`);
+        throw new Error(
+          `fixed array ${inputPreview(type)} requires length ${parsed.size}, got ${value.length}`
+        );
       }
       const chunks = value.map(
         (v) => encodeFieldWithBudget(parsed.inner, v, types, budget, depth + 1)
@@ -3462,20 +3512,15 @@ function encodeFieldWithBudget(type, value, types, budget, depth) {
     }
   }
 }
-function encodeField(type, value, types) {
+function encodeField(type, value, types, schemeVersion) {
   validateTypeMap(types);
-  return encodeFieldWithBudget(
-    type,
-    value,
-    types,
-    { remainingValues: TYPED_DATA_LIMITS.maxEncodedValues },
-    0
-  );
+  const scheme = schemeVersion ?? schemeVersionForTypes(types);
+  return encodeFieldWithBudget(type, value, types, newBudget(scheme), 0);
 }
 function hashStructWithBudget(primary, data, types, budget, depth) {
   consumeValue(budget);
   const fields = types[primary];
-  if (!fields) throw new Error(`unknown struct: ${primary}`);
+  if (!fields) throw new Error(`unknown struct: ${inputPreview(primary)}`);
   const expected = new Set(fields.map((f) => f.name));
   let ownFieldCount = 0;
   for (const k in data) {
@@ -3484,26 +3529,23 @@ function hashStructWithBudget(primary, data, types, budget, depth) {
     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}`);
+    if (!expected.has(k)) {
+      throw new Error(`unknown field in ${inputPreview(primary)}: ${inputPreview(k)}`);
+    }
   }
   const parts = [typeHash(primary, types)];
   for (const f of fields) {
     if (!Object.prototype.hasOwnProperty.call(data, f.name)) {
-      throw new Error(`missing field ${primary}.${f.name}`);
+      throw new Error(`missing field ${inputPreview(primary)}.${inputPreview(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) {
+function hashStruct(primary, data, types, schemeVersion) {
   validateTypeMap(types);
-  return hashStructWithBudget(
-    primary,
-    data,
-    types,
-    { remainingValues: TYPED_DATA_LIMITS.maxEncodedValues },
-    0
-  );
+  const scheme = schemeVersion ?? schemeVersionForTypes(types);
+  return hashStructWithBudget(primary, data, types, newBudget(scheme), 0);
 }
 var RESERVED_DOMAIN_FIELDS = {
   name: "string",
@@ -3520,11 +3562,13 @@ function validateDomainTypes(types) {
     const expected = RESERVED_DOMAIN_FIELDS[f.name];
     if (!expected) {
       throw new Error(
-        `QRLDomain field "${f.name}" not in reserved set (name, version, chainId, verifyingContract, salt)`
+        `QRLDomain field "${inputPreview(f.name)}" not in reserved set (name, version, chainId, verifyingContract, salt)`
       );
     }
     if (f.type !== expected) {
-      throw new Error(`QRLDomain field "${f.name}" must be type "${expected}", got "${f.type}"`);
+      throw new Error(
+        `QRLDomain field "${inputPreview(f.name)}" must be type "${expected}", got "${inputPreview(f.type)}"`
+      );
     }
     if (f.name === "name") hasName = true;
   }
@@ -3536,10 +3580,10 @@ function validatePayloadReachability(primary, types) {
     for (const t of collectDependencies(root, types)) reachable.add(t);
   }
   for (const k of Object.keys(types)) {
-    if (!reachable.has(k)) throw new Error(`unused referenced type: ${k}`);
+    if (!reachable.has(k)) throw new Error(`unused referenced type: ${inputPreview(k)}`);
   }
 }
-function computeTypedDataDigest(payload) {
+function parseAndValidatePayload(payload) {
   const parsed = parsePayload(payload);
   validateTypeMap(parsed.types);
   assertIdentifier(parsed.primaryType, "primary type");
@@ -3548,7 +3592,26 @@ function computeTypedDataDigest(payload) {
   }
   validateDomainTypes(parsed.types);
   validatePayloadReachability(parsed.primaryType, parsed.types);
-  const budget = { remainingValues: TYPED_DATA_LIMITS.maxEncodedValues };
+  return parsed;
+}
+function schemeVersionForTypes(types) {
+  for (const fields of Object.values(types)) {
+    if (fields.some((f) => baseTypeName(f.type) === "address")) {
+      return SCHEME_VERSION_TYPED_V2;
+    }
+  }
+  return SCHEME_VERSION_TYPED;
+}
+function typedDataSchemeVersion(payload) {
+  return schemeVersionForTypes(parseAndValidatePayload(payload).types);
+}
+function typedDataSchemeTag(schemeVersion) {
+  return SCHEME_TAGS[schemeVersion];
+}
+function computeTypedDataDigest(payload) {
+  const parsed = parseAndValidatePayload(payload);
+  const schemeVersion = schemeVersionForTypes(parsed.types);
+  const budget = newBudget(schemeVersion);
   const domainHash = hashStructWithBudget("QRLDomain", parsed.domain, parsed.types, budget, 0);
   const messageHash = hashStructWithBudget(
     parsed.primaryType,
@@ -3557,7 +3620,10 @@ function computeTypedDataDigest(payload) {
     budget,
     0
   );
-  return shake256Digest(concatBytes(SCHEME_TAG_TYPED, domainHash, messageHash), DIGEST_LEN);
+  return shake256Digest(
+    concatBytes(SCHEME_TAGS[schemeVersion], domainHash, messageHash),
+    DIGEST_LEN
+  );
 }
 
 // src/utils/platform.ts
@@ -3749,9 +3815,8 @@ function validateRestrictedRequest(method, params, authorizedAccounts, currentCh
   if (params[0] !== authorizedAccount) {
     throw new Error("qrl_signTypedData signer is not the authorized account");
   }
-  throw new Error(
-    "qrl_signTypedData is unavailable for QIP-55 until the 64-byte word encoding and signing scheme version are finalized"
-  );
+  computeTypedDataDigest(params[1]);
+  return void 0;
 }
 function requiresAuthorizedAccount(method) {
   return method === "qrl_sendTransaction" || method === "qrl_signTransaction" || method === "qrl_signMessage" || method === "qrl_signTypedData";
@@ -4397,9 +4462,13 @@ function verifyMessageBytes(signature, publicKey, messageBytes) {
   const digest = computeMessageDigest(messageBytes);
   return mldsaVerify(signature, digest, publicKey, SCHEME_TAG_MSG);
 }
-function verifyTypedDataBytes(signature, publicKey, payload) {
+function verifyTypedDataBytes(signature, publicKey, payload, claimedSchemeVersion) {
+  const schemeVersion = typedDataSchemeVersion(payload);
+  if (claimedSchemeVersion !== void 0 && claimedSchemeVersion !== schemeVersion) {
+    return false;
+  }
   const digest = computeTypedDataDigest(payload);
-  return mldsaVerify(signature, digest, publicKey, SCHEME_TAG_TYPED);
+  return mldsaVerify(signature, digest, publicKey, typedDataSchemeTag(schemeVersion));
 }
 function verifyMessageSignature({
   signature,
@@ -4419,13 +4488,14 @@ function verifyMessageSignature({
 function verifyTypedDataSignature({
   signature,
   publicKey,
-  payload
+  payload,
+  schemeVersion
 }) {
   try {
     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);
+    return verifyTypedDataBytes(sig, pk, payload, schemeVersion);
   } catch {
     return false;
   }
@@ -4463,7 +4533,8 @@ function verifyTypedDataForSigner({
   descriptor,
   signature,
   publicKey,
-  payload
+  payload,
+  schemeVersion
 }) {
   try {
     if (descriptor === void 0) return false;
@@ -4471,7 +4542,7 @@ function verifyTypedDataForSigner({
     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);
+    return publicKeyMatchesSigner(expectedSigner, descriptorBytes, publicKeyBytes) && verifyTypedDataBytes(signatureBytes, publicKeyBytes, payload, schemeVersion);
   } catch {
     return false;
   }
@@ -4513,8 +4584,10 @@ function verifyTypedData(params) {
   RESTRICTED_METHODS,
   SCHEME_TAG_MSG,
   SCHEME_TAG_TYPED,
+  SCHEME_TAG_TYPED_V2,
   SCHEME_VERSION_MSG,
   SCHEME_VERSION_TYPED,
+  SCHEME_VERSION_TYPED_V2,
   SocketClient,
   TYPED_DATA_LIMITS,
   UNRESTRICTED_METHODS,
@@ -4548,6 +4621,8 @@ function verifyTypedData(params) {
   parseConnectionURI,
   qip55AddressFromBytes,
   typeHash,
+  typedDataSchemeTag,
+  typedDataSchemeVersion,
   verifyMessage,
   verifyMessageForSigner,
   verifyMessageSignature,