@sphereon/ssi-sdk.wellknown-did-verifier/dist/agent/WellKnownDidVerifier.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.WellKnownDidVerifier = void 0;
const wellknown_dids_client_1 = require("@sphereon/wellknown-dids-client");
const index_1 = require("../index");
/**
 * {@inheritDoc IWellKnownDidVerifier}
 */
class WellKnownDidVerifier {
    constructor(args) {
        this.schema = index_1.schema.IWellKnownDidVerifier;
        this.methods = {
            registerSignatureVerification: this.registerSignatureVerification.bind(this),
            removeSignatureVerification: this.removeSignatureVerification.bind(this),
            verifyDomainLinkage: this.verifyDomainLinkage.bind(this),
            verifyDidConfigurationResource: this.verifyDidConfigurationResource.bind(this),
        };
        this.signatureVerifications = (args && args.signatureVerifications) || {};
        this.onlyVerifyServiceDids = (args && args.onlyVerifyServiceDids) || false;
    }
    /** {@inheritDoc IWellKnownDidVerifier.registerSignatureVerification} */
    registerSignatureVerification(args, context) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.signatureVerifications[args.callbackName] !== undefined) {
                return Promise.reject(new Error(`Signature validation with key: ${args.callbackName} already present`));
            }
            this.signatureVerifications[args.callbackName] = args.signatureVerification;
        });
    }
    /** {@inheritDoc IWellKnownDidVerifier.removeSignatureVerification} */
    removeSignatureVerification(args, context) {
        return __awaiter(this, void 0, void 0, function* () {
            return delete this.signatureVerifications[args.callbackName];
        });
    }
    /** {@inheritDoc IWellKnownDidVerifier.verifyDomainLinkage} */
    verifyDomainLinkage(args, context) {
        return __awaiter(this, void 0, void 0, function* () {
            const signatureVerification = typeof args.signatureVerification === 'string'
                ? yield this.getSignatureVerification(args.signatureVerification)
                : args.signatureVerification;
            return context.agent.resolveDid({ didUrl: args.did }).then((didResolutionResult) => {
                if (!didResolutionResult.didDocument) {
                    return Promise.reject(Error(`Unable to resolve did: ${args.did}`));
                }
                return new wellknown_dids_client_1.WellKnownDidVerifier().verifyDomainLinkage({
                    didDocument: didResolutionResult.didDocument,
                    verifySignatureCallback: signatureVerification,
                    onlyVerifyServiceDid: args.onlyVerifyServiceDids || this.onlyVerifyServiceDids,
                });
            });
        });
    }
    /** {@inheritDoc IWellKnownDidVerifier.verifyDidConfigurationResource} */
    verifyDidConfigurationResource(args, context) {
        return __awaiter(this, void 0, void 0, function* () {
            if (args.configuration && args.origin) {
                return Promise.reject(Error('Cannot supply both a DID configuration resource and an origin.'));
            }
            if (!args.configuration && !args.origin) {
                return Promise.reject(Error('No DID configuration resource or origin supplied.'));
            }
            const signatureVerification = typeof args.signatureVerification === 'string'
                ? yield this.getSignatureVerification(args.signatureVerification)
                : args.signatureVerification;
            return new wellknown_dids_client_1.WellKnownDidVerifier().verifyResource({
                verifySignatureCallback: signatureVerification,
                configuration: args.configuration,
                origin: args.origin,
                did: args.did,
            });
        });
    }
    getSignatureVerification(key) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.signatureVerifications[key] === undefined) {
                return Promise.reject(new Error(`Signature validation not found for key: ${key}`));
            }
            return this.signatureVerifications[key];
        });
    }
}
exports.WellKnownDidVerifier = WellKnownDidVerifier;
//# sourceMappingURL=WellKnownDidVerifier.js.map