@bcts/components 1.0.0-alpha.5

package/LICENSE

@@ -0,0 +1,48 @@
+Copyright © 2023 Blockchain Commons, LLC
+Copyright © 2025 Leonardo Amoroso Custodio
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+Subject to the terms and conditions of this license, each copyright holder and
+contributor hereby grants to those receiving rights under this license a
+perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except for failure to satisfy the conditions of this license) patent license to
+make, have made, use, offer to sell, sell, import, and otherwise transfer this
+software, where such license applies only to those patent claims, already
+acquired or hereafter acquired, licensable by such copyright holder or
+contributor that are necessarily infringed by:
+
+    (a) their Contribution(s) (the licensed copyrights of copyright holders and
+    non-copyrightable additions of contributors, in source or binary form)
+    alone; or
+
+    (b) combination of their Contribution(s) with the work of authorship to
+    which such Contribution(s) was added by such copyright holder or
+    contributor, if, at the time the Contribution is added, such addition causes
+    such combination to be necessarily infringed. The patent license shall not
+    apply to any other combinations which include the Contribution.
+
+Except as expressly stated above, no rights or licenses from any copyright
+holder or contributor is granted under this license, whether expressly, by
+implication, estoppel or otherwise.
+
+DISCLAIMER
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,14 @@
+# Blockchain Commons Secure Components for TypeScript
+
+> Disclaimer: This package is under active development and APIs may change.
+
+## Introduction
+
+A collection of useful primitives for cryptography, semantic graphs, and cryptocurrency, primarily for use in higher-level [Blockchain Commons](https://blockchaincommons.com) projects. All the types are [CBOR](https://cbor.io) serializable, and a number of them can also be serialized to and from [URs](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2020-005-ur.md).
+
+Also includes a library of CBOR tags and UR types for use with these types.
+
+## Rust Reference Implementation
+
+This TypeScript implementation is based on [bc-components-rust](https://github.com/BlockchainCommons/bc-components-rust) **v0.30.0** ([commit](https://github.com/BlockchainCommons/bc-components-rust/tree/f3d0081db048da942f316aa4cb5128af8921edd8)).
+

package/dist/digest--g2P5w95.mjs

@@ -0,0 +1,459 @@
+import { CryptoError, SHA256_SIZE, sha256 } from "@bcts/crypto";
+import { createTaggedCbor, decodeCbor, expectBytes, extractTaggedContent, tagsForValues, toByteString, validateTag } from "@bcts/dcbor";
+import { DIGEST } from "@bcts/tags";
+import { UR } from "@bcts/uniform-resources";
+
+//#region src/error.ts
+/**
+* Error types re-exported from @bcts/crypto
+* with additional factory methods for components
+*
+* Ported from bc-components-rust/src/error.rs
+*/
+var CryptoError$1 = class CryptoError$1 extends CryptoError {
+	static invalidSize(expected, actual) {
+		return new CryptoError$1(`Invalid size: expected ${expected}, got ${actual}`);
+	}
+	static invalidFormat(message) {
+		return new CryptoError$1(`Invalid format: ${message}`);
+	}
+	static cryptoOperation(message) {
+		return new CryptoError$1(`Crypto operation failed: ${message}`);
+	}
+	static invalidInput(message) {
+		return new CryptoError$1(`Invalid input: ${message}`);
+	}
+	static dataTooShort(name, minSize, actual) {
+		return new CryptoError$1(`${name} too short: minimum ${minSize}, got ${actual}`);
+	}
+	static invalidData(message) {
+		return new CryptoError$1(`Invalid data: ${message}`);
+	}
+};
+function isError(result) {
+	return result instanceof Error;
+}
+
+//#endregion
+//#region src/utils.ts
+/**
+* Utility functions for byte array conversions and comparisons.
+*
+* These functions provide cross-platform support for common byte manipulation
+* operations needed in cryptographic and encoding contexts.
+*
+* @packageDocumentation
+*/
+/**
+* Convert a Uint8Array to a lowercase hexadecimal string.
+*
+* @param data - The byte array to convert
+* @returns A lowercase hex string representation (2 characters per byte)
+*
+* @example
+* ```typescript
+* const bytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
+* bytesToHex(bytes); // "deadbeef"
+* ```
+*/
+function bytesToHex(data) {
+	return Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Convert a hexadecimal string to a Uint8Array.
+*
+* @param hex - A hex string (must have even length, case-insensitive)
+* @returns The decoded byte array
+* @throws {Error} If the hex string has odd length or contains invalid characters
+*
+* @example
+* ```typescript
+* hexToBytes("deadbeef"); // Uint8Array([0xde, 0xad, 0xbe, 0xef])
+* hexToBytes("DEADBEEF"); // Uint8Array([0xde, 0xad, 0xbe, 0xef])
+* hexToBytes("xyz"); // throws Error: Invalid hex string
+* ```
+*/
+function hexToBytes(hex) {
+	if (hex.length % 2 !== 0) throw new Error(`Hex string must have even length, got ${hex.length}`);
+	if (!/^[0-9A-Fa-f]*$/.test(hex)) throw new Error("Invalid hex string: contains non-hexadecimal characters");
+	const data = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) data[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+	return data;
+}
+/**
+* Convert a Uint8Array to a base64-encoded string.
+*
+* This function works in both browser and Node.js environments.
+* Uses btoa which is available in browsers and Node.js 16+.
+*
+* @param data - The byte array to encode
+* @returns A base64-encoded string
+*
+* @example
+* ```typescript
+* const bytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
+* toBase64(bytes); // "SGVsbG8="
+* ```
+*/
+function toBase64(data) {
+	let binary = "";
+	for (const byte of data) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+/**
+* Convert a base64-encoded string to a Uint8Array.
+*
+* This function works in both browser and Node.js environments.
+* Uses atob which is available in browsers and Node.js 16+.
+*
+* @param base64 - A base64-encoded string
+* @returns The decoded byte array
+*
+* @example
+* ```typescript
+* fromBase64("SGVsbG8="); // Uint8Array([72, 101, 108, 108, 111])
+* ```
+*/
+function fromBase64(base64) {
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+/**
+* Compare two Uint8Arrays for equality using constant-time comparison.
+*
+* This function is designed to be resistant to timing attacks by always
+* comparing all bytes regardless of where a difference is found. The
+* comparison time depends only on the length of the arrays, not on where
+* they differ.
+*
+* **Security Note**: If the arrays have different lengths, this function
+* returns `false` immediately, which does leak length information. For
+* cryptographic uses where length should also be secret, ensure both
+* arrays are the same length before comparison.
+*
+* @param a - First byte array
+* @param b - Second byte array
+* @returns `true` if both arrays have the same length and identical contents
+*
+* @example
+* ```typescript
+* const key1 = new Uint8Array([1, 2, 3, 4]);
+* const key2 = new Uint8Array([1, 2, 3, 4]);
+* const key3 = new Uint8Array([1, 2, 3, 5]);
+*
+* bytesEqual(key1, key2); // true
+* bytesEqual(key1, key3); // false
+* ```
+*/
+function bytesEqual(a, b) {
+	if (a.length !== b.length) return false;
+	let result = 0;
+	for (let i = 0; i < a.length; i++) result |= a[i] ^ b[i];
+	return result === 0;
+}
+
+//#endregion
+//#region src/digest.ts
+/**
+* SHA-256 cryptographic digest (32 bytes)
+*
+* Ported from bc-components-rust/src/digest.rs
+*
+* A `Digest` represents the cryptographic hash of some data. In this
+* implementation, SHA-256 is used, which produces a 32-byte hash value.
+* Digests are used throughout the crate for data verification and as unique
+* identifiers derived from data.
+*
+* # CBOR Serialization
+*
+* `Digest` implements the CBOR tagged encoding interfaces, which means it can be
+* serialized to and deserialized from CBOR with a specific tag (TAG_DIGEST = 40001).
+*
+* # UR Serialization
+*
+* When serialized as a Uniform Resource (UR), a `Digest` is represented as a
+* binary blob with the type "digest".
+*
+* @example
+* ```typescript
+* import { Digest } from '@bcts/components';
+*
+* // Create a digest from a string
+* const data = new TextEncoder().encode("hello world");
+* const digest = Digest.fromImage(data);
+*
+* // Validate that the digest matches the original data
+* console.log(digest.validate(data)); // true
+*
+* // Create a digest from a hex string
+* const hexString = "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9";
+* const digest2 = Digest.fromHex(hexString);
+*
+* // Retrieve the digest as hex
+* console.log(digest2.hex()); // b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9
+* ```
+*/
+var Digest = class Digest {
+	static DIGEST_SIZE = SHA256_SIZE;
+	_data;
+	constructor(data) {
+		if (data.length !== Digest.DIGEST_SIZE) throw CryptoError$1.invalidSize(Digest.DIGEST_SIZE, data.length);
+		this._data = new Uint8Array(data);
+	}
+	/**
+	* Get the digest data.
+	*/
+	data() {
+		return this._data;
+	}
+	/**
+	* Create a Digest from a 32-byte array.
+	*/
+	static fromData(data) {
+		return new Digest(new Uint8Array(data));
+	}
+	/**
+	* Create a Digest from data, validating the length.
+	* Alias for fromData for compatibility with Rust API.
+	*/
+	static fromDataRef(data) {
+		return Digest.fromData(data);
+	}
+	/**
+	* Create a Digest from hex string.
+	*
+	* @throws Error if the hex string is not exactly 64 characters.
+	*/
+	static fromHex(hex) {
+		return new Digest(hexToBytes(hex));
+	}
+	/**
+	* Compute SHA-256 digest of data (called "image" in Rust).
+	*
+	* @param image - The data to hash
+	*/
+	static fromImage(image) {
+		const hashData = sha256(image);
+		return new Digest(new Uint8Array(hashData));
+	}
+	/**
+	* Compute SHA-256 digest from multiple data parts.
+	*
+	* The parts are concatenated and then hashed.
+	*
+	* @param imageParts - Array of byte arrays to concatenate and hash
+	*/
+	static fromImageParts(imageParts) {
+		const totalLength = imageParts.reduce((sum, part) => sum + part.length, 0);
+		const buf = new Uint8Array(totalLength);
+		let offset = 0;
+		for (const part of imageParts) {
+			buf.set(part, offset);
+			offset += part.length;
+		}
+		return Digest.fromImage(buf);
+	}
+	/**
+	* Compute SHA-256 digest from an array of Digests.
+	*
+	* The digest bytes are concatenated and then hashed.
+	*
+	* @param digests - Array of Digests to combine
+	*/
+	static fromDigests(digests) {
+		const buf = new Uint8Array(digests.length * Digest.DIGEST_SIZE);
+		let offset = 0;
+		for (const digest of digests) {
+			buf.set(digest._data, offset);
+			offset += Digest.DIGEST_SIZE;
+		}
+		return Digest.fromImage(buf);
+	}
+	/**
+	* Compute SHA-256 digest of data (legacy alias for fromImage).
+	* @deprecated Use fromImage instead
+	*/
+	static hash(data) {
+		return Digest.fromImage(data);
+	}
+	/**
+	* Get the raw digest bytes as a copy.
+	*/
+	toData() {
+		return new Uint8Array(this._data);
+	}
+	/**
+	* Get a reference to the raw digest bytes.
+	*/
+	asBytes() {
+		return this._data;
+	}
+	/**
+	* Get hex string representation.
+	*/
+	hex() {
+		return bytesToHex(this._data);
+	}
+	/**
+	* Get hex string representation (alias for hex()).
+	*/
+	toHex() {
+		return this.hex();
+	}
+	/**
+	* Get base64 representation.
+	*/
+	toBase64() {
+		return toBase64(this._data);
+	}
+	/**
+	* Get the first four bytes of the digest as a hexadecimal string.
+	* Useful for short descriptions.
+	*/
+	shortDescription() {
+		return bytesToHex(this._data.slice(0, 4));
+	}
+	/**
+	* Validate the digest against the given image.
+	*
+	* The image is hashed with SHA-256 and compared to this digest.
+	* @returns `true` if the digest matches the image.
+	*/
+	validate(image) {
+		return this.equals(Digest.fromImage(image));
+	}
+	/**
+	* Compare with another Digest.
+	*/
+	equals(other) {
+		if (this._data.length !== other._data.length) return false;
+		for (let i = 0; i < this._data.length; i++) if (this._data[i] !== other._data[i]) return false;
+		return true;
+	}
+	/**
+	* Compare digests lexicographically.
+	*/
+	compare(other) {
+		for (let i = 0; i < this._data.length; i++) {
+			const a = this._data[i];
+			const b = other._data[i];
+			if (a < b) return -1;
+			if (a > b) return 1;
+		}
+		return 0;
+	}
+	/**
+	* Get string representation.
+	*/
+	toString() {
+		return `Digest(${this.hex()})`;
+	}
+	/**
+	* A Digest is its own digest provider - returns itself.
+	*/
+	digest() {
+		return this;
+	}
+	/**
+	* Returns the CBOR tags associated with Digest.
+	*/
+	cborTags() {
+		return tagsForValues([DIGEST.value]);
+	}
+	/**
+	* Returns the untagged CBOR encoding (as a byte string).
+	*/
+	untaggedCbor() {
+		return toByteString(this._data);
+	}
+	/**
+	* Returns the tagged CBOR encoding.
+	*/
+	taggedCbor() {
+		return createTaggedCbor(this);
+	}
+	/**
+	* Returns the tagged value in CBOR binary representation.
+	*/
+	taggedCborData() {
+		return this.taggedCbor().toData();
+	}
+	/**
+	* Creates a Digest by decoding it from untagged CBOR.
+	*/
+	fromUntaggedCbor(cbor$1) {
+		const data = expectBytes(cbor$1);
+		return Digest.fromData(data);
+	}
+	/**
+	* Creates a Digest by decoding it from tagged CBOR.
+	*/
+	fromTaggedCbor(cbor$1) {
+		validateTag(cbor$1, this.cborTags());
+		const content = extractTaggedContent(cbor$1);
+		return this.fromUntaggedCbor(content);
+	}
+	/**
+	* Static method to decode from tagged CBOR.
+	*/
+	static fromTaggedCbor(cbor$1) {
+		return new Digest(new Uint8Array(Digest.DIGEST_SIZE)).fromTaggedCbor(cbor$1);
+	}
+	/**
+	* Static method to decode from tagged CBOR binary data.
+	*/
+	static fromTaggedCborData(data) {
+		const cbor$1 = decodeCbor(data);
+		return Digest.fromTaggedCbor(cbor$1);
+	}
+	/**
+	* Static method to decode from untagged CBOR binary data.
+	*/
+	static fromUntaggedCborData(data) {
+		const bytes = expectBytes(decodeCbor(data));
+		return Digest.fromData(bytes);
+	}
+	/**
+	* Returns the UR representation of the Digest.
+	* Note: URs use untagged CBOR since the type is conveyed by the UR type itself.
+	*/
+	ur() {
+		return UR.new("digest", this.untaggedCbor());
+	}
+	/**
+	* Returns the UR string representation.
+	*/
+	urString() {
+		return this.ur().string();
+	}
+	/**
+	* Creates a Digest from a UR.
+	*/
+	static fromUR(ur) {
+		ur.checkType("digest");
+		return new Digest(new Uint8Array(Digest.DIGEST_SIZE)).fromUntaggedCbor(ur.cbor());
+	}
+	/**
+	* Creates a Digest from a UR string.
+	*/
+	static fromURString(urString) {
+		const ur = UR.fromURString(urString);
+		return Digest.fromUR(ur);
+	}
+	/**
+	* Validate the given data against the digest, if any.
+	*
+	* Returns `true` if the digest is `undefined` or if the digest matches the
+	* image's digest. Returns `false` if the digest does not match.
+	*/
+	static validateOpt(image, digest) {
+		if (digest === void 0) return true;
+		return digest.validate(image);
+	}
+};
+
+//#endregion
+export { hexToBytes as a, isError as c, fromBase64 as i, bytesEqual as n, toBase64 as o, bytesToHex as r, CryptoError$1 as s, Digest as t };
+//# sourceMappingURL=digest--g2P5w95.mjs.map

package/dist/digest--g2P5w95.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"digest--g2P5w95.mjs","names":["CryptoError","BaseCryptoError","CryptoError","TAG_DIGEST","cbor"],"sources":["../src/error.ts","../src/utils.ts","../src/digest.ts"],"sourcesContent":["/**\n * Error types re-exported from @bcts/crypto\n * with additional factory methods for components\n *\n * Ported from bc-components-rust/src/error.rs\n */\n\nimport { CryptoError as BaseCryptoError } from \"@bcts/crypto\";\n\nexport class CryptoError extends BaseCryptoError {\n  static invalidSize(expected: number, actual: number): CryptoError {\n    return new CryptoError(`Invalid size: expected ${expected}, got ${actual}`);\n  }\n\n  static invalidFormat(message: string): CryptoError {\n    return new CryptoError(`Invalid format: ${message}`);\n  }\n\n  static cryptoOperation(message: string): CryptoError {\n    return new CryptoError(`Crypto operation failed: ${message}`);\n  }\n\n  static invalidInput(message: string): CryptoError {\n    return new CryptoError(`Invalid input: ${message}`);\n  }\n\n  static dataTooShort(name: string, minSize: number, actual: number): CryptoError {\n    return new CryptoError(`${name} too short: minimum ${minSize}, got ${actual}`);\n  }\n\n  static invalidData(message: string): CryptoError {\n    return new CryptoError(`Invalid data: ${message}`);\n  }\n}\n\nexport type Result<T> = T | Error;\n\nexport function isError(result: unknown): result is Error {\n  return result instanceof Error;\n}\n","/**\n * Utility functions for byte array conversions and comparisons.\n *\n * These functions provide cross-platform support for common byte manipulation\n * operations needed in cryptographic and encoding contexts.\n *\n * @packageDocumentation\n */\n\n/**\n * Convert a Uint8Array to a lowercase hexadecimal string.\n *\n * @param data - The byte array to convert\n * @returns A lowercase hex string representation (2 characters per byte)\n *\n * @example\n * ```typescript\n * const bytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);\n * bytesToHex(bytes); // \"deadbeef\"\n * ```\n */\nexport function bytesToHex(data: Uint8Array): string {\n  return Array.from(data)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n\n/**\n * Convert a hexadecimal string to a Uint8Array.\n *\n * @param hex - A hex string (must have even length, case-insensitive)\n * @returns The decoded byte array\n * @throws {Error} If the hex string has odd length or contains invalid characters\n *\n * @example\n * ```typescript\n * hexToBytes(\"deadbeef\"); // Uint8Array([0xde, 0xad, 0xbe, 0xef])\n * hexToBytes(\"DEADBEEF\"); // Uint8Array([0xde, 0xad, 0xbe, 0xef])\n * hexToBytes(\"xyz\"); // throws Error: Invalid hex string\n * ```\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (hex.length % 2 !== 0) {\n    throw new Error(`Hex string must have even length, got ${hex.length}`);\n  }\n  if (!/^[0-9A-Fa-f]*$/.test(hex)) {\n    throw new Error(\"Invalid hex string: contains non-hexadecimal characters\");\n  }\n  const data = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    data[i / 2] = parseInt(hex.substring(i, i + 2), 16);\n  }\n  return data;\n}\n\n/**\n * Convert a Uint8Array to a base64-encoded string.\n *\n * This function works in both browser and Node.js environments.\n * Uses btoa which is available in browsers and Node.js 16+.\n *\n * @param data - The byte array to encode\n * @returns A base64-encoded string\n *\n * @example\n * ```typescript\n * const bytes = new Uint8Array([72, 101, 108, 108, 111]); // \"Hello\"\n * toBase64(bytes); // \"SGVsbG8=\"\n * ```\n */\nexport function toBase64(data: Uint8Array): string {\n  // Convert bytes to binary string without spread operator to avoid\n  // call stack limits for large arrays (spread would fail at ~65k bytes)\n  let binary = \"\";\n  for (const byte of data) {\n    binary += String.fromCharCode(byte);\n  }\n  return btoa(binary);\n}\n\n/**\n * Convert a base64-encoded string to a Uint8Array.\n *\n * This function works in both browser and Node.js environments.\n * Uses atob which is available in browsers and Node.js 16+.\n *\n * @param base64 - A base64-encoded string\n * @returns The decoded byte array\n *\n * @example\n * ```typescript\n * fromBase64(\"SGVsbG8=\"); // Uint8Array([72, 101, 108, 108, 111])\n * ```\n */\nexport function fromBase64(base64: string): Uint8Array {\n  const binary = atob(base64);\n  const bytes = new Uint8Array(binary.length);\n  for (let i = 0; i < binary.length; i++) {\n    bytes[i] = binary.charCodeAt(i);\n  }\n  return bytes;\n}\n\n/**\n * Compare two Uint8Arrays for equality using constant-time comparison.\n *\n * This function is designed to be resistant to timing attacks by always\n * comparing all bytes regardless of where a difference is found. The\n * comparison time depends only on the length of the arrays, not on where\n * they differ.\n *\n * **Security Note**: If the arrays have different lengths, this function\n * returns `false` immediately, which does leak length information. For\n * cryptographic uses where length should also be secret, ensure both\n * arrays are the same length before comparison.\n *\n * @param a - First byte array\n * @param b - Second byte array\n * @returns `true` if both arrays have the same length and identical contents\n *\n * @example\n * ```typescript\n * const key1 = new Uint8Array([1, 2, 3, 4]);\n * const key2 = new Uint8Array([1, 2, 3, 4]);\n * const key3 = new Uint8Array([1, 2, 3, 5]);\n *\n * bytesEqual(key1, key2); // true\n * bytesEqual(key1, key3); // false\n * ```\n */\nexport function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  let result = 0;\n  for (let i = 0; i < a.length; i++) {\n    result |= a[i] ^ b[i];\n  }\n  return result === 0;\n}\n","/**\n * SHA-256 cryptographic digest (32 bytes)\n *\n * Ported from bc-components-rust/src/digest.rs\n *\n * A `Digest` represents the cryptographic hash of some data. In this\n * implementation, SHA-256 is used, which produces a 32-byte hash value.\n * Digests are used throughout the crate for data verification and as unique\n * identifiers derived from data.\n *\n * # CBOR Serialization\n *\n * `Digest` implements the CBOR tagged encoding interfaces, which means it can be\n * serialized to and deserialized from CBOR with a specific tag (TAG_DIGEST = 40001).\n *\n * # UR Serialization\n *\n * When serialized as a Uniform Resource (UR), a `Digest` is represented as a\n * binary blob with the type \"digest\".\n *\n * @example\n * ```typescript\n * import { Digest } from '@bcts/components';\n *\n * // Create a digest from a string\n * const data = new TextEncoder().encode(\"hello world\");\n * const digest = Digest.fromImage(data);\n *\n * // Validate that the digest matches the original data\n * console.log(digest.validate(data)); // true\n *\n * // Create a digest from a hex string\n * const hexString = \"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9\";\n * const digest2 = Digest.fromHex(hexString);\n *\n * // Retrieve the digest as hex\n * console.log(digest2.hex()); // b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9\n * ```\n */\n\nimport { sha256, SHA256_SIZE } from \"@bcts/crypto\";\nimport {\n  type Cbor,\n  type Tag,\n  type CborTaggedEncodable,\n  type CborTaggedDecodable,\n  toByteString,\n  expectBytes,\n  createTaggedCbor,\n  validateTag,\n  extractTaggedContent,\n  decodeCbor,\n  tagsForValues,\n} from \"@bcts/dcbor\";\nimport { DIGEST as TAG_DIGEST } from \"@bcts/tags\";\nimport { UR, type UREncodable } from \"@bcts/uniform-resources\";\nimport { CryptoError } from \"./error.js\";\nimport { bytesToHex, hexToBytes, toBase64 } from \"./utils.js\";\nimport type { DigestProvider } from \"./digest-provider.js\";\n\nexport class Digest\n  implements DigestProvider, CborTaggedEncodable, CborTaggedDecodable<Digest>, UREncodable\n{\n  static readonly DIGEST_SIZE = SHA256_SIZE;\n\n  private readonly _data: Uint8Array;\n\n  private constructor(data: Uint8Array) {\n    if (data.length !== Digest.DIGEST_SIZE) {\n      throw CryptoError.invalidSize(Digest.DIGEST_SIZE, data.length);\n    }\n    this._data = new Uint8Array(data);\n  }\n\n  /**\n   * Get the digest data.\n   */\n  data(): Uint8Array {\n    return this._data;\n  }\n\n  // ============================================================================\n  // Static Factory Methods\n  // ============================================================================\n\n  /**\n   * Create a Digest from a 32-byte array.\n   */\n  static fromData(data: Uint8Array): Digest {\n    return new Digest(new Uint8Array(data));\n  }\n\n  /**\n   * Create a Digest from data, validating the length.\n   * Alias for fromData for compatibility with Rust API.\n   */\n  static fromDataRef(data: Uint8Array): Digest {\n    return Digest.fromData(data);\n  }\n\n  /**\n   * Create a Digest from hex string.\n   *\n   * @throws Error if the hex string is not exactly 64 characters.\n   */\n  static fromHex(hex: string): Digest {\n    return new Digest(hexToBytes(hex));\n  }\n\n  /**\n   * Compute SHA-256 digest of data (called \"image\" in Rust).\n   *\n   * @param image - The data to hash\n   */\n  static fromImage(image: Uint8Array): Digest {\n    const hashData = sha256(image);\n    return new Digest(new Uint8Array(hashData));\n  }\n\n  /**\n   * Compute SHA-256 digest from multiple data parts.\n   *\n   * The parts are concatenated and then hashed.\n   *\n   * @param imageParts - Array of byte arrays to concatenate and hash\n   */\n  static fromImageParts(imageParts: Uint8Array[]): Digest {\n    const totalLength = imageParts.reduce((sum, part) => sum + part.length, 0);\n    const buf = new Uint8Array(totalLength);\n    let offset = 0;\n    for (const part of imageParts) {\n      buf.set(part, offset);\n      offset += part.length;\n    }\n    return Digest.fromImage(buf);\n  }\n\n  /**\n   * Compute SHA-256 digest from an array of Digests.\n   *\n   * The digest bytes are concatenated and then hashed.\n   *\n   * @param digests - Array of Digests to combine\n   */\n  static fromDigests(digests: Digest[]): Digest {\n    const buf = new Uint8Array(digests.length * Digest.DIGEST_SIZE);\n    let offset = 0;\n    for (const digest of digests) {\n      buf.set(digest._data, offset);\n      offset += Digest.DIGEST_SIZE;\n    }\n    return Digest.fromImage(buf);\n  }\n\n  /**\n   * Compute SHA-256 digest of data (legacy alias for fromImage).\n   * @deprecated Use fromImage instead\n   */\n  static hash(data: Uint8Array): Digest {\n    return Digest.fromImage(data);\n  }\n\n  // ============================================================================\n  // Instance Methods\n  // ============================================================================\n\n  /**\n   * Get the raw digest bytes as a copy.\n   */\n  toData(): Uint8Array {\n    return new Uint8Array(this._data);\n  }\n\n  /**\n   * Get a reference to the raw digest bytes.\n   */\n  asBytes(): Uint8Array {\n    return this._data;\n  }\n\n  /**\n   * Get hex string representation.\n   */\n  hex(): string {\n    return bytesToHex(this._data);\n  }\n\n  /**\n   * Get hex string representation (alias for hex()).\n   */\n  toHex(): string {\n    return this.hex();\n  }\n\n  /**\n   * Get base64 representation.\n   */\n  toBase64(): string {\n    return toBase64(this._data);\n  }\n\n  /**\n   * Get the first four bytes of the digest as a hexadecimal string.\n   * Useful for short descriptions.\n   */\n  shortDescription(): string {\n    return bytesToHex(this._data.slice(0, 4));\n  }\n\n  /**\n   * Validate the digest against the given image.\n   *\n   * The image is hashed with SHA-256 and compared to this digest.\n   * @returns `true` if the digest matches the image.\n   */\n  validate(image: Uint8Array): boolean {\n    return this.equals(Digest.fromImage(image));\n  }\n\n  /**\n   * Compare with another Digest.\n   */\n  equals(other: Digest): boolean {\n    if (this._data.length !== other._data.length) return false;\n    for (let i = 0; i < this._data.length; i++) {\n      if (this._data[i] !== other._data[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Compare digests lexicographically.\n   */\n  compare(other: Digest): number {\n    for (let i = 0; i < this._data.length; i++) {\n      const a = this._data[i];\n      const b = other._data[i];\n      if (a < b) return -1;\n      if (a > b) return 1;\n    }\n    return 0;\n  }\n\n  /**\n   * Get string representation.\n   */\n  toString(): string {\n    return `Digest(${this.hex()})`;\n  }\n\n  // ============================================================================\n  // DigestProvider Implementation\n  // ============================================================================\n\n  /**\n   * A Digest is its own digest provider - returns itself.\n   */\n  digest(): Digest {\n    return this;\n  }\n\n  // ============================================================================\n  // CBOR Serialization (CborTaggedEncodable)\n  // ============================================================================\n\n  /**\n   * Returns the CBOR tags associated with Digest.\n   */\n  cborTags(): Tag[] {\n    return tagsForValues([TAG_DIGEST.value]);\n  }\n\n  /**\n   * Returns the untagged CBOR encoding (as a byte string).\n   */\n  untaggedCbor(): Cbor {\n    return toByteString(this._data);\n  }\n\n  /**\n   * Returns the tagged CBOR encoding.\n   */\n  taggedCbor(): Cbor {\n    return createTaggedCbor(this);\n  }\n\n  /**\n   * Returns the tagged value in CBOR binary representation.\n   */\n  taggedCborData(): Uint8Array {\n    return this.taggedCbor().toData();\n  }\n\n  // ============================================================================\n  // CBOR Deserialization (CborTaggedDecodable)\n  // ============================================================================\n\n  /**\n   * Creates a Digest by decoding it from untagged CBOR.\n   */\n  fromUntaggedCbor(cbor: Cbor): Digest {\n    const data = expectBytes(cbor);\n    return Digest.fromData(data);\n  }\n\n  /**\n   * Creates a Digest by decoding it from tagged CBOR.\n   */\n  fromTaggedCbor(cbor: Cbor): Digest {\n    validateTag(cbor, this.cborTags());\n    const content = extractTaggedContent(cbor);\n    return this.fromUntaggedCbor(content);\n  }\n\n  /**\n   * Static method to decode from tagged CBOR.\n   */\n  static fromTaggedCbor(cbor: Cbor): Digest {\n    const instance = new Digest(new Uint8Array(Digest.DIGEST_SIZE));\n    return instance.fromTaggedCbor(cbor);\n  }\n\n  /**\n   * Static method to decode from tagged CBOR binary data.\n   */\n  static fromTaggedCborData(data: Uint8Array): Digest {\n    const cbor = decodeCbor(data);\n    return Digest.fromTaggedCbor(cbor);\n  }\n\n  /**\n   * Static method to decode from untagged CBOR binary data.\n   */\n  static fromUntaggedCborData(data: Uint8Array): Digest {\n    const cbor = decodeCbor(data);\n    const bytes = expectBytes(cbor);\n    return Digest.fromData(bytes);\n  }\n\n  // ============================================================================\n  // UR Serialization (UREncodable)\n  // ============================================================================\n\n  /**\n   * Returns the UR representation of the Digest.\n   * Note: URs use untagged CBOR since the type is conveyed by the UR type itself.\n   */\n  ur(): UR {\n    return UR.new(\"digest\", this.untaggedCbor());\n  }\n\n  /**\n   * Returns the UR string representation.\n   */\n  urString(): string {\n    return this.ur().string();\n  }\n\n  /**\n   * Creates a Digest from a UR.\n   */\n  static fromUR(ur: UR): Digest {\n    ur.checkType(\"digest\");\n    const instance = new Digest(new Uint8Array(Digest.DIGEST_SIZE));\n    return instance.fromUntaggedCbor(ur.cbor());\n  }\n\n  /**\n   * Creates a Digest from a UR string.\n   */\n  static fromURString(urString: string): Digest {\n    const ur = UR.fromURString(urString);\n    return Digest.fromUR(ur);\n  }\n\n  // ============================================================================\n  // Static Utility Methods\n  // ============================================================================\n\n  /**\n   * Validate the given data against the digest, if any.\n   *\n   * Returns `true` if the digest is `undefined` or if the digest matches the\n   * image's digest. Returns `false` if the digest does not match.\n   */\n  static validateOpt(image: Uint8Array, digest: Digest | undefined): boolean {\n    if (digest === undefined) {\n      return true;\n    }\n    return digest.validate(image);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AASA,IAAaA,gBAAb,MAAaA,sBAAoBC,YAAgB;CAC/C,OAAO,YAAY,UAAkB,QAA6B;AAChE,SAAO,IAAID,cAAY,0BAA0B,SAAS,QAAQ,SAAS;;CAG7E,OAAO,cAAc,SAA8B;AACjD,SAAO,IAAIA,cAAY,mBAAmB,UAAU;;CAGtD,OAAO,gBAAgB,SAA8B;AACnD,SAAO,IAAIA,cAAY,4BAA4B,UAAU;;CAG/D,OAAO,aAAa,SAA8B;AAChD,SAAO,IAAIA,cAAY,kBAAkB,UAAU;;CAGrD,OAAO,aAAa,MAAc,SAAiB,QAA6B;AAC9E,SAAO,IAAIA,cAAY,GAAG,KAAK,sBAAsB,QAAQ,QAAQ,SAAS;;CAGhF,OAAO,YAAY,SAA8B;AAC/C,SAAO,IAAIA,cAAY,iBAAiB,UAAU;;;AAMtD,SAAgB,QAAQ,QAAkC;AACxD,QAAO,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;ACjB3B,SAAgB,WAAW,MAA0B;AACnD,QAAO,MAAM,KAAK,KAAK,CACpB,KAAK,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAC3C,KAAK,GAAG;;;;;;;;;;;;;;;;AAiBb,SAAgB,WAAW,KAAyB;AAClD,KAAI,IAAI,SAAS,MAAM,EACrB,OAAM,IAAI,MAAM,yCAAyC,IAAI,SAAS;AAExE,KAAI,CAAC,iBAAiB,KAAK,IAAI,CAC7B,OAAM,IAAI,MAAM,0DAA0D;CAE5E,MAAM,OAAO,IAAI,WAAW,IAAI,SAAS,EAAE;AAC3C,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,EACnC,MAAK,IAAI,KAAK,SAAS,IAAI,UAAU,GAAG,IAAI,EAAE,EAAE,GAAG;AAErD,QAAO;;;;;;;;;;;;;;;;;AAkBT,SAAgB,SAAS,MAA0B;CAGjD,IAAI,SAAS;AACb,MAAK,MAAM,QAAQ,KACjB,WAAU,OAAO,aAAa,KAAK;AAErC,QAAO,KAAK,OAAO;;;;;;;;;;;;;;;;AAiBrB,SAAgB,WAAW,QAA4B;CACrD,MAAM,SAAS,KAAK,OAAO;CAC3B,MAAM,QAAQ,IAAI,WAAW,OAAO,OAAO;AAC3C,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,IACjC,OAAM,KAAK,OAAO,WAAW,EAAE;AAEjC,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BT,SAAgB,WAAW,GAAe,GAAwB;AAChE,KAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;CAClC,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,IAC5B,WAAU,EAAE,KAAK,EAAE;AAErB,QAAO,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5EpB,IAAa,SAAb,MAAa,OAEb;CACE,OAAgB,cAAc;CAE9B,AAAiB;CAEjB,AAAQ,YAAY,MAAkB;AACpC,MAAI,KAAK,WAAW,OAAO,YACzB,OAAME,cAAY,YAAY,OAAO,aAAa,KAAK,OAAO;AAEhE,OAAK,QAAQ,IAAI,WAAW,KAAK;;;;;CAMnC,OAAmB;AACjB,SAAO,KAAK;;;;;CAUd,OAAO,SAAS,MAA0B;AACxC,SAAO,IAAI,OAAO,IAAI,WAAW,KAAK,CAAC;;;;;;CAOzC,OAAO,YAAY,MAA0B;AAC3C,SAAO,OAAO,SAAS,KAAK;;;;;;;CAQ9B,OAAO,QAAQ,KAAqB;AAClC,SAAO,IAAI,OAAO,WAAW,IAAI,CAAC;;;;;;;CAQpC,OAAO,UAAU,OAA2B;EAC1C,MAAM,WAAW,OAAO,MAAM;AAC9B,SAAO,IAAI,OAAO,IAAI,WAAW,SAAS,CAAC;;;;;;;;;CAU7C,OAAO,eAAe,YAAkC;EACtD,MAAM,cAAc,WAAW,QAAQ,KAAK,SAAS,MAAM,KAAK,QAAQ,EAAE;EAC1E,MAAM,MAAM,IAAI,WAAW,YAAY;EACvC,IAAI,SAAS;AACb,OAAK,MAAM,QAAQ,YAAY;AAC7B,OAAI,IAAI,MAAM,OAAO;AACrB,aAAU,KAAK;;AAEjB,SAAO,OAAO,UAAU,IAAI;;;;;;;;;CAU9B,OAAO,YAAY,SAA2B;EAC5C,MAAM,MAAM,IAAI,WAAW,QAAQ,SAAS,OAAO,YAAY;EAC/D,IAAI,SAAS;AACb,OAAK,MAAM,UAAU,SAAS;AAC5B,OAAI,IAAI,OAAO,OAAO,OAAO;AAC7B,aAAU,OAAO;;AAEnB,SAAO,OAAO,UAAU,IAAI;;;;;;CAO9B,OAAO,KAAK,MAA0B;AACpC,SAAO,OAAO,UAAU,KAAK;;;;;CAU/B,SAAqB;AACnB,SAAO,IAAI,WAAW,KAAK,MAAM;;;;;CAMnC,UAAsB;AACpB,SAAO,KAAK;;;;;CAMd,MAAc;AACZ,SAAO,WAAW,KAAK,MAAM;;;;;CAM/B,QAAgB;AACd,SAAO,KAAK,KAAK;;;;;CAMnB,WAAmB;AACjB,SAAO,SAAS,KAAK,MAAM;;;;;;CAO7B,mBAA2B;AACzB,SAAO,WAAW,KAAK,MAAM,MAAM,GAAG,EAAE,CAAC;;;;;;;;CAS3C,SAAS,OAA4B;AACnC,SAAO,KAAK,OAAO,OAAO,UAAU,MAAM,CAAC;;;;;CAM7C,OAAO,OAAwB;AAC7B,MAAI,KAAK,MAAM,WAAW,MAAM,MAAM,OAAQ,QAAO;AACrD,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,MAAM,QAAQ,IACrC,KAAI,KAAK,MAAM,OAAO,MAAM,MAAM,GAAI,QAAO;AAE/C,SAAO;;;;;CAMT,QAAQ,OAAuB;AAC7B,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,MAAM,QAAQ,KAAK;GAC1C,MAAM,IAAI,KAAK,MAAM;GACrB,MAAM,IAAI,MAAM,MAAM;AACtB,OAAI,IAAI,EAAG,QAAO;AAClB,OAAI,IAAI,EAAG,QAAO;;AAEpB,SAAO;;;;;CAMT,WAAmB;AACjB,SAAO,UAAU,KAAK,KAAK,CAAC;;;;;CAU9B,SAAiB;AACf,SAAO;;;;;CAUT,WAAkB;AAChB,SAAO,cAAc,CAACC,OAAW,MAAM,CAAC;;;;;CAM1C,eAAqB;AACnB,SAAO,aAAa,KAAK,MAAM;;;;;CAMjC,aAAmB;AACjB,SAAO,iBAAiB,KAAK;;;;;CAM/B,iBAA6B;AAC3B,SAAO,KAAK,YAAY,CAAC,QAAQ;;;;;CAUnC,iBAAiB,QAAoB;EACnC,MAAM,OAAO,YAAYC,OAAK;AAC9B,SAAO,OAAO,SAAS,KAAK;;;;;CAM9B,eAAe,QAAoB;AACjC,cAAYA,QAAM,KAAK,UAAU,CAAC;EAClC,MAAM,UAAU,qBAAqBA,OAAK;AAC1C,SAAO,KAAK,iBAAiB,QAAQ;;;;;CAMvC,OAAO,eAAe,QAAoB;AAExC,SADiB,IAAI,OAAO,IAAI,WAAW,OAAO,YAAY,CAAC,CAC/C,eAAeA,OAAK;;;;;CAMtC,OAAO,mBAAmB,MAA0B;EAClD,MAAMA,SAAO,WAAW,KAAK;AAC7B,SAAO,OAAO,eAAeA,OAAK;;;;;CAMpC,OAAO,qBAAqB,MAA0B;EAEpD,MAAM,QAAQ,YADD,WAAW,KAAK,CACE;AAC/B,SAAO,OAAO,SAAS,MAAM;;;;;;CAW/B,KAAS;AACP,SAAO,GAAG,IAAI,UAAU,KAAK,cAAc,CAAC;;;;;CAM9C,WAAmB;AACjB,SAAO,KAAK,IAAI,CAAC,QAAQ;;;;;CAM3B,OAAO,OAAO,IAAgB;AAC5B,KAAG,UAAU,SAAS;AAEtB,SADiB,IAAI,OAAO,IAAI,WAAW,OAAO,YAAY,CAAC,CAC/C,iBAAiB,GAAG,MAAM,CAAC;;;;;CAM7C,OAAO,aAAa,UAA0B;EAC5C,MAAM,KAAK,GAAG,aAAa,SAAS;AACpC,SAAO,OAAO,OAAO,GAAG;;;;;;;;CAa1B,OAAO,YAAY,OAAmB,QAAqC;AACzE,MAAI,WAAW,OACb,QAAO;AAET,SAAO,OAAO,SAAS,MAAM"}