xoonya 3.0.1 → 3.1.0

package/scripts/verify_trust_portability.js

@@ -1,56 +1,56 @@
-"use strict";
-
-const assert = require("assert");
-const { createServer } = require("../server.js");
-
-async function getJson(baseUrl, path) {
-  const response = await fetch(`${baseUrl}${path}`);
-  return {
-    status: response.status,
-    json: await response.json()
-  };
-}
-
-async function main() {
-  const server = createServer();
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const address = server.address();
-  const baseUrl = `http://127.0.0.1:${address.port}`;
-
-  try {
-    const pack = await getJson(baseUrl, "/v1/proof-center/trust-portability");
-    assert.strictEqual(pack.status, 200, "trust portability route failed");
-    assert.strictEqual(pack.json.category, "xoonya-trust-portability-pack", "trust portability category mismatch");
-    assert.strictEqual(pack.json.portability_profiles.length >= 4, true, "trust portability profile count mismatch");
-    assert.strictEqual(
-      pack.json.portability_profiles.some((entry) => entry.profile_id === "agent_identity_portability" && entry.callable_surfaces.includes("/v1/identity-interop")),
-      true,
-      "agent identity portability profile missing identity-interop surface"
-    );
-    assert.strictEqual(
-      pack.json.portability_profiles.some((entry) => entry.profile_id === "delivery_history_portability" && entry.supporting_surfaces.includes("/v1/result-package-trust/summary")),
-      true,
-      "delivery history portability profile missing result-package-trust support"
-    );
-
-    const summary = await getJson(baseUrl, "/v1/proof-center/trust-portability/summary");
-    assert.strictEqual(summary.status, 200, "trust portability summary route failed");
-    assert.strictEqual(summary.json.profile_count >= 4, true, "trust portability summary profile count mismatch");
-    assert.strictEqual(summary.json.bounded_live_profile_count >= 4, true, "trust portability bounded-live count mismatch");
-    assert.strictEqual(summary.json.callable_profile_count >= 4, true, "trust portability callable profile count mismatch");
-
-    const detail = await getJson(baseUrl, "/v1/proof-center/trust-portability/agent_identity_portability");
-    assert.strictEqual(detail.status, 200, "trust portability detail route failed");
-    assert.strictEqual(detail.json.profile.profile_id, "agent_identity_portability", "trust portability detail profile mismatch");
-    assert.strictEqual(detail.json.profile.claim_status, "bounded_live", "trust portability detail claim status mismatch");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-  }
-
-  console.log("xoonya verify:trust-portability passed");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server.js");
+
+async function getJson(baseUrl, path) {
+  const response = await fetch(`${baseUrl}${path}`);
+  return {
+    status: response.status,
+    json: await response.json()
+  };
+}
+
+async function main() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const pack = await getJson(baseUrl, "/v1/proof-center/trust-portability");
+    assert.strictEqual(pack.status, 200, "trust portability route failed");
+    assert.strictEqual(pack.json.category, "xoonya-trust-portability-pack", "trust portability category mismatch");
+    assert.strictEqual(pack.json.portability_profiles.length >= 4, true, "trust portability profile count mismatch");
+    assert.strictEqual(
+      pack.json.portability_profiles.some((entry) => entry.profile_id === "agent_identity_portability" && entry.callable_surfaces.includes("/v1/identity-interop")),
+      true,
+      "agent identity portability profile missing identity-interop surface"
+    );
+    assert.strictEqual(
+      pack.json.portability_profiles.some((entry) => entry.profile_id === "delivery_history_portability" && entry.supporting_surfaces.includes("/v1/result-package-trust/summary")),
+      true,
+      "delivery history portability profile missing result-package-trust support"
+    );
+
+    const summary = await getJson(baseUrl, "/v1/proof-center/trust-portability/summary");
+    assert.strictEqual(summary.status, 200, "trust portability summary route failed");
+    assert.strictEqual(summary.json.profile_count >= 4, true, "trust portability summary profile count mismatch");
+    assert.strictEqual(summary.json.bounded_live_profile_count >= 4, true, "trust portability bounded-live count mismatch");
+    assert.strictEqual(summary.json.callable_profile_count >= 4, true, "trust portability callable profile count mismatch");
+
+    const detail = await getJson(baseUrl, "/v1/proof-center/trust-portability/agent_identity_portability");
+    assert.strictEqual(detail.status, 200, "trust portability detail route failed");
+    assert.strictEqual(detail.json.profile.profile_id, "agent_identity_portability", "trust portability detail profile mismatch");
+    assert.strictEqual(detail.json.profile.claim_status, "bounded_live", "trust portability detail claim status mismatch");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+
+  console.log("xoonya verify:trust-portability passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/verify_vectors.js

@@ -1,192 +1,192 @@
-"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 || {});
-    if (vector.expected.receipt.algorithm === "xoonya-native-hybrid-v1") {
-      assert.strictEqual(receipt.version, vector.expected.receipt.version, `${vector.id} hybrid receipt version mismatch`);
-      assert.strictEqual(receipt.receipt_id, vector.expected.receipt.receipt_id, `${vector.id} hybrid receipt id mismatch`);
-      assert.strictEqual(receipt.agent_identity, vector.expected.receipt.agent_identity, `${vector.id} hybrid agent mismatch`);
-      assert.strictEqual(receipt.domain_id, vector.expected.receipt.domain_id, `${vector.id} hybrid domain mismatch`);
-      assert.strictEqual(receipt.sequence, vector.expected.receipt.sequence, `${vector.id} hybrid sequence mismatch`);
-      assert.strictEqual(receipt.event_commitment, vector.expected.receipt.event_commitment, `${vector.id} hybrid event commitment mismatch`);
-      assert.strictEqual(receipt.algorithm, vector.expected.receipt.algorithm, `${vector.id} hybrid algorithm mismatch`);
-      assert.strictEqual(receipt.native_proof.method, vector.expected.receipt.native_proof.method, `${vector.id} hybrid method mismatch`);
-      assert.strictEqual(receipt.native_proof.hybrid_suite, vector.expected.receipt.native_proof.hybrid_suite, `${vector.id} hybrid suite mismatch`);
-      assert.strictEqual(receipt.native_proof.identity_ref, vector.expected.receipt.native_proof.identity_ref, `${vector.id} hybrid identity ref mismatch`);
-      assert.strictEqual(receipt.native_proof.hybrid_public_key_ref, vector.expected.receipt.native_proof.hybrid_public_key_ref, `${vector.id} hybrid public key ref mismatch`);
-      assert.strictEqual(receipt.native_proof.classical_public_key_ref, vector.expected.receipt.native_proof.classical_public_key_ref, `${vector.id} hybrid classical key ref mismatch`);
-      assert.strictEqual(receipt.native_proof.pq_public_key_ref, vector.expected.receipt.native_proof.pq_public_key_ref, `${vector.id} hybrid pq key ref mismatch`);
-      assert.deepStrictEqual(receipt.native_proof.classical_public_key_material, vector.expected.receipt.native_proof.classical_public_key_material, `${vector.id} hybrid classical key material mismatch`);
-      assert.deepStrictEqual(receipt.native_proof.pq_public_key_material, vector.expected.receipt.native_proof.pq_public_key_material, `${vector.id} hybrid pq key material mismatch`);
-      assert.strictEqual(receipt.native_proof.proof_material.signing_material_sha256, vector.expected.receipt.native_proof.proof_material.signing_material_sha256, `${vector.id} hybrid signing material hash mismatch`);
-      assert.strictEqual(typeof receipt.native_proof.proof_material.classical_signature, "string", `${vector.id} hybrid classical signature missing`);
-      assert.strictEqual(receipt.native_proof.proof_material.classical_signature.length > 10, true, `${vector.id} hybrid classical signature too small`);
-      assert.strictEqual(typeof receipt.native_proof.proof_material.pq_signature, "string", `${vector.id} hybrid pq signature missing`);
-      assert.strictEqual(receipt.native_proof.proof_material.pq_signature.length > 100, true, `${vector.id} hybrid pq signature too small`);
-      assert.strictEqual(
-        receipt.signature,
-        `xoonya-native-hybrid-v1:${receipt.native_proof.hybrid_suite}:${receipt.native_proof.proof_material.classical_signature}.${receipt.native_proof.proof_material.pq_signature}`,
-        `${vector.id} hybrid compact signature mismatch`
-      );
-    } else {
-      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
-};
+"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 || {});
+    if (vector.expected.receipt.algorithm === "xoonya-native-hybrid-v1") {
+      assert.strictEqual(receipt.version, vector.expected.receipt.version, `${vector.id} hybrid receipt version mismatch`);
+      assert.strictEqual(receipt.receipt_id, vector.expected.receipt.receipt_id, `${vector.id} hybrid receipt id mismatch`);
+      assert.strictEqual(receipt.agent_identity, vector.expected.receipt.agent_identity, `${vector.id} hybrid agent mismatch`);
+      assert.strictEqual(receipt.domain_id, vector.expected.receipt.domain_id, `${vector.id} hybrid domain mismatch`);
+      assert.strictEqual(receipt.sequence, vector.expected.receipt.sequence, `${vector.id} hybrid sequence mismatch`);
+      assert.strictEqual(receipt.event_commitment, vector.expected.receipt.event_commitment, `${vector.id} hybrid event commitment mismatch`);
+      assert.strictEqual(receipt.algorithm, vector.expected.receipt.algorithm, `${vector.id} hybrid algorithm mismatch`);
+      assert.strictEqual(receipt.native_proof.method, vector.expected.receipt.native_proof.method, `${vector.id} hybrid method mismatch`);
+      assert.strictEqual(receipt.native_proof.hybrid_suite, vector.expected.receipt.native_proof.hybrid_suite, `${vector.id} hybrid suite mismatch`);
+      assert.strictEqual(receipt.native_proof.identity_ref, vector.expected.receipt.native_proof.identity_ref, `${vector.id} hybrid identity ref mismatch`);
+      assert.strictEqual(receipt.native_proof.hybrid_public_key_ref, vector.expected.receipt.native_proof.hybrid_public_key_ref, `${vector.id} hybrid public key ref mismatch`);
+      assert.strictEqual(receipt.native_proof.classical_public_key_ref, vector.expected.receipt.native_proof.classical_public_key_ref, `${vector.id} hybrid classical key ref mismatch`);
+      assert.strictEqual(receipt.native_proof.pq_public_key_ref, vector.expected.receipt.native_proof.pq_public_key_ref, `${vector.id} hybrid pq key ref mismatch`);
+      assert.deepStrictEqual(receipt.native_proof.classical_public_key_material, vector.expected.receipt.native_proof.classical_public_key_material, `${vector.id} hybrid classical key material mismatch`);
+      assert.deepStrictEqual(receipt.native_proof.pq_public_key_material, vector.expected.receipt.native_proof.pq_public_key_material, `${vector.id} hybrid pq key material mismatch`);
+      assert.strictEqual(receipt.native_proof.proof_material.signing_material_sha256, vector.expected.receipt.native_proof.proof_material.signing_material_sha256, `${vector.id} hybrid signing material hash mismatch`);
+      assert.strictEqual(typeof receipt.native_proof.proof_material.classical_signature, "string", `${vector.id} hybrid classical signature missing`);
+      assert.strictEqual(receipt.native_proof.proof_material.classical_signature.length > 10, true, `${vector.id} hybrid classical signature too small`);
+      assert.strictEqual(typeof receipt.native_proof.proof_material.pq_signature, "string", `${vector.id} hybrid pq signature missing`);
+      assert.strictEqual(receipt.native_proof.proof_material.pq_signature.length > 100, true, `${vector.id} hybrid pq signature too small`);
+      assert.strictEqual(
+        receipt.signature,
+        `xoonya-native-hybrid-v1:${receipt.native_proof.hybrid_suite}:${receipt.native_proof.proof_material.classical_signature}.${receipt.native_proof.proof_material.pq_signature}`,
+        `${vector.id} hybrid compact signature mismatch`
+      );
+    } else {
+      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
+};

package/scripts/verify_verification_services.js

@@ -1,56 +1,56 @@
-"use strict";
-
-const assert = require("assert");
-const { createServer } = require("../server.js");
-
-async function getJson(baseUrl, path) {
-  const response = await fetch(`${baseUrl}${path}`);
-  return {
-    status: response.status,
-    json: await response.json()
-  };
-}
-
-async function main() {
-  const server = createServer();
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const address = server.address();
-  const baseUrl = `http://127.0.0.1:${address.port}`;
-
-  try {
-    const pack = await getJson(baseUrl, "/v1/proof-center/verification-services");
-    assert.strictEqual(pack.status, 200, "verification services route failed");
-    assert.strictEqual(pack.json.category, "xoonya-verification-services-pack", "verification services category mismatch");
-    assert.strictEqual(pack.json.service_count >= 6, true, "verification services count mismatch");
-    assert.strictEqual(
-      pack.json.verification_services.some((entry) => entry.service_id === "bundle_verify" && entry.callable_surfaces.includes("/v1/proof-bundles/verify")),
-      true,
-      "bundle verify service missing proof-bundles verify surface"
-    );
-    assert.strictEqual(
-      pack.json.verification_services.some((entry) => entry.service_id === "dispute_replay" && entry.callable_surfaces.includes("/v1/proof-center/governance/disputes/case-bundle")),
-      true,
-      "dispute replay service missing case bundle surface"
-    );
-    assert.strictEqual(
-      pack.json.verification_services.some((entry) => entry.service_id === "identity_link_verify" && entry.supporting_surfaces.includes("/v1/identity-interop/summary")),
-      true,
-      "identity-link verification service missing identity interop support"
-    );
-
-    const summary = await getJson(baseUrl, "/v1/proof-center/verification-services/summary");
-    assert.strictEqual(summary.status, 200, "verification services summary route failed");
-    assert.strictEqual(summary.json.service_count >= 6, true, "verification services summary count mismatch");
-    assert.strictEqual(summary.json.live_service_count >= 1, true, "verification services summary live count missing");
-    assert.strictEqual(summary.json.bounded_live_service_count >= 5, true, "verification services summary bounded-live count missing");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-  }
-
-  console.log("xoonya verify:verification-services passed");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server.js");
+
+async function getJson(baseUrl, path) {
+  const response = await fetch(`${baseUrl}${path}`);
+  return {
+    status: response.status,
+    json: await response.json()
+  };
+}
+
+async function main() {
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const pack = await getJson(baseUrl, "/v1/proof-center/verification-services");
+    assert.strictEqual(pack.status, 200, "verification services route failed");
+    assert.strictEqual(pack.json.category, "xoonya-verification-services-pack", "verification services category mismatch");
+    assert.strictEqual(pack.json.service_count >= 6, true, "verification services count mismatch");
+    assert.strictEqual(
+      pack.json.verification_services.some((entry) => entry.service_id === "bundle_verify" && entry.callable_surfaces.includes("/v1/proof-bundles/verify")),
+      true,
+      "bundle verify service missing proof-bundles verify surface"
+    );
+    assert.strictEqual(
+      pack.json.verification_services.some((entry) => entry.service_id === "dispute_replay" && entry.callable_surfaces.includes("/v1/proof-center/governance/disputes/case-bundle")),
+      true,
+      "dispute replay service missing case bundle surface"
+    );
+    assert.strictEqual(
+      pack.json.verification_services.some((entry) => entry.service_id === "identity_link_verify" && entry.supporting_surfaces.includes("/v1/identity-interop/summary")),
+      true,
+      "identity-link verification service missing identity interop support"
+    );
+
+    const summary = await getJson(baseUrl, "/v1/proof-center/verification-services/summary");
+    assert.strictEqual(summary.status, 200, "verification services summary route failed");
+    assert.strictEqual(summary.json.service_count >= 6, true, "verification services summary count mismatch");
+    assert.strictEqual(summary.json.live_service_count >= 1, true, "verification services summary live count missing");
+    assert.strictEqual(summary.json.bounded_live_service_count >= 5, true, "verification services summary bounded-live count missing");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+
+  console.log("xoonya verify:verification-services passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});