@cmts-dev/carmentis-sdk-core 1.2.3 → 1.2.4

package/dist/constants/sections.d.ts

@@ -0,0 +1,141 @@
+import { Schema } from './schemas';
+import { SectionType } from '../type/valibot/blockchain/section/SectionType';
+export declare const SIGNATURE = SectionType.SIGNATURE;
+export declare const SIGNATURE_SCHEMA: {
+    label: string;
+    definition: {
+        name: string;
+        type: number;
+    }[];
+};
+export declare const PROTOCOL_CREATION = SectionType.PROTOCOL_CREATION;
+export declare const PROTOCOL_UPDATE = SectionType.PROTOCOL_UPDATE;
+export declare const ACCOUNT_PUBLIC_KEY = SectionType.ACCOUNT_PUBLIC_KEY;
+export declare const ACCOUNT_TOKEN_ISSUANCE = SectionType.ACCOUNT_TOKEN_ISSUANCE;
+export declare const ACCOUNT_CREATION = SectionType.ACCOUNT_CREATION;
+export declare const ACCOUNT_TRANSFER = SectionType.ACCOUNT_TRANSFER;
+export declare const ACCOUNT_VESTING_TRANSFER = SectionType.ACCOUNT_VESTING_TRANSFER;
+export declare const ACCOUNT_ESCROW_TRANSFER = SectionType.ACCOUNT_ESCROW_TRANSFER;
+export declare const ACCOUNT_ESCROW_SETTLEMENT = SectionType.ACCOUNT_ESCROW_SETTLEMENT;
+export declare const ACCOUNT_STAKE = SectionType.ACCOUNT_STAKE;
+export declare const VN_CREATION = SectionType.VN_CREATION;
+export declare const VN_COMETBFT_PUBLIC_KEY_DECLARATION = SectionType.VN_COMETBFT_PUBLIC_KEY_DECLARATION;
+export declare const VN_RPC_ENDPOINT = SectionType.VN_RPC_ENDPOINT;
+export declare const VN_APPROVAL = SectionType.VN_APPROVAL;
+export declare const ORG_CREATION = SectionType.ORG_CREATION;
+export declare const ORG_DESCRIPTION = SectionType.ORG_DESCRIPTION;
+export declare const APP_CREATION = SectionType.APP_CREATION;
+export declare const APP_DESCRIPTION = SectionType.APP_DESCRIPTION;
+export declare const APP_LEDGER_ALLOWED_SIG_SCHEMES = SectionType.APP_LEDGER_ALLOWED_SIG_SCHEMES;
+export declare const APP_LEDGER_ALLOWED_PKE_SCHEMES = SectionType.APP_LEDGER_ALLOWED_PKE_SCHEMES;
+export declare const APP_LEDGER_CREATION = SectionType.APP_LEDGER_CREATION;
+export declare const APP_LEDGER_ACTOR_CREATION = SectionType.APP_LEDGER_ACTOR_CREATION;
+export declare const APP_LEDGER_CHANNEL_CREATION = SectionType.APP_LEDGER_CHANNEL_CREATION;
+export declare const APP_LEDGER_SHARED_SECRET = SectionType.APP_LEDGER_SHARED_SECRET;
+export declare const APP_LEDGER_CHANNEL_INVITATION = SectionType.APP_LEDGER_CHANNEL_INVITATION;
+export declare const APP_LEDGER_ACTOR_SUBSCRIPTION = SectionType.APP_LEDGER_ACTOR_SUBSCRIPTION;
+export declare const APP_LEDGER_PUBLIC_CHANNEL_DATA = SectionType.APP_LEDGER_PUBLIC_CHANNEL_DATA;
+export declare const APP_LEDGER_PRIVATE_CHANNEL_DATA = SectionType.APP_LEDGER_PRIVATE_CHANNEL_DATA;
+export declare const APP_LEDGER_AUTHOR = SectionType.APP_LEDGER_AUTHOR;
+export declare const APP_LEDGER_ENDORSEMENT_REQUEST = SectionType.APP_LEDGER_ENDORSEMENT_REQUEST;
+export declare const ALL_SECTIONS_SCHEMAS: {
+    [x: number]: Schema;
+    length: number;
+    toString(): string;
+    toLocaleString(): string;
+    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+    pop(): Schema | undefined;
+    push(...items: Schema[]): number;
+    concat(...items: ConcatArray<Schema>[]): Schema[];
+    concat(...items: (Schema | ConcatArray<Schema>)[]): Schema[];
+    join(separator?: string): string;
+    reverse(): Schema[];
+    shift(): Schema | undefined;
+    slice(start?: number, end?: number): Schema[];
+    sort(compareFn?: ((a: Schema, b: Schema) => number) | undefined): Schema[];
+    splice(start: number, deleteCount?: number): Schema[];
+    splice(start: number, deleteCount: number, ...items: Schema[]): Schema[];
+    unshift(...items: Schema[]): number;
+    indexOf(searchElement: Schema, fromIndex?: number): number;
+    lastIndexOf(searchElement: Schema, fromIndex?: number): number;
+    every<S extends Schema>(predicate: (value: Schema, index: number, array: Schema[]) => value is S, thisArg?: any): this is S[];
+    every(predicate: (value: Schema, index: number, array: Schema[]) => unknown, thisArg?: any): boolean;
+    some(predicate: (value: Schema, index: number, array: Schema[]) => unknown, thisArg?: any): boolean;
+    forEach(callbackfn: (value: Schema, index: number, array: Schema[]) => void, thisArg?: any): void;
+    map<U>(callbackfn: (value: Schema, index: number, array: Schema[]) => U, thisArg?: any): U[];
+    filter<S extends Schema>(predicate: (value: Schema, index: number, array: Schema[]) => value is S, thisArg?: any): S[];
+    filter(predicate: (value: Schema, index: number, array: Schema[]) => unknown, thisArg?: any): Schema[];
+    reduce(callbackfn: (previousValue: Schema, currentValue: Schema, currentIndex: number, array: Schema[]) => Schema): Schema;
+    reduce(callbackfn: (previousValue: Schema, currentValue: Schema, currentIndex: number, array: Schema[]) => Schema, initialValue: Schema): Schema;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: Schema, currentIndex: number, array: Schema[]) => U, initialValue: U): U;
+    reduceRight(callbackfn: (previousValue: Schema, currentValue: Schema, currentIndex: number, array: Schema[]) => Schema): Schema;
+    reduceRight(callbackfn: (previousValue: Schema, currentValue: Schema, currentIndex: number, array: Schema[]) => Schema, initialValue: Schema): Schema;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: Schema, currentIndex: number, array: Schema[]) => U, initialValue: U): U;
+    find<S extends Schema>(predicate: (value: Schema, index: number, obj: Schema[]) => value is S, thisArg?: any): S | undefined;
+    find(predicate: (value: Schema, index: number, obj: Schema[]) => unknown, thisArg?: any): Schema | undefined;
+    findIndex(predicate: (value: Schema, index: number, obj: Schema[]) => unknown, thisArg?: any): number;
+    fill(value: Schema, start?: number, end?: number): Schema[];
+    copyWithin(target: number, start: number, end?: number): Schema[];
+    entries(): ArrayIterator<[number, Schema]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<Schema>;
+    includes(searchElement: Schema, fromIndex?: number): boolean;
+    flatMap<U, This = undefined>(callback: (this: This, value: Schema, index: number, array: Schema[]) => U | readonly U[], thisArg?: This | undefined): U[];
+    flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+    at(index: number): Schema | undefined;
+    findLast<S extends Schema>(predicate: (value: Schema, index: number, array: Schema[]) => value is S, thisArg?: any): S | undefined;
+    findLast(predicate: (value: Schema, index: number, array: Schema[]) => unknown, thisArg?: any): Schema | undefined;
+    findLastIndex(predicate: (value: Schema, index: number, array: Schema[]) => unknown, thisArg?: any): number;
+    toReversed(): Schema[];
+    toSorted(compareFn?: ((a: Schema, b: Schema) => number) | undefined): Schema[];
+    toSpliced(start: number, deleteCount: number, ...items: Schema[]): Schema[];
+    toSpliced(start: number, deleteCount?: number): Schema[];
+    with(index: number, value: Schema): Schema[];
+    [Symbol.iterator](): ArrayIterator<Schema>;
+    [Symbol.unscopables]: {
+        [x: number]: boolean | undefined;
+        length?: boolean | undefined;
+        toString?: boolean | undefined;
+        toLocaleString?: boolean | undefined;
+        pop?: boolean | undefined;
+        push?: boolean | undefined;
+        concat?: boolean | undefined;
+        join?: boolean | undefined;
+        reverse?: boolean | undefined;
+        shift?: boolean | undefined;
+        slice?: boolean | undefined;
+        sort?: boolean | undefined;
+        splice?: boolean | undefined;
+        unshift?: boolean | undefined;
+        indexOf?: boolean | undefined;
+        lastIndexOf?: boolean | undefined;
+        every?: boolean | undefined;
+        some?: boolean | undefined;
+        forEach?: boolean | undefined;
+        map?: boolean | undefined;
+        filter?: boolean | undefined;
+        reduce?: boolean | undefined;
+        reduceRight?: boolean | undefined;
+        find?: boolean | undefined;
+        findIndex?: boolean | undefined;
+        fill?: boolean | undefined;
+        copyWithin?: boolean | undefined;
+        entries?: boolean | undefined;
+        keys?: boolean | undefined;
+        values?: boolean | undefined;
+        includes?: boolean | undefined;
+        flatMap?: boolean | undefined;
+        flat?: boolean | undefined;
+        at?: boolean | undefined;
+        findLast?: boolean | undefined;
+        findLastIndex?: boolean | undefined;
+        toReversed?: boolean | undefined;
+        toSorted?: boolean | undefined;
+        toSpliced?: boolean | undefined;
+        with?: boolean | undefined;
+        [Symbol.iterator]?: boolean | undefined;
+        readonly [Symbol.unscopables]?: boolean | undefined;
+    };
+};
+export declare const DEF: Schema[][];
+//# sourceMappingURL=sections.d.ts.map

package/dist/constants/sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sections.d.ts","sourceRoot":"","sources":["../../src/constants/sections.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,MAAM,EAAC,MAAM,WAAW,CAAC;AACrD,OAAO,EAAC,WAAW,EAAC,MAAM,gDAAgD,CAAC;AAsB3E,eAAO,MAAM,SAAS,wBAA4B,CAAC;AACnD,eAAO,MAAM,gBAAgB;;;;;;CAM5B,CAAC;AAKF,eAAO,MAAM,iBAAiB,gCAAqC,CAAC;AACpE,eAAO,MAAM,eAAe,8BAA8B,CAAC;AAyB3D,eAAO,MAAM,kBAAkB,iCAAwC,CAAC;AACxE,eAAO,MAAM,sBAAsB,qCAAwC,CAAC;AAC5E,eAAO,MAAM,gBAAgB,+BAAwC,CAAC;AACtE,eAAO,MAAM,gBAAgB,+BAAwC,CAAC;AACtE,eAAO,MAAM,wBAAwB,uCAAwC,CAAC;AAC9E,eAAO,MAAM,uBAAuB,sCAAwC,CAAC;AAC7E,eAAO,MAAM,yBAAyB,wCAAwC,CAAC;AAC/E,eAAO,MAAM,aAAa,4BAAwC,CAAC;AA0FnE,eAAO,MAAM,WAAW,0BAAkC,CAAC;AAC3D,eAAO,MAAM,kCAAkC,iDAAyD,CAAC;AACzG,eAAO,MAAM,eAAe,8BAAqC,CAAC;AAClE,eAAO,MAAM,WAAW,0BAA0B,CAAC;AAmCnD,eAAO,MAAM,YAAY,2BAA8B,CAAC;AACxD,eAAO,MAAM,eAAe,8BAAgC,CAAC;AA0B7D,eAAO,MAAM,YAAY,2BAA2B,CAAC;AACrD,eAAO,MAAM,eAAe,8BAA8B,CAAC;AAyB3D,eAAO,MAAM,8BAA8B,6CAA8C,CAAC;AAC1F,eAAO,MAAM,8BAA8B,6CAA8C,CAAC;AAC1F,eAAO,MAAM,mBAAmB,kCAA2C,CAAC;AAC5E,eAAO,MAAM,yBAAyB,wCAA8C,CAAC;AACrF,eAAO,MAAM,2BAA2B,0CAA8C,CAAC;AACvF,eAAO,MAAM,wBAAwB,uCAA8C,CAAC;AACpF,eAAO,MAAM,6BAA6B,4CAA8C,CAAC;AACzF,eAAO,MAAM,6BAA6B,4CAA8C,CAAC;AACzF,eAAO,MAAM,8BAA8B,6CAA8C,CAAC;AAC1F,eAAO,MAAM,+BAA+B,8CAA8C,CAAC;AAC3F,eAAO,MAAM,iBAAiB,gCAA8C,CAAC;AAC7E,eAAO,MAAM,8BAA8B,6CAA8C,CAAC;AA4G1F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOhC,CAAA;AAKD,eAAO,MAAM,GAAG,EAAE,MAAM,EAAE,EAOzB,CAAC"}

package/dist/crypto/CryptoSchemeFactory.d.ts

@@ -0,0 +1,46 @@
+import { DecapsulationKey, SymmetricEncryptionKey, SymmetricEncryptionKeyScheme, SymmetricEncryptionSchemeId } from './encryption/symmetric-encryption/encryption-interface';
+import { CryptographicHash, CryptographicHashSchemeId } from './hash/hash-interface';
+import { PasswordBasedKeyDerivationFunction } from './kdf/PasswordBasedKeyDerivationFunction';
+import { KeyDerivationFunction } from './kdf/KeyDerivationFunction';
+import { HKDF } from './kdf/HKDF';
+import { PasswordBasedKeyDerivationFunctionSchemeId } from './kdf/PasswordBasedKeyDerivationFunctionSchemeId';
+import { AbstractPrivateDecryptionKey, AbstractPublicEncryptionKey } from './encryption/public-key-encryption/PublicKeyEncryptionSchemeInterface';
+import { PublicSignatureKey } from './signature/PublicSignatureKey';
+import { SignatureScheme } from './signature/SignatureScheme';
+import { PrivateSignatureKey } from './signature/PrivateSignatureKey';
+import { SignatureSchemeId } from './signature/SignatureSchemeId';
+export declare class CryptoSchemeFactory {
+    static createPrivateSignatureKey(schemeId: number, seed: Uint8Array): PrivateSignatureKey;
+    static createVirtualBlockchainPrivateSignature(kdf: KeyDerivationFunction, schemeId: SignatureSchemeId, walletSeed: Uint8Array, vbSeed: Uint8Array): PrivateSignatureKey;
+    /**
+     * Derives a symmetric encryption key from the provided password using the specified key derivation and encryption algorithms.
+     *
+     * @param {string} password - The password from which the encryption key will be derived.
+     * @param {PasswordBasedKeyDerivationFunctionSchemeId} [pbkdfSchemeId=PasswordBasedKeyDerivationFunctionSchemeId.PBKDF2] - The ID of the password-based key derivation function algorithm to use.
+     * @param {SymmetricEncryptionSchemeId} [symmetricEncryptionSchemeId=SymmetricEncryptionSchemeId.AES_256_GCM] - The ID of the symmetric encryption algorithm to create the key for.
+     * @return {SymmetricEncryptionKey} A symmetric encryption key derived from the password using the specified algorithms.
+     */
+    static deriveKeyFromPassword(password: string, pbkdfSchemeId?: PasswordBasedKeyDerivationFunctionSchemeId, symmetricEncryptionSchemeId?: SymmetricEncryptionSchemeId): SymmetricEncryptionKey;
+    createDecapsulationKey(schemeId: number, walletSeed: Uint8Array): DecapsulationKey;
+    createVirtualBlockchainDecapsulationKey(schemeId: number, walletSeed: Uint8Array, vbSeed: Uint8Array): DecapsulationKey;
+    createPublicSignatureKey(schemeId: number, publicKey: Uint8Array): Promise<PublicSignatureKey>;
+    static createPublicSignatureKey(schemeId: number, publicKey: Uint8Array): Promise<PublicSignatureKey>;
+    static createPublicEncryptionKey(schemeId: number, publicKey: Uint8Array): Promise<AbstractPublicEncryptionKey>;
+    static createPrivateDecryptionKey(schemeId: number, privateKeyOrSeed: Uint8Array): Promise<AbstractPrivateDecryptionKey>;
+    /**
+     * Creates a symmetric encryption key based on the provided encryption scheme ID and raw key data.
+     *
+     * @param {number} symmetricEncryptionSchemeId - The ID of the symmetric encryption scheme to use.
+     * @param {Uint8Array<ArrayBufferLike>} rawKey - The raw key data used to create the symmetric encryption key.
+     * @return {SymmetricEncryptionKey} The generated symmetric encryption key.
+     */
+    createSymmetricEncryptionKey(symmetricEncryptionSchemeId: number, rawKey: Uint8Array<ArrayBufferLike>): SymmetricEncryptionKey;
+    static createSymmetricEncryptionKey(symmetricEncryptionSchemeId: number, rawKey: Uint8Array<ArrayBufferLike>): SymmetricEncryptionKey;
+    static createSymmetricEncryptionKeyScheme(symmetricEncryptionSchemeId: number): SymmetricEncryptionKeyScheme;
+    static createCryptographicHash(schemeId: CryptographicHashSchemeId): CryptographicHash;
+    static createDefaultCryptographicHash(): CryptographicHash;
+    static createDefaultPBKDF(): PasswordBasedKeyDerivationFunction;
+    static createDefaultKDF(): HKDF;
+    static createSignatureScheme(schemeId: SignatureSchemeId): SignatureScheme;
+}
+//# sourceMappingURL=CryptoSchemeFactory.d.ts.map

package/dist/crypto/CryptoSchemeFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoSchemeFactory.d.ts","sourceRoot":"","sources":["../../src/crypto/CryptoSchemeFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,gBAAgB,EAChB,sBAAsB,EACtB,4BAA4B,EAC5B,2BAA2B,EAC9B,MAAM,wDAAwD,CAAC;AAEhE,OAAO,EAAC,iBAAiB,EAAE,yBAAyB,EAA0B,MAAM,uBAAuB,CAAC;AAG5G,OAAO,EAAC,kCAAkC,EAAC,MAAM,0CAA0C,CAAC;AAC5F,OAAO,EAAC,qBAAqB,EAAC,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAC,IAAI,EAAC,MAAM,YAAY,CAAC;AAChC,OAAO,EAAC,0CAA0C,EAAC,MAAM,kDAAkD,CAAC;AAC5G,OAAO,EACH,4BAA4B,EAC5B,2BAA2B,EAC9B,MAAM,uEAAuE,CAAC;AAI/E,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAC,eAAe,EAAC,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAC,mBAAmB,EAAC,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAC,iBAAiB,EAAC,MAAM,+BAA+B,CAAC;AAQhE,qBAAa,mBAAmB;IAC5B,MAAM,CAAC,yBAAyB,CAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAI,mBAAmB;IAS3F,MAAM,CAAC,uCAAuC,CAAE,GAAG,EAAE,qBAAqB,EAAE,QAAQ,EAAE,iBAAiB,EAAE,UAAU,EAAE,UAAU,EAAG,MAAM,EAAE,UAAU,GAAI,mBAAmB;IAa3K;;;;;;;OAOG;IACH,MAAM,CAAC,qBAAqB,CACxB,QAAQ,EAAE,MAAM,EAChB,aAAa,GAAE,0CAA8F,EAC7G,2BAA2B,GAAE,2BAAqE,GACnG,sBAAsB;IASzB,sBAAsB,CAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAK,gBAAgB;IAMrF,uCAAuC,CAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAI,gBAAgB;IAMnH,wBAAwB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAI,OAAO,CAAC,kBAAkB,CAAC;WAIzF,wBAAwB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAI,OAAO,CAAC,kBAAkB,CAAC;WAShG,yBAAyB,CAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,GAAI,OAAO,CAAC,2BAA2B,CAAC;WAO1G,0BAA0B,CAAC,QAAQ,EAAE,MAAM,EAAE,gBAAgB,EAAE,UAAU,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAO9H;;;;;;OAMG;IACH,4BAA4B,CAAC,2BAA2B,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,sBAAsB;IAI9H,MAAM,CAAC,4BAA4B,CAAC,2BAA2B,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,sBAAsB;IASrI,MAAM,CAAC,kCAAkC,CAAC,2BAA2B,EAAE,MAAM,GAAG,4BAA4B;IAO5G,MAAM,CAAC,uBAAuB,CAAC,QAAQ,EAAE,yBAAyB,GAAG,iBAAiB;IAQtF,MAAM,CAAC,8BAA8B,IAAI,iBAAiB;IAI1D,MAAM,CAAC,kBAAkB,IAAI,kCAAkC;IAI/D,MAAM,CAAC,gBAAgB;IAIvB,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,eAAe;CAQ7E"}

package/dist/crypto/aes.d.ts

@@ -0,0 +1,8 @@
+export declare const Aes: {
+    encryptGcm: typeof encryptGcm;
+    decryptGcm: typeof decryptGcm;
+};
+declare function encryptGcm(key: Uint8Array, data: Uint8Array, iv: Uint8Array): Uint8Array<ArrayBufferLike>;
+declare function decryptGcm(key: Uint8Array, data: Uint8Array, iv: Uint8Array): Uint8Array<ArrayBufferLike>;
+export {};
+//# sourceMappingURL=aes.d.ts.map

package/dist/crypto/aes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes.d.ts","sourceRoot":"","sources":["../../src/crypto/aes.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,GAAG;;;CAGf,CAAC;AAEF,iBAAS,UAAU,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,+BAKpE;AAED,iBAAS,UAAU,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,UAAU,+BAWpE"}

package/dist/crypto/crypto.d.ts

@@ -0,0 +1,52 @@
+export declare const Crypto: {
+    KEM_SCHEMES: {
+        name: string;
+    }[];
+    Random: {
+        getBytes: (n: any) => Uint8Array<ArrayBufferLike>;
+        getInteger: (max: any) => number;
+        getKey256: () => string;
+    };
+    Hashes: {
+        sha256AsBinary: (data: Uint8Array) => Uint8Array;
+        sha256: (data: Uint8Array) => string;
+        sha512AsBinary: (data: any) => Uint8Array<ArrayBufferLike>;
+        sha512: (data: any) => string;
+    };
+    Aes: {
+        encryptGcm: (key: Uint8Array, data: Uint8Array, iv: Uint8Array) => Uint8Array<ArrayBufferLike>;
+        decryptGcm: (key: Uint8Array, data: Uint8Array, iv: Uint8Array) => Uint8Array<ArrayBufferLike>;
+    };
+    MLDsa: {
+        generateKeyPair: (seed: any) => {
+            publicKey: Uint8Array<ArrayBufferLike>;
+            privateKey: Uint8Array<ArrayBufferLike>;
+        };
+        sign: (privateKey: any, data: any) => Uint8Array<ArrayBufferLike>;
+        verify: (publicKey: any, data: any, signature: any) => boolean;
+    };
+    MLKem: {
+        generateKeyPair: (seed: any) => {
+            publicKey: Uint8Array;
+            secretKey: Uint8Array;
+        };
+        encapsulate: (publicKey: any) => {
+            cipherText: Uint8Array;
+            sharedSecret: Uint8Array;
+        };
+        decapsulate: (cipherText: any, privateKey: any) => Uint8Array<ArrayBufferLike>;
+    };
+    Secp256k1: {
+        publicKeyFromPrivateKey: (privateKey: any) => import('@noble/secp256k1').Bytes;
+        sign: (privateKey: any, data: any) => import('@noble/secp256k1').Bytes;
+        verify: (publicKey: any, data: any, signature: any) => boolean;
+    };
+    ML_KEM: number;
+    SIG_SCHEMES: {
+        name: string;
+        signatureSectionSize: number;
+    }[];
+    SECP256K1: number;
+    ML_DSA: number;
+};
+//# sourceMappingURL=crypto.d.ts.map

package/dist/crypto/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/crypto/crypto.ts"],"names":[],"mappings":"AAyBA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWlB,CAAC"}

package/dist/crypto/encoder/CryptoEncoderFactory.d.ts

@@ -0,0 +1,15 @@
+import { EncoderInterface } from '../../utils/encoder';
+import { PkeEncoderInterface } from '../encryption/public-key-encryption/PkeEncoderInterface';
+import { SignatureEncoderInterface } from './signature/SignatureEncoderInterface';
+export declare class CBORCryptoBinaryEncoder implements EncoderInterface<any, Uint8Array> {
+    private static encoder;
+    decode(data: Uint8Array): any;
+    encode(data: any): Uint8Array;
+}
+export declare class CryptoEncoderFactory {
+    static defaultStringSignatureEncoder(): SignatureEncoderInterface<string>;
+    static defaultStringPublicKeyEncryptionEncoder(): PkeEncoderInterface;
+    private static cryptoBinaryEncoder;
+    static getCryptoBinaryEncoder(): EncoderInterface<object, Uint8Array>;
+}
+//# sourceMappingURL=CryptoEncoderFactory.d.ts.map

package/dist/crypto/encoder/CryptoEncoderFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoEncoderFactory.d.ts","sourceRoot":"","sources":["../../../src/crypto/encoder/CryptoEncoderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAAC,mBAAmB,EAAC,MAAM,yDAAyD,CAAC;AAC5F,OAAO,EAAC,yBAAyB,EAAC,MAAM,uCAAuC,CAAC;AAIhF,qBAAa,uBAAwB,YAAW,gBAAgB,CAAC,GAAG,EAAE,UAAU,CAAC;IAC7E,OAAO,CAAC,MAAM,CAAC,OAAO,CAEnB;IAEH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,GAAG;IAI7B,MAAM,CAAC,IAAI,EAAE,GAAG,GAAG,UAAU;CAIhC;AACD,qBAAa,oBAAoB;IAC7B,MAAM,CAAC,6BAA6B,IAAI,yBAAyB,CAAC,MAAM,CAAC;IAIzE,MAAM,CAAC,uCAAuC,IAAI,mBAAmB;IAIrE,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAiC;IAEnE,MAAM,CAAC,sBAAsB,IAAI,gBAAgB,CAAC,MAAM,EAAE,UAAU,CAAC;CAGxE"}

package/dist/crypto/encoder/signature/BytesSignatureEncoder.d.ts

@@ -0,0 +1,18 @@
+import { SignatureEncoderInterface } from './SignatureEncoderInterface';
+import { PublicSignatureKey } from '../../signature/PublicSignatureKey';
+import { PrivateSignatureKey } from '../../signature/PrivateSignatureKey';
+/**
+ * Class responsible for encoding and decoding digital signature-related data.
+ * Provides methods to convert signatures, public keys, and private keys between raw formats and serialized representations.
+ */
+export declare class BytesSignatureEncoder implements SignatureEncoderInterface<Uint8Array> {
+    encodeSignature(signature: Uint8Array): Uint8Array<ArrayBufferLike>;
+    decodeSignature(signature: Uint8Array<ArrayBufferLike>): Uint8Array;
+    encodeMessage(message: Uint8Array): Uint8Array<ArrayBufferLike>;
+    decodeMessage(message: Uint8Array<ArrayBufferLike>): Uint8Array;
+    encodePublicKey(publicKey: PublicSignatureKey): Promise<Uint8Array>;
+    decodePublicKey(publicKey: Uint8Array): Promise<PublicSignatureKey>;
+    encodePrivateKey(privateKey: PrivateSignatureKey): Promise<Uint8Array<ArrayBufferLike>>;
+    decodePrivateKey(privateKey: Uint8Array): Promise<PrivateSignatureKey>;
+}
+//# sourceMappingURL=BytesSignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/BytesSignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BytesSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encoder/signature/BytesSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAC,kBAAkB,EAAC,MAAM,oCAAoC,CAAC;AAItE,OAAO,EAAC,mBAAmB,EAAC,MAAM,qCAAqC,CAAC;AAExE;;;GAGG;AACH,qBAAa,qBAAsB,YAAW,yBAAyB,CAAC,UAAU,CAAC;IAC/E,eAAe,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU,CAAC,eAAe,CAAC;IAInE,eAAe,CAAC,SAAS,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,UAAU;IAInE,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAAC,eAAe,CAAC;IAI/D,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,eAAe,CAAC,GAAG,UAAU;IAKzD,eAAe,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,UAAU,CAAC;IAQnE,eAAe,CAAC,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAWnE,gBAAgB,CAAC,UAAU,EAAE,mBAAmB;IAQhD,gBAAgB,CAAC,UAAU,EAAE,UAAU;CAShD"}

package/dist/crypto/encoder/signature/HandlerBasedSignatureEncoder.d.ts

@@ -0,0 +1,26 @@
+import { SignatureEncoderInterface } from './SignatureEncoderInterface';
+import { ISignatureDecodeHandler, ISignatureEncoderHandler } from './ISignatureEncoderHandler';
+import { PrivateSignatureKey } from '../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../signature/PublicSignatureKey';
+import { BinaryToStringEncoderInterface } from '../../../utils/BinaryToStringEncoderInterface';
+/**
+ * A class responsible for encoding and decoding signatures, keys, and messages using a pluggable architecture.
+ * Implements the `SignatureEncoderInterface` for encoding and decoding operations.
+ */
+export declare class HandlerBasedSignatureEncoder implements SignatureEncoderInterface<string> {
+    private bytesEncoder;
+    private encoders;
+    private decoders;
+    constructor(bytesEncoder?: BinaryToStringEncoderInterface);
+    registerEncoder(encoder: ISignatureEncoderHandler): void;
+    registerDecoder(decoder: ISignatureDecodeHandler): void;
+    decodeMessage(message: string): Uint8Array;
+    decodePrivateKey(privateKey: string): Promise<PrivateSignatureKey>;
+    decodePublicKey(publicKey: string): Promise<PublicSignatureKey>;
+    decodeSignature(signature: string): Uint8Array;
+    encodeMessage(message: Uint8Array): string;
+    encodePrivateKey(privateKey: PrivateSignatureKey): Promise<string>;
+    encodePublicKey(publicKey: PublicSignatureKey): Promise<string>;
+    encodeSignature(signature: Uint8Array): string;
+}
+//# sourceMappingURL=HandlerBasedSignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/HandlerBasedSignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HandlerBasedSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encoder/signature/HandlerBasedSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAC,uBAAuB,EAAE,wBAAwB,EAAC,MAAM,4BAA4B,CAAC;AAC7F,OAAO,EAAC,mBAAmB,EAAC,MAAM,qCAAqC,CAAC;AACxE,OAAO,EAAC,kBAAkB,EAAC,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAC,8BAA8B,EAAC,MAAM,+CAA+C,CAAC;AAU7F;;;GAGG;AACH,qBAAa,4BAA6B,YAAW,yBAAyB,CAAC,MAAM,CAAC;IAgB9E,OAAO,CAAC,YAAY;IAfxB,OAAO,CAAC,QAAQ,CAId;IAEF,OAAO,CAAC,QAAQ,CAId;gBAKU,YAAY,GAAE,8BAAmE;IAI7F,eAAe,CAAC,OAAO,EAAE,wBAAwB;IAIjD,eAAe,CAAC,OAAO,EAAE,uBAAuB;IAIhD,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IAIpC,gBAAgB,CAAC,UAAU,EAAE,MAAM;IASnC,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IASrE,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU;IAI9C,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM;IAIpC,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;IASlE,eAAe,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IASrE,eAAe,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM;CAGjD"}

package/dist/crypto/encoder/signature/ISignatureEncoderHandler.d.ts

@@ -0,0 +1,15 @@
+import { PublicSignatureKey } from '../../signature/PublicSignatureKey';
+import { PrivateSignatureKey } from '../../signature/PrivateSignatureKey';
+export interface ISignatureEncoderHandler {
+    isAcceptingPublicKeyEncodingRequest(publicKey: PublicSignatureKey): Promise<boolean>;
+    isAcceptingPrivateKeyEncodingRequest(privateKey: PrivateSignatureKey): Promise<boolean>;
+    encodePublicKey(publicKey: PublicSignatureKey): Promise<string>;
+    encodePrivateKey(privateKey: PrivateSignatureKey): Promise<string>;
+}
+export interface ISignatureDecodeHandler {
+    isAcceptingPublicKeyDecodingRequest(encodedPublicKey: string): Promise<boolean>;
+    isAcceptingPrivateKeyDecodingRequest(encodedPrivateKey: string): Promise<boolean>;
+    decodePublicKey(encodedPublicKey: string): Promise<PublicSignatureKey>;
+    decodePrivateKey(encodedPrivateKey: string): Promise<PrivateSignatureKey>;
+}
+//# sourceMappingURL=ISignatureEncoderHandler.d.ts.map

package/dist/crypto/encoder/signature/ISignatureEncoderHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ISignatureEncoderHandler.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encoder/signature/ISignatureEncoderHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAC,mBAAmB,EAAC,MAAM,qCAAqC,CAAC;AAExE,MAAM,WAAW,wBAAwB;IACrC,mCAAmC,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACrF,oCAAoC,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACxF,eAAe,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAChE,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACtE;AAED,MAAM,WAAW,uBAAuB;IACpC,mCAAmC,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChF,oCAAoC,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAClF,eAAe,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACvE,gBAAgB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;CAC7E"}

package/dist/crypto/encoder/signature/JwkSignatureEncoder.d.ts

@@ -0,0 +1,25 @@
+import { PublicSignatureKey } from '../../signature/PublicSignatureKey';
+import { PrivateSignatureKey } from '../../signature/PrivateSignatureKey';
+/**
+ * Helper class for encoding and exporting signature keys as JWK (JSON Web Key).
+ */
+export declare class JwkSignatureEncoder {
+    /**
+     * Exports a public signature key into a CryptoKey format for usage in cryptographic operations.
+     *
+     * @param {PublicSignatureKey} publicKey - The public signature key to be exported. Must be of type `Ed25519PublicSignatureKey`.
+     * @return {Promise<CryptoKey>} A promise that resolves to the exported CryptoKey. The key will be in the EdDSA algorithm format.
+     * @throws {Error} If the provided public key is of an unsupported type.
+     */
+    static exportPublicSignatureKey(publicKey: PublicSignatureKey): Promise<CryptoKey>;
+    /**
+     * Exports a private signature key in a format compatible with cryptographic operations.
+     * The method supports the `Ed25519PrivateSignatureKey` type and derives the corresponding public key in the process.
+     *
+     * @param {PrivateSignatureKey} privateKey - The private signature key to be exported. Must be an instance of `Ed25519PrivateSignatureKey`.
+     * @return {Promise<CryptoKey>} A promise that resolves with the exported private key as a `CryptoKey` object.
+     * @throws {Error} If the provided key is of an unsupported type.
+     */
+    static exportPrivateSignatureKey(privateKey: PrivateSignatureKey): Promise<CryptoKey>;
+}
+//# sourceMappingURL=JwkSignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/JwkSignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JwkSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encoder/signature/JwkSignatureEncoder.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,kBAAkB,EAAC,MAAM,oCAAoC,CAAC;AAGtE,OAAO,EAAC,mBAAmB,EAAC,MAAM,qCAAqC,CAAC;AAGxE;;GAEG;AACH,qBAAa,mBAAmB;IAC5B;;;;;;OAMG;WACU,wBAAwB,CAAC,SAAS,EAAE,kBAAkB;IAenE;;;;;;;OAOG;WACU,yBAAyB,CAAC,UAAU,EAAE,mBAAmB;CAgBzE"}

package/dist/crypto/encoder/signature/SignatureEncoderInterface.d.ts

@@ -0,0 +1,69 @@
+import { PublicSignatureKey } from '../../signature/PublicSignatureKey';
+import { PrivateSignatureKey } from '../../signature/PrivateSignatureKey';
+/**
+ * An interface for encoding and decoding cryptographic signature keys and signatures.
+ *
+ * Provides methods to encode and decode public keys, private keys, and signatures
+ * into or from a specified format `T`.
+ *
+ * @template T - The format type for encoded keys and signatures.
+ */
+export interface SignatureEncoderInterface<T> {
+    /**
+     * Encodes the given public signature key into a specific format.
+     *
+     * @param {PublicSignatureKey} publicKey - The public signature key that needs to be encoded.
+     * @return {T} The encoded representation of the public signature key.
+     */
+    encodePublicKey(publicKey: PublicSignatureKey): Promise<T>;
+    /**
+     * Decodes a given public key object into a public signature key.
+     *
+     * @param {T} publicKey - The public key object that needs to be decoded.
+     * @return {PublicSignatureKey} The decoded public signature key.
+     */
+    decodePublicKey(publicKey: T): Promise<PublicSignatureKey>;
+    /**
+     * Encodes the given private key into a specific format.
+     *
+     * @param {PrivateSignatureKey} privateKey - The private key to be encoded.
+     * @return {T} The encoded representation of the private key.
+     */
+    encodePrivateKey(privateKey: PrivateSignatureKey): Promise<T>;
+    /**
+     * Decodes the provided private key and returns a private signature key object.
+     *
+     * @param {T} privateKey - The private key to decode.
+     * @return {PrivateSignatureKey} A decoded private signature key object.
+     */
+    decodePrivateKey(privateKey: T): Promise<PrivateSignatureKey>;
+    /**
+     * Encodes a given digital signature into a specific format.
+     *
+     * @param {Uint8Array} signature - The digital signature to be encoded. It should be provided as a Uint8Array.
+     * @return {T} The encoded signature in the required format, where T represents the resulting type of the encoded output.
+     */
+    encodeSignature(signature: Uint8Array): T;
+    /**
+     * Decodes the provided signature into a Uint8Array.
+     *
+     * @param {T} signature - The signature to be decoded.
+     * @return {Uint8Array} The decoded signature as a Uint8Array.
+     */
+    decodeSignature(signature: T): Uint8Array;
+    /**
+     * Encodes a given message into a specific format.
+     *
+     * @param {Uint8Array} message - The message to be encoded, provided as a Uint8Array.
+     * @return {T} The encoded message in the specified format.
+     */
+    encodeMessage(message: Uint8Array): T;
+    /**
+     * Decodes the provided message into a Uint8Array.
+     *
+     * @param {T} message - The message to be decoded. The type of the message is generic and should be specified upon usage.
+     * @return {Uint8Array} - The decoded representation of the input message as a Uint8Array.
+     */
+    decodeMessage(message: T): Uint8Array;
+}
+//# sourceMappingURL=SignatureEncoderInterface.d.ts.map

package/dist/crypto/encoder/signature/SignatureEncoderInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SignatureEncoderInterface.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encoder/signature/SignatureEncoderInterface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,oCAAoC,CAAC;AACtE,OAAO,EAAC,mBAAmB,EAAC,MAAM,qCAAqC,CAAC;AAExE;;;;;;;GAOG;AACH,MAAM,WAAW,yBAAyB,CAAC,CAAC;IACxC;;;;;OAKG;IACH,eAAe,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAE3D;;;;;OAKG;IACH,eAAe,CAAC,SAAS,EAAE,CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAE3D;;;;;OAKG;IACH,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAE9D;;;;;OAKG;IACH,gBAAgB,CAAC,UAAU,EAAE,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAE9D;;;;;OAKG;IACH,eAAe,CAAC,SAAS,EAAE,UAAU,GAAG,CAAC,CAAC;IAE1C;;;;;OAKG;IACH,eAAe,CAAC,SAAS,EAAE,CAAC,GAAG,UAAU,CAAC;IAE1C;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,CAAC,CAAC;IAEtC;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,CAAC,GAAG,UAAU,CAAC;CACzC"}

package/dist/crypto/encoder/signature/StringSignatureEncoder.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=StringSignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/StringSignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encoder/signature/StringSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAA"}

package/dist/crypto/encoder/signature/hcv/BaseHCVSignatureDecoder.d.ts

@@ -0,0 +1,55 @@
+import { ISignatureDecodeHandler } from '../ISignatureEncoderHandler';
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+/**
+ * Base class for HCV signature decoders.
+ * Provides common functionality for decoding signature keys encoded in HCV format.
+ *
+ * HCV (Hierarchical Colon Value) format uses a structured encoding with labels
+ * to identify the type of key and its algorithm.
+ */
+export declare abstract class BaseHCVSignatureDecoder implements ISignatureDecodeHandler {
+    private readonly labels;
+    private static logger;
+    protected bytesEncoder: import('../../../../common').EncoderInterface<Uint8Array<ArrayBufferLike>, string>;
+    /**
+     * Creates a new BaseHCVSignatureDecoder.
+     *
+     * @param labels - The hierarchical labels used to identify this signature type in HCV format
+     */
+    constructor(labels: string[]);
+    abstract decodePrivateKey(encodedPrivateKey: string): Promise<PrivateSignatureKey>;
+    abstract decodePublicKey(encodedPublicKey: string): Promise<PublicSignatureKey>;
+    /**
+     * Checks if this decoder can handle the given encoded private key.
+     * Verifies that the HCV structure matches the expected labels for this decoder.
+     *
+     * @param encodedPrivateKey - The HCV-encoded private key string
+     * @returns True if this decoder can handle the key, false otherwise
+     */
+    isAcceptingPrivateKeyDecodingRequest(encodedPrivateKey: string): Promise<boolean>;
+    /**
+     * Checks if this decoder can handle the given encoded public key.
+     * Verifies that the HCV structure matches the expected labels for this decoder.
+     *
+     * @param encodedPublicKey - The HCV-encoded public key string
+     * @returns True if this decoder can handle the key, false otherwise
+     */
+    isAcceptingPublicKeyDecodingRequest(encodedPublicKey: string): Promise<boolean>;
+    /**
+     * Gets the signature key constant used in HCV encoding.
+     * @internal
+     */
+    protected static getSignatureKey(): string;
+    /**
+     * Gets the secret key constant used in HCV encoding.
+     * @internal
+     */
+    protected static getSkSignatureKey(): string;
+    /**
+     * Gets the public key constant used in HCV encoding.
+     * @internal
+     */
+    protected static getPkSignatureKey(): string;
+}
+//# sourceMappingURL=BaseHCVSignatureDecoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/BaseHCVSignatureDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseHCVSignatureDecoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/BaseHCVSignatureDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AASzE;;;;;;GAMG;AACH,8BAAsB,uBAAwB,YAAW,uBAAuB;IAUhE,OAAO,CAAC,QAAQ,CAAC,MAAM;IARnC,OAAO,CAAC,MAAM,CAAC,MAAM,CAA4C;IACjE,SAAS,CAAC,YAAY,qFAAsC;IAE5D;;;;OAIG;gBAC0B,MAAM,EAAE,MAAM,EAAE;IAI7C,QAAQ,CAAC,gBAAgB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAClF,QAAQ,CAAC,eAAe,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAE/E;;;;;;OAMG;IACG,oCAAoC,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAevF;;;;;;OAMG;IACG,mCAAmC,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAarF;;;OAGG;IACH,SAAS,CAAC,MAAM,CAAC,eAAe,IAAI,MAAM;IAI1C;;;OAGG;IACH,SAAS,CAAC,MAAM,CAAC,iBAAiB,IAAI,MAAM;IAI5C;;;OAGG;IACH,SAAS,CAAC,MAAM,CAAC,iBAAiB,IAAI,MAAM;CAG/C"}

package/dist/crypto/encoder/signature/hcv/BaseHCVSignatureEncoder.d.ts

@@ -0,0 +1,47 @@
+import { ISignatureEncoderHandler } from '../ISignatureEncoderHandler';
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+/**
+ * Base class for HCV signature encoders.
+ * Provides common functionality for encoding signature keys into HCV format.
+ *
+ * HCV (Hierarchical Colon Value) format uses a structured encoding with labels
+ * to identify the type of key and its algorithm. For example:
+ * SIG:SECP256K1:PK:<base64_public_key>
+ */
+export declare abstract class BaseHCVSignatureEncoder implements ISignatureEncoderHandler {
+    protected readonly labels: string[];
+    protected bytesEncoder: import('../../../../common').EncoderInterface<Uint8Array<ArrayBufferLike>, string>;
+    /**
+     * Creates a new BaseHCVSignatureEncoder.
+     *
+     * @param labels - The hierarchical labels used to identify this signature type in HCV format
+     */
+    constructor(labels: string[]);
+    abstract isAcceptingPublicKeyEncodingRequest(publicKey: PublicSignatureKey): Promise<boolean>;
+    abstract isAcceptingPrivateKeyEncodingRequest(privateKey: PrivateSignatureKey): Promise<boolean>;
+    abstract encodePrivateKey(privateKey: PrivateSignatureKey): Promise<string>;
+    /**
+     * Encodes a public signature key into HCV format.
+     * The public key bytes are base64-encoded and prefixed with the appropriate HCV labels.
+     *
+     * @param publicKey - The public key to encode
+     * @returns The HCV-encoded public key string
+     */
+    encodePublicKey(publicKey: PublicSignatureKey): Promise<string>;
+    /**
+     * Gets the HCV prefix labels for encoding private keys.
+     *
+     * @returns An array of labels: [SIG, ...algorithm_labels, SK]
+     * @protected
+     */
+    protected getHCVPrivateKeyEncodingPrefix(): string[];
+    /**
+     * Gets the HCV prefix labels for encoding public keys.
+     *
+     * @returns An array of labels: [SIG, ...algorithm_labels, PK]
+     * @protected
+     */
+    protected getHCVPublicKeyEncodingPrefix(): string[];
+}
+//# sourceMappingURL=BaseHCVSignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/BaseHCVSignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseHCVSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/BaseHCVSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,wBAAwB,EAAC,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAQzE;;;;;;;GAOG;AACH,8BAAsB,uBAAwB,YAAW,wBAAwB;IAQjE,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE;IAP/C,SAAS,CAAC,YAAY,qFAAsC;IAE5D;;;;OAIG;gBAC4B,MAAM,EAAE,MAAM,EAAE;IAE/C,QAAQ,CAAC,mCAAmC,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAC7F,QAAQ,CAAC,oCAAoC,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAEhG,QAAQ,CAAC,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;IAE3E;;;;;;OAMG;IACG,eAAe,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAOrE;;;;;OAKG;IACH,SAAS,CAAC,8BAA8B;IAQxC;;;;;OAKG;IACH,SAAS,CAAC,6BAA6B;CAO1C"}

package/dist/crypto/encoder/signature/hcv/HCVSignatureEncoder.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=HCVSignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/HCVSignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HCVSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/HCVSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAA"}

package/dist/crypto/encoder/signature/hcv/MLDSA65HCVSignatureDecoder.d.ts

@@ -0,0 +1,23 @@
+import { NativeHCVSignatureDecoder } from './NativeHCVSignatureDecoder';
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+/**
+ * HCV decoder for ML-DSA-65 signature keys.
+ *
+ * Handles the decoding of ML-DSA-65 (Module-Lattice-Based Digital Signature Algorithm)
+ * post-quantum cryptography keys stored in HCV format.
+ * The expected HCV format is: SIG:MLDSA65:SK:<base64_private_key> for private keys
+ * and SIG:MLDSA65:PK:<base64_public_key> for public keys.
+ *
+ * ML-DSA-65 is a post-quantum signature scheme based on lattice cryptography.
+ */
+export declare class MLDSA65HCVSignatureDecoder extends NativeHCVSignatureDecoder {
+    private static ML_DSA65_SIGNATURE_KEY;
+    /**
+     * Creates a new MLDSA65HCVSignatureDecoder instance.
+     */
+    constructor();
+    protected bootstrapPrivateKey(privateKeyBytes: Uint8Array): PrivateSignatureKey;
+    protected bootstrapPublicKey(publicKeyBytes: Uint8Array): PublicSignatureKey;
+}
+//# sourceMappingURL=MLDSA65HCVSignatureDecoder.d.ts.map