@enbox/agent 0.0.1

package/dist/types/prototyping/crypto/algorithms/ecdsa.d.ts

@@ -0,0 +1,160 @@
+import type { Jwk, Signer, SignParams, KeyConverter, VerifyParams, GenerateKeyParams, GetPublicKeyParams, AsymmetricKeyConverter, AsymmetricKeyGenerator, ComputePublicKeyParams } from '@enbox/crypto';
+import { CryptoAlgorithm } from '@enbox/crypto';
+import { BytesToPrivateKeyParams, BytesToPublicKeyParams, PrivateKeyToBytesParams, PublicKeyToBytesParams } from '../types/params-direct.js';
+/**
+ * The `EcdsaGenerateKeyParams` interface defines the algorithm-specific parameters that should be
+ * passed into the `generateKey()` method when using the ECDSA algorithm.
+ */
+export interface EcdsaGenerateKeyParams extends GenerateKeyParams {
+    /**
+     * A string defining the type of key to generate. The value must be one of the following:
+     * - `"ES256"`: ECDSA using the secp256r1 (P-256) curve and SHA-256.
+     * - `"ES256K"`: ECDSA using the secp256k1 curve and SHA-256.
+     * - `"secp256k1"`: ECDSA using the secp256k1 curve and SHA-256.
+     * - `"secp256r1"`: ECDSA using the secp256r1 (P-256) curve and SHA-256.
+     */
+    algorithm: 'ES256' | 'ES256K' | 'secp256k1' | 'secp256r1';
+}
+/**
+ * The `EcdsaAlgorithm` class provides a concrete implementation for cryptographic operations using
+ * the Elliptic Curve Digital Signature Algorithm (ECDSA). This class implements both
+ * {@link Signer | `Signer`} and { @link AsymmetricKeyGenerator | `AsymmetricKeyGenerator`}
+ * interfaces, providing private key generation, public key derivation, and creation/verification
+ * of signatures.
+ *
+ * This class is typically accessed through implementations that extend the
+ * {@link CryptoApi | `CryptoApi`} interface.
+ */
+export declare class EcdsaAlgorithm extends CryptoAlgorithm implements AsymmetricKeyGenerator<EcdsaGenerateKeyParams, Jwk, GetPublicKeyParams>, KeyConverter, AsymmetricKeyConverter, Signer<SignParams, VerifyParams> {
+    bytesToPrivateKey({ algorithm, privateKeyBytes }: BytesToPrivateKeyParams & {
+        algorithm: 'ES256' | 'ES256K' | 'secp256k1' | 'secp256r1';
+    }): Promise<Jwk>;
+    bytesToPublicKey({ algorithm, publicKeyBytes }: BytesToPublicKeyParams & {
+        algorithm: 'ES256' | 'ES256K' | 'secp256k1' | 'secp256r1';
+    }): Promise<Jwk>;
+    /**
+     * Derives the public key in JWK format from a given private key.
+     *
+     * @remarks
+     * This method takes a private key in JWK format and derives its corresponding public key,
+     * also in JWK format. The process ensures that the derived public key correctly corresponds to
+     * the given private key.
+     *
+     * @example
+     * ```ts
+     * const ecdsa = new EcdsaAlgorithm();
+     * const privateKey = { ... }; // A Jwk object representing a private key
+     * const publicKey = await ecdsa.computePublicKey({ key: privateKey });
+     * ```
+     *
+     * @param params - The parameters for the public key derivation.
+     * @param params.key - The private key in JWK format from which to derive the public key.
+     *
+     * @returns A Promise that resolves to the derived public key in JWK format.
+     */
+    computePublicKey({ key }: ComputePublicKeyParams): Promise<Jwk>;
+    /**
+     * Generates a new private key with the specified algorithm in JSON Web Key (JWK) format.
+     *
+     * @example
+     * ```ts
+     * const ecdsa = new EcdsaAlgorithm();
+     * const privateKey = await ecdsa.generateKey({ algorithm: 'ES256K' });
+     * ```
+     *
+     * @param params - The parameters for key generation.
+     * @param params.algorithm - The algorithm to use for key generation.
+     *
+     * @returns A Promise that resolves to the generated private key in JWK format.
+     */
+    generateKey({ algorithm }: EcdsaGenerateKeyParams): Promise<Jwk>;
+    /**
+     * Retrieves the public key properties from a given private key in JWK format.
+     *
+     * @remarks
+     * This method extracts the public key portion from an ECDSA private key in JWK format. It does
+     * so by removing the private key property 'd' and making a shallow copy, effectively yielding the
+     * public key.
+     *
+     * Note: This method offers a significant performance advantage, being about 200 times faster
+     * than `computePublicKey()`. However, it does not mathematically validate the private key, nor
+     * does it derive the public key from the private key. It simply extracts existing public key
+     * properties from the private key object. This makes it suitable for scenarios where speed is
+     * critical and the private key's integrity is already assured.
+     *
+     * @example
+     * ```ts
+     * const ecdsa = new EcdsaAlgorithm();
+     * const privateKey = { ... }; // A Jwk object representing a private key
+     * const publicKey = await ecdsa.getPublicKey({ key: privateKey });
+     * ```
+     *
+     * @param params - The parameters for retrieving the public key properties.
+     * @param params.key - The private key in JWK format.
+     *
+     * @returns A Promise that resolves to the public key in JWK format.
+     */
+    getPublicKey({ key }: GetPublicKeyParams): Promise<Jwk>;
+    privateKeyToBytes({ privateKey }: PrivateKeyToBytesParams): Promise<Uint8Array>;
+    publicKeyToBytes({ publicKey }: PublicKeyToBytesParams): Promise<Uint8Array>;
+    /**
+     * Generates an ECDSA signature of given data using a private key.
+     *
+     * @remarks
+     * This method uses the signature algorithm determined by the given `algorithm` to sign the
+     * provided data.
+     *
+     * The signature can later be verified by parties with access to the corresponding
+     * public key, ensuring that the data has not been tampered with and was indeed signed by the
+     * holder of the private key.
+     *
+     * @example
+     * ```ts
+     * const ecdsa = new EcdsaAlgorithm();
+     * const data = new TextEncoder().encode('Message');
+     * const privateKey = { ... }; // A Jwk object representing a private key
+     * const signature = await ecdsa.sign({
+     *   key: privateKey,
+     *   data
+     * });
+     * ```
+     *
+     * @param params - The parameters for the signing operation.
+     * @param params.key - The private key to use for signing, represented in JWK format.
+     * @param params.data - The data to sign.
+     *
+     * @returns A Promise resolving to the digital signature as a `Uint8Array`.
+     */
+    sign({ key, data }: SignParams): Promise<Uint8Array>;
+    /**
+     * Verifies an ECDSA signature associated with the provided data using the provided key.
+     *
+     * @remarks
+     * This method uses the signature algorithm determined by the `crv` property of the provided key
+     * to check the validity of a digital signature against the original data. It confirms whether the
+     * signature was created by the holder of the corresponding private key and that the data has not
+     * been tampered with.
+     *s
+     * @example
+     * ```ts
+     * const ecdsa = new EcdsaAlgorithm();
+     * const publicKey = { ... }; // Public key in JWK format corresponding to the private key that signed the data
+     * const signature = new Uint8Array([...]); // Signature to verify
+     * const data = new TextEncoder().encode('Message');
+     * const isValid = await ecdsa.verify({
+     *   key: publicKey,
+     *   signature,
+     *   data
+     * });
+     * ```
+     *
+     * @param params - The parameters for the verification operation.
+     * @param params.key - The key to use for verification.
+     * @param params.signature - The signature to verify.
+     * @param params.data - The data to verify.
+     *
+     * @returns A Promise resolving to a boolean indicating whether the signature is valid.
+     */
+    verify({ key, signature, data }: VerifyParams): Promise<boolean>;
+}
+//# sourceMappingURL=ecdsa.d.ts.map

package/dist/types/prototyping/crypto/algorithms/ecdsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/ecdsa.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,GAAG,EACH,MAAM,EACN,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAuD,MAAM,eAAe,CAAC;AAErG,OAAO,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAE7I;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D;;;;;;OAMG;IACH,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAC;CAC3D;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,eAClC,YAAW,sBAAsB,CAAC,sBAAsB,EAAE,GAAG,EAAE,kBAAkB,CAAC,EACvE,YAAY,EAAE,sBAAsB,EACpC,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC;IAE9B,iBAAiB,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,EAC3D,uBAAuB,GAAG;QAAE,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAA;KAAE,GACtF,OAAO,CAAC,GAAG,CAAC;IAuBF,gBAAgB,CAAC,EAAE,SAAS,EAAE,cAAc,EAAE,EACzD,sBAAsB,GAAG;QAAE,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAA;KAAE,GACrF,OAAO,CAAC,GAAG,CAAC;IAuBf;;;;;;;;;;;;;;;;;;;OAmBG;IACU,gBAAgB,CAAC,EAAE,GAAG,EAAE,EACnC,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAuBf;;;;;;;;;;;;;OAaG;IACU,WAAW,CAAC,EAAE,SAAS,EAAE,EACpC,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAmBf;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,YAAY,CAAC,EAAE,GAAG,EAAE,EAC/B,kBAAkB,GACjB,OAAO,CAAC,GAAG,CAAC;IAuBF,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAC3C,uBAAuB,GACtB,OAAO,CAAC,UAAU,CAAC;IAiBT,gBAAgB,CAAC,EAAE,SAAS,EAAE,EACzC,sBAAsB,GACrB,OAAO,CAAC,UAAU,CAAC;IAiBtB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACU,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAC7B,UAAU,GACT,OAAO,CAAC,UAAU,CAAC;IAmBtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACU,MAAM,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,EAC1C,YAAY,GACX,OAAO,CAAC,OAAO,CAAC;CAkBpB"}

package/dist/types/prototyping/crypto/algorithms/eddsa.d.ts

@@ -0,0 +1,157 @@
+import type { Jwk, Signer, SignParams, KeyConverter, VerifyParams, GenerateKeyParams, GetPublicKeyParams, AsymmetricKeyConverter, AsymmetricKeyGenerator, ComputePublicKeyParams } from '@enbox/crypto';
+import { CryptoAlgorithm } from '@enbox/crypto';
+import { BytesToPrivateKeyParams, BytesToPublicKeyParams, PrivateKeyToBytesParams, PublicKeyToBytesParams } from '../types/params-direct.js';
+/**
+ * The `EdDsaGenerateKeyParams` interface defines the algorithm-specific parameters that should be
+ * passed into the `generateKey()` method when using the EdDSA algorithm.
+ */
+export interface EdDsaGenerateKeyParams extends GenerateKeyParams {
+    /**
+     * A string defining the type of key to generate. The value must be one of the following:
+     * - `"Ed25519"`: EdDSA using the Ed25519 curve.
+     */
+    algorithm: 'Ed25519';
+}
+/**
+ * The `EdDsaAlgorithm` class provides a concrete implementation for cryptographic operations using
+ * the Edwards-curve Digital Signature Algorithm (EdDSA). This class implements both
+ * {@link Signer | `Signer`} and { @link AsymmetricKeyGenerator | `AsymmetricKeyGenerator`}
+ * interfaces, providing private key generation, public key derivation, and creation/verification
+ * of signatures.
+ *
+ * This class is typically accessed through implementations that extend the
+ * {@link CryptoApi | `CryptoApi`} interface.
+ */
+export declare class EdDsaAlgorithm extends CryptoAlgorithm implements AsymmetricKeyGenerator<EdDsaGenerateKeyParams, Jwk, GetPublicKeyParams>, KeyConverter, AsymmetricKeyConverter, Signer<SignParams, VerifyParams> {
+    bytesToPrivateKey({ algorithm, privateKeyBytes }: BytesToPrivateKeyParams & {
+        algorithm: 'Ed25519';
+    }): Promise<Jwk>;
+    bytesToPublicKey({ algorithm, publicKeyBytes }: BytesToPublicKeyParams & {
+        algorithm: 'Ed25519';
+    }): Promise<Jwk>;
+    /**
+     * Derives the public key in JWK format from a given private key.
+     *
+     * @remarks
+     * This method takes a private key in JWK format and derives its corresponding public key,
+     * also in JWK format. The process ensures that the derived public key correctly corresponds to
+     * the given private key.
+     *
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const privateKey = { ... }; // A Jwk object representing a private key
+     * const publicKey = await eddsa.computePublicKey({ key: privateKey });
+     * ```
+     *
+     * @param params - The parameters for the public key derivation.
+     * @param params.key - The private key in JWK format from which to derive the public key.
+     *
+     * @returns A Promise that resolves to the derived public key in JWK format.
+     */
+    computePublicKey({ key }: ComputePublicKeyParams): Promise<Jwk>;
+    /**
+     * Generates a new private key with the specified algorithm in JSON Web Key (JWK) format.
+     *
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const privateKey = await eddsa.generateKey({ algorithm: 'Ed25519' });
+     * ```
+     *
+     * @param params - The parameters for key generation.
+     * @param params.algorithm - The algorithm to use for key generation.
+     *
+     * @returns A Promise that resolves to the generated private key in JWK format.
+     */
+    generateKey({ algorithm }: EdDsaGenerateKeyParams): Promise<Jwk>;
+    /**
+     * Retrieves the public key properties from a given private key in JWK format.
+     *
+     * @remarks
+     * This method extracts the public key portion from an EdDSA private key in JWK format. It does
+     * so by removing the private key property 'd' and making a shallow copy, effectively yielding the
+     * public key.
+     *
+     * Note: This method offers a significant performance advantage, being about 100 times faster
+     * than `computePublicKey()`. However, it does not mathematically validate the private key, nor
+     * does it derive the public key from the private key. It simply extracts existing public key
+     * properties from the private key object. This makes it suitable for scenarios where speed is
+     * critical and the private key's integrity is already assured.
+     *
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const privateKey = { ... }; // A Jwk object representing a private key
+     * const publicKey = await eddsa.getPublicKey({ key: privateKey });
+     * ```
+     *
+     * @param params - The parameters for retrieving the public key properties.
+     * @param params.key - The private key in JWK format.
+     *
+     * @returns A Promise that resolves to the public key in JWK format.
+     */
+    getPublicKey({ key }: GetPublicKeyParams): Promise<Jwk>;
+    privateKeyToBytes({ privateKey }: PrivateKeyToBytesParams): Promise<Uint8Array>;
+    publicKeyToBytes({ publicKey }: PublicKeyToBytesParams): Promise<Uint8Array>;
+    /**
+     * Generates an EdDSA signature of given data using a private key.
+     *
+     * @remarks
+     * This method uses the signature algorithm determined by the given `algorithm` to sign the
+     * provided data.
+     *
+     * The signature can later be verified by parties with access to the corresponding
+     * public key, ensuring that the data has not been tampered with and was indeed signed by the
+     * holder of the private key.
+     *
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const data = new TextEncoder().encode('Message');
+     * const privateKey = { ... }; // A Jwk object representing a private key
+     * const signature = await eddsa.sign({
+     *   key: privateKey,
+     *   data
+     * });
+     * ```
+     *
+     * @param params - The parameters for the signing operation.
+     * @param params.key - The private key to use for signing, represented in JWK format.
+     * @param params.data - The data to sign.
+     *
+     * @returns A Promise resolving to the digital signature as a `Uint8Array`.
+     */
+    sign({ key, data }: SignParams): Promise<Uint8Array>;
+    /**
+     * Verifies an EdDSA signature associated with the provided data using the provided key.
+     *
+     * @remarks
+     * This method uses the signature algorithm determined by the `crv` property of the provided key
+     * to check the validity of a digital signature against the original data. It confirms whether the
+     * signature was created by the holder of the corresponding private key and that the data has not
+     * been tampered with.
+     *s
+     * @example
+     * ```ts
+     * const eddsa = new EdDsaAlgorithm();
+     * const publicKey = { ... }; // Public key in JWK format corresponding to the private key that signed the data
+     * const signature = new Uint8Array([...]); // Signature to verify
+     * const data = new TextEncoder().encode('Message');
+     * const isValid = await eddsa.verify({
+     *   key: publicKey,
+     *   signature,
+     *   data
+     * });
+     * ```
+     *
+     * @param params - The parameters for the verification operation.
+     * @param params.key - The key to use for verification.
+     * @param params.signature - The signature to verify.
+     * @param params.data - The data to verify.
+     *
+     * @returns A Promise resolving to a boolean indicating whether the signature is valid.
+     */
+    verify({ key, signature, data }: VerifyParams): Promise<boolean>;
+}
+//# sourceMappingURL=eddsa.d.ts.map

package/dist/types/prototyping/crypto/algorithms/eddsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/eddsa.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,GAAG,EACH,MAAM,EACN,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAA4C,MAAM,eAAe,CAAC;AAE1F,OAAO,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAE7I;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D;;;OAGG;IACH,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,eAClC,YAAW,sBAAsB,CAAC,sBAAsB,EAAE,GAAG,EAAE,kBAAkB,CAAC,EACvE,YAAY,EAAE,sBAAsB,EACpC,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC;IAE9B,iBAAiB,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,EAC3D,uBAAuB,GAAG;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE,GACjD,OAAO,CAAC,GAAG,CAAC;IAeF,gBAAgB,CAAC,EAAE,SAAS,EAAE,cAAc,EAAE,EACzD,sBAAsB,GAAG;QAAE,SAAS,EAAE,SAAS,CAAA;KAAE,GAChD,OAAO,CAAC,GAAG,CAAC;IAef;;;;;;;;;;;;;;;;;;;OAmBG;IACU,gBAAgB,CAAC,EAAE,GAAG,EAAE,EACnC,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAiBf;;;;;;;;;;;;;OAaG;IACG,WAAW,CAAC,EAAE,SAAS,EAAE,EAC7B,sBAAsB,GACrB,OAAO,CAAC,GAAG,CAAC;IAWf;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACU,YAAY,CAAC,EAAE,GAAG,EAAE,EAC/B,kBAAkB,GACjB,OAAO,CAAC,GAAG,CAAC;IAiBF,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAC3C,uBAAuB,GACtB,OAAO,CAAC,UAAU,CAAC;IAaT,gBAAgB,CAAC,EAAE,SAAS,EAAE,EACzC,sBAAsB,GACrB,OAAO,CAAC,UAAU,CAAC;IAatB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACU,IAAI,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAC7B,UAAU,GACT,OAAO,CAAC,UAAU,CAAC;IAetB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACU,MAAM,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,EAC1C,YAAY,GACX,OAAO,CAAC,OAAO,CAAC;CAcpB"}

package/dist/types/prototyping/crypto/algorithms/hkdf.d.ts

@@ -0,0 +1,21 @@
+import { CryptoAlgorithm } from '@enbox/crypto';
+import type { DeriveKeyBytesParams } from '../types/params-direct.js';
+import { HkdfParams } from '../primitives/hkdf.js';
+import { KeyBytesDeriver } from '../types/key-deriver.js';
+/**
+ * The `HkdfDeriveKeyBytesParams` interface defines the algorithm-specific parameters that should be
+ * passed into the `deriveKeyBytes()` method when using the HKDF algorithm.
+ */
+export interface HkdfDeriveKeyBytesParams extends DeriveKeyBytesParams {
+    /** Specifies the algorithm variant for HKDF key derivation.
+     * The value determines the hash function that will be used and must be one of the following:
+     * - `"HKDF-256"`: HKDF with SHA-256.
+     * - `"HKDF-384"`: HKDF with SHA-384.
+     * - `"HKDF-512"`: HKDF with SHA-512.
+     */
+    algorithm: 'HKDF-256' | 'HKDF-384' | 'HKDF-512';
+}
+export declare class HkdfAlgorithm extends CryptoAlgorithm implements KeyBytesDeriver<HkdfDeriveKeyBytesParams, Uint8Array> {
+    deriveKeyBytes({ algorithm, ...params }: HkdfDeriveKeyBytesParams & Omit<HkdfParams, 'hash'>): Promise<Uint8Array>;
+}
+//# sourceMappingURL=hkdf.d.ts.map

package/dist/types/prototyping/crypto/algorithms/hkdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hkdf.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/hkdf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,OAAO,EAAQ,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE;;;;;OAKG;IACH,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;CACjD;AAED,qBAAa,aAAc,SAAQ,eACjC,YAAW,eAAe,CAAC,wBAAwB,EAAE,UAAU,CAAC;IAEnD,cAAc,CAAC,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,EAClD,wBAAwB,GAAG,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,GAClD,OAAO,CAAC,UAAU,CAAC;CAavB"}

package/dist/types/prototyping/crypto/algorithms/pbkdf2.d.ts

@@ -0,0 +1,21 @@
+import { CryptoAlgorithm } from '@enbox/crypto';
+import type { Pbkdf2Params } from '../primitives/pbkdf2.js';
+import type { KeyBytesDeriver } from '../types/key-deriver.js';
+import type { DeriveKeyBytesParams } from '../types/params-direct.js';
+/**
+ * The `Pbkdf2DeriveKeyBytesParams` interface defines the algorithm-specific parameters that
+ * should be passed into the `deriveKeyBytes()` method when using the PBKDF2 algorithm.
+ */
+export interface Pbkdf2DeriveKeyBytesParams extends DeriveKeyBytesParams {
+    /** Specifies the algorithm variant for PBKDF2 key derivation.
+     * The value determines the hash function that will be used and must be one of the following:
+     * - `"PBKDF2-HS256+A128KW"`: PBKDF2 with HMAC SHA-256 and A128KW key wrapping.
+     * - `"PBKDF2-HS384+A192KW"`: PBKDF2 with HMAC SHA-384 and A192KW key wrapping.
+     * - `"PBKDF2-HS512+A256KW"`: PBKDF2 with HMAC SHA-512 and A256KW key wrapping.
+     */
+    algorithm: 'PBES2-HS256+A128KW' | 'PBES2-HS384+A192KW' | 'PBES2-HS512+A256KW';
+}
+export declare class Pbkdf2Algorithm extends CryptoAlgorithm implements KeyBytesDeriver<Pbkdf2DeriveKeyBytesParams, Uint8Array> {
+    deriveKeyBytes({ algorithm, ...params }: Pbkdf2DeriveKeyBytesParams & Omit<Pbkdf2Params, 'hash'>): Promise<Uint8Array>;
+}
+//# sourceMappingURL=pbkdf2.d.ts.map

package/dist/types/prototyping/crypto/algorithms/pbkdf2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.d.ts","sourceRoot":"","sources":["../../../../../src/prototyping/crypto/algorithms/pbkdf2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAItE;;;GAGG;AACH,MAAM,WAAW,0BAA2B,SAAQ,oBAAoB;IACtE;;;;;OAKG;IACH,SAAS,EAAE,oBAAoB,GAAG,oBAAoB,GAAG,oBAAoB,CAAC;CAC/E;AAED,qBAAa,eAAgB,SAAQ,eACnC,YAAW,eAAe,CAAC,0BAA0B,EAAE,UAAU,CAAC;IAErD,cAAc,CAAC,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,EAClD,0BAA0B,GAAG,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GACtD,OAAO,CAAC,UAAU,CAAC;CAgBvB"}

package/dist/types/prototyping/crypto/crypto-error.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A custom error class for Crypto-related errors.
+ */
+export declare class CryptoError extends Error {
+    code: CryptoErrorCode;
+    /**
+     * Constructs an instance of CryptoError, a custom error class for handling Crypto-related errors.
+     *
+     * @param code - A {@link CryptoErrorCode} representing the specific type of error encountered.
+     * @param message - A human-readable description of the error.
+     */
+    constructor(code: CryptoErrorCode, message: string);
+}
+/**
+ * An enumeration of possible Crypto error codes.
+ */
+export declare enum CryptoErrorCode {
+    /** The supplied algorithm identifier is not supported by the implementation. */
+    AlgorithmNotSupported = "algorithmNotSupported",
+    /** The encoding operation (either encoding or decoding) failed. */
+    EncodingError = "encodingError",
+    /** The JWE supplied does not conform to valid syntax. */
+    InvalidJwe = "invalidJwe",
+    /** The JWK supplied does not conform to valid syntax. */
+    InvalidJwk = "invalidJwk",
+    /** The requested operation is not supported by the implementation. */
+    OperationNotSupported = "operationNotSupported"
+}
+//# sourceMappingURL=crypto-error.d.ts.map

package/dist/types/prototyping/crypto/crypto-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-error.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/crypto/crypto-error.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;IAOjB,IAAI,EAAE,eAAe;IANxC;;;;;OAKG;gBACgB,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM;CAc1D;AAED;;GAEG;AACH,oBAAY,eAAe;IACzB,gFAAgF;IAChF,qBAAqB,0BAA0B;IAE/C,mEAAmE;IACnE,aAAa,kBAAkB;IAE/B,yDAAyD;IACzD,UAAU,eAAe;IAEzB,yDAAyD;IACzD,UAAU,eAAe;IAEzB,sEAAsE;IACtE,qBAAqB,0BAA0B;CAChD"}

package/dist/types/prototyping/crypto/dsa.d.ts

@@ -0,0 +1,169 @@
+import type { Jwk, SignParams, DigestParams, VerifyParams, GenerateKeyParams, GetPublicKeyParams, KmsGetKeyUriParams } from '@enbox/crypto';
+import { Sha2Algorithm } from '@enbox/crypto';
+import type { DsaApi } from './types/crypto-api.js';
+import type { BytesToPrivateKeyParams, BytesToPublicKeyParams } from './types/params-direct.js';
+import { EcdsaAlgorithm } from './algorithms/ecdsa.js';
+import { EdDsaAlgorithm } from './algorithms/eddsa.js';
+export interface DsaBytesToPrivateKeyParams extends BytesToPrivateKeyParams {
+    algorithm: KeyConversionAlgorithm;
+}
+export interface DsaBytesToPublicKeyParams extends BytesToPublicKeyParams {
+    algorithm: AsymmetricKeyConversionAlgorithm;
+}
+/**
+ * The `DsaDigestParams` interface defines the algorithm-specific parameters that should
+ * be passed into the {@link AgentDsa.digest | `AgentDsa.digest()`} method.
+ */
+export interface DsaDigestParams extends DigestParams {
+    /**
+     * A string defining the name of hash function to use. The value must be one of the following:
+     * - `"SHA-256"`: Generates a 256-bit digest.
+     */
+    algorithm: DigestAlgorithm;
+}
+export interface DsaGenerateKeyParams extends GenerateKeyParams {
+    algorithm: KeyGenerationAlgorithm;
+}
+/**
+ * `supportedAlgorithms` is an object mapping algorithm names to their respective implementations
+ * Each entry in this map specifies the algorithm name and its associated properties, including the
+ * implementation class and any relevant names or identifiers for the algorithm. This structure
+ * allows for easy retrieval and instantiation of algorithm implementations based on the algorithm
+ * name or key specification. It facilitates the support of multiple algorithms within the
+ * `LocalKeyManager` class.
+ */
+declare const supportedAlgorithms: {
+    readonly Ed25519: {
+        readonly implementation: typeof EdDsaAlgorithm;
+        readonly names: readonly ["Ed25519"];
+        readonly operations: readonly ["bytesToPrivateKey", "bytesToPublicKey", "generateKey", "sign", "verify"];
+    };
+    readonly secp256k1: {
+        readonly implementation: typeof EcdsaAlgorithm;
+        readonly names: readonly ["ES256K", "secp256k1"];
+        readonly operations: readonly ["bytesToPrivateKey", "bytesToPublicKey", "generateKey", "sign", "verify"];
+    };
+    readonly secp256r1: {
+        readonly implementation: typeof EcdsaAlgorithm;
+        readonly names: readonly ["ES256", "secp256r1"];
+        readonly operations: readonly ["bytesToPrivateKey", "bytesToPublicKey", "generateKey", "sign", "verify"];
+    };
+    readonly 'SHA-256': {
+        readonly implementation: typeof Sha2Algorithm;
+        readonly names: readonly ["SHA-256"];
+        readonly operations: readonly ["digest"];
+    };
+};
+type SupportedAlgorithms = typeof supportedAlgorithms;
+type DigestAlgorithms = {
+    [K in keyof SupportedAlgorithms]: 'digest' extends SupportedAlgorithms[K]['operations'][number] ? K : never;
+}[keyof SupportedAlgorithms];
+type DigestAlgorithm = typeof supportedAlgorithms[DigestAlgorithms]['names'][number];
+type KeyConversionAlgorithms = {
+    [K in keyof SupportedAlgorithms]: 'bytesToPrivateKey' extends SupportedAlgorithms[K]['operations'][number] ? K : never;
+}[keyof SupportedAlgorithms];
+type KeyConversionAlgorithm = typeof supportedAlgorithms[KeyConversionAlgorithms]['names'][number];
+type AsymmetricKeyConversionAlgorithms = {
+    [K in keyof SupportedAlgorithms]: 'bytesToPublicKey' extends SupportedAlgorithms[K]['operations'][number] ? K : never;
+}[keyof SupportedAlgorithms];
+type AsymmetricKeyConversionAlgorithm = typeof supportedAlgorithms[AsymmetricKeyConversionAlgorithms]['names'][number];
+type KeyGenerationAlgorithms = {
+    [K in keyof SupportedAlgorithms]: 'generateKey' extends SupportedAlgorithms[K]['operations'][number] ? K : never;
+}[keyof SupportedAlgorithms];
+type KeyGenerationAlgorithm = typeof supportedAlgorithms[KeyGenerationAlgorithms]['names'][number];
+export declare class Dsa implements DsaApi<DsaGenerateKeyParams, Jwk, GetPublicKeyParams, DsaDigestParams, SignParams, VerifyParams> {
+    /**
+     * A private map that stores instances of cryptographic algorithm implementations. Each key in
+     * this map is an `AlgorithmConstructor`, and its corresponding value is an instance of a class
+     * that implements a specific cryptographic algorithm. This map is used to cache and reuse
+     * instances for performance optimization, ensuring that each algorithm is instantiated only once.
+     */
+    private _algorithmInstances;
+    bytesToPrivateKey({ algorithm: algorithmIdentifier, privateKeyBytes }: DsaBytesToPrivateKeyParams): Promise<Jwk>;
+    bytesToPublicKey({ algorithm: algorithmIdentifier, publicKeyBytes }: DsaBytesToPublicKeyParams): Promise<Jwk>;
+    /**
+     * Generates a hash digest of the provided data.
+     *
+     * @remarks
+     * A digest is the output of the hash function. It's a fixed-size string of bytes that uniquely
+     * represents the data input into the hash function. The digest is often used for data integrity
+     * checks, as any alteration in the input data results in a significantly different digest.
+     *
+     * It takes the algorithm identifier of the hash function and data to digest as input and returns
+     * the digest of the data.
+     *
+     * @example
+     * ```ts
+     * const Dsa = new AgentDsa();
+     * const data = new Uint8Array([...]);
+     * const digest = await Dsa.digest({ algorithm: 'SHA-256', data });
+     * ```
+     *
+     * @param params - The parameters for the digest operation.
+     * @param params.algorithm - The name of hash function to use.
+     * @param params.data - The data to digest.
+     *
+     * @returns A Promise which will be fulfilled with the hash digest.
+     */
+    digest({ algorithm, data }: DsaDigestParams): Promise<Uint8Array>;
+    generateKey(params: DsaGenerateKeyParams): Promise<Jwk>;
+    getKeyUri(_params: KmsGetKeyUriParams): Promise<string>;
+    getPublicKey({ key }: GetPublicKeyParams): Promise<Jwk>;
+    privateKeyToBytes({ privateKey }: {
+        privateKey: Jwk;
+    }): Promise<Uint8Array>;
+    publicKeyToBytes({ publicKey }: {
+        publicKey: Jwk;
+    }): Promise<Uint8Array>;
+    sign({ key, data }: SignParams): Promise<Uint8Array>;
+    verify({ key, signature, data }: VerifyParams): Promise<boolean>;
+    /**
+     * Retrieves an algorithm implementation instance based on the provided algorithm name.
+     *
+     * @remarks
+     * This method checks if the requested algorithm is supported and returns a cached instance
+     * if available. If an instance does not exist, it creates and caches a new one. This approach
+     * optimizes performance by reusing algorithm instances across cryptographic operations.
+     *
+     * @example
+     * ```ts
+     * const signer = this.getAlgorithm({ algorithm: 'Ed25519' });
+     * ```
+     *
+     * @param params - The parameters for retrieving the algorithm implementation.
+     * @param params.algorithm - The name of the algorithm to retrieve.
+     *
+     * @returns An instance of the requested algorithm implementation.
+     *
+     * @throws Error if the requested algorithm is not supported.
+     */
+    private getAlgorithm;
+    /**
+     * Determines the algorithm name based on the key's properties.
+     *
+     * @remarks
+     * This method facilitates the identification of the correct algorithm for cryptographic
+     * operations based on the `alg` or `crv` properties of a {@link Jwk | JWK}.
+     *
+     * @example
+     * ```ts
+     * const key = { ... }; // Public key in JWK format
+     * const algorithm = this.getAlgorithmName({ key });
+     * ```
+     *
+     * @example
+     * ```ts
+     * const algorithm = this.getAlgorithmName({ algorithm: 'ES256' });
+     * ```
+     *
+     * @param params - The parameters for determining the algorithm name.
+     * @param params.key - A JWK containing the `alg` or `crv` properties.
+     *
+     * @returns The algorithm name associated with the key.
+     *
+     * @throws Error if the algorithm name cannot be determined from the provided input.
+     */
+    private getAlgorithmName;
+}
+export {};
+//# sourceMappingURL=dsa.d.ts.map

package/dist/types/prototyping/crypto/dsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsa.d.ts","sourceRoot":"","sources":["../../../../src/prototyping/crypto/dsa.ts"],"names":[],"mappings":"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"}