@hashborn/verify 0.0.0-stage → 0.1.2

package/dist/remote.js

@@ -0,0 +1,176 @@
+/**
+ * Reading a published record from the Hashborn API and verifying it here. The API is only a
+ * transport: the server's own `verified` flag is never read. The record text, signature, root and
+ * pubSeed it returns are checked locally with SHA-256, exactly as `verifyRecord` checks them.
+ *
+ * Source: `GET /api/v1/records/<id>`. When that answer carries no signature (the v1 record view
+ * leaves the 2,404 signature bytes out), the published bytes are read from
+ * `GET /api/index?q=record&id=<id>`, the same index route the site's pages read.
+ */
+import { pqAddress } from './address.js';
+import { DEFAULT_BASE_URL, PQ } from './constants.js';
+import { HashbornError } from './errors.js';
+import { decodeSignature } from './signature.js';
+import { verifyRecord } from './verify.js';
+export const RECORD_ID_RE = /^0x[0-9a-fA-F]{72}$/;
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const str = (v, label) => {
+    if (typeof v !== 'string')
+        throw new HashbornError(`the API answer has no ${label}`);
+    return v;
+};
+async function getJson(fetcher, url) {
+    let res;
+    try {
+        res = await fetcher(url, { headers: { accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new HashbornError(`could not reach ${url}: ${err instanceof Error ? err.message : String(err)}`, 'network');
+    }
+    let body = null;
+    try {
+        body = await res.json();
+    }
+    catch {
+        if (res.ok)
+            throw new HashbornError(`${url} did not answer with JSON`, 'network');
+    }
+    return { status: res.status, body };
+}
+function parseFields(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (!isObj(value))
+            return null;
+        for (const v of Object.values(value))
+            if (v !== null && !['string', 'number', 'boolean'].includes(typeof v))
+                return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function fromV1(b) {
+    if (typeof b.signature !== 'string' || typeof b.record !== 'string')
+        return null;
+    const signer = isObj(b.signer) ? b.signer : {};
+    const anchored = isObj(b.anchored) ? b.anchored : {};
+    return {
+        domain: str(b.domain, 'domain'),
+        record: b.record,
+        signature: b.signature,
+        root: str(signer.root, 'signer.root'),
+        pubSeed: str(signer.pubSeed, 'signer.pubSeed'),
+        messageHash: str(b.messageHash, 'messageHash'),
+        leaf: Number(b.leaf),
+        wallet: str(signer.wallet, 'signer.wallet'),
+        txHash: str(anchored.txHash, 'anchored.txHash'),
+        blockNumber: Number(anchored.block),
+        anchoredAt: str(anchored.at, 'anchored.at'),
+        chainId: typeof anchored.chainId === 'number' ? anchored.chainId : null,
+    };
+}
+function fromIndex(r, chainId) {
+    const identity = isObj(r.identity) ? r.identity : {};
+    return {
+        domain: str(r.domain, 'domain'),
+        record: str(r.record, 'record'),
+        signature: str(r.signature, 'signature'),
+        root: str(r.root, 'root'),
+        pubSeed: str(identity.pubSeed, 'identity.pubSeed'),
+        messageHash: str(r.messageHash, 'messageHash'),
+        leaf: Number(r.leaf),
+        wallet: str(r.wallet, 'wallet'),
+        txHash: str(r.txHash, 'txHash'),
+        blockNumber: Number(r.blockNumber),
+        anchoredAt: new Date(Number(r.timestamp) * 1000).toISOString(),
+        chainId,
+    };
+}
+/**
+ * Reads one anchored record (id = anchoring transaction hash + log index, as on
+ * `/records/<id>`) and builds its attestation from the published bytes. Does not verify: pass the
+ * result to `verifyRecord(r.attestation, r.record)`, or call `verifyRemote`.
+ * Throws a HashbornError (`not-found`, `network`, `malformed`) when there is nothing to verify.
+ */
+export async function fetchRecord(id, options = {}) {
+    if (typeof id !== 'string' || !RECORD_ID_RE.test(id))
+        throw new HashbornError('a record id is 0x followed by 72 hex characters');
+    const recordId = id.toLowerCase();
+    const fetcher = options.fetch ?? globalThis.fetch;
+    if (!fetcher)
+        throw new HashbornError('no fetch implementation; pass options.fetch', 'network');
+    const base = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+    const v1 = await getJson(fetcher, `${base}/api/v1/records/${recordId}`);
+    if (v1.status === 404)
+        throw new HashbornError(`no record with id ${recordId}`, 'not-found');
+    if (v1.status !== 200 || !isObj(v1.body)) {
+        const msg = isObj(v1.body) && typeof v1.body.error === 'string' ? `: ${v1.body.error}` : '';
+        throw new HashbornError(`the API answered ${v1.status}${msg}`, 'network');
+    }
+    const chainId = isObj(v1.body.anchored) && typeof v1.body.anchored.chainId === 'number' ? v1.body.anchored.chainId : null;
+    let published = fromV1(v1.body);
+    let source = 'v1';
+    if (!published) {
+        const idx = await getJson(fetcher, `${base}/api/index?q=record&id=${recordId}`);
+        if (idx.status !== 200 || !isObj(idx.body))
+            throw new HashbornError(`the index answered ${idx.status}`, 'network');
+        if (idx.body.data === null)
+            throw new HashbornError(`no record with id ${recordId}`, 'not-found');
+        if (!isObj(idx.body.data))
+            throw new HashbornError('the index answer has no record');
+        published = fromIndex(idx.body.data, chainId);
+        source = 'index';
+    }
+    if (published.signature.length !== 2 + PQ.signatureBytes * 2) {
+        throw new HashbornError(`the published signature is not ${PQ.signatureBytes} bytes`);
+    }
+    const signature = decodeSignature(published.signature);
+    const attestation = {
+        version: 1,
+        scheme: 'wots-merkle',
+        domain: published.domain,
+        pqAddress: pqAddress(published),
+        root: published.root,
+        pubSeed: published.pubSeed,
+        height: PQ.height,
+        messageHash: published.messageHash,
+        signature,
+        txHash: published.txHash,
+        anchoredAt: published.anchoredAt,
+    };
+    return {
+        id: recordId,
+        attestation,
+        record: published.record,
+        fields: parseFields(published.record),
+        leaf: published.leaf,
+        wallet: published.wallet,
+        txHash: published.txHash,
+        blockNumber: published.blockNumber,
+        anchoredAt: published.anchoredAt,
+        chainId: published.chainId,
+        source,
+    };
+}
+/**
+ * `fetchRecord` then `verifyRecord` here, on the published bytes: the record text must hash to
+ * `messageHash`, the signature must climb to the identity's root, and the leaf the anchor burned
+ * must be the leaf that signed. The server's own verdict is never used.
+ */
+export async function verifyRemote(id, options = {}) {
+    const remote = await fetchRecord(id, options);
+    const result = verifyRecord(remote.attestation, remote.record);
+    if (result.valid && remote.leaf !== remote.attestation.signature.leaf) {
+        return {
+            ...result,
+            valid: false,
+            code: 'leaf',
+            reason: `The anchor burned leaf ${remote.leaf} but the signature names leaf ${remote.attestation.signature.leaf}.`,
+            id: remote.id,
+            remote,
+        };
+    }
+    return { ...result, id: remote.id, remote };
+}

package/dist/signature.d.ts

@@ -0,0 +1,6 @@
+/** The 2,404-byte wire form of a signature, as PQRegistry stores it: leaf u32 || sigma || auth. */
+import { type Hex, type MerkleSignature } from './constants.js';
+/** `leaf u32 || sigma_0..66 || auth_0..7`, the wire form of PROTOCOL-V1 section 5. */
+export declare function encodeSignature(signature: MerkleSignature): Hex;
+/** The wire form back into a signature: the inverse of `encodeSignature`. */
+export declare function decodeSignature(wire: Hex): MerkleSignature;

package/dist/signature.js

@@ -0,0 +1,26 @@
+/** The 2,404-byte wire form of a signature, as PQRegistry stores it: leaf u32 || sigma || auth. */
+import { fromHex, toHex } from './bytes.js';
+import { PQ } from './constants.js';
+import { HashbornError } from './errors.js';
+const CHAINS = PQ.len * PQ.n;
+/** `leaf u32 || sigma_0..66 || auth_0..7`, the wire form of PROTOCOL-V1 section 5. */
+export function encodeSignature(signature) {
+    const out = new Uint8Array(PQ.signatureBytes);
+    if (!Number.isInteger(signature.leaf) || signature.leaf < 0 || signature.leaf >= PQ.leaves) {
+        throw new HashbornError(`leaf index must be an integer in 0..${PQ.leaves - 1}`);
+    }
+    new DataView(out.buffer).setUint32(0, signature.leaf, false);
+    out.set(fromHex(signature.wots, CHAINS, 'signature.wots'), 4);
+    if (!Array.isArray(signature.auth) || signature.auth.length !== PQ.height) {
+        throw new HashbornError(`signature.auth must have ${PQ.height} nodes`);
+    }
+    signature.auth.forEach((node, i) => out.set(fromHex(node, PQ.n, `signature.auth[${i}]`), 4 + CHAINS + i * PQ.n));
+    return toHex(out);
+}
+/** The wire form back into a signature: the inverse of `encodeSignature`. */
+export function decodeSignature(wire) {
+    const bytes = fromHex(wire, PQ.signatureBytes, 'signature');
+    const leaf = new DataView(bytes.buffer, bytes.byteOffset).getUint32(0, false);
+    const auth = Array.from({ length: PQ.height }, (_, i) => toHex(bytes.slice(4 + CHAINS + i * PQ.n, 4 + CHAINS + (i + 1) * PQ.n)));
+    return { leaf, wots: toHex(bytes.slice(4, 4 + CHAINS)), auth };
+}

package/dist/verify.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Verification of protocol v1 attestations with SHA-256 alone:
+ *   finish the 67 WOTS chains over `messageHash`, hash the leaf, climb the 8-level auth path,
+ *   compare with `root`, and check that `pqAddress` derives from `root` and `pubSeed`.
+ */
+import { type DigestFields, type Hex, type MerkleSignature } from './constants.js';
+export interface SignatureCheck {
+    valid: boolean;
+    /** The root the signature climbs to. */
+    computedRoot: Hex;
+    /** SHA-256 calls made finishing the 67 chains: 45 to 990. */
+    hashCalls: number;
+}
+/**
+ * Low level: does `signature` over `messageHash` climb to `root`? Throws a HashbornError on
+ * malformed input (bad hex, wrong sizes, a leaf index outside 0..255).
+ */
+export declare function verifySignature(messageHash: Hex, signature: MerkleSignature, pub: {
+    root: Hex;
+    pubSeed: Hex;
+}): SignatureCheck;
+/** Why a check failed. */
+export type FailureCode = 
+/** Not an attestation: a missing field, bad hex, a wrong size, a leaf outside 0..255. */
+'malformed'
+/** Well formed, but not protocol v1: another version, scheme, height or domain. */
+ | 'unsupported'
+/** The signature does not climb to the root over messageHash. */
+ | 'signature'
+/** pqAddress does not derive from root and pubSeed. */
+ | 'pq-address'
+/** The record's fields do not hash to messageHash. */
+ | 'digest'
+/** The record and its signature name different leaves. */
+ | 'leaf';
+export interface VerifyResult {
+    valid: boolean;
+    /** Set when `valid` is false. */
+    code?: FailureCode;
+    /** One plain sentence, set when `valid` is false. */
+    reason?: string;
+    domain: string | null;
+    /** The leaf index that signed. */
+    leaf: number | null;
+    /** The signer's pq address, derived from root and pubSeed. */
+    pqAddress: string | null;
+    messageHash: Hex | null;
+    /** The identity root the attestation names. */
+    root: Hex | null;
+    /** The root the signature climbs to; equal to `root` when the signature is valid. */
+    computedRoot: Hex | null;
+    /** SHA-256 calls made finishing the chains (45 to 990), 0 when they were not run. */
+    hashCalls: number;
+}
+/**
+ * Verifies an attestation with SHA-256 alone: its shape and sizes, protocol v1 fields (version 1,
+ * scheme wots-merkle, height 8, a v1 domain), the WOTS signature and Merkle path over
+ * `messageHash` against `root` and `pubSeed`, and that `pqAddress` derives from them.
+ * Never throws: a bad input is `{valid: false, code, reason}`.
+ *
+ * It does not check that the attestation was anchored on chain, nor what `messageHash` stands
+ * for: use `verifyRecord` with the record's fields for that.
+ */
+export declare function verifyAttestation(attestation: unknown): VerifyResult;
+export interface RecordVerifyResult extends VerifyResult {
+    /** The digest recomputed from the record; equal to `messageHash` when they match. */
+    recordDigest: Hex | null;
+}
+/**
+ * `verifyAttestation` plus the record: recomputes the digest from `record` under the
+ * attestation's domain and requires it to equal `messageHash`. `record` is either the fields
+ * object (hashed as canonical JSON, keys sorted) or the record text exactly as published on chain.
+ */
+export declare function verifyRecord(attestation: unknown, record: DigestFields | string): RecordVerifyResult;

package/dist/verify.js

@@ -0,0 +1,104 @@
+/**
+ * Verification of protocol v1 attestations with SHA-256 alone:
+ *   finish the 67 WOTS chains over `messageHash`, hash the leaf, climb the 8-level auth path,
+ *   compare with `root`, and check that `pqAddress` derives from `root` and `pubSeed`.
+ */
+import { pqAddress as derivePqAddress } from './address.js';
+import { checkAttestation } from './attestation.js';
+import { equalBytes, fromHex, toHex } from './bytes.js';
+import { PQ } from './constants.js';
+import { canonicalJson, recordDigest } from './digest.js';
+import { HashbornError } from './errors.js';
+import { climb, leafHash } from './merkle.js';
+import { decodeSigma, wotsVerifyPk } from './wots.js';
+/**
+ * Low level: does `signature` over `messageHash` climb to `root`? Throws a HashbornError on
+ * malformed input (bad hex, wrong sizes, a leaf index outside 0..255).
+ */
+export function verifySignature(messageHash, signature, pub) {
+    const digest = fromHex(messageHash, PQ.n, 'messageHash');
+    const pubSeed = fromHex(pub.pubSeed, PQ.n, 'pubSeed');
+    const expectedRoot = fromHex(pub.root, PQ.n, 'root');
+    if (!signature || typeof signature !== 'object')
+        throw new HashbornError('signature must be an object');
+    const leaf = signature.leaf;
+    if (!Number.isInteger(leaf) || leaf < 0 || leaf >= PQ.leaves) {
+        throw new HashbornError(`leaf index must be an integer in 0..${PQ.leaves - 1}`);
+    }
+    const sigma = decodeSigma(fromHex(signature.wots, PQ.len * PQ.n, 'signature.wots'));
+    if (!Array.isArray(signature.auth) || signature.auth.length !== PQ.height) {
+        throw new HashbornError(`signature.auth must have ${PQ.height} nodes`);
+    }
+    const auth = signature.auth.map((h, i) => fromHex(h, PQ.n, `signature.auth[${i}]`));
+    const { pks, hashes } = wotsVerifyPk(pubSeed, leaf, digest, sigma);
+    const root = climb(pubSeed, leaf, leafHash(pubSeed, leaf, pks), auth, PQ.height);
+    return { valid: equalBytes(root, expectedRoot), computedRoot: toHex(root), hashCalls: hashes };
+}
+function readable(value) {
+    const v = (typeof value === 'object' && value !== null ? value : {});
+    const sig = (typeof v.signature === 'object' && v.signature !== null ? v.signature : {});
+    return {
+        domain: typeof v.domain === 'string' ? v.domain : null,
+        leaf: typeof sig.leaf === 'number' && Number.isInteger(sig.leaf) ? sig.leaf : null,
+        messageHash: typeof v.messageHash === 'string' && /^0x[0-9a-fA-F]{64}$/.test(v.messageHash) ? v.messageHash : null,
+        root: typeof v.root === 'string' && /^0x[0-9a-fA-F]{64}$/.test(v.root) ? v.root : null,
+    };
+}
+/**
+ * Verifies an attestation with SHA-256 alone: its shape and sizes, protocol v1 fields (version 1,
+ * scheme wots-merkle, height 8, a v1 domain), the WOTS signature and Merkle path over
+ * `messageHash` against `root` and `pubSeed`, and that `pqAddress` derives from them.
+ * Never throws: a bad input is `{valid: false, code, reason}`.
+ *
+ * It does not check that the attestation was anchored on chain, nor what `messageHash` stands
+ * for: use `verifyRecord` with the record's fields for that.
+ */
+export function verifyAttestation(attestation) {
+    const base = { ...readable(attestation), valid: false, pqAddress: null, computedRoot: null, hashCalls: 0 };
+    let att;
+    try {
+        att = checkAttestation(attestation, false);
+    }
+    catch (err) {
+        const code = err instanceof HashbornError && err.code === 'unsupported' ? 'unsupported' : 'malformed';
+        return { ...base, code, reason: err instanceof Error ? err.message : String(err) };
+    }
+    if (att.scheme !== 'wots-merkle') {
+        return { ...base, code: 'unsupported', reason: `scheme ${att.scheme} is not signed in protocol v1; only wots-merkle is` };
+    }
+    const derived = derivePqAddress(att);
+    const sig = verifySignature(att.messageHash, att.signature, att);
+    const result = { ...base, pqAddress: derived, computedRoot: sig.computedRoot, hashCalls: sig.hashCalls };
+    if (!sig.valid) {
+        return { ...result, code: 'signature', reason: 'The signature does not climb to the root over messageHash.' };
+    }
+    if (derived !== att.pqAddress) {
+        return { ...result, code: 'pq-address', reason: `pqAddress does not derive from root and pubSeed (expected ${derived}).` };
+    }
+    return { ...result, valid: true };
+}
+/**
+ * `verifyAttestation` plus the record: recomputes the digest from `record` under the
+ * attestation's domain and requires it to equal `messageHash`. `record` is either the fields
+ * object (hashed as canonical JSON, keys sorted) or the record text exactly as published on chain.
+ */
+export function verifyRecord(attestation, record) {
+    const result = verifyAttestation(attestation);
+    let recomputed;
+    try {
+        const domain = attestation?.domain;
+        if (typeof domain !== 'string')
+            throw new HashbornError('domain: string expected');
+        recomputed = recordDigest(domain, typeof record === 'string' ? record : canonicalJson(record));
+    }
+    catch (err) {
+        const reason = `record: ${err instanceof Error ? err.message : String(err)}`;
+        return result.valid ? { ...result, valid: false, code: 'malformed', reason, recordDigest: null } : { ...result, recordDigest: null };
+    }
+    if (!result.valid)
+        return { ...result, recordDigest: recomputed };
+    if (recomputed !== result.messageHash?.toLowerCase()) {
+        return { ...result, valid: false, code: 'digest', reason: 'The record does not hash to the signed messageHash.', recordDigest: recomputed };
+    }
+    return { ...result, recordDigest: recomputed };
+}

package/dist/wots.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The verifier's half of WOTS, protocol v1 parameters: w = 16, n = 32.
+ *
+ * A 32-byte digest becomes 64 base-16 digits d_0..d_63. The checksum C = sum(15 - d_i) (at most
+ * 960) is written as three base-16 digits, most significant first, giving 67 digits. The
+ * signature value of chain i is F^{d_i}(sk_i); the verifier finishes the chain,
+ * F^{15 - d_i}(sigma_i), and gets the chain's public end back. 45 to 990 SHA-256 calls.
+ */
+export declare const WOTS_SIGMA_BYTES: number;
+/** The 67 digits of a digest: 64 message digits then 3 checksum digits. */
+export declare function digits(digest: Uint8Array): number[];
+/** Walks chain `i` of `leaf` from step `start` for `steps` steps, starting at value `x`. */
+export declare function chain(pubSeed: Uint8Array, leaf: number, i: number, start: number, steps: number, x: Uint8Array): Uint8Array;
+/** Finishes every chain from the signature values, returning the implied chain ends. */
+export declare function wotsVerifyPk(pubSeed: Uint8Array, leaf: number, digest: Uint8Array, sigma: Uint8Array[]): {
+    pks: Uint8Array[];
+    hashes: number;
+};
+export declare function decodeSigma(bytes: Uint8Array): Uint8Array[];

package/dist/wots.js

@@ -0,0 +1,59 @@
+/**
+ * The verifier's half of WOTS, protocol v1 parameters: w = 16, n = 32.
+ *
+ * A 32-byte digest becomes 64 base-16 digits d_0..d_63. The checksum C = sum(15 - d_i) (at most
+ * 960) is written as three base-16 digits, most significant first, giving 67 digits. The
+ * signature value of chain i is F^{d_i}(sk_i); the verifier finishes the chain,
+ * F^{15 - d_i}(sigma_i), and gets the chain's public end back. 45 to 990 SHA-256 calls.
+ */
+import { PQ } from './constants.js';
+import { HashbornError } from './errors.js';
+import { ADRS, F, adrs } from './hash.js';
+export const WOTS_SIGMA_BYTES = PQ.len * PQ.n;
+/** The 67 digits of a digest: 64 message digits then 3 checksum digits. */
+export function digits(digest) {
+    if (digest.length !== PQ.n)
+        throw new HashbornError(`digest must be ${PQ.n} bytes`);
+    const out = new Array(PQ.len);
+    let csum = 0;
+    for (let i = 0; i < PQ.n; i++) {
+        const hi = digest[i] >> 4;
+        const lo = digest[i] & 15;
+        out[2 * i] = hi;
+        out[2 * i + 1] = lo;
+        csum += PQ.chainSteps - hi + (PQ.chainSteps - lo);
+    }
+    out[PQ.len1] = (csum >> 8) & 15;
+    out[PQ.len1 + 1] = (csum >> 4) & 15;
+    out[PQ.len1 + 2] = csum & 15;
+    return out;
+}
+/** Walks chain `i` of `leaf` from step `start` for `steps` steps, starting at value `x`. */
+export function chain(pubSeed, leaf, i, start, steps, x) {
+    let v = x;
+    for (let s = 0; s < steps; s++)
+        v = F(pubSeed, adrs(ADRS.chain, leaf, i, start + s), v);
+    return v;
+}
+/** Finishes every chain from the signature values, returning the implied chain ends. */
+export function wotsVerifyPk(pubSeed, leaf, digest, sigma) {
+    if (sigma.length !== PQ.len)
+        throw new HashbornError(`signature must have ${PQ.len} chain values`);
+    const d = digits(digest);
+    const pks = new Array(PQ.len);
+    let hashes = 0;
+    for (let i = 0; i < PQ.len; i++) {
+        const steps = PQ.chainSteps - d[i];
+        pks[i] = chain(pubSeed, leaf, i, d[i], steps, sigma[i]);
+        hashes += steps;
+    }
+    return { pks, hashes };
+}
+export function decodeSigma(bytes) {
+    if (bytes.length !== WOTS_SIGMA_BYTES)
+        throw new HashbornError(`signature.wots must be ${WOTS_SIGMA_BYTES} bytes`);
+    const out = new Array(PQ.len);
+    for (let i = 0; i < PQ.len; i++)
+        out[i] = bytes.subarray(i * PQ.n, (i + 1) * PQ.n);
+    return out;
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@hashborn/verify",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.2",
+  "description": "Verify Hashborn (protocol pqc-rh) post-quantum records offline with SHA-256 alone: WOTS + Merkle signatures, record digests, verify links and RWA manifest roots. Supersedes @hashborne/verify.",
+  "keywords": [
+    "hashborn",
+    "hashborne",
+    "pqc-rh",
+    "post-quantum",
+    "wots",
+    "merkle",
+    "hash-based-signature",
+    "sha256",
+    "verify",
+    "robinhood-chain"
+  ],
+  "homepage": "https://hashborn.com/docs",
+  "license": "MIT",
+  "author": "Hashborn",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "hashborn-verify": "dist/cli.js",
+    "hashborne-verify": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.19"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@noble/hashes": "^2.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "tsx": "^4.21.0",
+    "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test --import tsx \"test/**/*.test.ts\"",
+    "vectors": "node --import tsx test/gen-vectors.ts"
+  }
 }