xoonya 2.6.0 → 2.8.0

package/reference/rust/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "xoonya-native-rust"
+version = "0.0.0-candidate"
+edition = "2021"
+license = "Apache-2.0"
+publish = false
+
+[lib]
+name = "xnya_reference"
+path = "src/lib.rs"
+

package/reference/rust/README.md

@@ -0,0 +1,28 @@
+# XNYA Rust Candidate Scaffold
+
+This directory is a source-only candidate scaffold for a future independent
+Rust XNYA reference implementation.
+
+It is not a full XNYA-compatible reference implementation yet. The JavaScript
+package remains the canonical implementation, and the Python candidate remains
+the only verified non-JavaScript scaffold today.
+
+Current scope:
+
+- fixed-size `XNYA` atom constants
+- v1/v2 atom byte-length checks
+- record-type checks
+- deterministic atom parser error codes
+
+Not claimed yet:
+
+- SHA-256 or RIPEMD-160 verification parity
+- XNYP payload-profile parity
+- canonical-event or proof-bundle parity
+- signature-suite validation
+- adversarial vector parity
+- `XNYA-compatible` conformance mark eligibility
+
+Future promotion requires a real Rust toolchain check that compiles the crate
+and passes every required positive and adversarial vector set independently.
+

package/reference/rust/src/lib.rs

@@ -0,0 +1,87 @@
+//! Source-only Rust candidate scaffold for XNYA atom parsing.
+//!
+//! This crate is intentionally not promoted as an independent XNYA-compatible
+//! reference. It gives future Rust work a stable parser/error-code starting
+//! point while vector parity, hashing, payload, proof-bundle, and signature
+//! validation remain gated.
+
+pub const XNYA_MAGIC: [u8; 4] = *b"XNYA";
+pub const VERSION_V1: u8 = 0x01;
+pub const VERSION_V2: u8 = 0x02;
+pub const ATOM_V1_LEN: usize = 58;
+pub const ATOM_V2_LEN: usize = 70;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum XnyaError {
+    AtomBadMagic,
+    AtomUnsupportedLength,
+    AtomUnsupportedRecordType,
+    AtomVersionLengthMismatch,
+}
+
+impl XnyaError {
+    pub fn code(&self) -> &'static str {
+        match self {
+            XnyaError::AtomBadMagic => "atom_bad_magic",
+            XnyaError::AtomUnsupportedLength => "atom_unsupported_length",
+            XnyaError::AtomUnsupportedRecordType => "atom_unsupported_record_type",
+            XnyaError::AtomVersionLengthMismatch => "atom_version_length_mismatch",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ParsedAtom<'a> {
+    pub version: u8,
+    pub record_type: u8,
+    pub identity_commitment: &'a [u8],
+    pub payload_hash_sha256: &'a [u8],
+}
+
+pub fn parse_atom(bytes: &[u8]) -> Result<ParsedAtom<'_>, XnyaError> {
+    if bytes.len() != ATOM_V1_LEN && bytes.len() != ATOM_V2_LEN {
+        return Err(XnyaError::AtomUnsupportedLength);
+    }
+    if bytes[0..4] != XNYA_MAGIC {
+        return Err(XnyaError::AtomBadMagic);
+    }
+    let version = bytes[4];
+    let record_type = bytes[5];
+    if !matches!(record_type, 0x01 | 0x02 | 0x03) {
+        return Err(XnyaError::AtomUnsupportedRecordType);
+    }
+    let identity_len = match version {
+        VERSION_V1 if bytes.len() == ATOM_V1_LEN => 20,
+        VERSION_V2 if bytes.len() == ATOM_V2_LEN => 32,
+        VERSION_V1 | VERSION_V2 => return Err(XnyaError::AtomVersionLengthMismatch),
+        _ => return Err(XnyaError::AtomVersionLengthMismatch),
+    };
+    let identity_start = 6;
+    let identity_end = identity_start + identity_len;
+    let payload_end = identity_end + 32;
+    Ok(ParsedAtom {
+        version,
+        record_type,
+        identity_commitment: &bytes[identity_start..identity_end],
+        payload_hash_sha256: &bytes[identity_end..payload_end],
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rejects_bad_length() {
+        assert_eq!(parse_atom(&[]).unwrap_err().code(), "atom_unsupported_length");
+    }
+
+    #[test]
+    fn rejects_bad_magic() {
+        let mut atom = [0u8; ATOM_V1_LEN];
+        atom[4] = VERSION_V1;
+        atom[5] = 0x01;
+        assert_eq!(parse_atom(&atom).unwrap_err().code(), "atom_bad_magic");
+    }
+}
+

package/scripts/registry_cli.js

@@ -0,0 +1,157 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const {
+  exportIntegrationRegistrySnapshot,
+  summarizeIntegrationPromotionWorkflow,
+  summarizeIntegrationPromotionWorkflowList,
+  summarizeIntegrationPromotionReadiness,
+  validateIntegrationRegistration
+} = require("../integrations/registry");
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function writeJson(payload) {
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function resolveExampleRegistration(name) {
+  const filename = name === "verifier"
+    ? "example-third-party-verifier-registration.record.json"
+    : "example-third-party-verifier-registration.record.json";
+  return path.resolve(__dirname, "..", "integrations", "examples", filename);
+}
+
+function resolveExampleDescriptor(name) {
+  const descriptorByExample = {
+    verifier: {
+      integration_id: "partner.verifier.lattice_notary",
+      integration_class: "verification_helper_adapter",
+      proof_scope: "profile_verification"
+    }
+  };
+  return descriptorByExample[name] || descriptorByExample.verifier;
+}
+
+function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  const options = {};
+  for (let index = 0; index < rest.length; index += 1) {
+    const token = rest[index];
+    if (!token.startsWith("--")) continue;
+    const key = token.slice(2);
+    const next = rest[index + 1];
+    if (!next || next.startsWith("--")) {
+      options[key] = true;
+      continue;
+    }
+    options[key] = next;
+    index += 1;
+  }
+  return {
+    command: command || "",
+    options
+  };
+}
+
+function runValidateRegistration(options) {
+  const exampleName = options.example === "verifier" ? "verifier" : "verifier";
+  const filePath = options.file
+    ? path.resolve(process.cwd(), options.file)
+    : resolveExampleRegistration(exampleName);
+  const registrationRecord = readJson(filePath);
+  const descriptor = resolveExampleDescriptor(exampleName);
+  const validation = validateIntegrationRegistration(descriptor, registrationRecord);
+  writeJson({
+    ok: validation.ok,
+    file: filePath,
+    descriptor,
+    errors: validation.errors
+  });
+  process.exitCode = validation.ok ? 0 : 1;
+}
+
+function runExportSnapshot(options) {
+  const filters = {
+    source: options.source || undefined,
+    certification_state: options.certification_state || undefined,
+    integration_maturity: options.integration_maturity || undefined,
+    registration_state: options.registration_state || undefined,
+    proof_scope: options.proof_scope || undefined,
+    bundled: options.bundled || undefined
+  };
+  const snapshot = exportIntegrationRegistrySnapshot(filters);
+  writeJson({
+    generated_by: "registry_cli",
+    filters: snapshot.filters,
+    snapshot
+  });
+}
+
+function runPromotionReadiness(options) {
+  const integrationId = options.integration || "partner.verifier.lattice_notary";
+  writeJson({
+    integration_id: integrationId,
+    review: summarizeIntegrationPromotionReadiness(integrationId)
+  });
+}
+
+function runPromotionWorkflow(options) {
+  const integrationId = options.integration || "partner.verifier.lattice_notary";
+  writeJson({
+    integration_id: integrationId,
+    review: summarizeIntegrationPromotionWorkflow(integrationId)
+  });
+}
+
+function runPromotionWorkflowSummary(options) {
+  writeJson({
+    review: summarizeIntegrationPromotionWorkflowList({
+      source: options.source || undefined,
+      registration_state: options.registration_state || undefined,
+      proof_scope: options.proof_scope || undefined,
+      bundled: options.bundled || undefined
+    })
+  });
+}
+
+function main() {
+  const { command, options } = parseArgs(process.argv.slice(2));
+  if (command === "validate-registration") {
+    runValidateRegistration(options);
+    return;
+  }
+  if (command === "export-snapshot") {
+    runExportSnapshot(options);
+    return;
+  }
+  if (command === "promotion-readiness") {
+    runPromotionReadiness(options);
+    return;
+  }
+  if (command === "promotion-workflow") {
+    runPromotionWorkflow(options);
+    return;
+  }
+  if (command === "promotion-workflow-summary") {
+    runPromotionWorkflowSummary(options);
+    return;
+  }
+
+  writeJson({
+    ok: false,
+    usage: [
+      "node scripts/registry_cli.js validate-registration [--file <path>] [--example verifier]",
+      "node scripts/registry_cli.js export-snapshot [--source <value>] [--registration_state <value>] [--proof_scope <value>]",
+      "node scripts/registry_cli.js promotion-readiness [--integration <integration_id>]",
+      "node scripts/registry_cli.js promotion-workflow [--integration <integration_id>]",
+      "node scripts/registry_cli.js promotion-workflow-summary [--source <value>] [--registration_state <value>] [--proof_scope <value>] [--bundled true|false]"
+    ]
+  });
+  process.exitCode = 1;
+}
+
+main();