@bcts/hubert 1.0.0-alpha.17

package/LICENSE

@@ -0,0 +1,48 @@
+Copyright © 2025 Blockchain Commons, LLC
+Copyright © 2025-2026 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,18 @@
+# Hubert - Distributed Infrastructure for Secure Multiparty Transactions
+
+> Disclaimer: This package is under active development and APIs may change.
+
+## Introduction
+
+Hubert provides distributed infrastructure for secure multiparty transactions, designed to support FROST threshold signature protocols. It enables distributed key-value storage using ARID (Apparently Random Identifier) addressing with multiple storage backends.
+
+**Key Features:**
+- **ARID-based Addressing**: Cryptographic identifiers that appear random but are deterministically derived
+- **Multiple Storage Backends**: Mainline DHT, IPFS, Hybrid (DHT+IPFS), and Server modes
+- **Write-once Semantics**: Content-addressed storage that cannot be modified once written
+- **Data Obfuscation**: ChaCha20 encryption using ARID-derived keys
+- **Gordian Envelope**: All data is stored as Gordian Envelope structures
+
+## Rust Reference Implementation
+
+This TypeScript implementation is based on [hubert-rust](https://github.com/BlockchainCommons/hubert-rust) **v0.5.0** ([commit](https://github.com/BlockchainCommons/hubert-rust/tree/master)).

package/dist/arid-derivation-1CJuU-kZ.cjs

@@ -0,0 +1,150 @@
+const require_chunk = require('./chunk-CbDLau6x.cjs');
+let _bcts_crypto = require("@bcts/crypto");
+let _noble_ciphers_chacha_js = require("@noble/ciphers/chacha.js");
+
+//#region src/arid-derivation.ts
+/**
+* Derive a deterministic key from an ARID using a specific salt.
+*
+* Uses HKDF to derive key material from the ARID, ensuring that:
+* - Same ARID always produces same key for a given salt
+* - Keys are cryptographically derived (not guessable)
+* - Collision resistance inherited from ARID
+* - No identifying information in the key (fully anonymized)
+*
+* Port of `derive_key()` from arid_derivation.rs lines 8-29.
+*
+* @param salt - Domain-specific salt to ensure different backends derive different keys
+* @param arid - The ARID to derive from
+* @param outputLen - Length of output in bytes (typically 20 or 32)
+* @returns Derived key bytes
+* @category ARID Derivation
+*
+* @example
+* ```typescript
+* const key = deriveKey(new TextEncoder().encode("my-salt"), arid, 32);
+* ```
+*/
+function deriveKey(salt, arid, outputLen) {
+	return (0, _bcts_crypto.hkdfHmacSha256)(arid.data(), salt, outputLen);
+}
+/**
+* Salt for IPFS IPNS key derivation.
+* @internal
+*/
+const IPFS_KEY_NAME_SALT = new TextEncoder().encode("hubert-ipfs-ipns-v1");
+/**
+* Salt for Mainline DHT key derivation.
+* @internal
+*/
+const MAINLINE_KEY_SALT = new TextEncoder().encode("hubert-mainline-dht-v1");
+/**
+* Salt for obfuscation key derivation.
+* @internal
+*/
+const OBFUSCATION_SALT = new TextEncoder().encode("hubert-obfuscation-v1");
+/**
+* Derive an IPNS key name from an ARID.
+*
+* Returns a 64-character hex string suitable for use as an IPFS key name.
+*
+* Port of `derive_ipfs_key_name()` from arid_derivation.rs lines 31-37.
+*
+* @param arid - The ARID to derive from
+* @returns 64-character hex string
+* @category ARID Derivation
+*
+* @example
+* ```typescript
+* const keyName = deriveIpfsKeyName(arid);
+* // => "a1b2c3d4e5f6..." (64 hex characters)
+* ```
+*/
+function deriveIpfsKeyName(arid) {
+	return bytesToHex(deriveKey(IPFS_KEY_NAME_SALT, arid, 32));
+}
+/**
+* Derive Mainline DHT key material from an ARID.
+*
+* Returns 20 bytes of key material (SHA-1 compatible length).
+*
+* Port of `derive_mainline_key()` from arid_derivation.rs lines 39-45.
+*
+* @param arid - The ARID to derive from
+* @returns 20 bytes of key material
+* @category ARID Derivation
+*
+* @example
+* ```typescript
+* const key = deriveMainlineKey(arid);
+* // => Uint8Array(20) [...]
+* ```
+*/
+function deriveMainlineKey(arid) {
+	return deriveKey(MAINLINE_KEY_SALT, arid, 20);
+}
+/**
+* Obfuscate or deobfuscate data using ChaCha20 with an ARID-derived key.
+*
+* This function uses ChaCha20 as a stream cipher to XOR the data with a
+* keystream derived from the ARID. Since XOR is symmetric, the same function
+* is used for both obfuscation and deobfuscation.
+*
+* The result appears as uniform random data to anyone who doesn't have the
+* ARID, hiding both the structure and content of the reference envelope.
+*
+* Port of `obfuscate_with_arid()` from arid_derivation.rs lines 47-91.
+*
+* @param arid - The ARID used to derive the obfuscation key
+* @param data - The data to obfuscate or deobfuscate
+* @returns The obfuscated (or deobfuscated) data
+* @category ARID Derivation
+*
+* @example
+* ```typescript
+* const obfuscated = obfuscateWithArid(arid, plaintext);
+* const deobfuscated = obfuscateWithArid(arid, obfuscated);
+* // deobfuscated === plaintext
+* ```
+*/
+function obfuscateWithArid(arid, data) {
+	if (data.length === 0) return new Uint8Array(0);
+	const key = deriveKey(OBFUSCATION_SALT, arid, 32);
+	const iv = new Uint8Array(12);
+	for (let i = 0; i < 12; i++) iv[i] = key[31 - i];
+	return (0, _noble_ciphers_chacha_js.chacha20)(key, iv, data);
+}
+/**
+* Convert bytes to lowercase hex string.
+* @internal
+*/
+function bytesToHex(bytes) {
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+//#endregion
+Object.defineProperty(exports, 'deriveIpfsKeyName', {
+  enumerable: true,
+  get: function () {
+    return deriveIpfsKeyName;
+  }
+});
+Object.defineProperty(exports, 'deriveKey', {
+  enumerable: true,
+  get: function () {
+    return deriveKey;
+  }
+});
+Object.defineProperty(exports, 'deriveMainlineKey', {
+  enumerable: true,
+  get: function () {
+    return deriveMainlineKey;
+  }
+});
+Object.defineProperty(exports, 'obfuscateWithArid', {
+  enumerable: true,
+  get: function () {
+    return obfuscateWithArid;
+  }
+});
+//# sourceMappingURL=arid-derivation-1CJuU-kZ.cjs.map

package/dist/arid-derivation-1CJuU-kZ.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arid-derivation-1CJuU-kZ.cjs","names":[],"sources":["../src/arid-derivation.ts"],"sourcesContent":["/**\n * ARID key derivation and obfuscation utilities.\n *\n * Port of arid_derivation.rs from hubert-rust.\n *\n * @module\n */\n\nimport { type ARID } from \"@bcts/components\";\nimport { hkdfHmacSha256 } from \"@bcts/crypto\";\nimport { chacha20 } from \"@noble/ciphers/chacha.js\";\n\n/**\n * Derive a deterministic key from an ARID using a specific salt.\n *\n * Uses HKDF to derive key material from the ARID, ensuring that:\n * - Same ARID always produces same key for a given salt\n * - Keys are cryptographically derived (not guessable)\n * - Collision resistance inherited from ARID\n * - No identifying information in the key (fully anonymized)\n *\n * Port of `derive_key()` from arid_derivation.rs lines 8-29.\n *\n * @param salt - Domain-specific salt to ensure different backends derive different keys\n * @param arid - The ARID to derive from\n * @param outputLen - Length of output in bytes (typically 20 or 32)\n * @returns Derived key bytes\n * @category ARID Derivation\n *\n * @example\n * ```typescript\n * const key = deriveKey(new TextEncoder().encode(\"my-salt\"), arid, 32);\n * ```\n */\nexport function deriveKey(salt: Uint8Array, arid: ARID, outputLen: number): Uint8Array {\n  const aridBytes = arid.data();\n  // Note: @bcts/crypto hkdfHmacSha256 takes (keyMaterial, salt, keyLen)\n  // Rust bc-crypto takes (salt, ikm, keyLen)\n  return hkdfHmacSha256(aridBytes, salt, outputLen);\n}\n\n/**\n * Salt for IPFS IPNS key derivation.\n * @internal\n */\nconst IPFS_KEY_NAME_SALT = new TextEncoder().encode(\"hubert-ipfs-ipns-v1\");\n\n/**\n * Salt for Mainline DHT key derivation.\n * @internal\n */\nconst MAINLINE_KEY_SALT = new TextEncoder().encode(\"hubert-mainline-dht-v1\");\n\n/**\n * Salt for obfuscation key derivation.\n * @internal\n */\nconst OBFUSCATION_SALT = new TextEncoder().encode(\"hubert-obfuscation-v1\");\n\n/**\n * Derive an IPNS key name from an ARID.\n *\n * Returns a 64-character hex string suitable for use as an IPFS key name.\n *\n * Port of `derive_ipfs_key_name()` from arid_derivation.rs lines 31-37.\n *\n * @param arid - The ARID to derive from\n * @returns 64-character hex string\n * @category ARID Derivation\n *\n * @example\n * ```typescript\n * const keyName = deriveIpfsKeyName(arid);\n * // => \"a1b2c3d4e5f6...\" (64 hex characters)\n * ```\n */\nexport function deriveIpfsKeyName(arid: ARID): string {\n  const keyBytes = deriveKey(IPFS_KEY_NAME_SALT, arid, 32);\n  return bytesToHex(keyBytes);\n}\n\n/**\n * Derive Mainline DHT key material from an ARID.\n *\n * Returns 20 bytes of key material (SHA-1 compatible length).\n *\n * Port of `derive_mainline_key()` from arid_derivation.rs lines 39-45.\n *\n * @param arid - The ARID to derive from\n * @returns 20 bytes of key material\n * @category ARID Derivation\n *\n * @example\n * ```typescript\n * const key = deriveMainlineKey(arid);\n * // => Uint8Array(20) [...]\n * ```\n */\nexport function deriveMainlineKey(arid: ARID): Uint8Array {\n  return deriveKey(MAINLINE_KEY_SALT, arid, 20);\n}\n\n/**\n * Obfuscate or deobfuscate data using ChaCha20 with an ARID-derived key.\n *\n * This function uses ChaCha20 as a stream cipher to XOR the data with a\n * keystream derived from the ARID. Since XOR is symmetric, the same function\n * is used for both obfuscation and deobfuscation.\n *\n * The result appears as uniform random data to anyone who doesn't have the\n * ARID, hiding both the structure and content of the reference envelope.\n *\n * Port of `obfuscate_with_arid()` from arid_derivation.rs lines 47-91.\n *\n * @param arid - The ARID used to derive the obfuscation key\n * @param data - The data to obfuscate or deobfuscate\n * @returns The obfuscated (or deobfuscated) data\n * @category ARID Derivation\n *\n * @example\n * ```typescript\n * const obfuscated = obfuscateWithArid(arid, plaintext);\n * const deobfuscated = obfuscateWithArid(arid, obfuscated);\n * // deobfuscated === plaintext\n * ```\n */\nexport function obfuscateWithArid(arid: ARID, data: Uint8Array): Uint8Array {\n  if (data.length === 0) {\n    return new Uint8Array(0);\n  }\n\n  // Derive a 32-byte key from the ARID using HKDF with domain-specific salt\n  const key = deriveKey(OBFUSCATION_SALT, arid, 32);\n\n  // Derive IV from the key (last 12 bytes, reversed)\n  // Match Rust: key.iter().rev().take(12).copied().collect()\n  const iv = new Uint8Array(12);\n  for (let i = 0; i < 12; i++) {\n    iv[i] = key[31 - i];\n  }\n\n  // Use ChaCha20 to XOR the data\n  // @noble/ciphers chacha20 takes (key, nonce, data) and returns encrypted data\n  return chacha20(key, iv, data);\n}\n\n/**\n * Convert bytes to lowercase hex string.\n * @internal\n */\nfunction bytesToHex(bytes: Uint8Array): string {\n  return Array.from(bytes)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,UAAU,MAAkB,MAAY,WAA+B;AAIrF,yCAHkB,KAAK,MAAM,EAGI,MAAM,UAAU;;;;;;AAOnD,MAAM,qBAAqB,IAAI,aAAa,CAAC,OAAO,sBAAsB;;;;;AAM1E,MAAM,oBAAoB,IAAI,aAAa,CAAC,OAAO,yBAAyB;;;;;AAM5E,MAAM,mBAAmB,IAAI,aAAa,CAAC,OAAO,wBAAwB;;;;;;;;;;;;;;;;;;AAmB1E,SAAgB,kBAAkB,MAAoB;AAEpD,QAAO,WADU,UAAU,oBAAoB,MAAM,GAAG,CAC7B;;;;;;;;;;;;;;;;;;;AAoB7B,SAAgB,kBAAkB,MAAwB;AACxD,QAAO,UAAU,mBAAmB,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;AA2B/C,SAAgB,kBAAkB,MAAY,MAA8B;AAC1E,KAAI,KAAK,WAAW,EAClB,QAAO,IAAI,WAAW,EAAE;CAI1B,MAAM,MAAM,UAAU,kBAAkB,MAAM,GAAG;CAIjD,MAAM,KAAK,IAAI,WAAW,GAAG;AAC7B,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IACtB,IAAG,KAAK,IAAI,KAAK;AAKnB,+CAAgB,KAAK,IAAI,KAAK;;;;;;AAOhC,SAAS,WAAW,OAA2B;AAC7C,QAAO,MAAM,KAAK,MAAM,CACrB,KAAK,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAC3C,KAAK,GAAG"}

package/dist/arid-derivation-CbqACjdg.mjs

@@ -0,0 +1,126 @@
+import { hkdfHmacSha256 } from "@bcts/crypto";
+import { chacha20 } from "@noble/ciphers/chacha.js";
+
+//#region src/arid-derivation.ts
+/**
+* Derive a deterministic key from an ARID using a specific salt.
+*
+* Uses HKDF to derive key material from the ARID, ensuring that:
+* - Same ARID always produces same key for a given salt
+* - Keys are cryptographically derived (not guessable)
+* - Collision resistance inherited from ARID
+* - No identifying information in the key (fully anonymized)
+*
+* Port of `derive_key()` from arid_derivation.rs lines 8-29.
+*
+* @param salt - Domain-specific salt to ensure different backends derive different keys
+* @param arid - The ARID to derive from
+* @param outputLen - Length of output in bytes (typically 20 or 32)
+* @returns Derived key bytes
+* @category ARID Derivation
+*
+* @example
+* ```typescript
+* const key = deriveKey(new TextEncoder().encode("my-salt"), arid, 32);
+* ```
+*/
+function deriveKey(salt, arid, outputLen) {
+	return hkdfHmacSha256(arid.data(), salt, outputLen);
+}
+/**
+* Salt for IPFS IPNS key derivation.
+* @internal
+*/
+const IPFS_KEY_NAME_SALT = new TextEncoder().encode("hubert-ipfs-ipns-v1");
+/**
+* Salt for Mainline DHT key derivation.
+* @internal
+*/
+const MAINLINE_KEY_SALT = new TextEncoder().encode("hubert-mainline-dht-v1");
+/**
+* Salt for obfuscation key derivation.
+* @internal
+*/
+const OBFUSCATION_SALT = new TextEncoder().encode("hubert-obfuscation-v1");
+/**
+* Derive an IPNS key name from an ARID.
+*
+* Returns a 64-character hex string suitable for use as an IPFS key name.
+*
+* Port of `derive_ipfs_key_name()` from arid_derivation.rs lines 31-37.
+*
+* @param arid - The ARID to derive from
+* @returns 64-character hex string
+* @category ARID Derivation
+*
+* @example
+* ```typescript
+* const keyName = deriveIpfsKeyName(arid);
+* // => "a1b2c3d4e5f6..." (64 hex characters)
+* ```
+*/
+function deriveIpfsKeyName(arid) {
+	return bytesToHex(deriveKey(IPFS_KEY_NAME_SALT, arid, 32));
+}
+/**
+* Derive Mainline DHT key material from an ARID.
+*
+* Returns 20 bytes of key material (SHA-1 compatible length).
+*
+* Port of `derive_mainline_key()` from arid_derivation.rs lines 39-45.
+*
+* @param arid - The ARID to derive from
+* @returns 20 bytes of key material
+* @category ARID Derivation
+*
+* @example
+* ```typescript
+* const key = deriveMainlineKey(arid);
+* // => Uint8Array(20) [...]
+* ```
+*/
+function deriveMainlineKey(arid) {
+	return deriveKey(MAINLINE_KEY_SALT, arid, 20);
+}
+/**
+* Obfuscate or deobfuscate data using ChaCha20 with an ARID-derived key.
+*
+* This function uses ChaCha20 as a stream cipher to XOR the data with a
+* keystream derived from the ARID. Since XOR is symmetric, the same function
+* is used for both obfuscation and deobfuscation.
+*
+* The result appears as uniform random data to anyone who doesn't have the
+* ARID, hiding both the structure and content of the reference envelope.
+*
+* Port of `obfuscate_with_arid()` from arid_derivation.rs lines 47-91.
+*
+* @param arid - The ARID used to derive the obfuscation key
+* @param data - The data to obfuscate or deobfuscate
+* @returns The obfuscated (or deobfuscated) data
+* @category ARID Derivation
+*
+* @example
+* ```typescript
+* const obfuscated = obfuscateWithArid(arid, plaintext);
+* const deobfuscated = obfuscateWithArid(arid, obfuscated);
+* // deobfuscated === plaintext
+* ```
+*/
+function obfuscateWithArid(arid, data) {
+	if (data.length === 0) return new Uint8Array(0);
+	const key = deriveKey(OBFUSCATION_SALT, arid, 32);
+	const iv = new Uint8Array(12);
+	for (let i = 0; i < 12; i++) iv[i] = key[31 - i];
+	return chacha20(key, iv, data);
+}
+/**
+* Convert bytes to lowercase hex string.
+* @internal
+*/
+function bytesToHex(bytes) {
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+//#endregion
+export { obfuscateWithArid as i, deriveKey as n, deriveMainlineKey as r, deriveIpfsKeyName as t };
+//# sourceMappingURL=arid-derivation-CbqACjdg.mjs.map

package/dist/arid-derivation-CbqACjdg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arid-derivation-CbqACjdg.mjs","names":[],"sources":["../src/arid-derivation.ts"],"sourcesContent":["/**\n * ARID key derivation and obfuscation utilities.\n *\n * Port of arid_derivation.rs from hubert-rust.\n *\n * @module\n */\n\nimport { type ARID } from \"@bcts/components\";\nimport { hkdfHmacSha256 } from \"@bcts/crypto\";\nimport { chacha20 } from \"@noble/ciphers/chacha.js\";\n\n/**\n * Derive a deterministic key from an ARID using a specific salt.\n *\n * Uses HKDF to derive key material from the ARID, ensuring that:\n * - Same ARID always produces same key for a given salt\n * - Keys are cryptographically derived (not guessable)\n * - Collision resistance inherited from ARID\n * - No identifying information in the key (fully anonymized)\n *\n * Port of `derive_key()` from arid_derivation.rs lines 8-29.\n *\n * @param salt - Domain-specific salt to ensure different backends derive different keys\n * @param arid - The ARID to derive from\n * @param outputLen - Length of output in bytes (typically 20 or 32)\n * @returns Derived key bytes\n * @category ARID Derivation\n *\n * @example\n * ```typescript\n * const key = deriveKey(new TextEncoder().encode(\"my-salt\"), arid, 32);\n * ```\n */\nexport function deriveKey(salt: Uint8Array, arid: ARID, outputLen: number): Uint8Array {\n  const aridBytes = arid.data();\n  // Note: @bcts/crypto hkdfHmacSha256 takes (keyMaterial, salt, keyLen)\n  // Rust bc-crypto takes (salt, ikm, keyLen)\n  return hkdfHmacSha256(aridBytes, salt, outputLen);\n}\n\n/**\n * Salt for IPFS IPNS key derivation.\n * @internal\n */\nconst IPFS_KEY_NAME_SALT = new TextEncoder().encode(\"hubert-ipfs-ipns-v1\");\n\n/**\n * Salt for Mainline DHT key derivation.\n * @internal\n */\nconst MAINLINE_KEY_SALT = new TextEncoder().encode(\"hubert-mainline-dht-v1\");\n\n/**\n * Salt for obfuscation key derivation.\n * @internal\n */\nconst OBFUSCATION_SALT = new TextEncoder().encode(\"hubert-obfuscation-v1\");\n\n/**\n * Derive an IPNS key name from an ARID.\n *\n * Returns a 64-character hex string suitable for use as an IPFS key name.\n *\n * Port of `derive_ipfs_key_name()` from arid_derivation.rs lines 31-37.\n *\n * @param arid - The ARID to derive from\n * @returns 64-character hex string\n * @category ARID Derivation\n *\n * @example\n * ```typescript\n * const keyName = deriveIpfsKeyName(arid);\n * // => \"a1b2c3d4e5f6...\" (64 hex characters)\n * ```\n */\nexport function deriveIpfsKeyName(arid: ARID): string {\n  const keyBytes = deriveKey(IPFS_KEY_NAME_SALT, arid, 32);\n  return bytesToHex(keyBytes);\n}\n\n/**\n * Derive Mainline DHT key material from an ARID.\n *\n * Returns 20 bytes of key material (SHA-1 compatible length).\n *\n * Port of `derive_mainline_key()` from arid_derivation.rs lines 39-45.\n *\n * @param arid - The ARID to derive from\n * @returns 20 bytes of key material\n * @category ARID Derivation\n *\n * @example\n * ```typescript\n * const key = deriveMainlineKey(arid);\n * // => Uint8Array(20) [...]\n * ```\n */\nexport function deriveMainlineKey(arid: ARID): Uint8Array {\n  return deriveKey(MAINLINE_KEY_SALT, arid, 20);\n}\n\n/**\n * Obfuscate or deobfuscate data using ChaCha20 with an ARID-derived key.\n *\n * This function uses ChaCha20 as a stream cipher to XOR the data with a\n * keystream derived from the ARID. Since XOR is symmetric, the same function\n * is used for both obfuscation and deobfuscation.\n *\n * The result appears as uniform random data to anyone who doesn't have the\n * ARID, hiding both the structure and content of the reference envelope.\n *\n * Port of `obfuscate_with_arid()` from arid_derivation.rs lines 47-91.\n *\n * @param arid - The ARID used to derive the obfuscation key\n * @param data - The data to obfuscate or deobfuscate\n * @returns The obfuscated (or deobfuscated) data\n * @category ARID Derivation\n *\n * @example\n * ```typescript\n * const obfuscated = obfuscateWithArid(arid, plaintext);\n * const deobfuscated = obfuscateWithArid(arid, obfuscated);\n * // deobfuscated === plaintext\n * ```\n */\nexport function obfuscateWithArid(arid: ARID, data: Uint8Array): Uint8Array {\n  if (data.length === 0) {\n    return new Uint8Array(0);\n  }\n\n  // Derive a 32-byte key from the ARID using HKDF with domain-specific salt\n  const key = deriveKey(OBFUSCATION_SALT, arid, 32);\n\n  // Derive IV from the key (last 12 bytes, reversed)\n  // Match Rust: key.iter().rev().take(12).copied().collect()\n  const iv = new Uint8Array(12);\n  for (let i = 0; i < 12; i++) {\n    iv[i] = key[31 - i];\n  }\n\n  // Use ChaCha20 to XOR the data\n  // @noble/ciphers chacha20 takes (key, nonce, data) and returns encrypted data\n  return chacha20(key, iv, data);\n}\n\n/**\n * Convert bytes to lowercase hex string.\n * @internal\n */\nfunction bytesToHex(bytes: Uint8Array): string {\n  return Array.from(bytes)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,UAAU,MAAkB,MAAY,WAA+B;AAIrF,QAAO,eAHW,KAAK,MAAM,EAGI,MAAM,UAAU;;;;;;AAOnD,MAAM,qBAAqB,IAAI,aAAa,CAAC,OAAO,sBAAsB;;;;;AAM1E,MAAM,oBAAoB,IAAI,aAAa,CAAC,OAAO,yBAAyB;;;;;AAM5E,MAAM,mBAAmB,IAAI,aAAa,CAAC,OAAO,wBAAwB;;;;;;;;;;;;;;;;;;AAmB1E,SAAgB,kBAAkB,MAAoB;AAEpD,QAAO,WADU,UAAU,oBAAoB,MAAM,GAAG,CAC7B;;;;;;;;;;;;;;;;;;;AAoB7B,SAAgB,kBAAkB,MAAwB;AACxD,QAAO,UAAU,mBAAmB,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;AA2B/C,SAAgB,kBAAkB,MAAY,MAA8B;AAC1E,KAAI,KAAK,WAAW,EAClB,QAAO,IAAI,WAAW,EAAE;CAI1B,MAAM,MAAM,UAAU,kBAAkB,MAAM,GAAG;CAIjD,MAAM,KAAK,IAAI,WAAW,GAAG;AAC7B,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,IACtB,IAAG,KAAK,IAAI,KAAK;AAKnB,QAAO,SAAS,KAAK,IAAI,KAAK;;;;;;AAOhC,SAAS,WAAW,OAA2B;AAC7C,QAAO,MAAM,KAAK,MAAM,CACrB,KAAK,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAC3C,KAAK,GAAG"}