jsonld-signatures-merkleproof2019/lib/esm/inspectors/computeLocalHash.js

A jsonld signature implementation to support MerkleProof2019 verification in Verifiable Credential context

import jsonld from 'jsonld';
import { sha256 } from '@noble/hashes/sha2.js';
import { Buffer } from 'buffer';
import preloadedContexts from '../constants/contexts/preloadedContexts.js';
import { toUTF8Data } from '../utils/data.js';
import { isObject } from '../utils/object.js';
import VerifierError from '../models/VerifierError.js';
import getText from '../helpers/getText.js';
export function getUnmappedFields(normalized) {
    const normalizedArray = normalized.split('\n');
    const myRegexp = /<http:\/\/fallback\.org\/(.*)>/;
    const matches = normalizedArray
        .map(normalizedString => myRegexp.exec(normalizedString))
        .filter(match => match != null);
    if (matches.length > 0) {
        const unmappedFields = matches.map(match => match[1]).sort(); // only return name of unmapped key
        return Array.from(new Set(unmappedFields)); // dedup
    }
    return null;
}
export default async function computeLocalHash(document, targetProof = null, documentLoader = async (url) => Promise) {
    // the previous implementation was using a reference of @context, thus always adding @vocab to @context,
    // thus passing the information down to jsonld regardless of the configuration option. We explicitly do that now,
    // since we want to make sure unmapped fields are detected.
    if (!document['@context'].find((context) => isObject(context) && '@vocab' in context)) {
        document['@context'].push({ '@vocab': 'http://fallback.org/' });
    }
    const theDocument = JSON.parse(JSON.stringify(document));
    if (!Array.isArray(theDocument.proof)) {
        // compute the document as it was signed, so without proof
        delete theDocument.proof;
    }
    else {
        if (!targetProof) {
            throw new VerifierError('computeLocalHash', getText('errors', 'noProofSpecified'));
        }
        const proofIndex = theDocument.proof.findIndex(proof => proof.proofValue === targetProof.proofValue);
        theDocument.proof = theDocument.proof.slice(0, proofIndex);
    }
    const customLoader = async function (url) {
        if (documentLoader != null) {
            await documentLoader(url);
        }
        if (url in preloadedContexts) {
            return {
                contextUrl: null,
                document: preloadedContexts[url],
                documentUrl: url
            };
        }
        return jsonld.documentLoader(url);
    };
    const normalizeArgs = {
        algorithm: 'URDNA2015',
        format: 'application/nquads',
        documentLoader: customLoader,
        safe: false
    };
    let normalizedDocument;
    try {
        normalizedDocument = await jsonld.normalize(theDocument, normalizeArgs);
    }
    catch (e) {
        console.error(e);
        throw new VerifierError('computeLocalHash', getText('errors', 'failedJsonLdNormalization'));
    }
    const unmappedFields = getUnmappedFields(normalizedDocument);
    if (unmappedFields) {
        throw new VerifierError('computeLocalHash', `${getText('errors', 'foundUnmappedFields')}: ${unmappedFields.join(', ')}`);
    }
    else {
        return Buffer.from(sha256(Uint8Array.from(toUTF8Data(normalizedDocument)))).toString('hex');
    }
}