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

package/dist/utils/HCVCodec.d.ts

@@ -0,0 +1,52 @@
+/**
+ * HCVDecoded class represents the result of decoding an HCV string.
+ * It provides methods to access the keys and value, and to check if a given key sequence matches.
+ */
+export declare class HCVDecoded {
+    private readonly keys;
+    private readonly value;
+    /**
+     * Creates a new HCVDecoded instance.
+     * @param keys - The list of keys from the decoded string
+     * @param value - The value from the decoded string
+     */
+    constructor(keys: string[], value: string);
+    /**
+     * Checks if the given keys match the keys in this decoded object.
+     * @param keys - The keys to check against
+     * @returns True if the keys match, false otherwise
+     */
+    matchesKeys(...keys: string[]): boolean;
+    /**
+     * Gets the list of keys from the decoded string.
+     * @returns The list of keys
+     */
+    getKeys(): string[];
+    /**
+     * Gets the value from the decoded string.
+     * @returns The value
+     */
+    getValue(): string;
+}
+/**
+ * HCVCodec (Hierarchical Context Value Codec) provides methods to encode and decode
+ * strings in the format key1:key2:...:keyn{value}.
+ */
+export declare class HCVCodec {
+    /**
+     * Encodes a list of keys and a value into a string in the format key1:key2:...:keyn{value}.
+     * The last parameter is treated as the value, and all preceding parameters are treated as keys.
+     * @param args - The keys followed by the value (at least one key and one value)
+     * @returns The encoded string
+     * @throws Error if fewer than 2 arguments are provided
+     */
+    static encode(...args: string[]): string;
+    /**
+     * Decodes a string in the format key1:key2:...:keyn{value} into an HCVDecoded object.
+     * @param encoded - The encoded string to decode
+     * @returns An HCVDecoded object containing the keys and value
+     * @throws Error if the encoded string is not in the correct format
+     */
+    static decode(encoded: string): HCVDecoded;
+}
+//# sourceMappingURL=HCVCodec.d.ts.map

package/dist/utils/HCVCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HCVCodec.d.ts","sourceRoot":"","sources":["../../src/utils/HCVCodec.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAE/B;;;;OAIG;gBACS,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM;IAKzC;;;;OAIG;IACI,WAAW,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO;IAQ9C;;;OAGG;IACI,OAAO,IAAI,MAAM,EAAE;IAI1B;;;OAGG;IACI,QAAQ,IAAI,MAAM;CAG1B;AAED;;;GAGG;AACH,qBAAa,QAAQ;IACnB;;;;;;OAMG;WACW,MAAM,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM;IAW/C;;;;;OAKG;WACW,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;CAelD"}

package/dist/utils/Logger.d.ts

@@ -0,0 +1,14 @@
+export declare class Logger {
+    static getLogger(context?: string[]): import('@logtape/logtape').Logger;
+    static getProviderLogger(): import('@logtape/logtape').Logger;
+    static getMemoryProviderLogger(): import('@logtape/logtape').Logger;
+    static enableLogs(): Promise<void>;
+    static enableLogsSync(): void;
+    static getNetworkProviderLogger(): import('@logtape/logtape').Logger;
+    static getMicroblockLogger(): import('@logtape/logtape').Logger;
+    static getVirtualBlockchainLogger(): import('@logtape/logtape').Logger;
+    static getInternalStateUpdaterLogger(name: string): import('@logtape/logtape').Logger;
+    static getAbstractProviderLogger(name: string): import('@logtape/logtape').Logger;
+    static getMicroblockStructureCheckerLogger(): import('@logtape/logtape').Logger;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/dist/utils/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../src/utils/Logger.ts"],"names":[],"mappings":"AAEA,qBAAa,MAAM;IACf,MAAM,CAAC,SAAS,CAAC,OAAO,GAAE,MAAM,EAAO;IAIvC,MAAM,CAAC,iBAAiB;IAIxB,MAAM,CAAC,uBAAuB;WAIjB,UAAU;IAIvB,MAAM,CAAC,cAAc;IASrB,MAAM,CAAC,wBAAwB;IAI/B,MAAM,CAAC,mBAAmB;IAI1B,MAAM,CAAC,0BAA0B;IAIjC,MAAM,CAAC,6BAA6B,CAAC,IAAI,EAAE,MAAM;IAIjD,MAAM,CAAC,yBAAyB,CAAC,IAAI,EAAE,MAAM;IAI7C,MAAM,CAAC,mCAAmC;CAG7C"}

package/dist/utils/SectionLabel.d.ts

@@ -0,0 +1,22 @@
+import { SectionType } from '../type/valibot/blockchain/section/SectionType';
+import { Section } from '../type/valibot/blockchain/section/sections';
+/**
+ * A utility class for determining section labels based on section objects or section types.
+ */
+export declare class SectionLabel {
+    /**
+     * Retrieves the label corresponding to a given section.
+     *
+     * @param {Section} section - The section object from which the label will be derived.
+     * @return {string} The label associated with the given section.
+     */
+    static getSectionLabelFromSection(section: Section): string;
+    /**
+     * Retrieves the label associated with a given section type.
+     *
+     * @param {SectionType} sectionType - The type of the section for which the label is required.
+     * @return {string} The label corresponding to the specified section type.
+     */
+    static getSectionLabelFromSectionType(sectionType: SectionType): string;
+}
+//# sourceMappingURL=SectionLabel.d.ts.map

package/dist/utils/SectionLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SectionLabel.d.ts","sourceRoot":"","sources":["../../src/utils/SectionLabel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,gDAAgD,CAAC;AAC3E,OAAO,EAAC,OAAO,EAAC,MAAM,6CAA6C,CAAC;AAuDpE;;GAEG;AACH,qBAAa,YAAY;IACrB;;;;;OAKG;IACH,MAAM,CAAC,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM;IAI3D;;;;;OAKG;IACH,MAAM,CAAC,8BAA8B,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM;CAG1E"}

package/dist/utils/SeedEncoder.d.ts

@@ -0,0 +1,9 @@
+import { EncoderInterface } from './encoder';
+export declare class SeedEncoder implements EncoderInterface<Uint8Array, string> {
+    private readonly stringEncoder;
+    constructor(stringEncoder?: EncoderInterface<Uint8Array, string>);
+    decode(data: string): Uint8Array;
+    encode(data: Uint8Array): string;
+    protected getPrefix(): string[];
+}
+//# sourceMappingURL=SeedEncoder.d.ts.map

package/dist/utils/SeedEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SeedEncoder.d.ts","sourceRoot":"","sources":["../../src/utils/SeedEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,gBAAgB,EAAC,MAAM,WAAW,CAAC;AAIjE,qBAAa,WAAY,YAAW,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC;IAExD,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,GAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAA4B;IAG3G,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAUhC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAKhC,SAAS,CAAC,SAAS,IAAI,MAAM,EAAE;CAIlC"}

package/dist/utils/WalletInteractiveAnchoringEncoder.d.ts

@@ -0,0 +1,13 @@
+import { WalletInteractiveAnchoringRequest, WalletInteractiveAnchoringResponse } from '../type/valibot/walletOperatorMessages/Schemas';
+export declare class WalletInteractiveAnchoringEncoder {
+    private static encoder;
+    static encodeRequest(request: WalletInteractiveAnchoringRequest): Uint8Array;
+    static decodeRequest(request: Uint8Array): WalletInteractiveAnchoringRequest;
+    static encodeResponse(response: WalletInteractiveAnchoringResponse): Uint8Array;
+    static decodeResponse(response: Uint8Array): WalletInteractiveAnchoringResponse;
+}
+export declare class WalletInteractiveAnchoringValidation {
+    static validateRequest(request: object): WalletInteractiveAnchoringRequest;
+    static validateResponse(response: object): WalletInteractiveAnchoringResponse;
+}
+//# sourceMappingURL=WalletInteractiveAnchoringEncoder.d.ts.map

package/dist/utils/WalletInteractiveAnchoringEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WalletInteractiveAnchoringEncoder.d.ts","sourceRoot":"","sources":["../../src/utils/WalletInteractiveAnchoringEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,iCAAiC,EAEjC,kCAAkC,EAErC,MAAM,gDAAgD,CAAC;AAIxD,qBAAa,iCAAiC;IAC1C,OAAO,CAAC,MAAM,CAAC,OAAO,CAGnB;IACH,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,iCAAiC,GAAG,UAAU;IAI5E,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,iCAAiC;IAI5E,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,kCAAkC,GAAG,UAAU;IAI/E,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,UAAU,GAAG,kCAAkC;CAIlF;AAED,qBAAa,oCAAoC;IAC7C,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,iCAAiC;IAI1E,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,kCAAkC;CAGhF"}

package/dist/utils/WalletSeedEncoder.d.ts

@@ -0,0 +1,5 @@
+import { SeedEncoder } from './SeedEncoder';
+export declare class WalletSeedEncoder extends SeedEncoder {
+    protected getPrefix(): string[];
+}
+//# sourceMappingURL=WalletSeedEncoder.d.ts.map

package/dist/utils/WalletSeedEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WalletSeedEncoder.d.ts","sourceRoot":"","sources":["../../src/utils/WalletSeedEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1C,qBAAa,iBAAkB,SAAQ,WAAW;IAC9C,SAAS,CAAC,SAAS,IAAI,MAAM,EAAE;CAGlC"}

package/dist/utils/encoder.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Interface representing a generic encoder capable of encoding and decoding data.
+ *
+ * @template L - The type of the input data to be encoded.
+ * @template R - The type of the output data after encoding and also the input for decoding.
+ */
+export interface EncoderInterface<L, R> {
+    /**
+     * Encodes the given data into the desired format or structure.
+     *
+     * @param {L} data - The input data to be encoded.
+     * @return {R} The encoded result.
+     */
+    encode(data: L): R;
+    /**
+     * Decodes the provided data into a specific format or type.
+     *
+     * @param {R} data - The input data to decode.
+     * @return {L} The decoded output.
+     */
+    decode(data: R): L;
+}
+/**
+ * EncoderFactory is a class responsible for providing encoder instances.
+ * It contains static utility methods to create and retrieve encoders for specific purposes.
+ */
+export declare class EncoderFactory {
+    /**
+     * Provides the default encoder for converting `Uint8Array` bytes to a hexadecimal string representation.
+     *
+     * @return {EncoderInterface<Uint8Array, string>} An instance of `BytesToHexEncoder` for encoding bytes to strings.
+     */
+    static defaultBytesToStringEncoder(): EncoderInterface<Uint8Array, string>;
+    /**
+     * Provides an encoder for converting `Uint8Array` bytes to a base64 string representation.
+     *
+     * @return {EncoderInterface<Uint8Array, string>} An instance of `BytesToBase64Encoder` for encoding bytes to base64 strings.
+     */
+    static bytesToBase64Encoder(): EncoderInterface<Uint8Array, string>;
+    /**
+     * Retrieves an encoder instance that converts bytes (Uint8Array) into a hexadecimal string representation.
+     *
+     * @return {EncoderInterface<Uint8Array, string>} An encoder capable of transforming a Uint8Array into a hexadecimal string.
+     */
+    static bytesToHexEncoder(): EncoderInterface<Uint8Array, string>;
+}
+/**
+ * A class that implements an encoder to convert between byte arrays (Uint8Array)
+ * and base64 string representations. It provides methods for both encoding
+ * byte arrays to base64 strings and decoding base64 strings back to byte arrays.
+ *
+ * This class adheres to the `EncoderInterface` interface, parameterized with
+ * `Uint8Array` for the input/output data type and `string` for the encoded format.
+ *
+ * Methods:
+ * - encode: Converts a given Uint8Array into its base64 string equivalent.
+ * - decode: Converts a base64 string back into a Uint8Array representation.
+ */
+export declare class BytesToBase64Encoder implements EncoderInterface<Uint8Array, string> {
+    /**
+     * Statically decodes a base64 string into a Uint8Array.
+     *
+     * @param {string} data The base64 string to decode.
+     * @return {Uint8Array} The Uint8Array representation of the decoded data.
+     */
+    static decode(data: string): Uint8Array;
+    /**
+     * Statically encodes the given Uint8Array data into a base64 string representation.
+     *
+     * @param {Uint8Array} data - The byte array to be encoded.
+     * @return {string} The base64 string representation of the input data.
+     */
+    static encode(data: Uint8Array): string;
+    /**
+     * Decodes a base64 string into a Uint8Array.
+     *
+     * @param {string} data The base64 string to decode.
+     * @return {Uint8Array} The Uint8Array representation of the decoded data.
+     */
+    decode(data: string): Uint8Array;
+    /**
+     * Encodes the given Uint8Array data into a base64 string representation.
+     *
+     * @param {Uint8Array} data - The byte array to be encoded.
+     * @return {string} The base64 string representation of the input data.
+     */
+    encode(data: Uint8Array): string;
+}
+/**
+ * A class that implements an encoder to convert between byte arrays (Uint8Array)
+ * and hexadecimal string representations. It provides methods for both encoding
+ * byte arrays to hex strings and decoding hex strings back to byte arrays.
+ *
+ * This class adheres to the `EncoderInterface` interface, parameterized with
+ * `Uint8Array` for the input/output data type and `string` for the encoded format.
+ *
+ * Methods:
+ * - encode: Converts a given Uint8Array into its hexadecimal string equivalent.
+ * - decode: Converts a hexadecimal string back into a Uint8Array representation.
+ */
+export declare class BytesToHexEncoder implements EncoderInterface<Uint8Array, string> {
+    /**
+     * Decodes a hexadecimal string into a Uint8Array.
+     *
+     * @param {string} data The hexadecimal string to decode.
+     * @return {Uint8Array} The Uint8Array representation of the decoded data.
+     */
+    decode(data: string): Uint8Array;
+    /**
+     * Encodes the given Uint8Array data into a hexadecimal string representation.
+     *
+     * @param {Uint8Array} data - The byte array to be encoded.
+     * @return {string} The hexadecimal string representation of the input data.
+     */
+    encode(data: Uint8Array): string;
+}
+//# sourceMappingURL=encoder.d.ts.map

package/dist/utils/encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../src/utils/encoder.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,EAAC,CAAC;IACjC;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;IACnB;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;CACtB;AAED;;;GAGG;AACH,qBAAa,cAAc;IACvB;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,IAAI,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC;IAI1E;;;;OAIG;IACH,MAAM,CAAC,oBAAoB,IAAI,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC;IAInE;;;;OAIG;IACH,MAAM,CAAC,iBAAiB,IAAI,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC;CAGnE;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC;IAE7E;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAIvC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;IAIvC;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAIhC;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;CAGnC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAkB,YAAW,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC;IAC1E;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAIhC;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM;CAInC"}

package/dist/utils/utils.d.ts

@@ -0,0 +1,114 @@
+export declare const Utils: {
+    numberToHexa: typeof numberToHexa;
+    truncateString: typeof truncateString;
+    truncateStringMiddle: typeof truncateStringMiddle;
+    getNullHash: typeof getNullHash;
+    getTimestampInSeconds: typeof getTimestampInSeconds;
+    encodeDay: typeof encodeDay;
+    decodeDay: typeof decodeDay;
+    dateToDay: typeof dateToDay;
+    dayToDate: typeof dayToDate;
+    addDaysToTimestamp: typeof addDaysToTimestamp;
+    timestampDifferenceInDays: typeof timestampDifferenceInDays;
+    bufferToUint8Array: typeof bufferToUint8Array;
+    binaryToHexa: typeof binaryToHexa;
+    binaryFromHexa: typeof binaryFromHexa;
+    binaryFrom: typeof binaryFrom;
+    binaryIsEqual: typeof binaryIsEqual;
+    binaryCompare: typeof binaryCompare;
+    intToByteArray: typeof intToByteArray;
+    byteArrayToInt: typeof byteArrayToInt;
+    getGenesisEpochInTimestamp: typeof getInitialTimestampInSeconds;
+    jsonPrettify: typeof jsonPrettify;
+};
+/**
+ * Converts an integer to a hexadecimal string, padded with 0's to reach a given size
+ */
+declare function numberToHexa(value: number, size?: number): string;
+/**
+ * Truncates a string to a given size and appends "(...)" if it's longer
+ */
+declare function truncateString(str: string, size: number): string;
+/**
+ * Truncates a string on both ends and appends "(...)" in the middle if it's longer
+ */
+declare function truncateStringMiddle(str: string, leadingSize: number, trailingSize: number): string;
+/**
+ * Returns a null hash, i.e. an Uint8Array with 32 zero-bytes
+ */
+declare function getNullHash(): Uint8Array<ArrayBuffer>;
+/**
+ * Returns a timestamp in seconds
+ */
+declare function getTimestampInSeconds(): number;
+/**
+ * Returns an initial timestamp set to 0
+ */
+declare function getInitialTimestampInSeconds(): number;
+/**
+ * Encodes a day given as (year, month, day) to a 32-bit value
+ */
+declare function encodeDay(year: number, month: number, day: number): number;
+/**
+ * Converts a 32-bit encoded day to [ year, month, day ]
+ */
+declare function decodeDay(value: number): number[];
+/**
+ * Encodes a day given as a Date to a 32-bit value
+ */
+declare function dateToDay(date: Date): number;
+/**
+ * Converts a 32-bit encoded day to an UTC Date
+ */
+declare function dayToDate(value: number): Date;
+/**
+ * Adds a number of days to a timestamp (in seconds) and returns the resulting timestamp (in seconds),
+ * normalized to 00:00:00 UTC of the resulting date.
+ *
+ * Only the year, month and day are considered: any time-of-day information is discarded.
+ * The `days` offset can be positive, zero, or negative.
+ * If `days` is zero, the function returns the timestamp corresponding to 00:00:00 UTC of the same day.
+ */
+declare function addDaysToTimestamp(ts: number, days: number): number;
+/**
+ * Given two timestamps in seconds, returns the difference in whole days.
+ */
+declare function timestampDifferenceInDays(startTs: number, endTs: number): number;
+/**
+ * Converts a buffer to an Uint8Array
+ */
+declare function bufferToUint8Array(b: any): Uint8Array<any>;
+/**
+ * Converts an Uint8Array to a hexadecimal string
+ */
+declare function binaryToHexa(array: Uint8Array): string;
+/**
+ * Converts a hexadecimal string to an Uint8Array
+ */
+declare function binaryFromHexa(str: string): Uint8Array<ArrayBuffer>;
+/**
+ * Builds an Uint8Array from a list made of integers, strings and Uint8Array's
+ */
+declare function binaryFrom(...arg: (number | Uint8Array | string)[]): Uint8Array<ArrayBuffer>;
+/**
+ * Tests whether two Uint8Array's are equal
+ */
+declare function binaryIsEqual(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * Compares two Uint8Array's and returns 0 for 'equal', -1 for 'less than', 1 for 'greater than'
+ */
+declare function binaryCompare(a: any, b: any): 0 | 1 | -1;
+/**
+ * Converts an integer to an array of bytes, with an optional minimum number of bytes
+ */
+declare function intToByteArray(n: number, minSize?: number): number[];
+/**
+ * Converts an array of bytes to an integer
+ */
+declare function byteArrayToInt(array: number[]): number;
+/**
+ * Formats JSON with a specific format for Uint8Array's so that they are more readable
+ */
+declare function jsonPrettify(json: unknown, indent?: number): string;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;CAsBjB,CAAC;AAIF;;GAEG;AACH,iBAAS,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,UAEjD;AAED;;GAEG;AACH,iBAAS,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAEhD;AAED;;GAEG;AACH,iBAAS,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAKnF;AAED;;GAEG;AACH,iBAAS,WAAW,4BAEnB;AAED;;GAEG;AACH,iBAAS,qBAAqB,WAE7B;AAED;;GAEG;AACH,iBAAS,4BAA4B,WAEpC;AAED;;GAEG;AACH,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,UAE1D;AAED;;GAEG;AACH,iBAAS,SAAS,CAAC,KAAK,EAAE,MAAM,YAM/B;AAED;;GAEG;AACH,iBAAS,SAAS,CAAC,IAAI,EAAE,IAAI,UAM5B;AAED;;GAEG;AACH,iBAAS,SAAS,CAAC,KAAK,EAAE,MAAM,QAI/B;AAED;;;;;;;GAOG;AACH,iBAAS,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAWnD;AAED;;GAEG;AACH,iBAAS,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,UAEhE;AAED;;GAEG;AACH,iBAAS,kBAAkB,CAAC,CAAC,EAAE,GAAG,mBAEjC;AAED;;GAEG;AACH,iBAAS,YAAY,CAAC,KAAK,EAAE,UAAU,UAItC;AAED;;GAEG;AACH,iBAAS,cAAc,CAAC,GAAG,EAAE,MAAM,2BAKlC;AAED;;GAEG;AACH,iBAAS,UAAU,CAAC,GAAG,GAAG,EAAE,CAAC,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC,EAAE,2BAqC3D;AAED;;GAEG;AACH,iBAAS,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,WA0BlD;AAED;;GAEG;AACH,iBAAS,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,cAapC;AAED;;GAEG;AACH,iBAAS,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,MAAU,YAarD;AAED;;GAEG;AACH,iBAAS,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,UAEtC;AAED;;GAEG;AACH,iBAAS,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,SAAI,UAc9C"}

package/dist/wallet/AccountCrypto.d.ts

@@ -0,0 +1,28 @@
+import { ActorCrypto } from './ActorCrypto';
+import { PublicKeyEncryptionSchemeId } from '../crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeId';
+import { BinaryToStringEncoderInterface } from '../utils/BinaryToStringEncoderInterface';
+import { SignatureSchemeId } from '../crypto/signature/SignatureSchemeId';
+import { ICryptoKeyHandler } from './ICryptoKeyHandler';
+/**
+ * Represents the cryptographic operations handled by an account.
+ * An account is derived from a wallet ('s seed) and a nonce unique for each account.
+ */
+export declare class AccountCrypto implements ICryptoKeyHandler {
+    private readonly accountSeed;
+    static createFromWalletSeedAndNonce(walletSeed: Uint8Array, accountNonce: number): AccountCrypto;
+    static parseFromString(seed: string, encoder?: BinaryToStringEncoderInterface): AccountCrypto;
+    encode(encoder?: BinaryToStringEncoderInterface): string;
+    constructor(accountSeed: Uint8Array);
+    deriveActorFromVbSeed(vbSeed: Uint8Array): ActorCrypto;
+    getPrivateSignatureKey(schemeId: SignatureSchemeId): Promise<import('../common').PrivateSignatureKey>;
+    getPublicSignatureKey(schemeId: SignatureSchemeId): Promise<import('../common').PublicSignatureKey>;
+    getPrivateDecryptionKey(schemeId: PublicKeyEncryptionSchemeId): Promise<import('../common').AbstractPrivateDecryptionKey>;
+    getPublicEncryptionKey(schemeId: PublicKeyEncryptionSchemeId): Promise<import('../common').AbstractPublicEncryptionKey>;
+    static encoderStringAsBytes(data: string): Uint8Array;
+    getSeedAsBytes(): Uint8Array;
+    getAccountSeed(): Uint8Array<ArrayBufferLike>;
+    private static concatWalletSeedWith;
+    private static numberToUint8Array;
+    getActor(vbSeed: Uint8Array): ActorCrypto;
+}
+//# sourceMappingURL=AccountCrypto.d.ts.map

package/dist/wallet/AccountCrypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountCrypto.d.ts","sourceRoot":"","sources":["../../src/wallet/AccountCrypto.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAC,2BAA2B,EAAC,MAAM,wEAAwE,CAAC;AAEnH,OAAO,EAAC,8BAA8B,EAAC,MAAM,yCAAyC,CAAC;AACvF,OAAO,EAAC,iBAAiB,EAAC,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD;;;GAGG;AACH,qBAAa,aAAc,YAAW,iBAAiB;IAsBvC,OAAO,CAAC,QAAQ,CAAC,WAAW;IApBxC,MAAM,CAAC,4BAA4B,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM;IAYhF,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,8BAAkD,GAAG,aAAa;IAIhH,MAAM,CAAE,OAAO,GAAE,8BAAkD,GAAG,MAAM;gBAI/C,WAAW,EAAE,UAAU;IAEpD,qBAAqB,CAAC,MAAM,EAAE,UAAU;IAIlC,sBAAsB,CAAC,QAAQ,EAAE,iBAAiB;IAYlD,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB;IAKjD,uBAAuB,CAAC,QAAQ,EAAE,2BAA2B;IAW7D,sBAAsB,CAAC,QAAQ,EAAE,2BAA2B;IAKlE,MAAM,CAAC,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAKrD,cAAc,IAAI,UAAU;IAI5B,cAAc;IAId,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAInC,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAiBjC,QAAQ,CAAC,MAAM,EAAE,UAAU;CAG9B"}

package/dist/wallet/ActorCrypto.d.ts

@@ -0,0 +1,18 @@
+import { PublicKeyEncryptionSchemeId } from '../crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeId';
+import { BinaryToStringEncoderInterface } from '../utils/BinaryToStringEncoderInterface';
+import { SignatureSchemeId } from '../crypto/signature/SignatureSchemeId';
+import { ICryptoKeyHandler } from './ICryptoKeyHandler';
+export declare class ActorCrypto implements ICryptoKeyHandler {
+    private readonly actorSeed;
+    constructor(actorSeed: Uint8Array);
+    static createFromAccountSeedAndVbSeed(accountSeed: Uint8Array, vbSeed: Uint8Array): ActorCrypto;
+    static parseFromString(seed: string, encoder?: BinaryToStringEncoderInterface): ActorCrypto;
+    encode(encoder?: BinaryToStringEncoderInterface): string;
+    getSeedAsBytes(): Uint8Array;
+    getPrivateSignatureKey(schemeId: SignatureSchemeId): Promise<import('../common').PrivateSignatureKey>;
+    getPublicSignatureKey(schemeId: SignatureSchemeId): Promise<import('../common').PublicSignatureKey>;
+    getPrivateDecryptionKey(schemeId: PublicKeyEncryptionSchemeId): Promise<import('../common').AbstractPrivateDecryptionKey>;
+    getPublicEncryptionKey(schemeId: PublicKeyEncryptionSchemeId): Promise<import('../common').AbstractPublicEncryptionKey>;
+    private encoderStringAsBytes;
+}
+//# sourceMappingURL=ActorCrypto.d.ts.map

package/dist/wallet/ActorCrypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActorCrypto.d.ts","sourceRoot":"","sources":["../../src/wallet/ActorCrypto.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,2BAA2B,EAAC,MAAM,wEAAwE,CAAC;AACnH,OAAO,EAAC,8BAA8B,EAAC,MAAM,yCAAyC,CAAC;AACvF,OAAO,EAAC,iBAAiB,EAAC,MAAM,uCAAuC,CAAC;AAExE,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAEtD,qBAAa,WAAY,YAAW,iBAAiB;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,UAAU;IAElD,MAAM,CAAC,8BAA8B,CAAC,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU;IAKjF,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAG,OAAO,GAAE,8BAAkD,GAAG,WAAW;IAI/G,MAAM,CAAE,OAAO,GAAE,8BAAkD,GAAG,MAAM;IAI5E,cAAc,IAAI,UAAU;IAItB,sBAAsB,CAAC,QAAQ,EAAE,iBAAiB;IAWlD,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB;IAKvD,uBAAuB,CAAC,QAAQ,EAAE,2BAA2B;IAWvD,sBAAsB,CAAC,QAAQ,EAAE,2BAA2B;IAKlE,OAAO,CAAC,oBAAoB;CAI/B"}

package/dist/wallet/ICryptoKeyHandler.d.ts

@@ -0,0 +1,13 @@
+import { SignatureSchemeId } from '../crypto/signature/SignatureSchemeId';
+import { PublicKeyEncryptionSchemeId } from '../crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeId';
+import { PrivateSignatureKey } from '../crypto/signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../crypto/signature/PublicSignatureKey';
+import { PrivateDecryptionKey, PublicEncryptionKey } from '../crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeInterface';
+export interface ICryptoKeyHandler {
+    getPrivateSignatureKey(schemeId: SignatureSchemeId): Promise<PrivateSignatureKey>;
+    getPublicSignatureKey(schemeId: SignatureSchemeId): Promise<PublicSignatureKey>;
+    getPrivateDecryptionKey(schemeId: PublicKeyEncryptionSchemeId): Promise<PrivateDecryptionKey>;
+    getPublicEncryptionKey(schemeId: PublicKeyEncryptionSchemeId): Promise<PublicEncryptionKey>;
+    getSeedAsBytes(): Uint8Array;
+}
+//# sourceMappingURL=ICryptoKeyHandler.d.ts.map

package/dist/wallet/ICryptoKeyHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICryptoKeyHandler.d.ts","sourceRoot":"","sources":["../../src/wallet/ICryptoKeyHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,iBAAiB,EAAC,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAC,2BAA2B,EAAC,MAAM,wEAAwE,CAAC;AACnH,OAAO,EAAC,mBAAmB,EAAC,MAAM,yCAAyC,CAAC;AAC5E,OAAO,EAAC,kBAAkB,EAAC,MAAM,wCAAwC,CAAC;AAC1E,OAAO,EACH,oBAAoB,EACpB,mBAAmB,EACtB,MAAM,+EAA+E,CAAC;AAEvF,MAAM,WAAW,iBAAiB;IAC9B,sBAAsB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAClF,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAChF,uBAAuB,CAAC,QAAQ,EAAE,2BAA2B,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAC9F,sBAAsB,CAAC,QAAQ,EAAE,2BAA2B,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAC5F,cAAc,IAAI,UAAU,CAAC;CAChC"}

package/dist/wallet/WalletCrypto.d.ts

@@ -0,0 +1,73 @@
+import { AccountCrypto } from './AccountCrypto';
+import { PublicKeyEncryptionSchemeId } from '../crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeId';
+import { BinaryToStringEncoderInterface } from '../utils/BinaryToStringEncoderInterface';
+import { PrivateSignatureKey } from '../crypto/signature/PrivateSignatureKey';
+import { SignatureSchemeId } from '../crypto/signature/SignatureSchemeId';
+/**
+ * The Wallet class is responsible for generating and managing cryptographic keys
+ * based on a provided wallet seed. It provides methods to retrieve private signature
+ * keys, decapsulation keys, and keys specific to virtual blockchains.
+ */
+export declare class WalletCrypto {
+    private walletSeed;
+    /**
+     * Generates a new Wallet instance using a randomly generated seed.
+     *
+     * @return {WalletCrypto} A new Wallet object created with a random seed.
+     */
+    static generateWallet(): WalletCrypto;
+    static fromSeed(seed: Uint8Array): WalletCrypto;
+    static parseFromString(seed: string, encoder?: BinaryToStringEncoderInterface): WalletCrypto;
+    encode(encoder?: BinaryToStringEncoderInterface): string;
+    private constructor();
+    /**
+     * Generates the default account (i.e., the account associated with nonce zero).
+     */
+    getDefaultAccountCrypto(): AccountCrypto;
+    generateActorPrivateSignatureKey(algoId: SignatureSchemeId, vbSeed: Uint8Array): Promise<PrivateSignatureKey>;
+    /**
+     * @deprecated Will be removed soon!
+     * @param algoId
+     * @param vbSeed
+     */
+    generateActorPrivateDecryptionKey(algoId: PublicKeyEncryptionSchemeId, vbSeed: Uint8Array): Promise<import('../common').AbstractPrivateDecryptionKey>;
+    /**
+     * Generate the private signature key associated to the wallet.
+     *
+     * @param schemeId Type of signature scheme to generate.
+     */
+    getPrivateSignatureKey(schemeId?: SignatureSchemeId): PrivateSignatureKey;
+    /**
+     * Retrieves the decapsulation key for a given cryptographic scheme ID.
+     *
+     * @deprecated Will be removed soon.
+     *
+     * @param {number} schemeId - The identifier of the cryptographic scheme for which the decapsulation key is needed.
+     * @return {*} The generated decapsulation key for the specified scheme ID.
+     */
+    getDecapsulationKey(schemeId: number): import('../common').DecapsulationKey;
+    /**
+     * Derived from the wallet seed, unique for each account.
+     * Used to handle different accounts from the same wallet.
+     *
+     * @param accountNonce The index of the account.
+     */
+    getAccountSeed(accountNonce: number): Uint8Array<ArrayBufferLike>;
+    getAccount(accountNonce: number): AccountCrypto;
+    getAccountPrivateSignatureKey(schemeId: SignatureSchemeId, accountNonce: number): Promise<PrivateSignatureKey>;
+    getActorPrivateSignatureKey(schemeId: number, vbSeed: Uint8Array, accountNonce: number): Promise<PrivateSignatureKey>;
+    /**
+     * Retrieves the virtual blockchain decapsulation key using the specified scheme ID and virtual blockchain seed.
+     *
+     * @deprecated Will be removed soon.
+     * @param {number} schemeId - The identifier of the cryptographic scheme to be used for generating the key.
+     * @param {Uint8Array} vbSeed - The virtual blockchain seed
+     * */
+    getVirtualBlockchainDecapsulationKey(schemeId: number, vbSeed: Uint8Array): import('../common').DecapsulationKey;
+    getSeedAsBytes(): Uint8Array<ArrayBufferLike>;
+}
+/**
+ * @deprecated Will be removed soon!
+ */
+export type Wallet = WalletCrypto;
+//# sourceMappingURL=WalletCrypto.d.ts.map

package/dist/wallet/WalletCrypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WalletCrypto.d.ts","sourceRoot":"","sources":["../../src/wallet/WalletCrypto.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAC,2BAA2B,EAAC,MAAM,wEAAwE,CAAC;AACnH,OAAO,EAAC,8BAA8B,EAAC,MAAM,yCAAyC,CAAC;AACvF,OAAO,EAAC,mBAAmB,EAAC,MAAM,yCAAyC,CAAC;AAC5E,OAAO,EAAC,iBAAiB,EAAC,MAAM,uCAAuC,CAAC;AAIxE;;;;GAIG;AACH,qBAAa,YAAY;IA2BA,OAAO,CAAC,UAAU;IAxBvC;;;;OAIG;IACH,MAAM,CAAC,cAAc,IAAI,YAAY;IAKrC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY;IAK/C,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAG,OAAO,GAAE,8BAAkD,GAAG,YAAY;IAKhH,MAAM,CAAE,OAAO,GAAE,8BAAkD,GAAG,MAAM;IAI5E,OAAO;IAEP;;OAEG;IACH,uBAAuB,IAAI,aAAa;IAKlC,gCAAgC,CAAC,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,UAAU;IASpF;;;;OAIG;IACG,iCAAiC,CAAC,MAAM,EAAE,2BAA2B,EAAE,MAAM,EAAE,UAAU;IAQ/F;;;;OAIG;IACH,sBAAsB,CAAC,QAAQ,GAAE,iBAA+C,GAAG,mBAAmB;IAetG;;;;;;;OAOG;IACH,mBAAmB,CAAE,QAAQ,EAAE,MAAM;IAKrC;;;;;OAKG;IACH,cAAc,CAAC,YAAY,EAAE,MAAM;IAMnC,UAAU,CAAC,YAAY,EAAE,MAAM;IAK/B,6BAA6B,CAAE,QAAQ,EAAE,iBAAiB,EAAG,YAAY,EAAE,MAAM;IAKjF,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM;IAQtF;;;;;;SAMK;IACL,oCAAoC,CAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU;IAK1E,cAAc;CAGjB;AAED;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,YAAY,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmts-dev/carmentis-sdk-core",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "type": "module",
   "license": "Apache-2.0",
   "main": "./dist/carmentis-sdk-core.cjs",
@@ -10,7 +10,7 @@
     ".": {
       "import": "./dist/carmentis-sdk-core.es",
       "require": "./dist/carmentis-sdk-core.cjs",
-      "types": "./dist/carmentis-sdk-core.d.ts"
+      "types": "./dist/common.d.ts"
     }
   },
   "files": [
@@ -51,7 +51,6 @@
     "@noble/hashes": "^1.7.1",
     "@noble/post-quantum": "^0.4.1",
     "@noble/secp256k1": "^2.2.3",
-    "@types/node": "^25.5.2",
     "cbor-x": "^1.6.0",
     "decimal.js": "^10.6.0",
     "jose": "^6.2.2",