npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

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

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 key
    • xoonya-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 compatibility legacy-opreturn receipt
  • 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 newer

Verify 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_ref

verifyJws(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 invalid

xoonya 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_signature verdict 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.