@noeos/verification-engine 0.0.0

package/dist/cjs/domain/operation-result.js

@@ -0,0 +1,19 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.success = success;
+exports.failure = failure;
+const EMPTY_DIAGNOSTICS = Object.freeze([]);
+function success(value, diagnostics = []) {
+    return Object.freeze({
+        ok: true,
+        value,
+        diagnostics: diagnostics.length === 0 ? EMPTY_DIAGNOSTICS : Object.freeze([...diagnostics]),
+    });
+}
+function failure(diagnostics) {
+    return Object.freeze({
+        ok: false,
+        diagnostics: diagnostics.length === 0 ? EMPTY_DIAGNOSTICS : Object.freeze([...diagnostics]),
+    });
+}

package/dist/cjs/domain/position.js

@@ -0,0 +1,16 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Position = void 0;
+const positionBrand = Symbol("Position");
+class Position {
+    value;
+    [positionBrand] = true;
+    constructor(value) {
+        this.value = value;
+    }
+    static fromValidated(value) {
+        return Object.freeze(new Position(value));
+    }
+}
+exports.Position = Position;

package/dist/cjs/domain/protocol-version.js

@@ -0,0 +1,5 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENT_PROTOCOL_VERSION = void 0;
+exports.CURRENT_PROTOCOL_VERSION = 1;

package/dist/cjs/domain/rule.js

@@ -0,0 +1,3 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/domain/stream.js

@@ -0,0 +1,3 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/domain/version.js

@@ -0,0 +1,16 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfileVersion = void 0;
+const profileVersionBrand = Symbol("ProfileVersion");
+class ProfileVersion {
+    value;
+    [profileVersionBrand] = true;
+    constructor(value) {
+        this.value = value;
+    }
+    static fromValidated(value) {
+        return Object.freeze(new ProfileVersion(value));
+    }
+}
+exports.ProfileVersion = ProfileVersion;

package/dist/cjs/evidence/digest-evidence.js

@@ -0,0 +1,22 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digestEvidence = digestEvidence;
+const frame_builders_js_1 = require("../framing/frame-builders.js");
+const hash_frame_js_1 = require("../hashing/hash-frame.js");
+const jcs_profile_js_1 = require("../normalization/jcs-profile.js");
+const normalize_js_1 = require("../normalization/normalize.js");
+const evidence_parser_js_1 = require("./evidence-parser.js");
+function digestEvidence(value, limits) {
+    const evidence = (0, evidence_parser_js_1.parseEvidence)(value, limits);
+    if (!evidence.ok)
+        return evidence;
+    const normalized = (0, normalize_js_1.normalizeToBytes)(jcs_profile_js_1.jcsProfile, evidence.value, limits);
+    if (!normalized.ok)
+        return normalized;
+    return (0, hash_frame_js_1.hashTrustedFrame)(evidence.value.algorithm, (0, frame_builders_js_1.buildTrustedEvidenceFrame)({
+        algorithm: evidence.value.algorithm,
+        schemaUrn: evidence.value.$schema,
+        evidenceJcsBytes: normalized.value.bytes,
+    }, limits));
+}

package/dist/cjs/evidence/evidence-parser.js

@@ -0,0 +1,288 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEvidence = parseEvidence;
+exports.parseEvidenceText = parseEvidenceText;
+exports.parseRecordEvidence = parseRecordEvidence;
+exports.parseLinkEvidence = parseLinkEvidence;
+exports.parseChainSummaryEvidence = parseChainSummaryEvidence;
+const evidence_js_1 = require("../domain/evidence.js");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const algorithm_validation_js_1 = require("../validation/algorithm-validation.js");
+const diagnostic_collector_js_1 = require("../validation/diagnostic-collector.js");
+const digest_validation_js_1 = require("../validation/digest-validation.js");
+const identifier_validation_js_1 = require("../validation/identifier-validation.js");
+const json_text_parser_js_1 = require("../validation/json-text-parser.js");
+const object_inspection_js_1 = require("../validation/object-inspection.js");
+const position_validation_js_1 = require("../validation/position-validation.js");
+const version_validation_js_1 = require("../validation/version-validation.js");
+const record_service_js_1 = require("../records/record-service.js");
+function parseEvidence(value, limits) {
+    const entries = (0, object_inspection_js_1.inspectPlainObject)(value);
+    if (entries === undefined)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const schema = new Map(entries).get("$schema");
+    if (schema === evidence_js_1.RECORD_EVIDENCE_SCHEMA)
+        return parseRecordEvidence(value, limits);
+    if (schema === evidence_js_1.LINK_EVIDENCE_SCHEMA)
+        return parseLinkEvidence(value, limits);
+    if (schema === evidence_js_1.CHAIN_SUMMARY_EVIDENCE_SCHEMA)
+        return parseChainSummaryEvidence(value, limits);
+    return evidenceFailure("EVIDENCE_SCHEMA_UNKNOWN", limits);
+}
+function parseEvidenceText(value, limits) {
+    const parsed = (0, json_text_parser_js_1.parseJsonText)(value, limits);
+    if (!parsed.ok)
+        return parsed;
+    return parseEvidence(parsed.value, limits);
+}
+function parseRecordEvidence(value, limits) {
+    const fields = strictFields(value, [
+        "$schema",
+        "protocolVersion",
+        "contextId",
+        "recordId",
+        "profile",
+        "algorithm",
+        "normalizedByteLength",
+        "contentDigest",
+        "recordDigest",
+    ]);
+    if (fields?.get("$schema") !== evidence_js_1.RECORD_EVIDENCE_SCHEMA) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    const common = parseRecordFields(fields, limits);
+    if (!common.ok)
+        return common;
+    return (0, operation_result_js_1.success)(Object.freeze({ $schema: evidence_js_1.RECORD_EVIDENCE_SCHEMA, ...common.value }));
+}
+function parseLinkEvidence(value, limits) {
+    const fields = strictFields(value, [
+        "$schema",
+        "protocolVersion",
+        "contextId",
+        "sequenceId",
+        "position",
+        "recordId",
+        "profile",
+        "algorithm",
+        "normalizedByteLength",
+        "contentDigest",
+        "recordDigest",
+        "previous",
+        "linkDigest",
+    ]);
+    if (fields?.get("$schema") !== evidence_js_1.LINK_EVIDENCE_SCHEMA) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    const common = parseRecordFields(fields, limits);
+    const sequenceId = (0, identifier_validation_js_1.validateSequenceId)(fields.get("sequenceId"));
+    const position = (0, position_validation_js_1.validatePosition)(fields.get("position"));
+    if (!common.ok)
+        return common;
+    if (!sequenceId.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    if (!position.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const previous = parsePrevious(fields.get("previous"), common.value.algorithm, limits);
+    const linkDigest = (0, digest_validation_js_1.validateDigest)(fields.get("linkDigest"), common.value.algorithm);
+    if (!previous.ok || !linkDigest.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    if ((position.value.value === 0) !== (previous.value.kind === "none")) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    return (0, operation_result_js_1.success)(Object.freeze({
+        $schema: evidence_js_1.LINK_EVIDENCE_SCHEMA,
+        ...common.value,
+        sequenceId: sequenceId.value.value,
+        position: position.value.value,
+        previous: previous.value,
+        linkDigest: linkDigest.value.toHex(),
+    }));
+}
+function parseChainSummaryEvidence(value, limits) {
+    const fields = strictFields(value, [
+        "$schema",
+        "protocolVersion",
+        "contextId",
+        "sequenceId",
+        "profile",
+        "algorithm",
+        "count",
+        "firstPosition",
+        "lastPosition",
+        "firstLinkDigest",
+        "finalLinkDigest",
+        "boundaries",
+        "status",
+        "diagnostics",
+    ], true);
+    if (fields?.get("$schema") !== evidence_js_1.CHAIN_SUMMARY_EVIDENCE_SCHEMA) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    const protocol = (0, version_validation_js_1.validateProtocolVersion)(fields.get("protocolVersion"));
+    const contextId = (0, identifier_validation_js_1.validateContextId)(fields.get("contextId"));
+    const sequenceId = (0, identifier_validation_js_1.validateSequenceId)(fields.get("sequenceId"));
+    const profile = (0, record_service_js_1.validateProfile)(fields.get("profile"), limits);
+    const algorithm = (0, algorithm_validation_js_1.validateAlgorithmId)(fields.get("algorithm"));
+    const count = validateNonNegativeSafeInteger(fields.get("count"));
+    const boundaries = parseBoundaries(fields.get("boundaries"));
+    const status = fields.get("status");
+    const diagnostics = parseDiagnosticSummary(fields.get("diagnostics"));
+    if (!protocol.ok ||
+        !contextId.ok ||
+        !sequenceId.ok ||
+        !profile.ok ||
+        !algorithm.ok ||
+        count === undefined ||
+        boundaries === undefined ||
+        !isStatus(status) ||
+        diagnostics === undefined) {
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    }
+    if (count === 0) {
+        if (fields.has("firstPosition") ||
+            fields.has("lastPosition") ||
+            fields.has("firstLinkDigest") ||
+            fields.has("finalLinkDigest"))
+            return evidenceFailure("EVIDENCE_INVALID", limits);
+        return (0, operation_result_js_1.success)(Object.freeze({
+            $schema: evidence_js_1.CHAIN_SUMMARY_EVIDENCE_SCHEMA,
+            protocolVersion: 1,
+            contextId: contextId.value.value,
+            sequenceId: sequenceId.value.value,
+            profile: profile.value,
+            algorithm: algorithm.value,
+            count,
+            boundaries,
+            status,
+            diagnostics,
+        }));
+    }
+    if (!fields.has("firstPosition") ||
+        !fields.has("lastPosition") ||
+        !fields.has("firstLinkDigest") ||
+        !fields.has("finalLinkDigest"))
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const firstPosition = validateNonNegativeSafeInteger(fields.get("firstPosition"));
+    const lastPosition = validateNonNegativeSafeInteger(fields.get("lastPosition"));
+    const firstDigest = (0, digest_validation_js_1.validateDigest)(fields.get("firstLinkDigest"), algorithm.value);
+    const finalDigest = (0, digest_validation_js_1.validateDigest)(fields.get("finalLinkDigest"), algorithm.value);
+    if (firstPosition === undefined ||
+        lastPosition === undefined ||
+        firstPosition > lastPosition ||
+        !firstDigest.ok ||
+        !finalDigest.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    return (0, operation_result_js_1.success)(Object.freeze({
+        $schema: evidence_js_1.CHAIN_SUMMARY_EVIDENCE_SCHEMA,
+        protocolVersion: 1,
+        contextId: contextId.value.value,
+        sequenceId: sequenceId.value.value,
+        profile: profile.value,
+        algorithm: algorithm.value,
+        count,
+        firstPosition,
+        lastPosition,
+        firstLinkDigest: firstDigest.value.toHex(),
+        finalLinkDigest: finalDigest.value.toHex(),
+        boundaries,
+        status,
+        diagnostics,
+    }));
+}
+function parseRecordFields(fields, limits) {
+    const protocol = (0, version_validation_js_1.validateProtocolVersion)(fields.get("protocolVersion"));
+    const contextId = (0, identifier_validation_js_1.validateContextId)(fields.get("contextId"));
+    const recordId = (0, identifier_validation_js_1.validateRecordId)(fields.get("recordId"));
+    const profile = (0, record_service_js_1.validateProfile)(fields.get("profile"), limits);
+    const algorithm = (0, algorithm_validation_js_1.validateAlgorithmId)(fields.get("algorithm"));
+    const normalizedByteLength = validateNonNegativeSafeInteger(fields.get("normalizedByteLength"));
+    if (!protocol.ok ||
+        !contextId.ok ||
+        !recordId.ok ||
+        !profile.ok ||
+        !algorithm.ok ||
+        normalizedByteLength === undefined)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const contentDigest = (0, digest_validation_js_1.validateDigest)(fields.get("contentDigest"), algorithm.value);
+    const recordDigest = (0, digest_validation_js_1.validateDigest)(fields.get("recordDigest"), algorithm.value);
+    if (!contentDigest.ok || !recordDigest.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    return (0, operation_result_js_1.success)(Object.freeze({
+        protocolVersion: 1,
+        contextId: contextId.value.value,
+        recordId: recordId.value.value,
+        profile: profile.value,
+        algorithm: algorithm.value,
+        normalizedByteLength,
+        contentDigest: contentDigest.value.toHex(),
+        recordDigest: recordDigest.value.toHex(),
+    }));
+}
+function parsePrevious(value, algorithm, limits) {
+    const fields = strictFields(value, ["kind", "value"], true);
+    if (fields === undefined)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    if (fields.get("kind") === "none" && fields.size === 1)
+        return (0, operation_result_js_1.success)(Object.freeze({ kind: "none" }));
+    if (fields.get("kind") !== "digest" || fields.size !== 2)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    const digest = (0, digest_validation_js_1.validateDigest)(fields.get("value"), algorithm);
+    if (!digest.ok)
+        return evidenceFailure("EVIDENCE_INVALID", limits);
+    return (0, operation_result_js_1.success)(Object.freeze({ kind: "digest", value: digest.value.toHex() }));
+}
+function parseBoundaries(value) {
+    const fields = strictFields(value, ["start", "end"]);
+    if (fields === undefined)
+        return undefined;
+    const start = fields.get("start");
+    const end = fields.get("end");
+    if (!isBoundary(start) || !isBoundary(end))
+        return undefined;
+    return Object.freeze({ start, end });
+}
+function parseDiagnosticSummary(value) {
+    const fields = strictFields(value, ["errors", "warnings", "info", "truncated"]);
+    if (fields === undefined)
+        return undefined;
+    const errors = validateNonNegativeSafeInteger(fields.get("errors"));
+    const warnings = validateNonNegativeSafeInteger(fields.get("warnings"));
+    const info = validateNonNegativeSafeInteger(fields.get("info"));
+    const truncated = fields.get("truncated");
+    if (errors === undefined ||
+        warnings === undefined ||
+        info === undefined ||
+        typeof truncated !== "boolean")
+        return undefined;
+    return Object.freeze({ errors, warnings, info, truncated });
+}
+function strictFields(value, keys, optional = false) {
+    const entries = (0, object_inspection_js_1.inspectPlainObject)(value);
+    if (entries === undefined)
+        return undefined;
+    const fields = new Map(entries);
+    for (const key of fields.keys())
+        if (!keys.includes(key))
+            return undefined;
+    if (!optional && fields.size !== keys.length)
+        return undefined;
+    if (optional && fields.size > keys.length)
+        return undefined;
+    return fields;
+}
+function validateNonNegativeSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function isBoundary(value) {
+    return value === "verified" || value === "unverified" || value === "not-applicable";
+}
+function isStatus(value) {
+    return (value === "valid" || value === "invalid" || value === "indeterminate" || value === "aborted");
+}
+function evidenceFailure(code, limits) {
+    const collector = new diagnostic_collector_js_1.DiagnosticCollector(limits);
+    collector.addCode(code, "input");
+    return (0, operation_result_js_1.failure)(collector.finish());
+}

package/dist/cjs/framing/frame-builders.js

@@ -0,0 +1,124 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildContentFrame = buildContentFrame;
+exports.buildRecordFrame = buildRecordFrame;
+exports.buildLinkFrame = buildLinkFrame;
+exports.buildEvidenceFrame = buildEvidenceFrame;
+exports.buildTrustedContentFrame = buildTrustedContentFrame;
+exports.buildTrustedRecordFrame = buildTrustedRecordFrame;
+exports.buildTrustedLinkFrame = buildTrustedLinkFrame;
+exports.buildTrustedEvidenceFrame = buildTrustedEvidenceFrame;
+const digest_js_1 = require("../domain/digest.js");
+const frame_encoder_js_1 = require("./frame-encoder.js");
+function buildContentFrame(input, limits) {
+    const frame = {
+        kind: "content",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.profileId },
+            { tag: 3, type: "utf8", value: input.profileVersion },
+            { tag: 4, type: "bytes", value: input.normalizedBytes },
+        ],
+    };
+    return (0, frame_encoder_js_1.encodeFrame)(frame, limits);
+}
+function buildRecordFrame(input, limits) {
+    const frame = {
+        kind: "record",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.contextId },
+            { tag: 3, type: "utf8", value: input.recordId },
+            { tag: 4, type: "utf8", value: input.profileId },
+            { tag: 5, type: "utf8", value: input.profileVersion },
+            { tag: 6, type: "uint64", value: input.normalizedByteLength },
+            { tag: 7, type: "bytes", value: input.contentDigest.toBytes() },
+        ],
+    };
+    return (0, frame_encoder_js_1.encodeFrame)(frame, limits);
+}
+function buildLinkFrame(input, limits) {
+    const previous = input.previousLinkDigest;
+    const frame = {
+        kind: "link",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.contextId },
+            { tag: 3, type: "utf8", value: input.sequenceId },
+            { tag: 4, type: "uint64", value: input.position },
+            { tag: 5, type: "utf8", value: input.recordId },
+            { tag: 6, type: "bytes", value: input.recordDigest.toBytes() },
+            previous === undefined
+                ? { tag: 7, type: "none" }
+                : { tag: 7, type: "bytes", value: previous.toBytes() },
+        ],
+    };
+    return (0, frame_encoder_js_1.encodeFrame)(frame, limits);
+}
+function buildEvidenceFrame(input, limits) {
+    const frame = {
+        kind: "evidence",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.schemaUrn },
+            { tag: 3, type: "bytes", value: input.evidenceJcsBytes },
+        ],
+    };
+    return (0, frame_encoder_js_1.encodeFrame)(frame, limits);
+}
+function buildTrustedContentFrame(input, limits) {
+    return (0, frame_encoder_js_1.encodeTrustedFrame)({
+        kind: "content",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.profileId },
+            { tag: 3, type: "utf8", value: input.profileVersion },
+            { tag: 4, type: "bytes", value: input.normalizedBytes },
+        ],
+    }, limits);
+}
+function buildTrustedRecordFrame(input, limits) {
+    return (0, frame_encoder_js_1.encodeTrustedFrame)({
+        kind: "record",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.contextId },
+            { tag: 3, type: "utf8", value: input.recordId },
+            { tag: 4, type: "utf8", value: input.profileId },
+            { tag: 5, type: "utf8", value: input.profileVersion },
+            { tag: 6, type: "uint64", value: input.normalizedByteLength },
+            { tag: 7, type: "bytes", value: (0, digest_js_1.digestBytesForTrustedFrame)(input.contentDigest) },
+        ],
+    }, limits);
+}
+function buildTrustedLinkFrame(input, limits) {
+    return (0, frame_encoder_js_1.encodeTrustedFrame)({
+        kind: "link",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.contextId },
+            { tag: 3, type: "utf8", value: input.sequenceId },
+            { tag: 4, type: "uint64", value: input.position },
+            { tag: 5, type: "utf8", value: input.recordId },
+            { tag: 6, type: "bytes", value: (0, digest_js_1.digestBytesForTrustedFrame)(input.recordDigest) },
+            input.previousLinkDigest === undefined
+                ? { tag: 7, type: "none" }
+                : {
+                    tag: 7,
+                    type: "bytes",
+                    value: (0, digest_js_1.digestBytesForTrustedFrame)(input.previousLinkDigest),
+                },
+        ],
+    }, limits);
+}
+function buildTrustedEvidenceFrame(input, limits) {
+    return (0, frame_encoder_js_1.encodeTrustedFrame)({
+        kind: "evidence",
+        fields: [
+            { tag: 1, type: "utf8", value: input.algorithm },
+            { tag: 2, type: "utf8", value: input.schemaUrn },
+            { tag: 3, type: "bytes", value: input.evidenceJcsBytes },
+        ],
+    }, limits);
+}