xoonya 2.6.0 → 2.7.0

package/scripts/verify_vectors.js

@@ -0,0 +1,164 @@
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+const sdk = require("..");
+
+const conformanceVectors = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "vectors", "conformance-vectors.json"), "utf8")
+);
+const adversarialVectors = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "vectors", "adversarial-vectors.json"), "utf8")
+);
+const nativeAtomVectors = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "vectors", "native-atom-vectors.json"), "utf8")
+);
+
+function unique(values) {
+  return Array.from(new Set(values.filter(Boolean))).sort();
+}
+
+function runVectorVerification() {
+  assert.strictEqual(conformanceVectors.version, "proof-conformance-v1", "conformance vector version mismatch");
+  assert.strictEqual(adversarialVectors.version, "proof-adversarial-v1", "adversarial vector version mismatch");
+  assert.strictEqual(nativeAtomVectors.version, "xoonya-native-atom-vectors-v1", "native atom vector version mismatch");
+
+  const conformanceResults = [];
+  for (const vector of conformanceVectors.vectors) {
+    const eventCommitment = sdk.hashEvent(vector.event);
+    assert.strictEqual(eventCommitment, vector.expected.event_commitment, `${vector.id} event commitment mismatch`);
+
+    const receipt = sdk.emitReceipt(vector.event, vector.receipt_options || {});
+    assert.deepStrictEqual(receipt, vector.expected.receipt, `${vector.id} receipt mismatch`);
+
+    const bundle = sdk.buildProofBundle({
+      ceb: vector.event,
+      receipt,
+      anchors: Array.isArray(vector.anchors) ? vector.anchors : undefined
+    });
+    assert.strictEqual(bundle.version, vector.expected.proof_bundle_version, `${vector.id} proof bundle version mismatch`);
+    const verification = sdk.verifyProofBundle(bundle);
+    assert.strictEqual(verification.valid, true, `${vector.id} proof bundle should verify`);
+    conformanceResults.push({
+      id: vector.id,
+      verification_method: verification.verification_method,
+      verification_state: verification.verification_state
+    });
+  }
+
+  const adversarialResults = [];
+  for (const vector of adversarialVectors.vectors) {
+    if (vector.kind === "canonicalize_event_error") {
+      assert.throws(
+        () => sdk.canonicalizeEvent(vector.event),
+        (error) => error && error.message === vector.expected_reason,
+        `${vector.id} should throw expected reason`
+      );
+      adversarialResults.push({
+        id: vector.id,
+        kind: vector.kind,
+        reason: vector.expected_reason
+      });
+      continue;
+    }
+    if (vector.kind === "verify_bundle_reason") {
+      const result = sdk.verifyProofBundle(vector.bundle);
+      assert.strictEqual(result.valid, false, `${vector.id} should fail`);
+      assert.strictEqual(result.reason, vector.expected_reason, `${vector.id} failure reason mismatch`);
+      adversarialResults.push({
+        id: vector.id,
+        kind: vector.kind,
+        reason: result.reason
+      });
+      continue;
+    }
+    throw new Error(`${vector.id} has unsupported vector kind`);
+  }
+
+  const nativeAtomResults = [];
+  const nativeAtomPayload = Buffer.from(nativeAtomVectors.payload_ascii, "utf8");
+  for (const vector of nativeAtomVectors.vectors) {
+    const parsed = sdk.parseXoonyaNativeAtom(vector.atom_hex);
+    assert.strictEqual(parsed.atom_version, vector.atom_version, `${vector.id} atom version mismatch`);
+    assert.strictEqual(parsed.byte_length, vector.byte_length, `${vector.id} byte length mismatch`);
+    assert.strictEqual(parsed.agent_id, vector.agent_id, `${vector.id} agent id mismatch`);
+    assert.strictEqual(parsed.payload_hash_sha256, vector.payload_hash_sha256, `${vector.id} payload hash mismatch`);
+    const hasPayload = vector.payload_hash_sha256 !== "00".repeat(32);
+    const verification = sdk.verifyXoonyaNativeAtom(vector.atom_hex, {
+      identity_material_hex: nativeAtomVectors.identity_material_hex,
+      ...(hasPayload ? { payload_bytes: nativeAtomPayload } : {})
+    });
+    assert.strictEqual(verification.valid, true, `${vector.id} should verify`);
+    assert.strictEqual(verification.error_code, null, `${vector.id} should not have error code`);
+    nativeAtomResults.push({
+      id: vector.id,
+      atom_version: vector.atom_version,
+      byte_length: vector.byte_length
+    });
+  }
+
+  const nativeAtomAdversarialResults = [];
+  for (const vector of nativeAtomVectors.adversarial) {
+    const verification = sdk.verifyXoonyaNativeAtom(vector.atom_hex, {
+      identity_material_hex: vector.identity_material_hex || nativeAtomVectors.identity_material_hex,
+      ...(vector.payload_ascii ? { payload_bytes: Buffer.from(vector.payload_ascii, "utf8") } : {})
+    });
+    assert.strictEqual(verification.valid, false, `${vector.id} should fail`);
+    assert.strictEqual(verification.reason, vector.expected_reason, `${vector.id} failure reason mismatch`);
+    assert.strictEqual(verification.error_code, vector.expected_error_code, `${vector.id} error code mismatch`);
+    nativeAtomAdversarialResults.push({
+      id: vector.id,
+      reason: verification.reason,
+      error_code: verification.error_code
+    });
+  }
+
+  return {
+    ok: true,
+    product: "xoonya",
+    suite: "proof-conformance-and-adversarial-vectors",
+    conformance_version: conformanceVectors.version,
+    adversarial_version: adversarialVectors.version,
+    conformance_count: conformanceResults.length,
+    adversarial_count: adversarialResults.length,
+    native_atom_vector_count: nativeAtomResults.length,
+    native_atom_adversarial_count: nativeAtomAdversarialResults.length,
+    verification_methods: unique(conformanceResults.map((result) => result.verification_method)),
+    adversarial_reasons: unique(adversarialResults.map((result) => result.reason)),
+    native_atom_error_codes: unique(nativeAtomAdversarialResults.map((result) => result.error_code)),
+    conformance_results: conformanceResults,
+    adversarial_results: adversarialResults,
+    native_atom_results: nativeAtomResults,
+    native_atom_adversarial_results: nativeAtomAdversarialResults
+  };
+}
+
+function main() {
+  const json = process.argv.includes("--json");
+  const summary = runVectorVerification();
+  if (json) {
+    process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(
+    [
+      "xoonya verify:vectors passed",
+      `conformance vectors: ${summary.conformance_count}`,
+      `adversarial vectors: ${summary.adversarial_count}`,
+      `native atom vectors: ${summary.native_atom_vector_count}`,
+      `native atom adversarial vectors: ${summary.native_atom_adversarial_count}`,
+      `verification methods: ${summary.verification_methods.join(", ")}`,
+      `adversarial reasons: ${summary.adversarial_reasons.join(", ")}`,
+      `native atom error codes: ${summary.native_atom_error_codes.join(", ")}`
+    ].join("\n") + "\n"
+  );
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  runVectorVerification
+};