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

package/build/utils/JsonEncoder.mjs

@@ -0,0 +1,69 @@
+
+
+import { Buffer } from "./buffer.mjs";
+import { base64ToBase64URL } from "./base64.mjs";
+import { TypedArrayEncoder } from "./TypedArrayEncoder.mjs";
+
+//#region src/utils/JsonEncoder.ts
+var JsonEncoder = class JsonEncoder {
+	/**
+	* Encode json object into base64 string.
+	*
+	* @param json the json object to encode into base64 string
+	*/
+	static toBase64(json) {
+		return Buffer.from(JsonEncoder.toString(json)).toString("base64");
+	}
+	/**
+	* Encode json object into base64url string.
+	*
+	* @param json the json object to encode into base64url string
+	*/
+	static toBase64URL(json) {
+		return base64ToBase64URL(JsonEncoder.toBase64(json));
+	}
+	/**
+	* Decode base64 string into json object. Also supports base64url
+	*
+	* @param base64 the base64 or base64url string to decode into json
+	*/
+	static fromBase64(base64) {
+		return JsonEncoder.fromBuffer(TypedArrayEncoder.fromBase64(base64));
+	}
+	/**
+	* Encode json object into string
+	*
+	* @param json the json object to encode into string
+	*/
+	static toString(json) {
+		return JSON.stringify(json);
+	}
+	/**
+	* Decode string into json object
+	*
+	* @param string the string to decode into json
+	*/
+	static fromString(string) {
+		return JSON.parse(string);
+	}
+	/**
+	* Encode json object into buffer
+	*
+	* @param json the json object to encode into buffer format
+	*/
+	static toBuffer(json) {
+		return Buffer.from(JsonEncoder.toString(json));
+	}
+	/**
+	* Decode buffer into json object
+	*
+	* @param buffer the buffer to decode into json
+	*/
+	static fromBuffer(buffer) {
+		return JsonEncoder.fromString(Buffer.from(buffer).toString("utf-8"));
+	}
+};
+
+//#endregion
+export { JsonEncoder };
+//# sourceMappingURL=JsonEncoder.mjs.map

package/build/utils/JsonEncoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonEncoder.mjs","names":[],"sources":["../../src/utils/JsonEncoder.ts"],"sourcesContent":["import type { AnyUint8Array, Uint8ArrayBuffer } from '../types'\nimport { base64ToBase64URL } from './base64'\nimport { Buffer } from './buffer'\nimport { TypedArrayEncoder } from './TypedArrayEncoder'\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class JsonEncoder {\n  /**\n   * Encode json object into base64 string.\n   *\n   * @param json the json object to encode into base64 string\n   */\n  public static toBase64(json: unknown) {\n    return Buffer.from(JsonEncoder.toString(json)).toString('base64')\n  }\n\n  /**\n   * Encode json object into base64url string.\n   *\n   * @param json the json object to encode into base64url string\n   */\n  public static toBase64URL(json: unknown) {\n    return base64ToBase64URL(JsonEncoder.toBase64(json))\n  }\n\n  /**\n   * Decode base64 string into json object. Also supports base64url\n   *\n   * @param base64 the base64 or base64url string to decode into json\n   */\n  public static fromBase64(base64: string) {\n    return JsonEncoder.fromBuffer(TypedArrayEncoder.fromBase64(base64))\n  }\n\n  /**\n   * Encode json object into string\n   *\n   * @param json the json object to encode into string\n   */\n  public static toString(json: unknown) {\n    return JSON.stringify(json)\n  }\n\n  /**\n   * Decode string into json object\n   *\n   * @param string the string to decode into json\n   */\n  public static fromString(string: string) {\n    return JSON.parse(string)\n  }\n\n  /**\n   * Encode json object into buffer\n   *\n   * @param json the json object to encode into buffer format\n   */\n  public static toBuffer(json: unknown): Uint8ArrayBuffer {\n    return Buffer.from(JsonEncoder.toString(json))\n  }\n\n  /**\n   * Decode buffer into json object\n   *\n   * @param buffer the buffer to decode into json\n   */\n  public static fromBuffer(buffer: Buffer | AnyUint8Array) {\n    return JsonEncoder.fromString(Buffer.from(buffer).toString('utf-8'))\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,cAAb,MAAa,YAAY;;;;;;CAMvB,OAAc,SAAS,MAAe;AACpC,SAAO,OAAO,KAAK,YAAY,SAAS,KAAK,CAAC,CAAC,SAAS,SAAS;;;;;;;CAQnE,OAAc,YAAY,MAAe;AACvC,SAAO,kBAAkB,YAAY,SAAS,KAAK,CAAC;;;;;;;CAQtD,OAAc,WAAW,QAAgB;AACvC,SAAO,YAAY,WAAW,kBAAkB,WAAW,OAAO,CAAC;;;;;;;CAQrE,OAAc,SAAS,MAAe;AACpC,SAAO,KAAK,UAAU,KAAK;;;;;;;CAQ7B,OAAc,WAAW,QAAgB;AACvC,SAAO,KAAK,MAAM,OAAO;;;;;;;CAQ3B,OAAc,SAAS,MAAiC;AACtD,SAAO,OAAO,KAAK,YAAY,SAAS,KAAK,CAAC;;;;;;;CAQhD,OAAc,WAAW,QAAgC;AACvD,SAAO,YAAY,WAAW,OAAO,KAAK,OAAO,CAAC,SAAS,QAAQ,CAAC"}

package/build/utils/JsonTransformer.d.mts

@@ -0,0 +1,22 @@
+//#region src/utils/JsonTransformer.d.ts
+interface Validate {
+  validate?: boolean;
+}
+declare class JsonTransformer {
+  static toJSON<T>(classInstance: T): Record<string, any>;
+  static fromJSON<T>(json: any, cls: {
+    new (...args: any[]): T;
+  }, {
+    validate
+  }?: Validate): T;
+  static clone<T>(classInstance: T): T;
+  static serialize<T>(classInstance: T): string;
+  static deserialize<T>(jsonString: string, cls: {
+    new (...args: any[]): T;
+  }, {
+    validate
+  }?: Validate): T;
+}
+//#endregion
+export { JsonTransformer };
+//# sourceMappingURL=JsonTransformer.d.mts.map

package/build/utils/JsonTransformer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonTransformer.d.mts","names":[],"sources":["../../src/utils/JsonTransformer.ts"],"sourcesContent":[],"mappings":";UAMU,QAAA;;;AAAA,cAKG,eAAA,CALK;EAKL,OAAA,MAAA,CAAA,CAAA,CAAA,CAAA,aAAe,EACa,CADb,CAAA,EACc,MADd,CAAA,MAAA,EAAA,GAAA,CAAA;EACa,OAAA,QAAA,CAAA,CAAA,CAAA,CAAA,IAAA,EAAA,GAAA,EAAA,GAAA,EAAA;IAAC,KAAA,GAAA,IAAA,EAAA,GAAA,EAAA,CAAA,EAUT,CAVS;EAUT,CAAA,EAAA;IAAA;EAAA,CAAA,CAAA,EACR,QADQ,CAAA,EAE5B,CAF4B;EAC3B,OAAA,KAAA,CAAA,CAAA,CAAA,CAAA,aAAA,EAekC,CAflC,CAAA,EAesC,CAftC;EAAmB,OAAA,SAAA,CAAA,CAAA,CAAA,CAAA,aAAA,EAwBmB,CAxBnB,CAAA,EAAA,MAAA;EACpB,OAAA,WAAA,CAAA,CAAA,CAAA,CAAA,UAAA,EAAA,MAAA,EAAA,GAAA,EAAA;IAcmC,KAAA,GAAA,IAAA,EAAA,GAAA,EAAA,CAAA,EAgBP,CAhBO;EAAI,CAAA,EAAA;IAAA;EAAA,CAAA,CAAA,EAiBnB,QAjBmB,CAAA,EAkBvC,CAlBuC"}

package/build/utils/JsonTransformer.mjs

@@ -0,0 +1,37 @@
+
+
+import { ClassValidationError } from "../error/ClassValidationError.mjs";
+import { MessageValidator } from "./MessageValidator.mjs";
+import { instanceToInstance, instanceToPlain, plainToInstance } from "class-transformer";
+
+//#region src/utils/JsonTransformer.ts
+var JsonTransformer = class JsonTransformer {
+	static toJSON(classInstance) {
+		return instanceToPlain(classInstance, { exposeDefaultValues: true });
+	}
+	static fromJSON(json, cls, { validate = true } = {}) {
+		const instance = plainToInstance(cls, json, { exposeDefaultValues: true });
+		if (!validate) return instance;
+		if (!instance) throw new ClassValidationError("Cannot validate instance of ", { classType: Object.getPrototypeOf(cls).name });
+		MessageValidator.validateSync(instance);
+		return instance;
+	}
+	static clone(classInstance) {
+		return instanceToInstance(classInstance, {
+			exposeDefaultValues: true,
+			enableCircularCheck: true,
+			enableImplicitConversion: true,
+			ignoreDecorators: true
+		});
+	}
+	static serialize(classInstance) {
+		return JSON.stringify(JsonTransformer.toJSON(classInstance));
+	}
+	static deserialize(jsonString, cls, { validate = true } = {}) {
+		return JsonTransformer.fromJSON(JSON.parse(jsonString), cls, { validate });
+	}
+};
+
+//#endregion
+export { JsonTransformer };
+//# sourceMappingURL=JsonTransformer.mjs.map

package/build/utils/JsonTransformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"JsonTransformer.mjs","names":[],"sources":["../../src/utils/JsonTransformer.ts"],"sourcesContent":["import { instanceToInstance, instanceToPlain, plainToInstance } from 'class-transformer'\n\nimport { ClassValidationError } from '../error/ClassValidationError'\n\nimport { MessageValidator } from './MessageValidator'\n\ninterface Validate {\n  validate?: boolean\n}\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class JsonTransformer {\n  public static toJSON<T>(classInstance: T) {\n    return instanceToPlain(classInstance, {\n      exposeDefaultValues: true,\n    })\n  }\n\n  public static fromJSON<T>(\n    // biome-ignore lint/suspicious/noExplicitAny: no explanation\n    json: any,\n    // biome-ignore lint/suspicious/noExplicitAny: no explanation\n    cls: { new (...args: any[]): T },\n    { validate = true }: Validate = {}\n  ): T {\n    const instance = plainToInstance(cls, json, { exposeDefaultValues: true })\n\n    // Skip validation\n    if (!validate) return instance\n\n    if (!instance) {\n      throw new ClassValidationError('Cannot validate instance of ', { classType: Object.getPrototypeOf(cls).name })\n    }\n    MessageValidator.validateSync(instance)\n\n    return instance\n  }\n\n  public static clone<T>(classInstance: T): T {\n    return instanceToInstance(classInstance, {\n      exposeDefaultValues: true,\n      enableCircularCheck: true,\n      enableImplicitConversion: true,\n      ignoreDecorators: true,\n    })\n  }\n\n  public static serialize<T>(classInstance: T): string {\n    return JSON.stringify(JsonTransformer.toJSON(classInstance))\n  }\n\n  public static deserialize<T>(\n    jsonString: string,\n    // biome-ignore lint/suspicious/noExplicitAny: no explanation\n    cls: { new (...args: any[]): T },\n    { validate = true }: Validate = {}\n  ): T {\n    return JsonTransformer.fromJSON(JSON.parse(jsonString), cls, { validate })\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,kBAAb,MAAa,gBAAgB;CAC3B,OAAc,OAAU,eAAkB;AACxC,SAAO,gBAAgB,eAAe,EACpC,qBAAqB,MACtB,CAAC;;CAGJ,OAAc,SAEZ,MAEA,KACA,EAAE,WAAW,SAAmB,EAAE,EAC/B;EACH,MAAM,WAAW,gBAAgB,KAAK,MAAM,EAAE,qBAAqB,MAAM,CAAC;AAG1E,MAAI,CAAC,SAAU,QAAO;AAEtB,MAAI,CAAC,SACH,OAAM,IAAI,qBAAqB,gCAAgC,EAAE,WAAW,OAAO,eAAe,IAAI,CAAC,MAAM,CAAC;AAEhH,mBAAiB,aAAa,SAAS;AAEvC,SAAO;;CAGT,OAAc,MAAS,eAAqB;AAC1C,SAAO,mBAAmB,eAAe;GACvC,qBAAqB;GACrB,qBAAqB;GACrB,0BAA0B;GAC1B,kBAAkB;GACnB,CAAC;;CAGJ,OAAc,UAAa,eAA0B;AACnD,SAAO,KAAK,UAAU,gBAAgB,OAAO,cAAc,CAAC;;CAG9D,OAAc,YACZ,YAEA,KACA,EAAE,WAAW,SAAmB,EAAE,EAC/B;AACH,SAAO,gBAAgB,SAAS,KAAK,MAAM,WAAW,EAAE,KAAK,EAAE,UAAU,CAAC"}

package/build/utils/MessageValidator.d.mts

@@ -0,0 +1,13 @@
+//#region src/utils/MessageValidator.d.ts
+declare class MessageValidator {
+  /**
+   *
+   * @param classInstance the class instance to validate
+   * @returns void
+   * @throws array of validation errors {@link ValidationError}
+   */
+  static validateSync<T extends object>(classInstance: T & {}): void;
+}
+//#endregion
+export { MessageValidator };
+//# sourceMappingURL=MessageValidator.d.mts.map

package/build/utils/MessageValidator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageValidator.d.mts","names":[],"sources":["../../src/utils/MessageValidator.ts"],"sourcesContent":[],"mappings":";cAMa,gBAAA;;;AAAb;;;;uDAO8D"}

package/build/utils/MessageValidator.mjs

@@ -0,0 +1,28 @@
+
+
+import { ClassValidationError } from "../error/ClassValidationError.mjs";
+import "../error/index.mjs";
+import { isValidationErrorArray } from "../error/ValidationErrorUtils.mjs";
+import { validateSync } from "class-validator";
+
+//#region src/utils/MessageValidator.ts
+var MessageValidator = class {
+	/**
+	*
+	* @param classInstance the class instance to validate
+	* @returns void
+	* @throws array of validation errors {@link ValidationError}
+	*/
+	static validateSync(classInstance) {
+		const errors = validateSync(classInstance, { forbidUnknownValues: false });
+		if (isValidationErrorArray(errors)) throw new ClassValidationError("Failed to validate class.", {
+			classType: classInstance.constructor.name,
+			validationErrors: errors
+		});
+		if (errors.length !== 0) throw new ClassValidationError("An unknown validation error occurred.", { classType: Object.prototype.constructor(classInstance).name });
+	}
+};
+
+//#endregion
+export { MessageValidator };
+//# sourceMappingURL=MessageValidator.mjs.map

package/build/utils/MessageValidator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageValidator.mjs","names":[],"sources":["../../src/utils/MessageValidator.ts"],"sourcesContent":["import { validateSync } from 'class-validator'\n\nimport { ClassValidationError } from '../error'\nimport { isValidationErrorArray } from '../error/ValidationErrorUtils'\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class MessageValidator {\n  /**\n   *\n   * @param classInstance the class instance to validate\n   * @returns void\n   * @throws array of validation errors {@link ValidationError}\n   */\n  public static validateSync<T extends object>(classInstance: T & {}) {\n    // NOTE: validateSync returns an Array of errors.\n    // We have to transform that into an error of choice and throw that.\n    const errors = validateSync(classInstance, {\n      forbidUnknownValues: false,\n    })\n    if (isValidationErrorArray(errors)) {\n      throw new ClassValidationError('Failed to validate class.', {\n        classType: classInstance.constructor.name,\n        validationErrors: errors,\n      })\n    }\n    if (errors.length !== 0) {\n      throw new ClassValidationError('An unknown validation error occurred.', {\n        classType: Object.prototype.constructor(classInstance).name,\n      })\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAMA,IAAa,mBAAb,MAA8B;;;;;;;CAO5B,OAAc,aAA+B,eAAuB;EAGlE,MAAM,SAAS,aAAa,eAAe,EACzC,qBAAqB,OACtB,CAAC;AACF,MAAI,uBAAuB,OAAO,CAChC,OAAM,IAAI,qBAAqB,6BAA6B;GAC1D,WAAW,cAAc,YAAY;GACrC,kBAAkB;GACnB,CAAC;AAEJ,MAAI,OAAO,WAAW,EACpB,OAAM,IAAI,qBAAqB,yCAAyC,EACtE,WAAW,OAAO,UAAU,YAAY,cAAc,CAAC,MACxD,CAAC"}

package/build/utils/MultiBaseEncoder.d.mts

@@ -0,0 +1,30 @@
+import { AnyUint8Array, Uint8ArrayBuffer } from "../types.mjs";
+
+//#region src/utils/MultiBaseEncoder.d.ts
+type BaseName = 'base58btc';
+declare class MultiBaseEncoder {
+  /**
+   *
+   * Encodes a buffer into a multibase
+   *
+   * @param buffer the buffer that has to be encoded
+   * @param baseName the encoding algorithm
+   */
+  static encode(buffer: AnyUint8Array, baseName: BaseName): string;
+  /**
+   *
+   * Decodes a multibase into a Uint8Array
+   *
+   * @param data the multibase that has to be decoded
+   *
+   * @returns decoded data and the multi base name
+   */
+  static decode(data: string): {
+    data: Uint8ArrayBuffer;
+    baseName: string;
+  };
+  static isValid(data: string): boolean;
+}
+//#endregion
+export { BaseName, MultiBaseEncoder };
+//# sourceMappingURL=MultiBaseEncoder.d.mts.map

package/build/utils/MultiBaseEncoder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiBaseEncoder.d.mts","names":[],"sources":["../../src/utils/MultiBaseEncoder.ts"],"sourcesContent":[],"mappings":";;;KAGY,QAAA;cAmBC,gBAAA;;;AAnBb;AAmBA;;;;EA0B8D,OAAA,MAAA,CAAA,MAAA,EAlB/B,aAkB+B,EAAA,QAAA,EAlBN,QAkBM,CAAA,EAAA,MAAA;;;;;;;;;;UAAhB"}

package/build/utils/MultiBaseEncoder.mjs

@@ -0,0 +1,50 @@
+
+
+import { decodeFromBase58, encodeToBase58 } from "./base58.mjs";
+
+//#region src/utils/MultiBaseEncoder.ts
+const multibaseEncodingMap = { base58btc: (data) => `z${encodeToBase58(data)}` };
+const multibaseDecodingMap = { z: (data) => ({
+	data: decodeFromBase58(data.substring(1)),
+	baseName: "base58btc"
+}) };
+var MultiBaseEncoder = class MultiBaseEncoder {
+	/**
+	*
+	* Encodes a buffer into a multibase
+	*
+	* @param buffer the buffer that has to be encoded
+	* @param baseName the encoding algorithm
+	*/
+	static encode(buffer, baseName) {
+		const encode = multibaseEncodingMap[baseName];
+		if (!encode) throw new Error(`Unsupported encoding '${baseName}'`);
+		return encode(buffer);
+	}
+	/**
+	*
+	* Decodes a multibase into a Uint8Array
+	*
+	* @param data the multibase that has to be decoded
+	*
+	* @returns decoded data and the multi base name
+	*/
+	static decode(data) {
+		const prefix = data[0];
+		const decode = multibaseDecodingMap[prefix];
+		if (!decode) throw new Error(`No decoder found for multibase prefix '${prefix}'`);
+		return decode(data);
+	}
+	static isValid(data) {
+		try {
+			MultiBaseEncoder.decode(data);
+			return true;
+		} catch (_error) {
+			return false;
+		}
+	}
+};
+
+//#endregion
+export { MultiBaseEncoder };
+//# sourceMappingURL=MultiBaseEncoder.mjs.map

package/build/utils/MultiBaseEncoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiBaseEncoder.mjs","names":["multibaseEncodingMap: EncodingMap","multibaseDecodingMap: DecodingMap"],"sources":["../../src/utils/MultiBaseEncoder.ts"],"sourcesContent":["import type { AnyUint8Array, Uint8ArrayBuffer } from '../types'\nimport { decodeFromBase58, encodeToBase58 } from './base58'\n\nexport type BaseName = 'base58btc'\n\ntype EncodingMap = {\n  [key in BaseName]: (data: AnyUint8Array) => string\n}\n\ntype DecodingMap = {\n  [key: string]: (data: string) => { data: Uint8ArrayBuffer; baseName: BaseName }\n}\n\nconst multibaseEncodingMap: EncodingMap = {\n  base58btc: (data) => `z${encodeToBase58(data)}`,\n}\n\nconst multibaseDecodingMap: DecodingMap = {\n  z: (data) => ({ data: decodeFromBase58(data.substring(1)), baseName: 'base58btc' }),\n}\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class MultiBaseEncoder {\n  /**\n   *\n   * Encodes a buffer into a multibase\n   *\n   * @param buffer the buffer that has to be encoded\n   * @param baseName the encoding algorithm\n   */\n  public static encode(buffer: AnyUint8Array, baseName: BaseName) {\n    const encode = multibaseEncodingMap[baseName]\n\n    if (!encode) {\n      throw new Error(`Unsupported encoding '${baseName}'`)\n    }\n\n    return encode(buffer)\n  }\n\n  /**\n   *\n   * Decodes a multibase into a Uint8Array\n   *\n   * @param data the multibase that has to be decoded\n   *\n   * @returns decoded data and the multi base name\n   */\n  public static decode(data: string): { data: Uint8ArrayBuffer; baseName: string } {\n    const prefix = data[0]\n    const decode = multibaseDecodingMap[prefix]\n\n    if (!decode) {\n      throw new Error(`No decoder found for multibase prefix '${prefix}'`)\n    }\n\n    return decode(data)\n  }\n\n  public static isValid(data: string): boolean {\n    try {\n      MultiBaseEncoder.decode(data)\n      return true\n    } catch (_error) {\n      return false\n    }\n  }\n}\n"],"mappings":";;;;;AAaA,MAAMA,uBAAoC,EACxC,YAAY,SAAS,IAAI,eAAe,KAAK,IAC9C;AAED,MAAMC,uBAAoC,EACxC,IAAI,UAAU;CAAE,MAAM,iBAAiB,KAAK,UAAU,EAAE,CAAC;CAAE,UAAU;CAAa,GACnF;AAGD,IAAa,mBAAb,MAAa,iBAAiB;;;;;;;;CAQ5B,OAAc,OAAO,QAAuB,UAAoB;EAC9D,MAAM,SAAS,qBAAqB;AAEpC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,yBAAyB,SAAS,GAAG;AAGvD,SAAO,OAAO,OAAO;;;;;;;;;;CAWvB,OAAc,OAAO,MAA4D;EAC/E,MAAM,SAAS,KAAK;EACpB,MAAM,SAAS,qBAAqB;AAEpC,MAAI,CAAC,OACH,OAAM,IAAI,MAAM,0CAA0C,OAAO,GAAG;AAGtE,SAAO,OAAO,KAAK;;CAGrB,OAAc,QAAQ,MAAuB;AAC3C,MAAI;AACF,oBAAiB,OAAO,KAAK;AAC7B,UAAO;WACA,QAAQ;AACf,UAAO"}

package/build/utils/MultiHashEncoder.d.mts

@@ -0,0 +1,41 @@
+import { AnyUint8Array, Uint8ArrayBuffer } from "../types.mjs";
+import { HashName } from "../crypto/hashes/Hasher.mjs";
+import "../crypto/hashes/index.mjs";
+
+//#region src/utils/MultiHashEncoder.d.ts
+declare class MultiHashEncoder {
+  /**
+   *
+   * Encodes a buffer into a hash
+   *
+   * @param buffer the buffer that has to be encoded
+   * @param hashName the hashing algorithm, 'sha-256'
+   *
+   * @returns a multihash
+   */
+  static encode(data: AnyUint8Array, hashName: HashName): Uint8ArrayBuffer;
+  /**
+   *
+   * Decodes the multihash
+   *
+   * @param data the multihash that has to be decoded
+   *
+   * @returns object with the data and the hashing algorithm
+   */
+  static decode(data: AnyUint8Array): {
+    data: Uint8ArrayBuffer;
+    hashName: string;
+  };
+  /**
+   *
+   * Validates if it is a valid mulithash
+   *
+   * @param data the multihash that needs to be validated
+   *
+   * @returns a boolean whether the multihash is valid
+   */
+  static isValid(data: AnyUint8Array): boolean;
+}
+//#endregion
+export { MultiHashEncoder };
+//# sourceMappingURL=MultiHashEncoder.d.mts.map

package/build/utils/MultiHashEncoder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiHashEncoder.d.mts","names":[],"sources":["../../src/utils/MultiHashEncoder.ts"],"sourcesContent":[],"mappings":";;;;;cA6Ba,gBAAA;;;;;AAAb;;;;;EA4BqD,OAAA,MAAA,CAAA,IAAA,EAlBxB,aAkBwB,EAAA,QAAA,EAlBC,QAkBD,CAAA,EAlBY,gBAkBZ;EA2BvB;;;;;;;;sBA3BD;UAAwB;;;;;;;;;;;uBA2BvB"}

package/build/utils/MultiHashEncoder.mjs

@@ -0,0 +1,79 @@
+
+
+import { TypedArrayEncoder } from "./TypedArrayEncoder.mjs";
+import { Hasher } from "../crypto/hashes/Hasher.mjs";
+import "../crypto/hashes/index.mjs";
+import { VarintEncoder } from "./VarintEncoder.mjs";
+
+//#region src/utils/MultiHashEncoder.ts
+const multiHashNameMap = {
+	"sha-1": 17,
+	"sha-256": 18,
+	"sha-512": 19,
+	"sha-384": 32
+};
+const multiHashCodeMap = Object.entries(multiHashNameMap).reduce((map, [hashName, hashCode]) => ({
+	...map,
+	[hashCode]: hashName
+}), {});
+var MultiHashEncoder = class MultiHashEncoder {
+	/**
+	*
+	* Encodes a buffer into a hash
+	*
+	* @param buffer the buffer that has to be encoded
+	* @param hashName the hashing algorithm, 'sha-256'
+	*
+	* @returns a multihash
+	*/
+	static encode(data, hashName) {
+		const hash = Hasher.hash(data, hashName);
+		const hashCode = multiHashNameMap[hashName];
+		const hashPrefix = VarintEncoder.encode(hashCode);
+		const hashLengthPrefix = VarintEncoder.encode(hash.length);
+		return TypedArrayEncoder.concat([
+			hashPrefix,
+			hashLengthPrefix,
+			hash
+		]);
+	}
+	/**
+	*
+	* Decodes the multihash
+	*
+	* @param data the multihash that has to be decoded
+	*
+	* @returns object with the data and the hashing algorithm
+	*/
+	static decode(data) {
+		const [hashPrefix, hashPrefixByteLength] = VarintEncoder.decode(data);
+		const withoutHashPrefix = data.slice(hashPrefixByteLength);
+		const [, lengthPrefixByteLength] = VarintEncoder.decode(withoutHashPrefix);
+		const withoutLengthPrefix = withoutHashPrefix.slice(lengthPrefixByteLength);
+		if (!multiHashCodeMap[hashPrefix]) throw new Error(`Unsupported hash code 0x${hashPrefix.toString(16)}`);
+		return {
+			data: new Uint8Array(withoutLengthPrefix),
+			hashName: multiHashCodeMap[hashPrefix]
+		};
+	}
+	/**
+	*
+	* Validates if it is a valid mulithash
+	*
+	* @param data the multihash that needs to be validated
+	*
+	* @returns a boolean whether the multihash is valid
+	*/
+	static isValid(data) {
+		try {
+			MultiHashEncoder.decode(data);
+			return true;
+		} catch (_e) {
+			return false;
+		}
+	}
+};
+
+//#endregion
+export { MultiHashEncoder };
+//# sourceMappingURL=MultiHashEncoder.mjs.map

package/build/utils/MultiHashEncoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiHashEncoder.mjs","names":["multiHashNameMap: MultiHashNameMap","multiHashCodeMap: MultiHashCodeMap"],"sources":["../../src/utils/MultiHashEncoder.ts"],"sourcesContent":["import type { HashName } from '../crypto/hashes'\n\nimport { Hasher } from '../crypto/hashes'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../types'\nimport { TypedArrayEncoder } from './TypedArrayEncoder'\nimport { VarintEncoder } from './VarintEncoder'\n\ntype MultiHashNameMap = {\n  [key in HashName]: number\n}\n\ntype MultiHashCodeMap = {\n  [key: number]: HashName\n}\n\nconst multiHashNameMap: MultiHashNameMap = {\n  'sha-1': 0x11,\n  'sha-256': 0x12,\n  'sha-512': 0x13,\n  'sha-384': 0x20,\n}\n\nconst multiHashCodeMap: MultiHashCodeMap = Object.entries(multiHashNameMap).reduce(\n  // biome-ignore lint/performance/noAccumulatingSpread: no explanation\n  (map, [hashName, hashCode]) => ({ ...map, [hashCode]: hashName }),\n  {}\n)\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class MultiHashEncoder {\n  /**\n   *\n   * Encodes a buffer into a hash\n   *\n   * @param buffer the buffer that has to be encoded\n   * @param hashName the hashing algorithm, 'sha-256'\n   *\n   * @returns a multihash\n   */\n  public static encode(data: AnyUint8Array, hashName: HashName): Uint8ArrayBuffer {\n    const hash = Hasher.hash(data, hashName)\n    const hashCode = multiHashNameMap[hashName]\n\n    const hashPrefix = VarintEncoder.encode(hashCode)\n    const hashLengthPrefix = VarintEncoder.encode(hash.length)\n\n    return TypedArrayEncoder.concat([hashPrefix, hashLengthPrefix, hash])\n  }\n\n  /**\n   *\n   * Decodes the multihash\n   *\n   * @param data the multihash that has to be decoded\n   *\n   * @returns object with the data and the hashing algorithm\n   */\n  public static decode(data: AnyUint8Array): { data: Uint8ArrayBuffer; hashName: string } {\n    const [hashPrefix, hashPrefixByteLength] = VarintEncoder.decode(data)\n    const withoutHashPrefix = data.slice(hashPrefixByteLength)\n\n    const [, lengthPrefixByteLength] = VarintEncoder.decode(withoutHashPrefix)\n    const withoutLengthPrefix = withoutHashPrefix.slice(lengthPrefixByteLength)\n\n    const hashName = multiHashCodeMap[hashPrefix]\n\n    if (!hashName) {\n      throw new Error(`Unsupported hash code 0x${hashPrefix.toString(16)}`)\n    }\n\n    return {\n      data: new Uint8Array(withoutLengthPrefix),\n      hashName: multiHashCodeMap[hashPrefix],\n    }\n  }\n\n  /**\n   *\n   * Validates if it is a valid mulithash\n   *\n   * @param data the multihash that needs to be validated\n   *\n   * @returns a boolean whether the multihash is valid\n   */\n  public static isValid(data: AnyUint8Array): boolean {\n    try {\n      MultiHashEncoder.decode(data)\n      return true\n    } catch (_e) {\n      return false\n    }\n  }\n}\n"],"mappings":";;;;;;;;AAeA,MAAMA,mBAAqC;CACzC,SAAS;CACT,WAAW;CACX,WAAW;CACX,WAAW;CACZ;AAED,MAAMC,mBAAqC,OAAO,QAAQ,iBAAiB,CAAC,QAEzE,KAAK,CAAC,UAAU,eAAe;CAAE,GAAG;EAAM,WAAW;CAAU,GAChE,EAAE,CACH;AAGD,IAAa,mBAAb,MAAa,iBAAiB;;;;;;;;;;CAU5B,OAAc,OAAO,MAAqB,UAAsC;EAC9E,MAAM,OAAO,OAAO,KAAK,MAAM,SAAS;EACxC,MAAM,WAAW,iBAAiB;EAElC,MAAM,aAAa,cAAc,OAAO,SAAS;EACjD,MAAM,mBAAmB,cAAc,OAAO,KAAK,OAAO;AAE1D,SAAO,kBAAkB,OAAO;GAAC;GAAY;GAAkB;GAAK,CAAC;;;;;;;;;;CAWvE,OAAc,OAAO,MAAmE;EACtF,MAAM,CAAC,YAAY,wBAAwB,cAAc,OAAO,KAAK;EACrE,MAAM,oBAAoB,KAAK,MAAM,qBAAqB;EAE1D,MAAM,GAAG,0BAA0B,cAAc,OAAO,kBAAkB;EAC1E,MAAM,sBAAsB,kBAAkB,MAAM,uBAAuB;AAI3E,MAAI,CAFa,iBAAiB,YAGhC,OAAM,IAAI,MAAM,2BAA2B,WAAW,SAAS,GAAG,GAAG;AAGvE,SAAO;GACL,MAAM,IAAI,WAAW,oBAAoB;GACzC,UAAU,iBAAiB;GAC5B;;;;;;;;;;CAWH,OAAc,QAAQ,MAA8B;AAClD,MAAI;AACF,oBAAiB,OAAO,KAAK;AAC7B,UAAO;WACA,IAAI;AACX,UAAO"}

package/build/utils/TypedArrayEncoder.d.mts

@@ -0,0 +1,68 @@
+import { AnyUint8Array, Uint8ArrayBuffer } from "../types.mjs";
+import { Buffer } from "./buffer.mjs";
+
+//#region src/utils/TypedArrayEncoder.d.ts
+declare class TypedArrayEncoder {
+  /**
+   * Encode buffer into base64 string.
+   *
+   * @param buffer the buffer to encode into base64 string
+   */
+  static toBase64(buffer: Buffer | AnyUint8Array): string;
+  /**
+   * Encode buffer into base64url string.
+   *
+   * @param buffer the buffer to encode into base64url string
+   */
+  static toBase64URL(buffer: Buffer | AnyUint8Array): string;
+  /**
+   * Encode buffer into base58 string.
+   *
+   * @param buffer the buffer to encode into base58 string
+   */
+  static toBase58(buffer: Buffer | AnyUint8Array): string;
+  /**
+   * Decode base64 string into buffer. Also supports base64url
+   *
+   * @param base64 the base64 or base64url string to decode into buffer format
+   */
+  static fromBase64(base64: string): Buffer<ArrayBuffer>;
+  /**
+   * Decode base58 string into buffer
+   *
+   * @param base58 the base58 string to decode into buffer format
+   */
+  static fromBase58(base58: string): Buffer<ArrayBuffer>;
+  /**
+   * Encode buffer into base64 string.
+   *
+   * @param buffer the buffer to encode into base64 string
+   */
+  static toHex(buffer: Buffer | AnyUint8Array): string;
+  /**
+   * Decode hex string into buffer
+   *
+   * @param hex the hex string to decode into buffer format
+   */
+  static fromHex(hex: string): Buffer<ArrayBuffer>;
+  /**
+   * Decode string into buffer.
+   *
+   * @param str the string to decode into buffer format
+   */
+  static fromString(str: string): Uint8ArrayBuffer;
+  static toUtf8String(buffer: Buffer | AnyUint8Array): string;
+  static concat(entries: AnyUint8Array[]): Uint8ArrayBuffer;
+  static equals(firstBuffer: AnyUint8Array, otherBuffer: AnyUint8Array): boolean;
+  /**
+   * Check whether an array is byte, or typed, array
+   *
+   * @param array unknown The array that has to be checked
+   *
+   * @returns A boolean if the array is a byte array
+   */
+  static isTypedArray(array: unknown): boolean;
+}
+//#endregion
+export { TypedArrayEncoder };
+//# sourceMappingURL=TypedArrayEncoder.d.mts.map

package/build/utils/TypedArrayEncoder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedArrayEncoder.d.mts","names":[],"sources":["../../src/utils/TypedArrayEncoder.ts"],"sourcesContent":[],"mappings":";;;;cAMa,iBAAA;;;;AAAb;;EAM0C,OAAA,QAAA,CAAA,MAAA,EAAT,MAAS,GAAA,aAAA,CAAA,EAAA,MAAA;EASN;;;;;EAkBK,OAAA,WAAA,CAAA,MAAA,EAlBL,MAkBK,GAlBI,aAkBJ,CAAA,EAAA,MAAA;EASA;;;;;EAkBN,OAAA,QAAA,CAAA,MAAA,EApCF,MAoCE,GApCO,aAoCP,CAAA,EAAA,MAAA;EASM;;;;;EAYL,OAAA,UAAA,CAAA,MAAA,EAAA,MAAA,CAAA,EAhDK,MAgDL,CAhDK,WAgDL,CAAA;EAA4B;;;;;qCAvCvB,OAAA;;;;;;uBASX,SAAS;;;;;;+BASJ,OAAA;;;;;;kCASM;8BAIJ,SAAS;yBAId,kBAAkB;6BAId,4BAA4B"}

package/build/utils/TypedArrayEncoder.mjs

@@ -0,0 +1,96 @@
+
+
+import { Buffer } from "./buffer.mjs";
+import { decodeFromBase58, encodeToBase58 } from "./base58.mjs";
+import { base64ToBase64URL } from "./base64.mjs";
+
+//#region src/utils/TypedArrayEncoder.ts
+var TypedArrayEncoder = class TypedArrayEncoder {
+	/**
+	* Encode buffer into base64 string.
+	*
+	* @param buffer the buffer to encode into base64 string
+	*/
+	static toBase64(buffer) {
+		return Buffer.from(buffer).toString("base64");
+	}
+	/**
+	* Encode buffer into base64url string.
+	*
+	* @param buffer the buffer to encode into base64url string
+	*/
+	static toBase64URL(buffer) {
+		return base64ToBase64URL(TypedArrayEncoder.toBase64(buffer));
+	}
+	/**
+	* Encode buffer into base58 string.
+	*
+	* @param buffer the buffer to encode into base58 string
+	*/
+	static toBase58(buffer) {
+		return encodeToBase58(buffer);
+	}
+	/**
+	* Decode base64 string into buffer. Also supports base64url
+	*
+	* @param base64 the base64 or base64url string to decode into buffer format
+	*/
+	static fromBase64(base64) {
+		return Buffer.from(base64, "base64");
+	}
+	/**
+	* Decode base58 string into buffer
+	*
+	* @param base58 the base58 string to decode into buffer format
+	*/
+	static fromBase58(base58) {
+		return Buffer.from(decodeFromBase58(base58));
+	}
+	/**
+	* Encode buffer into base64 string.
+	*
+	* @param buffer the buffer to encode into base64 string
+	*/
+	static toHex(buffer) {
+		return Buffer.from(buffer).toString("hex");
+	}
+	/**
+	* Decode hex string into buffer
+	*
+	* @param hex the hex string to decode into buffer format
+	*/
+	static fromHex(hex) {
+		return Buffer.from(hex, "hex");
+	}
+	/**
+	* Decode string into buffer.
+	*
+	* @param str the string to decode into buffer format
+	*/
+	static fromString(str) {
+		return Buffer.from(str);
+	}
+	static toUtf8String(buffer) {
+		return Buffer.from(buffer).toString();
+	}
+	static concat(entries) {
+		return Buffer.concat(entries);
+	}
+	static equals(firstBuffer, otherBuffer) {
+		return Buffer.from(firstBuffer).equals(otherBuffer);
+	}
+	/**
+	* Check whether an array is byte, or typed, array
+	*
+	* @param array unknown The array that has to be checked
+	*
+	* @returns A boolean if the array is a byte array
+	*/
+	static isTypedArray(array) {
+		return "BYTES_PER_ELEMENT" in array;
+	}
+};
+
+//#endregion
+export { TypedArrayEncoder };
+//# sourceMappingURL=TypedArrayEncoder.mjs.map

package/build/utils/TypedArrayEncoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedArrayEncoder.mjs","names":[],"sources":["../../src/utils/TypedArrayEncoder.ts"],"sourcesContent":["import type { AnyUint8Array, Uint8ArrayBuffer } from '../types'\nimport { decodeFromBase58, encodeToBase58 } from './base58'\nimport { base64ToBase64URL } from './base64'\nimport { Buffer } from './buffer'\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class TypedArrayEncoder {\n  /**\n   * Encode buffer into base64 string.\n   *\n   * @param buffer the buffer to encode into base64 string\n   */\n  public static toBase64(buffer: Buffer | AnyUint8Array) {\n    return Buffer.from(buffer).toString('base64')\n  }\n\n  /**\n   * Encode buffer into base64url string.\n   *\n   * @param buffer the buffer to encode into base64url string\n   */\n  public static toBase64URL(buffer: Buffer | AnyUint8Array) {\n    return base64ToBase64URL(TypedArrayEncoder.toBase64(buffer))\n  }\n\n  /**\n   * Encode buffer into base58 string.\n   *\n   * @param buffer the buffer to encode into base58 string\n   */\n  public static toBase58(buffer: Buffer | AnyUint8Array) {\n    return encodeToBase58(buffer)\n  }\n\n  /**\n   * Decode base64 string into buffer. Also supports base64url\n   *\n   * @param base64 the base64 or base64url string to decode into buffer format\n   */\n  public static fromBase64(base64: string) {\n    return Buffer.from(base64, 'base64')\n  }\n\n  /**\n   * Decode base58 string into buffer\n   *\n   * @param base58 the base58 string to decode into buffer format\n   */\n  public static fromBase58(base58: string) {\n    return Buffer.from(decodeFromBase58(base58))\n  }\n\n  /**\n   * Encode buffer into base64 string.\n   *\n   * @param buffer the buffer to encode into base64 string\n   */\n  public static toHex(buffer: Buffer | AnyUint8Array) {\n    return Buffer.from(buffer).toString('hex')\n  }\n\n  /**\n   * Decode hex string into buffer\n   *\n   * @param hex the hex string to decode into buffer format\n   */\n  public static fromHex(hex: string) {\n    return Buffer.from(hex, 'hex')\n  }\n\n  /**\n   * Decode string into buffer.\n   *\n   * @param str the string to decode into buffer format\n   */\n  public static fromString(str: string): Uint8ArrayBuffer {\n    return Buffer.from(str)\n  }\n\n  public static toUtf8String(buffer: Buffer | AnyUint8Array) {\n    return Buffer.from(buffer).toString()\n  }\n\n  public static concat(entries: AnyUint8Array[]): Uint8ArrayBuffer {\n    return Buffer.concat(entries)\n  }\n\n  public static equals(firstBuffer: AnyUint8Array, otherBuffer: AnyUint8Array): boolean {\n    return Buffer.from(firstBuffer).equals(otherBuffer)\n  }\n\n  /**\n   * Check whether an array is byte, or typed, array\n   *\n   * @param array unknown The array that has to be checked\n   *\n   * @returns A boolean if the array is a byte array\n   */\n  public static isTypedArray(array: unknown): boolean {\n    // Checks whether the static property 'BYTES_PER_ELEMENT' exists on the provided array.\n    // This has to be done, since the TypedArrays, e.g. Uint8Array and Float32Array, do not\n    // extend a single base class\n    return 'BYTES_PER_ELEMENT' in (array as Record<string, unknown>)\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,oBAAb,MAAa,kBAAkB;;;;;;CAM7B,OAAc,SAAS,QAAgC;AACrD,SAAO,OAAO,KAAK,OAAO,CAAC,SAAS,SAAS;;;;;;;CAQ/C,OAAc,YAAY,QAAgC;AACxD,SAAO,kBAAkB,kBAAkB,SAAS,OAAO,CAAC;;;;;;;CAQ9D,OAAc,SAAS,QAAgC;AACrD,SAAO,eAAe,OAAO;;;;;;;CAQ/B,OAAc,WAAW,QAAgB;AACvC,SAAO,OAAO,KAAK,QAAQ,SAAS;;;;;;;CAQtC,OAAc,WAAW,QAAgB;AACvC,SAAO,OAAO,KAAK,iBAAiB,OAAO,CAAC;;;;;;;CAQ9C,OAAc,MAAM,QAAgC;AAClD,SAAO,OAAO,KAAK,OAAO,CAAC,SAAS,MAAM;;;;;;;CAQ5C,OAAc,QAAQ,KAAa;AACjC,SAAO,OAAO,KAAK,KAAK,MAAM;;;;;;;CAQhC,OAAc,WAAW,KAA+B;AACtD,SAAO,OAAO,KAAK,IAAI;;CAGzB,OAAc,aAAa,QAAgC;AACzD,SAAO,OAAO,KAAK,OAAO,CAAC,UAAU;;CAGvC,OAAc,OAAO,SAA4C;AAC/D,SAAO,OAAO,OAAO,QAAQ;;CAG/B,OAAc,OAAO,aAA4B,aAAqC;AACpF,SAAO,OAAO,KAAK,YAAY,CAAC,OAAO,YAAY;;;;;;;;;CAUrD,OAAc,aAAa,OAAyB;AAIlD,SAAO,uBAAwB"}

package/build/utils/VarintEncoder.d.mts

@@ -0,0 +1 @@
+import "../types.mjs";

package/build/utils/VarintEncoder.mjs

@@ -0,0 +1,22 @@
+
+
+import varint from "varint";
+
+//#region src/utils/VarintEncoder.ts
+var VarintEncoder = class VarintEncoder {
+	static decode(data) {
+		return [varint.decode(data), varint.decode.bytes];
+	}
+	static encode(int) {
+		const target = new Uint8Array(VarintEncoder.encodingLength(int));
+		varint.encode(int, target);
+		return target;
+	}
+	static encodingLength(int) {
+		return varint.encodingLength(int);
+	}
+};
+
+//#endregion
+export { VarintEncoder };
+//# sourceMappingURL=VarintEncoder.mjs.map

package/build/utils/VarintEncoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VarintEncoder.mjs","names":[],"sources":["../../src/utils/VarintEncoder.ts"],"sourcesContent":["import varint from 'varint'\n\nimport type { AnyUint8Array } from '../types'\n\n// biome-ignore lint/complexity/noStaticOnlyClass: no explanation\nexport class VarintEncoder {\n  public static decode(data: AnyUint8Array | number[]) {\n    const code = varint.decode(data)\n    return [code, varint.decode.bytes] as const\n  }\n\n  public static encode(int: number) {\n    const target = new Uint8Array(VarintEncoder.encodingLength(int))\n    varint.encode(int, target)\n    return target\n  }\n\n  public static encodingLength(int: number) {\n    return varint.encodingLength(int)\n  }\n}\n"],"mappings":";;;;;AAKA,IAAa,gBAAb,MAAa,cAAc;CACzB,OAAc,OAAO,MAAgC;AAEnD,SAAO,CADM,OAAO,OAAO,KAAK,EAClB,OAAO,OAAO,MAAM;;CAGpC,OAAc,OAAO,KAAa;EAChC,MAAM,SAAS,IAAI,WAAW,cAAc,eAAe,IAAI,CAAC;AAChE,SAAO,OAAO,KAAK,OAAO;AAC1B,SAAO;;CAGT,OAAc,eAAe,KAAa;AACxC,SAAO,OAAO,eAAe,IAAI"}

package/build/utils/array.d.mts

@@ -0,0 +1,7 @@
+import { SingleOrArray } from "../types.mjs";
+
+//#region src/utils/array.d.ts
+declare const asArray: <T>(val?: SingleOrArray<T>) => Array<T>;
+//#endregion
+export { asArray };
+//# sourceMappingURL=array.d.mts.map

package/build/utils/array.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.mts","names":[],"sources":["../../src/utils/array.ts"],"sourcesContent":[],"mappings":";;;cAEa,mBAAoB,cAAc,OAAK,MAAM"}