@credo-ts/core 0.6.1-pr-2091-20241119140918 → 0.6.1

package/build/crypto/webcrypto/CredoWebCrypto.mjs

@@ -0,0 +1,26 @@
+
+
+import { Hasher } from "../hashes/Hasher.mjs";
+import "../hashes/index.mjs";
+import { CredoSubtle } from "./CredoSubtle.mjs";
+import { CredoWalletWebCrypto } from "./CredoWalletWebCrypto.mjs";
+import * as core from "webcrypto-core";
+
+//#region src/crypto/webcrypto/CredoWebCrypto.ts
+var CredoWebCrypto = class extends core.Crypto {
+	constructor(agentContext) {
+		super();
+		this.walletWebCrypto = new CredoWalletWebCrypto(agentContext);
+		this.subtle = new CredoSubtle(this.walletWebCrypto);
+	}
+	getRandomValues(array) {
+		return this.walletWebCrypto.generateRandomValues(array);
+	}
+	digest(algorithm, data) {
+		return Hasher.hash(new Uint8Array(data), algorithm).buffer;
+	}
+};
+
+//#endregion
+export { CredoWebCrypto };
+//# sourceMappingURL=CredoWebCrypto.mjs.map

package/build/crypto/webcrypto/CredoWebCrypto.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredoWebCrypto.mjs","names":[],"sources":["../../../src/crypto/webcrypto/CredoWebCrypto.ts"],"sourcesContent":["import * as core from 'webcrypto-core'\nimport type { AgentContext } from '../../agent'\n\nimport { Hasher } from '../hashes'\n\nimport { CredoSubtle } from './CredoSubtle'\nimport { CredoWalletWebCrypto } from './CredoWalletWebCrypto'\n\nexport class CredoWebCrypto extends core.Crypto {\n  private walletWebCrypto: CredoWalletWebCrypto\n  public subtle: CredoSubtle\n\n  public constructor(agentContext: AgentContext) {\n    super()\n    this.walletWebCrypto = new CredoWalletWebCrypto(agentContext)\n    this.subtle = new CredoSubtle(this.walletWebCrypto)\n  }\n\n  public getRandomValues<T extends ArrayBufferView | null>(array: T): T {\n    return this.walletWebCrypto.generateRandomValues(array)\n  }\n\n  public digest(algorithm: string, data: ArrayBuffer): ArrayBuffer {\n    return Hasher.hash(new Uint8Array(data), algorithm).buffer\n  }\n}\n"],"mappings":";;;;;;;;;AAQA,IAAa,iBAAb,cAAoC,KAAK,OAAO;CAI9C,AAAO,YAAY,cAA4B;AAC7C,SAAO;AACP,OAAK,kBAAkB,IAAI,qBAAqB,aAAa;AAC7D,OAAK,SAAS,IAAI,YAAY,KAAK,gBAAgB;;CAGrD,AAAO,gBAAkD,OAAa;AACpE,SAAO,KAAK,gBAAgB,qBAAqB,MAAM;;CAGzD,AAAO,OAAO,WAAmB,MAAgC;AAC/D,SAAO,OAAO,KAAK,IAAI,WAAW,KAAK,EAAE,UAAU,CAAC"}

package/build/crypto/webcrypto/CredoWebCryptoError.mjs

@@ -0,0 +1,11 @@
+
+
+import { CredoError } from "../../error/CredoError.mjs";
+import "../../error/index.mjs";
+
+//#region src/crypto/webcrypto/CredoWebCryptoError.ts
+var CredoWebCryptoError = class extends CredoError {};
+
+//#endregion
+export { CredoWebCryptoError };
+//# sourceMappingURL=CredoWebCryptoError.mjs.map

package/build/crypto/webcrypto/CredoWebCryptoError.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredoWebCryptoError.mjs","names":[],"sources":["../../../src/crypto/webcrypto/CredoWebCryptoError.ts"],"sourcesContent":["import { CredoError } from '../../error'\n\nexport class CredoWebCryptoError extends CredoError {}\n"],"mappings":";;;;;;AAEA,IAAa,sBAAb,cAAyC,WAAW"}

package/build/crypto/webcrypto/CredoWebCryptoKey.d.mts

@@ -0,0 +1,17 @@
+import { KeyGenAlgorithm, KeyType, KeyUsage } from "./types.mjs";
+import { PublicJwk } from "../../modules/kms/jwk/PublicJwk.mjs";
+import "../../modules/kms/index.mjs";
+import * as core from "webcrypto-core";
+
+//#region src/crypto/webcrypto/CredoWebCryptoKey.d.ts
+declare class CredoWebCryptoKey extends core.CryptoKey {
+  publicJwk: PublicJwk;
+  algorithm: KeyGenAlgorithm;
+  extractable: boolean;
+  type: KeyType;
+  usages: Array<KeyUsage>;
+  constructor(publicJwk: PublicJwk, algorithm: KeyGenAlgorithm, extractable: boolean, type: KeyType, usages: Array<KeyUsage>);
+}
+//#endregion
+export { CredoWebCryptoKey };
+//# sourceMappingURL=CredoWebCryptoKey.d.mts.map

package/build/crypto/webcrypto/CredoWebCryptoKey.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredoWebCryptoKey.d.mts","names":[],"sources":["../../../src/crypto/webcrypto/CredoWebCryptoKey.ts"],"sourcesContent":[],"mappings":";;;;;;cAIa,iBAAA,SAA0B,IAAA,CAAK,SAAA;aAEtB;aACS;;QAEL;EALb,MAAA,EAMe,KANf,CAMqB,QANH,CAAA;EAET,WAAA,CAAA,SAAA,EAAA,SAAA,EAAA,SAAA,EACS,eADT,EAAA,WAAA,EAAA,OAAA,EAAA,IAAA,EAGI,OAHJ,EAAA,MAAA,EAIM,KAJN,CAIY,QAJZ,CAAA"}

package/build/crypto/webcrypto/CredoWebCryptoKey.mjs

@@ -0,0 +1,20 @@
+
+
+import "../../modules/kms/index.mjs";
+import * as core from "webcrypto-core";
+
+//#region src/crypto/webcrypto/CredoWebCryptoKey.ts
+var CredoWebCryptoKey = class extends core.CryptoKey {
+	constructor(publicJwk, algorithm, extractable, type, usages) {
+		super();
+		this.publicJwk = publicJwk;
+		this.algorithm = algorithm;
+		this.extractable = extractable;
+		this.type = type;
+		this.usages = usages;
+	}
+};
+
+//#endregion
+export { CredoWebCryptoKey };
+//# sourceMappingURL=CredoWebCryptoKey.mjs.map

package/build/crypto/webcrypto/CredoWebCryptoKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredoWebCryptoKey.mjs","names":["publicJwk: PublicJwk","algorithm: KeyGenAlgorithm","extractable: boolean","type: KeyType","usages: Array<KeyUsage>"],"sources":["../../../src/crypto/webcrypto/CredoWebCryptoKey.ts"],"sourcesContent":["import * as core from 'webcrypto-core'\nimport { PublicJwk } from '../../modules/kms'\nimport type { KeyGenAlgorithm, KeyType, KeyUsage } from './types'\n\nexport class CredoWebCryptoKey extends core.CryptoKey {\n  public constructor(\n    public publicJwk: PublicJwk,\n    public override algorithm: KeyGenAlgorithm,\n    public override extractable: boolean,\n    public override type: KeyType,\n    public override usages: Array<KeyUsage>\n  ) {\n    super()\n  }\n}\n"],"mappings":";;;;;;AAIA,IAAa,oBAAb,cAAuC,KAAK,UAAU;CACpD,AAAO,YACL,AAAOA,WACP,AAAgBC,WAChB,AAAgBC,aAChB,AAAgBC,MAChB,AAAgBC,QAChB;AACA,SAAO;EANA;EACS;EACA;EACA;EACA"}

package/build/crypto/webcrypto/algorithmIdentifiers.mjs

@@ -0,0 +1,62 @@
+
+
+import { id_ecPublicKey, id_secp256r1, id_secp384r1, id_secp521r1 } from "@peculiar/asn1-ecc";
+import { AsnObjectIdentifierConverter } from "@peculiar/asn1-schema";
+import { AlgorithmIdentifier } from "@peculiar/asn1-x509";
+import { id_rsaEncryption } from "@peculiar/asn1-rsa";
+
+//#region src/crypto/webcrypto/algorithmIdentifiers.ts
+const ecPublicKeyAlgorithmIdentifier = (objectId) => new AlgorithmIdentifier({
+	algorithm: id_ecPublicKey,
+	parameters: AsnObjectIdentifierConverter.toASN(objectId).toBER()
+});
+/**
+*
+* https://oid-rep.orange-labs.fr/get/1.2.840.10045.3.1.7
+*
+*/
+const ecPublicKeyWithP256AlgorithmIdentifier = ecPublicKeyAlgorithmIdentifier(id_secp256r1);
+/**
+*
+* https://oid-rep.orange-labs.fr/get/1.3.132.0.34
+*
+*/
+const ecPublicKeyWithP384AlgorithmIdentifier = ecPublicKeyAlgorithmIdentifier(id_secp384r1);
+/**
+*
+* https://oid-rep.orange-labs.fr/get/1.3.132.0.35
+*
+*/
+const ecPublicKeyWithP521AlgorithmIdentifier = ecPublicKeyAlgorithmIdentifier(id_secp521r1);
+/**
+*
+* https://oid-rep.orange-labs.fr/get/1.3.132.0.10
+*
+*/
+const ecPublicKeyWithK256AlgorithmIdentifier = ecPublicKeyAlgorithmIdentifier("1.3.132.0.10");
+/**
+*
+* from: https://datatracker.ietf.org/doc/html/rfc8410#section-3
+*
+*/
+const ed25519AlgorithmIdentifier = new AlgorithmIdentifier({ algorithm: "1.3.101.112" });
+/**
+*
+* from: https://datatracker.ietf.org/doc/html/rfc8410#section-3
+*
+*/
+const x25519AlgorithmIdentifier = new AlgorithmIdentifier({ algorithm: "1.3.101.110" });
+/**
+*
+* RSA algorithm identifier
+* https://oid-rep.orange-labs.fr/get/1.2.840.113549.1.1.1
+*
+*/
+const rsaKeyAlgorithmIdentifier = new AlgorithmIdentifier({
+	algorithm: id_rsaEncryption,
+	parameters: null
+});
+
+//#endregion
+export { ecPublicKeyWithK256AlgorithmIdentifier, ecPublicKeyWithP256AlgorithmIdentifier, ecPublicKeyWithP384AlgorithmIdentifier, ecPublicKeyWithP521AlgorithmIdentifier, ed25519AlgorithmIdentifier, rsaKeyAlgorithmIdentifier, x25519AlgorithmIdentifier };
+//# sourceMappingURL=algorithmIdentifiers.mjs.map

package/build/crypto/webcrypto/algorithmIdentifiers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"algorithmIdentifiers.mjs","names":[],"sources":["../../../src/crypto/webcrypto/algorithmIdentifiers.ts"],"sourcesContent":["import { id_ecPublicKey, id_secp256r1, id_secp384r1, id_secp521r1 } from '@peculiar/asn1-ecc'\nimport { id_rsaEncryption } from '@peculiar/asn1-rsa'\nimport { AsnObjectIdentifierConverter } from '@peculiar/asn1-schema'\nimport { AlgorithmIdentifier } from '@peculiar/asn1-x509'\n\nconst ecPublicKeyAlgorithmIdentifier = (objectId: string) =>\n  new AlgorithmIdentifier({\n    algorithm: id_ecPublicKey,\n    parameters: AsnObjectIdentifierConverter.toASN(objectId).toBER(),\n  })\n\n/**\n *\n * https://oid-rep.orange-labs.fr/get/1.2.840.10045.3.1.7\n *\n */\nexport const ecPublicKeyWithP256AlgorithmIdentifier = ecPublicKeyAlgorithmIdentifier(id_secp256r1)\n/**\n *\n * https://oid-rep.orange-labs.fr/get/1.3.132.0.34\n *\n */\nexport const ecPublicKeyWithP384AlgorithmIdentifier = ecPublicKeyAlgorithmIdentifier(id_secp384r1)\n/**\n *\n * https://oid-rep.orange-labs.fr/get/1.3.132.0.35\n *\n */\nexport const ecPublicKeyWithP521AlgorithmIdentifier = ecPublicKeyAlgorithmIdentifier(id_secp521r1)\n/**\n *\n * https://oid-rep.orange-labs.fr/get/1.3.132.0.10\n *\n */\nexport const ecPublicKeyWithK256AlgorithmIdentifier = ecPublicKeyAlgorithmIdentifier('1.3.132.0.10')\n\n/**\n *\n * from: https://datatracker.ietf.org/doc/html/rfc8410#section-3\n *\n */\nexport const ed25519AlgorithmIdentifier = new AlgorithmIdentifier({ algorithm: '1.3.101.112' })\n\n/**\n *\n * from: https://datatracker.ietf.org/doc/html/rfc8410#section-3\n *\n */\nexport const x25519AlgorithmIdentifier = new AlgorithmIdentifier({ algorithm: '1.3.101.110' })\n\n/**\n *\n * RSA algorithm identifier\n * https://oid-rep.orange-labs.fr/get/1.2.840.113549.1.1.1\n *\n */\nexport const rsaKeyAlgorithmIdentifier = new AlgorithmIdentifier({\n  algorithm: id_rsaEncryption,\n  parameters: null,\n})\n"],"mappings":";;;;;;;;AAKA,MAAM,kCAAkC,aACtC,IAAI,oBAAoB;CACtB,WAAW;CACX,YAAY,6BAA6B,MAAM,SAAS,CAAC,OAAO;CACjE,CAAC;;;;;;AAOJ,MAAa,yCAAyC,+BAA+B,aAAa;;;;;;AAMlG,MAAa,yCAAyC,+BAA+B,aAAa;;;;;;AAMlG,MAAa,yCAAyC,+BAA+B,aAAa;;;;;;AAMlG,MAAa,yCAAyC,+BAA+B,eAAe;;;;;;AAOpG,MAAa,6BAA6B,IAAI,oBAAoB,EAAE,WAAW,eAAe,CAAC;;;;;;AAO/F,MAAa,4BAA4B,IAAI,oBAAoB,EAAE,WAAW,eAAe,CAAC;;;;;;;AAQ9F,MAAa,4BAA4B,IAAI,oBAAoB;CAC/D,WAAW;CACX,YAAY;CACb,CAAC"}

package/build/crypto/webcrypto/index.d.mts

@@ -0,0 +1,5 @@
+import { KeyGenAlgorithm, KeySignParams } from "./types.mjs";
+import { CredoWebCryptoKey } from "./CredoWebCryptoKey.mjs";
+import { CredoWebCrypto } from "./CredoWebCrypto.mjs";
+import { publicJwkToCryptoKeyAlgorithm } from "./utils/keyAlgorithmConversion.mjs";
+import "./utils/index.mjs";

package/build/crypto/webcrypto/index.mjs

@@ -0,0 +1,6 @@
+
+
+import { CredoWebCryptoKey } from "./CredoWebCryptoKey.mjs";
+import { publicJwkToCryptoKeyAlgorithm } from "./utils/keyAlgorithmConversion.mjs";
+import "./utils/index.mjs";
+import { CredoWebCrypto } from "./CredoWebCrypto.mjs";

package/build/crypto/webcrypto/providers/CredoEcdsaProvider.mjs

@@ -0,0 +1,40 @@
+
+
+import { PublicJwk } from "../../../modules/kms/jwk/PublicJwk.mjs";
+import "../../../modules/kms/index.mjs";
+import { CredoWebCryptoKey } from "../CredoWebCryptoKey.mjs";
+import * as core from "webcrypto-core";
+
+//#region src/crypto/webcrypto/providers/CredoEcdsaProvider.ts
+var CredoEcdsaProvider = class extends core.EcdsaProvider {
+	constructor(walletWebCrypto) {
+		super();
+		this.walletWebCrypto = walletWebCrypto;
+	}
+	async onSign(algorithm, key, data) {
+		return new Uint8Array(await this.walletWebCrypto.sign(key, new Uint8Array(data), algorithm)).buffer;
+	}
+	async onVerify(algorithm, key, signature, data) {
+		return this.walletWebCrypto.verify(key, algorithm, new Uint8Array(data), new Uint8Array(signature));
+	}
+	async onGenerateKey(algorithm, extractable, keyUsages) {
+		const key = await this.walletWebCrypto.generate(algorithm);
+		const publicJwk = PublicJwk.fromPublicJwk(key.publicJwk);
+		return {
+			publicKey: new CredoWebCryptoKey(publicJwk, algorithm, extractable, "public", keyUsages),
+			privateKey: new CredoWebCryptoKey(publicJwk, algorithm, extractable, "private", keyUsages)
+		};
+	}
+	async onExportKey(format, key) {
+		const exported = await this.walletWebCrypto.exportKey(format, key);
+		if (exported instanceof Uint8Array) return new Uint8Array(exported).buffer;
+		return exported;
+	}
+	async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+		return this.walletWebCrypto.importKey(format, keyData.kty ? keyData : new Uint8Array(keyData), algorithm, extractable, keyUsages);
+	}
+};
+
+//#endregion
+export { CredoEcdsaProvider };
+//# sourceMappingURL=CredoEcdsaProvider.mjs.map

package/build/crypto/webcrypto/providers/CredoEcdsaProvider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredoEcdsaProvider.mjs","names":["walletWebCrypto: CredoWalletWebCrypto"],"sources":["../../../../src/crypto/webcrypto/providers/CredoEcdsaProvider.ts"],"sourcesContent":["import * as core from 'webcrypto-core'\nimport { PublicJwk } from '../../../modules/kms'\nimport type { CredoWalletWebCrypto } from '../CredoWalletWebCrypto'\nimport { CredoWebCryptoKey } from '../CredoWebCryptoKey'\nimport type {\n  CredoWebCryptoKeyPair,\n  EcdsaParams,\n  EcKeyGenParams,\n  EcKeyImportParams,\n  JsonWebKey,\n  KeyFormat,\n  KeyUsage,\n} from '../types'\n\nexport class CredoEcdsaProvider extends core.EcdsaProvider {\n  public constructor(private walletWebCrypto: CredoWalletWebCrypto) {\n    super()\n  }\n\n  public async onSign(algorithm: EcdsaParams, key: CredoWebCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {\n    return new Uint8Array(await this.walletWebCrypto.sign(key, new Uint8Array(data), algorithm)).buffer\n  }\n\n  public async onVerify(\n    algorithm: EcdsaParams,\n    key: CredoWebCryptoKey,\n    signature: ArrayBuffer,\n    data: ArrayBuffer\n  ): Promise<boolean> {\n    return this.walletWebCrypto.verify(key, algorithm, new Uint8Array(data), new Uint8Array(signature))\n  }\n\n  public async onGenerateKey(\n    algorithm: EcKeyGenParams,\n    extractable: boolean,\n    keyUsages: KeyUsage[]\n  ): Promise<CredoWebCryptoKeyPair> {\n    const key = await this.walletWebCrypto.generate(algorithm)\n    const publicJwk = PublicJwk.fromPublicJwk(key.publicJwk)\n\n    return {\n      publicKey: new CredoWebCryptoKey(publicJwk, algorithm, extractable, 'public', keyUsages),\n      privateKey: new CredoWebCryptoKey(publicJwk, algorithm, extractable, 'private', keyUsages),\n    }\n  }\n\n  public async onExportKey(format: KeyFormat, key: CredoWebCryptoKey): Promise<JsonWebKey | ArrayBuffer> {\n    const exported = await this.walletWebCrypto.exportKey(format, key)\n    if (exported instanceof Uint8Array) return new Uint8Array(exported).buffer\n    return exported\n  }\n\n  public async onImportKey(\n    format: KeyFormat,\n    keyData: JsonWebKey | ArrayBuffer,\n    algorithm: EcKeyImportParams,\n    extractable: boolean,\n    keyUsages: KeyUsage[]\n  ): Promise<CredoWebCryptoKey> {\n    return this.walletWebCrypto.importKey(\n      format,\n      (keyData as JsonWebKey).kty ? (keyData as JsonWebKey) : new Uint8Array(keyData as ArrayBuffer),\n      algorithm,\n      extractable,\n      keyUsages\n    )\n  }\n}\n"],"mappings":";;;;;;;;AAcA,IAAa,qBAAb,cAAwC,KAAK,cAAc;CACzD,AAAO,YAAY,AAAQA,iBAAuC;AAChE,SAAO;EADkB;;CAI3B,MAAa,OAAO,WAAwB,KAAwB,MAAyC;AAC3G,SAAO,IAAI,WAAW,MAAM,KAAK,gBAAgB,KAAK,KAAK,IAAI,WAAW,KAAK,EAAE,UAAU,CAAC,CAAC;;CAG/F,MAAa,SACX,WACA,KACA,WACA,MACkB;AAClB,SAAO,KAAK,gBAAgB,OAAO,KAAK,WAAW,IAAI,WAAW,KAAK,EAAE,IAAI,WAAW,UAAU,CAAC;;CAGrG,MAAa,cACX,WACA,aACA,WACgC;EAChC,MAAM,MAAM,MAAM,KAAK,gBAAgB,SAAS,UAAU;EAC1D,MAAM,YAAY,UAAU,cAAc,IAAI,UAAU;AAExD,SAAO;GACL,WAAW,IAAI,kBAAkB,WAAW,WAAW,aAAa,UAAU,UAAU;GACxF,YAAY,IAAI,kBAAkB,WAAW,WAAW,aAAa,WAAW,UAAU;GAC3F;;CAGH,MAAa,YAAY,QAAmB,KAA2D;EACrG,MAAM,WAAW,MAAM,KAAK,gBAAgB,UAAU,QAAQ,IAAI;AAClE,MAAI,oBAAoB,WAAY,QAAO,IAAI,WAAW,SAAS,CAAC;AACpE,SAAO;;CAGT,MAAa,YACX,QACA,SACA,WACA,aACA,WAC4B;AAC5B,SAAO,KAAK,gBAAgB,UAC1B,QACC,QAAuB,MAAO,UAAyB,IAAI,WAAW,QAAuB,EAC9F,WACA,aACA,UACD"}

package/build/crypto/webcrypto/providers/CredoEd25519Provider.mjs

@@ -0,0 +1,40 @@
+
+
+import { PublicJwk } from "../../../modules/kms/jwk/PublicJwk.mjs";
+import "../../../modules/kms/index.mjs";
+import { CredoWebCryptoKey } from "../CredoWebCryptoKey.mjs";
+import * as core from "webcrypto-core";
+
+//#region src/crypto/webcrypto/providers/CredoEd25519Provider.ts
+var CredoEd25519Provider = class extends core.Ed25519Provider {
+	constructor(walletWebCrypto) {
+		super();
+		this.walletWebCrypto = walletWebCrypto;
+	}
+	async onSign(algorithm, key, data) {
+		return new Uint8Array(await this.walletWebCrypto.sign(key, new Uint8Array(data), algorithm)).buffer;
+	}
+	async onVerify(algorithm, key, signature, data) {
+		return this.walletWebCrypto.verify(key, algorithm, new Uint8Array(data), new Uint8Array(signature));
+	}
+	async onGenerateKey(algorithm, extractable, keyUsages) {
+		const key = await this.walletWebCrypto.generate(algorithm);
+		const publicJwk = PublicJwk.fromPublicJwk(key.publicJwk);
+		return {
+			publicKey: new CredoWebCryptoKey(publicJwk, algorithm, extractable, "public", keyUsages),
+			privateKey: new CredoWebCryptoKey(publicJwk, algorithm, extractable, "private", keyUsages)
+		};
+	}
+	async onExportKey(format, key) {
+		const exported = await this.walletWebCrypto.exportKey(format, key);
+		if (exported instanceof Uint8Array) return new Uint8Array(exported).buffer;
+		return exported;
+	}
+	async onImportKey(format, keyData, algorithm, extractable, keyUsages) {
+		return this.walletWebCrypto.importKey(format, keyData.kty ? keyData : new Uint8Array(keyData), algorithm, extractable, keyUsages);
+	}
+};
+
+//#endregion
+export { CredoEd25519Provider };
+//# sourceMappingURL=CredoEd25519Provider.mjs.map

package/build/crypto/webcrypto/providers/CredoEd25519Provider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredoEd25519Provider.mjs","names":["walletWebCrypto: CredoWalletWebCrypto"],"sources":["../../../../src/crypto/webcrypto/providers/CredoEd25519Provider.ts"],"sourcesContent":["import * as core from 'webcrypto-core'\nimport { PublicJwk } from '../../../modules/kms'\nimport type { CredoWalletWebCrypto } from '../CredoWalletWebCrypto'\nimport { CredoWebCryptoKey } from '../CredoWebCryptoKey'\nimport type {\n  CredoWebCryptoKeyPair,\n  Ed25519KeyGenParams,\n  Ed25519KeyImportParams,\n  Ed25519Params,\n  JsonWebKey,\n  KeyFormat,\n  KeyUsage,\n} from '../types'\n\nexport class CredoEd25519Provider extends core.Ed25519Provider {\n  public constructor(private walletWebCrypto: CredoWalletWebCrypto) {\n    super()\n  }\n\n  public async onSign(algorithm: Ed25519Params, key: CredoWebCryptoKey, data: ArrayBuffer): Promise<ArrayBuffer> {\n    return new Uint8Array(await this.walletWebCrypto.sign(key, new Uint8Array(data), algorithm)).buffer\n  }\n\n  public async onVerify(\n    algorithm: Ed25519Params,\n    key: CredoWebCryptoKey,\n    signature: ArrayBuffer,\n    data: ArrayBuffer\n  ): Promise<boolean> {\n    return this.walletWebCrypto.verify(key, algorithm, new Uint8Array(data), new Uint8Array(signature))\n  }\n\n  public async onGenerateKey(\n    algorithm: Ed25519KeyGenParams,\n    extractable: boolean,\n    keyUsages: KeyUsage[]\n  ): Promise<CredoWebCryptoKeyPair> {\n    const key = await this.walletWebCrypto.generate(algorithm)\n    const publicJwk = PublicJwk.fromPublicJwk(key.publicJwk)\n\n    return {\n      publicKey: new CredoWebCryptoKey(publicJwk, algorithm, extractable, 'public', keyUsages),\n      privateKey: new CredoWebCryptoKey(publicJwk, algorithm, extractable, 'private', keyUsages),\n    }\n  }\n\n  public async onExportKey(format: KeyFormat, key: CredoWebCryptoKey): Promise<JsonWebKey | ArrayBuffer> {\n    const exported = await this.walletWebCrypto.exportKey(format, key)\n    if (exported instanceof Uint8Array) return new Uint8Array(exported).buffer\n    return exported\n  }\n\n  public async onImportKey(\n    format: KeyFormat,\n    keyData: JsonWebKey | ArrayBuffer,\n    algorithm: Ed25519KeyImportParams,\n    extractable: boolean,\n    keyUsages: KeyUsage[]\n  ): Promise<CredoWebCryptoKey> {\n    return this.walletWebCrypto.importKey(\n      format,\n      (keyData as JsonWebKey).kty ? (keyData as JsonWebKey) : new Uint8Array(keyData as ArrayBuffer),\n      algorithm,\n      extractable,\n      keyUsages\n    )\n  }\n}\n"],"mappings":";;;;;;;;AAcA,IAAa,uBAAb,cAA0C,KAAK,gBAAgB;CAC7D,AAAO,YAAY,AAAQA,iBAAuC;AAChE,SAAO;EADkB;;CAI3B,MAAa,OAAO,WAA0B,KAAwB,MAAyC;AAC7G,SAAO,IAAI,WAAW,MAAM,KAAK,gBAAgB,KAAK,KAAK,IAAI,WAAW,KAAK,EAAE,UAAU,CAAC,CAAC;;CAG/F,MAAa,SACX,WACA,KACA,WACA,MACkB;AAClB,SAAO,KAAK,gBAAgB,OAAO,KAAK,WAAW,IAAI,WAAW,KAAK,EAAE,IAAI,WAAW,UAAU,CAAC;;CAGrG,MAAa,cACX,WACA,aACA,WACgC;EAChC,MAAM,MAAM,MAAM,KAAK,gBAAgB,SAAS,UAAU;EAC1D,MAAM,YAAY,UAAU,cAAc,IAAI,UAAU;AAExD,SAAO;GACL,WAAW,IAAI,kBAAkB,WAAW,WAAW,aAAa,UAAU,UAAU;GACxF,YAAY,IAAI,kBAAkB,WAAW,WAAW,aAAa,WAAW,UAAU;GAC3F;;CAGH,MAAa,YAAY,QAAmB,KAA2D;EACrG,MAAM,WAAW,MAAM,KAAK,gBAAgB,UAAU,QAAQ,IAAI;AAClE,MAAI,oBAAoB,WAAY,QAAO,IAAI,WAAW,SAAS,CAAC;AACpE,SAAO;;CAGT,MAAa,YACX,QACA,SACA,WACA,aACA,WAC4B;AAC5B,SAAO,KAAK,gBAAgB,UAC1B,QACC,QAAuB,MAAO,UAAyB,IAAI,WAAW,QAAuB,EAC9F,WACA,aACA,UACD"}

package/build/crypto/webcrypto/providers/CredoSha1Provider.mjs

@@ -0,0 +1,24 @@
+
+
+import { Sha1 } from "../../hashes/Sha1.mjs";
+import "../../hashes/index.mjs";
+import * as core from "webcrypto-core";
+
+//#region src/crypto/webcrypto/providers/CredoSha1Provider.ts
+var CredoSha1Provider = class extends core.ProviderCrypto {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "SHA-1";
+		this.usages = [];
+	}
+	async onDigest(algorithm, data) {
+		switch (algorithm.name.toUpperCase()) {
+			case "SHA-1": return new Sha1().hash(new Uint8Array(data)).buffer;
+			default: throw new Error(`Hashing algorithm: ${JSON.stringify(algorithm)} is not supported`);
+		}
+	}
+};
+
+//#endregion
+export { CredoSha1Provider };
+//# sourceMappingURL=CredoSha1Provider.mjs.map

package/build/crypto/webcrypto/providers/CredoSha1Provider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredoSha1Provider.mjs","names":[],"sources":["../../../../src/crypto/webcrypto/providers/CredoSha1Provider.ts"],"sourcesContent":["import * as core from 'webcrypto-core'\nimport { Sha1 } from '../../hashes'\nimport type { HashAlgorithm } from '../types'\n\nexport class CredoSha1Provider extends core.ProviderCrypto {\n  public name = 'SHA-1'\n  public usages = []\n\n  public override async onDigest(algorithm: HashAlgorithm, data: ArrayBuffer): Promise<ArrayBuffer> {\n    switch (algorithm.name.toUpperCase()) {\n      case 'SHA-1': {\n        const hash = new Sha1().hash(new Uint8Array(data))\n        return hash.buffer\n      }\n      default:\n        throw new Error(`Hashing algorithm: ${JSON.stringify(algorithm)} is not supported`)\n    }\n  }\n}\n"],"mappings":";;;;;;;AAIA,IAAa,oBAAb,cAAuC,KAAK,eAAe;;;OAClD,OAAO;OACP,SAAS,EAAE;;CAElB,MAAsB,SAAS,WAA0B,MAAyC;AAChG,UAAQ,UAAU,KAAK,aAAa,EAApC;GACE,KAAK,QAEH,QADa,IAAI,MAAM,CAAC,KAAK,IAAI,WAAW,KAAK,CAAC,CACtC;GAEd,QACE,OAAM,IAAI,MAAM,sBAAsB,KAAK,UAAU,UAAU,CAAC,mBAAmB"}

package/build/crypto/webcrypto/providers/CredoSha256Provider.mjs

@@ -0,0 +1,24 @@
+
+
+import { Sha256 } from "../../hashes/Sha256.mjs";
+import "../../hashes/index.mjs";
+import * as core from "webcrypto-core";
+
+//#region src/crypto/webcrypto/providers/CredoSha256Provider.ts
+var CredoSha256Provider = class extends core.ProviderCrypto {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "SHA-256";
+		this.usages = [];
+	}
+	async onDigest(algorithm, data) {
+		switch (algorithm.name.toUpperCase()) {
+			case "SHA-256": return new Sha256().hash(new Uint8Array(data)).buffer;
+			default: throw new Error(`Hashing algorithm: ${JSON.stringify(algorithm)} is not supported`);
+		}
+	}
+};
+
+//#endregion
+export { CredoSha256Provider };
+//# sourceMappingURL=CredoSha256Provider.mjs.map

package/build/crypto/webcrypto/providers/CredoSha256Provider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CredoSha256Provider.mjs","names":[],"sources":["../../../../src/crypto/webcrypto/providers/CredoSha256Provider.ts"],"sourcesContent":["import * as core from 'webcrypto-core'\nimport { Sha256 } from '../../hashes'\nimport type { HashAlgorithm } from '../types'\n\nexport class CredoSha256Provider extends core.ProviderCrypto {\n  public name = 'SHA-256'\n  public usages = []\n\n  public override async onDigest(algorithm: HashAlgorithm, data: ArrayBuffer): Promise<ArrayBuffer> {\n    switch (algorithm.name.toUpperCase()) {\n      case 'SHA-256': {\n        const hash = new Sha256().hash(new Uint8Array(data))\n        return hash.buffer\n      }\n      default:\n        throw new Error(`Hashing algorithm: ${JSON.stringify(algorithm)} is not supported`)\n    }\n  }\n}\n"],"mappings":";;;;;;;AAIA,IAAa,sBAAb,cAAyC,KAAK,eAAe;;;OACpD,OAAO;OACP,SAAS,EAAE;;CAElB,MAAsB,SAAS,WAA0B,MAAyC;AAChG,UAAQ,UAAU,KAAK,aAAa,EAApC;GACE,KAAK,UAEH,QADa,IAAI,QAAQ,CAAC,KAAK,IAAI,WAAW,KAAK,CAAC,CACxC;GAEd,QACE,OAAM,IAAI,MAAM,sBAAsB,KAAK,UAAU,UAAU,CAAC,mBAAmB"}

package/build/crypto/webcrypto/providers/index.mjs

@@ -0,0 +1,5 @@
+
+
+import { CredoEcdsaProvider } from "./CredoEcdsaProvider.mjs";
+import { CredoSha1Provider } from "./CredoSha1Provider.mjs";
+import { CredoSha256Provider } from "./CredoSha256Provider.mjs";

package/build/crypto/webcrypto/types.d.mts

@@ -0,0 +1,62 @@
+import { AnyUint8Array } from "../../types.mjs";
+import { Jwk } from "../../modules/kms/jwk/jwk.mjs";
+import "./CredoWebCryptoKey.mjs";
+import "../../modules/kms/index.mjs";
+
+//#region src/crypto/webcrypto/types.d.ts
+type HashAlgorithmIdentifier = 'SHA-256' | 'SHA-384' | 'SHA-512';
+type EcdsaParams = {
+  name: 'ECDSA';
+  hash: {
+    name: HashAlgorithmIdentifier;
+  } | HashAlgorithmIdentifier;
+};
+type Ed25519Params = {
+  name: 'Ed25519';
+};
+type RsaSsaParams = {
+  name: 'RSASSA-PKCS1-v1_5' | 'RSA-PSS';
+  hash: {
+    name: HashAlgorithmIdentifier;
+  } | HashAlgorithmIdentifier;
+  saltLength?: number;
+};
+type Ed25519KeyGenParams = {
+  name: 'Ed25519';
+};
+type EcKeyGenParams = {
+  name: 'ECDSA';
+  namedCurve: 'P-256' | 'P-384' | 'P-521' | 'K-256';
+};
+type RsaHashedKeyGenParams = {
+  name: 'RSASSA-PKCS1-v1_5' | 'RSA-PSS';
+  modulusLength: number;
+  publicExponent: AnyUint8Array;
+  hash: {
+    name: HashAlgorithmIdentifier;
+  };
+};
+type Ed25519KeyImportParams = {
+  name: 'Ed25519';
+};
+type EcKeyImportParams = {
+  name: 'ECDSA';
+  namedCurve: 'P-256' | 'P-384' | 'K-256' | 'P-521';
+};
+type RsaHashedImportParams = {
+  name: 'RSASSA-PKCS1-v1_5' | 'RSA-PSS';
+  hash: {
+    name: HashAlgorithmIdentifier;
+  };
+};
+type KeyUsage = 'sign' | 'verify' | 'encrypt' | 'decrypt' | 'wrapKey' | 'unwrapKey' | 'deriveKey' | 'deriveBits';
+type KeyFormat = 'jwk' | 'pkcs8' | 'spki' | 'raw';
+type KeyType = 'private' | 'public' | 'secret';
+type JsonWebKey = Jwk;
+type KeyImportParams = EcKeyImportParams | Ed25519KeyImportParams | RsaHashedImportParams;
+type KeyGenAlgorithm = EcKeyGenParams | Ed25519KeyGenParams | RsaHashedKeyGenParams;
+type KeySignParams = EcdsaParams | Ed25519Params | RsaSsaParams;
+type KeyVerifyParams = EcdsaParams | Ed25519Params | RsaSsaParams;
+//#endregion
+export { JsonWebKey, KeyFormat, KeyGenAlgorithm, KeyImportParams, KeySignParams, KeyType, KeyUsage, KeyVerifyParams };
+//# sourceMappingURL=types.d.mts.map

package/build/crypto/webcrypto/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/crypto/webcrypto/types.ts"],"sourcesContent":[],"mappings":";;;;;;KAwBK,uBAAA;AAAA,KAQO,WAAA,GARP;EAQO,IAAA,EAAA,OAAA;EAKA,IAAA,EAAA;IAEA,IAAA,EALI,uBAOA;EAUJ,CAAA,GAjBgC,uBAiBb;AAE/B,CAAA;AAKY,KArBA,aAAA,GAqBqB;EAarB,IAAA,EAAA,SAAA;AAEZ,CAAA;AAKY,KAvCA,YAAA,GAuCA;EAKA,IAAA,EAAA,mBAAQ,GAAA,SAAA;EACR,IAAA,EAAA;IACA,IAAA,EA5CI,uBA4CG;EAEP,CAAA,GA9CgC,uBA8CnB;EAIb,UAAA,CAAA,EAAA,MAAe;CAAG;AAAoB,KAxCtC,mBAAA,GAwCsC;EAAyB,IAAA,EAAA,SAAA;CAAqB;AACpF,KAvCA,cAAA,GAuCe;EAAG,IAAA,EAAA,OAAA;EAAiB,UAAA,EAAA,OAAA,GAAA,OAAA,GAAA,OAAA,GAAA,OAAA;CAAsB;AAAqB,KAlC9E,qBAAA,GAkC8E;EAC9E,IAAA,EAAA,mBAAa,GAAA,SAAA;EAAG,aAAA,EAAA,MAAA;EAAc,cAAA,EAhCxB,aAgCwB;EAAgB,IAAA,EAAA;IAAY,IAAA,EA/BtD,uBA+BsD;EAC1D,CAAA;CAAkB;AAAc,KAvBhC,sBAAA,GAuBgC;EAAgB,IAAA,EAAA,SAAA;CAAY;KArB5D,iBAAA;;;;KAKA,qBAAA;;;UAEI;;;KAGJ,QAAA;KACA,SAAA;KACA,OAAA;KAEA,UAAA,GAAa;KAIb,eAAA,GAAkB,oBAAoB,yBAAyB;KAC/D,eAAA,GAAkB,iBAAiB,sBAAsB;KACzD,aAAA,GAAgB,cAAc,gBAAgB;KAC9C,eAAA,GAAkB,cAAc,gBAAgB"}

package/build/crypto/webcrypto/types.mjs

@@ -0,0 +1,68 @@
+
+
+import { P256PublicJwk } from "../../modules/kms/jwk/kty/ec/P256PublicJwk.mjs";
+import { P384PublicJwk } from "../../modules/kms/jwk/kty/ec/P384PublicJwk.mjs";
+import { P521PublicJwk } from "../../modules/kms/jwk/kty/ec/P521PublicJwk.mjs";
+import { Secp256k1PublicJwk } from "../../modules/kms/jwk/kty/ec/Secp256k1PublicJwk.mjs";
+import { Ed25519PublicJwk } from "../../modules/kms/jwk/kty/okp/Ed25519PublicJwk.mjs";
+import { RsaPublicJwk } from "../../modules/kms/jwk/kty/rsa/RsaPublicJwk.mjs";
+import "../../modules/kms/index.mjs";
+import { CredoWebCryptoError } from "./CredoWebCryptoError.mjs";
+
+//#region src/crypto/webcrypto/types.ts
+/**
+* Derives the JWA algorithm name from KeySignParams or KeyVerifyParams
+* @param params - The signing or verification parameters
+* @returns The corresponding JWA algorithm string
+*/
+function keyParamsToJwaAlgorithm(params, key) {
+	if (params.name === "Ed25519") {
+		if (!key.publicJwk.is(Ed25519PublicJwk)) throw new CredoWebCryptoError(`Unsupported key for algorithm for Ed25519: ${key.publicJwk.jwkTypeHumanDescription}`);
+		return "EdDSA";
+	}
+	if (params.name === "ECDSA") {
+		const hashName = typeof params.hash === "string" ? params.hash : params.hash.name;
+		if (key.publicJwk.is(Secp256k1PublicJwk)) switch (hashName) {
+			case "SHA-256": return "ES256K";
+			default: throw new CredoWebCryptoError(`Unsupported hash algorithm for ECDSA with Secp255K1: ${hashName}`);
+		}
+		if (key.publicJwk.is(P256PublicJwk)) switch (hashName) {
+			case "SHA-256": return "ES256";
+			default: throw new CredoWebCryptoError(`Unsupported hash algorithm for ECDSA with P256: ${hashName}`);
+		}
+		if (key.publicJwk.is(P384PublicJwk)) switch (hashName) {
+			case "SHA-384": return "ES384";
+			default: throw new CredoWebCryptoError(`Unsupported hash algorithm for ECDSA with P384: ${hashName}`);
+		}
+		if (key.publicJwk.is(P521PublicJwk)) switch (hashName) {
+			case "SHA-512": return "ES512";
+			default: throw new CredoWebCryptoError(`Unsupported hash algorithm for ECDSA with P521: ${hashName}`);
+		}
+		throw new CredoWebCryptoError(`Unsupported key ${key.publicJwk.jwkTypeHumanDescription} or hash algorithm '${hashName}' for ECDSA`);
+	}
+	if (params.name === "RSASSA-PKCS1-v1_5") {
+		const hashName = typeof params.hash === "string" ? params.hash : params.hash.name;
+		if (!key.publicJwk.is(RsaPublicJwk)) throw new CredoWebCryptoError(`Unsupported key for algorithm for RSASSA-PKCS1-v1_5: ${key.publicJwk.jwkTypeHumanDescription}`);
+		switch (hashName) {
+			case "SHA-256": return "RS256";
+			case "SHA-384": return "RS384";
+			case "SHA-512": return "RS512";
+			default: throw new CredoWebCryptoError(`Unsupported hash algorithm for RSASSA-PKCS1-v1_5: ${hashName}`);
+		}
+	}
+	if (params.name === "RSA-PSS") {
+		const hashName = typeof params.hash === "string" ? params.hash : params.hash.name;
+		if (!key.publicJwk.is(RsaPublicJwk)) throw new CredoWebCryptoError(`Unsupported key for algorithm for RSA-PSS: ${key.publicJwk.jwkTypeHumanDescription}`);
+		switch (hashName) {
+			case "SHA-256": return "PS256";
+			case "SHA-384": return "PS384";
+			case "SHA-512": return "PS512";
+			default: throw new CredoWebCryptoError(`Unsupported hash algorithm for RSA-PSS: ${hashName}`);
+		}
+	}
+	throw new CredoWebCryptoError(`Unsupported algorithm: ${params.name}`);
+}
+
+//#endregion
+export { keyParamsToJwaAlgorithm };
+//# sourceMappingURL=types.mjs.map

package/build/crypto/webcrypto/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../../../src/crypto/webcrypto/types.ts"],"sourcesContent":["/*\n *\n * Based on: https://www.w3.org/TR/WebCryptoAPI/\n */\n\nimport {\n  Ed25519PublicJwk,\n  type Jwk,\n  type KnownJwaSignatureAlgorithm,\n  P256PublicJwk,\n  P384PublicJwk,\n  P521PublicJwk,\n  RsaPublicJwk,\n  Secp256k1PublicJwk,\n} from '../../modules/kms'\nimport type { AnyUint8Array } from '../../types'\nimport { CredoWebCryptoError } from './CredoWebCryptoError'\nimport type { CredoWebCryptoKey } from './CredoWebCryptoKey'\n\nexport type CredoWebCryptoKeyPair = {\n  publicKey: CredoWebCryptoKey\n  privateKey: CredoWebCryptoKey\n}\n\ntype HashAlgorithmIdentifier = 'SHA-256' | 'SHA-384' | 'SHA-512'\n\n/*\n *\n * Sign and Verify Parameters\n *\n */\n\nexport type EcdsaParams = {\n  name: 'ECDSA'\n  hash: { name: HashAlgorithmIdentifier } | HashAlgorithmIdentifier\n}\n\nexport type Ed25519Params = { name: 'Ed25519' }\n\nexport type RsaSsaParams = {\n  name: 'RSASSA-PKCS1-v1_5' | 'RSA-PSS'\n  hash: { name: HashAlgorithmIdentifier } | HashAlgorithmIdentifier\n  saltLength?: number // Only for RSA-PSS\n}\n\n/*\n *\n * Key Generation Parameters\n *\n */\n\nexport type Ed25519KeyGenParams = { name: 'Ed25519' }\n\nexport type EcKeyGenParams = {\n  name: 'ECDSA'\n  namedCurve: 'P-256' | 'P-384' | 'P-521' | 'K-256'\n}\n\nexport type RsaHashedKeyGenParams = {\n  name: 'RSASSA-PKCS1-v1_5' | 'RSA-PSS'\n  modulusLength: number\n  publicExponent: AnyUint8Array\n  hash: { name: HashAlgorithmIdentifier }\n}\n\n/*\n *\n * Key Import Parameters\n *\n */\n\nexport type Ed25519KeyImportParams = { name: 'Ed25519' }\n\nexport type EcKeyImportParams = {\n  name: 'ECDSA'\n  namedCurve: 'P-256' | 'P-384' | 'K-256' | 'P-521'\n}\n\nexport type RsaHashedImportParams = {\n  name: 'RSASSA-PKCS1-v1_5' | 'RSA-PSS'\n  hash: { name: HashAlgorithmIdentifier }\n}\n\nexport type KeyUsage = 'sign' | 'verify' | 'encrypt' | 'decrypt' | 'wrapKey' | 'unwrapKey' | 'deriveKey' | 'deriveBits'\nexport type KeyFormat = 'jwk' | 'pkcs8' | 'spki' | 'raw'\nexport type KeyType = 'private' | 'public' | 'secret'\n\nexport type JsonWebKey = Jwk\n\nexport type HashAlgorithm = { name: HashAlgorithmIdentifier }\n\nexport type KeyImportParams = EcKeyImportParams | Ed25519KeyImportParams | RsaHashedImportParams\nexport type KeyGenAlgorithm = EcKeyGenParams | Ed25519KeyGenParams | RsaHashedKeyGenParams\nexport type KeySignParams = EcdsaParams | Ed25519Params | RsaSsaParams\nexport type KeyVerifyParams = EcdsaParams | Ed25519Params | RsaSsaParams\n\n/**\n * Derives the JWA algorithm name from KeySignParams or KeyVerifyParams\n * @param params - The signing or verification parameters\n * @returns The corresponding JWA algorithm string\n */\nexport function keyParamsToJwaAlgorithm(\n  params: KeySignParams | KeyVerifyParams,\n  key: CredoWebCryptoKey\n): KnownJwaSignatureAlgorithm {\n  if (params.name === 'Ed25519') {\n    if (!key.publicJwk.is(Ed25519PublicJwk)) {\n      throw new CredoWebCryptoError(\n        `Unsupported key for algorithm for Ed25519: ${key.publicJwk.jwkTypeHumanDescription}`\n      )\n    }\n\n    return 'EdDSA'\n  }\n\n  if (params.name === 'ECDSA') {\n    // Normalize hash parameter\n    const hashName = typeof params.hash === 'string' ? params.hash : params.hash.name\n\n    if (key.publicJwk.is(Secp256k1PublicJwk)) {\n      // Map ECDSA with different hash algorithms to JWA names\n      switch (hashName) {\n        case 'SHA-256':\n          return 'ES256K'\n        default:\n          throw new CredoWebCryptoError(`Unsupported hash algorithm for ECDSA with Secp255K1: ${hashName}`)\n      }\n    }\n\n    // Map ECDSA with different hash algorithms to JWA names\n    if (key.publicJwk.is(P256PublicJwk)) {\n      switch (hashName) {\n        case 'SHA-256':\n          return 'ES256'\n        default:\n          throw new CredoWebCryptoError(`Unsupported hash algorithm for ECDSA with P256: ${hashName}`)\n      }\n    }\n\n    // Map ECDSA with different hash algorithms to JWA names\n    if (key.publicJwk.is(P384PublicJwk)) {\n      switch (hashName) {\n        case 'SHA-384':\n          return 'ES384'\n        default:\n          throw new CredoWebCryptoError(`Unsupported hash algorithm for ECDSA with P384: ${hashName}`)\n      }\n    }\n\n    // Map ECDSA with different hash algorithms to JWA names\n    if (key.publicJwk.is(P521PublicJwk)) {\n      switch (hashName) {\n        case 'SHA-512':\n          return 'ES512'\n        default:\n          throw new CredoWebCryptoError(`Unsupported hash algorithm for ECDSA with P521: ${hashName}`)\n      }\n    }\n\n    throw new CredoWebCryptoError(\n      `Unsupported key ${key.publicJwk.jwkTypeHumanDescription} or hash algorithm '${hashName}' for ECDSA`\n    )\n  }\n\n  if (params.name === 'RSASSA-PKCS1-v1_5') {\n    // Normalize hash parameter\n    const hashName = typeof params.hash === 'string' ? params.hash : params.hash.name\n\n    if (!key.publicJwk.is(RsaPublicJwk)) {\n      throw new CredoWebCryptoError(\n        `Unsupported key for algorithm for RSASSA-PKCS1-v1_5: ${key.publicJwk.jwkTypeHumanDescription}`\n      )\n    }\n\n    // Map RSA-PKCS1 with different hash algorithms to JWA names\n    switch (hashName) {\n      case 'SHA-256':\n        return 'RS256'\n      case 'SHA-384':\n        return 'RS384'\n      case 'SHA-512':\n        return 'RS512'\n      default:\n        throw new CredoWebCryptoError(`Unsupported hash algorithm for RSASSA-PKCS1-v1_5: ${hashName}`)\n    }\n  }\n\n  if (params.name === 'RSA-PSS') {\n    // Normalize hash parameter\n    const hashName = typeof params.hash === 'string' ? params.hash : params.hash.name\n\n    if (!key.publicJwk.is(RsaPublicJwk)) {\n      throw new CredoWebCryptoError(\n        `Unsupported key for algorithm for RSA-PSS: ${key.publicJwk.jwkTypeHumanDescription}`\n      )\n    }\n\n    // Map RSA-PSS with different hash algorithms to JWA names\n    switch (hashName) {\n      case 'SHA-256':\n        return 'PS256'\n      case 'SHA-384':\n        return 'PS384'\n      case 'SHA-512':\n        return 'PS512'\n      default:\n        throw new CredoWebCryptoError(`Unsupported hash algorithm for RSA-PSS: ${hashName}`)\n    }\n  }\n\n  throw new CredoWebCryptoError(`Unsupported algorithm: ${params.name}`)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAqGA,SAAgB,wBACd,QACA,KAC4B;AAC5B,KAAI,OAAO,SAAS,WAAW;AAC7B,MAAI,CAAC,IAAI,UAAU,GAAG,iBAAiB,CACrC,OAAM,IAAI,oBACR,8CAA8C,IAAI,UAAU,0BAC7D;AAGH,SAAO;;AAGT,KAAI,OAAO,SAAS,SAAS;EAE3B,MAAM,WAAW,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO,OAAO,KAAK;AAE7E,MAAI,IAAI,UAAU,GAAG,mBAAmB,CAEtC,SAAQ,UAAR;GACE,KAAK,UACH,QAAO;GACT,QACE,OAAM,IAAI,oBAAoB,wDAAwD,WAAW;;AAKvG,MAAI,IAAI,UAAU,GAAG,cAAc,CACjC,SAAQ,UAAR;GACE,KAAK,UACH,QAAO;GACT,QACE,OAAM,IAAI,oBAAoB,mDAAmD,WAAW;;AAKlG,MAAI,IAAI,UAAU,GAAG,cAAc,CACjC,SAAQ,UAAR;GACE,KAAK,UACH,QAAO;GACT,QACE,OAAM,IAAI,oBAAoB,mDAAmD,WAAW;;AAKlG,MAAI,IAAI,UAAU,GAAG,cAAc,CACjC,SAAQ,UAAR;GACE,KAAK,UACH,QAAO;GACT,QACE,OAAM,IAAI,oBAAoB,mDAAmD,WAAW;;AAIlG,QAAM,IAAI,oBACR,mBAAmB,IAAI,UAAU,wBAAwB,sBAAsB,SAAS,aACzF;;AAGH,KAAI,OAAO,SAAS,qBAAqB;EAEvC,MAAM,WAAW,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO,OAAO,KAAK;AAE7E,MAAI,CAAC,IAAI,UAAU,GAAG,aAAa,CACjC,OAAM,IAAI,oBACR,wDAAwD,IAAI,UAAU,0BACvE;AAIH,UAAQ,UAAR;GACE,KAAK,UACH,QAAO;GACT,KAAK,UACH,QAAO;GACT,KAAK,UACH,QAAO;GACT,QACE,OAAM,IAAI,oBAAoB,qDAAqD,WAAW;;;AAIpG,KAAI,OAAO,SAAS,WAAW;EAE7B,MAAM,WAAW,OAAO,OAAO,SAAS,WAAW,OAAO,OAAO,OAAO,KAAK;AAE7E,MAAI,CAAC,IAAI,UAAU,GAAG,aAAa,CACjC,OAAM,IAAI,oBACR,8CAA8C,IAAI,UAAU,0BAC7D;AAIH,UAAQ,UAAR;GACE,KAAK,UACH,QAAO;GACT,KAAK,UACH,QAAO;GACT,KAAK,UACH,QAAO;GACT,QACE,OAAM,IAAI,oBAAoB,2CAA2C,WAAW;;;AAI1F,OAAM,IAAI,oBAAoB,0BAA0B,OAAO,OAAO"}

package/build/crypto/webcrypto/utils/index.d.mts

@@ -0,0 +1 @@
+import { publicJwkToCryptoKeyAlgorithm } from "./keyAlgorithmConversion.mjs";

package/build/crypto/webcrypto/utils/index.mjs

@@ -0,0 +1,3 @@
+
+
+import { cryptoKeyAlgorithmToCreateKeyOptions, publicJwkToCryptoKeyAlgorithm, publicJwkToSpki, spkiToPublicJwk } from "./keyAlgorithmConversion.mjs";

package/build/crypto/webcrypto/utils/keyAlgorithmConversion.d.mts

@@ -0,0 +1,10 @@
+import { KeyGenAlgorithm } from "../types.mjs";
+import { PublicJwk } from "../../../modules/kms/jwk/PublicJwk.mjs";
+import "../../../modules/kms/index.mjs";
+import { SubjectPublicKeyInfo } from "@peculiar/asn1-x509";
+
+//#region src/crypto/webcrypto/utils/keyAlgorithmConversion.d.ts
+declare const publicJwkToCryptoKeyAlgorithm: (key: PublicJwk) => KeyGenAlgorithm;
+//#endregion
+export { publicJwkToCryptoKeyAlgorithm };
+//# sourceMappingURL=keyAlgorithmConversion.d.mts.map

package/build/crypto/webcrypto/utils/keyAlgorithmConversion.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyAlgorithmConversion.d.mts","names":[],"sources":["../../../../src/crypto/webcrypto/utils/keyAlgorithmConversion.ts"],"sourcesContent":[],"mappings":";;;;;;cAgBa,qCAAsC,cAAY"}