@z-torrent/merkle-tree 0.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Z-Torrent contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# @z-torrent/merkle-tree
+
+[BEP 52](http://www.bittorrent.org/beps/bep_0052.html) BitTorrent v2 **merkle hash trees** (SHA-256, 16 KiB leaf blocks). Used by [@z-torrent/create](https://www.npmjs.com/package/@z-torrent/create) and [@z-torrent/core](https://www.npmjs.com/package/@z-torrent/core) for v2 / hybrid torrents.
+
+**Node.js 18+** (uses `node:crypto`).
+
+## Install
+
+```bash
+npm install @z-torrent/merkle-tree
+```
+
+## API overview
+
+### Constants
+
+- **`BEP52_BLOCK_SIZE`** — leaf block size (16 KiB).
+- **`BEP52_ZERO_LEAF`** — 32 zero bytes; padding leaf per BEP 52.
+
+### Hash helpers
+
+- **`sha256Data(data)`** — SHA-256 of raw bytes.
+- **`sha256Concat(left, right)`** — SHA-256 of `left || right` (64-byte node input).
+
+### Layers and roots
+
+- **`rootHashLayer(hashes)`** — Merkle root of a complete binary layer (length must be a power of two). Each parent is `SHA256(left || right)`.
+- **`buildMerkleLayers(leaves)`** — Build all tree layers from leaf hashes (padded to the next power of two with zero leaves).
+- **`padPieceBlockHashes(blockHashes, blocksPerPiece, isFirstPiece)`** — Pad per-piece block hashes to the leaf count required by BEP 52.
+- **`padPieceRoot(blocksPerPiece)`** — Root of a virtual “all zero leaf” piece (file-tree balancing).
+
+### File hashing (torrent creator)
+
+- **`buildFileV2Merkle(fileData, pieceLength)`** — Compute v2 per-file metadata: `piecesRoot`, optional `pieceLayerConcat`, and `pieceSubtreeRoots`. `pieceLength` must be a power of two and ≥ 16 KiB.
+
+### Proofs and verification
+
+- **`unclesForLeafIndex(layers, leafIndex, proofLayers)`** — Uncle (sibling) hashes for a leaf, bottom-up.
+- **`verifyLeafToRoot(leafHash, leafIndex, uncles, expectedRoot)`** — Check a Merkle path.
+- **`pieceSubtreeRootFromBytes(pieceBytes, pieceLength, isFirstPieceOfFile)`** — Subtree root for one logical piece’s raw bytes (matches reference BEP 52 padding for the first piece of a file).
+
+### Types
+
+- **`FileV2MerkleResult`** — `{ length, piecesRoot?, pieceLayerConcat?, pieceSubtreeRoots }`.
+
+## Example
+
+```js
+import { buildFileV2Merkle, BEP52_BLOCK_SIZE } from '@z-torrent/merkle-tree'
+
+const data = new TextEncoder().encode('hello')
+const pieceLength = 32 * 1024 // ≥ BEP52_BLOCK_SIZE, power of two
+const { piecesRoot, pieceSubtreeRoots } = buildFileV2Merkle(data, pieceLength)
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+//#region src/bep52.d.ts
+/** 16 KiB — BEP 52 leaf block size */
+declare const BEP52_BLOCK_SIZE: number;
+/** 32 zero bytes — padding leaf per BEP 52 */
+declare const BEP52_ZERO_LEAF: Uint8Array<ArrayBuffer>;
+declare function sha256Concat(left: Uint8Array, right: Uint8Array): Uint8Array;
+declare function sha256Data(data: Uint8Array): Uint8Array;
+/**
+ * Merkle root of a complete binary layer (length must be a power of two).
+ * Each node is SHA256(left || right).
+ */
+declare function rootHashLayer(hashes: Uint8Array[]): Uint8Array;
+/**
+ * Pad block hashes for one piece to the leaf count required by BEP 52.
+ */
+declare function padPieceBlockHashes(blockHashes: Uint8Array[], blocksPerPiece: number, isFirstPiece: boolean): Uint8Array[];
+/** Root of a “virtual” piece made entirely of zero leaves (BEP 52 file-tree balancing). */
+declare function padPieceRoot(blocksPerPiece: number): Uint8Array;
+interface FileV2MerkleResult {
+  /** Total file length in bytes */
+  length: number;
+  /** Merkle root over piece-level hashes (`pieces root` in file tree) */
+  piecesRoot?: Uint8Array;
+  /**
+   * Concatenated 32-byte piece subtree roots for `piece layers` dict value.
+   * Omitted when file fits in one piece (no `piece layers` entry per BEP 52).
+   */
+  pieceLayerConcat?: Uint8Array;
+  /** Per-piece subtree roots (each is root of that piece’s block merkle tree) */
+  pieceSubtreeRoots: Uint8Array[];
+}
+/**
+ * Build BEP 52 per-file merkle metadata from raw file bytes.
+ * Mirrors `FileHasher` in the reference `bep_0052_torrent_creator.py`.
+ */
+declare function buildFileV2Merkle(fileData: Uint8Array, pieceLength: number): FileV2MerkleResult;
+/**
+ * Build all layers from leaf hashes (padded to power of two with zero leaves).
+ */
+declare function buildMerkleLayers(leaves: Uint8Array[]): Uint8Array[][];
+/**
+ * Uncle hashes for one leaf index, from leaf layer up `proofLayers` steps.
+ * Returns uncles from bottom to top (closest to root last).
+ */
+declare function unclesForLeafIndex(layers: Uint8Array[][], leafIndex: number, proofLayers: number): Uint8Array[];
+/**
+ * Verify that `leafHash` at `leafIndex` (in padded leaf layer) reaches `expectedRoot`
+ * using `uncles` (sibling hashes bottom-up).
+ */
+/**
+ * Merkle subtree root for one logical piece’s raw bytes (BEP 52).
+ * `isFirstPieceOfFile` matches reference `FileHasher` padding (first piece of each file).
+ */
+declare function pieceSubtreeRootFromBytes(pieceBytes: Uint8Array, pieceLength: number, isFirstPieceOfFile: boolean): Uint8Array;
+declare function verifyLeafToRoot(leafHash: Uint8Array, leafIndex: number, uncles: Uint8Array[], expectedRoot: Uint8Array): boolean;
+//#endregion
+export { BEP52_BLOCK_SIZE, BEP52_ZERO_LEAF, type FileV2MerkleResult, buildFileV2Merkle, buildMerkleLayers, padPieceBlockHashes, padPieceRoot, pieceSubtreeRootFromBytes, rootHashLayer, sha256Concat, sha256Data, unclesForLeafIndex, verifyLeafToRoot };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,176 @@
+import { createHash } from "node:crypto";
+//#region src/bep52.ts
+/*! @z-torrent/merkle-tree. MIT License. */
+/** 16 KiB — BEP 52 leaf block size */
+const BEP52_BLOCK_SIZE = 16384;
+/** 32 zero bytes — padding leaf per BEP 52 */
+const BEP52_ZERO_LEAF = new Uint8Array(32);
+function sha256Concat(left, right) {
+	const buf = new Uint8Array(64);
+	buf.set(left, 0);
+	buf.set(right, 32);
+	return new Uint8Array(createHash("sha256").update(buf).digest());
+}
+function sha256Data(data) {
+	return new Uint8Array(createHash("sha256").update(data).digest());
+}
+/**
+* Merkle root of a complete binary layer (length must be a power of two).
+* Each node is SHA256(left || right).
+*/
+function rootHashLayer(hashes) {
+	if (hashes.length === 0) throw new Error("rootHashLayer: empty layer");
+	if ((hashes.length & hashes.length - 1) !== 0) throw new Error("rootHashLayer: layer length must be a power of two");
+	let layer = hashes;
+	while (layer.length > 1) {
+		const next = [];
+		for (let i = 0; i < layer.length; i += 2) next.push(sha256Concat(layer[i], layer[i + 1]));
+		layer = next;
+	}
+	return layer[0];
+}
+function nextPow2(n) {
+	if (n <= 1) return 1;
+	return 1 << 32 - Math.clz32(n - 1);
+}
+/** Like Python `int.bit_length()` for non-negative integers. */
+function uintBitLength(x) {
+	if (x <= 0) return 0;
+	return 32 - Math.clz32(x);
+}
+/**
+* Pad block hashes for one piece to the leaf count required by BEP 52.
+*/
+function padPieceBlockHashes(blockHashes, blocksPerPiece, isFirstPiece) {
+	const n = blockHashes.length;
+	if (n === 0) return [];
+	const leavesRequired = isFirstPiece ? 1 << uintBitLength(n - 1) : blocksPerPiece;
+	const out = blockHashes.slice();
+	while (out.length < leavesRequired) out.push(BEP52_ZERO_LEAF.slice());
+	return out;
+}
+/** Root of a “virtual” piece made entirely of zero leaves (BEP 52 file-tree balancing). */
+function padPieceRoot(blocksPerPiece) {
+	const zeros = [];
+	for (let i = 0; i < blocksPerPiece; i++) zeros.push(BEP52_ZERO_LEAF.slice());
+	return rootHashLayer(zeros);
+}
+/**
+* Build BEP 52 per-file merkle metadata from raw file bytes.
+* Mirrors `FileHasher` in the reference `bep_0052_torrent_creator.py`.
+*/
+function buildFileV2Merkle(fileData, pieceLength) {
+	if (pieceLength < 16384 || (pieceLength & pieceLength - 1) !== 0) throw new Error("pieceLength must be a power of two and >= 16 KiB");
+	const blocksPerPiece = pieceLength / BEP52_BLOCK_SIZE;
+	const pieceSubtreeRoots = [];
+	let offset = 0;
+	const len = fileData.length;
+	while (offset < len) {
+		const blockHashes = [];
+		for (let i = 0; i < blocksPerPiece && offset < len; i++) {
+			const end = Math.min(offset + BEP52_BLOCK_SIZE, len);
+			const block = fileData.subarray(offset, end);
+			if (block.length === 0) break;
+			offset = end;
+			blockHashes.push(sha256Data(block));
+		}
+		if (blockHashes.length === 0) break;
+		const padded = padPieceBlockHashes(blockHashes, blocksPerPiece, pieceSubtreeRoots.length === 0);
+		pieceSubtreeRoots.push(rootHashLayer(padded));
+	}
+	const length = len;
+	if (length === 0) return {
+		length: 0,
+		pieceSubtreeRoots: []
+	};
+	const layerHashes = pieceSubtreeRoots.slice();
+	let pieceLayerConcat;
+	if (pieceSubtreeRoots.length > 1) {
+		const flat = new Uint8Array(pieceSubtreeRoots.length * 32);
+		let p = 0;
+		for (const h of pieceSubtreeRoots) {
+			flat.set(h, p);
+			p += 32;
+		}
+		pieceLayerConcat = flat;
+	}
+	const padPiece = padPieceRoot(blocksPerPiece);
+	const targetPieces = nextPow2(layerHashes.length);
+	while (layerHashes.length < targetPieces) layerHashes.push(padPiece.slice());
+	const out = {
+		length,
+		piecesRoot: rootHashLayer(layerHashes),
+		pieceSubtreeRoots
+	};
+	if (length > pieceLength && pieceLayerConcat) out.pieceLayerConcat = pieceLayerConcat;
+	return out;
+}
+/**
+* Build all layers from leaf hashes (padded to power of two with zero leaves).
+*/
+function buildMerkleLayers(leaves) {
+	if (leaves.length === 0) throw new Error("buildMerkleLayers: no leaves");
+	const n = nextPow2(leaves.length);
+	const padded = leaves.slice();
+	while (padded.length < n) padded.push(BEP52_ZERO_LEAF.slice());
+	const layers = [padded];
+	let layer = padded;
+	while (layer.length > 1) {
+		const next = [];
+		for (let i = 0; i < layer.length; i += 2) next.push(sha256Concat(layer[i], layer[i + 1]));
+		layers.push(next);
+		layer = next;
+	}
+	return layers;
+}
+/**
+* Uncle hashes for one leaf index, from leaf layer up `proofLayers` steps.
+* Returns uncles from bottom to top (closest to root last).
+*/
+function unclesForLeafIndex(layers, leafIndex, proofLayers) {
+	const uncles = [];
+	let idx = leafIndex;
+	for (let depth = 0; depth < proofLayers && depth < layers.length - 1; depth++) {
+		const row = layers[depth];
+		const sibling = idx ^ 1;
+		if (sibling >= row.length) break;
+		uncles.push(row[sibling].slice());
+		idx >>= 1;
+	}
+	return uncles;
+}
+/**
+* Verify that `leafHash` at `leafIndex` (in padded leaf layer) reaches `expectedRoot`
+* using `uncles` (sibling hashes bottom-up).
+*/
+/**
+* Merkle subtree root for one logical piece’s raw bytes (BEP 52).
+* `isFirstPieceOfFile` matches reference `FileHasher` padding (first piece of each file).
+*/
+function pieceSubtreeRootFromBytes(pieceBytes, pieceLength, isFirstPieceOfFile) {
+	const blocksPerPiece = pieceLength / BEP52_BLOCK_SIZE;
+	const blockHashes = [];
+	let offset = 0;
+	while (offset < pieceBytes.length) {
+		const end = Math.min(offset + BEP52_BLOCK_SIZE, pieceBytes.length);
+		blockHashes.push(sha256Data(pieceBytes.subarray(offset, end)));
+		offset = end;
+	}
+	if (blockHashes.length === 0) return rootHashLayer([BEP52_ZERO_LEAF.slice()]);
+	return rootHashLayer(padPieceBlockHashes(blockHashes, blocksPerPiece, isFirstPieceOfFile));
+}
+function verifyLeafToRoot(leafHash, leafIndex, uncles, expectedRoot) {
+	let idx = leafIndex;
+	let acc = leafHash.slice();
+	for (const uncle of uncles) {
+		acc = sha256Concat((idx & 1) === 0 ? acc : uncle, (idx & 1) === 0 ? uncle : acc);
+		idx >>= 1;
+	}
+	if (acc.length !== expectedRoot.length) return false;
+	for (let i = 0; i < acc.length; i++) if (acc[i] !== expectedRoot[i]) return false;
+	return true;
+}
+//#endregion
+export { BEP52_BLOCK_SIZE, BEP52_ZERO_LEAF, buildFileV2Merkle, buildMerkleLayers, padPieceBlockHashes, padPieceRoot, pieceSubtreeRootFromBytes, rootHashLayer, sha256Concat, sha256Data, unclesForLeafIndex, verifyLeafToRoot };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/bep52.ts"],"sourcesContent":["/*! @z-torrent/merkle-tree. MIT License. */\nimport { createHash } from 'node:crypto'\n\n/** 16 KiB — BEP 52 leaf block size */\nexport const BEP52_BLOCK_SIZE = 1 << 14\n\n/** 32 zero bytes — padding leaf per BEP 52 */\nexport const BEP52_ZERO_LEAF = new Uint8Array(32)\n\nexport function sha256Concat(left: Uint8Array, right: Uint8Array): Uint8Array {\n  const buf = new Uint8Array(64)\n  buf.set(left, 0)\n  buf.set(right, 32)\n  return new Uint8Array(createHash('sha256').update(buf).digest())\n}\n\nexport function sha256Data(data: Uint8Array): Uint8Array {\n  return new Uint8Array(createHash('sha256').update(data).digest())\n}\n\n/**\n * Merkle root of a complete binary layer (length must be a power of two).\n * Each node is SHA256(left || right).\n */\nexport function rootHashLayer(hashes: Uint8Array[]): Uint8Array {\n  if (hashes.length === 0) {\n    throw new Error('rootHashLayer: empty layer')\n  }\n  if ((hashes.length & (hashes.length - 1)) !== 0) {\n    throw new Error('rootHashLayer: layer length must be a power of two')\n  }\n  let layer = hashes\n  while (layer.length > 1) {\n    const next: Uint8Array[] = []\n    for (let i = 0; i < layer.length; i += 2) {\n      next.push(sha256Concat(layer[i]!, layer[i + 1]!))\n    }\n    layer = next\n  }\n  return layer[0]!\n}\n\nfunction nextPow2(n: number): number {\n  if (n <= 1) return 1\n  return 1 << (32 - Math.clz32(n - 1))\n}\n\n/** Like Python `int.bit_length()` for non-negative integers. */\nfunction uintBitLength(x: number): number {\n  if (x <= 0) return 0\n  return 32 - Math.clz32(x)\n}\n\n/**\n * Pad block hashes for one piece to the leaf count required by BEP 52.\n */\nexport function padPieceBlockHashes(\n  blockHashes: Uint8Array[],\n  blocksPerPiece: number,\n  isFirstPiece: boolean\n): Uint8Array[] {\n  const n = blockHashes.length\n  if (n === 0) return []\n  const leavesRequired = isFirstPiece ? 1 << uintBitLength(n - 1) : blocksPerPiece\n  const out = blockHashes.slice()\n  while (out.length < leavesRequired) {\n    out.push(BEP52_ZERO_LEAF.slice())\n  }\n  return out\n}\n\n/** Root of a “virtual” piece made entirely of zero leaves (BEP 52 file-tree balancing). */\nexport function padPieceRoot(blocksPerPiece: number): Uint8Array {\n  const zeros: Uint8Array[] = []\n  for (let i = 0; i < blocksPerPiece; i++) {\n    zeros.push(BEP52_ZERO_LEAF.slice())\n  }\n  return rootHashLayer(zeros)\n}\n\nexport interface FileV2MerkleResult {\n  /** Total file length in bytes */\n  length: number\n  /** Merkle root over piece-level hashes (`pieces root` in file tree) */\n  piecesRoot?: Uint8Array\n  /**\n   * Concatenated 32-byte piece subtree roots for `piece layers` dict value.\n   * Omitted when file fits in one piece (no `piece layers` entry per BEP 52).\n   */\n  pieceLayerConcat?: Uint8Array\n  /** Per-piece subtree roots (each is root of that piece’s block merkle tree) */\n  pieceSubtreeRoots: Uint8Array[]\n}\n\n/**\n * Build BEP 52 per-file merkle metadata from raw file bytes.\n * Mirrors `FileHasher` in the reference `bep_0052_torrent_creator.py`.\n */\nexport function buildFileV2Merkle(fileData: Uint8Array, pieceLength: number): FileV2MerkleResult {\n  if (pieceLength < BEP52_BLOCK_SIZE || (pieceLength & (pieceLength - 1)) !== 0) {\n    throw new Error('pieceLength must be a power of two and >= 16 KiB')\n  }\n\n  const blocksPerPiece = pieceLength / BEP52_BLOCK_SIZE\n  const pieceSubtreeRoots: Uint8Array[] = []\n  let offset = 0\n  const len = fileData.length\n\n  while (offset < len) {\n    const blockHashes: Uint8Array[] = []\n    for (let i = 0; i < blocksPerPiece && offset < len; i++) {\n      const end = Math.min(offset + BEP52_BLOCK_SIZE, len)\n      const block = fileData.subarray(offset, end)\n      if (block.length === 0) break\n      offset = end\n      blockHashes.push(sha256Data(block))\n    }\n\n    if (blockHashes.length === 0) break\n\n    const padded = padPieceBlockHashes(blockHashes, blocksPerPiece, pieceSubtreeRoots.length === 0)\n    pieceSubtreeRoots.push(rootHashLayer(padded))\n  }\n\n  const length = len\n  if (length === 0) {\n    return { length: 0, pieceSubtreeRoots: [] }\n  }\n\n  const layerHashes = pieceSubtreeRoots.slice()\n  let pieceLayerConcat: Uint8Array | undefined\n  if (pieceSubtreeRoots.length > 1) {\n    const flat = new Uint8Array(pieceSubtreeRoots.length * 32)\n    let p = 0\n    for (const h of pieceSubtreeRoots) {\n      flat.set(h, p)\n      p += 32\n    }\n    pieceLayerConcat = flat\n  }\n\n  const padPiece = padPieceRoot(blocksPerPiece)\n  const targetPieces = nextPow2(layerHashes.length)\n  while (layerHashes.length < targetPieces) {\n    layerHashes.push(padPiece.slice())\n  }\n\n  const piecesRoot = rootHashLayer(layerHashes)\n\n  const out: FileV2MerkleResult = {\n    length,\n    piecesRoot,\n    pieceSubtreeRoots,\n  }\n  if (length > pieceLength && pieceLayerConcat) {\n    out.pieceLayerConcat = pieceLayerConcat\n  }\n  return out\n}\n\n/**\n * Build all layers from leaf hashes (padded to power of two with zero leaves).\n */\nexport function buildMerkleLayers(leaves: Uint8Array[]): Uint8Array[][] {\n  if (leaves.length === 0) {\n    throw new Error('buildMerkleLayers: no leaves')\n  }\n  const n = nextPow2(leaves.length)\n  const padded: Uint8Array[] = leaves.slice()\n  while (padded.length < n) {\n    padded.push(BEP52_ZERO_LEAF.slice())\n  }\n  const layers: Uint8Array[][] = [padded]\n  let layer = padded\n  while (layer.length > 1) {\n    const next: Uint8Array[] = []\n    for (let i = 0; i < layer.length; i += 2) {\n      next.push(sha256Concat(layer[i]!, layer[i + 1]!))\n    }\n    layers.push(next)\n    layer = next\n  }\n  return layers\n}\n\n/**\n * Uncle hashes for one leaf index, from leaf layer up `proofLayers` steps.\n * Returns uncles from bottom to top (closest to root last).\n */\nexport function unclesForLeafIndex(layers: Uint8Array[][], leafIndex: number, proofLayers: number): Uint8Array[] {\n  const uncles: Uint8Array[] = []\n  let idx = leafIndex\n  for (let depth = 0; depth < proofLayers && depth < layers.length - 1; depth++) {\n    const row = layers[depth]!\n    const sibling = idx ^ 1\n    if (sibling >= row.length) break\n    uncles.push(row[sibling]!.slice())\n    idx >>= 1\n  }\n  return uncles\n}\n\n/**\n * Verify that `leafHash` at `leafIndex` (in padded leaf layer) reaches `expectedRoot`\n * using `uncles` (sibling hashes bottom-up).\n */\n/**\n * Merkle subtree root for one logical piece’s raw bytes (BEP 52).\n * `isFirstPieceOfFile` matches reference `FileHasher` padding (first piece of each file).\n */\nexport function pieceSubtreeRootFromBytes(\n  pieceBytes: Uint8Array,\n  pieceLength: number,\n  isFirstPieceOfFile: boolean\n): Uint8Array {\n  const blocksPerPiece = pieceLength / BEP52_BLOCK_SIZE\n  const blockHashes: Uint8Array[] = []\n  let offset = 0\n  while (offset < pieceBytes.length) {\n    const end = Math.min(offset + BEP52_BLOCK_SIZE, pieceBytes.length)\n    blockHashes.push(sha256Data(pieceBytes.subarray(offset, end)))\n    offset = end\n  }\n  if (blockHashes.length === 0) {\n    return rootHashLayer([BEP52_ZERO_LEAF.slice()])\n  }\n  const padded = padPieceBlockHashes(blockHashes, blocksPerPiece, isFirstPieceOfFile)\n  return rootHashLayer(padded)\n}\n\nexport function verifyLeafToRoot(\n  leafHash: Uint8Array,\n  leafIndex: number,\n  uncles: Uint8Array[],\n  expectedRoot: Uint8Array\n): boolean {\n  let idx = leafIndex\n  let acc = leafHash.slice()\n  for (const uncle of uncles) {\n    const left = (idx & 1) === 0 ? acc : uncle\n    const right = (idx & 1) === 0 ? uncle : acc\n    acc = sha256Concat(left, right)\n    idx >>= 1\n  }\n  if (acc.length !== expectedRoot.length) return false\n  for (let i = 0; i < acc.length; i++) {\n    if (acc[i] !== expectedRoot[i]) return false\n  }\n  return true\n}\n"],"mappings":";;;;AAIA,MAAa,mBAAmB;;AAGhC,MAAa,kBAAkB,IAAI,WAAW,GAAG;AAEjD,SAAgB,aAAa,MAAkB,OAA+B;CAC5E,MAAM,MAAM,IAAI,WAAW,GAAG;AAC9B,KAAI,IAAI,MAAM,EAAE;AAChB,KAAI,IAAI,OAAO,GAAG;AAClB,QAAO,IAAI,WAAW,WAAW,SAAS,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC;;AAGlE,SAAgB,WAAW,MAA8B;AACvD,QAAO,IAAI,WAAW,WAAW,SAAS,CAAC,OAAO,KAAK,CAAC,QAAQ,CAAC;;;;;;AAOnE,SAAgB,cAAc,QAAkC;AAC9D,KAAI,OAAO,WAAW,EACpB,OAAM,IAAI,MAAM,6BAA6B;AAE/C,MAAK,OAAO,SAAU,OAAO,SAAS,OAAQ,EAC5C,OAAM,IAAI,MAAM,qDAAqD;CAEvE,IAAI,QAAQ;AACZ,QAAO,MAAM,SAAS,GAAG;EACvB,MAAM,OAAqB,EAAE;AAC7B,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,MAAK,KAAK,aAAa,MAAM,IAAK,MAAM,IAAI,GAAI,CAAC;AAEnD,UAAQ;;AAEV,QAAO,MAAM;;AAGf,SAAS,SAAS,GAAmB;AACnC,KAAI,KAAK,EAAG,QAAO;AACnB,QAAO,KAAM,KAAK,KAAK,MAAM,IAAI,EAAE;;;AAIrC,SAAS,cAAc,GAAmB;AACxC,KAAI,KAAK,EAAG,QAAO;AACnB,QAAO,KAAK,KAAK,MAAM,EAAE;;;;;AAM3B,SAAgB,oBACd,aACA,gBACA,cACc;CACd,MAAM,IAAI,YAAY;AACtB,KAAI,MAAM,EAAG,QAAO,EAAE;CACtB,MAAM,iBAAiB,eAAe,KAAK,cAAc,IAAI,EAAE,GAAG;CAClE,MAAM,MAAM,YAAY,OAAO;AAC/B,QAAO,IAAI,SAAS,eAClB,KAAI,KAAK,gBAAgB,OAAO,CAAC;AAEnC,QAAO;;;AAIT,SAAgB,aAAa,gBAAoC;CAC/D,MAAM,QAAsB,EAAE;AAC9B,MAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,IAClC,OAAM,KAAK,gBAAgB,OAAO,CAAC;AAErC,QAAO,cAAc,MAAM;;;;;;AAqB7B,SAAgB,kBAAkB,UAAsB,aAAyC;AAC/F,KAAI,cAAA,UAAmC,cAAe,cAAc,OAAQ,EAC1E,OAAM,IAAI,MAAM,mDAAmD;CAGrE,MAAM,iBAAiB,cAAc;CACrC,MAAM,oBAAkC,EAAE;CAC1C,IAAI,SAAS;CACb,MAAM,MAAM,SAAS;AAErB,QAAO,SAAS,KAAK;EACnB,MAAM,cAA4B,EAAE;AACpC,OAAK,IAAI,IAAI,GAAG,IAAI,kBAAkB,SAAS,KAAK,KAAK;GACvD,MAAM,MAAM,KAAK,IAAI,SAAS,kBAAkB,IAAI;GACpD,MAAM,QAAQ,SAAS,SAAS,QAAQ,IAAI;AAC5C,OAAI,MAAM,WAAW,EAAG;AACxB,YAAS;AACT,eAAY,KAAK,WAAW,MAAM,CAAC;;AAGrC,MAAI,YAAY,WAAW,EAAG;EAE9B,MAAM,SAAS,oBAAoB,aAAa,gBAAgB,kBAAkB,WAAW,EAAE;AAC/F,oBAAkB,KAAK,cAAc,OAAO,CAAC;;CAG/C,MAAM,SAAS;AACf,KAAI,WAAW,EACb,QAAO;EAAE,QAAQ;EAAG,mBAAmB,EAAE;EAAE;CAG7C,MAAM,cAAc,kBAAkB,OAAO;CAC7C,IAAI;AACJ,KAAI,kBAAkB,SAAS,GAAG;EAChC,MAAM,OAAO,IAAI,WAAW,kBAAkB,SAAS,GAAG;EAC1D,IAAI,IAAI;AACR,OAAK,MAAM,KAAK,mBAAmB;AACjC,QAAK,IAAI,GAAG,EAAE;AACd,QAAK;;AAEP,qBAAmB;;CAGrB,MAAM,WAAW,aAAa,eAAe;CAC7C,MAAM,eAAe,SAAS,YAAY,OAAO;AACjD,QAAO,YAAY,SAAS,aAC1B,aAAY,KAAK,SAAS,OAAO,CAAC;CAKpC,MAAM,MAA0B;EAC9B;EACA,YAJiB,cAAc,YAAY;EAK3C;EACD;AACD,KAAI,SAAS,eAAe,iBAC1B,KAAI,mBAAmB;AAEzB,QAAO;;;;;AAMT,SAAgB,kBAAkB,QAAsC;AACtE,KAAI,OAAO,WAAW,EACpB,OAAM,IAAI,MAAM,+BAA+B;CAEjD,MAAM,IAAI,SAAS,OAAO,OAAO;CACjC,MAAM,SAAuB,OAAO,OAAO;AAC3C,QAAO,OAAO,SAAS,EACrB,QAAO,KAAK,gBAAgB,OAAO,CAAC;CAEtC,MAAM,SAAyB,CAAC,OAAO;CACvC,IAAI,QAAQ;AACZ,QAAO,MAAM,SAAS,GAAG;EACvB,MAAM,OAAqB,EAAE;AAC7B,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,MAAK,KAAK,aAAa,MAAM,IAAK,MAAM,IAAI,GAAI,CAAC;AAEnD,SAAO,KAAK,KAAK;AACjB,UAAQ;;AAEV,QAAO;;;;;;AAOT,SAAgB,mBAAmB,QAAwB,WAAmB,aAAmC;CAC/G,MAAM,SAAuB,EAAE;CAC/B,IAAI,MAAM;AACV,MAAK,IAAI,QAAQ,GAAG,QAAQ,eAAe,QAAQ,OAAO,SAAS,GAAG,SAAS;EAC7E,MAAM,MAAM,OAAO;EACnB,MAAM,UAAU,MAAM;AACtB,MAAI,WAAW,IAAI,OAAQ;AAC3B,SAAO,KAAK,IAAI,SAAU,OAAO,CAAC;AAClC,UAAQ;;AAEV,QAAO;;;;;;;;;;AAWT,SAAgB,0BACd,YACA,aACA,oBACY;CACZ,MAAM,iBAAiB,cAAc;CACrC,MAAM,cAA4B,EAAE;CACpC,IAAI,SAAS;AACb,QAAO,SAAS,WAAW,QAAQ;EACjC,MAAM,MAAM,KAAK,IAAI,SAAS,kBAAkB,WAAW,OAAO;AAClE,cAAY,KAAK,WAAW,WAAW,SAAS,QAAQ,IAAI,CAAC,CAAC;AAC9D,WAAS;;AAEX,KAAI,YAAY,WAAW,EACzB,QAAO,cAAc,CAAC,gBAAgB,OAAO,CAAC,CAAC;AAGjD,QAAO,cADQ,oBAAoB,aAAa,gBAAgB,mBAAmB,CACvD;;AAG9B,SAAgB,iBACd,UACA,WACA,QACA,cACS;CACT,IAAI,MAAM;CACV,IAAI,MAAM,SAAS,OAAO;AAC1B,MAAK,MAAM,SAAS,QAAQ;AAG1B,QAAM,cAFQ,MAAM,OAAO,IAAI,MAAM,QACtB,MAAM,OAAO,IAAI,QAAQ,IACT;AAC/B,UAAQ;;AAEV,KAAI,IAAI,WAAW,aAAa,OAAQ,QAAO;AAC/C,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,IAC9B,KAAI,IAAI,OAAO,aAAa,GAAI,QAAO;AAEzC,QAAO"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@z-torrent/merkle-tree",
+  "description": "BEP 52 BitTorrent v2 merkle hash trees (SHA-256)",
+  "version": "0.0.7",
+  "type": "module",
+  "author": "Dmitriy Skrylnikov <skrylnikovd@ya.ru>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/skrylnikov/z-torrent.git",
+    "directory": "packages/merkle-tree"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "bittorrent",
+    "bep52",
+    "merkle",
+    "v2",
+    "z-torrent"
+  ]
+}