@optimystic/quereus-plugin-crypto 0.13.4 → 0.14.1

package/dist/index.js

@@ -1,11 +1,17 @@
 import { sha512, sha256 } from '@noble/hashes/sha2.js';
 import { blake3 } from '@noble/hashes/blake3.js';
-import { randomBytes as randomBytes$1, concatBytes, utf8ToBytes } from '@noble/hashes/utils.js';
+import { concatBytes, randomBytes as randomBytes$1, utf8ToBytes } from '@noble/hashes/utils.js';
 import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { p256 } from '@noble/curves/nist.js';
 import { ed25519 } from '@noble/curves/ed25519.js';
-import { hexToBytes, bytesToHex } from '@noble/curves/utils.js';
-import { fromString, toString } from 'uint8arrays';
+import { bytesToHex, hexToBytes } from '@noble/curves/utils.js';
+import { toString, fromString } from 'uint8arrays';
+import { CID } from 'multiformats/cid';
+import * as Digest from 'multiformats/hashes/digest';
+import { base32 } from 'multiformats/bases/base32';
+import { base58btc } from 'multiformats/bases/base58';
+import { base64url } from 'multiformats/bases/base64';
+import { base16 } from 'multiformats/bases/base16';
 
 // src/crypto.ts
 function toBytes(input, encoding = "base64url") {
@@ -47,29 +53,136 @@ function fromBytes(bytes, encoding = "base64url") {
       return toString(bytes, "base64url");
   }
 }
-function digest(data, algorithm = "sha256", inputEncoding = "base64url", outputEncoding = "base64url") {
-  const bytes = toBytes(data, inputEncoding);
-  let hashBytes;
-  switch (algorithm) {
-    case "sha256":
-      hashBytes = sha256(bytes);
-      break;
-    case "sha512":
-      hashBytes = sha512(bytes);
-      break;
-    case "blake3":
-      hashBytes = blake3(bytes);
-      break;
+var HASHERS = {
+  sha256,
+  sha512,
+  blake3
+};
+var OUTPUT_ENCODERS = {
+  base64url: (bytes) => toString(bytes, "base64url"),
+  base64: (bytes) => toString(bytes, "base64"),
+  hex: (bytes) => bytesToHex(bytes),
+  bytes: (bytes) => bytes
+};
+function resolveHasher(algorithm) {
+  const hasher = HASHERS[algorithm];
+  if (!hasher) {
+    throw new Error(`Unsupported hash algorithm: ${algorithm}`);
+  }
+  return hasher;
+}
+function resolveOutputEncoder(encoding) {
+  const encoder = OUTPUT_ENCODERS[encoding];
+  if (!encoder) {
+    throw new Error(`Unsupported output encoding: ${encoding}`);
+  }
+  return encoder;
+}
+var DIGEST_FORMAT_V1 = 1;
+var TAG_NULL = 0;
+var TAG_INT = 1;
+var TAG_REAL = 2;
+var TAG_TEXT = 3;
+var TAG_BOOL = 4;
+var TAG_BLOB = 5;
+var TAG_JSON = 6;
+function writeVarint(out, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`varint expects a non-negative integer, got ${value}`);
+  }
+  let v = value;
+  while (v >= 128) {
+    out.push(v & 127 | 128);
+    v = Math.floor(v / 128);
+  }
+  out.push(v);
+}
+function framed(tag, payload) {
+  const header = [tag];
+  writeVarint(header, payload.length);
+  return concatBytes(Uint8Array.from(header), payload);
+}
+function canonicalJson(value) {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "boolean") return value ? "true" : "false";
+  if (t === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("digest: cannot encode a non-finite number inside a JSON field");
+    }
+    return JSON.stringify(value);
+  }
+  if (t === "bigint") {
+    throw new Error("digest: bigint is not representable inside a JSON field");
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((el) => {
+      if (el === void 0) {
+        throw new Error("digest: undefined / sparse element inside a JSON field");
+      }
+      return canonicalJson(el);
+    }).join(",")}]`;
+  }
+  if (t === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) {
+      throw new Error("digest: only plain objects are allowed inside a JSON field");
+    }
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((k) => {
+      if (obj[k] === void 0) {
+        throw new Error(`digest: undefined value for JSON key '${k}'`);
+      }
+      return `${JSON.stringify(k)}:${canonicalJson(obj[k])}`;
+    }).join(",")}}`;
+  }
+  throw new Error(`digest: unsupported value of type '${t}' inside a JSON field`);
+}
+function encodeField(field) {
+  if (field === null || field === void 0) {
+    return Uint8Array.of(TAG_NULL);
+  }
+  switch (typeof field) {
+    case "boolean":
+      return Uint8Array.of(TAG_BOOL, field ? 1 : 0);
+    case "bigint":
+      return framed(TAG_INT, utf8ToBytes(field.toString()));
+    case "number":
+      if (!Number.isFinite(field)) {
+        throw new Error("digest: cannot encode a non-finite number");
+      }
+      return Number.isInteger(field) ? framed(TAG_INT, utf8ToBytes(BigInt(field).toString())) : framed(TAG_REAL, utf8ToBytes(field.toString()));
+    case "string":
+      return framed(TAG_TEXT, utf8ToBytes(field));
+    case "object":
+      if (field instanceof Uint8Array) {
+        return framed(TAG_BLOB, field);
+      }
+      return framed(TAG_JSON, utf8ToBytes(canonicalJson(field)));
     default:
-      throw new Error(`Unsupported hash algorithm: ${algorithm}`);
+      throw new Error(`digest: unsupported field type '${typeof field}'`);
+  }
+}
+function encodeFields(fields) {
+  const chunks = [Uint8Array.of(DIGEST_FORMAT_V1)];
+  for (const field of fields) {
+    chunks.push(encodeField(field));
   }
-  return fromBytes(hashBytes, outputEncoding);
+  return concatBytes(...chunks);
+}
+function digestFields(fields, hasher, encode) {
+  return encode(hasher(encodeFields(fields)));
+}
+function digest(fields, algorithm = "sha256", encoding = "base64url") {
+  return digestFields(fields, resolveHasher(algorithm), resolveOutputEncoder(encoding));
 }
 function hashMod(data, bits, algorithm = "sha256", inputEncoding = "base64url") {
   if (bits <= 0 || bits > 53) {
     throw new Error("Bits must be between 1 and 53 (JavaScript safe integer limit)");
   }
-  const hashBytes = toBytes(digest(data, algorithm, inputEncoding, "base64url"), "base64url");
+  const hashBytes = resolveHasher(algorithm)(toBytes(data, inputEncoding));
   const view = new DataView(hashBytes.buffer, hashBytes.byteOffset, Math.min(8, hashBytes.length));
   const fullHash = view.getBigUint64(0, false);
   const modulus = BigInt(2) ** BigInt(bits);
@@ -157,285 +270,167 @@ function getPublicKey(privateKey, curve = "secp256k1", keyEncoding = "base64url"
   }
   return fromBytes(pubBytes, outputEncoding);
 }
-function inputToBytes(input) {
-  if (input === null || input === void 0) {
-    return new Uint8Array(0);
-  }
-  if (typeof input === "string") {
-    return utf8ToBytes(input);
-  }
-  if (input instanceof Uint8Array) {
-    return input;
-  }
-  if (typeof input === "number") {
-    const buffer = new ArrayBuffer(8);
-    const view = new DataView(buffer);
-    view.setFloat64(0, input, false);
-    return new Uint8Array(buffer);
-  }
-  if (typeof input === "boolean") {
-    return new Uint8Array([input ? 1 : 0]);
-  }
-  return utf8ToBytes(String(input));
-}
-function getHashFunction(algorithm) {
-  switch (algorithm) {
-    case "sha256":
-      return sha256;
-    case "sha512":
-      return sha512;
-    case "blake3":
-      return blake3;
-    default:
-      throw new Error(`Unsupported hash algorithm: ${algorithm}`);
-  }
-}
-function Digest(...args) {
-  return DigestWithOptions({ algorithm: "sha256", output: "uint8array" }, ...args);
-}
-function DigestWithOptions(options, ...args) {
-  const algorithm = options.algorithm || "sha256";
-  const output = options.output || "uint8array";
-  const byteArrays = args.map(inputToBytes);
-  const combined = concatBytes(...byteArrays);
-  const hashFunction = getHashFunction(algorithm);
-  const hash = hashFunction(combined);
-  if (output === "hex") {
-    return Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-  return hash;
-}
-Digest.withOptions = (options) => {
-  return (...args) => DigestWithOptions(options, ...args);
-};
-Digest.sha256 = (...args) => {
-  return DigestWithOptions({ algorithm: "sha256" }, ...args);
-};
-Digest.sha512 = (...args) => {
-  return DigestWithOptions({ algorithm: "sha512" }, ...args);
+var MULTICODEC_CODES = {
+  "raw": 85,
+  "dag-cbor": 113
 };
-Digest.blake3 = (...args) => {
-  return DigestWithOptions({ algorithm: "blake3" }, ...args);
+var MULTIHASH_CODES = {
+  "sha2-256": 18,
+  "sha2-512": 19,
+  "blake3": 30
 };
-Digest.hex = (...args) => {
-  return DigestWithOptions({ algorithm: "sha256", output: "hex" }, ...args);
+var MULTIHASH_TO_ALGORITHM = {
+  "sha2-256": "sha256",
+  "sha2-512": "sha512",
+  "blake3": "blake3"
 };
-Digest.sha256Hex = (...args) => {
-  return DigestWithOptions({ algorithm: "sha256", output: "hex" }, ...args);
+var MULTIHASH_DIGEST_LENGTHS = {
+  "sha2-256": 32,
+  "sha2-512": 64,
+  "blake3": 32
 };
-Digest.sha512Hex = (...args) => {
-  return DigestWithOptions({ algorithm: "sha512", output: "hex" }, ...args);
+var MULTICODEC_NAMES = new Map(
+  Object.entries(MULTICODEC_CODES).map(([name, code]) => [code, name])
+);
+var MULTIHASH_NAMES = new Map(
+  Object.entries(MULTIHASH_CODES).map(([name, code]) => [code, name])
+);
+var MULTIBASE_ENCODERS = {
+  "base32": base32,
+  "base58btc": base58btc,
+  "base64url": base64url,
+  "base16": base16
 };
-Digest.blake3Hex = (...args) => {
-  return DigestWithOptions({ algorithm: "blake3", output: "hex" }, ...args);
-};
-function normalizePrivateKey(privateKey) {
-  if (privateKey instanceof Uint8Array) {
-    return privateKey;
-  }
-  if (typeof privateKey === "string") {
-    return hexToBytes(privateKey);
-  }
-  if (typeof privateKey === "bigint") {
-    const hex = privateKey.toString(16).padStart(64, "0");
-    return hexToBytes(hex);
+var MULTIBASE_DECODER = base32.decoder.or(base58btc.decoder).or(base64url.decoder).or(base16.decoder);
+function resolveCodecCode(codec) {
+  const code = MULTICODEC_CODES[codec];
+  if (code === void 0) {
+    throw new Error(`cid: unsupported multicodec '${codec}' (expected one of ${Object.keys(MULTICODEC_CODES).join(", ")})`);
   }
-  throw new Error("Invalid private key format");
+  return code;
 }
-function normalizeDigest(digest2) {
-  if (digest2 instanceof Uint8Array) {
-    return digest2;
+function resolveBaseEncoder(base) {
+  const encoder = MULTIBASE_ENCODERS[base];
+  if (!encoder) {
+    throw new Error(`cid: unsupported multibase '${base}' (expected one of ${Object.keys(MULTIBASE_ENCODERS).join(", ")})`);
   }
-  if (typeof digest2 === "string") {
-    return hexToBytes(digest2);
-  }
-  throw new Error("Invalid digest format");
+  return encoder;
 }
-function formatSignature(signature, format, curve) {
-  switch (format) {
-    case "uint8array":
-    case "compact":
-      return signature;
-    case "hex":
-      return bytesToHex(signature);
-    case "der":
-      if (curve === "ed25519") {
-        throw new Error("DER format not supported for ed25519");
-      }
-      return signature;
-    default:
-      throw new Error(`Unsupported signature format: ${format}`);
-  }
+function cidV1(digest2, hash, codec = "raw", base = "base32") {
+  const hashCode = MULTIHASH_CODES[hash];
+  if (hashCode === void 0) {
+    throw new Error(`cid: unsupported multihash code '${hash}' (expected one of ${Object.keys(MULTIHASH_CODES).join(", ")})`);
+  }
+  const expectedLength = MULTIHASH_DIGEST_LENGTHS[hash];
+  if (digest2.length !== expectedLength) {
+    throw new Error(`cid: digest length ${digest2.length} does not match asserted hash '${hash}' (expected ${expectedLength} bytes)`);
+  }
+  const codecCode = resolveCodecCode(codec);
+  const encoder = resolveBaseEncoder(base);
+  const multihash = Digest.create(hashCode, digest2);
+  return CID.createV1(codecCode, multihash).toString(encoder);
 }
-function Sign(digest2, privateKey, options = {}) {
-  const {
-    curve = "secp256k1",
-    format = "uint8array",
-    extraEntropy = false,
-    lowS = true
-  } = options;
-  const normalizedDigest = normalizeDigest(digest2);
-  const normalizedPrivateKey = normalizePrivateKey(privateKey);
-  let signature;
-  switch (curve) {
-    case "secp256k1": {
-      const signOptions = { lowS };
-      if (extraEntropy) {
-        signOptions.extraEntropy = extraEntropy;
-      }
-      signature = secp256k1.sign(normalizedDigest, normalizedPrivateKey, signOptions);
-      break;
-    }
-    case "p256": {
-      const signOptions = { lowS };
-      if (extraEntropy) {
-        signOptions.extraEntropy = extraEntropy;
-      }
-      signature = p256.sign(normalizedDigest, normalizedPrivateKey, signOptions);
-      break;
-    }
-    case "ed25519": {
-      signature = ed25519.sign(normalizedDigest, normalizedPrivateKey);
-      break;
-    }
-    default:
-      throw new Error(`Unsupported curve: ${curve}`);
+function cid(data, codec = "raw", hash = "sha2-256", base = "base32") {
+  const algorithm = MULTIHASH_TO_ALGORITHM[hash];
+  if (!algorithm) {
+    throw new Error(`cid: unsupported multihash code '${hash}' (expected one of ${Object.keys(MULTIHASH_CODES).join(", ")})`);
   }
-  return formatSignature(signature, format, curve);
+  const digest2 = resolveHasher(algorithm)(data);
+  return cidV1(digest2, hash, codec, base);
 }
-Sign.secp256k1 = (digest2, privateKey, options = {}) => {
-  return Sign(digest2, privateKey, { ...options, curve: "secp256k1" });
-};
-Sign.p256 = (digest2, privateKey, options = {}) => {
-  return Sign(digest2, privateKey, { ...options, curve: "p256" });
-};
-Sign.ed25519 = (digest2, privateKey, options = {}) => {
-  return Sign(digest2, privateKey, { ...options, curve: "ed25519" });
-};
-Sign.generatePrivateKey = (curve = "secp256k1") => {
-  switch (curve) {
-    case "secp256k1":
-      return secp256k1.utils.randomSecretKey();
-    case "p256":
-      return p256.utils.randomSecretKey();
-    case "ed25519":
-      return ed25519.utils.randomSecretKey();
-    default:
-      throw new Error(`Unsupported curve: ${curve}`);
-  }
-};
-Sign.getPublicKey = (privateKey, curve = "secp256k1") => {
-  const normalizedPrivateKey = normalizePrivateKey(privateKey);
-  switch (curve) {
-    case "secp256k1":
-      return secp256k1.getPublicKey(normalizedPrivateKey);
-    case "p256":
-      return p256.getPublicKey(normalizedPrivateKey);
-    case "ed25519":
-      return ed25519.getPublicKey(normalizedPrivateKey);
-    default:
-      throw new Error(`Unsupported curve: ${curve}`);
-  }
-};
-function normalizeBytes(input) {
-  if (input instanceof Uint8Array) {
-    return input;
-  }
-  if (typeof input === "string") {
-    return hexToBytes(input);
-  }
-  throw new Error("Invalid input format - expected Uint8Array or hex string");
+function cidDecode(value) {
+  const parsed = CID.parse(value, MULTIBASE_DECODER);
+  return {
+    version: parsed.version,
+    codec: MULTICODEC_NAMES.get(parsed.code) ?? parsed.code,
+    hashCode: MULTIHASH_NAMES.get(parsed.multihash.code) ?? parsed.multihash.code,
+    digest: parsed.multihash.digest
+  };
 }
-function detectSignatureFormat(signature, curve) {
-  const length = signature.length;
-  if (curve === "ed25519") {
-    return "raw";
+var SD_LEAF_DOMAIN_V1 = "optimystic/sd-leaf/v1";
+var SD_SET_DOMAIN_V1 = "optimystic/sd-set/v1";
+var HIDDEN_ENCODING = "base64url";
+function compareBytes(a, b) {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const d = a[i] - b[i];
+    if (d !== 0) return d;
+  }
+  return a.length - b.length;
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
   }
-  if (length === 64) {
-    return "compact";
+  return true;
+}
+function requireSaltBytes(leaf) {
+  const { salt } = leaf;
+  if (salt == null) {
+    throw new Error(`set commitment: leaf '${leaf.name}' is missing a salt (an unsalted leaf is brute-forceable)`);
   }
-  if (length >= 70 && length <= 72 && signature[0] === 48) {
-    return "der";
+  const bytes = salt instanceof Uint8Array ? salt : fromString(salt, HIDDEN_ENCODING);
+  if (bytes.length === 0) {
+    throw new Error(`set commitment: leaf '${leaf.name}' has an empty salt (an unsalted leaf is brute-forceable)`);
   }
-  return "compact";
+  return bytes;
 }
-function parseSignature(signature, format, curve) {
-  if (curve === "ed25519") {
-    return signature;
+function assertUniqueNames(leaves) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const leaf of leaves) {
+    if (seen.has(leaf.name)) {
+      throw new Error(`set commitment: duplicate leaf name '${leaf.name}'`);
+    }
+    seen.add(leaf.name);
   }
-  const sigFormat = format === "raw" ? "compact" : format;
-  if (curve === "secp256k1") {
-    return secp256k1.Signature.fromBytes(signature, sigFormat).toBytes();
-  } else if (curve === "p256") {
-    return p256.Signature.fromBytes(signature, sigFormat).toBytes();
+}
+function leafDigest(leaf, hasher) {
+  const saltBytes = requireSaltBytes(leaf);
+  return hasher(encodeFields([SD_LEAF_DOMAIN_V1, leaf.name, leaf.value, saltBytes]));
+}
+function setCommit(leaves, hasher = resolveHasher("sha256"), encode = resolveOutputEncoder("base64url")) {
+  assertUniqueNames(leaves);
+  const leafDigests = leaves.map((leaf) => leafDigest(leaf, hasher));
+  leafDigests.sort(compareBytes);
+  return encode(hasher(encodeFields([SD_SET_DOMAIN_V1, ...leafDigests])));
+}
+function setDisclose(leaves, revealNames, hasher = resolveHasher("sha256")) {
+  assertUniqueNames(leaves);
+  const reveal = new Set(revealNames);
+  const disclosed = [];
+  const hidden = [];
+  for (const leaf of leaves) {
+    if (reveal.has(leaf.name)) {
+      disclosed.push(leaf);
+    } else {
+      hidden.push(toString(leafDigest(leaf, hasher), HIDDEN_ENCODING));
+    }
   }
-  throw new Error(`Failed to parse signature for curve ${curve} with format ${format}`);
+  return { disclosed, hidden };
 }
-function SignatureValid(digest2, signature, publicKey, options = {}) {
+function setVerify(root, disclosure, hasher = resolveHasher("sha256"), encode = resolveOutputEncoder("base64url")) {
   try {
-    const {
-      curve = "secp256k1",
-      signatureFormat,
-      allowMalleableSignatures
-    } = options;
-    const normalizedDigest = normalizeBytes(digest2);
-    const normalizedSignature = normalizeBytes(signature);
-    const normalizedPublicKey = normalizeBytes(publicKey);
-    const detectedFormat = signatureFormat || detectSignatureFormat(normalizedSignature, curve);
-    const parsedSignature = parseSignature(normalizedSignature, detectedFormat, curve);
-    const verifyOptions = {};
-    if (curve !== "ed25519" && allowMalleableSignatures !== void 0) {
-      verifyOptions.lowS = !allowMalleableSignatures;
+    const { disclosed, hidden } = disclosure;
+    const digests = [];
+    for (const leaf of disclosed) {
+      digests.push(leafDigest(leaf, hasher));
     }
-    switch (curve) {
-      case "secp256k1":
-        return secp256k1.verify(parsedSignature, normalizedDigest, normalizedPublicKey, verifyOptions);
-      case "p256":
-        return p256.verify(parsedSignature, normalizedDigest, normalizedPublicKey, verifyOptions);
-      case "ed25519":
-        return ed25519.verify(parsedSignature, normalizedDigest, normalizedPublicKey);
-      default:
-        throw new Error(`Unsupported curve: ${curve}`);
+    for (const h of hidden) {
+      digests.push(fromString(h, HIDDEN_ENCODING));
     }
-  } catch (error) {
+    digests.sort(compareBytes);
+    const recomputed = hasher(encodeFields([SD_SET_DOMAIN_V1, ...digests]));
+    if (root instanceof Uint8Array) {
+      return bytesEqual(recomputed, root);
+    }
+    const encoded = encode(recomputed);
+    return typeof encoded === "string" && encoded === root;
+  } catch {
     return false;
   }
 }
-SignatureValid.secp256k1 = (digest2, signature, publicKey, options = {}) => {
-  return SignatureValid(digest2, signature, publicKey, { ...options, curve: "secp256k1" });
-};
-SignatureValid.p256 = (digest2, signature, publicKey, options = {}) => {
-  return SignatureValid(digest2, signature, publicKey, { ...options, curve: "p256" });
-};
-SignatureValid.ed25519 = (digest2, signature, publicKey, options = {}) => {
-  return SignatureValid(digest2, signature, publicKey, { ...options, curve: "ed25519" });
-};
-SignatureValid.batch = (verifications) => {
-  return verifications.map(
-    ({ digest: digest2, signature, publicKey, options }) => SignatureValid(digest2, signature, publicKey, options)
-  );
-};
-SignatureValid.detailed = (digest2, signature, publicKey, options = {}) => {
-  const curve = options.curve || "secp256k1";
-  try {
-    const normalizedSignature = normalizeBytes(signature);
-    const detectedFormat = options.signatureFormat || detectSignatureFormat(normalizedSignature, curve);
-    const valid = SignatureValid(digest2, signature, publicKey, options);
-    return {
-      valid,
-      curve,
-      signatureFormat: detectedFormat
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      curve,
-      signatureFormat: "unknown",
-      error: error instanceof Error ? error.message : "Unknown error"
-    };
-  }
-};
 
-export { Digest, Sign, SignatureValid, digest, generatePrivateKey, getPublicKey, hashMod, randomBytes, sign, verify };
+export { cid, cidDecode, cidV1, digest, digestFields, encodeFields, generatePrivateKey, getPublicKey, hashMod, leafDigest, randomBytes, resolveHasher, resolveOutputEncoder, setCommit, setDisclose, setVerify, sign, verify };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map