@sphereon/ssi-sdk.wellknown-did-verifier/dist/index.cjs

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// plugin.schema.json
var require_plugin_schema = __commonJS({
  "plugin.schema.json"(exports, module2) {
    module2.exports = {
      IWellKnownDidVerifier: {
        components: {
          schemas: {
            IVerifyDomainLinkageArgs: {
              type: "object",
              properties: {
                didUrl: {
                  type: "string"
                },
                signatureVerification: {
                  type: "string"
                },
                onlyVerifyServiceDids: {
                  type: "boolean"
                },
                additionalProperties: false
              },
              required: ["didUrl", "signatureVerification"],
              description: "Arguments needed for {@link IWellKnownDidVerifier.verifyDomainLinkage } "
            }
          },
          methods: {
            verifyDomainLinkage: {
              description: "Verifies the relationship between the controller of an origin and a DID",
              arguments: {
                $ref: "#/components/schemas/IVerifyDomainLinkageArgs"
              },
              returnType: "object"
            }
          }
        }
      }
    };
  }
});

// src/index.ts
var index_exports = {};
__export(index_exports, {
  WellKnownDidVerifier: () => WellKnownDidVerifier,
  schema: () => schema
});
module.exports = __toCommonJS(index_exports);

// src/agent/WellKnownDidVerifier.ts
var import_wellknown_dids_client = require("@sphereon/wellknown-dids-client");
var WellKnownDidVerifier = class {
  static {
    __name(this, "WellKnownDidVerifier");
  }
  schema = schema.IWellKnownDidVerifier;
  methods = {
    registerSignatureVerification: this.registerSignatureVerification.bind(this),
    removeSignatureVerification: this.removeSignatureVerification.bind(this),
    verifyDomainLinkage: this.verifyDomainLinkage.bind(this),
    verifyDidConfigurationResource: this.verifyDidConfigurationResource.bind(this)
  };
  signatureVerifications;
  onlyVerifyServiceDids;
  constructor(args) {
    this.signatureVerifications = args && args.signatureVerifications || {};
    this.onlyVerifyServiceDids = args && args.onlyVerifyServiceDids || false;
  }
  /** {@inheritDoc IWellKnownDidVerifier.registerSignatureVerification} */
  async registerSignatureVerification(args, context) {
    if (this.signatureVerifications[args.callbackName] !== void 0) {
      return Promise.reject(new Error(`Signature validation with key: ${args.callbackName} already present`));
    }
    this.signatureVerifications[args.callbackName] = args.signatureVerification;
  }
  /** {@inheritDoc IWellKnownDidVerifier.removeSignatureVerification} */
  async removeSignatureVerification(args, context) {
    return delete this.signatureVerifications[args.callbackName];
  }
  /** {@inheritDoc IWellKnownDidVerifier.verifyDomainLinkage} */
  async verifyDomainLinkage(args, context) {
    const signatureVerification = typeof args.signatureVerification === "string" ? await 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 import_wellknown_dids_client.WellKnownDidVerifier().verifyDomainLinkage({
        didDocument: didResolutionResult.didDocument,
        verifySignatureCallback: signatureVerification,
        onlyVerifyServiceDid: args.onlyVerifyServiceDids || this.onlyVerifyServiceDids
      });
    });
  }
  /** {@inheritDoc IWellKnownDidVerifier.verifyDidConfigurationResource} */
  async verifyDidConfigurationResource(args, context) {
    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" ? await this.getSignatureVerification(args.signatureVerification) : args.signatureVerification;
    return new import_wellknown_dids_client.WellKnownDidVerifier().verifyResource({
      verifySignatureCallback: signatureVerification,
      configuration: args.configuration,
      origin: args.origin,
      did: args.did
    });
  }
  async getSignatureVerification(key) {
    if (this.signatureVerifications[key] === void 0) {
      return Promise.reject(new Error(`Signature validation not found for key: ${key}`));
    }
    return this.signatureVerifications[key];
  }
};

// src/index.ts
var schema = require_plugin_schema();
//# sourceMappingURL=index.cjs.map