@credo-ts/core 0.6.1-pr-2091-20241119140918 → 0.6.2-alpha-20251210145840

package/build/modules/kms/jwk/knownJwk.mjs

@@ -0,0 +1,57 @@
+
+
+import { KeyManagementError } from "../error/KeyManagementError.mjs";
+import { zParseWithErrorHandling } from "../../../utils/zod.mjs";
+import { zKmsJwkPrivateEc, zKmsJwkPrivateToPublicEc, zKmsJwkPublicEc } from "./kty/ec/ecJwk.mjs";
+import { zKmsJwkPrivateOct, zKmsJwkPrivateToPublicOct, zKmsJwkPublicOct } from "./kty/oct/octJwk.mjs";
+import { zKmsJwkPrivateOkp, zKmsJwkPrivateToPublicOkp, zKmsJwkPublicOkp } from "./kty/okp/okpJwk.mjs";
+import { zKmsJwkPrivateRsa, zKmsJwkPrivateToPublicRsa, zKmsJwkPublicRsa } from "./kty/rsa/rsaJwk.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/jwk/knownJwk.ts
+const zKmsJwkPublicAsymmetric = z.discriminatedUnion("kty", [
+	zKmsJwkPublicEc,
+	zKmsJwkPublicRsa,
+	zKmsJwkPublicOkp
+]);
+function isJwkAsymmetric(jwk) {
+	return jwk.kty !== "oct";
+}
+function assertJwkAsymmetric(jwk, keyId) {
+	if (!isJwkAsymmetric(jwk)) {
+		if (keyId) throw new KeyManagementError(`Expected jwk with keyId ${keyId} to be an assymetric jwk, but found kty 'oct'`);
+		throw new KeyManagementError("Expected jwk to be an assymetric jwk, but found kty 'oct'");
+	}
+}
+const zKmsJwkPublicCrv = z.discriminatedUnion("kty", [zKmsJwkPublicEc, zKmsJwkPublicOkp]);
+const zKmsJwkPublic = z.discriminatedUnion("kty", [
+	zKmsJwkPublicEc,
+	zKmsJwkPublicRsa,
+	zKmsJwkPublicOct,
+	zKmsJwkPublicOkp
+]);
+const zKmsJwkPrivateToPublic = z.discriminatedUnion("kty", [
+	zKmsJwkPrivateToPublicEc,
+	zKmsJwkPrivateToPublicRsa,
+	zKmsJwkPrivateToPublicOct,
+	zKmsJwkPrivateToPublicOkp
+]).transform((jwk) => Object.fromEntries(Object.entries(jwk).filter(([, value]) => value !== void 0)));
+const zKmsJwkPrivateCrv = z.discriminatedUnion("kty", [zKmsJwkPrivateEc, zKmsJwkPrivateOkp]);
+const zKmsJwkPrivate = z.discriminatedUnion("kty", [
+	zKmsJwkPrivateEc,
+	zKmsJwkPrivateRsa,
+	zKmsJwkPrivateOct,
+	zKmsJwkPrivateOkp
+]);
+const zKmsJwkPrivateAsymmetric = z.discriminatedUnion("kty", [
+	zKmsJwkPrivateEc,
+	zKmsJwkPrivateRsa,
+	zKmsJwkPrivateOkp
+]);
+function publicJwkFromPrivateJwk(privateJwk) {
+	return zParseWithErrorHandling(zKmsJwkPrivateToPublic, privateJwk);
+}
+
+//#endregion
+export { assertJwkAsymmetric, isJwkAsymmetric, publicJwkFromPrivateJwk, zKmsJwkPrivate, zKmsJwkPublic, zKmsJwkPublicAsymmetric };
+//# sourceMappingURL=knownJwk.mjs.map

package/build/modules/kms/jwk/knownJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"knownJwk.mjs","names":[],"sources":["../../../../src/modules/kms/jwk/knownJwk.ts"],"sourcesContent":["import { z } from 'zod'\nimport { zParseWithErrorHandling } from '../../../utils/zod'\nimport { KeyManagementError } from '../error/KeyManagementError'\nimport type {\n  KmsCreateKeyType,\n  KmsCreateKeyTypeEc,\n  KmsCreateKeyTypeOct,\n  KmsCreateKeyTypeOkp,\n  KmsCreateKeyTypeRsa,\n} from '../options'\nimport {\n  type KmsJwkPrivateEc,\n  type KmsJwkPublicEc,\n  zKmsJwkPrivateEc,\n  zKmsJwkPrivateToPublicEc,\n  zKmsJwkPublicEc,\n} from './kty/ec/ecJwk'\nimport {\n  type KmsJwkPrivateOct,\n  type KmsJwkPublicOct,\n  zKmsJwkPrivateOct,\n  zKmsJwkPrivateToPublicOct,\n  zKmsJwkPublicOct,\n} from './kty/oct/octJwk'\nimport {\n  type KmsJwkPrivateOkp,\n  type KmsJwkPublicOkp,\n  zKmsJwkPrivateOkp,\n  zKmsJwkPrivateToPublicOkp,\n  zKmsJwkPublicOkp,\n} from './kty/okp/okpJwk'\nimport {\n  type KmsJwkPrivateRsa,\n  type KmsJwkPublicRsa,\n  zKmsJwkPrivateRsa,\n  zKmsJwkPrivateToPublicRsa,\n  zKmsJwkPublicRsa,\n} from './kty/rsa/rsaJwk'\n\nexport const zKmsJwkPublicAsymmetric = z.discriminatedUnion('kty', [\n  zKmsJwkPublicEc,\n  zKmsJwkPublicRsa,\n  zKmsJwkPublicOkp,\n])\nexport type KmsJwkPublicAsymmetric = z.output<typeof zKmsJwkPublicAsymmetric>\n\nexport function isJwkAsymmetric(\n  jwk: KmsJwkPublic | KmsJwkPrivate\n): jwk is KmsJwkPrivateAsymmetric | KmsJwkPublicAsymmetric {\n  return jwk.kty !== 'oct'\n}\n\nexport function assertJwkAsymmetric(\n  jwk: KmsJwkPublic | KmsJwkPrivate,\n  keyId?: string\n): asserts jwk is KmsJwkPublicAsymmetric | KmsJwkPrivateAsymmetric {\n  if (!isJwkAsymmetric(jwk)) {\n    if (keyId) {\n      throw new KeyManagementError(`Expected jwk with keyId ${keyId} to be an assymetric jwk, but found kty 'oct'`)\n    }\n    throw new KeyManagementError(\"Expected jwk to be an assymetric jwk, but found kty 'oct'\")\n  }\n}\n\nexport const zKmsJwkPublicCrv = z.discriminatedUnion('kty', [zKmsJwkPublicEc, zKmsJwkPublicOkp])\nexport type KmsJwkPublicCrv = z.output<typeof zKmsJwkPublicCrv>\n\nexport const zKmsJwkPublic = z.discriminatedUnion('kty', [\n  zKmsJwkPublicEc,\n  zKmsJwkPublicRsa,\n  zKmsJwkPublicOct,\n  zKmsJwkPublicOkp,\n])\nexport type KmsJwkPublic = z.output<typeof zKmsJwkPublic>\n\nconst zKmsJwkPrivateToPublic = z\n  .discriminatedUnion('kty', [\n    zKmsJwkPrivateToPublicEc,\n    zKmsJwkPrivateToPublicRsa,\n    zKmsJwkPrivateToPublicOct,\n    zKmsJwkPrivateToPublicOkp,\n  ])\n  // Mdoc library does not work well with undefined values. It should not be needed\n  // but for now it's the easiest approach\n  .transform(\n    (jwk): KmsJwkPublic =>\n      Object.fromEntries(Object.entries(jwk).filter(([, value]) => value !== undefined)) as KmsJwkPublic\n  )\n\nexport const zKmsJwkPrivateCrv = z.discriminatedUnion('kty', [zKmsJwkPrivateEc, zKmsJwkPrivateOkp])\nexport type KmsJwkPrivateCrv = z.output<typeof zKmsJwkPrivateCrv>\n\nexport const zKmsJwkPrivate = z.discriminatedUnion('kty', [\n  zKmsJwkPrivateEc,\n  zKmsJwkPrivateRsa,\n  zKmsJwkPrivateOct,\n  zKmsJwkPrivateOkp,\n])\nexport type KmsJwkPrivate = z.output<typeof zKmsJwkPrivate>\n\nexport const zKmsJwkPrivateAsymmetric = z.discriminatedUnion('kty', [\n  zKmsJwkPrivateEc,\n  zKmsJwkPrivateRsa,\n  zKmsJwkPrivateOkp,\n])\nexport type KmsJwkPrivateAsymmetric = z.output<typeof zKmsJwkPrivateAsymmetric>\n\nexport function publicJwkFromPrivateJwk(privateJwk: KmsJwkPrivate | KmsJwkPublic): KmsJwkPublic {\n  // This will remove any private properties\n  return zParseWithErrorHandling(zKmsJwkPrivateToPublic, privateJwk)\n}\n\nexport type KmsJwkPrivateFromKmsJwkPublic<Type extends KmsCreateKeyType> = Type extends KmsCreateKeyTypeRsa\n  ? KmsJwkPrivateRsa\n  : Type extends KmsCreateKeyTypeOct\n    ? KmsJwkPrivateOct\n    : Type extends KmsCreateKeyTypeOkp\n      ? KmsJwkPrivateOkp & { crv: Type['crv'] }\n      : Type extends KmsCreateKeyTypeEc\n        ? KmsJwkPrivateEc & { crv: Type['crv'] }\n        : KmsJwkPrivate\n\nexport type KmsJwkPublicFromKmsJwkPrivate<Jwk extends KmsJwkPrivate> = Jwk extends KmsJwkPrivateRsa\n  ? KmsJwkPublicRsa\n  : Jwk extends KmsJwkPrivateOct\n    ? KmsJwkPublicOct\n    : Jwk extends KmsJwkPrivateOkp\n      ? KmsJwkPublicOkp & { crv: Jwk['crv'] }\n      : Jwk extends KmsJwkPrivateEc\n        ? KmsJwkPublicEc & { crv: Jwk['crv'] }\n        : KmsJwkPublic\n\nexport type KmsJwkPublicFromCreateType<Type extends KmsCreateKeyType> = Type extends KmsCreateKeyTypeRsa\n  ? KmsJwkPublicRsa\n  : Type extends KmsCreateKeyTypeOct\n    ? KmsJwkPublicOct\n    : Type extends KmsCreateKeyTypeOkp\n      ? KmsJwkPublicOkp & { crv: Type['crv'] }\n      : Type extends KmsCreateKeyTypeEc\n        ? KmsJwkPublicEc & { crv: Type['crv'] }\n        : KmsJwkPublic\n"],"mappings":";;;;;;;;;;;AAuCA,MAAa,0BAA0B,EAAE,mBAAmB,OAAO;CACjE;CACA;CACA;CACD,CAAC;AAGF,SAAgB,gBACd,KACyD;AACzD,QAAO,IAAI,QAAQ;;AAGrB,SAAgB,oBACd,KACA,OACiE;AACjE,KAAI,CAAC,gBAAgB,IAAI,EAAE;AACzB,MAAI,MACF,OAAM,IAAI,mBAAmB,2BAA2B,MAAM,+CAA+C;AAE/G,QAAM,IAAI,mBAAmB,4DAA4D;;;AAI7F,MAAa,mBAAmB,EAAE,mBAAmB,OAAO,CAAC,iBAAiB,iBAAiB,CAAC;AAGhG,MAAa,gBAAgB,EAAE,mBAAmB,OAAO;CACvD;CACA;CACA;CACA;CACD,CAAC;AAGF,MAAM,yBAAyB,EAC5B,mBAAmB,OAAO;CACzB;CACA;CACA;CACA;CACD,CAAC,CAGD,WACE,QACC,OAAO,YAAY,OAAO,QAAQ,IAAI,CAAC,QAAQ,GAAG,WAAW,UAAU,OAAU,CAAC,CACrF;AAEH,MAAa,oBAAoB,EAAE,mBAAmB,OAAO,CAAC,kBAAkB,kBAAkB,CAAC;AAGnG,MAAa,iBAAiB,EAAE,mBAAmB,OAAO;CACxD;CACA;CACA;CACA;CACD,CAAC;AAGF,MAAa,2BAA2B,EAAE,mBAAmB,OAAO;CAClE;CACA;CACA;CACD,CAAC;AAGF,SAAgB,wBAAwB,YAAwD;AAE9F,QAAO,wBAAwB,wBAAwB,WAAW"}

package/build/modules/kms/jwk/kty/PublicJwk.d.mts

@@ -0,0 +1,14 @@
+import { KnownJwaKeyAgreementAlgorithm, KnownJwaSignatureAlgorithm } from "../jwa.mjs";
+import { AnyUint8Array } from "../../../../types.mjs";
+import { KmsJwkPublicAsymmetric } from "../knownJwk.mjs";
+
+//#region src/modules/kms/jwk/kty/PublicJwk.d.ts
+interface PublicJwkType<Jwk extends KmsJwkPublicAsymmetric = KmsJwkPublicAsymmetric> {
+  readonly jwk: Jwk;
+  supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] | undefined;
+  supportdEncryptionKeyAgreementAlgorithms: KnownJwaKeyAgreementAlgorithm[] | undefined;
+  multicodec: AnyUint8Array;
+}
+//#endregion
+export { PublicJwkType };
+//# sourceMappingURL=PublicJwk.d.mts.map

package/build/modules/kms/jwk/kty/PublicJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PublicJwk.d.mts","names":[],"sources":["../../../../../src/modules/kms/jwk/kty/PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;UAIiB,0BAA0B,yBAAyB;gBACpD;gCAEgB;4CACY;EAJ3B,UAAA,EAMH,aANgB"}

package/build/modules/kms/jwk/kty/ec/P256PublicJwk.d.mts

@@ -0,0 +1,35 @@
+import { KnownJwaSignatureAlgorithm } from "../../jwa.mjs";
+import { AnyUint8Array } from "../../../../../types.mjs";
+import { KmsJwkPublicEc } from "./ecJwk.mjs";
+import { PublicJwkType } from "../PublicJwk.mjs";
+
+//#region src/modules/kms/jwk/kty/ec/P256PublicJwk.d.ts
+type Jwk = KmsJwkPublicEc & {
+  crv: 'P-256';
+};
+declare class P256PublicJwk implements PublicJwkType<Jwk> {
+  readonly jwk: Jwk;
+  static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
+  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  static multicodecPrefix: number;
+  supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];
+  multicodecPrefix: number;
+  constructor(jwk: Jwk);
+  get publicKey(): {
+    crv: "P-256";
+    kty: "EC";
+    publicKey: AnyUint8Array;
+  };
+  get compressedPublicKey(): {
+    crv: "P-256";
+    kty: "EC";
+    publicKey: AnyUint8Array;
+  };
+  get multicodec(): AnyUint8Array;
+  static fromPublicKey(publicKey: AnyUint8Array): P256PublicJwk;
+  static fromMulticodec(multicodec: AnyUint8Array): P256PublicJwk;
+}
+//#endregion
+export { P256PublicJwk };
+//# sourceMappingURL=P256PublicJwk.d.mts.map

package/build/modules/kms/jwk/kty/ec/P256PublicJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"P256PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P256PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,aAAA,YAAyB,cAAc;EAF/C,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAc,EACmB,0BADnB,EAAA;EAAyB,OAAA,wCAAA,EAAA,SAAA,EAAA;EASV,OAAA,gBAAA,EAAA,MAAA;EARI,wCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,OAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApClB,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,OAAA;;;;oBA2B5B;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/ec/P256PublicJwk.mjs

@@ -0,0 +1,44 @@
+
+
+import { KnownJwaKeyAgreementAlgorithms, KnownJwaSignatureAlgorithms } from "../../jwa.mjs";
+import { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from "./ecPublicKey.mjs";
+
+//#region src/modules/kms/jwk/kty/ec/P256PublicJwk.ts
+var P256PublicJwk = class P256PublicJwk {
+	constructor(jwk) {
+		this.jwk = jwk;
+		this.supportdEncryptionKeyAgreementAlgorithms = P256PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedSignatureAlgorithms = P256PublicJwk.supportedSignatureAlgorithms;
+		this.multicodecPrefix = P256PublicJwk.multicodecPrefix;
+	}
+	get publicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: ecPublicJwkToPublicKey(this.jwk)
+		};
+	}
+	get compressedPublicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true })
+		};
+	}
+	get multicodec() {
+		return ecPublicJwkToPublicKey(this.jwk, { compressed: true });
+	}
+	static fromPublicKey(publicKey) {
+		return new P256PublicJwk(ecPublicKeyToPublicJwk(publicKey, "P-256"));
+	}
+	static fromMulticodec(multicodec) {
+		return new P256PublicJwk(ecPublicKeyToPublicJwk(multicodec, "P-256"));
+	}
+};
+P256PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.ES256];
+P256PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
+P256PublicJwk.multicodecPrefix = 4608;
+
+//#endregion
+export { P256PublicJwk };
+//# sourceMappingURL=P256PublicJwk.mjs.map

package/build/modules/kms/jwk/kty/ec/P256PublicJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"P256PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P256PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'P-256' }\n\nexport class P256PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES256]\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 4608\n\n  public supportdEncryptionKeyAgreementAlgorithms = P256PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = P256PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = P256PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'P-256')\n    return new P256PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'P-256')\n    return new P256PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAAa,cAA4C;CASvD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,2CAA2C,cAAc;OACzD,+BAA+B,cAAc;OAC7C,mBAAmB,cAAc;;CAIxC,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,cADC,uBAAuB,WAAW,QAAQ,CACzB;;CAG/B,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,cADC,uBAAuB,YAAY,QAAQ,CAC1B;;;cArCjB,+BAA6D,CAAC,4BAA4B,MAAM;cAChG,2CAA2C,CAAC,+BAA+B,QAAQ;cACnF,mBAAmB"}

package/build/modules/kms/jwk/kty/ec/P384PublicJwk.d.mts

@@ -0,0 +1,35 @@
+import { KnownJwaSignatureAlgorithm } from "../../jwa.mjs";
+import { AnyUint8Array } from "../../../../../types.mjs";
+import { KmsJwkPublicEc } from "./ecJwk.mjs";
+import { PublicJwkType } from "../PublicJwk.mjs";
+
+//#region src/modules/kms/jwk/kty/ec/P384PublicJwk.d.ts
+type Jwk = KmsJwkPublicEc & {
+  crv: 'P-384';
+};
+declare class P384PublicJwk implements PublicJwkType<Jwk> {
+  readonly jwk: Jwk;
+  static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
+  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  static multicodecPrefix: number;
+  supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];
+  multicodecPrefix: number;
+  constructor(jwk: Jwk);
+  get publicKey(): {
+    crv: "P-384";
+    kty: "EC";
+    publicKey: AnyUint8Array;
+  };
+  get compressedPublicKey(): {
+    crv: "P-384";
+    kty: "EC";
+    publicKey: AnyUint8Array;
+  };
+  get multicodec(): AnyUint8Array;
+  static fromPublicKey(publicKey: AnyUint8Array): P384PublicJwk;
+  static fromMulticodec(multicodec: AnyUint8Array): P384PublicJwk;
+}
+//#endregion
+export { P384PublicJwk };
+//# sourceMappingURL=P384PublicJwk.d.mts.map

package/build/modules/kms/jwk/kty/ec/P384PublicJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"P384PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P384PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,aAAA,YAAyB,cAAc;EAF/C,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAc,EACmB,0BADnB,EAAA;EAAyB,OAAA,wCAAA,EAAA,SAAA,EAAA;EASV,OAAA,gBAAA,EAAA,MAAA;EARI,wCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,OAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApClB,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,OAAA;;;;oBA2B5B;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/ec/P384PublicJwk.mjs

@@ -0,0 +1,44 @@
+
+
+import { KnownJwaKeyAgreementAlgorithms, KnownJwaSignatureAlgorithms } from "../../jwa.mjs";
+import { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from "./ecPublicKey.mjs";
+
+//#region src/modules/kms/jwk/kty/ec/P384PublicJwk.ts
+var P384PublicJwk = class P384PublicJwk {
+	constructor(jwk) {
+		this.jwk = jwk;
+		this.supportdEncryptionKeyAgreementAlgorithms = P384PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedSignatureAlgorithms = P384PublicJwk.supportedSignatureAlgorithms;
+		this.multicodecPrefix = P384PublicJwk.multicodecPrefix;
+	}
+	get publicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: ecPublicJwkToPublicKey(this.jwk)
+		};
+	}
+	get compressedPublicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true })
+		};
+	}
+	get multicodec() {
+		return ecPublicJwkToPublicKey(this.jwk, { compressed: true });
+	}
+	static fromPublicKey(publicKey) {
+		return new P384PublicJwk(ecPublicKeyToPublicJwk(publicKey, "P-384"));
+	}
+	static fromMulticodec(multicodec) {
+		return new P384PublicJwk(ecPublicKeyToPublicJwk(multicodec, "P-384"));
+	}
+};
+P384PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.ES384];
+P384PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
+P384PublicJwk.multicodecPrefix = 4609;
+
+//#endregion
+export { P384PublicJwk };
+//# sourceMappingURL=P384PublicJwk.mjs.map

package/build/modules/kms/jwk/kty/ec/P384PublicJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"P384PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P384PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'P-384' }\n\nexport class P384PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES384]\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 4609\n\n  public supportdEncryptionKeyAgreementAlgorithms = P384PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = P384PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = P384PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'P-384')\n    return new P384PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'P-384')\n    return new P384PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAAa,cAA4C;CASvD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,2CAA2C,cAAc;OACzD,+BAA+B,cAAc;OAC7C,mBAAmB,cAAc;;CAIxC,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,cADC,uBAAuB,WAAW,QAAQ,CACzB;;CAG/B,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,cADC,uBAAuB,YAAY,QAAQ,CAC1B;;;cArCjB,+BAA6D,CAAC,4BAA4B,MAAM;cAChG,2CAA2C,CAAC,+BAA+B,QAAQ;cACnF,mBAAmB"}

package/build/modules/kms/jwk/kty/ec/P521PublicJwk.d.mts

@@ -0,0 +1,35 @@
+import { KnownJwaSignatureAlgorithm } from "../../jwa.mjs";
+import { AnyUint8Array } from "../../../../../types.mjs";
+import { KmsJwkPublicEc } from "./ecJwk.mjs";
+import { PublicJwkType } from "../PublicJwk.mjs";
+
+//#region src/modules/kms/jwk/kty/ec/P521PublicJwk.d.ts
+type Jwk = KmsJwkPublicEc & {
+  crv: 'P-521';
+};
+declare class P521PublicJwk implements PublicJwkType<Jwk> {
+  readonly jwk: Jwk;
+  static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
+  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  static multicodecPrefix: number;
+  supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];
+  multicodecPrefix: number;
+  constructor(jwk: Jwk);
+  get publicKey(): {
+    crv: "P-521";
+    kty: "EC";
+    publicKey: AnyUint8Array;
+  };
+  get compressedPublicKey(): {
+    crv: "P-521";
+    kty: "EC";
+    publicKey: AnyUint8Array;
+  };
+  get multicodec(): AnyUint8Array;
+  static fromPublicKey(publicKey: AnyUint8Array): P521PublicJwk;
+  static fromMulticodec(multicodec: AnyUint8Array): P521PublicJwk;
+}
+//#endregion
+export { P521PublicJwk };
+//# sourceMappingURL=P521PublicJwk.d.mts.map

package/build/modules/kms/jwk/kty/ec/P521PublicJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"P521PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P521PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,aAAA,YAAyB,cAAc;EAF/C,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAc,EACmB,0BADnB,EAAA;EAAyB,OAAA,wCAAA,EAAA,SAAA,EAAA;EASV,OAAA,gBAAA,EAAA,MAAA;EARI,wCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,OAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApClB,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,OAAA;;;;oBA2B5B;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/ec/P521PublicJwk.mjs

@@ -0,0 +1,44 @@
+
+
+import { KnownJwaKeyAgreementAlgorithms, KnownJwaSignatureAlgorithms } from "../../jwa.mjs";
+import { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from "./ecPublicKey.mjs";
+
+//#region src/modules/kms/jwk/kty/ec/P521PublicJwk.ts
+var P521PublicJwk = class P521PublicJwk {
+	constructor(jwk) {
+		this.jwk = jwk;
+		this.supportdEncryptionKeyAgreementAlgorithms = P521PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedSignatureAlgorithms = P521PublicJwk.supportedSignatureAlgorithms;
+		this.multicodecPrefix = P521PublicJwk.multicodecPrefix;
+	}
+	get publicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: ecPublicJwkToPublicKey(this.jwk)
+		};
+	}
+	get compressedPublicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true })
+		};
+	}
+	get multicodec() {
+		return ecPublicJwkToPublicKey(this.jwk, { compressed: true });
+	}
+	static fromPublicKey(publicKey) {
+		return new P521PublicJwk(ecPublicKeyToPublicJwk(publicKey, "P-521"));
+	}
+	static fromMulticodec(multicodec) {
+		return new P521PublicJwk(ecPublicKeyToPublicJwk(multicodec, "P-521"));
+	}
+};
+P521PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.ES512];
+P521PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
+P521PublicJwk.multicodecPrefix = 4610;
+
+//#endregion
+export { P521PublicJwk };
+//# sourceMappingURL=P521PublicJwk.mjs.map

package/build/modules/kms/jwk/kty/ec/P521PublicJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"P521PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/P521PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'P-521' }\n\nexport class P521PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES512]\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 4610\n\n  public supportdEncryptionKeyAgreementAlgorithms = P521PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = P521PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = P521PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'P-521')\n    return new P521PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'P-521')\n    return new P521PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,gBAAb,MAAa,cAA4C;CASvD,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,2CAA2C,cAAc;OACzD,+BAA+B,cAAc;OAC7C,mBAAmB,cAAc;;CAIxC,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,cADC,uBAAuB,WAAW,QAAQ,CACzB;;CAG/B,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,cADC,uBAAuB,YAAY,QAAQ,CAC1B;;;cArCjB,+BAA6D,CAAC,4BAA4B,MAAM;cAChG,2CAA2C,CAAC,+BAA+B,QAAQ;cACnF,mBAAmB"}

package/build/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.d.mts

@@ -0,0 +1,35 @@
+import { KnownJwaSignatureAlgorithm } from "../../jwa.mjs";
+import { AnyUint8Array } from "../../../../../types.mjs";
+import { KmsJwkPublicEc } from "./ecJwk.mjs";
+import { PublicJwkType } from "../PublicJwk.mjs";
+
+//#region src/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.d.ts
+type Jwk = KmsJwkPublicEc & {
+  crv: 'secp256k1';
+};
+declare class Secp256k1PublicJwk implements PublicJwkType<Jwk> {
+  readonly jwk: Jwk;
+  static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[];
+  static supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  static multicodecPrefix: number;
+  supportdEncryptionKeyAgreementAlgorithms: "ECDH-ES"[];
+  supportedSignatureAlgorithms: ("HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | "Ed25519" | "ES256K")[];
+  multicodecPrefix: number;
+  constructor(jwk: Jwk);
+  get publicKey(): {
+    crv: "secp256k1";
+    kty: "EC";
+    publicKey: AnyUint8Array;
+  };
+  get compressedPublicKey(): {
+    crv: "secp256k1";
+    kty: "EC";
+    publicKey: AnyUint8Array;
+  };
+  get multicodec(): AnyUint8Array;
+  static fromPublicKey(publicKey: AnyUint8Array): Secp256k1PublicJwk;
+  static fromMulticodec(multicodec: AnyUint8Array): Secp256k1PublicJwk;
+}
+//#endregion
+export { Secp256k1PublicJwk };
+//# sourceMappingURL=Secp256k1PublicJwk.d.mts.map

package/build/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Secp256k1PublicJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.ts"],"sourcesContent":[],"mappings":";;;;;;KAMK,GAAA,GAAM;;;cAEE,kBAAA,YAA8B,cAAc;EAFpD,SAAG,GAAA,EAWkC,GAXlC;EAEK,OAAA,4BAAmB,EACc,0BADd,EAAA;EAAyB,OAAA,wCAAA,EAAA,SAAA,EAAA;EASf,OAAA,gBAAA,EAAA,MAAA;EARI,wCAAA,EAAA,SAAA,EAAA;EAQJ,4BAAA,EAAA,CAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,SAAA,GAAA,QAAA,CAAA,EAAA;;mBAAA;EAkBnB,IAAA,SAAA,CAAA,CAAA,EAAA;IAIkB,GAAA,EAAA,WAAA;IAAa,GAAA,EAAA,IAAA;IAKX,SAAA,eAAA;EAAa,CAAA;EApCb,IAAA,mBAAA,CAAA,CAAA,EAAA;IAAa,GAAA,EAAA,WAAA;;;;oBA2BjC;kCAIkB,gBAAa;oCAKX,gBAAa"}

package/build/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.mjs

@@ -0,0 +1,44 @@
+
+
+import { KnownJwaKeyAgreementAlgorithms, KnownJwaSignatureAlgorithms } from "../../jwa.mjs";
+import { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from "./ecPublicKey.mjs";
+
+//#region src/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.ts
+var Secp256k1PublicJwk = class Secp256k1PublicJwk {
+	constructor(jwk) {
+		this.jwk = jwk;
+		this.supportdEncryptionKeyAgreementAlgorithms = Secp256k1PublicJwk.supportdEncryptionKeyAgreementAlgorithms;
+		this.supportedSignatureAlgorithms = Secp256k1PublicJwk.supportedSignatureAlgorithms;
+		this.multicodecPrefix = Secp256k1PublicJwk.multicodecPrefix;
+	}
+	get publicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: ecPublicJwkToPublicKey(this.jwk)
+		};
+	}
+	get compressedPublicKey() {
+		return {
+			crv: this.jwk.crv,
+			kty: this.jwk.kty,
+			publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true })
+		};
+	}
+	get multicodec() {
+		return ecPublicJwkToPublicKey(this.jwk, { compressed: true });
+	}
+	static fromPublicKey(publicKey) {
+		return new Secp256k1PublicJwk(ecPublicKeyToPublicJwk(publicKey, "secp256k1"));
+	}
+	static fromMulticodec(multicodec) {
+		return new Secp256k1PublicJwk(ecPublicKeyToPublicJwk(multicodec, "secp256k1"));
+	}
+};
+Secp256k1PublicJwk.supportedSignatureAlgorithms = [KnownJwaSignatureAlgorithms.ES256K];
+Secp256k1PublicJwk.supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES];
+Secp256k1PublicJwk.multicodecPrefix = 231;
+
+//#endregion
+export { Secp256k1PublicJwk };
+//# sourceMappingURL=Secp256k1PublicJwk.mjs.map

package/build/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Secp256k1PublicJwk.mjs","names":["jwk: Jwk"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/Secp256k1PublicJwk.ts"],"sourcesContent":["import type { AnyUint8Array } from '../../../../../types'\nimport { KnownJwaKeyAgreementAlgorithms, type KnownJwaSignatureAlgorithm, KnownJwaSignatureAlgorithms } from '../../jwa'\nimport type { PublicJwkType } from '../PublicJwk'\nimport type { KmsJwkPublicEc } from './ecJwk'\nimport { ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk } from './ecPublicKey'\n\ntype Jwk = KmsJwkPublicEc & { crv: 'secp256k1' }\n\nexport class Secp256k1PublicJwk implements PublicJwkType<Jwk> {\n  public static supportedSignatureAlgorithms: KnownJwaSignatureAlgorithm[] = [KnownJwaSignatureAlgorithms.ES256K]\n  public static supportdEncryptionKeyAgreementAlgorithms = [KnownJwaKeyAgreementAlgorithms.ECDH_ES]\n  public static multicodecPrefix = 231\n\n  public supportdEncryptionKeyAgreementAlgorithms = Secp256k1PublicJwk.supportdEncryptionKeyAgreementAlgorithms\n  public supportedSignatureAlgorithms = Secp256k1PublicJwk.supportedSignatureAlgorithms\n  public multicodecPrefix = Secp256k1PublicJwk.multicodecPrefix\n\n  public constructor(public readonly jwk: Jwk) {}\n\n  public get publicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk),\n    }\n  }\n\n  public get compressedPublicKey() {\n    return {\n      crv: this.jwk.crv,\n      kty: this.jwk.kty,\n      publicKey: ecPublicJwkToPublicKey(this.jwk, { compressed: true }),\n    }\n  }\n\n  public get multicodec() {\n    return ecPublicJwkToPublicKey(this.jwk, { compressed: true })\n  }\n\n  public static fromPublicKey(publicKey: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(publicKey, 'secp256k1')\n    return new Secp256k1PublicJwk(jwk)\n  }\n\n  public static fromMulticodec(multicodec: AnyUint8Array) {\n    const jwk = ecPublicKeyToPublicJwk(multicodec, 'secp256k1')\n    return new Secp256k1PublicJwk(jwk)\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAa,qBAAb,MAAa,mBAAiD;CAS5D,AAAO,YAAY,AAAgBA,KAAU;EAAV;OAJ5B,2CAA2C,mBAAmB;OAC9D,+BAA+B,mBAAmB;OAClD,mBAAmB,mBAAmB;;CAI7C,IAAW,YAAY;AACrB,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,IAAI;GAC5C;;CAGH,IAAW,sBAAsB;AAC/B,SAAO;GACL,KAAK,KAAK,IAAI;GACd,KAAK,KAAK,IAAI;GACd,WAAW,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;GAClE;;CAGH,IAAW,aAAa;AACtB,SAAO,uBAAuB,KAAK,KAAK,EAAE,YAAY,MAAM,CAAC;;CAG/D,OAAc,cAAc,WAA0B;AAEpD,SAAO,IAAI,mBADC,uBAAuB,WAAW,YAAY,CACxB;;CAGpC,OAAc,eAAe,YAA2B;AAEtD,SAAO,IAAI,mBADC,uBAAuB,YAAY,YAAY,CACzB;;;mBArCtB,+BAA6D,CAAC,4BAA4B,OAAO;mBACjG,2CAA2C,CAAC,+BAA+B,QAAQ;mBACnF,mBAAmB"}

package/build/modules/kms/jwk/kty/ec/ecJwk.d.mts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+//#region src/modules/kms/jwk/kty/ec/ecJwk.d.ts
+declare const zKmsJwkPublicEc: z.ZodObject<{
+  kty: z.ZodLiteral<"EC">;
+  crv: z.ZodEnum<{
+    "P-256": "P-256";
+    "P-384": "P-384";
+    "P-521": "P-521";
+    secp256k1: "secp256k1";
+  }>;
+  x: z.ZodString;
+  y: z.ZodString;
+  d: z.ZodOptional<z.ZodUndefined>;
+  kid: z.ZodOptional<z.ZodString>;
+  alg: z.ZodOptional<z.ZodString>;
+  key_ops: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sign">, z.ZodLiteral<"verify">, z.ZodLiteral<"encrypt">, z.ZodLiteral<"decrypt">, z.ZodLiteral<"wrapKey">, z.ZodLiteral<"unwrapKey">, z.ZodLiteral<"deriveKey">, z.ZodLiteral<"deriveBits">]>, z.ZodString]>>>;
+  use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sig">, z.ZodLiteral<"enc">]>, z.ZodString]>>;
+  ext: z.ZodOptional<z.ZodBoolean>;
+  x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  x5t: z.ZodOptional<z.ZodString>;
+  'x5t#S256': z.ZodOptional<z.ZodString>;
+  x5u: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type KmsJwkPublicEc = z.output<typeof zKmsJwkPublicEc>;
+declare const zKmsJwkPrivateEc: z.ZodObject<{
+  d: z.ZodString;
+  kty: z.ZodLiteral<"EC">;
+  crv: z.ZodEnum<{
+    "P-256": "P-256";
+    "P-384": "P-384";
+    "P-521": "P-521";
+    secp256k1: "secp256k1";
+  }>;
+  x: z.ZodString;
+  y: z.ZodString;
+  kid: z.ZodOptional<z.ZodString>;
+  alg: z.ZodOptional<z.ZodString>;
+  key_ops: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sign">, z.ZodLiteral<"verify">, z.ZodLiteral<"encrypt">, z.ZodLiteral<"decrypt">, z.ZodLiteral<"wrapKey">, z.ZodLiteral<"unwrapKey">, z.ZodLiteral<"deriveKey">, z.ZodLiteral<"deriveBits">]>, z.ZodString]>>>;
+  use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"sig">, z.ZodLiteral<"enc">]>, z.ZodString]>>;
+  ext: z.ZodOptional<z.ZodBoolean>;
+  x5c: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  x5t: z.ZodOptional<z.ZodString>;
+  'x5t#S256': z.ZodOptional<z.ZodString>;
+  x5u: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type KmsJwkPrivateEc = z.output<typeof zKmsJwkPrivateEc>;
+//#endregion
+export { KmsJwkPrivateEc, KmsJwkPublicEc, zKmsJwkPrivateEc, zKmsJwkPublicEc };
+//# sourceMappingURL=ecJwk.d.mts.map

package/build/modules/kms/jwk/kty/ec/ecJwk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecJwk.d.mts","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/ecJwk.ts"],"sourcesContent":[],"mappings":";;;cAIa,iBAAe,CAAA,CAAA;;;;IAAf,OAAA,EAAA,OAWX;;;;;;;;;;;;;;;;;KACU,cAAA,GAAiB,CAAA,CAAE,cAAc;cAOhC,kBAAgB,CAAA,CAAA;;;EAnBD,GAAA,WAAA,CAAA;IAAA,OAAA,EAAA,OAAA;IAYhB,OAAA,EAAA,OAAc;IAOb,OAAA,EAAA,OAKX;;;;;;;;;;;;;;;KACU,eAAA,GAAkB,CAAA,CAAE,cAAc"}

package/build/modules/kms/jwk/kty/ec/ecJwk.mjs

@@ -0,0 +1,32 @@
+
+
+import { zBase64Url, zOptionalToUndefined } from "../../../../../utils/zod.mjs";
+import { vJwkCommon } from "../../jwk.mjs";
+import { z } from "zod";
+
+//#region src/modules/kms/jwk/kty/ec/ecJwk.ts
+const zKmsJwkPublicEc = z.object({
+	...vJwkCommon.shape,
+	kty: z.literal("EC"),
+	crv: z.enum([
+		"P-256",
+		"P-384",
+		"P-521",
+		"secp256k1"
+	]),
+	x: zBase64Url,
+	y: zBase64Url,
+	d: z.optional(z.undefined())
+});
+const zKmsJwkPrivateToPublicEc = z.object({
+	...zKmsJwkPublicEc.shape,
+	d: zOptionalToUndefined(zBase64Url)
+});
+const zKmsJwkPrivateEc = z.object({
+	...zKmsJwkPublicEc.shape,
+	d: zBase64Url
+});
+
+//#endregion
+export { zKmsJwkPrivateEc, zKmsJwkPrivateToPublicEc, zKmsJwkPublicEc };
+//# sourceMappingURL=ecJwk.mjs.map

package/build/modules/kms/jwk/kty/ec/ecJwk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecJwk.mjs","names":[],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/ecJwk.ts"],"sourcesContent":["import { z } from 'zod'\nimport { zBase64Url, zOptionalToUndefined } from '../../../../../utils/zod'\nimport { vJwkCommon } from '../../jwk'\n\nexport const zKmsJwkPublicEc = z.object({\n  ...vJwkCommon.shape,\n  kty: z.literal('EC'),\n  crv: z.enum(['P-256', 'P-384', 'P-521', 'secp256k1']),\n\n  // Public\n  x: zBase64Url, // Public key x-coordinate\n  y: zBase64Url, // Public key y-coordinate\n\n  // Private\n  d: z.optional(z.undefined()),\n})\nexport type KmsJwkPublicEc = z.output<typeof zKmsJwkPublicEc>\n\nexport const zKmsJwkPrivateToPublicEc = z.object({\n  ...zKmsJwkPublicEc.shape,\n  d: zOptionalToUndefined(zBase64Url),\n})\n\nexport const zKmsJwkPrivateEc = z.object({\n  ...zKmsJwkPublicEc.shape,\n\n  // Private\n  d: zBase64Url,\n})\nexport type KmsJwkPrivateEc = z.output<typeof zKmsJwkPrivateEc>\n"],"mappings":";;;;;;;AAIA,MAAa,kBAAkB,EAAE,OAAO;CACtC,GAAG,WAAW;CACd,KAAK,EAAE,QAAQ,KAAK;CACpB,KAAK,EAAE,KAAK;EAAC;EAAS;EAAS;EAAS;EAAY,CAAC;CAGrD,GAAG;CACH,GAAG;CAGH,GAAG,EAAE,SAAS,EAAE,WAAW,CAAC;CAC7B,CAAC;AAGF,MAAa,2BAA2B,EAAE,OAAO;CAC/C,GAAG,gBAAgB;CACnB,GAAG,qBAAqB,WAAW;CACpC,CAAC;AAEF,MAAa,mBAAmB,EAAE,OAAO;CACvC,GAAG,gBAAgB;CAGnB,GAAG;CACJ,CAAC"}

package/build/modules/kms/jwk/kty/ec/ecPublicKey.d.mts

@@ -0,0 +1,3 @@
+import "../../../../../types.mjs";
+import "./ecJwk.mjs";
+import "ec-compression";

package/build/modules/kms/jwk/kty/ec/ecPublicKey.mjs

@@ -0,0 +1,36 @@
+
+
+import { KeyManagementError } from "../../../error/KeyManagementError.mjs";
+import { TypedArrayEncoder } from "../../../../../utils/TypedArrayEncoder.mjs";
+import "../../../../../utils/index.mjs";
+import { AffinePoint, Secp256k1, Secp256r1, Secp384r1, Secp521r1, isValidCompressedPublicKeyFormat, isValidDecompressedPublicKeyFormat } from "ec-compression";
+
+//#region src/modules/kms/jwk/kty/ec/ecPublicKey.ts
+const ecCrvToCurveParams = {
+	"P-256": Secp256r1,
+	"P-384": Secp384r1,
+	"P-521": Secp521r1,
+	secp256k1: Secp256k1
+};
+function ecPublicJwkToPublicKey(publicJwk, { compressed = false } = {}) {
+	const affinePoint = new AffinePoint(Uint8Array.from(TypedArrayEncoder.fromBase64(publicJwk.x)), Uint8Array.from(TypedArrayEncoder.fromBase64(publicJwk.y)));
+	return compressed ? affinePoint.compressedForm : affinePoint.decompressedForm;
+}
+function ecPublicKeyToPublicJwk(publicKey, crv) {
+	const curveParams = ecCrvToCurveParams[crv];
+	if (!curveParams) throw new KeyManagementError(`kty EC with crv '${crv}' is not supported for creating jwk based on public key bytes`);
+	let affinePoint;
+	if (isValidCompressedPublicKeyFormat(publicKey, curveParams)) affinePoint = AffinePoint.fromCompressedPoint(publicKey, curveParams);
+	else if (isValidDecompressedPublicKeyFormat(publicKey, curveParams)) affinePoint = AffinePoint.fromDecompressedPoint(publicKey, curveParams);
+	else throw new KeyManagementError(`public key for kty EC with crv '${crv}' is neither a valid compressed or uncompressed key. Key prefix '${publicKey[0]}', key length '${publicKey.length}'`);
+	return {
+		kty: "EC",
+		crv,
+		x: TypedArrayEncoder.toBase64URL(affinePoint.xBytes),
+		y: TypedArrayEncoder.toBase64URL(affinePoint.yBytes)
+	};
+}
+
+//#endregion
+export { ecCrvToCurveParams, ecPublicJwkToPublicKey, ecPublicKeyToPublicJwk };
+//# sourceMappingURL=ecPublicKey.mjs.map

package/build/modules/kms/jwk/kty/ec/ecPublicKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecPublicKey.mjs","names":["ecCrvToCurveParams: Record<KmsJwkPublicEc['crv'], CurveParams>","affinePoint: AffinePoint"],"sources":["../../../../../../src/modules/kms/jwk/kty/ec/ecPublicKey.ts"],"sourcesContent":["import {\n  AffinePoint,\n  CurveParams,\n  isValidCompressedPublicKeyFormat,\n  isValidDecompressedPublicKeyFormat,\n  Secp256k1,\n  Secp256r1,\n  Secp384r1,\n  Secp521r1,\n} from 'ec-compression'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../../../../../types'\nimport { TypedArrayEncoder } from '../../../../../utils'\nimport { KeyManagementError } from '../../../error/KeyManagementError'\nimport type { KmsJwkPublicEc } from './ecJwk'\n\n// CurveParams for ec-compression lib\nexport const ecCrvToCurveParams: Record<KmsJwkPublicEc['crv'], CurveParams> = {\n  'P-256': Secp256r1,\n  'P-384': Secp384r1,\n  'P-521': Secp521r1,\n  secp256k1: Secp256k1,\n}\n\nexport function ecPublicJwkToPublicKey(\n  publicJwk: KmsJwkPublicEc,\n  { compressed = false }: { compressed?: boolean } = {}\n): AnyUint8Array {\n  const xAsBytes = Uint8Array.from(TypedArrayEncoder.fromBase64(publicJwk.x))\n  const yAsBytes = Uint8Array.from(TypedArrayEncoder.fromBase64(publicJwk.y))\n\n  const affinePoint = new AffinePoint(xAsBytes, yAsBytes)\n\n  return compressed\n    ? (affinePoint.compressedForm as Uint8ArrayBuffer)\n    : (affinePoint.decompressedForm as Uint8ArrayBuffer)\n}\n\nexport function ecPublicKeyToPublicJwk<Crv extends KmsJwkPublicEc['crv']>(publicKey: AnyUint8Array, crv: Crv) {\n  const curveParams = ecCrvToCurveParams[crv]\n\n  if (!curveParams) {\n    throw new KeyManagementError(`kty EC with crv '${crv}' is not supported for creating jwk based on public key bytes`)\n  }\n\n  let affinePoint: AffinePoint\n\n  if (isValidCompressedPublicKeyFormat(publicKey, curveParams)) {\n    affinePoint = AffinePoint.fromCompressedPoint(publicKey, curveParams)\n  } else if (isValidDecompressedPublicKeyFormat(publicKey, curveParams)) {\n    affinePoint = AffinePoint.fromDecompressedPoint(publicKey, curveParams)\n  } else {\n    throw new KeyManagementError(\n      `public key for kty EC with crv '${crv}' is neither a valid compressed or uncompressed key. Key prefix '${publicKey[0]}', key length '${publicKey.length}'`\n    )\n  }\n\n  const jwk = {\n    kty: 'EC',\n    crv,\n    x: TypedArrayEncoder.toBase64URL(affinePoint.xBytes),\n    y: TypedArrayEncoder.toBase64URL(affinePoint.yBytes),\n  } satisfies KmsJwkPublicEc & { crv: Crv }\n\n  return jwk\n}\n"],"mappings":";;;;;;;;AAgBA,MAAaA,qBAAiE;CAC5E,SAAS;CACT,SAAS;CACT,SAAS;CACT,WAAW;CACZ;AAED,SAAgB,uBACd,WACA,EAAE,aAAa,UAAoC,EAAE,EACtC;CAIf,MAAM,cAAc,IAAI,YAHP,WAAW,KAAK,kBAAkB,WAAW,UAAU,EAAE,CAAC,EAC1D,WAAW,KAAK,kBAAkB,WAAW,UAAU,EAAE,CAAC,CAEpB;AAEvD,QAAO,aACF,YAAY,iBACZ,YAAY;;AAGnB,SAAgB,uBAA0D,WAA0B,KAAU;CAC5G,MAAM,cAAc,mBAAmB;AAEvC,KAAI,CAAC,YACH,OAAM,IAAI,mBAAmB,oBAAoB,IAAI,+DAA+D;CAGtH,IAAIC;AAEJ,KAAI,iCAAiC,WAAW,YAAY,CAC1D,eAAc,YAAY,oBAAoB,WAAW,YAAY;UAC5D,mCAAmC,WAAW,YAAY,CACnE,eAAc,YAAY,sBAAsB,WAAW,YAAY;KAEvE,OAAM,IAAI,mBACR,mCAAmC,IAAI,mEAAmE,UAAU,GAAG,iBAAiB,UAAU,OAAO,GAC1J;AAUH,QAPY;EACV,KAAK;EACL;EACA,GAAG,kBAAkB,YAAY,YAAY,OAAO;EACpD,GAAG,kBAAkB,YAAY,YAAY,OAAO;EACrD"}

package/build/modules/kms/jwk/kty/ec/ecSignature.d.mts

@@ -0,0 +1,24 @@
+import { AnyUint8Array, Uint8ArrayBuffer } from "../../../../../types.mjs";
+import { KmsJwkPublicEc } from "./ecJwk.mjs";
+
+//#region src/modules/kms/jwk/kty/ec/ecSignature.d.ts
+
+/**
+ * Converts a RAW EC signature to DER format
+ *
+ * @param rawSignature - Raw signature as r || s concatenated values
+ * @param crv - The EC crv of the key used for the signature
+ * @returns DER encoded signature
+ */
+declare function rawEcSignatureToDer(rawSignature: AnyUint8Array, crv: KmsJwkPublicEc['crv']): Uint8ArrayBuffer;
+/**
+ * Converts a DER encoded EC signature to RAW format
+ *
+ * @param derSignature - DER encoded signature
+ * @param crv - The EC crv of the key used for the signature
+ * @returns Raw signature as r || s concatenated values
+ */
+declare function derEcSignatureToRaw(derSignature: AnyUint8Array, crv: KmsJwkPublicEc['crv']): Uint8ArrayBuffer;
+//#endregion
+export { derEcSignatureToRaw, rawEcSignatureToDer };
+//# sourceMappingURL=ecSignature.d.mts.map