xoonya
v3.9.23
Published
Verifier for xoonya proofs and naxytra delivery evidence: deterministic verification of xoonya native proof bundles (replayable digest, Ed25519/secp256k1/P-256 signed, Ed25519 + ML-DSA-65 post-quantum hybrid, anchored), XNYA machine-evidence atoms, and de
Maintainers
Readme
xoonya
Verifier for xoonya proofs and naxytra delivery evidence.
xoonya is the proof side of the naxytra machine stack: a hosted proof engine that emits deterministic, portable machine evidence for paid agent work, plus this public verifier that lets anyone check that evidence offline with classical and post-quantum signatures.
The proof engine and server are a hosted service; this package is the verifier. The engine is not distributed.
- Hosted service: https://xoonya.onrender.com
- Product page: https://www.naxytra.com/xoonya
- Agent entry points: https://www.naxytra.com/agents
What this package verifies
- Native proof bundles (
proof-bundle/v1) carrying a canonical event bundle and a receipt:xoonya-native-sha256-v1— replayable digest (integrity, not authorship)xoonya-native-signed-v1— Ed25519 / secp256k1 / P-256 signature bound to the carried public keyxoonya-native-hybrid-v1— classical + post-quantum dual signature (Ed25519 + ML-DSA-65, FIPS 204)xoonya-native-anchored-v1— digest binding to declared chain / batch / finality anchor refs- structural acceptance of external envelopes (
detached-assertion,jwt-assertion,did-vc,sd-jwt-vc,signed-envelope,partner-proof-envelope) and the compatibilitylegacy-opreturnreceipt
- Detached signatures and compact JWS — EdDSA, ES256/384/512, ES256K, RS*/PS*, and ML-DSA-44/65/87 — with an explicit trusted-key fingerprint model
- XNYA machine-evidence atoms, XNYP payload profiles and line-rate frames
Everything runs on Node built-ins (node:crypto); there are no dependencies.
Install
npm install xoonya # Node 24 or newerVerify a native proof bundle
A proof bundle is what the hosted service (or a counterparty running it) hands back after a paid execution. Verification is deterministic and offline:
const xoonya = require("xoonya");
const bundle = JSON.parse(require("fs").readFileSync("proof-bundle.json", "utf8"));
const result = xoonya.verifyNativeBundle(bundle);
// {
// valid: true,
// verification_method: "xoonya-native-hybrid-v1",
// verification_state: "verified_native_hybrid_signature",
// verification_class: "cryptographic",
// cryptographically_verified: true,
// public_key_ref: "ed25519+ml-dsa-65-hybrid-spki-sha256:...",
// classical_public_key_ref: "ed25519-spki-sha256:...",
// pq_public_key_ref: "ml-dsa-65-spki-sha256:...",
// ...
// }A valid result says the bundle is well-formed, bound to the canonical event, and (for signed / hybrid methods) really signed by the carried public key. It does not say who controls that key. Bind the key to an identity you already trust, and refuse digest-only and structural results, with options:
xoonya.verifyNativeBundle(bundle, {
strict: true, // only cryptographically verified methods pass
trusted_public_key_refs: {
"did:xoonya:agent-1": {
classical: "ed25519-spki-sha256:...",
pq: "ml-dsa-65-spki-sha256:..."
}
}
});
// a bundle signed by any other key => { valid: false, reason: "native_hybrid_public_key_not_trusted" }verifyNativeProof({ event, receipt, anchors }) does the same for a receipt that is not yet wrapped in
a bundle. XOONYA_STRICT_VERIFY=1 turns strict mode on for every call.
Verify a detached ML-DSA signature
const result = xoonya.verifyDetachedSignature({
material: deliverableBytes, // Buffer or string that was signed
signature: signatureBase64, // base64 (default), "hex" or "base64url" via signature_encoding
public_key: signerSpkiPem, // SPKI PEM, base64 DER or public JWK; private material is refused
algorithm: "ML-DSA-65", // or "EdDSA", "ES256", "ES256K", "RS256", "PS256", ...
expected_key_ref: "ml-dsa-65-spki-sha256:..." // the fingerprint you already trust (optional)
});
// result.signature_valid => the signature verifies under the supplied key
// result.signing_key_ref => "ml-dsa-65-spki-sha256:..." fingerprint of that key
// result.trust_anchored => signature_valid AND the key matches expected_key_refverifyJws(compactJws, { trusted_public_key, expected_key_ref }) verifies a compact JWS the same
way; alg: "none", crit extensions and unencoded payloads are rejected.
CLI
xoonya start-here # the shortest verification path
xoonya first-run --verify-native --pretty # run the shipped vectors, print a JSON verdict
xoonya conformance --json # conformance + adversarial vectors, full summary
xoonya verify ./proof-bundle.json --pretty # verify one bundle; add --strict; exit 1 if invalidxoonya release and xoonya review are operator tooling of the hosted service and are not part
of this package.
Conformance
vectors/ ships the conformance and adversarial vectors the hosted engine is tested against
(eleven verification methods, fifteen rejection cases, XNYA atom and payload-profile vectors).
xoonya.verifyVectors() runs them in-process and returns the summary. The same vectors are run by
both the hosted engine and this verifier before every release, and every result must be identical.
Honest claims
- Post-quantum means machine-evidence verification. A
verified_native_hybrid_signatureverdict says the proof was signed by the carried Ed25519 and ML-DSA-65 keys. It is not an identity, custody, settlement, transport-security or chain-finality claim. - Proven suites: Ed25519 and Ed25519 + ML-DSA-65 are exercised by the shipped vectors and by a live paid verification on Base mainnet through the naxytra runtime. secp256k1, P-256 and SLH-DSA are implemented suites but are not covered by shipped vectors.
- Digest and anchored methods prove integrity, not authorship. Anyone can produce a valid digest; anchor refs are bound, not checked against the external chain or provider.
- Trust in a signing key is yours to declare. A key carried inside a proof, or supplied in the same request, is never treated as trusted by itself.
License
The verifier SDK is Apache-2.0 (see LICENSE and NOTICE). The hosted xoonya proof engine and
server are proprietary.
