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

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

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/SphereonKeyDidProvider.ts
import { importProvidedOrGeneratedKey, JWK_JCS_PUB_NAME, JWK_JCS_PUB_PREFIX, jwkJcsEncode, JwkKeyUse, toJwk, toRawCompressedHexPublicKey } from "@sphereon/ssi-sdk-ext.key-utils";
import { AbstractIdentifierProvider } from "@veramo/did-manager";
import Debug from "debug";
import Multibase from "multibase";
import Multicodec from "multicodec";
import * as u8a from "uint8arrays";
var { fromString, toString } = u8a;
var PROVIDER_NAME = "Sphereon Key DID Provider";
var debug = Debug("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 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" ? JWK_JCS_PUB_NAME : options?.codecName;
    const keyType = options?.type ?? options?.key?.type ?? (codecName === JWK_JCS_PUB_NAME ? "Secp256r1" : "Secp256k1");
    const key = await importProvidedOrGeneratedKey({
      providerName: PROVIDER_NAME,
      // @ts-ignore
      kms: kms ?? this.kms,
      alias,
      options: {
        ...options,
        type: keyType
      }
    }, context);
    let methodSpecificId;
    const compressedPublicKeyHex = toRawCompressedHexPublicKey(fromString(key.publicKeyHex, "hex"), key.type);
    if (codecName === JWK_JCS_PUB_NAME) {
      const jwk = toJwk(key.publicKeyHex, keyType, {
        use: JwkKeyUse.Signature,
        key,
        noKidThumbprint: true
      });
      methodSpecificId = toString(Multibase.encode("base58btc", Multicodec.addPrefix(fromString(JWK_JCS_PUB_PREFIX.valueOf().toString(16), "hex"), jwkJcsEncode(jwk))));
    } else if (codecName) {
      methodSpecificId = toString(Multibase.encode("base58btc", Multicodec.addPrefix(codecName, fromString(compressedPublicKeyHex, "hex"))));
    } else {
      codecName = keyCodecs[keyType];
      if (codecName) {
        methodSpecificId = toString(Multibase.encode("base58btc", Multicodec.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
import { Resolver } from "did-resolver";
import { getResolver } from "@sphereon/ssi-sdk-ext.did-resolver-key";
var resolveDidKey = /* @__PURE__ */ __name(async (didUrl, _parsed, _resolver, options) => {
  const resolver = new Resolver({
    ...getResolver()
  });
  return resolver.resolve(didUrl, options);
}, "resolveDidKey");
function getDidKeyResolver() {
  return {
    key: resolveDidKey
  };
}
__name(getDidKeyResolver, "getDidKeyResolver");
export {
  SphereonKeyDidProvider,
  getDidKeyResolver
};
//# sourceMappingURL=index.js.map