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

var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
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;
};

// plugin.schema.json
var require_plugin_schema = __commonJS({
  "plugin.schema.json"(exports, module) {
    module.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/agent/WellKnownDidVerifier.ts
import { WellKnownDidVerifier as Verifier } from "@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 Verifier().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 Verifier().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();
export {
  WellKnownDidVerifier,
  schema
};
//# sourceMappingURL=index.js.map