@sphereon/ssi-sdk-ext.did-provider-key/dist/index.cjs

Sphereon SSI-SDK plugin for management of did:key identifiers.

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

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

// src/SphereonKeyDidProvider.ts
var import_ssi_sdk_ext = require("@sphereon/ssi-sdk-ext.key-utils");
var import_did_manager = require("@veramo/did-manager");
var import_debug = __toESM(require("debug"), 1);
var import_multibase = __toESM(require("multibase"), 1);
var import_multicodec = __toESM(require("multicodec"), 1);
var u8a = __toESM(require("uint8arrays"), 1);
var { fromString, toString } = u8a;
var PROVIDER_NAME = "Sphereon Key DID Provider";
var debug = (0, import_debug.default)("did-provider-key");
var keyCodecs = {
  RSA: "rsa-pub",
  Ed25519: "ed25519-pub",
  X25519: "x25519-pub",
  Secp256k1: "secp256k1-pub",
  Secp256r1: "p256-pub",
  Bls12381G1: "bls12_381-g1-pub",
  Bls12381G2: "bls12_381-g2-pub"
};
var SphereonKeyDidProvider = class extends import_did_manager.AbstractIdentifierProvider {
  static {
    __name(this, "SphereonKeyDidProvider");
  }
  kms;
  constructor(options) {
    super();
    this.kms = options.defaultKms;
  }
  async createIdentifier({ kms, alias, options }, context) {
    let codecName = options?.codecName?.toUpperCase() === "EBSI" ? import_ssi_sdk_ext.JWK_JCS_PUB_NAME : options?.codecName;
    const keyType = options?.type ?? options?.key?.type ?? (codecName === import_ssi_sdk_ext.JWK_JCS_PUB_NAME ? "Secp256r1" : "Secp256k1");
    const key = await (0, import_ssi_sdk_ext.importProvidedOrGeneratedKey)({
      providerName: PROVIDER_NAME,
      // @ts-ignore
      kms: kms ?? this.kms,
      alias,
      options: {
        ...options,
        type: keyType
      }
    }, context);
    let methodSpecificId;
    const compressedPublicKeyHex = (0, import_ssi_sdk_ext.toRawCompressedHexPublicKey)(fromString(key.publicKeyHex, "hex"), key.type);
    if (codecName === import_ssi_sdk_ext.JWK_JCS_PUB_NAME) {
      const jwk = (0, import_ssi_sdk_ext.toJwk)(key.publicKeyHex, keyType, {
        use: import_ssi_sdk_ext.JwkKeyUse.Signature,
        key,
        noKidThumbprint: true
      });
      methodSpecificId = toString(import_multibase.default.encode("base58btc", import_multicodec.default.addPrefix(fromString(import_ssi_sdk_ext.JWK_JCS_PUB_PREFIX.valueOf().toString(16), "hex"), (0, import_ssi_sdk_ext.jwkJcsEncode)(jwk))));
    } else if (codecName) {
      methodSpecificId = toString(import_multibase.default.encode("base58btc", import_multicodec.default.addPrefix(codecName, fromString(compressedPublicKeyHex, "hex"))));
    } else {
      codecName = keyCodecs[keyType];
      if (codecName) {
        methodSpecificId = toString(import_multibase.default.encode("base58btc", import_multicodec.default.addPrefix(codecName, fromString(compressedPublicKeyHex, "hex")))).toString();
      }
    }
    if (!methodSpecificId) {
      throw Error(`Key type ${keyType}, codec ${codecName} is not supported currently for did:key`);
    }
    const identifier = {
      did: `did:key:${methodSpecificId}`,
      controllerKeyId: key.kid,
      keys: [
        key
      ],
      services: []
    };
    debug("Created", identifier.did);
    return identifier;
  }
  async updateIdentifier(args, context) {
    throw new Error("KeyDIDProvider updateIdentifier not supported yet.");
  }
  async deleteIdentifier(identifier, context) {
    for (const { kid } of identifier.keys) {
      await context.agent.keyManagerDelete({
        kid
      });
    }
    return true;
  }
  async addKey({ identifier, key, options }, context) {
    throw Error("KeyDIDProvider addKey not supported");
  }
  async addService({ identifier, service, options }, context) {
    throw Error("KeyDIDProvider addService not supported");
  }
  async removeKey(args, context) {
    throw Error("KeyDIDProvider removeKey not supported");
  }
  async removeService(args, context) {
    throw Error("KeyDIDProvider removeService not supported");
  }
};

// src/KeyDidResolver.ts
var import_did_resolver = require("did-resolver");
var import_ssi_sdk_ext2 = require("@sphereon/ssi-sdk-ext.did-resolver-key");
var resolveDidKey = /* @__PURE__ */ __name(async (didUrl, _parsed, _resolver, options) => {
  const resolver = new import_did_resolver.Resolver({
    ...(0, import_ssi_sdk_ext2.getResolver)()
  });
  return resolver.resolve(didUrl, options);
}, "resolveDidKey");
function getDidKeyResolver() {
  return {
    key: resolveDidKey
  };
}
__name(getDidKeyResolver, "getDidKeyResolver");
//# sourceMappingURL=index.cjs.map