Verkle Implementation: Build out Trie Processing

packages/statemanager/package.json

@@ -58,7 +58,7 @@
     "ethereum-cryptography": "^2.1.3",
     "js-sdsl": "^4.1.4",
     "lru-cache": "10.1.0",
-    "verkle-cryptography-wasm": "^0.4.2"
+    "verkle-cryptography-wasm": "^0.4.3"
   },
   "devDependencies": {
     "@ethereumjs/block": "^5.2.0",

packages/verkle/package.json

@@ -53,7 +53,7 @@
   },
   "dependencies": {
     "lru-cache": "10.1.0",
-    "verkle-cryptography-wasm": "^0.4.2",
+    "verkle-cryptography-wasm": "^0.4.3",
     "@ethereumjs/block": "^5.2.0",
     "@ethereumjs/rlp": "^5.0.2",
     "@ethereumjs/util": "^9.0.3"

packages/verkle/src/node/baseVerkleNode.ts

@@ -2,20 +2,23 @@ import { RLP } from '@ethereumjs/rlp'
 
 import { type VerkleNodeInterface, type VerkleNodeOptions, type VerkleNodeType } from './types.js'
 
+import type { VerkleCrypto } from 'verkle-cryptography-wasm'
+
 export abstract class BaseVerkleNode<T extends VerkleNodeType> implements VerkleNodeInterface {
   public commitment: Uint8Array
   public depth: number
-
+  protected verkleCrypto: VerkleCrypto
   constructor(options: VerkleNodeOptions[T]) {
     this.commitment = options.commitment
     this.depth = options.depth
+    this.verkleCrypto = options.verkleCrypto
   }
 
   abstract commit(): Uint8Array
 
   // Hash returns the field representation of the commitment.
   hash(): Uint8Array {
-    throw new Error('Not implemented')
+    return this.verkleCrypto.hashCommitment(this.commitment)
   }
 
   abstract insert(key: Uint8Array, value: Uint8Array, nodeResolverFn: () => void): void

packages/verkle/src/node/internalNode.ts

@@ -1,23 +1,23 @@
-import { equalsBytes } from '@ethereumjs/util'
+import { BIGINT_0, bytesToBigInt, equalsBytes } from '@ethereumjs/util'
 
 import { POINT_IDENTITY } from '../util/crypto.js'
 
 import { BaseVerkleNode } from './baseVerkleNode.js'
 import { LeafNode } from './leafNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 
-import type { VerkleNode, VerkleNodeOptions } from './types.js'
+import type { VerkleCrypto } from '../types.js'
+import type { VerkleNodeOptions } from './types.js'
 
 export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
-  // Array of references to children nodes
-  public children: Array<VerkleNode | null>
+  // Array of commitments to child nodes
+  public children: Uint8Array[]
   public copyOnWrite: Record<string, Uint8Array>
   public type = VerkleNodeType.Internal
 
-  /* TODO: options.children is not actually used here */
   constructor(options: VerkleNodeOptions[VerkleNodeType.Internal]) {
     super(options)
-    this.children = options.children ?? new Array(NODE_WIDTH).fill(null)
+    this.children = options.children ?? new Array(NODE_WIDTH).fill(new Uint8Array())
     this.copyOnWrite = options.copyOnWrite ?? {}
   }
 
@@ -29,11 +29,17 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     // Not implemented yet
   }
 
-  setChild(index: number, child: VerkleNode) {
+  // Updates the commitment value for a child node at the corresponding index
+  setChild(index: number, child: Uint8Array) {
     this.children[index] = child
+    // TODO: Update commitment as well
   }
 
-  static fromRawNode(rawNode: Uint8Array[], depth: number): InternalNode {
+  static fromRawNode(
+    rawNode: Uint8Array[],
+    depth: number,
+    verkleCrypto: VerkleCrypto
+  ): InternalNode {
     const nodeType = rawNode[0][0]
     if (nodeType !== VerkleNodeType.Internal) {
       throw new Error('Invalid node type')
@@ -47,35 +53,47 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     // TODO: Generate Point from rawNode value
     const commitment = rawNode[rawNode.length - 1]
 
-    return new InternalNode({ commitment, depth })
+    return new InternalNode({ commitment, depth, verkleCrypto })
   }
 
-  static create(depth: number): InternalNode {
+  static create(depth: number, verkleCrypto: VerkleCrypto): InternalNode {
     const node = new InternalNode({
       commitment: POINT_IDENTITY,
       depth,
+      verkleCrypto,
     })
 
     return node
   }
 
-  getChildren(index: number): VerkleNode | null {
+  getChildren(index: number): Uint8Array | null {
     return this.children?.[index] ?? null
   }
 
-  insert(key: Uint8Array, value: Uint8Array, resolver: () => void): void {
+  insert(
+    key: Uint8Array,
+    value: Uint8Array,
+    resolver: () => void,
+    verkleCrypto?: VerkleCrypto
+  ): void {
     const values = new Array<Uint8Array>(NODE_WIDTH)
     values[key[31]] = value
-    this.insertStem(key.slice(0, 31), values, resolver)
+    this.insertStem(key.slice(0, 31), values, resolver, verkleCrypto!)
   }
 
-  insertStem(stem: Uint8Array, values: Uint8Array[], resolver: () => void): void {
+  insertStem(
+    stem: Uint8Array,
+    values: Uint8Array[],
+    resolver: () => void,
+    verkleCrypto: VerkleCrypto
+  ): void {
     // Index of the child pointed by the next byte in the key
     const childIndex = stem[this.depth]
 
     const child = this.children[childIndex]
 
     if (child instanceof LeafNode) {
+      // TODO: Understand the intent of what cowChild is suppoded to do
       this.cowChild(childIndex)
       if (equalsBytes(child.stem, stem)) {
         return child.insertMultiple(stem, values)
@@ -85,35 +103,64 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       // on the next byte in both keys, a recursion into
       // the moved leaf node can occur.
       const nextByteInExistingKey = child.stem[this.depth + 1]
-      const newBranch = InternalNode.create(this.depth + 1)
+      const newBranch = InternalNode.create(this.depth + 1, this.verkleCrypto)
       newBranch.cowChild(nextByteInExistingKey)
-      this.children[childIndex] = newBranch
+      this.children[childIndex] = newBranch.commitment
       newBranch.children[nextByteInExistingKey] = child
       child.depth += 1
 
       const nextByteInInsertedKey = stem[this.depth + 1]
       if (nextByteInInsertedKey === nextByteInExistingKey) {
-        return newBranch.insertStem(stem, values, resolver)
+        return newBranch.insertStem(stem, values, resolver, verkleCrypto)
       }
 
       // Next word differs, so this was the last level.
       // Insert it directly into its final slot.
-      const leafNode = LeafNode.create(stem, values)
+      // TODO: Fix this following `trie.put` logic
+      let leafCommitment = verkleCrypto.zeroCommitment
+      let c1 = verkleCrypto.zeroCommitment
+      let c2 = verkleCrypto.zeroCommitment
+      for (const [idx, value] of values.entries()) {
+        if (bytesToBigInt(value) > BIGINT_0) {
+          leafCommitment = verkleCrypto.updateCommitment(
+            leafCommitment,
+            idx,
+            new Uint8Array(32),
+            value
+          )
+          if (idx < 128) {
+            // We multiply the commitment index by 2 here because each 32 byte value in the leaf node is represented as two 16 byte arrays
+            c1 = verkleCrypto.updateCommitment(c1, idx * 2, new Uint8Array(32), value)
+          } else {
+            c2 = verkleCrypto.updateCommitment(c2, (idx - 128) * 2, new Uint8Array(32), value)
+          }
+        }
+      }
 
+      const leafNode = LeafNode.create(
+        stem,
+        values,
+        this.depth + 1,
+        leafCommitment,
+        c1,
+        c2,
+        this.verkleCrypto
+      )
+
+      // TODO - Why is the leaf node set at depth + 2 instead of + 1)?
       leafNode.setDepth(this.depth + 2)
       newBranch.cowChild(nextByteInInsertedKey)
       newBranch.children[nextByteInInsertedKey] = leafNode
     } else if (child instanceof InternalNode) {
       this.cowChild(childIndex)
-      return child.insertStem(stem, values, resolver)
+      return child.insertStem(stem, values, resolver, verkleCrypto)
     } else {
       throw new Error('Invalid node type')
     }
   }
 
   // TODO: go-verkle also adds the bitlist to the raw format.
   raw(): Uint8Array[] {
-    throw new Error('not implemented yet')
-    // return [new Uint8Array([VerkleNodeType.Internal]), ...this.children, this.commitment]
+    return [new Uint8Array([VerkleNodeType.Internal]), ...this.children, this.commitment]
   }
 }

packages/verkle/src/node/leafNode.ts

@@ -1,15 +1,14 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import { BaseVerkleNode } from './baseVerkleNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 
-import type { Point } from '../types.js'
+import type { VerkleCrypto } from '../types.js'
 import type { VerkleNodeOptions } from './types.js'
 
 export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
   public stem: Uint8Array
-  public values: Uint8Array[]
-  public c1: Point
-  public c2: Point
+  public values: Uint8Array[] // Array of 256 possible values represented as 32 byte Uint8Arrays
+  public c1?: Uint8Array
+  public c2?: Uint8Array
   public type = VerkleNodeType.Leaf
 
   constructor(options: VerkleNodeOptions[VerkleNodeType.Leaf]) {
@@ -21,11 +20,27 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     this.c2 = options.c2
   }
 
-  static create(stem: Uint8Array, values: Uint8Array[]): LeafNode {
-    throw new Error('Not implemented')
+  static create(
+    stem: Uint8Array,
+    values: Uint8Array[],
+    depth: number,
+    commitment: Uint8Array,
+    c1: Uint8Array,
+    c2: Uint8Array,
+    verkleCrypto: VerkleCrypto
+  ): LeafNode {
+    return new LeafNode({
+      stem,
+      values,
+      depth,
+      commitment,
+      c1,
+      c2,
+      verkleCrypto,
+    })
   }
 
-  static fromRawNode(rawNode: Uint8Array[], depth: number): LeafNode {
+  static fromRawNode(rawNode: Uint8Array[], depth: number, verkleCrypto: VerkleCrypto): LeafNode {
     const nodeType = rawNode[0][0]
     if (nodeType !== VerkleNodeType.Leaf) {
       throw new Error('Invalid node type')
@@ -39,11 +54,11 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     const stem = rawNode[1]
     // TODO: Convert the rawNode commitments to points
     const commitment = rawNode[2]
-    const c1 = rawNode[3] as unknown as Point
-    const c2 = rawNode[4] as unknown as Point
+    const c1 = rawNode[3]
+    const c2 = rawNode[4]
     const values = rawNode.slice(5, rawNode.length)
 
-    return new LeafNode({ depth, stem, values, c1, c2, commitment })
+    return new LeafNode({ depth, stem, values, c1, c2, commitment, verkleCrypto })
   }
   commit(): Uint8Array {
     throw new Error('Not implemented')
@@ -73,8 +88,8 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
       new Uint8Array([VerkleNodeType.Leaf]),
       this.stem,
       this.commitment,
-      this.c1.bytes(),
-      this.c2.bytes(),
+      this.c1 ?? new Uint8Array(),
+      this.c2 ?? new Uint8Array(),
       ...this.values,
     ]
   }

packages/verkle/src/node/types.ts

@@ -1,6 +1,6 @@
-import type { Point } from '../types.js'
 import type { InternalNode } from './internalNode.js'
 import type { LeafNode } from './leafNode.js'
+import type { VerkleCrypto } from 'verkle-cryptography-wasm'
 
 export enum VerkleNodeType {
   Internal,
@@ -16,14 +16,15 @@ export type VerkleNode = TypedVerkleNode[VerkleNodeType]
 
 export interface VerkleNodeInterface {
   commit(): Uint8Array
-  hash(): any
+  hash(verkleCrypto: VerkleCrypto): any
   serialize(): Uint8Array
 }
 
 interface BaseVerkleNodeOptions {
   // Value of the commitment
   commitment: Uint8Array
   depth: number
+  verkleCrypto: VerkleCrypto
 }
 
 interface VerkleInternalNodeOptions extends BaseVerkleNodeOptions {
@@ -37,8 +38,8 @@ interface VerkleInternalNodeOptions extends BaseVerkleNodeOptions {
 interface VerkleLeafNodeOptions extends BaseVerkleNodeOptions {
   stem: Uint8Array
   values: Uint8Array[]
-  c1: Point
-  c2: Point
+  c1?: Uint8Array
+  c2?: Uint8Array
 }
 
 export interface VerkleNodeOptions {