feat: implement ViewDU.batchHashTreeRoot()

packages/persistent-merkle-tree/test/perf/hasher.test.ts

@@ -1,10 +1,10 @@
 import {itBench} from "@dapplion/benchmark";
-import {HashObject, uint8ArrayToHashObject} from "../../src/hasher";
+import {HashObject, setHasher, uint8ArrayToHashObject} from "../../src/hasher";
 import {hasher as asShaHasher} from "../../src/hasher/as-sha256";
 import {hasher as nobleHasher} from "../../src/hasher/noble";
 import {hasher as hashtreeHasher} from "../../src/hasher/hashtree";
 import {buildComparisonTrees} from "../utils/tree";
-import { HashComputationLevel, getHashComputations } from "../../src";
+import {HashComputationLevel, getHashComputations} from "../../src";
 
 describe("hasher", function () {
  this.timeout(0);
@@ -65,4 +65,41 @@ describe("hasher", function () {
  }
 });
 
-// TODO - batch: test more methods
+describe("hashtree", function () {
+ itBench({
+ id: `getHashComputations`,
+ beforeEach: () => {
+ const [tree] = buildComparisonTrees(16);
+ return tree;
+ },
+ fn: (tree) => {
+ const hcByLevel: HashComputationLevel[] = [];
+ getHashComputations(tree, 0, hcByLevel);
+ },
+ });
+
+ itBench({
+ id: `executeHashComputations`,
+ beforeEach: () => {
+ const [tree] = buildComparisonTrees(16);
+ return tree;
+ },
+ fn: (tree) => {
+ const hcByLevel: HashComputationLevel[] = [];
+ getHashComputations(tree, 0, hcByLevel);
+ hashtreeHasher.executeHashComputations(hcByLevel);
+ },
+ });
+
+ itBench({
+ id: `get root`,
+ beforeEach: () => {
+ const [tree] = buildComparisonTrees(16);
+ setHasher(hashtreeHasher);
+ return tree;
+ },
+ fn: (tree) => {
+ tree.root;
+ },
+ });
+});

packages/ssz/src/type/arrayBasic.ts

@@ -5,6 +5,8 @@ import {
  getNodesAtDepth,
  packedNodeRootsToBytes,
  packedRootsBytesToNode,
+ HashComputationLevel,
+ levelAtIndex,
 } from "@chainsafe/persistent-merkle-tree";
 import {Type, ValueOf, ByteViews} from "./abstract";
 import {BasicType} from "./basic";
@@ -39,14 +41,24 @@ export function addLengthNode(chunksNode: Node, length: number): Node {
  return new BranchNode(chunksNode, LeafNode.fromUint32(length));
 }
 
-export function setChunksNode(rootNode: Node, chunksNode: Node, newLength?: number): Node {
+export function setChunksNode(
+ rootNode: Node,
+ chunksNode: Node,
+ newLength: number | null,
+ hcOffset = 0,
+ hcByLevel: HashComputationLevel[] | null = null
+): Node {
  const lengthNode =
- newLength !== undefined
+ newLength !== null
  ? // If newLength is set, create a new node for length
  LeafNode.fromUint32(newLength)
  : // else re-use existing node
  (rootNode.right as LeafNode);
- return new BranchNode(chunksNode, lengthNode);
+ const branchNode = new BranchNode(chunksNode, lengthNode);
+ if (hcByLevel !== null) {
+ levelAtIndex(hcByLevel, hcOffset).push(chunksNode, lengthNode, branchNode);
+ }
+ return branchNode;
 }
 
 export type ArrayProps = {isList: true; limit: number} | {isList: false; length: number};

packages/ssz/src/type/bitArray.ts

@@ -1,4 +1,4 @@
-import {concatGindices, Gindex, Node, toGindex, Tree} from "@chainsafe/persistent-merkle-tree";
+import {concatGindices, Gindex, Node, toGindex, Tree, HashComputationLevel} from "@chainsafe/persistent-merkle-tree";
 import {fromHexString, toHexString, byteArrayEquals} from "../util/byteArray";
 import {splitIntoRootChunks} from "../util/merkleize";
 import {CompositeType, LENGTH_GINDEX} from "./composite";
@@ -29,8 +29,8 @@ export abstract class BitArrayType extends CompositeType<BitArray, BitArrayTreeV
  return view.node;
  }
 
- commitViewDU(view: BitArrayTreeViewDU): Node {
- view.commit();
+ commitViewDU(view: BitArrayTreeViewDU, hcOffset = 0, hcByLevel: HashComputationLevel[] | null = null): Node {
+ view.commit(hcOffset, hcByLevel);
  return view.node;
  }
 

packages/ssz/src/type/byteArray.ts

@@ -1,4 +1,12 @@
-import {concatGindices, Gindex, Node, toGindex, Tree} from "@chainsafe/persistent-merkle-tree";
+import {
+ concatGindices,
+ Gindex,
+ Node,
+ toGindex,
+ Tree,
+ HashComputationLevel,
+ getHashComputations,
+} from "@chainsafe/persistent-merkle-tree";
 import {fromHexString, toHexString, byteArrayEquals} from "../util/byteArray";
 import {splitIntoRootChunks} from "../util/merkleize";
 import {ByteViews} from "./abstract";
@@ -37,11 +45,16 @@ export abstract class ByteArrayType extends CompositeType<ByteArray, ByteArray,
  return this.commitViewDU(view);
  }
 
- commitViewDU(view: ByteArray): Node {
+ // there is no respective ViewDU for this type
+ commitViewDU(view: ByteArray, hcOffset = 0, hcByLevel: HashComputationLevel[] | null = null): Node {
  const uint8Array = new Uint8Array(this.value_serializedSize(view));
  const dataView = new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength);
  this.value_serializeToBytes({uint8Array, dataView}, 0, view);
- return this.tree_deserializeFromBytes({uint8Array, dataView}, 0, uint8Array.length);
+ const node = this.tree_deserializeFromBytes({uint8Array, dataView}, 0, uint8Array.length);
+ if (hcByLevel !== null && node.h0 === null) {
+ getHashComputations(node, hcOffset, hcByLevel);
+ }
+ return node;
  }
 
  cacheOfViewDU(): unknown {

packages/ssz/src/type/composite.ts

@@ -7,6 +7,7 @@ import {
  Proof,
  ProofType,
  Tree,
+ HashComputationLevel,
 } from "@chainsafe/persistent-merkle-tree";
 import {byteArrayEquals} from "../util/byteArray";
 import {merkleize, symbolCachedPermanentRoot, ValueWithCachedPermanentRoot} from "../util/merkleize";
@@ -126,7 +127,7 @@ export abstract class CompositeType<V, TV, TVDU> extends Type<V> {
  /** INTERNAL METHOD: Given a Tree View, returns a `Node` with all its updated data */
  abstract commitView(view: TV): Node;
  /** INTERNAL METHOD: Given a Deferred Update Tree View returns a `Node` with all its updated data */
- abstract commitViewDU(view: TVDU): Node;
+ abstract commitViewDU(view: TVDU, hcOffset?: number, hcByLevel?: HashComputationLevel[] | null): Node;
  /** INTERNAL METHOD: Return the cache of a Deferred Update Tree View. May return `undefined` if this ViewDU has no cache */
  abstract cacheOfViewDU(view: TVDU): unknown;
 

packages/ssz/src/type/container.ts

@@ -7,6 +7,7 @@ import {
  toGindex,
  concatGindices,
  getNode,
+ HashComputationLevel,
 } from "@chainsafe/persistent-merkle-tree";
 import {maxChunksToDepth} from "../util/merkleize";
 import {Require} from "../util/types";
@@ -162,8 +163,12 @@ export class ContainerType<Fields extends Record<string, Type<unknown>>> extends
  return view.node;
  }
 
- commitViewDU(view: ContainerTreeViewDUType<Fields>): Node {
- view.commit();
+ commitViewDU(
+ view: ContainerTreeViewDUType<Fields>,
+ hcOffset = 0,
+ hcByLevel: HashComputationLevel[] | null = null
+ ): Node {
+ view.commit(hcOffset, hcByLevel);
  return view.node;
  }
 

packages/ssz/src/type/listBasic.ts

@@ -1,4 +1,4 @@
-import {LeafNode, Node, Tree} from "@chainsafe/persistent-merkle-tree";
+import {LeafNode, Node, Tree, HashComputationLevel} from "@chainsafe/persistent-merkle-tree";
 import {ValueOf} from "./abstract";
 import {BasicType} from "./basic";
 import {ByteViews} from "./composite";
@@ -93,8 +93,12 @@ export class ListBasicType<ElementType extends BasicType<unknown>>
  return view.node;
  }
 
- commitViewDU(view: ListBasicTreeViewDU<ElementType>): Node {
- view.commit();
+ commitViewDU(
+ view: ListBasicTreeViewDU<ElementType>,
+ hcOffset = 0,
+ hcByLevel: HashComputationLevel[] | null = null
+ ): Node {
+ view.commit(hcOffset, hcByLevel);
  return view.node;
  }
 
@@ -144,8 +148,19 @@ export class ListBasicType<ElementType extends BasicType<unknown>>
  return node.left;
  }
 
- tree_setChunksNode(rootNode: Node, chunksNode: Node, newLength?: number): Node {
- return setChunksNode(rootNode, chunksNode, newLength);
+ tree_chunksNodeOffset(): number {
+ // one more level for length, see setChunksNode below
+ return 1;
+ }
+
+ tree_setChunksNode(
+ rootNode: Node,
+ chunksNode: Node,
+ newLength: number | null,
+ hcOffset = 0,
+ hcByLevel: HashComputationLevel[] | null = null
+ ): Node {
+ return setChunksNode(rootNode, chunksNode, newLength, hcOffset, hcByLevel);
  }
 
  // Merkleization

packages/ssz/src/type/listComposite.ts

@@ -1,4 +1,4 @@
-import {Node, Tree} from "@chainsafe/persistent-merkle-tree";
+import {Node, Tree, HashComputationLevel} from "@chainsafe/persistent-merkle-tree";
 import {
  mixInLength,
  maxChunksToDepth,
@@ -97,8 +97,12 @@ export class ListCompositeType<
  return view.node;
  }
 
- commitViewDU(view: ListCompositeTreeViewDU<ElementType>): Node {
- view.commit();
+ commitViewDU(
+ view: ListCompositeTreeViewDU<ElementType>,
+ hcOffset = 0,
+ hcByLevel: HashComputationLevel[] | null = null
+ ): Node {
+ view.commit(hcOffset, hcByLevel);
  return view.node;
  }
 
@@ -150,8 +154,19 @@ export class ListCompositeType<
  return node.left;
  }
 
- tree_setChunksNode(rootNode: Node, chunksNode: Node, newLength?: number): Node {
- return setChunksNode(rootNode, chunksNode, newLength);
+ tree_chunksNodeOffset(): number {
+ // one more level for length, see setChunksNode below
+ return 1;
+ }
+
+ tree_setChunksNode(
+ rootNode: Node,
+ chunksNode: Node,
+ newLength: number | null,
+ hcOffset = 0,
+ hcByLevel: HashComputationLevel[] | null = null
+ ): Node {
+ return setChunksNode(rootNode, chunksNode, newLength, hcOffset, hcByLevel);
  }
 
  // Merkleization

packages/ssz/src/type/optional.ts

@@ -1,4 +1,12 @@
-import {concatGindices, Gindex, Node, Tree, zeroNode} from "@chainsafe/persistent-merkle-tree";
+import {
+ concatGindices,
+ Gindex,
+ Node,
+ Tree,
+ zeroNode,
+ HashComputationLevel,
+ getHashComputations,
+} from "@chainsafe/persistent-merkle-tree";
 import {mixInLength} from "../util/merkleize";
 import {Require} from "../util/types";
 import {namedClass} from "../util/named";
@@ -75,8 +83,12 @@ export class OptionalType<ElementType extends Type<unknown>> extends CompositeTy
  }
 
  // TODO add an OptionalViewDU
- commitViewDU(view: ValueOfType<ElementType>): Node {
- return this.value_toTree(view);
+ commitViewDU(view: ValueOfType<ElementType>, hcOffset = 0, hcByLevel: HashComputationLevel[] | null = null): Node {
+ const node = this.value_toTree(view);
+ if (hcByLevel !== null && node.h0 === null) {
+ getHashComputations(node, hcOffset, hcByLevel);
+ }
+ return node;
  }
 
  // TODO add an OptionalViewDU

packages/ssz/src/type/union.ts

@@ -1,4 +1,12 @@
-import {concatGindices, getNode, Gindex, Node, Tree} from "@chainsafe/persistent-merkle-tree";
+import {
+ concatGindices,
+ getNode,
+ Gindex,
+ Node,
+ Tree,
+ HashComputationLevel,
+ getHashComputations,
+} from "@chainsafe/persistent-merkle-tree";
 import {mixInLength} from "../util/merkleize";
 import {Require} from "../util/types";
 import {namedClass} from "../util/named";
@@ -106,8 +114,12 @@ export class UnionType<Types extends Type<unknown>[]> extends CompositeType<
  return this.value_toTree(view);
  }
 
- commitViewDU(view: ValueOfTypes<Types>): Node {
- return this.value_toTree(view);
+ commitViewDU(view: ValueOfTypes<Types>, hcOffset = 0, hcByLevel: HashComputationLevel[] | null = null): Node {
+ const node = this.value_toTree(view);
+ if (hcByLevel !== null && node.h0 === null) {
+ getHashComputations(node, hcOffset, hcByLevel);
+ }
+ return node;
  }
 
  value_serializedSize(value: ValueOfTypes<Types>): number {

packages/ssz/src/type/vectorBasic.ts

@@ -1,4 +1,4 @@
-import {Node, Tree} from "@chainsafe/persistent-merkle-tree";
+import {Node, Tree, HashComputationLevel} from "@chainsafe/persistent-merkle-tree";
 import {maxChunksToDepth, splitIntoRootChunks} from "../util/merkleize";
 import {Require} from "../util/types";
 import {namedClass} from "../util/named";
@@ -83,8 +83,12 @@ export class VectorBasicType<ElementType extends BasicType<unknown>>
  return view.node;
  }
 
- commitViewDU(view: ArrayBasicTreeViewDU<ElementType>): Node {
- view.commit();
+ commitViewDU(
+ view: ArrayBasicTreeViewDU<ElementType>,
+ hcOffset = 0,
+ hcByLevel: HashComputationLevel[] | null = null
+ ): Node {
+ view.commit(hcOffset, hcByLevel);
  return view.node;
  }
 
@@ -132,6 +136,10 @@ export class VectorBasicType<ElementType extends BasicType<unknown>>
  return node;
  }
 
+ tree_chunksNodeOffset(): number {
+ return 0;
+ }
+
  tree_setChunksNode(rootNode: Node, chunksNode: Node): Node {
  return chunksNode;
  }

packages/ssz/src/type/vectorComposite.ts

@@ -1,4 +1,4 @@
-import {Node, Tree} from "@chainsafe/persistent-merkle-tree";
+import {Node, Tree, HashComputationLevel} from "@chainsafe/persistent-merkle-tree";
 import {maxChunksToDepth} from "../util/merkleize";
 import {Require} from "../util/types";
 import {namedClass} from "../util/named";
@@ -90,8 +90,12 @@ export class VectorCompositeType<
  return view.node;
  }
 
- commitViewDU(view: ArrayCompositeTreeViewDU<ElementType>): Node {
- view.commit();
+ commitViewDU(
+ view: ArrayCompositeTreeViewDU<ElementType>,
+ hcOffset = 0,
+ hcByLevel: HashComputationLevel[] | null = null
+ ): Node {
+ view.commit(hcOffset, hcByLevel);
  return view.node;
  }
 
@@ -139,6 +143,10 @@ export class VectorCompositeType<
  return node;
  }
 
+ tree_chunksNodeOffset(): number {
+ return 0;
+ }
+
  tree_setChunksNode(rootNode: Node, chunksNode: Node): Node {
  return chunksNode;
  }