@algovoi/rfc9421-verifier 0.1.0

package/README.md

@@ -0,0 +1,146 @@
+# algovoi-rfc9421-verifier
+
+[![PyPI](https://img.shields.io/pypi/v/algovoi-rfc9421-verifier?label=PyPI)](https://pypi.org/project/algovoi-rfc9421-verifier/)
+[![npm](https://img.shields.io/npm/v/@algovoi/rfc9421-verifier?label=npm)](https://www.npmjs.com/package/@algovoi/rfc9421-verifier)
+[![Apache 2.0](https://img.shields.io/badge/license-Apache--2.0-green)](./LICENSE)
+[![IETF I-D](https://img.shields.io/badge/companion%20IETF%20I--D-draft--hopley--x402--compliance--receipt--00-blue)](https://datatracker.ietf.org/doc/draft-hopley-x402-compliance-receipt/)
+
+AlgoVoi-authored reference verifier for
+[RFC 9421 (HTTP Message Signatures)](https://www.rfc-editor.org/rfc/rfc9421)
+plus
+[RFC 9530 (Digest Fields for HTTP)](https://www.rfc-editor.org/rfc/rfc9530).
+Python and TypeScript, byte-for-byte parity, Apache 2.0.
+
+Use cases:
+
+- Verify an incoming RFC 9421-signed HTTP request against a known
+  public key.
+- Re-validate a captured request after it traverses a TLS-re-terminating
+  proxy chain (the property pinned in the
+  [`rfc9421_proxy_chain_v0`](https://github.com/chopmob-cloud/algovoi-jcs-conformance-vectors/tree/main/vectors/rfc9421_proxy_chain_v0)
+  conformance fixture).
+- Build conformance test harnesses anchored to the RFC 8032 Section
+  7.1 deterministic Ed25519 reference keypair.
+
+## Packages
+
+| Language | Package | Install |
+|---|---|---|
+| Python | [`algovoi-rfc9421-verifier`](https://pypi.org/project/algovoi-rfc9421-verifier/) | `pip install algovoi-rfc9421-verifier` |
+| TypeScript | [`@algovoi/rfc9421-verifier`](https://www.npmjs.com/package/@algovoi/rfc9421-verifier) | `npm install @algovoi/rfc9421-verifier` |
+
+Both packages are byte-deterministic on identical inputs and tested
+against the same RFC 8032 Section 7.1 Test 1 reference fixture.
+
+## Quick start
+
+### Python
+
+```python
+from algovoi_rfc9421_verifier import verify_request
+
+result = verify_request(
+    method="GET",
+    authority="api.algovoi.co.uk",
+    path="/compliance/attestation",
+    headers={
+        "content-digest": "sha-256=:47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=:",
+        "signature-input": (
+            'sig=("@method" "@authority" "@path" "content-digest" "created");'
+            'created=1778955520;keyid="did:web:api.algovoi.co.uk";alg="ed25519"'
+        ),
+        "signature": (
+            "sig=:Xj1peMjEYi75R/QQFYpU9q/gHwQKYwgt1etjAX1qc0zugTMJoJ86Uhy/jTZ175b3"
+            "zFhp0j8cLjmDJvGmySDBAQ==:"
+        ),
+    },
+    body=b"",
+    public_key="d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a",
+)
+assert result.valid
+```
+
+### TypeScript
+
+```typescript
+import { verifyRequest } from "@algovoi/rfc9421-verifier";
+
+const result = await verifyRequest({
+  method: "GET",
+  authority: "api.algovoi.co.uk",
+  path: "/compliance/attestation",
+  headers: {
+    "content-digest": "sha-256=:47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=:",
+    "signature-input":
+      'sig=("@method" "@authority" "@path" "content-digest" "created");created=1778955520;keyid="did:web:api.algovoi.co.uk";alg="ed25519"',
+    signature:
+      "sig=:Xj1peMjEYi75R/QQFYpU9q/gHwQKYwgt1etjAX1qc0zugTMJoJ86Uhy/jTZ175b3zFhp0j8cLjmDJvGmySDBAQ==:",
+  },
+  body: new Uint8Array(),
+  publicKey:
+    "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a",
+});
+if (result.valid) console.log("verified");
+```
+
+## API surface (v0.1.0)
+
+| Function | Purpose |
+|---|---|
+| `verify_request` / `verifyRequest` | High-level: parse all headers, build signing base, verify Content-Digest, verify Ed25519 signature, return a `VerifyResult` with per-step success flags. |
+| `verify_signature` / `verifySignature` | Lower-level: caller supplies the signing base; library verifies Ed25519 only. |
+| `verify_content_digest` / `verifyContentDigest` | Validate RFC 9530 `Content-Digest` header against a body. SHA-256 and SHA-512 supported. |
+| `build_signing_base` / `buildSigningBase` | Construct the RFC 9421 §2.5 signing base from covered components + values. |
+| `parse_signature_input` / `parseSignatureInput` | Parse a `Signature-Input` header. Accepts the strict labelled form and the unlabelled real-world form. |
+| `parse_signature_value` / `parseSignatureValue` | Parse a `Signature` header. |
+| `compute_content_digest` / `computeContentDigest` | Compute a `Content-Digest` header value for a body. |
+
+## Scope (v0.1.0)
+
+- **Algorithms**: Ed25519 only. ECDSA-P256 and RSA-PSS are roadmap.
+- **Derived components**: `@method`, `@authority`, `@path`,
+  `@target-uri`, `@scheme`, `@status`, plus `created` and `expires`
+  parameters. `@request-target`, `@query`, `@query-param` are roadmap.
+- **Header forms**: strict labelled `<label>=(...)` and unlabelled
+  `(...);created=...` real-world forms both accepted.
+- **Content-Digest**: SHA-256 (mandatory per RFC 9530) and SHA-512.
+  Other algorithms in the IANA registry are roadmap.
+
+The v0.1.0 surface is sufficient to verify any AlgoVoi production
+compliance receipt and the `rfc9421_proxy_chain_v0` conformance
+fixture. Multi-algorithm + multi-label support arrives in v0.2.0.
+
+## Conformance fixture
+
+The reference fixture for the verifier is at
+[`chopmob-cloud/algovoi-jcs-conformance-vectors/vectors/rfc9421_proxy_chain_v0/`](https://github.com/chopmob-cloud/algovoi-jcs-conformance-vectors/tree/main/vectors/rfc9421_proxy_chain_v0).
+It uses the RFC 8032 Section 7.1 Test 1 deterministic Ed25519 keypair
+and includes a `tcpdump` wire-capture record (`E2E_PROOF.md`)
+demonstrating that the RFC 9421 headers survive a 3-hop
+TLS-re-terminating proxy chain (Cloudflare edge → nginx → FastAPI)
+byte-identical.
+
+## Companion IETF Internet-Draft
+
+This library is part of the AlgoVoi substrate that anchors
+[`draft-hopley-x402-compliance-receipt-00`](https://datatracker.ietf.org/doc/draft-hopley-x402-compliance-receipt/)
+(Independent Submission, Informational; posted 2026-05-23). The
+receipt-format audit-chain property in the I-D assumes signed
+receipts can be transported and re-verified independently of the
+originating gateway — exactly the property this verifier checks.
+
+## Related AlgoVoi substrate packages
+
+| Package | Purpose |
+|---|---|
+| [`algovoi-substrate`](https://pypi.org/project/algovoi-substrate/) / [`@algovoi/substrate`](https://www.npmjs.com/package/@algovoi/substrate) | JCS RFC 8785 canonicalisation, `action_ref`, transactional lifecycle, compliance receipt builder |
+| [`algovoi-audit-verifier`](https://pypi.org/project/algovoi-audit-verifier/) / [`@algovoi/audit-verifier`](https://www.npmjs.com/package/@algovoi/audit-verifier) | Selective-disclosure audit bundle verifier; consumes substrate output |
+| **`algovoi-rfc9421-verifier`** / `@algovoi/rfc9421-verifier` | **This package.** RFC 9421/9530 HTTP signature verifier |
+
+## Licence
+
+Apache 2.0. See [`LICENSE`](./LICENSE).
+
+## Author
+
+AlgoVoi (Christopher Hopley, GitHub [`chopmob-cloud`](https://github.com/chopmob-cloud)).

package/dist/content-digest.d.ts

@@ -0,0 +1,10 @@
+/**
+ * RFC 9530 Content-Digest field implementation.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.content_digest module.
+ */
+export declare class ContentDigestError extends Error {
+    constructor(message: string);
+}
+export declare function computeContentDigest(body: Uint8Array | Buffer | string, algorithm?: string): string;
+export declare function verifyContentDigest(body: Uint8Array | Buffer | string, headerValue: string, requireAlgorithm?: string): boolean;

package/dist/content-digest.js

@@ -0,0 +1,72 @@
+/**
+ * RFC 9530 Content-Digest field implementation.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.content_digest module.
+ */
+import { createHash } from "node:crypto";
+export class ContentDigestError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ContentDigestError";
+    }
+}
+const DIGEST_ENTRY_RE = /([a-z0-9-]+)=:([A-Za-z0-9+/=]+):/g;
+const SUPPORTED_ALGOS = {
+    "sha-256": "sha256",
+    "sha-512": "sha512",
+};
+function bodyBytes(body) {
+    if (typeof body === "string")
+        return Buffer.from(body, "utf-8");
+    if (Buffer.isBuffer(body))
+        return body;
+    return Buffer.from(body);
+}
+export function computeContentDigest(body, algorithm = "sha-256") {
+    const algoLower = algorithm.toLowerCase();
+    const nodeAlgo = SUPPORTED_ALGOS[algoLower];
+    if (!nodeAlgo) {
+        throw new ContentDigestError(`unsupported algorithm ${JSON.stringify(algorithm)}; supported: ${Object.keys(SUPPORTED_ALGOS)}`);
+    }
+    const hash = createHash(nodeAlgo).update(bodyBytes(body)).digest("base64");
+    return `${algoLower}=:${hash}:`;
+}
+export function verifyContentDigest(body, headerValue, requireAlgorithm) {
+    if (typeof headerValue !== "string") {
+        throw new ContentDigestError(`header must be string, got ${typeof headerValue}`);
+    }
+    const entries = [];
+    const localRe = new RegExp(DIGEST_ENTRY_RE.source, "g");
+    let m;
+    while ((m = localRe.exec(headerValue)) !== null) {
+        entries.push([m[1], m[2]]);
+    }
+    if (entries.length === 0) {
+        throw new ContentDigestError(`no valid digest entries in header: ${JSON.stringify(headerValue)}`);
+    }
+    const reqAlg = requireAlgorithm?.toLowerCase();
+    let requiredSeen = false;
+    for (const [algo, digestB64] of entries) {
+        const algoLower = algo.toLowerCase();
+        const nodeAlgo = SUPPORTED_ALGOS[algoLower];
+        if (!nodeAlgo)
+            continue;
+        if (reqAlg && algoLower === reqAlg)
+            requiredSeen = true;
+        let expected;
+        try {
+            expected = Buffer.from(digestB64, "base64");
+        }
+        catch (e) {
+            throw new ContentDigestError(`digest entry ${algoLower} is not valid base64: ${e.message}`);
+        }
+        const actual = createHash(nodeAlgo).update(bodyBytes(body)).digest();
+        if (!expected.equals(actual)) {
+            throw new ContentDigestError(`digest mismatch on ${algoLower}: header claims ${digestB64} but body hashes to ${actual.toString("base64")}`);
+        }
+    }
+    if (reqAlg && !requiredSeen) {
+        throw new ContentDigestError(`required algorithm ${reqAlg} not present in header`);
+    }
+    return true;
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @algovoi/rfc9421-verifier
+ *
+ * AlgoVoi RFC 9421 HTTP Message Signatures + RFC 9530 Content-Digest
+ * reference verifier (TypeScript). Byte-for-byte parity with the
+ * Python sibling `algovoi-rfc9421-verifier` on PyPI.
+ *
+ * Apache 2.0. Companion to IETF Internet-Draft
+ * draft-hopley-x402-compliance-receipt-00.
+ */
+export { SignatureInputParseError, parseSignatureInput, parseSignatureValue, type ParsedSignatureInput, } from "./parse.js";
+export { SigningBaseError, buildSigningBase, type SigningBaseInput, } from "./signing-base.js";
+export { ContentDigestError, computeContentDigest, verifyContentDigest, } from "./content-digest.js";
+export { VerifyError, verifySignature, verifyRequest, type VerifyResult, type VerifyRequestInput, type PublicKey, } from "./verify.js";

package/dist/index.js

@@ -0,0 +1,14 @@
+/**
+ * @algovoi/rfc9421-verifier
+ *
+ * AlgoVoi RFC 9421 HTTP Message Signatures + RFC 9530 Content-Digest
+ * reference verifier (TypeScript). Byte-for-byte parity with the
+ * Python sibling `algovoi-rfc9421-verifier` on PyPI.
+ *
+ * Apache 2.0. Companion to IETF Internet-Draft
+ * draft-hopley-x402-compliance-receipt-00.
+ */
+export { SignatureInputParseError, parseSignatureInput, parseSignatureValue, } from "./parse.js";
+export { SigningBaseError, buildSigningBase, } from "./signing-base.js";
+export { ContentDigestError, computeContentDigest, verifyContentDigest, } from "./content-digest.js";
+export { VerifyError, verifySignature, verifyRequest, } from "./verify.js";

package/dist/parse.d.ts

@@ -0,0 +1,19 @@
+/**
+ * RFC 9421 Signature-Input and Signature header parsers.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.parse module.
+ */
+export declare class SignatureInputParseError extends Error {
+    constructor(message: string);
+}
+export interface ParsedSignatureInput {
+    label: string;
+    covered_components: string[];
+    parameters: Record<string, string | number>;
+    raw: string;
+}
+export declare function parseSignatureInput(headerValue: string): ParsedSignatureInput;
+export declare function parseSignatureValue(headerValue: string): {
+    label: string;
+    signature: Uint8Array;
+};

package/dist/parse.js

@@ -0,0 +1,107 @@
+/**
+ * RFC 9421 Signature-Input and Signature header parsers.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.parse module.
+ */
+export class SignatureInputParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SignatureInputParseError";
+    }
+}
+const LABEL_RE = /^\s*([A-Za-z][A-Za-z0-9_-]*)\s*=\s*/;
+const COVERED_RE = /\(\s*(?:"[^"]*"\s*)*\)/;
+const QUOTED_RE = /"([^"]*)"/g;
+const PARAM_RE = /([A-Za-z][A-Za-z0-9_-]*)=([^;,\s]+|"[^"]*")/g;
+export function parseSignatureInput(headerValue) {
+    if (typeof headerValue !== "string") {
+        throw new SignatureInputParseError(`header must be string, got ${typeof headerValue}`);
+    }
+    const trimmed = headerValue.trim();
+    if (trimmed.length === 0) {
+        throw new SignatureInputParseError("empty header value");
+    }
+    let label;
+    let rest;
+    const labelMatch = LABEL_RE.exec(trimmed);
+    if (labelMatch) {
+        label = labelMatch[1];
+        rest = trimmed.slice(labelMatch[0].length);
+    }
+    else if (trimmed.startsWith("(")) {
+        label = "";
+        rest = trimmed;
+    }
+    else {
+        throw new SignatureInputParseError(`no label or covered-components list found at start: ${JSON.stringify(trimmed.slice(0, 40))}`);
+    }
+    const coveredMatch = COVERED_RE.exec(rest);
+    if (!coveredMatch) {
+        throw new SignatureInputParseError("no covered-components list found");
+    }
+    const coveredRaw = coveredMatch[0];
+    const covered = [];
+    let qm;
+    const localQuoted = /"([^"]*)"/g;
+    while ((qm = localQuoted.exec(coveredRaw)) !== null) {
+        covered.push(qm[1]);
+    }
+    rest = rest.slice(coveredMatch.index + coveredRaw.length);
+    const parameters = {};
+    const localParam = new RegExp(PARAM_RE.source, "g");
+    let pm;
+    while ((pm = localParam.exec(rest)) !== null) {
+        const key = pm[1];
+        const raw = pm[2];
+        if (raw.startsWith('"') && raw.endsWith('"')) {
+            parameters[key] = raw.slice(1, -1);
+        }
+        else if (/^-?\d+$/.test(raw)) {
+            parameters[key] = parseInt(raw, 10);
+        }
+        else {
+            parameters[key] = raw;
+        }
+    }
+    return {
+        label,
+        covered_components: covered,
+        parameters,
+        raw: trimmed,
+    };
+}
+export function parseSignatureValue(headerValue) {
+    if (typeof headerValue !== "string") {
+        throw new SignatureInputParseError(`header must be string, got ${typeof headerValue}`);
+    }
+    const trimmed = headerValue.trim();
+    if (trimmed.length === 0) {
+        throw new SignatureInputParseError("empty Signature header value");
+    }
+    let label;
+    let rest;
+    const labelMatch = LABEL_RE.exec(trimmed);
+    if (labelMatch) {
+        label = labelMatch[1];
+        rest = trimmed.slice(labelMatch[0].length).trim();
+    }
+    else if (trimmed.startsWith(":")) {
+        label = "";
+        rest = trimmed;
+    }
+    else {
+        throw new SignatureInputParseError(`no label or signature-value prefix found at start: ${JSON.stringify(trimmed.slice(0, 40))}`);
+    }
+    if (!rest.startsWith(":") || !rest.endsWith(":")) {
+        throw new SignatureInputParseError("signature value must be wrapped in colons (RFC 8941 byte-sequence form)");
+    }
+    const sigB64 = rest.slice(1, -1);
+    let sigBytes;
+    try {
+        sigBytes = new Uint8Array(Buffer.from(sigB64, "base64"));
+    }
+    catch (e) {
+        throw new SignatureInputParseError(`signature value is not valid base64: ${e.message}`);
+    }
+    return { label, signature: sigBytes };
+}

package/dist/signing-base.d.ts

@@ -0,0 +1,20 @@
+/**
+ * RFC 9421 Section 2.5 signing-base construction.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.signing_base module.
+ */
+export declare class SigningBaseError extends Error {
+    constructor(message: string);
+}
+export interface SigningBaseInput {
+    coveredComponents: string[];
+    method?: string;
+    authority?: string;
+    path?: string;
+    targetUri?: string;
+    scheme?: string;
+    status?: number;
+    headers?: Record<string, string>;
+    parameters?: Record<string, string | number>;
+}
+export declare function buildSigningBase(input: SigningBaseInput): string;

package/dist/signing-base.js

@@ -0,0 +1,76 @@
+/**
+ * RFC 9421 Section 2.5 signing-base construction.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.signing_base module.
+ */
+export class SigningBaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SigningBaseError";
+    }
+}
+export function buildSigningBase(input) {
+    const normHeaders = {};
+    for (const [k, v] of Object.entries(input.headers ?? {})) {
+        normHeaders[k.toLowerCase()] = v;
+    }
+    const parameters = input.parameters ?? {};
+    const lines = [];
+    for (const component of input.coveredComponents) {
+        const c = component.toLowerCase();
+        let value;
+        switch (c) {
+            case "@method":
+                if (input.method === undefined)
+                    throw new SigningBaseError("@method covered but method not supplied");
+                value = input.method.toLowerCase();
+                break;
+            case "@authority":
+                if (input.authority === undefined)
+                    throw new SigningBaseError("@authority covered but authority not supplied");
+                value = input.authority.toLowerCase();
+                break;
+            case "@path":
+                if (input.path === undefined)
+                    throw new SigningBaseError("@path covered but path not supplied");
+                value = input.path;
+                break;
+            case "@target-uri":
+                if (input.targetUri === undefined)
+                    throw new SigningBaseError("@target-uri covered but targetUri not supplied");
+                value = input.targetUri;
+                break;
+            case "@scheme":
+                if (input.scheme === undefined)
+                    throw new SigningBaseError("@scheme covered but scheme not supplied");
+                value = input.scheme.toLowerCase();
+                break;
+            case "@status":
+                if (input.status === undefined)
+                    throw new SigningBaseError("@status covered but status not supplied");
+                value = String(input.status);
+                break;
+            case "created":
+                if (!("created" in parameters))
+                    throw new SigningBaseError("'created' covered but no 'created' parameter in Signature-Input");
+                value = String(parameters["created"]);
+                break;
+            case "expires":
+                if (!("expires" in parameters))
+                    throw new SigningBaseError("'expires' covered but no 'expires' parameter in Signature-Input");
+                value = String(parameters["expires"]);
+                break;
+            default:
+                if (c.startsWith("@")) {
+                    throw new SigningBaseError(`unsupported derived component: ${component}`);
+                }
+                if (!(c in normHeaders)) {
+                    throw new SigningBaseError(`covered header ${JSON.stringify(component)} not present in supplied headers`);
+                }
+                value = normHeaders[c];
+                break;
+        }
+        lines.push(`"${c}": ${value}`);
+    }
+    return lines.join("\n");
+}

package/dist/verify.d.ts

@@ -0,0 +1,33 @@
+/**
+ * RFC 9421 + RFC 9530 verification top-level.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.verify module.
+ * Uses @noble/ed25519 for Ed25519 verification.
+ */
+export declare class VerifyError extends Error {
+    constructor(message: string);
+}
+export type PublicKey = string | Uint8Array;
+export interface VerifyResult {
+    valid: boolean;
+    signature_valid: boolean;
+    content_digest_valid: boolean;
+    signing_base: string;
+    covered_components: string[];
+    parameters: Record<string, string | number>;
+    label: string;
+    errors: string[];
+}
+export interface VerifyRequestInput {
+    method: string;
+    authority: string;
+    path: string;
+    headers: Record<string, string>;
+    body: Uint8Array | Buffer | string;
+    publicKey: PublicKey;
+    scheme?: string;
+    requireContentDigest?: boolean;
+    requireAlgorithm?: string;
+}
+export declare function verifySignature(signingBase: string, signatureBytes: Uint8Array, publicKey: PublicKey, algorithm?: string): Promise<boolean>;
+export declare function verifyRequest(input: VerifyRequestInput): Promise<VerifyResult>;

package/dist/verify.js

@@ -0,0 +1,170 @@
+/**
+ * RFC 9421 + RFC 9530 verification top-level.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.verify module.
+ * Uses @noble/ed25519 for Ed25519 verification.
+ */
+import * as ed25519 from "@noble/ed25519";
+import { parseSignatureInput, parseSignatureValue, SignatureInputParseError, } from "./parse.js";
+import { buildSigningBase, SigningBaseError, } from "./signing-base.js";
+import { verifyContentDigest, ContentDigestError, } from "./content-digest.js";
+export class VerifyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "VerifyError";
+    }
+}
+function newResult() {
+    return {
+        valid: false,
+        signature_valid: false,
+        content_digest_valid: false,
+        signing_base: "",
+        covered_components: [],
+        parameters: {},
+        label: "",
+        errors: [],
+    };
+}
+function fail(result, msg) {
+    result.errors.push(msg);
+    result.valid = false;
+    return result;
+}
+function publicKeyBytes(pk) {
+    if (pk instanceof Uint8Array) {
+        if (pk.length !== 32) {
+            throw new VerifyError(`Ed25519 public key must be 32 bytes, got ${pk.length}`);
+        }
+        return pk;
+    }
+    if (typeof pk === "string") {
+        const hex = pk.startsWith("0x") ? pk.slice(2) : pk;
+        if (!/^[0-9a-fA-F]+$/.test(hex)) {
+            throw new VerifyError("public key hex is invalid");
+        }
+        if (hex.length !== 64) {
+            throw new VerifyError(`Ed25519 public key hex must decode to 32 bytes (64 hex chars), got ${hex.length}`);
+        }
+        const bytes = new Uint8Array(32);
+        for (let i = 0; i < 32; i++) {
+            bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+        }
+        return bytes;
+    }
+    throw new VerifyError("publicKey must be Uint8Array or hex string");
+}
+export async function verifySignature(signingBase, signatureBytes, publicKey, algorithm = "ed25519") {
+    if (algorithm.toLowerCase() !== "ed25519") {
+        throw new VerifyError(`v0.1.0 supports ed25519 only; got ${algorithm}`);
+    }
+    if (signatureBytes.length !== 64) {
+        throw new VerifyError(`Ed25519 signature must be 64 bytes, got ${signatureBytes.length}`);
+    }
+    const pkBytes = publicKeyBytes(publicKey);
+    const messageBytes = new TextEncoder().encode(signingBase);
+    try {
+        return await ed25519.verifyAsync(signatureBytes, messageBytes, pkBytes);
+    }
+    catch {
+        return false;
+    }
+}
+export async function verifyRequest(input) {
+    const result = newResult();
+    const normHeaders = {};
+    for (const [k, v] of Object.entries(input.headers)) {
+        normHeaders[k.toLowerCase()] = v;
+    }
+    const siValue = normHeaders["signature-input"];
+    if (!siValue)
+        return fail(result, "Signature-Input header missing");
+    const sValue = normHeaders["signature"];
+    if (!sValue)
+        return fail(result, "Signature header missing");
+    let parsedSi;
+    try {
+        parsedSi = parseSignatureInput(siValue);
+    }
+    catch (e) {
+        if (e instanceof SignatureInputParseError) {
+            return fail(result, `Signature-Input parse error: ${e.message}`);
+        }
+        throw e;
+    }
+    result.label = parsedSi.label;
+    result.covered_components = parsedSi.covered_components;
+    result.parameters = parsedSi.parameters;
+    let sigParsed;
+    try {
+        sigParsed = parseSignatureValue(sValue);
+    }
+    catch (e) {
+        if (e instanceof SignatureInputParseError) {
+            return fail(result, `Signature parse error: ${e.message}`);
+        }
+        throw e;
+    }
+    if (sigParsed.label &&
+        parsedSi.label &&
+        sigParsed.label !== parsedSi.label) {
+        return fail(result, `Signature label ${sigParsed.label} does not match Signature-Input label ${parsedSi.label}`);
+    }
+    const requireCd = input.requireContentDigest ?? true;
+    const requireAlg = input.requireAlgorithm ?? "sha-256";
+    if (requireCd) {
+        const cdHeader = normHeaders["content-digest"];
+        if (!cdHeader)
+            return fail(result, "Content-Digest header required but missing");
+        try {
+            verifyContentDigest(input.body, cdHeader, requireAlg);
+            result.content_digest_valid = true;
+        }
+        catch (e) {
+            if (e instanceof ContentDigestError) {
+                return fail(result, `Content-Digest verification failed: ${e.message}`);
+            }
+            throw e;
+        }
+    }
+    else {
+        result.content_digest_valid = true;
+    }
+    let signingBase;
+    try {
+        signingBase = buildSigningBase({
+            coveredComponents: parsedSi.covered_components,
+            method: input.method,
+            authority: input.authority,
+            path: input.path,
+            scheme: input.scheme ?? "https",
+            headers: normHeaders,
+            parameters: parsedSi.parameters,
+        });
+    }
+    catch (e) {
+        if (e instanceof SigningBaseError) {
+            return fail(result, `Signing-base build error: ${e.message}`);
+        }
+        throw e;
+    }
+    result.signing_base = signingBase;
+    const alg = parsedSi.parameters["alg"];
+    const algStr = typeof alg === "string" ? alg : "ed25519";
+    let sigOk;
+    try {
+        sigOk = await verifySignature(signingBase, sigParsed.signature, input.publicKey, algStr);
+    }
+    catch (e) {
+        if (e instanceof VerifyError) {
+            return fail(result, `Signature verification setup error: ${e.message}`);
+        }
+        throw e;
+    }
+    if (!sigOk) {
+        return fail(result, "Ed25519 signature does not verify against signing base");
+    }
+    result.signature_valid = true;
+    result.valid = result.signature_valid && result.content_digest_valid;
+    return result;
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@algovoi/rfc9421-verifier",
+  "version": "0.1.0",
+  "description": "AlgoVoi RFC 9421 HTTP Message Signatures + RFC 9530 Content-Digest reference verifier",
+  "keywords": [
+    "rfc9421",
+    "rfc9530",
+    "http-signatures",
+    "ed25519",
+    "agentic-payments",
+    "compliance"
+  ],
+  "homepage": "https://github.com/chopmob-cloud/algovoi-rfc9421-verifier",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chopmob-cloud/algovoi-rfc9421-verifier.git",
+    "directory": "typescript"
+  },
+  "bugs": {
+    "url": "https://github.com/chopmob-cloud/algovoi-rfc9421-verifier/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "AlgoVoi <chopmob@gmail.com>",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@noble/ed25519": "^2.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "rimraf": "^5.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/content-digest.ts

@@ -0,0 +1,97 @@
+/**
+ * RFC 9530 Content-Digest field implementation.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.content_digest module.
+ */
+
+import { createHash } from "node:crypto";
+
+export class ContentDigestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ContentDigestError";
+  }
+}
+
+const DIGEST_ENTRY_RE = /([a-z0-9-]+)=:([A-Za-z0-9+/=]+):/g;
+
+const SUPPORTED_ALGOS: Record<string, string> = {
+  "sha-256": "sha256",
+  "sha-512": "sha512",
+};
+
+function bodyBytes(body: Uint8Array | Buffer | string): Buffer {
+  if (typeof body === "string") return Buffer.from(body, "utf-8");
+  if (Buffer.isBuffer(body)) return body;
+  return Buffer.from(body);
+}
+
+export function computeContentDigest(
+  body: Uint8Array | Buffer | string,
+  algorithm: string = "sha-256",
+): string {
+  const algoLower = algorithm.toLowerCase();
+  const nodeAlgo = SUPPORTED_ALGOS[algoLower];
+  if (!nodeAlgo) {
+    throw new ContentDigestError(
+      `unsupported algorithm ${JSON.stringify(algorithm)}; supported: ${Object.keys(SUPPORTED_ALGOS)}`,
+    );
+  }
+  const hash = createHash(nodeAlgo).update(bodyBytes(body)).digest("base64");
+  return `${algoLower}=:${hash}:`;
+}
+
+export function verifyContentDigest(
+  body: Uint8Array | Buffer | string,
+  headerValue: string,
+  requireAlgorithm?: string,
+): boolean {
+  if (typeof headerValue !== "string") {
+    throw new ContentDigestError(
+      `header must be string, got ${typeof headerValue}`,
+    );
+  }
+  const entries: Array<[string, string]> = [];
+  const localRe = new RegExp(DIGEST_ENTRY_RE.source, "g");
+  let m: RegExpExecArray | null;
+  while ((m = localRe.exec(headerValue)) !== null) {
+    entries.push([m[1], m[2]]);
+  }
+  if (entries.length === 0) {
+    throw new ContentDigestError(
+      `no valid digest entries in header: ${JSON.stringify(headerValue)}`,
+    );
+  }
+
+  const reqAlg = requireAlgorithm?.toLowerCase();
+  let requiredSeen = false;
+
+  for (const [algo, digestB64] of entries) {
+    const algoLower = algo.toLowerCase();
+    const nodeAlgo = SUPPORTED_ALGOS[algoLower];
+    if (!nodeAlgo) continue;
+    if (reqAlg && algoLower === reqAlg) requiredSeen = true;
+
+    let expected: Buffer;
+    try {
+      expected = Buffer.from(digestB64, "base64");
+    } catch (e) {
+      throw new ContentDigestError(
+        `digest entry ${algoLower} is not valid base64: ${(e as Error).message}`,
+      );
+    }
+    const actual = createHash(nodeAlgo).update(bodyBytes(body)).digest();
+    if (!expected.equals(actual)) {
+      throw new ContentDigestError(
+        `digest mismatch on ${algoLower}: header claims ${digestB64} but body hashes to ${actual.toString("base64")}`,
+      );
+    }
+  }
+
+  if (reqAlg && !requiredSeen) {
+    throw new ContentDigestError(
+      `required algorithm ${reqAlg} not present in header`,
+    );
+  }
+  return true;
+}

package/src/index.ts

@@ -0,0 +1,38 @@
+/**
+ * @algovoi/rfc9421-verifier
+ *
+ * AlgoVoi RFC 9421 HTTP Message Signatures + RFC 9530 Content-Digest
+ * reference verifier (TypeScript). Byte-for-byte parity with the
+ * Python sibling `algovoi-rfc9421-verifier` on PyPI.
+ *
+ * Apache 2.0. Companion to IETF Internet-Draft
+ * draft-hopley-x402-compliance-receipt-00.
+ */
+
+export {
+  SignatureInputParseError,
+  parseSignatureInput,
+  parseSignatureValue,
+  type ParsedSignatureInput,
+} from "./parse.js";
+
+export {
+  SigningBaseError,
+  buildSigningBase,
+  type SigningBaseInput,
+} from "./signing-base.js";
+
+export {
+  ContentDigestError,
+  computeContentDigest,
+  verifyContentDigest,
+} from "./content-digest.js";
+
+export {
+  VerifyError,
+  verifySignature,
+  verifyRequest,
+  type VerifyResult,
+  type VerifyRequestInput,
+  type PublicKey,
+} from "./verify.js";

package/src/parse.ts

@@ -0,0 +1,135 @@
+/**
+ * RFC 9421 Signature-Input and Signature header parsers.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.parse module.
+ */
+
+export class SignatureInputParseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SignatureInputParseError";
+  }
+}
+
+export interface ParsedSignatureInput {
+  label: string;
+  covered_components: string[];
+  parameters: Record<string, string | number>;
+  raw: string;
+}
+
+const LABEL_RE = /^\s*([A-Za-z][A-Za-z0-9_-]*)\s*=\s*/;
+const COVERED_RE = /\(\s*(?:"[^"]*"\s*)*\)/;
+const QUOTED_RE = /"([^"]*)"/g;
+const PARAM_RE = /([A-Za-z][A-Za-z0-9_-]*)=([^;,\s]+|"[^"]*")/g;
+
+export function parseSignatureInput(headerValue: string): ParsedSignatureInput {
+  if (typeof headerValue !== "string") {
+    throw new SignatureInputParseError(
+      `header must be string, got ${typeof headerValue}`,
+    );
+  }
+  const trimmed = headerValue.trim();
+  if (trimmed.length === 0) {
+    throw new SignatureInputParseError("empty header value");
+  }
+
+  let label: string;
+  let rest: string;
+
+  const labelMatch = LABEL_RE.exec(trimmed);
+  if (labelMatch) {
+    label = labelMatch[1];
+    rest = trimmed.slice(labelMatch[0].length);
+  } else if (trimmed.startsWith("(")) {
+    label = "";
+    rest = trimmed;
+  } else {
+    throw new SignatureInputParseError(
+      `no label or covered-components list found at start: ${JSON.stringify(trimmed.slice(0, 40))}`,
+    );
+  }
+
+  const coveredMatch = COVERED_RE.exec(rest);
+  if (!coveredMatch) {
+    throw new SignatureInputParseError("no covered-components list found");
+  }
+  const coveredRaw = coveredMatch[0];
+  const covered: string[] = [];
+  let qm: RegExpExecArray | null;
+  const localQuoted = /"([^"]*)"/g;
+  while ((qm = localQuoted.exec(coveredRaw)) !== null) {
+    covered.push(qm[1]);
+  }
+  rest = rest.slice(coveredMatch.index + coveredRaw.length);
+
+  const parameters: Record<string, string | number> = {};
+  const localParam = new RegExp(PARAM_RE.source, "g");
+  let pm: RegExpExecArray | null;
+  while ((pm = localParam.exec(rest)) !== null) {
+    const key = pm[1];
+    const raw = pm[2];
+    if (raw.startsWith('"') && raw.endsWith('"')) {
+      parameters[key] = raw.slice(1, -1);
+    } else if (/^-?\d+$/.test(raw)) {
+      parameters[key] = parseInt(raw, 10);
+    } else {
+      parameters[key] = raw;
+    }
+  }
+
+  return {
+    label,
+    covered_components: covered,
+    parameters,
+    raw: trimmed,
+  };
+}
+
+export function parseSignatureValue(headerValue: string): {
+  label: string;
+  signature: Uint8Array;
+} {
+  if (typeof headerValue !== "string") {
+    throw new SignatureInputParseError(
+      `header must be string, got ${typeof headerValue}`,
+    );
+  }
+  const trimmed = headerValue.trim();
+  if (trimmed.length === 0) {
+    throw new SignatureInputParseError("empty Signature header value");
+  }
+
+  let label: string;
+  let rest: string;
+
+  const labelMatch = LABEL_RE.exec(trimmed);
+  if (labelMatch) {
+    label = labelMatch[1];
+    rest = trimmed.slice(labelMatch[0].length).trim();
+  } else if (trimmed.startsWith(":")) {
+    label = "";
+    rest = trimmed;
+  } else {
+    throw new SignatureInputParseError(
+      `no label or signature-value prefix found at start: ${JSON.stringify(trimmed.slice(0, 40))}`,
+    );
+  }
+
+  if (!rest.startsWith(":") || !rest.endsWith(":")) {
+    throw new SignatureInputParseError(
+      "signature value must be wrapped in colons (RFC 8941 byte-sequence form)",
+    );
+  }
+
+  const sigB64 = rest.slice(1, -1);
+  let sigBytes: Uint8Array;
+  try {
+    sigBytes = new Uint8Array(Buffer.from(sigB64, "base64"));
+  } catch (e) {
+    throw new SignatureInputParseError(
+      `signature value is not valid base64: ${(e as Error).message}`,
+    );
+  }
+  return { label, signature: sigBytes };
+}

package/src/signing-base.ts

@@ -0,0 +1,100 @@
+/**
+ * RFC 9421 Section 2.5 signing-base construction.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.signing_base module.
+ */
+
+export class SigningBaseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "SigningBaseError";
+  }
+}
+
+export interface SigningBaseInput {
+  coveredComponents: string[];
+  method?: string;
+  authority?: string;
+  path?: string;
+  targetUri?: string;
+  scheme?: string;
+  status?: number;
+  headers?: Record<string, string>;
+  parameters?: Record<string, string | number>;
+}
+
+export function buildSigningBase(input: SigningBaseInput): string {
+  const normHeaders: Record<string, string> = {};
+  for (const [k, v] of Object.entries(input.headers ?? {})) {
+    normHeaders[k.toLowerCase()] = v;
+  }
+  const parameters = input.parameters ?? {};
+  const lines: string[] = [];
+
+  for (const component of input.coveredComponents) {
+    const c = component.toLowerCase();
+    let value: string;
+
+    switch (c) {
+      case "@method":
+        if (input.method === undefined)
+          throw new SigningBaseError("@method covered but method not supplied");
+        value = input.method.toLowerCase();
+        break;
+      case "@authority":
+        if (input.authority === undefined)
+          throw new SigningBaseError("@authority covered but authority not supplied");
+        value = input.authority.toLowerCase();
+        break;
+      case "@path":
+        if (input.path === undefined)
+          throw new SigningBaseError("@path covered but path not supplied");
+        value = input.path;
+        break;
+      case "@target-uri":
+        if (input.targetUri === undefined)
+          throw new SigningBaseError("@target-uri covered but targetUri not supplied");
+        value = input.targetUri;
+        break;
+      case "@scheme":
+        if (input.scheme === undefined)
+          throw new SigningBaseError("@scheme covered but scheme not supplied");
+        value = input.scheme.toLowerCase();
+        break;
+      case "@status":
+        if (input.status === undefined)
+          throw new SigningBaseError("@status covered but status not supplied");
+        value = String(input.status);
+        break;
+      case "created":
+        if (!("created" in parameters))
+          throw new SigningBaseError(
+            "'created' covered but no 'created' parameter in Signature-Input",
+          );
+        value = String(parameters["created"]);
+        break;
+      case "expires":
+        if (!("expires" in parameters))
+          throw new SigningBaseError(
+            "'expires' covered but no 'expires' parameter in Signature-Input",
+          );
+        value = String(parameters["expires"]);
+        break;
+      default:
+        if (c.startsWith("@")) {
+          throw new SigningBaseError(`unsupported derived component: ${component}`);
+        }
+        if (!(c in normHeaders)) {
+          throw new SigningBaseError(
+            `covered header ${JSON.stringify(component)} not present in supplied headers`,
+          );
+        }
+        value = normHeaders[c];
+        break;
+    }
+
+    lines.push(`"${c}": ${value}`);
+  }
+
+  return lines.join("\n");
+}

package/src/verify.ts

@@ -0,0 +1,238 @@
+/**
+ * RFC 9421 + RFC 9530 verification top-level.
+ *
+ * Mirror of the Python algovoi_rfc9421_verifier.verify module.
+ * Uses @noble/ed25519 for Ed25519 verification.
+ */
+
+import * as ed25519 from "@noble/ed25519";
+
+import {
+  parseSignatureInput,
+  parseSignatureValue,
+  SignatureInputParseError,
+} from "./parse.js";
+import {
+  buildSigningBase,
+  SigningBaseError,
+} from "./signing-base.js";
+import {
+  verifyContentDigest,
+  ContentDigestError,
+} from "./content-digest.js";
+
+export class VerifyError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "VerifyError";
+  }
+}
+
+export type PublicKey = string | Uint8Array;
+
+export interface VerifyResult {
+  valid: boolean;
+  signature_valid: boolean;
+  content_digest_valid: boolean;
+  signing_base: string;
+  covered_components: string[];
+  parameters: Record<string, string | number>;
+  label: string;
+  errors: string[];
+}
+
+export interface VerifyRequestInput {
+  method: string;
+  authority: string;
+  path: string;
+  headers: Record<string, string>;
+  body: Uint8Array | Buffer | string;
+  publicKey: PublicKey;
+  scheme?: string;
+  requireContentDigest?: boolean;
+  requireAlgorithm?: string;
+}
+
+function newResult(): VerifyResult {
+  return {
+    valid: false,
+    signature_valid: false,
+    content_digest_valid: false,
+    signing_base: "",
+    covered_components: [],
+    parameters: {},
+    label: "",
+    errors: [],
+  };
+}
+
+function fail(result: VerifyResult, msg: string): VerifyResult {
+  result.errors.push(msg);
+  result.valid = false;
+  return result;
+}
+
+function publicKeyBytes(pk: PublicKey): Uint8Array {
+  if (pk instanceof Uint8Array) {
+    if (pk.length !== 32) {
+      throw new VerifyError(
+        `Ed25519 public key must be 32 bytes, got ${pk.length}`,
+      );
+    }
+    return pk;
+  }
+  if (typeof pk === "string") {
+    const hex = pk.startsWith("0x") ? pk.slice(2) : pk;
+    if (!/^[0-9a-fA-F]+$/.test(hex)) {
+      throw new VerifyError("public key hex is invalid");
+    }
+    if (hex.length !== 64) {
+      throw new VerifyError(
+        `Ed25519 public key hex must decode to 32 bytes (64 hex chars), got ${hex.length}`,
+      );
+    }
+    const bytes = new Uint8Array(32);
+    for (let i = 0; i < 32; i++) {
+      bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  throw new VerifyError("publicKey must be Uint8Array or hex string");
+}
+
+export async function verifySignature(
+  signingBase: string,
+  signatureBytes: Uint8Array,
+  publicKey: PublicKey,
+  algorithm: string = "ed25519",
+): Promise<boolean> {
+  if (algorithm.toLowerCase() !== "ed25519") {
+    throw new VerifyError(`v0.1.0 supports ed25519 only; got ${algorithm}`);
+  }
+  if (signatureBytes.length !== 64) {
+    throw new VerifyError(
+      `Ed25519 signature must be 64 bytes, got ${signatureBytes.length}`,
+    );
+  }
+  const pkBytes = publicKeyBytes(publicKey);
+  const messageBytes = new TextEncoder().encode(signingBase);
+  try {
+    return await ed25519.verifyAsync(signatureBytes, messageBytes, pkBytes);
+  } catch {
+    return false;
+  }
+}
+
+export async function verifyRequest(
+  input: VerifyRequestInput,
+): Promise<VerifyResult> {
+  const result = newResult();
+
+  const normHeaders: Record<string, string> = {};
+  for (const [k, v] of Object.entries(input.headers)) {
+    normHeaders[k.toLowerCase()] = v;
+  }
+
+  const siValue = normHeaders["signature-input"];
+  if (!siValue) return fail(result, "Signature-Input header missing");
+  const sValue = normHeaders["signature"];
+  if (!sValue) return fail(result, "Signature header missing");
+
+  let parsedSi;
+  try {
+    parsedSi = parseSignatureInput(siValue);
+  } catch (e) {
+    if (e instanceof SignatureInputParseError) {
+      return fail(result, `Signature-Input parse error: ${e.message}`);
+    }
+    throw e;
+  }
+  result.label = parsedSi.label;
+  result.covered_components = parsedSi.covered_components;
+  result.parameters = parsedSi.parameters;
+
+  let sigParsed;
+  try {
+    sigParsed = parseSignatureValue(sValue);
+  } catch (e) {
+    if (e instanceof SignatureInputParseError) {
+      return fail(result, `Signature parse error: ${e.message}`);
+    }
+    throw e;
+  }
+
+  if (
+    sigParsed.label &&
+    parsedSi.label &&
+    sigParsed.label !== parsedSi.label
+  ) {
+    return fail(
+      result,
+      `Signature label ${sigParsed.label} does not match Signature-Input label ${parsedSi.label}`,
+    );
+  }
+
+  const requireCd = input.requireContentDigest ?? true;
+  const requireAlg = input.requireAlgorithm ?? "sha-256";
+
+  if (requireCd) {
+    const cdHeader = normHeaders["content-digest"];
+    if (!cdHeader)
+      return fail(result, "Content-Digest header required but missing");
+    try {
+      verifyContentDigest(input.body, cdHeader, requireAlg);
+      result.content_digest_valid = true;
+    } catch (e) {
+      if (e instanceof ContentDigestError) {
+        return fail(result, `Content-Digest verification failed: ${e.message}`);
+      }
+      throw e;
+    }
+  } else {
+    result.content_digest_valid = true;
+  }
+
+  let signingBase: string;
+  try {
+    signingBase = buildSigningBase({
+      coveredComponents: parsedSi.covered_components,
+      method: input.method,
+      authority: input.authority,
+      path: input.path,
+      scheme: input.scheme ?? "https",
+      headers: normHeaders,
+      parameters: parsedSi.parameters,
+    });
+  } catch (e) {
+    if (e instanceof SigningBaseError) {
+      return fail(result, `Signing-base build error: ${e.message}`);
+    }
+    throw e;
+  }
+  result.signing_base = signingBase;
+
+  const alg = parsedSi.parameters["alg"];
+  const algStr = typeof alg === "string" ? alg : "ed25519";
+
+  let sigOk: boolean;
+  try {
+    sigOk = await verifySignature(
+      signingBase,
+      sigParsed.signature,
+      input.publicKey,
+      algStr,
+    );
+  } catch (e) {
+    if (e instanceof VerifyError) {
+      return fail(result, `Signature verification setup error: ${e.message}`);
+    }
+    throw e;
+  }
+
+  if (!sigOk) {
+    return fail(result, "Ed25519 signature does not verify against signing base");
+  }
+  result.signature_valid = true;
+  result.valid = result.signature_valid && result.content_digest_valid;
+  return result;
+}