Verkle Implementation: Build out Trie Processing

packages/verkle/src/node/baseVerkleNode.ts

@@ -6,11 +6,9 @@ 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
   }
 

packages/verkle/src/node/internalNode.ts

@@ -58,13 +58,16 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     const children = childrenCommitments.map((commitment, idx) => {
       return { commitment, path: childrenPaths[idx] }
     })
-    return new InternalNode({ commitment, depth, verkleCrypto, children })
+    return new InternalNode({ commitment, verkleCrypto, children })
   }
 
-  static create(depth: number, verkleCrypto: VerkleCrypto): InternalNode {
+  /**
+   * Generates a new Internal node with default commitment
+   */
+
+  static create(verkleCrypto: VerkleCrypto): InternalNode {
     const node = new InternalNode({
       commitment: verkleCrypto.zeroCommitment,
-      depth,
       verkleCrypto,
     })
 

packages/verkle/src/node/leafNode.ts

@@ -87,7 +87,6 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     return new LeafNode({
       stem,
       values,
-      depth,
       commitment,
       c1,
       c2,
@@ -112,7 +111,7 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     const c2 = rawNode[4]
     const values = rawNode.slice(5, rawNode.length)
 
-    return new LeafNode({ depth, stem, values, c1, c2, commitment, verkleCrypto })
+    return new LeafNode({ stem, values, c1, c2, commitment, verkleCrypto })
   }
 
   // Retrieve the value at the provided index from the values array
@@ -181,8 +180,4 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
       ...this.values,
     ]
   }
-
-  setDepth(depth: number): void {
-    this.depth = depth
-  }
 }

packages/verkle/src/node/types.ts

@@ -19,24 +19,18 @@ export interface TypedVerkleNode {
 export type VerkleNode = TypedVerkleNode[VerkleNodeType]
 
 export interface VerkleNodeInterface {
-  hash(): any
+  hash(): Uint8Array
   serialize(): Uint8Array
 }
 
 interface BaseVerkleNodeOptions {
-  // Value of the commitment
   commitment: Uint8Array
-  depth: number
   verkleCrypto: VerkleCrypto
 }
 
 interface VerkleInternalNodeOptions extends BaseVerkleNodeOptions {
   // Children nodes of this internal node.
   children?: ChildNode[]
-
-  // Values of the child commitments before the tree is modified by inserts.
-  // This is useful because the delta of the child commitments can be used to efficiently update the node's commitment
-  copyOnWrite?: Record<string, Uint8Array>
 }
 interface VerkleLeafNodeOptions extends BaseVerkleNodeOptions {
   stem: Uint8Array

packages/verkle/test/crypto.spec.ts

@@ -1,13 +1,17 @@
-import { Address, bytesToHex, hexToBytes, randomBytes } from '@ethereumjs/util'
+import {
+  Address,
+  type VerkleCrypto,
+  type VerkleExecutionWitness,
+  bytesToHex,
+  hexToBytes,
+  randomBytes,
+} from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, beforeAll, describe, it } from 'vitest'
 
 import * as verkleBlockJSON from '../../statemanager/test/testdata/verkleKaustinen6Block72.json'
 import { getStem, verifyProof } from '../src/index.js'
 
-import type { VerkleCrypto } from '../src/index.js'
-import type { VerkleExecutionWitness } from '@ethereumjs/block'
-
 describe('Verkle cryptographic helpers', () => {
   let verkle: VerkleCrypto
   beforeAll(async () => {

packages/verkle/test/internalNode.spec.ts

@@ -1,28 +1,21 @@
-import { equalsBytes, randomBytes } from '@ethereumjs/util'
+import { type VerkleCrypto, equalsBytes, randomBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, beforeAll, describe, it } from 'vitest'
 
 import { NODE_WIDTH, VerkleNodeType, decodeNode } from '../src/node/index.js'
 import { InternalNode } from '../src/node/internalNode.js'
 
-import type { VerkleCrypto } from '../src/types.js'
-
 describe('verkle node - internal', () => {
   let verkleCrypto: VerkleCrypto
   beforeAll(async () => {
     verkleCrypto = await loadVerkleCrypto()
   })
   it('constructor should create an internal node', async () => {
     const commitment = randomBytes(32)
-    const depth = 2
-    const node = new InternalNode({ commitment, depth, verkleCrypto })
+    const node = new InternalNode({ commitment, verkleCrypto })
 
     assert.equal(node.type, VerkleNodeType.Internal, 'type should be set')
-    assert.ok(
-      equalsBytes(node.commitment as unknown as Uint8Array, commitment),
-      'commitment should be set'
-    )
-    assert.equal(node.depth, depth, 'depth should be set')
+    assert.ok(equalsBytes(node.commitment, commitment), 'commitment should be set')
 
     // Children nodes should all default to null.
     assert.equal(node.children.length, NODE_WIDTH, 'number of children should equal verkle width')
@@ -33,16 +26,14 @@ describe('verkle node - internal', () => {
   })
 
   it('create method should create an internal node', async () => {
-    const depth = 3
-    const node = InternalNode.create(depth, verkleCrypto)
+    const node = InternalNode.create(verkleCrypto)
 
     assert.equal(node.type, VerkleNodeType.Internal, 'type should be set')
     assert.deepEqual(
       node.commitment,
       verkleCrypto.zeroCommitment,
       'commitment should be set to point identity'
     )
-    assert.equal(node.depth, depth, 'depth should be set')
 
     // Children nodes should all default to null.
     assert.equal(node.children.length, NODE_WIDTH, 'number of children should equal verkle width')
@@ -61,7 +52,6 @@ describe('verkle node - internal', () => {
     const node = new InternalNode({
       children,
       verkleCrypto,
-      depth: 0,
       commitment: verkleCrypto.zeroCommitment,
     })
     const serialized = node.serialize()

packages/verkle/test/leafNode.spec.ts

@@ -1,12 +1,10 @@
-import { equalsBytes, randomBytes } from '@ethereumjs/util'
+import { type VerkleCrypto, equalsBytes, randomBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, beforeAll, describe, it } from 'vitest'
 
 import { VerkleNodeType } from '../src/node/index.js'
 import { LeafNode } from '../src/node/leafNode.js'
 
-import type { VerkleCrypto } from '../src/types.js'
-
 describe('verkle node - leaf', () => {
   let verkleCrypto = undefined as never as VerkleCrypto
   beforeAll(async () => {
@@ -18,13 +16,10 @@ describe('verkle node - leaf', () => {
     const c2 = randomBytes(64)
     const stem = randomBytes(32)
     const values = new Array<Uint8Array>(256).fill(randomBytes(32))
-
-    const depth = 2
     const node = new LeafNode({
       c1,
       c2,
       commitment,
-      depth,
       stem,
       values,
       verkleCrypto,
@@ -42,7 +37,6 @@ describe('verkle node - leaf', () => {
       values.every((value, index) => equalsBytes(value, node.values[index])),
       'values should be set'
     )
-    assert.equal(node.depth, depth, 'depth should be set')
   })
 
   it('create method should create an leaf node', async () => {

packages/verkle/test/verkle.spec.ts

@@ -195,13 +195,8 @@ describe('findPath validation', () => {
     leafNode2.setValue(hexToBytes(keys[2])[31], hexToBytes(values[2]))
     putStack.push([stem2, leafNode2])
 
-    // Update the depth of leafNode1
-    // Note: We wouldn't need to do this if we didn't track depth as a property of each node
-    leafNode1.depth = 2
-    putStack.push([stem1, leafNode1])
-
     // Create new internal node
-    const internalNode1 = InternalNode.create(1, verkleCrypto)
+    const internalNode1 = InternalNode.create(verkleCrypto)
 
     // Compute the portion of stem1 and stem2 that match
     // Note: We subtract 1 since we are using 0-indexed arrays