From 0b0344473dec56d935f64d1ca2ee82d3c6d1f441 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 10 May 2024 12:38:26 -0400
Subject: [PATCH 01/51] add verkle crypto to trie

---
 packages/verkle/src/verkleTree.ts             |  4 +-
 packages/verkle/test/leafNode.spec.ts         | 48 ++++++++++++++++++-
 .../test/testData/interopTestVectors.ts       | 42 ++++++++++++++++
 packages/verkle/test/verkle.spec.ts           | 12 +++--
 4 files changed, 100 insertions(+), 6 deletions(-)
 create mode 100644 packages/verkle/test/testData/interopTestVectors.ts

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 261865903d..90dc09aa57 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -15,7 +15,7 @@ import {
 import { WalkController, matchingBytesLength } from './util/index.js'
 
 import type { VerkleNode } from './node/types.js'
-import type { FoundNodeFunction } from './types.js'
+import type { FoundNodeFunction, VerkleCrypto } from './types.js'
 import type { BatchDBOp, DB, PutBatch } from '@ethereumjs/util'
 
 interface Path {
@@ -43,7 +43,7 @@ export class VerkleTree {
   protected _lock = new Lock()
   protected _root: Uint8Array
 
-  protected verkleCrypto: any
+  protected verkleCrypto: VerkleCrypto
   /**
    * Creates a new verkle tree.
    * @param opts Options for instantiating the verkle tree
diff --git a/packages/verkle/test/leafNode.spec.ts b/packages/verkle/test/leafNode.spec.ts
index b3fdafa452..db5d4e4203 100644
--- a/packages/verkle/test/leafNode.spec.ts
+++ b/packages/verkle/test/leafNode.spec.ts
@@ -6,6 +6,49 @@ import { LeafNode } from '../src/node/leafNode.js'
 
 import type { Point } from '../src/types.js'
 
+const keys = [
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 0,
+  ]),
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 1,
+  ]),
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 2,
+  ]),
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 3,
+  ]),
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 4,
+  ]),
+]
+
+const values = [
+  Uint8Array.from([
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  ]),
+  Uint8Array.from([
+    0, 0, 100, 167, 179, 182, 224, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0,
+  ]),
+  Uint8Array.from([
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  ]),
+  Uint8Array.from([
+    197, 210, 70, 1, 134, 247, 35, 60, 146, 126, 125, 178, 220, 199, 3, 192, 229, 0, 182, 83, 202,
+    130, 39, 59, 123, 250, 216, 4, 93, 133, 164, 112,
+  ]),
+  Uint8Array.from([
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  ]),
+]
+
 describe('verkle node - leaf', () => {
   it('constructor should create an leaf node', async () => {
     const commitment = randomBytes(32)
@@ -38,5 +81,8 @@ describe('verkle node - leaf', () => {
     assert.equal(node.depth, depth, 'depth should be set')
   })
 
-  it.todo('create method should create an leaf node')
+  it.only('create method should create an leaf node', () => {
+    const nodeData = keys[0]
+    const node = LeafNode.create()
+  })
 })
diff --git a/packages/verkle/test/testData/interopTestVectors.ts b/packages/verkle/test/testData/interopTestVectors.ts
new file mode 100644
index 0000000000..78e11cfe01
--- /dev/null
+++ b/packages/verkle/test/testData/interopTestVectors.ts
@@ -0,0 +1,42 @@
+export const keys = [
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 0,
+  ]),
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 1,
+  ]),
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 2,
+  ]),
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 3,
+  ]),
+  Uint8Array.from([
+    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
+    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 4,
+  ]),
+]
+
+export const values = [
+  Uint8Array.from([
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  ]),
+  Uint8Array.from([
+    0, 0, 100, 167, 179, 182, 224, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0,
+  ]),
+  Uint8Array.from([
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  ]),
+  Uint8Array.from([
+    197, 210, 70, 1, 134, 247, 35, 60, 146, 126, 125, 178, 220, 199, 3, 192, 229, 0, 182, 83, 202,
+    130, 39, 59, 123, 250, 216, 4, 93, 133, 164, 112,
+  ]),
+  Uint8Array.from([
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  ]),
+]
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 9ce064e07b..b28457d859 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -1,4 +1,5 @@
-import { equalsBytes, hexToBytes } from '@ethereumjs/util'
+import { MapDB, equalsBytes, hexToBytes } from '@ethereumjs/util'
+import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, describe, it } from 'vitest'
 
 import { VerkleTree } from '../src/verkleTree.js'
@@ -46,8 +47,13 @@ const absentKeys = [
 ].map((key) => hexToBytes(key as PrefixedHexString))
 
 describe('Verkle tree', () => {
-  it.todo('should insert and retrieve values', async () => {
-    const tree = new VerkleTree()
+  it('should insert and retrieve values', async () => {
+    const verkleCrypto = await loadVerkleCrypto()
+    const tree = await VerkleTree.create({
+      verkleCrypto,
+    })
+    const db = new MapDB<Uint8Array, Uint8Array>()
+    tree.database(db)
     for (let i = 0; i < presentKeys.length; i++) {
       await tree.put(presentKeys[i], values[i])
     }

From c1ce5ebb932f71618d4f48ee8cfc487fad9669c0 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 13 May 2024 12:04:12 -0400
Subject: [PATCH 02/51] More spam

---
 electra.yaml                                  | 21 +++++++++
 packages/verkle/src/node/leafNode.ts          |  2 +-
 packages/verkle/src/node/types.ts             |  4 +-
 packages/verkle/src/verkleTree.ts             |  5 +-
 packages/verkle/test/leafNode.spec.ts         | 47 +------------------
 .../test/testData/interopTestVectors.ts       | 42 -----------------
 6 files changed, 28 insertions(+), 93 deletions(-)
 create mode 100644 electra.yaml
 delete mode 100644 packages/verkle/test/testData/interopTestVectors.ts

diff --git a/electra.yaml b/electra.yaml
new file mode 100644
index 0000000000..10e91c85fa
--- /dev/null
+++ b/electra.yaml
@@ -0,0 +1,21 @@
+participants:
+  - el_type: ethereumjs
+    el_image: ethereumjs:local
+    cl_type: grandine
+    cl_image: ethpandaops/grandine:feature-electra
+
+  - el_type: ethereumjs
+    el_image: ethereumjs:local
+    cl_type: grandine
+    cl_image: ethpandaops/grandine:feature-electra
+
+network_params:
+  electra_fork_epoch: 1
+  electra_fork_version: "0x50000038"
+    #global_log_level: debug
+additional_services:
+  - dora
+  - tx_spammer
+  - blob_spammer
+
+snooper_enabled: true
\ No newline at end of file
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 330fbf17c6..98e9707a03 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -22,7 +22,7 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
   }
 
   static create(stem: Uint8Array, values: Uint8Array[]): LeafNode {
-    throw new Error('Not implemented')
+    return new LeafNode({ stem, values })
   }
 
   static fromRawNode(rawNode: Uint8Array[], depth: number): LeafNode {
diff --git a/packages/verkle/src/node/types.ts b/packages/verkle/src/node/types.ts
index 4070d1e7ad..e4908e532c 100644
--- a/packages/verkle/src/node/types.ts
+++ b/packages/verkle/src/node/types.ts
@@ -37,8 +37,8 @@ interface VerkleInternalNodeOptions extends BaseVerkleNodeOptions {
 interface VerkleLeafNodeOptions extends BaseVerkleNodeOptions {
   stem: Uint8Array
   values: Uint8Array[]
-  c1: Point
-  c2: Point
+  c1?: Point
+  c2?: Point
 }
 
 export interface VerkleNodeOptions {
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 90dc09aa57..191d400d99 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -176,11 +176,10 @@ export class VerkleTree {
     await this._db.put(key, value)
 
     // Find or create the leaf node
-    const leafNode = await this.findLeafNode(key, false)
+    let leafNode = await this.findLeafNode(key, false)
     if (leafNode === null) {
       // If leafNode is missing, create it
-      // leafNode = LeafNode.create()
-      throw new Error('Not implemented')
+      leafNode = LeafNode.create(key.slice(0, 31), [value])
     }
 
     // Walk up the tree and update internal nodes
diff --git a/packages/verkle/test/leafNode.spec.ts b/packages/verkle/test/leafNode.spec.ts
index db5d4e4203..515c8f6304 100644
--- a/packages/verkle/test/leafNode.spec.ts
+++ b/packages/verkle/test/leafNode.spec.ts
@@ -6,49 +6,6 @@ import { LeafNode } from '../src/node/leafNode.js'
 
 import type { Point } from '../src/types.js'
 
-const keys = [
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 0,
-  ]),
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 1,
-  ]),
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 2,
-  ]),
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 3,
-  ]),
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 4,
-  ]),
-]
-
-const values = [
-  Uint8Array.from([
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  ]),
-  Uint8Array.from([
-    0, 0, 100, 167, 179, 182, 224, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0,
-  ]),
-  Uint8Array.from([
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  ]),
-  Uint8Array.from([
-    197, 210, 70, 1, 134, 247, 35, 60, 146, 126, 125, 178, 220, 199, 3, 192, 229, 0, 182, 83, 202,
-    130, 39, 59, 123, 250, 216, 4, 93, 133, 164, 112,
-  ]),
-  Uint8Array.from([
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  ]),
-]
-
 describe('verkle node - leaf', () => {
   it('constructor should create an leaf node', async () => {
     const commitment = randomBytes(32)
@@ -82,7 +39,7 @@ describe('verkle node - leaf', () => {
   })
 
   it.only('create method should create an leaf node', () => {
-    const nodeData = keys[0]
-    const node = LeafNode.create()
+    const nodeData = values[1]
+    // const node = LeafNode.create()
   })
 })
diff --git a/packages/verkle/test/testData/interopTestVectors.ts b/packages/verkle/test/testData/interopTestVectors.ts
deleted file mode 100644
index 78e11cfe01..0000000000
--- a/packages/verkle/test/testData/interopTestVectors.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-export const keys = [
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 0,
-  ]),
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 1,
-  ]),
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 2,
-  ]),
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 3,
-  ]),
-  Uint8Array.from([
-    245, 110, 100, 66, 36, 244, 87, 100, 144, 207, 224, 222, 20, 36, 164, 83, 34, 18, 82, 155, 254,
-    55, 71, 19, 216, 78, 125, 126, 142, 146, 114, 4,
-  ]),
-]
-
-export const values = [
-  Uint8Array.from([
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  ]),
-  Uint8Array.from([
-    0, 0, 100, 167, 179, 182, 224, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0,
-  ]),
-  Uint8Array.from([
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  ]),
-  Uint8Array.from([
-    197, 210, 70, 1, 134, 247, 35, 60, 146, 126, 125, 178, 220, 199, 3, 192, 229, 0, 182, 83, 202,
-    130, 39, 59, 123, 250, 216, 4, 93, 133, 164, 112,
-  ]),
-  Uint8Array.from([
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  ]),
-]

From 16701559504f7599ffcae1fb9ea8d0e27b2f9c5d Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 15 May 2024 15:21:56 -0400
Subject: [PATCH 03/51] Update leafNode.create [no ci]

---
 packages/verkle/src/node/internalNode.ts |  2 +-
 packages/verkle/src/node/leafNode.ts     | 17 +++++++++++------
 packages/verkle/src/verkleTree.ts        | 13 +++++++------
 packages/verkle/test/leafNode.spec.ts    | 19 +++++++++++++++----
 packages/verkle/test/verkle.spec.ts      |  2 +-
 5 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 06869e1172..ef5c123c59 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -98,7 +98,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
       // Next word differs, so this was the last level.
       // Insert it directly into its final slot.
-      const leafNode = LeafNode.create(stem, values)
+      const leafNode = LeafNode.create(stem, values, this.depth + 1)
 
       leafNode.setDepth(this.depth + 2)
       newBranch.cowChild(nextByteInInsertedKey)
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 98e9707a03..95da8bbbda 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -8,8 +8,8 @@ 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 c1?: Point
+  public c2?: Point
   public type = VerkleNodeType.Leaf
 
   constructor(options: VerkleNodeOptions[VerkleNodeType.Leaf]) {
@@ -21,8 +21,13 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     this.c2 = options.c2
   }
 
-  static create(stem: Uint8Array, values: Uint8Array[]): LeafNode {
-    return new LeafNode({ stem, values })
+  static create(
+    stem: Uint8Array,
+    values: Uint8Array[],
+    depth: number,
+    commitment?: Uint8Array
+  ): LeafNode {
+    return new LeafNode({ stem, values, depth, commitment: commitment ?? new Uint8Array() })
   }
 
   static fromRawNode(rawNode: Uint8Array[], depth: number): LeafNode {
@@ -73,8 +78,8 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
       new Uint8Array([VerkleNodeType.Leaf]),
       this.stem,
       this.commitment,
-      this.c1.bytes(),
-      this.c2.bytes(),
+      this.c1?.bytes() ?? new Uint8Array(),
+      this.c2?.bytes() ?? new Uint8Array(),
       ...this.values,
     ]
   }
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 191d400d99..ff5ef0e2a1 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -154,7 +154,7 @@ export class VerkleTree {
    */
   async get(key: Uint8Array, throwIfMissing = false): Promise<Uint8Array | null> {
     const node = await this.findLeafNode(key, throwIfMissing)
-    if (node !== null) {
+    if (typeof node !== 'number') {
       const keyLastByte = key[key.length - 1]
 
       // The retrieved leaf node contains an array of 256 possible values.
@@ -177,9 +177,9 @@ export class VerkleTree {
 
     // Find or create the leaf node
     let leafNode = await this.findLeafNode(key, false)
-    if (leafNode === null) {
+    if (typeof leafNode === 'number') {
       // If leafNode is missing, create it
-      leafNode = LeafNode.create(key.slice(0, 31), [value])
+      leafNode = LeafNode.create(key.slice(0, 31), [value], leafNode)
     }
 
     // Walk up the tree and update internal nodes
@@ -279,13 +279,14 @@ export class VerkleTree {
    * @param key - the search key
    * @param throwIfMissing - if true, throws if any nodes are missing. Used for verifying proofs. (default: false)
    */
-  async findLeafNode(key: Uint8Array, throwIfMissing = false): Promise<LeafNode | null> {
-    const { node } = await this.findPath(key, throwIfMissing)
+  async findLeafNode(key: Uint8Array, throwIfMissing = false): Promise<LeafNode | number> {
+    const { node, stack } = await this.findPath(key, throwIfMissing)
     if (!(node instanceof LeafNode)) {
       if (throwIfMissing) {
         throw new Error('leaf node not found')
       }
-      return null
+      // return depth of remaining nodes
+      return stack.length
     }
     return node
   }
diff --git a/packages/verkle/test/leafNode.spec.ts b/packages/verkle/test/leafNode.spec.ts
index 515c8f6304..5acdc54882 100644
--- a/packages/verkle/test/leafNode.spec.ts
+++ b/packages/verkle/test/leafNode.spec.ts
@@ -1,10 +1,11 @@
-import { equalsBytes, randomBytes } from '@ethereumjs/util'
+import { equalsBytes, hexToBytes, randomBytes } from '@ethereumjs/util'
 import { assert, describe, it } from 'vitest'
 
 import { VerkleNodeType } from '../src/node/index.js'
 import { LeafNode } from '../src/node/leafNode.js'
 
 import type { Point } from '../src/types.js'
+import type { PrefixedHexString } from '@ethereumjs/util'
 
 describe('verkle node - leaf', () => {
   it('constructor should create an leaf node', async () => {
@@ -38,8 +39,18 @@ describe('verkle node - leaf', () => {
     assert.equal(node.depth, depth, 'depth should be set')
   })
 
-  it.only('create method should create an leaf node', () => {
-    const nodeData = values[1]
-    // const node = LeafNode.create()
+  it('create method should create an leaf node', () => {
+    const presentKeys = ['0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d01'].map(
+      (key) => hexToBytes(key as PrefixedHexString)
+    )
+
+    // Corresponding values for the present keys
+    const values = ['0x320122e8584be00d000000000000000000000000000000000000000000000000'].map(
+      (key) => hexToBytes(key as PrefixedHexString)
+    )
+    const stem = presentKeys[0].slice(0, 31)
+    const nodeData = values
+    const node = LeafNode.create(stem, nodeData, 0)
+    assert.ok(node instanceof LeafNode)
   })
 })
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index b28457d859..332aae0008 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -47,7 +47,7 @@ const absentKeys = [
 ].map((key) => hexToBytes(key as PrefixedHexString))
 
 describe('Verkle tree', () => {
-  it('should insert and retrieve values', async () => {
+  it.only('should insert and retrieve values', async () => {
     const verkleCrypto = await loadVerkleCrypto()
     const tree = await VerkleTree.create({
       verkleCrypto,

From 974d1aea634fb7e331e342e99e4dde42b150d59a Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 16 May 2024 17:08:45 -0400
Subject: [PATCH 04/51] small removal [no ci]

---
 packages/verkle/src/node/leafNode.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 95da8bbbda..25c0ba8442 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import { BaseVerkleNode } from './baseVerkleNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 

From 430d801c8cbbb382db10d7d0a0773e2e030936ec Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 20 May 2024 13:09:31 -0400
Subject: [PATCH 05/51] Update trie.get to check existence first

---
 packages/verkle/src/verkleTree.ts | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index ff5ef0e2a1..5699fb90b5 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -153,14 +153,15 @@ export class VerkleTree {
    * @returns A Promise that resolves to `Uint8Array` if a value was found or `null` if no value was found.
    */
   async get(key: Uint8Array, throwIfMissing = false): Promise<Uint8Array | null> {
-    const node = await this.findLeafNode(key, throwIfMissing)
-    if (typeof node !== 'number') {
-      const keyLastByte = key[key.length - 1]
-
-      // The retrieved leaf node contains an array of 256 possible values.
-      // The index of the value we want is at the key's last byte
-      return node.values?.[keyLastByte] ?? null
-    }
+    const node = await this._db.get(key)
+    if (node !== undefined && node instanceof LeafNode)
+      if (node instanceof LeafNode) {
+        const keyLastByte = key[key.length - 1]
+
+        // The retrieved leaf node contains an array of 256 possible values.
+        // The index of the value we want is at the key's last byte
+        return node.values?.[keyLastByte] ?? null
+      }
 
     return null
   }
@@ -177,9 +178,15 @@ export class VerkleTree {
 
     // Find or create the leaf node
     let leafNode = await this.findLeafNode(key, false)
-    if (typeof leafNode === 'number') {
+    if (!(leafNode instanceof LeafNode)) {
       // If leafNode is missing, create it
-      leafNode = LeafNode.create(key.slice(0, 31), [value], leafNode)
+      const commitment = this.verkleCrypto.updateCommitment(this.verkleCrypto.zeroCommitment)
+      leafNode = LeafNode.create(
+        key.slice(0, 31),
+        [value],
+        leafNode.length,
+        leafNode[leafNode.length - 1].commitment
+      )
     }
 
     // Walk up the tree and update internal nodes
@@ -279,14 +286,14 @@ export class VerkleTree {
    * @param key - the search key
    * @param throwIfMissing - if true, throws if any nodes are missing. Used for verifying proofs. (default: false)
    */
-  async findLeafNode(key: Uint8Array, throwIfMissing = false): Promise<LeafNode | number> {
+  async findLeafNode(key: Uint8Array, throwIfMissing = false): Promise<LeafNode | VerkleNode[]> {
     const { node, stack } = await this.findPath(key, throwIfMissing)
     if (!(node instanceof LeafNode)) {
       if (throwIfMissing) {
         throw new Error('leaf node not found')
       }
       // return depth of remaining nodes
-      return stack.length
+      return stack
     }
     return node
   }

From fa34dde51b02c19e897f54740d0b97cac4411d45 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 20 May 2024 13:40:30 -0400
Subject: [PATCH 06/51] Update `put` when inserting a new leaf node [no ci]

---
 packages/verkle/src/node/leafNode.ts |  8 ++++----
 packages/verkle/src/util/keys.ts     |  4 ++++
 packages/verkle/src/verkleTree.ts    | 19 ++++++++++++-------
 3 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 25c0ba8442..b20549a320 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -6,7 +6,7 @@ import type { VerkleNodeOptions } from './types.js'
 
 export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
   public stem: Uint8Array
-  public values: Uint8Array[]
+  public values: Uint8Array[] // Array of 256 possible values represented as 32 byte Uint8Arrays
   public c1?: Point
   public c2?: Point
   public type = VerkleNodeType.Leaf
@@ -24,9 +24,9 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     stem: Uint8Array,
     values: Uint8Array[],
     depth: number,
-    commitment?: Uint8Array
+    commitment: Uint8Array
   ): LeafNode {
-    return new LeafNode({ stem, values, depth, commitment: commitment ?? new Uint8Array() })
+    return new LeafNode({ stem, values, depth, commitment })
   }
 
   static fromRawNode(rawNode: Uint8Array[], depth: number): LeafNode {
@@ -63,7 +63,7 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     this.insertStem(key.slice(0, 31), values, nodeResolverFn)
   }
 
-  insertMultiple(key: Uint8Array, values: Uint8Array[]): void {
+  insertMultiple(keys: Uint8Array[], values: Uint8Array[]): void {
     throw new Error('Not implemented')
   }
 
diff --git a/packages/verkle/src/util/keys.ts b/packages/verkle/src/util/keys.ts
index 5f2a3adb7f..858b5a49bc 100644
--- a/packages/verkle/src/util/keys.ts
+++ b/packages/verkle/src/util/keys.ts
@@ -94,3 +94,7 @@ export const getTreeKeyForStorageSlot = async (
 
   return concatBytes(getStem(verkleCrypto, address, treeIndex), toBytes(subIndex))
 }
+
+export const verifyKeyLength = (key: Uint8Array) => {
+  if (key.length !== 32) throw new Error(`expected key with length 32l; got ${key.length}`)
+}
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 5699fb90b5..ee7256ef41 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -13,6 +13,7 @@ import {
   type VerkleTreeOptsWithDefaults,
 } from './types.js'
 import { WalkController, matchingBytesLength } from './util/index.js'
+import { verifyKeyLength } from './util/keys.js'
 
 import type { VerkleNode } from './node/types.js'
 import type { FoundNodeFunction, VerkleCrypto } from './types.js'
@@ -153,6 +154,7 @@ export class VerkleTree {
    * @returns A Promise that resolves to `Uint8Array` if a value was found or `null` if no value was found.
    */
   async get(key: Uint8Array, throwIfMissing = false): Promise<Uint8Array | null> {
+    verifyKeyLength(key)
     const node = await this._db.get(key)
     if (node !== undefined && node instanceof LeafNode)
       if (node instanceof LeafNode) {
@@ -174,19 +176,22 @@ export class VerkleTree {
    * @returns A Promise that resolves once value is stored.
    */
   async put(key: Uint8Array, value: Uint8Array): Promise<void> {
+    verifyKeyLength(key)
     await this._db.put(key, value)
 
     // Find or create the leaf node
     let leafNode = await this.findLeafNode(key, false)
     if (!(leafNode instanceof LeafNode)) {
       // If leafNode is missing, create it
-      const commitment = this.verkleCrypto.updateCommitment(this.verkleCrypto.zeroCommitment)
-      leafNode = LeafNode.create(
-        key.slice(0, 31),
-        [value],
-        leafNode.length,
-        leafNode[leafNode.length - 1].commitment
-      )
+      const values = new Array(256) as Uint8Array[] // Create new empty array of 256 values
+      const suffix = key[31]
+      values[suffix] = value // Set value at key suffix
+
+      // Generate a commitment for the new leaf node, using the zero commitment as a base
+      const commitment = this.verkleCrypto.zeroCommitment
+      // TODO: Confirm the old/new scalar values we're passing in here are correct
+      this.verkleCrypto.updateCommitment(commitment, suffix, new Uint8Array(), value)
+      leafNode = LeafNode.create(key.slice(0, 31), values, leafNode.length, commitment)
     }
 
     // Walk up the tree and update internal nodes

From b2806cf167fbacac382654be1ec6bbc60c328585 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Tue, 21 May 2024 08:58:15 -0400
Subject: [PATCH 07/51] more halfway stuff [no ci]

---
 packages/verkle/src/node/internalNode.ts | 35 ++++++++++++++++++------
 packages/verkle/src/node/leafNode.ts     |  2 +-
 packages/verkle/src/verkleTree.ts        |  2 +-
 packages/verkle/test/leafNode.spec.ts    |  2 +-
 4 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index ef5c123c59..6861f33d18 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -1,4 +1,4 @@
-import { equalsBytes } from '@ethereumjs/util'
+import { BIGINT_0, bytesToBigInt, equalsBytes } from '@ethereumjs/util'
 
 import { POINT_IDENTITY } from '../util/crypto.js'
 
@@ -6,6 +6,7 @@ import { BaseVerkleNode } from './baseVerkleNode.js'
 import { LeafNode } from './leafNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 
+import type { VerkleCrypto } from '../types.js'
 import type { VerkleNode, VerkleNodeOptions } from './types.js'
 
 export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
@@ -14,9 +15,9 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
   public copyOnWrite: Record<string, Uint8Array>
   public type = VerkleNodeType.Internal
 
-  /* TODO: options.children is not actually used here */
   constructor(options: VerkleNodeOptions[VerkleNodeType.Internal]) {
     super(options)
+    // TODO: Decide whether to fill with null or not - personal opinion - should never use null
     this.children = options.children ?? new Array(NODE_WIDTH).fill(null)
     this.copyOnWrite = options.copyOnWrite ?? {}
   }
@@ -63,19 +64,30 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     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)
@@ -93,19 +105,26 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
       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, this.depth + 1)
+      // TODO: Determine if this is how to create the correct commitment
+      let commitment = verkleCrypto.zeroCommitment
+      for (const [idx, value] of values.entries()) {
+        if (bytesToBigInt(value) > BIGINT_0)
+          commitment = verkleCrypto.updateCommitment(commitment, idx, new Uint8Array(32), value)
+      }
+      const leafNode = LeafNode.create(stem, values, this.depth + 1, commitment)
 
+      // 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')
     }
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index b20549a320..aa090133e9 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -63,7 +63,7 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     this.insertStem(key.slice(0, 31), values, nodeResolverFn)
   }
 
-  insertMultiple(keys: Uint8Array[], values: Uint8Array[]): void {
+  insertMultiple(key: Uint8Array, values: Uint8Array[]): void {
     throw new Error('Not implemented')
   }
 
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index ee7256ef41..cabc0d7407 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -190,7 +190,7 @@ export class VerkleTree {
       // Generate a commitment for the new leaf node, using the zero commitment as a base
       const commitment = this.verkleCrypto.zeroCommitment
       // TODO: Confirm the old/new scalar values we're passing in here are correct
-      this.verkleCrypto.updateCommitment(commitment, suffix, new Uint8Array(), value)
+      this.verkleCrypto.updateCommitment(commitment, suffix, new Uint8Array(32), value)
       leafNode = LeafNode.create(key.slice(0, 31), values, leafNode.length, commitment)
     }
 
diff --git a/packages/verkle/test/leafNode.spec.ts b/packages/verkle/test/leafNode.spec.ts
index 5acdc54882..f81dabe907 100644
--- a/packages/verkle/test/leafNode.spec.ts
+++ b/packages/verkle/test/leafNode.spec.ts
@@ -50,7 +50,7 @@ describe('verkle node - leaf', () => {
     )
     const stem = presentKeys[0].slice(0, 31)
     const nodeData = values
-    const node = LeafNode.create(stem, nodeData, 0)
+    const node = LeafNode.create(stem, nodeData, 0, new Uint8Array(32))
     assert.ok(node instanceof LeafNode)
   })
 })

From f9e019e0ee678de030b59490e389f6a9bbf39ed8 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 30 May 2024 22:08:18 -0400
Subject: [PATCH 08/51] Remove unnecessary commit [no ci]

---
 electra.yaml | 21 ---------------------
 1 file changed, 21 deletions(-)
 delete mode 100644 electra.yaml

diff --git a/electra.yaml b/electra.yaml
deleted file mode 100644
index 10e91c85fa..0000000000
--- a/electra.yaml
+++ /dev/null
@@ -1,21 +0,0 @@
-participants:
-  - el_type: ethereumjs
-    el_image: ethereumjs:local
-    cl_type: grandine
-    cl_image: ethpandaops/grandine:feature-electra
-
-  - el_type: ethereumjs
-    el_image: ethereumjs:local
-    cl_type: grandine
-    cl_image: ethpandaops/grandine:feature-electra
-
-network_params:
-  electra_fork_epoch: 1
-  electra_fork_version: "0x50000038"
-    #global_log_level: debug
-additional_services:
-  - dora
-  - tx_spammer
-  - blob_spammer
-
-snooper_enabled: true
\ No newline at end of file

From 74676b0e88a603973ef177ce212d674f0f799515 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 3 Jun 2024 06:30:25 -0400
Subject: [PATCH 09/51] update verkle crypto dep [no ci]

---
 package-lock.json                  | 10 +++++-----
 packages/statemanager/package.json |  2 +-
 packages/verkle/package.json       |  2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 2c9bc6ed7e..71cc2787db 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12154,9 +12154,9 @@
       }
     },
     "node_modules/verkle-cryptography-wasm": {
-      "version": "0.4.2",
-      "resolved": "https://registry.npmjs.org/verkle-cryptography-wasm/-/verkle-cryptography-wasm-0.4.2.tgz",
-      "integrity": "sha512-Mji9ibiCBS0ObveKuIC6XY009zLJTVBwwPaLnOI3yoj26MbZjAI8ByhWSmoQCJkWj/j/hNjcq9Jbx39Fguh92w==",
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/verkle-cryptography-wasm/-/verkle-cryptography-wasm-0.4.3.tgz",
+      "integrity": "sha512-feUY8JnS9I3sJAkZbHJdvRDQTp0YG7bXGH1f99WK+aSLhr3mU/tbpbwfDL9zTbvRcX/15+5LmM35cLbMexEJeA==",
       "dependencies": {
         "@scure/base": "^1.1.5"
       },
@@ -13536,7 +13536,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",
@@ -13619,7 +13619,7 @@
         "@ethereumjs/rlp": "^5.0.2",
         "@ethereumjs/util": "^9.0.3",
         "lru-cache": "10.1.0",
-        "verkle-cryptography-wasm": "^0.4.2"
+        "verkle-cryptography-wasm": "^0.4.3"
       },
       "engines": {
         "node": ">=18"
diff --git a/packages/statemanager/package.json b/packages/statemanager/package.json
index 9849f958e6..e551fc1bf4 100644
--- a/packages/statemanager/package.json
+++ b/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",
diff --git a/packages/verkle/package.json b/packages/verkle/package.json
index cafbf05fa0..26013c10b2 100644
--- a/packages/verkle/package.json
+++ b/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"

From a267be126f21313883443e75db6de43059dd0239 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 3 Jun 2024 11:00:41 -0400
Subject: [PATCH 10/51] Add helper to create leaf values as 16 bytes

---
 packages/verkle/src/node/util.ts | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
index 16726076dc..1b5bbcbdae 100644
--- a/packages/verkle/src/node/util.ts
+++ b/packages/verkle/src/node/util.ts
@@ -1,4 +1,5 @@
 import { RLP } from '@ethereumjs/rlp'
+import { bigIntToBytes, bytesToBigInt } from '@ethereumjs/util'
 
 import { InternalNode } from './internalNode.js'
 import { LeafNode } from './leafNode.js'
@@ -28,3 +29,25 @@ export function decodeNode(raw: Uint8Array) {
 export function isRawNode(node: Uint8Array | Uint8Array[]): node is Uint8Array[] {
   return Array.isArray(node) && !(node instanceof Uint8Array)
 }
+
+/***
+ * Converts 128 32byte values of a leaf node into 16 byte values for generating a commitment for half of a
+ * leaf node's values
+ * @param values - an array of Uint8Arrays representing the first or second  128 values stored by verkle trie leaf node
+ * @param deletedValues - an array of booleans where a value of true at a given position indicates a value
+ * that is being deleted - should always be false if generating C2 values
+ * Returns an array of 256 16byte UintArrays with the leaf marker set for each value that is deleted
+ */
+export const createCValues = (values: Uint8Array[], deletedValues: boolean[]) => {
+  if (values.length !== 128 || deletedValues.length !== 128)
+    throw new Error(`got wrong number of values, expected 128, got ${values.length}`)
+  const expandedValues: Uint8Array[] = new Array(256)
+  for (let x = 0; x < 128; x++) {
+    // TODO: Improve performance by only flipping the 129th bit of `expandedValues[x]` (instead of bigint addition)
+    expandedValues[x] = deletedValues[x]
+      ? bigIntToBytes(bytesToBigInt(values[x].subarray(0, 16)) + BigInt(2 ** 128))
+      : values[x].subarray(0, 16)
+    expandedValues[x + 1] = values[x].subarray(16)
+  }
+  return expandedValues
+}

From e3ab994d867df1d0edcb0d619aa94036b4747001 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 3 Jun 2024 15:36:23 -0400
Subject: [PATCH 11/51] Changes to support c1 and c2 [no ci]

---
 packages/verkle/src/node/baseVerkleNode.ts |  6 ++++--
 packages/verkle/src/node/internalNode.ts   | 23 ++++++++++++++++++----
 packages/verkle/src/node/leafNode.ts       | 19 +++++++++---------
 packages/verkle/src/node/types.ts          |  8 ++++----
 packages/verkle/src/node/util.ts           | 14 +++++++------
 packages/verkle/src/types.ts               |  4 ++++
 packages/verkle/src/verkleTree.ts          | 15 +++++++++++---
 7 files changed, 61 insertions(+), 28 deletions(-)

diff --git a/packages/verkle/src/node/baseVerkleNode.ts b/packages/verkle/src/node/baseVerkleNode.ts
index 43edb15007..d9e3987690 100644
--- a/packages/verkle/src/node/baseVerkleNode.ts
+++ b/packages/verkle/src/node/baseVerkleNode.ts
@@ -2,6 +2,8 @@ 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
@@ -14,8 +16,8 @@ export abstract class BaseVerkleNode<T extends VerkleNodeType> implements Verkle
   abstract commit(): Uint8Array
 
   // Hash returns the field representation of the commitment.
-  hash(): Uint8Array {
-    throw new Error('Not implemented')
+  hash(verkleCrypto: VerkleCrypto): Uint8Array {
+    return verkleCrypto.hashCommitment(this.commitment)
   }
 
   abstract insert(key: Uint8Array, value: Uint8Array, nodeResolverFn: () => void): void
diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 6861f33d18..a90c8d1aff 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -111,12 +111,27 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       // Next word differs, so this was the last level.
       // Insert it directly into its final slot.
       // TODO: Determine if this is how to create the correct commitment
-      let commitment = verkleCrypto.zeroCommitment
+      let leafCommitment = verkleCrypto.zeroCommitment
+      let c1 = verkleCrypto.zeroCommitment
+      let c2 = verkleCrypto.zeroCommitment
       for (const [idx, value] of values.entries()) {
-        if (bytesToBigInt(value) > BIGINT_0)
-          commitment = verkleCrypto.updateCommitment(commitment, idx, new Uint8Array(32), value)
+        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, commitment)
+
+      const leafNode = LeafNode.create(stem, values, this.depth + 1, leafCommitment, c1, c2)
 
       // TODO - Why is the leaf node set at depth + 2 instead of + 1)?
       leafNode.setDepth(this.depth + 2)
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index aa090133e9..1cbcbb1c24 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -1,14 +1,13 @@
 import { BaseVerkleNode } from './baseVerkleNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 
-import type { Point } from '../types.js'
 import type { VerkleNodeOptions } from './types.js'
 
 export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
   public stem: Uint8Array
   public values: Uint8Array[] // Array of 256 possible values represented as 32 byte Uint8Arrays
-  public c1?: Point
-  public c2?: Point
+  public c1?: Uint8Array
+  public c2?: Uint8Array
   public type = VerkleNodeType.Leaf
 
   constructor(options: VerkleNodeOptions[VerkleNodeType.Leaf]) {
@@ -24,9 +23,11 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     stem: Uint8Array,
     values: Uint8Array[],
     depth: number,
-    commitment: Uint8Array
+    commitment: Uint8Array,
+    c1: Uint8Array,
+    c2: Uint8Array
   ): LeafNode {
-    return new LeafNode({ stem, values, depth, commitment })
+    return new LeafNode({ stem, values, depth, commitment, c1, c2 })
   }
 
   static fromRawNode(rawNode: Uint8Array[], depth: number): LeafNode {
@@ -43,8 +44,8 @@ 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 })
@@ -77,8 +78,8 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
       new Uint8Array([VerkleNodeType.Leaf]),
       this.stem,
       this.commitment,
-      this.c1?.bytes() ?? new Uint8Array(),
-      this.c2?.bytes() ?? new Uint8Array(),
+      this.c1 ?? new Uint8Array(),
+      this.c2 ?? new Uint8Array(),
       ...this.values,
     ]
   }
diff --git a/packages/verkle/src/node/types.ts b/packages/verkle/src/node/types.ts
index e4908e532c..0705b0649e 100644
--- a/packages/verkle/src/node/types.ts
+++ b/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,7 +16,7 @@ export type VerkleNode = TypedVerkleNode[VerkleNodeType]
 
 export interface VerkleNodeInterface {
   commit(): Uint8Array
-  hash(): any
+  hash(verkleCrypto: VerkleCrypto): any
   serialize(): Uint8Array
 }
 
@@ -37,8 +37,8 @@ interface VerkleInternalNodeOptions extends BaseVerkleNodeOptions {
 interface VerkleLeafNodeOptions extends BaseVerkleNodeOptions {
   stem: Uint8Array
   values: Uint8Array[]
-  c1?: Point
-  c2?: Point
+  c1?: Uint8Array
+  c2?: Uint8Array
 }
 
 export interface VerkleNodeOptions {
diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
index 1b5bbcbdae..e978021578 100644
--- a/packages/verkle/src/node/util.ts
+++ b/packages/verkle/src/node/util.ts
@@ -33,21 +33,23 @@ export function isRawNode(node: Uint8Array | Uint8Array[]): node is Uint8Array[]
 /***
  * Converts 128 32byte values of a leaf node into 16 byte values for generating a commitment for half of a
  * leaf node's values
- * @param values - an array of Uint8Arrays representing the first or second  128 values stored by verkle trie leaf node
+ * @param values - an array of Uint8Arrays representing the first or second 128 values stored by verkle trie leaf node
  * @param deletedValues - an array of booleans where a value of true at a given position indicates a value
  * that is being deleted - should always be false if generating C2 values
  * Returns an array of 256 16byte UintArrays with the leaf marker set for each value that is deleted
  */
-export const createCValues = (values: Uint8Array[], deletedValues: boolean[]) => {
+export const createCValues = (values: Uint8Array[], deletedValues = new Array(128).fill(false)) => {
   if (values.length !== 128 || deletedValues.length !== 128)
     throw new Error(`got wrong number of values, expected 128, got ${values.length}`)
   const expandedValues: Uint8Array[] = new Array(256)
   for (let x = 0; x < 128; x++) {
     // TODO: Improve performance by only flipping the 129th bit of `expandedValues[x]` (instead of bigint addition)
-    expandedValues[x] = deletedValues[x]
-      ? bigIntToBytes(bytesToBigInt(values[x].subarray(0, 16)) + BigInt(2 ** 128))
-      : values[x].subarray(0, 16)
-    expandedValues[x + 1] = values[x].subarray(16)
+    expandedValues[x] =
+      deletedValues[x] === true
+        ? bigIntToBytes(bytesToBigInt(values[x].subarray(0, 16)) + BigInt(2 ** 128))
+        : values[x].slice(0, 16)
+    // TODO: Decide if we should use slice or subarray here (i.e. do we need to copy these slices or not)
+    expandedValues[x + 1] = values[x].slice(16)
   }
   return expandedValues
 }
diff --git a/packages/verkle/src/types.ts b/packages/verkle/src/types.ts
index 81614ae5a0..cb60869129 100644
--- a/packages/verkle/src/types.ts
+++ b/packages/verkle/src/types.ts
@@ -8,6 +8,7 @@ import type { VerkleCrypto as VerkleFFI } from 'verkle-cryptography-wasm'
 // Field representation of a commitment
 export interface Fr {}
 
+// TODO: Decide if we still need this interface.  Commitments are now all bytes from the JS perspective
 // Elliptic curve point representation of a commitment
 export interface Point {
   // Bytes returns the compressed serialized version of the element.
@@ -142,3 +143,6 @@ export const HEADER_STORAGE_OFFSET = 64
 export const CODE_OFFSET = 128
 export const VERKLE_NODE_WIDTH = 256
 export const MAIN_STORAGE_OFFSET = BigInt(256) ** BigInt(31)
+
+export const zeroValues = new Array(256).fill(new Uint8Array())
+export const zeroCValues = new Array(128).fill(new Uint8Array())
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index cabc0d7407..f0e57ae3a2 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -5,12 +5,13 @@ import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { CheckpointDB } from './db/checkpoint.js'
 import { InternalNode } from './node/internalNode.js'
 import { LeafNode } from './node/leafNode.js'
-import { decodeNode, decodeRawNode, isRawNode } from './node/util.js'
+import { createCValues, decodeNode, decodeRawNode, isRawNode } from './node/util.js'
 import {
   type Proof,
   ROOT_DB_KEY,
   type VerkleTreeOpts,
   type VerkleTreeOptsWithDefaults,
+  zeroCValues,
 } from './types.js'
 import { WalkController, matchingBytesLength } from './util/index.js'
 import { verifyKeyLength } from './util/keys.js'
@@ -187,11 +188,19 @@ export class VerkleTree {
       const suffix = key[31]
       values[suffix] = value // Set value at key suffix
 
+      let c1 = this.verkleCrypto.zeroCommitment
+      let c2 = this.verkleCrypto.zeroCommitment
+      if (suffix < 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 = this.verkleCrypto.updateCommitment(c1, suffix * 2, new Uint8Array(32), value)
+      } else {
+        c2 = this.verkleCrypto.updateCommitment(c2, (suffix - 128) * 2, new Uint8Array(32), value)
+      }
       // Generate a commitment for the new leaf node, using the zero commitment as a base
       const commitment = this.verkleCrypto.zeroCommitment
       // TODO: Confirm the old/new scalar values we're passing in here are correct
       this.verkleCrypto.updateCommitment(commitment, suffix, new Uint8Array(32), value)
-      leafNode = LeafNode.create(key.slice(0, 31), values, leafNode.length, commitment)
+      leafNode = LeafNode.create(key.slice(0, 31), values, leafNode.length, commitment, c1, c2)
     }
 
     // Walk up the tree and update internal nodes
@@ -211,7 +220,7 @@ export class VerkleTree {
       currentDepth--
     }
 
-    this._root = currentNode.hash()
+    this._root = currentNode.hash(this.verkleCrypto)
   }
 
   /**

From 6e7e91e21e82e92177a72e7d79fd4926a44d4fb6 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Tue, 4 Jun 2024 14:13:08 -0400
Subject: [PATCH 12/51] update new leaf node commitment correctly [no ci]

---
 packages/verkle/src/verkleTree.ts | 35 ++++++++++++++++++++++++++-----
 1 file changed, 30 insertions(+), 5 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index f0e57ae3a2..e8dfecaac3 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -1,5 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { KeyEncoding, Lock, ValueEncoding, equalsBytes, zeros } from '@ethereumjs/util'
+import {
+  KeyEncoding,
+  Lock,
+  ValueEncoding,
+  equalsBytes,
+  intToBytes,
+  setLengthLeft,
+  zeros,
+} from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 
 import { CheckpointDB } from './db/checkpoint.js'
@@ -191,15 +199,32 @@ export class VerkleTree {
       let c1 = this.verkleCrypto.zeroCommitment
       let c2 = this.verkleCrypto.zeroCommitment
       if (suffix < 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
+        // We multiply the commitment index by 2 here because each 32 byte value in the leaf node is represented as two 16 byte values
         c1 = this.verkleCrypto.updateCommitment(c1, suffix * 2, new Uint8Array(32), value)
       } else {
         c2 = this.verkleCrypto.updateCommitment(c2, (suffix - 128) * 2, new Uint8Array(32), value)
       }
       // Generate a commitment for the new leaf node, using the zero commitment as a base
-      const commitment = this.verkleCrypto.zeroCommitment
-      // TODO: Confirm the old/new scalar values we're passing in here are correct
-      this.verkleCrypto.updateCommitment(commitment, suffix, new Uint8Array(32), value)
+      // 1) Update commitment with Leaf marker (1) in position 0
+      // 2) Update commitment with stem (in little endian format) in position 1
+      // 3) Update commitment with c1
+      // 4) update commitment with c2
+      // TODO: Confirm the commitment process here is correct
+      // TODO: Figure out how to do batch commitment update
+      let commitment = this.verkleCrypto.updateCommitment(
+        this.verkleCrypto.zeroCommitment,
+        0,
+        new Uint8Array(32),
+        intToBytes(1)
+      )
+      commitment = this.verkleCrypto.updateCommitment(
+        commitment,
+        1,
+        new Uint8Array(32),
+        setLengthLeft(key.slice(0, 31), 32)
+      )
+      commitment = this.verkleCrypto.updateCommitment(commitment, 2, new Uint8Array(32), c1)
+      commitment = this.verkleCrypto.updateCommitment(commitment, 3, new Uint8Array(32), c2)
       leafNode = LeafNode.create(key.slice(0, 31), values, leafNode.length, commitment, c1, c2)
     }
 

From a2ed90e471e1fe508dfa023d5d141c0677011ee0 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 6 Jun 2024 16:29:13 -0400
Subject: [PATCH 13/51] Changes needed to make `put` work [no ci]

---
 packages/verkle/src/node/util.ts           | 15 +++---
 packages/verkle/src/util/walkController.ts |  4 +-
 packages/verkle/src/verkleTree.ts          | 58 ++++++++++++++++------
 3 files changed, 54 insertions(+), 23 deletions(-)

diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
index e978021578..c0cfe50ec6 100644
--- a/packages/verkle/src/node/util.ts
+++ b/packages/verkle/src/node/util.ts
@@ -1,5 +1,5 @@
 import { RLP } from '@ethereumjs/rlp'
-import { bigIntToBytes, bytesToBigInt } from '@ethereumjs/util'
+import { bigIntToBytes, bytesToBigInt, setLengthRight } from '@ethereumjs/util'
 
 import { InternalNode } from './internalNode.js'
 import { LeafNode } from './leafNode.js'
@@ -43,13 +43,16 @@ export const createCValues = (values: Uint8Array[], deletedValues = new Array(12
     throw new Error(`got wrong number of values, expected 128, got ${values.length}`)
   const expandedValues: Uint8Array[] = new Array(256)
   for (let x = 0; x < 128; x++) {
-    // TODO: Improve performance by only flipping the 129th bit of `expandedValues[x]` (instead of bigint addition)
-    expandedValues[x] =
+    // We add 16 trailing zeros to each value since all commitments are to an array of 32 byte values
+    expandedValues[x] = setLengthRight(
       deletedValues[x] === true
-        ? bigIntToBytes(bytesToBigInt(values[x].subarray(0, 16)) + BigInt(2 ** 128))
-        : values[x].slice(0, 16)
+        ? // TODO: Improve performance by only flipping the 129th bit of `expandedValues[x]` (instead of bigint addition)
+          bigIntToBytes(bytesToBigInt(values[x].subarray(0, 16)) + BigInt(2 ** 128))
+        : values[x].slice(0, 16),
+      32
+    )
     // TODO: Decide if we should use slice or subarray here (i.e. do we need to copy these slices or not)
-    expandedValues[x + 1] = values[x].slice(16)
+    expandedValues[x + 1] = setLengthRight(values[x].slice(16), 32)
   }
   return expandedValues
 }
diff --git a/packages/verkle/src/util/walkController.ts b/packages/verkle/src/util/walkController.ts
index 18333080fd..043c742fe9 100644
--- a/packages/verkle/src/util/walkController.ts
+++ b/packages/verkle/src/util/walkController.ts
@@ -80,7 +80,7 @@ export class WalkController {
     for (const child of children) {
       if (child.nodeRef !== null) {
         const childKey = new Uint8Array([...key, child.keyExtension])
-        this.pushNodeToQueue(child.nodeRef.hash(), childKey)
+        this.pushNodeToQueue(child.nodeRef.hash(undefined as any), childKey)
       }
     }
   }
@@ -128,7 +128,7 @@ export class WalkController {
       throw new Error('Could not get node at childIndex')
     }
     const childKey = new Uint8Array([...key, childIndex])
-    this.pushNodeToQueue(childRef.hash(), childKey, priority ?? childKey.length)
+    this.pushNodeToQueue(childRef.hash(undefined as any), childKey, priority ?? childKey.length)
   }
 
   private processNode(
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index e8dfecaac3..7fec6c6245 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -6,6 +6,7 @@ import {
   equalsBytes,
   intToBytes,
   setLengthLeft,
+  setLengthRight,
   zeros,
 } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
@@ -192,39 +193,66 @@ export class VerkleTree {
     let leafNode = await this.findLeafNode(key, false)
     if (!(leafNode instanceof LeafNode)) {
       // If leafNode is missing, create it
-      const values = new Array(256) as Uint8Array[] // Create new empty array of 256 values
+      const values: Uint8Array[] = new Array(256).fill(new Uint8Array()) // Create new empty array of 256 values
       const suffix = key[31]
       values[suffix] = value // Set value at key suffix
 
-      let c1 = this.verkleCrypto.zeroCommitment
-      let c2 = this.verkleCrypto.zeroCommitment
-      if (suffix < 128) {
-        // We multiply the commitment index by 2 here because each 32 byte value in the leaf node is represented as two 16 byte values
-        c1 = this.verkleCrypto.updateCommitment(c1, suffix * 2, new Uint8Array(32), value)
-      } else {
-        c2 = this.verkleCrypto.updateCommitment(c2, (suffix - 128) * 2, new Uint8Array(32), value)
-      }
+      // Generate the 16 byte values representing the 32 byte values in the half of the values array that
+      // contain the initial value for the leaf node
+      const cValues =
+        suffix < 128 ? createCValues(values.slice(0, 128)) : createCValues(values.slice(128))
+      // The commitment index is the 2 * the suffix (i.e. the position of the value in the values array)
+      // here because each 32 byte value in the leaf node is represented as two 16 byte values in the
+      // cValues array.
+      const commitmentIndex = suffix < 128 ? suffix * 2 : (suffix - 128) * 2
+      let cCommitment = this.verkleCrypto.zeroCommitment
+      // Update the commitment for the first 16 bytes of the value
+      cCommitment = this.verkleCrypto.updateCommitment(
+        cCommitment,
+        commitmentIndex,
+        new Uint8Array(32),
+        cValues[commitmentIndex]
+      )
+      // Update thecommitment for the second 16 bytes of the value
+      cCommitment = this.verkleCrypto.updateCommitment(
+        cCommitment,
+        commitmentIndex + 1,
+        new Uint8Array(32),
+        cValues[commitmentIndex + 1]
+      )
+      const c1 = suffix < 128 ? cCommitment : this.verkleCrypto.zeroCommitment
+      const c2 = suffix > 127 ? cCommitment : this.verkleCrypto.zeroCommitment
       // Generate a commitment for the new leaf node, using the zero commitment as a base
       // 1) Update commitment with Leaf marker (1) in position 0
       // 2) Update commitment with stem (in little endian format) in position 1
       // 3) Update commitment with c1
       // 4) update commitment with c2
-      // TODO: Confirm the commitment process here is correct
-      // TODO: Figure out how to do batch commitment update
       let commitment = this.verkleCrypto.updateCommitment(
         this.verkleCrypto.zeroCommitment,
         0,
         new Uint8Array(32),
-        intToBytes(1)
+        setLengthLeft(intToBytes(1), 32)
       )
       commitment = this.verkleCrypto.updateCommitment(
         commitment,
         1,
         new Uint8Array(32),
-        setLengthLeft(key.slice(0, 31), 32)
+        setLengthRight(key.slice(0, 31), 32)
+      )
+      commitment = this.verkleCrypto.updateCommitment(
+        commitment,
+        2,
+        new Uint8Array(32),
+        // We hash the commitment when using in the leaf node commitment since c1 is 64 bytes long
+        // and we need a 32 byte input for the scalar value in `updateCommitment`
+        this.verkleCrypto.hashCommitment(c1)
+      )
+      commitment = this.verkleCrypto.updateCommitment(
+        commitment,
+        3,
+        new Uint8Array(32),
+        this.verkleCrypto.hashCommitment(c2)
       )
-      commitment = this.verkleCrypto.updateCommitment(commitment, 2, new Uint8Array(32), c1)
-      commitment = this.verkleCrypto.updateCommitment(commitment, 3, new Uint8Array(32), c2)
       leafNode = LeafNode.create(key.slice(0, 31), values, leafNode.length, commitment, c1, c2)
     }
 

From 1902ebc29a83f4d4fc3cde01e784195ee8fff42e Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 6 Jun 2024 16:51:36 -0400
Subject: [PATCH 14/51] Begin fixing internal node implementation [no ci]

---
 packages/verkle/src/node/internalNode.ts | 22 +++++++++++-----------
 packages/verkle/src/verkleTree.ts        | 23 +++++++++++++++--------
 2 files changed, 26 insertions(+), 19 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index a90c8d1aff..a56e96953d 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -7,18 +7,17 @@ import { LeafNode } from './leafNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 
 import type { VerkleCrypto } from '../types.js'
-import type { VerkleNode, VerkleNodeOptions } 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
 
   constructor(options: VerkleNodeOptions[VerkleNodeType.Internal]) {
     super(options)
-    // TODO: Decide whether to fill with null or not - personal opinion - should never use null
-    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 ?? {}
   }
 
@@ -30,8 +29,10 @@ 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 {
@@ -60,7 +61,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     return node
   }
 
-  getChildren(index: number): VerkleNode | null {
+  getChildren(index: number): Uint8Array | null {
     return this.children?.[index] ?? null
   }
 
@@ -99,7 +100,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       const nextByteInExistingKey = child.stem[this.depth + 1]
       const newBranch = InternalNode.create(this.depth + 1)
       newBranch.cowChild(nextByteInExistingKey)
-      this.children[childIndex] = newBranch
+      this.children[childIndex] = newBranch.commitment
       newBranch.children[nextByteInExistingKey] = child
       child.depth += 1
 
@@ -110,7 +111,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
       // Next word differs, so this was the last level.
       // Insert it directly into its final slot.
-      // TODO: Determine if this is how to create the correct commitment
+      // TODO: Fix this following `trie.put` logic
       let leafCommitment = verkleCrypto.zeroCommitment
       let c1 = verkleCrypto.zeroCommitment
       let c2 = verkleCrypto.zeroCommitment
@@ -147,7 +148,6 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
   // 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]
   }
 }
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 7fec6c6245..94e66357f9 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
+import { RLP } from '@ethereumjs/rlp'
 import {
   KeyEncoding,
   Lock,
@@ -14,18 +14,17 @@ import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { CheckpointDB } from './db/checkpoint.js'
 import { InternalNode } from './node/internalNode.js'
 import { LeafNode } from './node/leafNode.js'
+import { type VerkleNode, VerkleNodeType } from './node/types.js'
 import { createCValues, decodeNode, decodeRawNode, isRawNode } from './node/util.js'
 import {
   type Proof,
   ROOT_DB_KEY,
   type VerkleTreeOpts,
   type VerkleTreeOptsWithDefaults,
-  zeroCValues,
 } from './types.js'
 import { WalkController, matchingBytesLength } from './util/index.js'
 import { verifyKeyLength } from './util/keys.js'
 
-import type { VerkleNode } from './node/types.js'
 import type { FoundNodeFunction, VerkleCrypto } from './types.js'
 import type { BatchDBOp, DB, PutBatch } from '@ethereumjs/util'
 
@@ -160,13 +159,21 @@ export class VerkleTree {
   /**
    * Gets a value given a `key`
    * @param key - the key to search for
-   * @param throwIfMissing - if true, throws if any nodes are missing. Used for verifying proofs. (default: false)
    * @returns A Promise that resolves to `Uint8Array` if a value was found or `null` if no value was found.
    */
-  async get(key: Uint8Array, throwIfMissing = false): Promise<Uint8Array | null> {
+  async get(key: Uint8Array): Promise<Uint8Array | null> {
     verifyKeyLength(key)
-    const node = await this._db.get(key)
-    if (node !== undefined && node instanceof LeafNode)
+    const nodeRLP = await this._db.get(key)
+    if (nodeRLP === undefined) return null
+    // We first retrieve the node and decode it
+    const rawNode = RLP.decode(nodeRLP) as Uint8Array[]
+    const node =
+      rawNode[0][0] === VerkleNodeType.Leaf
+        ? // TODO: Figure out how to determine depth from key
+          LeafNode.fromRawNode(rawNode, 1)
+        : InternalNode.fromRawNode(rawNode, 1)
+
+    if (node instanceof LeafNode)
       if (node instanceof LeafNode) {
         const keyLastByte = key[key.length - 1]
 
@@ -187,7 +194,6 @@ export class VerkleTree {
    */
   async put(key: Uint8Array, value: Uint8Array): Promise<void> {
     verifyKeyLength(key)
-    await this._db.put(key, value)
 
     // Find or create the leaf node
     let leafNode = await this.findLeafNode(key, false)
@@ -254,6 +260,7 @@ export class VerkleTree {
         this.verkleCrypto.hashCommitment(c2)
       )
       leafNode = LeafNode.create(key.slice(0, 31), values, leafNode.length, commitment, c1, c2)
+      await this._db.put(leafNode.hash(this.verkleCrypto), leafNode.serialize())
     }
 
     // Walk up the tree and update internal nodes

From 541240c111c140e58c1475529f20bb166722a2dc Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 7 Jun 2024 11:40:15 -0400
Subject: [PATCH 15/51] move verkleCrypto to verkleNode constructor opts

---
 packages/verkle/src/node/baseVerkleNode.ts |  7 ++++---
 packages/verkle/src/node/internalNode.ts   | 23 +++++++++++++++++-----
 packages/verkle/src/node/leafNode.ts       | 18 +++++++++++++----
 packages/verkle/src/node/types.ts          |  1 +
 packages/verkle/src/verkleTree.ts          | 20 +++++++++++++------
 5 files changed, 51 insertions(+), 18 deletions(-)

diff --git a/packages/verkle/src/node/baseVerkleNode.ts b/packages/verkle/src/node/baseVerkleNode.ts
index d9e3987690..74cc5d5658 100644
--- a/packages/verkle/src/node/baseVerkleNode.ts
+++ b/packages/verkle/src/node/baseVerkleNode.ts
@@ -7,17 +7,18 @@ 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(verkleCrypto: VerkleCrypto): Uint8Array {
-    return verkleCrypto.hashCommitment(this.commitment)
+  hash(): Uint8Array {
+    return this.verkleCrypto.hashCommitment(this.commitment)
   }
 
   abstract insert(key: Uint8Array, value: Uint8Array, nodeResolverFn: () => void): void
diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index a56e96953d..62ebb8f4e2 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -35,7 +35,11 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     // 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')
@@ -49,13 +53,14 @@ 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
@@ -98,7 +103,7 @@ 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.commitment
       newBranch.children[nextByteInExistingKey] = child
@@ -132,7 +137,15 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
         }
       }
 
-      const leafNode = LeafNode.create(stem, values, this.depth + 1, leafCommitment, c1, c2)
+      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)
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 1cbcbb1c24..adecd2db7e 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -1,6 +1,7 @@
 import { BaseVerkleNode } from './baseVerkleNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 
+import type { VerkleCrypto } from '../types.js'
 import type { VerkleNodeOptions } from './types.js'
 
 export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
@@ -25,12 +26,21 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     depth: number,
     commitment: Uint8Array,
     c1: Uint8Array,
-    c2: Uint8Array
+    c2: Uint8Array,
+    verkleCrypto: VerkleCrypto
   ): LeafNode {
-    return new LeafNode({ stem, values, depth, commitment, c1, c2 })
+    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')
@@ -48,7 +58,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 })
+    return new LeafNode({ depth, stem, values, c1, c2, commitment, verkleCrypto })
   }
   commit(): Uint8Array {
     throw new Error('Not implemented')
diff --git a/packages/verkle/src/node/types.ts b/packages/verkle/src/node/types.ts
index 0705b0649e..90af9aa37a 100644
--- a/packages/verkle/src/node/types.ts
+++ b/packages/verkle/src/node/types.ts
@@ -24,6 +24,7 @@ interface BaseVerkleNodeOptions {
   // Value of the commitment
   commitment: Uint8Array
   depth: number
+  verkleCrypto: VerkleCrypto
 }
 
 interface VerkleInternalNodeOptions extends BaseVerkleNodeOptions {
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 94e66357f9..29018276a8 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -170,8 +170,8 @@ export class VerkleTree {
     const node =
       rawNode[0][0] === VerkleNodeType.Leaf
         ? // TODO: Figure out how to determine depth from key
-          LeafNode.fromRawNode(rawNode, 1)
-        : InternalNode.fromRawNode(rawNode, 1)
+          LeafNode.fromRawNode(rawNode, 1, this.verkleCrypto)
+        : InternalNode.fromRawNode(rawNode, 1, this.verkleCrypto)
 
     if (node instanceof LeafNode)
       if (node instanceof LeafNode) {
@@ -259,8 +259,16 @@ export class VerkleTree {
         new Uint8Array(32),
         this.verkleCrypto.hashCommitment(c2)
       )
-      leafNode = LeafNode.create(key.slice(0, 31), values, leafNode.length, commitment, c1, c2)
-      await this._db.put(leafNode.hash(this.verkleCrypto), leafNode.serialize())
+      leafNode = LeafNode.create(
+        key.slice(0, 31),
+        values,
+        leafNode.length,
+        commitment,
+        c1,
+        c2,
+        this.verkleCrypto
+      )
+      await this._db.put(leafNode.hash(), leafNode.serialize())
     }
 
     // Walk up the tree and update internal nodes
@@ -271,7 +279,7 @@ export class VerkleTree {
     while (currentDepth > 0) {
       const parentKey = currentKey.slice(0, -1)
       const parentIndex = currentKey[currentKey.length - 1]
-      const parentNode = InternalNode.create(currentDepth)
+      const parentNode = InternalNode.create(currentDepth, this.verkleCrypto)
       parentNode.children[parentIndex] = currentNode
       await this._db.put(parentKey, parentNode.serialize())
 
@@ -280,7 +288,7 @@ export class VerkleTree {
       currentDepth--
     }
 
-    this._root = currentNode.hash(this.verkleCrypto)
+    this._root = currentNode.hash()
   }
 
   /**

From 76da96c5c9f218b349d9e6ca62ab5a839ec48f66 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 7 Jun 2024 14:00:06 -0400
Subject: [PATCH 16/51] address feedback

---
 packages/verkle/src/node/internalNode.ts | 46 +++++++++------------
 packages/verkle/src/node/leafNode.ts     |  1 -
 packages/verkle/src/node/types.ts        |  2 +-
 packages/verkle/src/node/util.ts         |  4 +-
 packages/verkle/src/types.ts             | 52 ------------------------
 packages/verkle/src/util/keys.ts         |  2 +-
 6 files changed, 23 insertions(+), 84 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 62ebb8f4e2..d887c22d08 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -1,12 +1,12 @@
 import { BIGINT_0, bytesToBigInt, equalsBytes } from '@ethereumjs/util'
 
+import { type VerkleCrypto, zeroValues } from '../types.js'
 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 { VerkleCrypto } from '../types.js'
 import type { VerkleNodeOptions } from './types.js'
 
 export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
@@ -17,7 +17,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
   constructor(options: VerkleNodeOptions[VerkleNodeType.Internal]) {
     super(options)
-    this.children = options.children ?? new Array(NODE_WIDTH).fill(new Uint8Array())
+    this.children = options.children ?? zeroValues
     this.copyOnWrite = options.copyOnWrite ?? {}
   }
 
@@ -31,8 +31,8 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
   // Updates the commitment value for a child node at the corresponding index
   setChild(index: number, child: Uint8Array) {
+    // Updates the commitment to the child node at `index`
     this.children[index] = child
-    // TODO: Update commitment as well
   }
 
   static fromRawNode(
@@ -66,35 +66,28 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     return node
   }
 
+  /**
+   *
+   * @param index The index in the children array to retrieve the child node commitment from
+   * @returns the commitment for the child node at the `index` position in the children array
+   */
   getChildren(index: number): Uint8Array | null {
     return this.children?.[index] ?? null
   }
 
-  insert(
-    key: Uint8Array,
-    value: Uint8Array,
-    resolver: () => void,
-    verkleCrypto?: VerkleCrypto
-  ): void {
+  insert(key: Uint8Array, value: Uint8Array, resolver: () => void): void {
     const values = new Array<Uint8Array>(NODE_WIDTH)
     values[key[31]] = value
-    this.insertStem(key.slice(0, 31), values, resolver, verkleCrypto!)
+    this.insertStem(key.slice(0, 31), values, resolver)
   }
 
-  insertStem(
-    stem: Uint8Array,
-    values: Uint8Array[],
-    resolver: () => void,
-    verkleCrypto: VerkleCrypto
-  ): void {
+  insertStem(stem: Uint8Array, values: Uint8Array[], resolver: () => void): 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)
       }
@@ -111,18 +104,18 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
       const nextByteInInsertedKey = stem[this.depth + 1]
       if (nextByteInInsertedKey === nextByteInExistingKey) {
-        return newBranch.insertStem(stem, values, resolver, verkleCrypto)
+        return newBranch.insertStem(stem, values, resolver)
       }
 
       // Next word differs, so this was the last level.
       // Insert it directly into its final slot.
       // TODO: Fix this following `trie.put` logic
-      let leafCommitment = verkleCrypto.zeroCommitment
-      let c1 = verkleCrypto.zeroCommitment
-      let c2 = verkleCrypto.zeroCommitment
+      let leafCommitment = this.verkleCrypto.zeroCommitment
+      let c1 = this.verkleCrypto.zeroCommitment
+      let c2 = this.verkleCrypto.zeroCommitment
       for (const [idx, value] of values.entries()) {
         if (bytesToBigInt(value) > BIGINT_0) {
-          leafCommitment = verkleCrypto.updateCommitment(
+          leafCommitment = this.verkleCrypto.updateCommitment(
             leafCommitment,
             idx,
             new Uint8Array(32),
@@ -130,9 +123,9 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
           )
           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)
+            c1 = this.verkleCrypto.updateCommitment(c1, idx * 2, new Uint8Array(32), value)
           } else {
-            c2 = verkleCrypto.updateCommitment(c2, (idx - 128) * 2, new Uint8Array(32), value)
+            c2 = this.verkleCrypto.updateCommitment(c2, (idx - 128) * 2, new Uint8Array(32), value)
           }
         }
       }
@@ -153,13 +146,12 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       newBranch.children[nextByteInInsertedKey] = leafNode
     } else if (child instanceof InternalNode) {
       this.cowChild(childIndex)
-      return child.insertStem(stem, values, resolver, verkleCrypto)
+      return child.insertStem(stem, values, resolver)
     } else {
       throw new Error('Invalid node type')
     }
   }
 
-  // TODO: go-verkle also adds the bitlist to the raw format.
   raw(): Uint8Array[] {
     return [new Uint8Array([VerkleNodeType.Internal]), ...this.children, this.commitment]
   }
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index adecd2db7e..6cfd99f506 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -52,7 +52,6 @@ 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]
     const c2 = rawNode[4]
diff --git a/packages/verkle/src/node/types.ts b/packages/verkle/src/node/types.ts
index 90af9aa37a..d02d4b38ce 100644
--- a/packages/verkle/src/node/types.ts
+++ b/packages/verkle/src/node/types.ts
@@ -16,7 +16,7 @@ export type VerkleNode = TypedVerkleNode[VerkleNodeType]
 
 export interface VerkleNodeInterface {
   commit(): Uint8Array
-  hash(verkleCrypto: VerkleCrypto): any
+  hash(): any
   serialize(): Uint8Array
 }
 
diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
index c0cfe50ec6..c227c8ed3f 100644
--- a/packages/verkle/src/node/util.ts
+++ b/packages/verkle/src/node/util.ts
@@ -33,7 +33,7 @@ export function isRawNode(node: Uint8Array | Uint8Array[]): node is Uint8Array[]
 /***
  * Converts 128 32byte values of a leaf node into 16 byte values for generating a commitment for half of a
  * leaf node's values
- * @param values - an array of Uint8Arrays representing the first or second 128 values stored by verkle trie leaf node
+ * @param values - an array of Uint8Arrays representing the first or second set of 128 values stored by the verkle trie leaf node
  * @param deletedValues - an array of booleans where a value of true at a given position indicates a value
  * that is being deleted - should always be false if generating C2 values
  * Returns an array of 256 16byte UintArrays with the leaf marker set for each value that is deleted
@@ -43,7 +43,7 @@ export const createCValues = (values: Uint8Array[], deletedValues = new Array(12
     throw new Error(`got wrong number of values, expected 128, got ${values.length}`)
   const expandedValues: Uint8Array[] = new Array(256)
   for (let x = 0; x < 128; x++) {
-    // We add 16 trailing zeros to each value since all commitments are to an array of 32 byte values
+    // We add 16 trailing zeros to each value since all commitments are padded to an array of 32 byte values
     expandedValues[x] = setLengthRight(
       deletedValues[x] === true
         ? // TODO: Improve performance by only flipping the 129th bit of `expandedValues[x]` (instead of bigint addition)
diff --git a/packages/verkle/src/types.ts b/packages/verkle/src/types.ts
index cb60869129..196ad5b0a3 100644
--- a/packages/verkle/src/types.ts
+++ b/packages/verkle/src/types.ts
@@ -8,58 +8,6 @@ import type { VerkleCrypto as VerkleFFI } from 'verkle-cryptography-wasm'
 // Field representation of a commitment
 export interface Fr {}
 
-// TODO: Decide if we still need this interface.  Commitments are now all bytes from the JS perspective
-// Elliptic curve point representation of a commitment
-export interface Point {
-  // Bytes returns the compressed serialized version of the element.
-  bytes(): Uint8Array
-  // BytesUncompressed returns the uncompressed serialized version of the element.
-  bytesUncompressed(): Uint8Array
-
-  // SetBytes deserializes a compressed group element from buf.
-  // This method does all the proper checks assuming the bytes come from an
-  // untrusted source.
-  setBytes(bytes: Uint8Array): void
-
-  // SetBytesUncompressed deserializes an uncompressed group element from buf.
-  setBytesUncompressed(bytes: Uint8Array, trusted: boolean): void
-
-  // computes X/Y
-  mapToBaseField(): Point
-
-  // mapToScalarField maps a group element to the scalar field.
-  mapToScalarField(field: Fr): void
-
-  // Equal returns true if p and other represent the same point.
-  equal(secondPoint: Point): boolean
-
-  // SetIdentity sets p to the identity element.
-  setIdentity(): Point
-
-  // Double sets p to 2*p1.
-  double(point1: Point): Point
-
-  // Add sets p to p1+p2.
-  add(point1: Point, point2: Point): Point
-
-  // Sub sets p to p1-p2.
-  sub(point1: Point, point2: Point): Point
-
-  // IsOnCurve returns true if p is on the curve.
-  isOnCurve(): boolean
-
-  normalise(): void
-
-  // Set sets p to p1.
-  set(): Point
-
-  // Neg sets p to -p1.
-  neg(): Point
-
-  // ScalarMul sets p to p1*s.
-  scalarMul(point1: Point, scalarMont: Fr): Point
-}
-
 export type Proof = Uint8Array[]
 
 export interface VerkleTreeOpts {
diff --git a/packages/verkle/src/util/keys.ts b/packages/verkle/src/util/keys.ts
index 858b5a49bc..ca3fd7296d 100644
--- a/packages/verkle/src/util/keys.ts
+++ b/packages/verkle/src/util/keys.ts
@@ -96,5 +96,5 @@ export const getTreeKeyForStorageSlot = async (
 }
 
 export const verifyKeyLength = (key: Uint8Array) => {
-  if (key.length !== 32) throw new Error(`expected key with length 32l; got ${key.length}`)
+  if (key.length !== 32) throw new Error(`expected key with length 32; got ${key.length}`)
 }

From 52d50a84145491422dc06b4fc67c445f84bdc65e Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 7 Jun 2024 16:13:40 -0400
Subject: [PATCH 17/51] WIP [no ci]

---
 packages/verkle/src/node/internalNode.ts | 26 ++++++++--------
 packages/verkle/src/verkleTree.ts        | 38 ++++++++++++++++--------
 2 files changed, 40 insertions(+), 24 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index d887c22d08..64e8e21951 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -10,29 +10,33 @@ import { NODE_WIDTH, VerkleNodeType } from './types.js'
 import type { VerkleNodeOptions } from './types.js'
 
 export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
-  // Array of commitments to child nodes
+  // Array of uncompressed commitments (i.e. 64 byte Uint8Arrays) to child nodes
   public children: Uint8Array[]
-  public copyOnWrite: Record<string, Uint8Array>
   public type = VerkleNodeType.Internal
 
   constructor(options: VerkleNodeOptions[VerkleNodeType.Internal]) {
     super(options)
-    this.children = options.children ?? zeroValues
-    this.copyOnWrite = options.copyOnWrite ?? {}
+    this.children = options.children ?? new Array(64).fill(new Uint8Array(64))
   }
 
   commit(): Uint8Array {
     throw new Error('Not implemented')
   }
 
-  cowChild(_: number): void {
-    // Not implemented yet
-  }
-
   // Updates the commitment value for a child node at the corresponding index
   setChild(index: number, child: Uint8Array) {
+    // Get previous child commitment at `index`
+    const oldChild = this.children[index]
     // Updates the commitment to the child node at `index`
     this.children[index] = child
+    // Updates the overall node commitment based on the update to this child
+    this.commitment = this.verkleCrypto.updateCommitment(
+      this.commitment,
+      index,
+      // The hashed child commitments are used when updating the internal node commitment
+      this.verkleCrypto.hashCommitment(oldChild),
+      this.verkleCrypto.hashCommitment(child)
+    )
   }
 
   static fromRawNode(
@@ -50,7 +54,6 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       throw new Error('Invalid node length')
     }
 
-    // TODO: Generate Point from rawNode value
     const commitment = rawNode[rawNode.length - 1]
 
     return new InternalNode({ commitment, depth, verkleCrypto })
@@ -72,7 +75,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
    * @returns the commitment for the child node at the `index` position in the children array
    */
   getChildren(index: number): Uint8Array | null {
-    return this.children?.[index] ?? null
+    return this.children[index]
   }
 
   insert(key: Uint8Array, value: Uint8Array, resolver: () => void): void {
@@ -81,6 +84,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     this.insertStem(key.slice(0, 31), values, resolver)
   }
 
+  // TODO: Determine how this function is used and if we need it
   insertStem(stem: Uint8Array, values: Uint8Array[], resolver: () => void): void {
     // Index of the child pointed by the next byte in the key
     const childIndex = stem[this.depth]
@@ -97,7 +101,6 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       // the moved leaf node can occur.
       const nextByteInExistingKey = child.stem[this.depth + 1]
       const newBranch = InternalNode.create(this.depth + 1, this.verkleCrypto)
-      newBranch.cowChild(nextByteInExistingKey)
       this.children[childIndex] = newBranch.commitment
       newBranch.children[nextByteInExistingKey] = child
       child.depth += 1
@@ -142,7 +145,6 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
       // 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)
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 29018276a8..aa8083eaaf 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -162,7 +162,9 @@ export class VerkleTree {
    * @returns A Promise that resolves to `Uint8Array` if a value was found or `null` if no value was found.
    */
   async get(key: Uint8Array): Promise<Uint8Array | null> {
-    verifyKeyLength(key)
+    // TODO: Determine if we actually need to do this check.  The key for an internal node will necessarily
+    // be less than 32 bytes since it's the path to that node in the trie
+    // verifyKeyLength(key)
     const nodeRLP = await this._db.get(key)
     if (nodeRLP === undefined) return null
     // We first retrieve the node and decode it
@@ -173,14 +175,13 @@ export class VerkleTree {
           LeafNode.fromRawNode(rawNode, 1, this.verkleCrypto)
         : InternalNode.fromRawNode(rawNode, 1, this.verkleCrypto)
 
-    if (node instanceof LeafNode)
-      if (node instanceof LeafNode) {
-        const keyLastByte = key[key.length - 1]
+    if (node instanceof LeafNode) {
+      const keyLastByte = key[key.length - 1]
 
-        // The retrieved leaf node contains an array of 256 possible values.
-        // The index of the value we want is at the key's last byte
-        return node.values?.[keyLastByte] ?? null
-      }
+      // The retrieved leaf node contains an array of 256 possible values.
+      // The index of the value we want is at the key's last byte
+      return node.values?.[keyLastByte] ?? null
+    }
 
     return null
   }
@@ -219,7 +220,7 @@ export class VerkleTree {
         new Uint8Array(32),
         cValues[commitmentIndex]
       )
-      // Update thecommitment for the second 16 bytes of the value
+      // Update the commitment for the second 16 bytes of the value
       cCommitment = this.verkleCrypto.updateCommitment(
         cCommitment,
         commitmentIndex + 1,
@@ -277,10 +278,23 @@ export class VerkleTree {
     let currentDepth = leafNode.depth
 
     while (currentDepth > 0) {
-      const parentKey = currentKey.slice(0, -1)
       const parentIndex = currentKey[currentKey.length - 1]
-      const parentNode = InternalNode.create(currentDepth, this.verkleCrypto)
-      parentNode.children[parentIndex] = currentNode
+      // Parent key should be at least one shorter than the current key length
+      const parentKey = currentKey.slice(0, currentKey.length - 1)
+      const rawNode = await this.get(parentKey)
+      let parentNode
+      // TODO: Determine how to decide if we need to go further up the tree or create a new internal node here
+      // Currently, this code would insert a new internal node at every step up the trie (which we don't want)
+      if (rawNode !== null) {
+        parentNode = InternalNode.fromRawNode(
+          RLP.decode(rawNode) as Uint8Array[],
+          currentDepth,
+          this.verkleCrypto
+        )
+      } else {
+        parentNode = InternalNode.create(currentDepth, this.verkleCrypto)
+      }
+      parentNode.setChild(parentIndex, currentNode.commitment)
       await this._db.put(parentKey, parentNode.serialize())
 
       currentNode = parentNode

From 86dd9e989e9cbeebfd5165226190d5445b98ffea Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 10 Jun 2024 15:47:18 -0400
Subject: [PATCH 18/51] Finish naive findpath implementation

---
 packages/verkle/src/node/internalNode.ts |   4 +-
 packages/verkle/src/node/util.ts         |  17 ++-
 packages/verkle/src/verkleTree.ts        | 164 ++++++++++++-----------
 packages/verkle/test/verkle.spec.ts      |   6 +-
 4 files changed, 101 insertions(+), 90 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 64e8e21951..6a81087eb2 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -16,7 +16,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
   constructor(options: VerkleNodeOptions[VerkleNodeType.Internal]) {
     super(options)
-    this.children = options.children ?? new Array(64).fill(new Uint8Array(64))
+    this.children = options.children ?? new Array(256).fill(new Uint8Array(64))
   }
 
   commit(): Uint8Array {
@@ -72,7 +72,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
   /**
    *
    * @param index The index in the children array to retrieve the child node commitment from
-   * @returns the commitment for the child node at the `index` position in the children array
+   * @returns the uncompressed 64byte commitment for the child node at the `index` position in the children array
    */
   getChildren(index: number): Uint8Array | null {
     return this.children[index]
diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
index c227c8ed3f..2949fc357a 100644
--- a/packages/verkle/src/node/util.ts
+++ b/packages/verkle/src/node/util.ts
@@ -5,25 +5,30 @@ import { InternalNode } from './internalNode.js'
 import { LeafNode } from './leafNode.js'
 import { type VerkleNode, VerkleNodeType } from './types.js'
 
-export function decodeRawNode(raw: Uint8Array[]): VerkleNode {
+import type { VerkleCrypto } from '../types.js'
+
+export function decodeRawNode(
+  raw: Uint8Array[],
+  depth: number,
+  verkleCrypto: VerkleCrypto
+): VerkleNode {
   const nodeType = raw[0][0]
-  const depth = 0
   switch (nodeType) {
     case VerkleNodeType.Internal:
-      return InternalNode.fromRawNode(raw, depth)
+      return InternalNode.fromRawNode(raw, depth, verkleCrypto)
     case VerkleNodeType.Leaf:
-      return LeafNode.fromRawNode(raw, depth)
+      return LeafNode.fromRawNode(raw, depth, verkleCrypto)
     default:
       throw new Error('Invalid node type')
   }
 }
 
-export function decodeNode(raw: Uint8Array) {
+export function decodeNode(raw: Uint8Array, depth: number, verkleCrypto: VerkleCrypto) {
   const decoded = RLP.decode(Uint8Array.from(raw)) as Uint8Array[]
   if (!Array.isArray(decoded)) {
     throw new Error('Invalid node')
   }
-  return decodeRawNode(decoded)
+  return decodeRawNode(decoded, depth, verkleCrypto)
 }
 
 export function isRawNode(node: Uint8Array | Uint8Array[]): node is Uint8Array[] {
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index aa8083eaaf..df7eb73d43 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -162,9 +162,7 @@ export class VerkleTree {
    * @returns A Promise that resolves to `Uint8Array` if a value was found or `null` if no value was found.
    */
   async get(key: Uint8Array): Promise<Uint8Array | null> {
-    // TODO: Determine if we actually need to do this check.  The key for an internal node will necessarily
-    // be less than 32 bytes since it's the path to that node in the trie
-    // verifyKeyLength(key)
+    verifyKeyLength(key)
     const nodeRLP = await this._db.get(key)
     if (nodeRLP === undefined) return null
     // We first retrieve the node and decode it
@@ -269,7 +267,7 @@ export class VerkleTree {
         c2,
         this.verkleCrypto
       )
-      await this._db.put(leafNode.hash(), leafNode.serialize())
+      await this._db.put(key, leafNode.serialize())
     }
 
     // Walk up the tree and update internal nodes
@@ -278,22 +276,28 @@ export class VerkleTree {
     let currentDepth = leafNode.depth
 
     while (currentDepth > 0) {
-      const parentIndex = currentKey[currentKey.length - 1]
-      // Parent key should be at least one shorter than the current key length
-      const parentKey = currentKey.slice(0, currentKey.length - 1)
-      const rawNode = await this.get(parentKey)
-      let parentNode
+      let rawNode: Uint8Array | undefined
+      let parentIndex = currentKey[currentKey.length - 1]
+      let parentKey = currentKey.slice(0, currentKey.length - 1)
+      while (!(rawNode instanceof Uint8Array)) {
+        parentIndex = currentKey[currentKey.length - 1]
+        // Parent key should be at least one shorter than the current key length
+        parentKey = currentKey.slice(0, currentKey.length - 1)
+        // Try to retrieve parent node - going back up the path one byte at a time
+        rawNode = await this._db.get(parentKey)
+        if (rawNode === null) continue
+      }
       // TODO: Determine how to decide if we need to go further up the tree or create a new internal node here
       // Currently, this code would insert a new internal node at every step up the trie (which we don't want)
-      if (rawNode !== null) {
-        parentNode = InternalNode.fromRawNode(
-          RLP.decode(rawNode) as Uint8Array[],
-          currentDepth,
-          this.verkleCrypto
-        )
-      } else {
-        parentNode = InternalNode.create(currentDepth, this.verkleCrypto)
-      }
+      // if (rawNode !== null) {
+      const parentNode = InternalNode.fromRawNode(
+        RLP.decode(rawNode) as Uint8Array[],
+        currentDepth,
+        this.verkleCrypto
+      )
+      // } else {
+      //   parentNode = InternalNode.create(currentDepth, this.verkleCrypto)
+      // }
       parentNode.setChild(parentIndex, currentNode.commitment)
       await this._db.put(parentKey, parentNode.serialize())
 
@@ -311,60 +315,57 @@ export class VerkleTree {
    * @param key - the search key
    * @param throwIfMissing - if true, throws if any nodes are missing. Used for verifying proofs. (default: false)
    */
-  async findPath(key: Uint8Array, throwIfMissing = false): Promise<Path> {
-    // eslint-disable-next-line no-async-promise-executor
-    return new Promise(async (resolve, reject) => {
-      const stack: VerkleNode[] = []
-
-      const onFound: FoundNodeFunction = async (_, node, keyProgress, walkController) => {
-        if (node === null) {
-          return reject(new Error('Path not found'))
-        }
-        const keyRemainder = key.slice(matchingBytesLength(keyProgress, key))
-        stack.push(node)
-
-        if (node instanceof InternalNode) {
-          if (keyRemainder.length === 0) {
-            // we exhausted the key without finding a node
-            resolve({ node, remaining: new Uint8Array(0), stack })
-          } else {
-            const childrenIndex = keyRemainder[0]
-            const childNode = node.getChildren(childrenIndex)
-            if (childNode === null) {
-              // There are no more nodes to find and we didn't find the key
-              resolve({ node: null, remaining: keyRemainder, stack })
-            } else {
-              // node found, continue search from children
-              walkController.pushChildrenAtIndex(node, keyProgress, childrenIndex)
-            }
-          }
-        } else if (node instanceof LeafNode) {
-          // The stem of the leaf node should be the full key minus the last byte
-          const stem = key.slice(0, key.length - 1)
-          if (equalsBytes(stem, node.stem)) {
-            // keys match, return node with empty key
-            resolve({ node, remaining: new Uint8Array(0), stack })
-          } else {
-            // reached leaf but keys don't match
-            resolve({ node: null, remaining: keyRemainder, stack })
-          }
-        }
-      }
+  async findPath(key: Uint8Array): Promise<Path> {
+    const result: Path = {
+      node: null,
+      stack: [],
+      remaining: key,
+    }
+    if (equalsBytes(this.root(), this.EMPTY_TREE_ROOT)) return result
+
+    // Check to see if desired node is available
+    let rawNode = await this._db.get(key)
+    let targetNodeBytes: Uint8Array[] = []
+    if (rawNode !== undefined) {
+      // Store target node bytes for deccoding later
+      targetNodeBytes = RLP.decode(rawNode) as Uint8Array[]
+    }
 
-      // walk tree and process nodes
-      try {
-        await this.walkTree(this.root(), onFound)
-      } catch (error: any) {
-        if (error.message === 'Missing node in DB' && !throwIfMissing) {
-          // pass
-        } else {
-          reject(error)
-        }
+    let parentKey = key.slice(0, key.length - 1)
+    rawNode = await this._db.get(parentKey)
+    const stack = []
+    // We walk up the parent key from the end of the key to the root
+    while (parentKey.length > 0) {
+      // Try to retrieve parent node - going back up the path one byte at a time
+      rawNode = await this._db.get(parentKey)
+      if (rawNode === undefined) {
+        parentKey = parentKey.slice(0, parentKey.length - 1)
+        continue
       }
-
-      // Resolve if walkTree finishes without finding any nodes
-      resolve({ node: null, remaining: new Uint8Array(0), stack })
-    })
+      const decodedNode = RLP.decode(rawNode) as Uint8Array[]
+      // Store node RLP and its corresponding path for later
+      stack.push([decodedNode, parentKey])
+      parentKey = parentKey.slice(0, parentKey.length - 1)
+    }
+    // Convert RLP of path nodes to stack of verkle nodes
+    result.stack = stack.map((node, idx) =>
+      decodeRawNode(node[0] as Uint8Array[], idx, this.verkleCrypto)
+    )
+    if (targetNodeBytes.length === 0) {
+      if (stack.length === 0) {
+        // Return entire key if no nodes found in trie
+        result.remaining = key
+      } else {
+        // Get path/key of first node in stack which is the node closest to the sought node
+        const lastKey = stack[0][1] as Uint8Array
+        const lastIndex = matchingBytesLength(lastKey, key)
+        result.remaining = key.slice(lastIndex)
+      }
+    } else {
+      result.remaining = new Uint8Array()
+      result.node = decodeRawNode(targetNodeBytes, result.stack.length, this.verkleCrypto)
+    }
+    return result
   }
 
   /**
@@ -383,7 +384,7 @@ export class VerkleTree {
    * @param throwIfMissing - if true, throws if any nodes are missing. Used for verifying proofs. (default: false)
    */
   async findLeafNode(key: Uint8Array, throwIfMissing = false): Promise<LeafNode | VerkleNode[]> {
-    const { node, stack } = await this.findPath(key, throwIfMissing)
+    const { node, stack } = await this.findPath(key)
     if (!(node instanceof LeafNode)) {
       if (throwIfMissing) {
         throw new Error('leaf node not found')
@@ -406,16 +407,17 @@ export class VerkleTree {
    * Retrieves a node from db by hash.
    */
   async lookupNode(node: Uint8Array | Uint8Array[]): Promise<VerkleNode | null> {
-    if (isRawNode(node)) {
-      return decodeRawNode(node)
-    }
-    const value = await this._db.get(node)
-    if (value !== undefined) {
-      return decodeNode(value)
-    } else {
-      // Dev note: this error message text is used for error checking in `checkRoot`, `verifyProof`, and `findPath`
-      throw new Error('Missing node in DB')
-    }
+    throw new Error('not implemented')
+    // if (isRawNode(node)) {
+    //   return decodeRawNode(node)
+    // }
+    // const value = await this._db.get(node)
+    // if (value !== undefined) {
+    //   return decodeNode(value)
+    // } else {
+    //   // Dev note: this error message text is used for error checking in `checkRoot`, `verifyProof`, and `findPath`
+    //   throw new Error('Missing node in DB')
+    // }
   }
 
   /**
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 332aae0008..eb48180978 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -2,6 +2,7 @@ import { MapDB, equalsBytes, hexToBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, describe, it } from 'vitest'
 
+import { LeafNode } from '../src/index.js'
 import { VerkleTree } from '../src/verkleTree.js'
 
 import type { PrefixedHexString } from '@ethereumjs/util'
@@ -47,13 +48,14 @@ const absentKeys = [
 ].map((key) => hexToBytes(key as PrefixedHexString))
 
 describe('Verkle tree', () => {
-  it.only('should insert and retrieve values', async () => {
+  it('should insert and retrieve values', async () => {
     const verkleCrypto = await loadVerkleCrypto()
     const tree = await VerkleTree.create({
       verkleCrypto,
     })
     const db = new MapDB<Uint8Array, Uint8Array>()
     tree.database(db)
+
     for (let i = 0; i < presentKeys.length; i++) {
       await tree.put(presentKeys[i], values[i])
     }
@@ -64,5 +66,7 @@ describe('Verkle tree', () => {
       }
       assert.ok(equalsBytes(retrievedValue, values[i]))
     }
+    const path = await tree.findPath(presentKeys[0])
+    assert.ok(path.node instanceof LeafNode)
   })
 })

From 189b112c44678a6b137e2e2a3444cbad37a3ce15 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Tue, 11 Jun 2024 15:09:24 -0400
Subject: [PATCH 19/51] Update internal node layout

---
 packages/verkle/src/node/internalNode.ts  | 42 ++++++++++++++++-------
 packages/verkle/test/internalNode.spec.ts | 25 ++++++++------
 2 files changed, 45 insertions(+), 22 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 6a81087eb2..de31908d2b 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -9,14 +9,23 @@ import { NODE_WIDTH, VerkleNodeType } from './types.js'
 
 import type { VerkleNodeOptions } from './types.js'
 
+export interface ChildNode {
+  commitment: Uint8Array // 64 byte commitment to child node
+  path: Uint8Array // path/partial stem to child node (used as DB key)
+}
 export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
-  // Array of uncompressed commitments (i.e. 64 byte Uint8Arrays) to child nodes
-  public children: Uint8Array[]
+  // Array of tuples of uncompressed commitments (i.e. 64 byte Uint8Arrays) to child nodes along with the path to that child (i.e. the partial stem)
+  public children: Array<ChildNode>
   public type = VerkleNodeType.Internal
 
   constructor(options: VerkleNodeOptions[VerkleNodeType.Internal]) {
     super(options)
-    this.children = options.children ?? new Array(256).fill(new Uint8Array(64))
+    this.children =
+      options.children ??
+      new Array(256).fill({
+        commitment: options.verkleCrypto.zeroCommitment,
+        path: new Uint8Array(),
+      })
   }
 
   commit(): Uint8Array {
@@ -24,7 +33,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
   }
 
   // Updates the commitment value for a child node at the corresponding index
-  setChild(index: number, child: Uint8Array) {
+  setChild(index: number, child: ChildNode) {
     // Get previous child commitment at `index`
     const oldChild = this.children[index]
     // Updates the commitment to the child node at `index`
@@ -34,8 +43,8 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       this.commitment,
       index,
       // The hashed child commitments are used when updating the internal node commitment
-      this.verkleCrypto.hashCommitment(oldChild),
-      this.verkleCrypto.hashCommitment(child)
+      this.verkleCrypto.hashCommitment(oldChild.commitment),
+      this.verkleCrypto.hashCommitment(child.commitment)
     )
   }
 
@@ -61,7 +70,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
   static create(depth: number, verkleCrypto: VerkleCrypto): InternalNode {
     const node = new InternalNode({
-      commitment: POINT_IDENTITY,
+      commitment: verkleCrypto.zeroCommitment,
       depth,
       verkleCrypto,
     })
@@ -74,7 +83,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
    * @param index The index in the children array to retrieve the child node commitment from
    * @returns the uncompressed 64byte commitment for the child node at the `index` position in the children array
    */
-  getChildren(index: number): Uint8Array | null {
+  getChildren(index: number): ChildNode | null {
     return this.children[index]
   }
 
@@ -101,7 +110,10 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       // the moved leaf node can occur.
       const nextByteInExistingKey = child.stem[this.depth + 1]
       const newBranch = InternalNode.create(this.depth + 1, this.verkleCrypto)
-      this.children[childIndex] = newBranch.commitment
+      this.children[childIndex] = {
+        commitment: newBranch.commitment,
+        path: child.stem.slice(0, this.depth + 1),
+      }
       newBranch.children[nextByteInExistingKey] = child
       child.depth += 1
 
@@ -145,9 +157,11 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
 
       // TODO - Why is the leaf node set at depth + 2 instead of + 1)?
       leafNode.setDepth(this.depth + 2)
-      newBranch.children[nextByteInInsertedKey] = leafNode
+      newBranch.children[nextByteInInsertedKey] = {
+        commitment: leafNode.commitment,
+        path: leafNode.stem,
+      }
     } else if (child instanceof InternalNode) {
-      this.cowChild(childIndex)
       return child.insertStem(stem, values, resolver)
     } else {
       throw new Error('Invalid node type')
@@ -155,6 +169,10 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
   }
 
   raw(): Uint8Array[] {
-    return [new Uint8Array([VerkleNodeType.Internal]), ...this.children, this.commitment]
+    return [
+      new Uint8Array([VerkleNodeType.Internal]),
+      ...this.children.map((child) => child.commitment),
+      this.commitment,
+    ]
   }
 }
diff --git a/packages/verkle/test/internalNode.spec.ts b/packages/verkle/test/internalNode.spec.ts
index 826006aa95..ad4fceee36 100644
--- a/packages/verkle/test/internalNode.spec.ts
+++ b/packages/verkle/test/internalNode.spec.ts
@@ -1,15 +1,22 @@
 import { equalsBytes, randomBytes } from '@ethereumjs/util'
-import { assert, describe, it } from 'vitest'
+import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
+import { assert, beforeAll, describe, it } from 'vitest'
 
 import { NODE_WIDTH, VerkleNodeType } from '../src/node/index.js'
 import { InternalNode } from '../src/node/internalNode.js'
 import { POINT_IDENTITY } from '../src/util/crypto.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 })
+    const node = new InternalNode({ commitment, depth, verkleCrypto })
 
     assert.equal(node.type, VerkleNodeType.Internal, 'type should be set')
     assert.ok(
@@ -21,21 +28,19 @@ describe('verkle node - internal', () => {
     // Children nodes should all default to null.
     assert.equal(node.children.length, NODE_WIDTH, 'number of children should equal verkle width')
     assert.ok(
-      node.children.every((child) => child === null),
+      node.children.every((child) => equalsBytes(child.commitment, verkleCrypto.zeroCommitment)),
       'every children should be null'
     )
   })
 
   it('create method should create an internal node', async () => {
     const depth = 3
-    const node = InternalNode.create(depth)
+    const node = InternalNode.create(depth, verkleCrypto)
 
     assert.equal(node.type, VerkleNodeType.Internal, 'type should be set')
-    assert.ok(
-      equalsBytes(
-        node.commitment as unknown as Uint8Array,
-        POINT_IDENTITY as unknown as Uint8Array
-      ),
+    assert.deepEqual(
+      node.commitment,
+      verkleCrypto.zeroCommitment,
       'commitment should be set to point identity'
     )
     assert.equal(node.depth, depth, 'depth should be set')
@@ -43,7 +48,7 @@ describe('verkle node - internal', () => {
     // Children nodes should all default to null.
     assert.equal(node.children.length, NODE_WIDTH, 'number of children should equal verkle width')
     assert.ok(
-      node.children.every((child) => child === null),
+      node.children.every((child) => equalsBytes(child.commitment, verkleCrypto.zeroCommitment)),
       'every children should be null'
     )
   })

From 60219ae52013d32db3fac119662c26f68d407e99 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Tue, 11 Jun 2024 17:07:15 -0400
Subject: [PATCH 20/51] WIP [no ci]

---
 packages/verkle/src/node/internalNode.ts  |   3 +-
 packages/verkle/src/verkleTree.ts         | 136 ++++++++++++++--------
 packages/verkle/test/internalNode.spec.ts |   1 -
 packages/verkle/test/verkle.spec.ts       |  43 ++++---
 4 files changed, 118 insertions(+), 65 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index de31908d2b..cb547a0fc9 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -1,7 +1,6 @@
 import { BIGINT_0, bytesToBigInt, equalsBytes } from '@ethereumjs/util'
 
-import { type VerkleCrypto, zeroValues } from '../types.js'
-import { POINT_IDENTITY } from '../util/crypto.js'
+import { type VerkleCrypto } from '../types.js'
 
 import { BaseVerkleNode } from './baseVerkleNode.js'
 import { LeafNode } from './leafNode.js'
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index df7eb73d43..2ddee652e8 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -3,6 +3,7 @@ import {
   KeyEncoding,
   Lock,
   ValueEncoding,
+  bytesToHex,
   equalsBytes,
   intToBytes,
   setLengthLeft,
@@ -15,7 +16,7 @@ import { CheckpointDB } from './db/checkpoint.js'
 import { InternalNode } from './node/internalNode.js'
 import { LeafNode } from './node/leafNode.js'
 import { type VerkleNode, VerkleNodeType } from './node/types.js'
-import { createCValues, decodeNode, decodeRawNode, isRawNode } from './node/util.js'
+import { createCValues, decodeRawNode } from './node/util.js'
 import {
   type Proof,
   ROOT_DB_KEY,
@@ -99,12 +100,16 @@ export class VerkleTree {
       }
     }
 
-    if (opts === undefined) {
-      opts = {
-        verkleCrypto: loadVerkleCrypto,
+    if (opts?.verkleCrypto === undefined) {
+      const verkleCrypto = await loadVerkleCrypto()
+      if (opts === undefined)
+        opts = {
+          verkleCrypto,
+        }
+      else {
+        opts.verkleCrypto = verkleCrypto
       }
     }
-    opts.verkleCrypto = await loadVerkleCrypto()
 
     return new VerkleTree(opts)
   }
@@ -173,6 +178,8 @@ export class VerkleTree {
           LeafNode.fromRawNode(rawNode, 1, this.verkleCrypto)
         : InternalNode.fromRawNode(rawNode, 1, this.verkleCrypto)
 
+    // TODO: Decide if we needt this check since this should always be a leaf node
+    // since internal nodes should have never have a key/stem of 31 bytes
     if (node instanceof LeafNode) {
       const keyLastByte = key[key.length - 1]
 
@@ -195,7 +202,8 @@ export class VerkleTree {
     verifyKeyLength(key)
 
     // Find or create the leaf node
-    let leafNode = await this.findLeafNode(key, false)
+    const res = await this.findPath(key)
+    let leafNode = res.node
     if (!(leafNode instanceof LeafNode)) {
       // If leafNode is missing, create it
       const values: Uint8Array[] = new Array(256).fill(new Uint8Array()) // Create new empty array of 256 values
@@ -261,7 +269,7 @@ export class VerkleTree {
       leafNode = LeafNode.create(
         key.slice(0, 31),
         values,
-        leafNode.length,
+        res.stack.length + 1,
         commitment,
         c1,
         c2,
@@ -271,7 +279,30 @@ export class VerkleTree {
     }
 
     // Walk up the tree and update internal nodes
-    let currentNode: VerkleNode = leafNode
+    if (res.stack.length === 0) {
+      // Special case where findPath returned early because no root node exists
+      // Create a root node
+      const rootNode = new InternalNode({
+        commitment: this.verkleCrypto.zeroCommitment,
+        depth: 0,
+        verkleCrypto: this.verkleCrypto,
+      })
+      // Update the child node's commitment and path
+      rootNode.children[key[0]].commitment = leafNode.commitment
+      rootNode.children[key[0]].path = key
+      // Update root node commitment
+      this.verkleCrypto.updateCommitment(
+        rootNode.commitment,
+        key[0],
+        new Uint8Array(32),
+        this.verkleCrypto.hashCommitment(leafNode.commitment)
+      )
+      // Put root node in DB
+      await this._db.put(ROOT_DB_KEY, rootNode.serialize())
+      // We're done so return early
+      return
+    }
+    let currentNode: VerkleNode = res.stack[res.stack.length - 1]
     let currentKey = leafNode.stem
     let currentDepth = leafNode.depth
 
@@ -298,7 +329,7 @@ export class VerkleTree {
       // } else {
       //   parentNode = InternalNode.create(currentDepth, this.verkleCrypto)
       // }
-      parentNode.setChild(parentIndex, currentNode.commitment)
+      parentNode.setChild(parentIndex, { commitment: currentNode.commitment, path: parentKey })
       await this._db.put(parentKey, parentNode.serialize())
 
       currentNode = parentNode
@@ -323,47 +354,54 @@ export class VerkleTree {
     }
     if (equalsBytes(this.root(), this.EMPTY_TREE_ROOT)) return result
 
-    // Check to see if desired node is available
-    let rawNode = await this._db.get(key)
-    let targetNodeBytes: Uint8Array[] = []
-    if (rawNode !== undefined) {
-      // Store target node bytes for deccoding later
-      targetNodeBytes = RLP.decode(rawNode) as Uint8Array[]
-    }
-
-    let parentKey = key.slice(0, key.length - 1)
-    rawNode = await this._db.get(parentKey)
-    const stack = []
-    // We walk up the parent key from the end of the key to the root
-    while (parentKey.length > 0) {
-      // Try to retrieve parent node - going back up the path one byte at a time
-      rawNode = await this._db.get(parentKey)
-      if (rawNode === undefined) {
-        parentKey = parentKey.slice(0, parentKey.length - 1)
-        continue
-      }
-      const decodedNode = RLP.decode(rawNode) as Uint8Array[]
-      // Store node RLP and its corresponding path for later
-      stack.push([decodedNode, parentKey])
-      parentKey = parentKey.slice(0, parentKey.length - 1)
-    }
-    // Convert RLP of path nodes to stack of verkle nodes
-    result.stack = stack.map((node, idx) =>
-      decodeRawNode(node[0] as Uint8Array[], idx, this.verkleCrypto)
-    )
-    if (targetNodeBytes.length === 0) {
-      if (stack.length === 0) {
-        // Return entire key if no nodes found in trie
-        result.remaining = key
-      } else {
-        // Get path/key of first node in stack which is the node closest to the sought node
-        const lastKey = stack[0][1] as Uint8Array
-        const lastIndex = matchingBytesLength(lastKey, key)
-        result.remaining = key.slice(lastIndex)
+    // Get root node
+    let rawNode = await this._db.get(ROOT_DB_KEY)
+    if (rawNode === undefined)
+      throw new Error('root node should exist when root not empty tree root')
+
+    const rootNode = decodeRawNode(
+      RLP.decode(rawNode) as Uint8Array[],
+      0,
+      this.verkleCrypto
+    ) as InternalNode
+
+    result.stack.push(rootNode)
+    let child = rootNode.children[key[0]]
+    // Root node doesn't contain a child node's commitment on the first byte of the path so we're done
+    if (child.commitment === this.verkleCrypto.zeroCommitment) return result
+    let finished = false
+    while (!finished) {
+      rawNode = await this._db.get(child.path)
+      // We should always find the node if the path is specified in child.path
+      if (rawNode === undefined) throw new Error(`missing node at ${bytesToHex(child.path)}`)
+      const decodedNode = decodeRawNode(
+        RLP.decode(rawNode) as Uint8Array[],
+        result.stack.length,
+        this.verkleCrypto
+      )
+      // Calculate the index of the last matching byte in the key
+      const matchingKeyLength = matchingBytesLength(key, child.path)
+      const foundNode = equalsBytes(key, child.path)
+      if (foundNode || child.path.length >= key.length || decodedNode instanceof LeafNode) {
+        // If the key and child.path are equal, then we found the node
+        // If the child.path is the same length or longer than the key but doesn't match it
+        // or the found node is a leaf node, we've found another node where this node should
+        // be if it existed in the trie
+        // i.e. the node doesn't exist in the trie
+        finished = true
+        if (foundNode) {
+          result.node = decodedNode
+          result.remaining = new Uint8Array()
+          return result
+        }
+        // We found a different node than the one specified by `key`
+        // so the sought node doesn't exist
+        result.remaining = key.slice(matchingKeyLength)
+        return result
       }
-    } else {
-      result.remaining = new Uint8Array()
-      result.node = decodeRawNode(targetNodeBytes, result.stack.length, this.verkleCrypto)
+      // Get the next child node in the path
+      const childIndex = key[matchingKeyLength]
+      child = decodedNode.children[childIndex]
     }
     return result
   }
diff --git a/packages/verkle/test/internalNode.spec.ts b/packages/verkle/test/internalNode.spec.ts
index ad4fceee36..c01497b29f 100644
--- a/packages/verkle/test/internalNode.spec.ts
+++ b/packages/verkle/test/internalNode.spec.ts
@@ -4,7 +4,6 @@ import { assert, beforeAll, describe, it } from 'vitest'
 
 import { NODE_WIDTH, VerkleNodeType } from '../src/node/index.js'
 import { InternalNode } from '../src/node/internalNode.js'
-import { POINT_IDENTITY } from '../src/util/crypto.js'
 
 import type { VerkleCrypto } from '../src/types.js'
 
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index eb48180978..080dd0fee0 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -1,8 +1,9 @@
+import { RLP } from '@ethereumjs/rlp'
 import { MapDB, equalsBytes, hexToBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, describe, it } from 'vitest'
 
-import { LeafNode } from '../src/index.js'
+import { InternalNode, LeafNode, ROOT_DB_KEY } from '../src/index.js'
 import { VerkleTree } from '../src/verkleTree.js'
 
 import type { PrefixedHexString } from '@ethereumjs/util'
@@ -55,18 +56,34 @@ describe('Verkle tree', () => {
     })
     const db = new MapDB<Uint8Array, Uint8Array>()
     tree.database(db)
+    // Insert a root node
+    await tree['_db'].put(
+      ROOT_DB_KEY,
+      new InternalNode({
+        commitment: verkleCrypto.zeroCommitment,
+        depth: 0,
+        verkleCrypto,
+      }).serialize()
+    )
+    const res = await tree.findPath(presentKeys[0])
 
-    for (let i = 0; i < presentKeys.length; i++) {
-      await tree.put(presentKeys[i], values[i])
-    }
-    for (let i = 0; i < presentKeys.length; i++) {
-      const retrievedValue = await tree.get(presentKeys[i])
-      if (retrievedValue === null) {
-        assert.fail('Value not found')
-      }
-      assert.ok(equalsBytes(retrievedValue, values[i]))
-    }
-    const path = await tree.findPath(presentKeys[0])
-    assert.ok(path.node instanceof LeafNode)
+    assert.ok(res.node === null, 'should not find a node when the key is not present')
+    assert.deepEqual(res.remaining, presentKeys[0])
+
+    await tree.put(presentKeys[0], values[0])
+    console.log(await tree.get(presentKeys[0]))
+    // for (let i = 0; i < presentKeys.length; i++) {
+    //   console.log('lets put a key')
+    //   await tree.put(presentKeys[i], values[i])
+    // }
+    // for (let i = 0; i < presentKeys.length; i++) {
+    //   const retrievedValue = await tree.get(presentKeys[i])
+    //   if (retrievedValue === null) {
+    //     assert.fail('Value not found')
+    //   }
+    //   assert.ok(equalsBytes(retrievedValue, values[i]))
+    // }
+    // const path = await tree.findPath(presentKeys[0])
+    // assert.ok(path.node instanceof LeafNode)
   })
 })

From bbd0e96f2ec45e2ba7c9821b3df7a0d48ab8d18b Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Tue, 11 Jun 2024 18:05:14 -0400
Subject: [PATCH 21/51] Partial implementation of put [no ci]

---
 packages/verkle/src/node/internalNode.ts  | 18 ++---
 packages/verkle/src/node/types.ts         |  6 +-
 packages/verkle/src/verkleTree.ts         | 86 +++++++++++++----------
 packages/verkle/test/internalNode.spec.ts | 19 ++++-
 packages/verkle/test/verkle.spec.ts       | 23 +++---
 5 files changed, 91 insertions(+), 61 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index cb547a0fc9..74ba6dba4e 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -6,12 +6,8 @@ import { BaseVerkleNode } from './baseVerkleNode.js'
 import { LeafNode } from './leafNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 
-import type { VerkleNodeOptions } from './types.js'
+import type { ChildNode, VerkleNodeOptions } from './types.js'
 
-export interface ChildNode {
-  commitment: Uint8Array // 64 byte commitment to child node
-  path: Uint8Array // path/partial stem to child node (used as DB key)
-}
 export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
   // Array of tuples of uncompressed commitments (i.e. 64 byte Uint8Arrays) to child nodes along with the path to that child (i.e. the partial stem)
   public children: Array<ChildNode>
@@ -57,14 +53,19 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       throw new Error('Invalid node type')
     }
 
-    // The length of the rawNode should be the # of children, + 2 for the node type and the commitment
-    if (rawNode.length !== NODE_WIDTH + 2) {
+    // The length of the rawNode should be the # of children * 2 (for commitments and paths) + 2 for the node type and the commitment
+    if (rawNode.length !== NODE_WIDTH * 2 + 2) {
       throw new Error('Invalid node length')
     }
 
     const commitment = rawNode[rawNode.length - 1]
+    const childrenCommitments = rawNode.slice(1, NODE_WIDTH)
+    const childrenPaths = rawNode.slice(NODE_WIDTH + 1, NODE_WIDTH * 2)
 
-    return new InternalNode({ commitment, depth, verkleCrypto })
+    const children = childrenCommitments.map((commitment, idx) => {
+      return { commitment, path: childrenPaths[idx] }
+    })
+    return new InternalNode({ commitment, depth, verkleCrypto, children })
   }
 
   static create(depth: number, verkleCrypto: VerkleCrypto): InternalNode {
@@ -171,6 +172,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     return [
       new Uint8Array([VerkleNodeType.Internal]),
       ...this.children.map((child) => child.commitment),
+      ...this.children.map((child) => child.path),
       this.commitment,
     ]
   }
diff --git a/packages/verkle/src/node/types.ts b/packages/verkle/src/node/types.ts
index d02d4b38ce..05fbb41407 100644
--- a/packages/verkle/src/node/types.ts
+++ b/packages/verkle/src/node/types.ts
@@ -7,6 +7,10 @@ export enum VerkleNodeType {
   Leaf,
 }
 
+export interface ChildNode {
+  commitment: Uint8Array // 64 byte commitment to child node
+  path: Uint8Array // path/partial stem to child node (used as DB key)
+}
 export interface TypedVerkleNode {
   [VerkleNodeType.Internal]: InternalNode
   [VerkleNodeType.Leaf]: LeafNode
@@ -29,7 +33,7 @@ interface BaseVerkleNodeOptions {
 
 interface VerkleInternalNodeOptions extends BaseVerkleNodeOptions {
   // Children nodes of this internal node.
-  children?: VerkleNode[]
+  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
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 2ddee652e8..f31ade32a9 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -287,11 +287,12 @@ export class VerkleTree {
         depth: 0,
         verkleCrypto: this.verkleCrypto,
       })
+
       // Update the child node's commitment and path
-      rootNode.children[key[0]].commitment = leafNode.commitment
-      rootNode.children[key[0]].path = key
-      // Update root node commitment
-      this.verkleCrypto.updateCommitment(
+      rootNode.children[key[0]] = { commitment: leafNode.commitment, path: key }
+
+      // Update root node commitment using a zero commitment hash for the old scalar value (since this is a new root node)
+      rootNode.commitment = this.verkleCrypto.updateCommitment(
         rootNode.commitment,
         key[0],
         new Uint8Array(32),
@@ -299,45 +300,51 @@ export class VerkleTree {
       )
       // Put root node in DB
       await this._db.put(ROOT_DB_KEY, rootNode.serialize())
+      // FIXME: This is incorrect.  We should be using `serializeCommitment` here since the root of the trie
+      // should be the compressed form of the commitment so it can be uncompressed when put in a proof
+      // `serializeCommitment` currently isn't part of the public API of `verkle-cryptography-wasm`
+      this.root(this.verkleCrypto.hashCommitment(rootNode.commitment))
       // We're done so return early
       return
     }
-    let currentNode: VerkleNode = res.stack[res.stack.length - 1]
-    let currentKey = leafNode.stem
-    let currentDepth = leafNode.depth
-
-    while (currentDepth > 0) {
-      let rawNode: Uint8Array | undefined
-      let parentIndex = currentKey[currentKey.length - 1]
-      let parentKey = currentKey.slice(0, currentKey.length - 1)
-      while (!(rawNode instanceof Uint8Array)) {
-        parentIndex = currentKey[currentKey.length - 1]
-        // Parent key should be at least one shorter than the current key length
-        parentKey = currentKey.slice(0, currentKey.length - 1)
-        // Try to retrieve parent node - going back up the path one byte at a time
-        rawNode = await this._db.get(parentKey)
-        if (rawNode === null) continue
-      }
-      // TODO: Determine how to decide if we need to go further up the tree or create a new internal node here
-      // Currently, this code would insert a new internal node at every step up the trie (which we don't want)
-      // if (rawNode !== null) {
-      const parentNode = InternalNode.fromRawNode(
-        RLP.decode(rawNode) as Uint8Array[],
-        currentDepth,
-        this.verkleCrypto
-      )
-      // } else {
-      //   parentNode = InternalNode.create(currentDepth, this.verkleCrypto)
-      // }
-      parentNode.setChild(parentIndex, { commitment: currentNode.commitment, path: parentKey })
-      await this._db.put(parentKey, parentNode.serialize())
-
-      currentNode = parentNode
-      currentKey = parentKey
-      currentDepth--
-    }
 
-    this._root = currentNode.hash()
+    // TODO: Build out rest of logic to update internal nodes and/or insert new ones as needed
+    // let currentNode: VerkleNode = res.stack[res.stack.length - 1]
+    // let currentKey = leafNode.stem
+    // let currentDepth = leafNode.depth
+
+    // while (currentDepth > 0) {
+    //   let rawNode: Uint8Array | undefined
+    //   let parentIndex = currentKey[currentKey.length - 1]
+    //   let parentKey = currentKey.slice(0, currentKey.length - 1)
+    //   while (!(rawNode instanceof Uint8Array)) {
+    //     parentIndex = currentKey[currentKey.length - 1]
+    //     // Parent key should be at least one shorter than the current key length
+    //     parentKey = currentKey.slice(0, currentKey.length - 1)
+    //     // Try to retrieve parent node - going back up the path one byte at a time
+    //     rawNode = await this._db.get(parentKey)
+    //     if (rawNode === null) continue
+    //   }
+    //   // TODO: Determine how to decide if we need to go further up the tree or create a new internal node here
+    //   // Currently, this code would insert a new internal node at every step up the trie (which we don't want)
+    //   // if (rawNode !== null) {
+    //   const parentNode = InternalNode.fromRawNode(
+    //     RLP.decode(rawNode) as Uint8Array[],
+    //     currentDepth,
+    //     this.verkleCrypto
+    //   )
+    //   // } else {
+    //   //   parentNode = InternalNode.create(currentDepth, this.verkleCrypto)
+    //   // }
+    //   parentNode.setChild(parentIndex, { commitment: currentNode.commitment, path: parentKey })
+    //   await this._db.put(parentKey, parentNode.serialize())
+
+    //   currentNode = parentNode
+    //   currentKey = parentKey
+    //   currentDepth--
+    // }
+
+    // this._root = currentNode.hash()
   }
 
   /**
@@ -367,6 +374,7 @@ export class VerkleTree {
 
     result.stack.push(rootNode)
     let child = rootNode.children[key[0]]
+
     // Root node doesn't contain a child node's commitment on the first byte of the path so we're done
     if (child.commitment === this.verkleCrypto.zeroCommitment) return result
     let finished = false
diff --git a/packages/verkle/test/internalNode.spec.ts b/packages/verkle/test/internalNode.spec.ts
index c01497b29f..09005ca8f1 100644
--- a/packages/verkle/test/internalNode.spec.ts
+++ b/packages/verkle/test/internalNode.spec.ts
@@ -2,7 +2,7 @@ import { equalsBytes, randomBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, beforeAll, describe, it } from 'vitest'
 
-import { NODE_WIDTH, VerkleNodeType } from '../src/node/index.js'
+import { NODE_WIDTH, VerkleNodeType, decodeNode } from '../src/node/index.js'
 import { InternalNode } from '../src/node/internalNode.js'
 
 import type { VerkleCrypto } from '../src/types.js'
@@ -51,4 +51,21 @@ describe('verkle node - internal', () => {
       'every children should be null'
     )
   })
+  it('should serialize and deserialize a node', async () => {
+    const child = {
+      commitment: randomBytes(64),
+      path: randomBytes(10),
+    }
+    const children = new Array(256).fill({ commitment: new Uint8Array(64), path: new Uint8Array() })
+    children[0] = child
+    const node = new InternalNode({
+      children,
+      verkleCrypto,
+      depth: 0,
+      commitment: verkleCrypto.zeroCommitment,
+    })
+    const serialized = node.serialize()
+    const decoded = decodeNode(serialized, 0, verkleCrypto)
+    assert.deepEqual((decoded as InternalNode).children[0].commitment, child.commitment)
+  })
 })
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 080dd0fee0..27ba0e4825 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -1,11 +1,12 @@
 import { RLP } from '@ethereumjs/rlp'
-import { MapDB, equalsBytes, hexToBytes } from '@ethereumjs/util'
+import { MapDB, bytesToHex, equalsBytes, hexToBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, describe, it } from 'vitest'
 
-import { InternalNode, LeafNode, ROOT_DB_KEY } from '../src/index.js'
+import { InternalNode, ROOT_DB_KEY, VerkleNodeType } from '../src/index.js'
 import { VerkleTree } from '../src/verkleTree.js'
 
+import type { LeafNode } from '../src/index.js'
 import type { PrefixedHexString } from '@ethereumjs/util'
 
 // Testdata from https://github.com/gballet/go-ethereum/blob/kaustinen-with-shapella/trie/verkle_test.go
@@ -56,22 +57,20 @@ describe('Verkle tree', () => {
     })
     const db = new MapDB<Uint8Array, Uint8Array>()
     tree.database(db)
-    // Insert a root node
-    await tree['_db'].put(
-      ROOT_DB_KEY,
-      new InternalNode({
-        commitment: verkleCrypto.zeroCommitment,
-        depth: 0,
-        verkleCrypto,
-      }).serialize()
-    )
+
     const res = await tree.findPath(presentKeys[0])
 
     assert.ok(res.node === null, 'should not find a node when the key is not present')
     assert.deepEqual(res.remaining, presentKeys[0])
 
     await tree.put(presentKeys[0], values[0])
-    console.log(await tree.get(presentKeys[0]))
+    const path = await tree.findPath(presentKeys[0])
+
+    assert.equal(path.node?.depth, 1, 'found a node at the correct depth')
+    assert.equal(path.node?.type, VerkleNodeType.Leaf)
+
+    const value = (path.node! as LeafNode).getValue(presentKeys[0][31])
+    assert.deepEqual(value, values[0], 'retrieved correct leaf node holding correct value')
     // for (let i = 0; i < presentKeys.length; i++) {
     //   console.log('lets put a key')
     //   await tree.put(presentKeys[i], values[i])

From 2301d2c3c734405e415742c150a57f42917a27b0 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Tue, 11 Jun 2024 22:09:49 -0400
Subject: [PATCH 22/51] update verkle crypto [no ci]

---
 package-lock.json                  | 10 +++++-----
 packages/statemanager/package.json |  2 +-
 packages/verkle/package.json       |  2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 71cc2787db..e5df5574ec 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -12154,9 +12154,9 @@
       }
     },
     "node_modules/verkle-cryptography-wasm": {
-      "version": "0.4.3",
-      "resolved": "https://registry.npmjs.org/verkle-cryptography-wasm/-/verkle-cryptography-wasm-0.4.3.tgz",
-      "integrity": "sha512-feUY8JnS9I3sJAkZbHJdvRDQTp0YG7bXGH1f99WK+aSLhr3mU/tbpbwfDL9zTbvRcX/15+5LmM35cLbMexEJeA==",
+      "version": "0.4.4",
+      "resolved": "https://registry.npmjs.org/verkle-cryptography-wasm/-/verkle-cryptography-wasm-0.4.4.tgz",
+      "integrity": "sha512-ijAqsbnkoCYm6TS1qUxCq0BkSC+6bFE2UxSfwNRWeIJxdvvEHZxPGifdXsqC4NnOA1JVWeloNuxGuIwTo3HlSw==",
       "dependencies": {
         "@scure/base": "^1.1.5"
       },
@@ -13536,7 +13536,7 @@
         "ethereum-cryptography": "^2.1.3",
         "js-sdsl": "^4.1.4",
         "lru-cache": "10.1.0",
-        "verkle-cryptography-wasm": "^0.4.3"
+        "verkle-cryptography-wasm": "^0.4.4"
       },
       "devDependencies": {
         "@ethereumjs/block": "^5.2.0",
@@ -13619,7 +13619,7 @@
         "@ethereumjs/rlp": "^5.0.2",
         "@ethereumjs/util": "^9.0.3",
         "lru-cache": "10.1.0",
-        "verkle-cryptography-wasm": "^0.4.3"
+        "verkle-cryptography-wasm": "^0.4.4"
       },
       "engines": {
         "node": ">=18"
diff --git a/packages/statemanager/package.json b/packages/statemanager/package.json
index e551fc1bf4..ca59a8717a 100644
--- a/packages/statemanager/package.json
+++ b/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.3"
+    "verkle-cryptography-wasm": "^0.4.4"
   },
   "devDependencies": {
     "@ethereumjs/block": "^5.2.0",
diff --git a/packages/verkle/package.json b/packages/verkle/package.json
index 26013c10b2..9644f655f8 100644
--- a/packages/verkle/package.json
+++ b/packages/verkle/package.json
@@ -53,7 +53,7 @@
   },
   "dependencies": {
     "lru-cache": "10.1.0",
-    "verkle-cryptography-wasm": "^0.4.3",
+    "verkle-cryptography-wasm": "^0.4.4",
     "@ethereumjs/block": "^5.2.0",
     "@ethereumjs/rlp": "^5.0.2",
     "@ethereumjs/util": "^9.0.3"

From dcdd778761adfa8a1de0b75e9ef302606def1fe1 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Tue, 11 Jun 2024 22:10:54 -0400
Subject: [PATCH 23/51] Update this.root [no ci]

---
 packages/verkle/src/verkleTree.ts | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index f31ade32a9..2cba39e959 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -300,10 +300,8 @@ export class VerkleTree {
       )
       // Put root node in DB
       await this._db.put(ROOT_DB_KEY, rootNode.serialize())
-      // FIXME: This is incorrect.  We should be using `serializeCommitment` here since the root of the trie
-      // should be the compressed form of the commitment so it can be uncompressed when put in a proof
-      // `serializeCommitment` currently isn't part of the public API of `verkle-cryptography-wasm`
-      this.root(this.verkleCrypto.hashCommitment(rootNode.commitment))
+      // Set trie root to serialized (aka compressed) commitment for later use in verkle proof
+      this.root(this.verkleCrypto.serializeCommitment(rootNode.commitment))
       // We're done so return early
       return
     }

From cf33476eec0673dd1af485a03abd4356dab38c92 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 12 Jun 2024 12:56:01 -0400
Subject: [PATCH 24/51] Clean up db opt typing [no ci]

---
 packages/verkle/src/types.ts        | 2 +-
 packages/verkle/src/verkleTree.ts   | 3 +++
 packages/verkle/test/verkle.spec.ts | 8 +++-----
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/packages/verkle/src/types.ts b/packages/verkle/src/types.ts
index 196ad5b0a3..5a3f126fc6 100644
--- a/packages/verkle/src/types.ts
+++ b/packages/verkle/src/types.ts
@@ -18,7 +18,7 @@ export interface VerkleTreeOpts {
   /**
    * A database instance.
    */
-  db?: DB<Uint8Array, Uint8Array>
+  db: DB<Uint8Array, Uint8Array>
 
   /**
    * A `Uint8Array` for the root of a previously stored tree
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 2cba39e959..85c4db2c32 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -2,6 +2,7 @@ import { RLP } from '@ethereumjs/rlp'
 import {
   KeyEncoding,
   Lock,
+  MapDB,
   ValueEncoding,
   bytesToHex,
   equalsBytes,
@@ -43,6 +44,7 @@ export class VerkleTree {
     useRootPersistence: false,
     cacheSize: 0,
     verkleCrypto: undefined,
+    db: new MapDB<Uint8Array, Uint8Array>(),
   }
 
   /** The root for an empty tree */
@@ -105,6 +107,7 @@ export class VerkleTree {
       if (opts === undefined)
         opts = {
           verkleCrypto,
+          db: new MapDB<Uint8Array, Uint8Array>(),
         }
       else {
         opts.verkleCrypto = verkleCrypto
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 27ba0e4825..0ed983543d 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -1,9 +1,8 @@
-import { RLP } from '@ethereumjs/rlp'
-import { MapDB, bytesToHex, equalsBytes, hexToBytes } from '@ethereumjs/util'
+import { MapDB, hexToBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, describe, it } from 'vitest'
 
-import { InternalNode, ROOT_DB_KEY, VerkleNodeType } from '../src/index.js'
+import { VerkleNodeType } from '../src/index.js'
 import { VerkleTree } from '../src/verkleTree.js'
 
 import type { LeafNode } from '../src/index.js'
@@ -54,9 +53,8 @@ describe('Verkle tree', () => {
     const verkleCrypto = await loadVerkleCrypto()
     const tree = await VerkleTree.create({
       verkleCrypto,
+      db: new MapDB<Uint8Array, Uint8Array>(),
     })
-    const db = new MapDB<Uint8Array, Uint8Array>()
-    tree.database(db)
 
     const res = await tree.findPath(presentKeys[0])
 

From b9285e28b6b72fd3254a593961c0458af3fea992 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 12 Jun 2024 13:13:20 -0400
Subject: [PATCH 25/51] API clean/comments [no ci]

---
 packages/verkle/src/node/baseVerkleNode.ts |  5 +-
 packages/verkle/src/node/internalNode.ts   | 88 ----------------------
 packages/verkle/src/node/leafNode.ts       | 24 ++----
 packages/verkle/src/node/types.ts          |  1 -
 packages/verkle/src/verkleTree.ts          | 54 ++++---------
 5 files changed, 22 insertions(+), 150 deletions(-)

diff --git a/packages/verkle/src/node/baseVerkleNode.ts b/packages/verkle/src/node/baseVerkleNode.ts
index 74cc5d5658..d854aa501e 100644
--- a/packages/verkle/src/node/baseVerkleNode.ts
+++ b/packages/verkle/src/node/baseVerkleNode.ts
@@ -14,15 +14,12 @@ export abstract class BaseVerkleNode<T extends VerkleNodeType> implements Verkle
     this.verkleCrypto = options.verkleCrypto
   }
 
-  abstract commit(): Uint8Array
-
   // Hash returns the field representation of the commitment.
   hash(): Uint8Array {
     return this.verkleCrypto.hashCommitment(this.commitment)
   }
 
-  abstract insert(key: Uint8Array, value: Uint8Array, nodeResolverFn: () => void): void
-
+  // Returns an array of Uint8Arrays containing the values necessary to reconstruct a node from the DB (where we store them in a RLP serialized format)
   abstract raw(): Uint8Array[]
 
   /**
diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 74ba6dba4e..306b1fcf37 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -1,9 +1,6 @@
-import { BIGINT_0, bytesToBigInt, equalsBytes } from '@ethereumjs/util'
-
 import { type VerkleCrypto } from '../types.js'
 
 import { BaseVerkleNode } from './baseVerkleNode.js'
-import { LeafNode } from './leafNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 
 import type { ChildNode, VerkleNodeOptions } from './types.js'
@@ -23,10 +20,6 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
       })
   }
 
-  commit(): Uint8Array {
-    throw new Error('Not implemented')
-  }
-
   // Updates the commitment value for a child node at the corresponding index
   setChild(index: number, child: ChildNode) {
     // Get previous child commitment at `index`
@@ -87,87 +80,6 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     return this.children[index]
   }
 
-  insert(key: Uint8Array, value: Uint8Array, resolver: () => void): void {
-    const values = new Array<Uint8Array>(NODE_WIDTH)
-    values[key[31]] = value
-    this.insertStem(key.slice(0, 31), values, resolver)
-  }
-
-  // TODO: Determine how this function is used and if we need it
-  insertStem(stem: Uint8Array, values: Uint8Array[], resolver: () => void): 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) {
-      if (equalsBytes(child.stem, stem)) {
-        return child.insertMultiple(stem, values)
-      }
-
-      // A new branch node has to be inserted. Depending
-      // 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, this.verkleCrypto)
-      this.children[childIndex] = {
-        commitment: newBranch.commitment,
-        path: child.stem.slice(0, this.depth + 1),
-      }
-      newBranch.children[nextByteInExistingKey] = child
-      child.depth += 1
-
-      const nextByteInInsertedKey = stem[this.depth + 1]
-      if (nextByteInInsertedKey === nextByteInExistingKey) {
-        return newBranch.insertStem(stem, values, resolver)
-      }
-
-      // Next word differs, so this was the last level.
-      // Insert it directly into its final slot.
-      // TODO: Fix this following `trie.put` logic
-      let leafCommitment = this.verkleCrypto.zeroCommitment
-      let c1 = this.verkleCrypto.zeroCommitment
-      let c2 = this.verkleCrypto.zeroCommitment
-      for (const [idx, value] of values.entries()) {
-        if (bytesToBigInt(value) > BIGINT_0) {
-          leafCommitment = this.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 = this.verkleCrypto.updateCommitment(c1, idx * 2, new Uint8Array(32), value)
-          } else {
-            c2 = this.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.children[nextByteInInsertedKey] = {
-        commitment: leafNode.commitment,
-        path: leafNode.stem,
-      }
-    } else if (child instanceof InternalNode) {
-      return child.insertStem(stem, values, resolver)
-    } else {
-      throw new Error('Invalid node type')
-    }
-  }
-
   raw(): Uint8Array[] {
     return [
       new Uint8Array([VerkleNodeType.Internal]),
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 6cfd99f506..32908dfadc 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -59,28 +59,18 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
 
     return new LeafNode({ depth, stem, values, c1, c2, commitment, verkleCrypto })
   }
-  commit(): Uint8Array {
-    throw new Error('Not implemented')
-  }
 
-  getValue(index: number): Uint8Array | null {
+  // Retrieve the value at the provided index from the values array
+  getValue(index: number): Uint8Array | undefined {
     return this.values?.[index] ?? null
   }
 
-  insert(key: Uint8Array, value: Uint8Array, nodeResolverFn: () => void): void {
-    const values = new Array<Uint8Array>(NODE_WIDTH)
-    values[key[31]] = value
-    this.insertStem(key.slice(0, 31), values, nodeResolverFn)
-  }
-
-  insertMultiple(key: Uint8Array, values: Uint8Array[]): void {
-    throw new Error('Not implemented')
+  // Set the value at the provided index from the values array
+  // TODO: Decide whether we need a separate "deleteValue" function since it has special handling
+  // since we never actually delete a node in a verkle trie but overwrite instead
+  setValue(index: number, value: Uint8Array): void {
+    this.values[index] = value
   }
-
-  insertStem(key: Uint8Array, value: Uint8Array[], resolver: () => void): void {
-    throw new Error('Not implemented')
-  }
-
   // TODO: go-verkle also adds the bitlist to the raw format.
   raw(): Uint8Array[] {
     return [
diff --git a/packages/verkle/src/node/types.ts b/packages/verkle/src/node/types.ts
index 05fbb41407..9a9114b6ea 100644
--- a/packages/verkle/src/node/types.ts
+++ b/packages/verkle/src/node/types.ts
@@ -19,7 +19,6 @@ export interface TypedVerkleNode {
 export type VerkleNode = TypedVerkleNode[VerkleNodeType]
 
 export interface VerkleNodeInterface {
-  commit(): Uint8Array
   hash(): any
   serialize(): Uint8Array
 }
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 85c4db2c32..00a2acd4cb 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -24,10 +24,10 @@ import {
   type VerkleTreeOpts,
   type VerkleTreeOptsWithDefaults,
 } from './types.js'
-import { WalkController, matchingBytesLength } from './util/index.js'
+import { matchingBytesLength } from './util/index.js'
 import { verifyKeyLength } from './util/keys.js'
 
-import type { FoundNodeFunction, VerkleCrypto } from './types.js'
+import type { VerkleCrypto } from './types.js'
 import type { BatchDBOp, DB, PutBatch } from '@ethereumjs/util'
 
 interface Path {
@@ -415,16 +415,6 @@ export class VerkleTree {
     return result
   }
 
-  /**
-   * Walks a tree until finished.
-   * @param root
-   * @param onFound - callback to call when a node is found. This schedules new tasks. If no tasks are available, the Promise resolves.
-   * @returns Resolves when finished walking tree.
-   */
-  async walkTree(root: Uint8Array, onFound: FoundNodeFunction): Promise<void> {
-    await WalkController.newWalk(onFound, this, root)
-  }
-
   /**
    * Tries to find the leaf node leading up to the given key, or null if not found.
    * @param key - the search key
@@ -446,6 +436,8 @@ export class VerkleTree {
    * Creates the initial node from an empty tree.
    * @private
    */
+
+  // TODO: Decide if we keep this.  I currently have this as part of `put`
   protected async _createInitialNode(key: Uint8Array, value: Uint8Array): Promise<void> {
     throw new Error('Not implemented')
   }
@@ -453,6 +445,7 @@ export class VerkleTree {
   /**
    * Retrieves a node from db by hash.
    */
+  // TODO: Decide whether to keep or remove this.  We look up nodes by path/partial path so not sure if we need this or not
   async lookupNode(node: Uint8Array | Uint8Array[]): Promise<VerkleNode | null> {
     throw new Error('not implemented')
     // if (isRawNode(node)) {
@@ -475,6 +468,8 @@ export class VerkleTree {
    * @param keyRemainder
    * @param stack
    */
+
+  // TODO: Decide if we need this.  Looks like it's left over from the MPT `trie` class
   protected async _updateNode(
     k: Uint8Array,
     value: Uint8Array,
@@ -491,6 +486,8 @@ export class VerkleTree {
    * @param stack - a stack of nodes to the value given by the key
    * @param opStack - a stack of levelup operations to commit at the end of this function
    */
+  // TODO: Decide if we will ever use something like this.  Could make sense for batching trie updates but its closely wedded to `level`
+  // and I don't use it in the current `trie.put` logic (though could be helpful)
   async saveStack(
     key: Uint8Array,
     stack: VerkleNode[],
@@ -499,24 +496,6 @@ export class VerkleTree {
     throw new Error('Not implemented')
   }
 
-  /**
-   * Formats node to be saved by `levelup.batch`.
-   * @private
-   * @param node - the node to format.
-   * @param topLevel - if the node is at the top level.
-   * @param opStack - the opStack to push the node's data.
-   * @param remove - whether to remove the node
-   * @returns The node's hash used as the key or the rawNode.
-   */
-  _formatNode(
-    node: VerkleNode,
-    topLevel: boolean,
-    opStack: PutBatch<Uint8Array, Uint8Array>,
-    remove: boolean = false
-  ): Uint8Array {
-    throw new Error('Not implemented')
-  }
-
   /**
    * The given hash of operations (key additions or deletions) are executed on the tree
    * (delete operations are only executed on DB with `deleteFromDB` set to `true`)
@@ -531,6 +510,8 @@ export class VerkleTree {
    * await tree.batch(ops)
    * @param ops
    */
+
+  // TODO: Decide if we keep or not.
   async batch(ops: BatchDBOp[]): Promise<void> {
     throw new Error('Not implemented')
   }
@@ -559,6 +540,9 @@ export class VerkleTree {
    * @throws If proof is found to be invalid.
    * @returns The value from the key, or null if valid proof of non-existence.
    */
+
+  // TODO: Decide if we need this.  We already have the `verifyProof` functionality in the `verkle-cryptography-wasm` functionality
+  // and it doesn't require the use of the trie state to verify.
   async verifyProof(
     rootHash: Uint8Array,
     key: Uint8Array,
@@ -610,16 +594,6 @@ export class VerkleTree {
     }
   }
 
-  /**
-   * Finds all nodes that are stored directly in the db
-   * (some nodes are stored raw inside other nodes)
-   * called by {@link ScratchReadStream}
-   * @private
-   */
-  protected async _findDbNodes(onFound: () => void): Promise<void> {
-    throw new Error('Not implemented')
-  }
-
   /**
    * Is the tree during a checkpoint phase?
    */

From 1dcc64dc4d63bab4e58912f70685eb4f94281cab Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 12 Jun 2024 15:41:44 -0400
Subject: [PATCH 26/51] fix logic bug for nonexistent path [no ci]

---
 packages/verkle/src/verkleTree.ts   | 2 +-
 packages/verkle/test/verkle.spec.ts | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 00a2acd4cb..63d2ee7070 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -377,7 +377,7 @@ export class VerkleTree {
     let child = rootNode.children[key[0]]
 
     // Root node doesn't contain a child node's commitment on the first byte of the path so we're done
-    if (child.commitment === this.verkleCrypto.zeroCommitment) return result
+    if (equalsBytes(child.commitment, this.verkleCrypto.zeroCommitment)) return result
     let finished = false
     while (!finished) {
       rawNode = await this._db.get(child.path)
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 0ed983543d..fdfb5adb47 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -11,6 +11,7 @@ import type { PrefixedHexString } from '@ethereumjs/util'
 // Testdata from https://github.com/gballet/go-ethereum/blob/kaustinen-with-shapella/trie/verkle_test.go
 const presentKeys = [
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d01',
+  '0x318dca512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0xe6ed6c222e3985050b4fc574b136b0a42c63538e9ab970995cd418ba8e526400',
   '0x18fb432d3b859ec3a1803854e8cceea75d092e52d0d4a4398d13022496745a02',
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
@@ -69,6 +70,10 @@ describe('Verkle tree', () => {
 
     const value = (path.node! as LeafNode).getValue(presentKeys[0][31])
     assert.deepEqual(value, values[0], 'retrieved correct leaf node holding correct value')
+    const pathToNonExistentNode = await tree.findPath(absentKeys[0])
+    assert.equal(pathToNonExistentNode.node, null)
+    assert.equal(pathToNonExistentNode.stack.length, 1, 'contains the root node in the stack')
+
     // for (let i = 0; i < presentKeys.length; i++) {
     //   console.log('lets put a key')
     //   await tree.put(presentKeys[i], values[i])

From f42ac23b729c0ce198a48f956f207c3a533c1905 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 12 Jun 2024 15:52:58 -0400
Subject: [PATCH 27/51] Describe logic for updating tree along path [no ci]

---
 packages/verkle/src/verkleTree.ts | 50 ++++++++-----------------------
 1 file changed, 13 insertions(+), 37 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 63d2ee7070..a4e85ade17 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -278,7 +278,8 @@ export class VerkleTree {
         c2,
         this.verkleCrypto
       )
-      await this._db.put(key, leafNode.serialize())
+      // TODO: Add this to stack of nodes rather than put directly so we can update depth as needed after walking up trie
+      // await this._db.put(key, leafNode.serialize())
     }
 
     // Walk up the tree and update internal nodes
@@ -309,43 +310,18 @@ export class VerkleTree {
       return
     }
 
-    // TODO: Build out rest of logic to update internal nodes and/or insert new ones as needed
-    // let currentNode: VerkleNode = res.stack[res.stack.length - 1]
-    // let currentKey = leafNode.stem
-    // let currentDepth = leafNode.depth
-
-    // while (currentDepth > 0) {
-    //   let rawNode: Uint8Array | undefined
-    //   let parentIndex = currentKey[currentKey.length - 1]
-    //   let parentKey = currentKey.slice(0, currentKey.length - 1)
-    //   while (!(rawNode instanceof Uint8Array)) {
-    //     parentIndex = currentKey[currentKey.length - 1]
-    //     // Parent key should be at least one shorter than the current key length
-    //     parentKey = currentKey.slice(0, currentKey.length - 1)
-    //     // Try to retrieve parent node - going back up the path one byte at a time
-    //     rawNode = await this._db.get(parentKey)
-    //     if (rawNode === null) continue
-    //   }
-    //   // TODO: Determine how to decide if we need to go further up the tree or create a new internal node here
-    //   // Currently, this code would insert a new internal node at every step up the trie (which we don't want)
-    //   // if (rawNode !== null) {
-    //   const parentNode = InternalNode.fromRawNode(
-    //     RLP.decode(rawNode) as Uint8Array[],
-    //     currentDepth,
-    //     this.verkleCrypto
-    //   )
-    //   // } else {
-    //   //   parentNode = InternalNode.create(currentDepth, this.verkleCrypto)
-    //   // }
-    //   parentNode.setChild(parentIndex, { commitment: currentNode.commitment, path: parentKey })
-    //   await this._db.put(parentKey, parentNode.serialize())
-
-    //   currentNode = parentNode
-    //   currentKey = parentKey
-    //   currentDepth--
-    // }
+    const currentNode: VerkleNode = res.stack.pop()
+    const currentKey = leafNode.stem
+    const currentDepth = leafNode.depth
+
+    while (currentDepth > 0) {
+      // Updating inner nodes
+      // 1. Update `currentNode` child node commitment to leafnode, commitment of `currentNode`, and depth as needed
+      // 2. Walk up result.stack doing the same thing (while inserting new internal nodes as needed and updating lower level node depth as needed)
+      // 3. Use `saveStack` or whatever to put all nodes in DB
+    }
 
-    // this._root = currentNode.hash()
+    this._root = this.verkleCrypto.serializeCommitment(currentNode.commitment)
   }
 
   /**

From e4e257a7c9afbac86e1d03cdd1fcd90eb44aec08 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 12 Jun 2024 21:37:13 -0400
Subject: [PATCH 28/51] Update `put` to use `saveStack` [no ci]

---
 packages/verkle/src/verkleTree.ts | 35 +++++++++++++++++--------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index a4e85ade17..0034da6a25 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -203,7 +203,8 @@ export class VerkleTree {
    */
   async put(key: Uint8Array, value: Uint8Array): Promise<void> {
     verifyKeyLength(key)
-
+    // A stack of nodes to put/update in the DB once the new leaf node is inserted
+    const putStack: [Uint8Array, VerkleNode][] = []
     // Find or create the leaf node
     const res = await this.findPath(key)
     let leafNode = res.node
@@ -278,11 +279,11 @@ export class VerkleTree {
         c2,
         this.verkleCrypto
       )
-      // TODO: Add this to stack of nodes rather than put directly so we can update depth as needed after walking up trie
-      // await this._db.put(key, leafNode.serialize())
+      // Add leaf node to put stack
+      putStack.push([key, leafNode])
     }
 
-    // Walk up the tree and update internal nodes
+    // Walk the tree from the root to the leaf and update/insert internal nodes along the way
     if (res.stack.length === 0) {
       // Special case where findPath returned early because no root node exists
       // Create a root node
@@ -302,8 +303,10 @@ export class VerkleTree {
         new Uint8Array(32),
         this.verkleCrypto.hashCommitment(leafNode.commitment)
       )
-      // Put root node in DB
+      // Add root node to put stack
+      putStack.push([ROOT_DB_KEY, rootNode])
       await this._db.put(ROOT_DB_KEY, rootNode.serialize())
+      await this.saveStack(putStack)
       // Set trie root to serialized (aka compressed) commitment for later use in verkle proof
       this.root(this.verkleCrypto.serializeCommitment(rootNode.commitment))
       // We're done so return early
@@ -458,18 +461,18 @@ export class VerkleTree {
   /**
    * Saves a stack of nodes to the database.
    *
-   * @param key - the key. Should follow the stack
-   * @param stack - a stack of nodes to the value given by the key
-   * @param opStack - a stack of levelup operations to commit at the end of this function
+   * @param putStack - an array of tuples of keys (the partial path of the node in the trie) and nodes (VerkleNodes)
    */
-  // TODO: Decide if we will ever use something like this.  Could make sense for batching trie updates but its closely wedded to `level`
-  // and I don't use it in the current `trie.put` logic (though could be helpful)
-  async saveStack(
-    key: Uint8Array,
-    stack: VerkleNode[],
-    opStack: PutBatch<Uint8Array, Uint8Array>[]
-  ): Promise<void> {
-    throw new Error('Not implemented')
+
+  async saveStack(putStack: [Uint8Array, VerkleNode][]): Promise<void> {
+    const opStack = putStack.map(([key, node]) => {
+      return {
+        type: 'put',
+        key,
+        value: node.serialize(),
+      } as PutBatch
+    })
+    await this._db.batch(opStack)
   }
 
   /**

From 1b1706d9cae1ec2287c2be6db2e9ac67de38b618 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 13 Jun 2024 07:29:16 -0400
Subject: [PATCH 29/51] WIP [no ci]

---
 packages/verkle/src/verkleTree.ts | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 0034da6a25..642c843164 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -16,7 +16,7 @@ import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { CheckpointDB } from './db/checkpoint.js'
 import { InternalNode } from './node/internalNode.js'
 import { LeafNode } from './node/leafNode.js'
-import { type VerkleNode, VerkleNodeType } from './node/types.js'
+import { type ChildNode, type VerkleNode, VerkleNodeType } from './node/types.js'
 import { createCValues, decodeRawNode } from './node/util.js'
 import {
   type Proof,
@@ -313,11 +313,30 @@ export class VerkleTree {
       return
     }
 
-    const currentNode: VerkleNode = res.stack.pop()
+    // Pop the root node off the stack
+    const currentNode: VerkleNode = res.stack.unshift()
     const currentKey = leafNode.stem
-    const currentDepth = leafNode.depth
-
-    while (currentDepth > 0) {
+    const currentDepth = 0
+    const index = currentKey[0]
+
+    while (res.stack.length > 0) {
+      if (currentNode instanceof InternalNode) {
+        const child = currentNode.getChildren(index)
+        const matchingKeyLength = matchingBytesLength(child!.path, currentKey)
+        if (matchingKeyLength < 31) {
+          // We have to update the internal node referenced by `child`
+          const children = new Array<ChildNode>(256).fill({
+            commitment: this.verkleCrypto.zeroCommitment,
+            path: new Uint8Array(),
+          })
+
+          const newInternalNode = new InternalNode({
+            verkleCrypto: this.verkleCrypto,
+            depth: currentNode.depth + 1,
+            children,
+          })
+        }
+      }
       // Updating inner nodes
       // 1. Update `currentNode` child node commitment to leafnode, commitment of `currentNode`, and depth as needed
       // 2. Walk up result.stack doing the same thing (while inserting new internal nodes as needed and updating lower level node depth as needed)

From 96f99aaccad563bcf1b4b8b17d3935a0e5f6881b Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 13 Jun 2024 14:42:40 -0400
Subject: [PATCH 30/51] revise leafNode.create API [no ci]

---
 packages/verkle/src/node/leafNode.ts  | 113 ++++++++++++++++++++++++--
 packages/verkle/src/node/util.ts      |   4 +-
 packages/verkle/src/verkleTree.ts     |  80 +++---------------
 packages/verkle/test/leafNode.spec.ts |  55 ++++++++-----
 4 files changed, 152 insertions(+), 100 deletions(-)

diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 32908dfadc..0008dbf516 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -1,5 +1,8 @@
+import { equalsBytes, intToBytes, setLengthLeft, setLengthRight } from '@ethereumjs/util'
+
 import { BaseVerkleNode } from './baseVerkleNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
+import { createCValues } from './util.js'
 
 import type { VerkleCrypto } from '../types.js'
 import type { VerkleNodeOptions } from './types.js'
@@ -20,15 +23,67 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     this.c2 = options.c2
   }
 
-  static create(
+  /**
+   * Create a new leaf node from a stem, values, and depth
+   * @param stem the 31 byte stem corresponding to the where the leaf node should be placed in the trie
+   * @param values the 256 element array of 32 byte values stored in the leaf node
+   * @param depth the depth of the leafnode
+   * @param verkleCrypto the verkle cryptography interface
+   * @returns an instantiated leaf node with commitments defined
+   */
+  static async create(
     stem: Uint8Array,
     values: Uint8Array[],
     depth: number,
-    commitment: Uint8Array,
-    c1: Uint8Array,
-    c2: Uint8Array,
     verkleCrypto: VerkleCrypto
-  ): LeafNode {
+  ): Promise<LeafNode> {
+    // Generate the value arrays for c1 and c2
+    const c1Values = createCValues(values.slice(0, 128))
+    const c2Values = createCValues(values.slice(128))
+    let c1 = verkleCrypto.zeroCommitment
+    let c2 = verkleCrypto.zeroCommitment
+
+    // Update the c1/c2 commitments for any values that are nonzero
+    for (let x = 0; x < 256; x++) {
+      if (!equalsBytes(c1Values[x], new Uint8Array(32))) {
+        c1 = verkleCrypto.updateCommitment(c1, x, new Uint8Array(32), c1Values[x])
+      }
+      if (!equalsBytes(c2Values[x], new Uint8Array(32))) {
+        c2 = verkleCrypto.updateCommitment(c2, x, new Uint8Array(32), c2Values[x])
+      }
+    }
+
+    // Generate a commitment for the new leaf node, using the zero commitment as a base
+    // 1) Update commitment with Leaf marker (1) in position 0
+    // 2) Update commitment with stem (in little endian format) in position 1
+    // 3) Update commitment with c1
+    // 4) update commitment with c2
+    let commitment = verkleCrypto.updateCommitment(
+      verkleCrypto.zeroCommitment,
+      0,
+      new Uint8Array(32),
+      setLengthLeft(intToBytes(1), 32)
+    )
+    commitment = verkleCrypto.updateCommitment(
+      commitment,
+      1,
+      new Uint8Array(32),
+      setLengthRight(stem, 32)
+    )
+    commitment = verkleCrypto.updateCommitment(
+      commitment,
+      2,
+      new Uint8Array(32),
+      // We hash the commitment when using in the leaf node commitment since c1 is 64 bytes long
+      // and we need a 32 byte input for the scalar value in `updateCommitment`
+      verkleCrypto.hashCommitment(c1)
+    )
+    commitment = verkleCrypto.updateCommitment(
+      commitment,
+      3,
+      new Uint8Array(32),
+      verkleCrypto.hashCommitment(c2)
+    )
     return new LeafNode({
       stem,
       values,
@@ -65,13 +120,57 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     return this.values?.[index] ?? null
   }
 
-  // Set the value at the provided index from the values array
+  // Set the value at the provided index from the values array and update the node commitments
   // TODO: Decide whether we need a separate "deleteValue" function since it has special handling
   // since we never actually delete a node in a verkle trie but overwrite instead
   setValue(index: number, value: Uint8Array): void {
+    // First we update c1 or c2 (depending on whether the index is < 128 or not)
+    // Generate the 16 byte values representing the 32 byte values in the half of the values array that
+    // contain the old value for the leaf node
+    const cValues =
+      index < 128 ? createCValues(this.values.slice(0, 128)) : createCValues(this.values.slice(128))
+    // The commitment index is the 2 * the suffix (i.e. the position of the value in the values array)
+    // here because each 32 byte value in the leaf node is represented as two 16 byte values in the
+    // cValues array.
+    const commitmentIndex = index < 128 ? index * 2 : (index - 128) * 2
+    let cCommitment = index < 128 ? this.c1 : this.c2
+    // Update the commitment for the first 16 bytes of the value
+    cCommitment = this.verkleCrypto.updateCommitment(
+      cCommitment!,
+      commitmentIndex,
+      cValues[commitmentIndex],
+      // Right pad the value with zeroes since commitments require 32 byte scalars
+      setLengthRight(value.slice(0, 16), 32)
+    )
+    // Update the commitment for the second 16 bytes of the value
+    cCommitment = this.verkleCrypto.updateCommitment(
+      cCommitment!,
+      commitmentIndex + 1,
+      cValues[commitmentIndex + 1],
+      // Right pad the value with zeroes since commitments require 32 byte scalars
+      setLengthRight(value.slice(16), 32)
+    )
+    // Update the cCommitment corresponding to the index
+    let oldCCommitment
+    if (index < 128) {
+      oldCCommitment = this.c1
+      this.c1 = cCommitment
+    } else {
+      oldCCommitment
+      this.c2 = cCommitment
+    }
+    // Set the new values in the values array
     this.values[index] = value
+    // Update leaf node commitment
+    const cIndex = index < 128 ? 2 : 3
+    this.commitment = this.verkleCrypto.updateCommitment(
+      this.commitment,
+      cIndex,
+      this.verkleCrypto.hashCommitment(oldCCommitment!),
+      this.verkleCrypto.hashCommitment(cCommitment)
+    )
   }
-  // TODO: go-verkle also adds the bitlist to the raw format.
+
   raw(): Uint8Array[] {
     return [
       new Uint8Array([VerkleNodeType.Leaf]),
diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
index 2949fc357a..faeac262d2 100644
--- a/packages/verkle/src/node/util.ts
+++ b/packages/verkle/src/node/util.ts
@@ -49,7 +49,7 @@ export const createCValues = (values: Uint8Array[], deletedValues = new Array(12
   const expandedValues: Uint8Array[] = new Array(256)
   for (let x = 0; x < 128; x++) {
     // We add 16 trailing zeros to each value since all commitments are padded to an array of 32 byte values
-    expandedValues[x] = setLengthRight(
+    expandedValues[x * 2] = setLengthRight(
       deletedValues[x] === true
         ? // TODO: Improve performance by only flipping the 129th bit of `expandedValues[x]` (instead of bigint addition)
           bigIntToBytes(bytesToBigInt(values[x].subarray(0, 16)) + BigInt(2 ** 128))
@@ -57,7 +57,7 @@ export const createCValues = (values: Uint8Array[], deletedValues = new Array(12
       32
     )
     // TODO: Decide if we should use slice or subarray here (i.e. do we need to copy these slices or not)
-    expandedValues[x + 1] = setLengthRight(values[x].slice(16), 32)
+    expandedValues[x * 2 + 1] = setLengthRight(values[x].slice(16), 32)
   }
   return expandedValues
 }
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 642c843164..1c0aff0f8c 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -6,9 +6,6 @@ import {
   ValueEncoding,
   bytesToHex,
   equalsBytes,
-  intToBytes,
-  setLengthLeft,
-  setLengthRight,
   zeros,
 } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
@@ -17,7 +14,7 @@ import { CheckpointDB } from './db/checkpoint.js'
 import { InternalNode } from './node/internalNode.js'
 import { LeafNode } from './node/leafNode.js'
 import { type ChildNode, type VerkleNode, VerkleNodeType } from './node/types.js'
-import { createCValues, decodeRawNode } from './node/util.js'
+import { decodeRawNode } from './node/util.js'
 import {
   type Proof,
   ROOT_DB_KEY,
@@ -181,7 +178,7 @@ export class VerkleTree {
           LeafNode.fromRawNode(rawNode, 1, this.verkleCrypto)
         : InternalNode.fromRawNode(rawNode, 1, this.verkleCrypto)
 
-    // TODO: Decide if we needt this check since this should always be a leaf node
+    // TODO: Decide if we need this check since this should always be a leaf node
     // since internal nodes should have never have a key/stem of 31 bytes
     if (node instanceof LeafNode) {
       const keyLastByte = key[key.length - 1]
@@ -208,81 +205,26 @@ export class VerkleTree {
     // Find or create the leaf node
     const res = await this.findPath(key)
     let leafNode = res.node
+    const suffix = key[31]
     if (!(leafNode instanceof LeafNode)) {
       // If leafNode is missing, create it
       const values: Uint8Array[] = new Array(256).fill(new Uint8Array()) // Create new empty array of 256 values
-      const suffix = key[31]
       values[suffix] = value // Set value at key suffix
 
-      // Generate the 16 byte values representing the 32 byte values in the half of the values array that
-      // contain the initial value for the leaf node
-      const cValues =
-        suffix < 128 ? createCValues(values.slice(0, 128)) : createCValues(values.slice(128))
-      // The commitment index is the 2 * the suffix (i.e. the position of the value in the values array)
-      // here because each 32 byte value in the leaf node is represented as two 16 byte values in the
-      // cValues array.
-      const commitmentIndex = suffix < 128 ? suffix * 2 : (suffix - 128) * 2
-      let cCommitment = this.verkleCrypto.zeroCommitment
-      // Update the commitment for the first 16 bytes of the value
-      cCommitment = this.verkleCrypto.updateCommitment(
-        cCommitment,
-        commitmentIndex,
-        new Uint8Array(32),
-        cValues[commitmentIndex]
-      )
-      // Update the commitment for the second 16 bytes of the value
-      cCommitment = this.verkleCrypto.updateCommitment(
-        cCommitment,
-        commitmentIndex + 1,
-        new Uint8Array(32),
-        cValues[commitmentIndex + 1]
-      )
-      const c1 = suffix < 128 ? cCommitment : this.verkleCrypto.zeroCommitment
-      const c2 = suffix > 127 ? cCommitment : this.verkleCrypto.zeroCommitment
-      // Generate a commitment for the new leaf node, using the zero commitment as a base
-      // 1) Update commitment with Leaf marker (1) in position 0
-      // 2) Update commitment with stem (in little endian format) in position 1
-      // 3) Update commitment with c1
-      // 4) update commitment with c2
-      let commitment = this.verkleCrypto.updateCommitment(
-        this.verkleCrypto.zeroCommitment,
-        0,
-        new Uint8Array(32),
-        setLengthLeft(intToBytes(1), 32)
-      )
-      commitment = this.verkleCrypto.updateCommitment(
-        commitment,
-        1,
-        new Uint8Array(32),
-        setLengthRight(key.slice(0, 31), 32)
-      )
-      commitment = this.verkleCrypto.updateCommitment(
-        commitment,
-        2,
-        new Uint8Array(32),
-        // We hash the commitment when using in the leaf node commitment since c1 is 64 bytes long
-        // and we need a 32 byte input for the scalar value in `updateCommitment`
-        this.verkleCrypto.hashCommitment(c1)
-      )
-      commitment = this.verkleCrypto.updateCommitment(
-        commitment,
-        3,
-        new Uint8Array(32),
-        this.verkleCrypto.hashCommitment(c2)
-      )
-      leafNode = LeafNode.create(
+      leafNode = await LeafNode.create(
         key.slice(0, 31),
         values,
         res.stack.length + 1,
-        commitment,
-        c1,
-        c2,
         this.verkleCrypto
       )
-      // Add leaf node to put stack
-      putStack.push([key, leafNode])
+    } else {
+      // We found our leaf node so lets update the value and commitment
+      leafNode.setValue(suffix, value)
     }
 
+    // Add leaf node to put stack
+    putStack.push([key, leafNode])
+
     // Walk the tree from the root to the leaf and update/insert internal nodes along the way
     if (res.stack.length === 0) {
       // Special case where findPath returned early because no root node exists
@@ -314,7 +256,7 @@ export class VerkleTree {
     }
 
     // Pop the root node off the stack
-    const currentNode: VerkleNode = res.stack.unshift()
+    const currentNode: VerkleNode = res.stack.shift()
     const currentKey = leafNode.stem
     const currentDepth = 0
     const index = currentKey[0]
diff --git a/packages/verkle/test/leafNode.spec.ts b/packages/verkle/test/leafNode.spec.ts
index f81dabe907..1ab4c63de9 100644
--- a/packages/verkle/test/leafNode.spec.ts
+++ b/packages/verkle/test/leafNode.spec.ts
@@ -1,27 +1,33 @@
-import { equalsBytes, hexToBytes, randomBytes } from '@ethereumjs/util'
-import { assert, describe, it } from 'vitest'
+import { 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 { Point } from '../src/types.js'
-import type { PrefixedHexString } from '@ethereumjs/util'
+import type { VerkleCrypto } from '../src/types.js'
 
 describe('verkle node - leaf', () => {
+  let verkleCrypto = undefined as never as VerkleCrypto
+  beforeAll(async () => {
+    verkleCrypto = await loadVerkleCrypto()
+  })
   it('constructor should create an leaf node', async () => {
-    const commitment = randomBytes(32)
-    const c1 = randomBytes(32)
-    const c2 = randomBytes(32)
+    const commitment = randomBytes(64)
+    const c1 = randomBytes(64)
+    const c2 = randomBytes(64)
     const stem = randomBytes(32)
-    const values = [randomBytes(32), randomBytes(32)]
+    const values = new Array<Uint8Array>(256).fill(randomBytes(32))
+
     const depth = 2
     const node = new LeafNode({
-      c1: c1 as unknown as Point,
-      c2: c2 as unknown as Point,
+      c1,
+      c2,
       commitment,
       depth,
       stem,
       values,
+      verkleCrypto,
     })
 
     assert.equal(node.type, VerkleNodeType.Leaf, 'type should be set')
@@ -39,18 +45,23 @@ describe('verkle node - leaf', () => {
     assert.equal(node.depth, depth, 'depth should be set')
   })
 
-  it('create method should create an leaf node', () => {
-    const presentKeys = ['0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d01'].map(
-      (key) => hexToBytes(key as PrefixedHexString)
-    )
-
-    // Corresponding values for the present keys
-    const values = ['0x320122e8584be00d000000000000000000000000000000000000000000000000'].map(
-      (key) => hexToBytes(key as PrefixedHexString)
-    )
-    const stem = presentKeys[0].slice(0, 31)
-    const nodeData = values
-    const node = LeafNode.create(stem, nodeData, 0, new Uint8Array(32))
+  it('create method should create an leaf node', async () => {
+    const key = randomBytes(32)
+    const value = randomBytes(32)
+    const values = new Array<Uint8Array>(256).fill(new Uint8Array(32))
+    values[2] = value
+    const stem = key.slice(0, 31)
+    const node = await LeafNode.create(stem, values, 0, verkleCrypto)
     assert.ok(node instanceof LeafNode)
   })
+
+  it('should update a commitment when setting a value', async () => {
+    const key = randomBytes(32)
+    const stem = key.slice(0, 31)
+    const values = new Array<Uint8Array>(256).fill(new Uint8Array(32))
+    const node = await LeafNode.create(stem, values, 0, verkleCrypto)
+    assert.deepEqual(node.c1, verkleCrypto.zeroCommitment)
+    node.setValue(0, randomBytes(32))
+    assert.notDeepEqual(node.c1, verkleCrypto.zeroCommitment)
+  })
 })

From e4bcb66970e69b67bfcb9507226a705bcda16d98 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 13 Jun 2024 15:24:58 -0400
Subject: [PATCH 31/51] more updates to put/get [no ci]

---
 packages/verkle/src/verkleTree.ts   | 95 +++++++++++++----------------
 packages/verkle/test/verkle.spec.ts | 42 +++++--------
 2 files changed, 59 insertions(+), 78 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 1c0aff0f8c..68620326ee 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -13,8 +13,8 @@ import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { CheckpointDB } from './db/checkpoint.js'
 import { InternalNode } from './node/internalNode.js'
 import { LeafNode } from './node/leafNode.js'
-import { type ChildNode, type VerkleNode, VerkleNodeType } from './node/types.js'
-import { decodeRawNode } from './node/util.js'
+import { type ChildNode, type VerkleNode } from './node/types.js'
+import { decodeNode } from './node/util.js'
 import {
   type Proof,
   ROOT_DB_KEY,
@@ -164,20 +164,15 @@ export class VerkleTree {
   /**
    * Gets a value given a `key`
    * @param key - the key to search for
-   * @returns A Promise that resolves to `Uint8Array` if a value was found or `null` if no value was found.
+   * @returns A Promise that resolves to `Uint8Array` if a value was found or `undefined` if no value was found.
    */
-  async get(key: Uint8Array): Promise<Uint8Array | null> {
+  async get(key: Uint8Array): Promise<Uint8Array | undefined> {
     verifyKeyLength(key)
     const nodeRLP = await this._db.get(key)
-    if (nodeRLP === undefined) return null
-    // We first retrieve the node and decode it
-    const rawNode = RLP.decode(nodeRLP) as Uint8Array[]
-    const node =
-      rawNode[0][0] === VerkleNodeType.Leaf
-        ? // TODO: Figure out how to determine depth from key
-          LeafNode.fromRawNode(rawNode, 1, this.verkleCrypto)
-        : InternalNode.fromRawNode(rawNode, 1, this.verkleCrypto)
 
+    if (nodeRLP === undefined) return
+    // We first retrieve the node and decode it
+    const node = decodeNode(nodeRLP, 0, this.verkleCrypto)
     // TODO: Decide if we need this check since this should always be a leaf node
     // since internal nodes should have never have a key/stem of 31 bytes
     if (node instanceof LeafNode) {
@@ -185,10 +180,11 @@ export class VerkleTree {
 
       // The retrieved leaf node contains an array of 256 possible values.
       // The index of the value we want is at the key's last byte
-      return node.values?.[keyLastByte] ?? null
+      const value = node.getValue(keyLastByte)
+      return value
     }
 
-    return null
+    return
   }
 
   /**
@@ -211,6 +207,7 @@ export class VerkleTree {
       const values: Uint8Array[] = new Array(256).fill(new Uint8Array()) // Create new empty array of 256 values
       values[suffix] = value // Set value at key suffix
 
+      // Create leaf node
       leafNode = await LeafNode.create(
         key.slice(0, 31),
         values,
@@ -218,14 +215,14 @@ export class VerkleTree {
         this.verkleCrypto
       )
     } else {
-      // We found our leaf node so lets update the value and commitment
+      // Found the leaf node so update the value (setValue also updates the commitments)
       leafNode.setValue(suffix, value)
     }
 
     // Add leaf node to put stack
     putStack.push([key, leafNode])
 
-    // Walk the tree from the root to the leaf and update/insert internal nodes along the way
+    // No stack returned from `findPath` indicates no root node so let's create one
     if (res.stack.length === 0) {
       // Special case where findPath returned early because no root node exists
       // Create a root node
@@ -247,7 +244,6 @@ export class VerkleTree {
       )
       // Add root node to put stack
       putStack.push([ROOT_DB_KEY, rootNode])
-      await this._db.put(ROOT_DB_KEY, rootNode.serialize())
       await this.saveStack(putStack)
       // Set trie root to serialized (aka compressed) commitment for later use in verkle proof
       this.root(this.verkleCrypto.serializeCommitment(rootNode.commitment))
@@ -255,37 +251,40 @@ export class VerkleTree {
       return
     }
 
-    // Pop the root node off the stack
-    const currentNode: VerkleNode = res.stack.shift()
-    const currentKey = leafNode.stem
-    const currentDepth = 0
-    const index = currentKey[0]
+    // Walk up the tree from the nearest node to the leaf and update/insert internal nodes along the way
 
+    // Updating inner nodes
+    // 1. Update `currentNode` child node commitment to leafnode, commitment of `currentNode`, and depth as needed
+    // 2. Walk up result.stack doing the same thing (while inserting new internal nodes as needed and updating lower level node depth as needed)
+    // 3. Use `saveStack` to put all nodes in DB
     while (res.stack.length > 0) {
+      // Pop the last node off the path stack
+      const currentNode: VerkleNode = res.stack.pop()!
+      const currentKey = leafNode.stem
+      const currentDepth = currentNode.depth
+      const index = currentKey[0]
       if (currentNode instanceof InternalNode) {
-        const child = currentNode.getChildren(index)
-        const matchingKeyLength = matchingBytesLength(child!.path, currentKey)
-        if (matchingKeyLength < 31) {
-          // We have to update the internal node referenced by `child`
-          const children = new Array<ChildNode>(256).fill({
-            commitment: this.verkleCrypto.zeroCommitment,
-            path: new Uint8Array(),
-          })
-
-          const newInternalNode = new InternalNode({
-            verkleCrypto: this.verkleCrypto,
-            depth: currentNode.depth + 1,
-            children,
-          })
+        if (currentDepth === 0) {
+          if (res.stack.length > 0)
+            throw new Error('cannot have node of depth zero and more nodes in path')
+          // We're at the root node.  Just update the child commitment/path
+          // using the key and commitment from the last node in the putStack
+          const child: ChildNode = {
+            commitment: putStack[putStack.length - 1][1].commitment,
+            path: putStack[putStack.length - 1][0],
+          }
+          currentNode.setChild(index, child)
+          putStack.push([ROOT_DB_KEY, currentNode])
+          // Update root
+          this.root(this.verkleCrypto.serializeCommitment(currentNode.commitment))
+          break
         }
+        // const child = currentNode.getChildren(index)
+        // const matchingKeyLength = matchingBytesLength(child!.path, currentKey)
+        // We have to update the internal node referenced by `child`
       }
-      // Updating inner nodes
-      // 1. Update `currentNode` child node commitment to leafnode, commitment of `currentNode`, and depth as needed
-      // 2. Walk up result.stack doing the same thing (while inserting new internal nodes as needed and updating lower level node depth as needed)
-      // 3. Use `saveStack` or whatever to put all nodes in DB
     }
-
-    this._root = this.verkleCrypto.serializeCommitment(currentNode.commitment)
+    await this.saveStack(putStack)
   }
 
   /**
@@ -307,11 +306,7 @@ export class VerkleTree {
     if (rawNode === undefined)
       throw new Error('root node should exist when root not empty tree root')
 
-    const rootNode = decodeRawNode(
-      RLP.decode(rawNode) as Uint8Array[],
-      0,
-      this.verkleCrypto
-    ) as InternalNode
+    const rootNode = decodeNode(rawNode, 0, this.verkleCrypto) as InternalNode
 
     result.stack.push(rootNode)
     let child = rootNode.children[key[0]]
@@ -323,11 +318,7 @@ export class VerkleTree {
       rawNode = await this._db.get(child.path)
       // We should always find the node if the path is specified in child.path
       if (rawNode === undefined) throw new Error(`missing node at ${bytesToHex(child.path)}`)
-      const decodedNode = decodeRawNode(
-        RLP.decode(rawNode) as Uint8Array[],
-        result.stack.length,
-        this.verkleCrypto
-      )
+      const decodedNode = decodeNode(rawNode, result.stack.length, this.verkleCrypto)
       // Calculate the index of the last matching byte in the key
       const matchingKeyLength = matchingBytesLength(key, child.path)
       const foundNode = equalsBytes(key, child.path)
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index fdfb5adb47..69ece505b7 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -1,8 +1,9 @@
-import { MapDB, hexToBytes } from '@ethereumjs/util'
+import { ROOT_DB_KEY } from '@ethereumjs/trie'
+import { MapDB, equalsBytes, hexToBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, describe, it } from 'vitest'
 
-import { VerkleNodeType } from '../src/index.js'
+import { VerkleNodeType, decodeNode } from '../src/index.js'
 import { VerkleTree } from '../src/verkleTree.js'
 
 import type { LeafNode } from '../src/index.js'
@@ -62,30 +63,19 @@ describe('Verkle tree', () => {
     assert.ok(res.node === null, 'should not find a node when the key is not present')
     assert.deepEqual(res.remaining, presentKeys[0])
 
-    await tree.put(presentKeys[0], values[0])
-    const path = await tree.findPath(presentKeys[0])
+    for (let i = 0; i < 2; i++) {
+      await tree.put(presentKeys[i], values[i])
+    }
+    for (let i = 0; i < 2; i++) {
+      const retrievedValue = await tree.get(presentKeys[i])
+      if (retrievedValue === undefined) {
+        assert.fail('Value not found')
+      }
+      assert.ok(equalsBytes(retrievedValue, values[i]))
+    }
 
-    assert.equal(path.node?.depth, 1, 'found a node at the correct depth')
-    assert.equal(path.node?.type, VerkleNodeType.Leaf)
-
-    const value = (path.node! as LeafNode).getValue(presentKeys[0][31])
-    assert.deepEqual(value, values[0], 'retrieved correct leaf node holding correct value')
-    const pathToNonExistentNode = await tree.findPath(absentKeys[0])
-    assert.equal(pathToNonExistentNode.node, null)
-    assert.equal(pathToNonExistentNode.stack.length, 1, 'contains the root node in the stack')
-
-    // for (let i = 0; i < presentKeys.length; i++) {
-    //   console.log('lets put a key')
-    //   await tree.put(presentKeys[i], values[i])
-    // }
-    // for (let i = 0; i < presentKeys.length; i++) {
-    //   const retrievedValue = await tree.get(presentKeys[i])
-    //   if (retrievedValue === null) {
-    //     assert.fail('Value not found')
-    //   }
-    //   assert.ok(equalsBytes(retrievedValue, values[i]))
-    // }
-    // const path = await tree.findPath(presentKeys[0])
-    // assert.ok(path.node instanceof LeafNode)
+    // const pathToNonExistentNode = await tree.findPath(absentKeys[0])
+    // assert.equal(pathToNonExistentNode.node, null)
+    // assert.equal(pathToNonExistentNode.stack.length, 1, 'contains the root node in the stack')
   })
 })

From 27144c070c377b7fd16c2c93749b8a4b67e2cf71 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 13 Jun 2024 16:40:10 -0400
Subject: [PATCH 32/51] More wip [no ci]

---
 packages/verkle/src/node/util.ts    |  1 +
 packages/verkle/src/verkleTree.ts   | 17 ++++++++---------
 packages/verkle/test/verkle.spec.ts | 11 ++++-------
 3 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
index faeac262d2..4ae17a06e4 100644
--- a/packages/verkle/src/node/util.ts
+++ b/packages/verkle/src/node/util.ts
@@ -7,6 +7,7 @@ import { type VerkleNode, VerkleNodeType } from './types.js'
 
 import type { VerkleCrypto } from '../types.js'
 
+// TODO: Make depth optional since we don't always know what it is
 export function decodeRawNode(
   raw: Uint8Array[],
   depth: number,
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 68620326ee..f7ab8520bf 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -168,7 +168,8 @@ export class VerkleTree {
    */
   async get(key: Uint8Array): Promise<Uint8Array | undefined> {
     verifyKeyLength(key)
-    const nodeRLP = await this._db.get(key)
+    const stem = key.slice(0, 31)
+    const nodeRLP = await this._db.get(stem)
 
     if (nodeRLP === undefined) return
     // We first retrieve the node and decode it
@@ -196,6 +197,7 @@ export class VerkleTree {
    */
   async put(key: Uint8Array, value: Uint8Array): Promise<void> {
     verifyKeyLength(key)
+    const stem = key.slice(0, 31)
     // A stack of nodes to put/update in the DB once the new leaf node is inserted
     const putStack: [Uint8Array, VerkleNode][] = []
     // Find or create the leaf node
@@ -208,19 +210,14 @@ export class VerkleTree {
       values[suffix] = value // Set value at key suffix
 
       // Create leaf node
-      leafNode = await LeafNode.create(
-        key.slice(0, 31),
-        values,
-        res.stack.length + 1,
-        this.verkleCrypto
-      )
+      leafNode = await LeafNode.create(stem, values, res.stack.length, this.verkleCrypto)
     } else {
       // Found the leaf node so update the value (setValue also updates the commitments)
       leafNode.setValue(suffix, value)
     }
 
     // Add leaf node to put stack
-    putStack.push([key, leafNode])
+    putStack.push([stem, leafNode])
 
     // No stack returned from `findPath` indicates no root node so let's create one
     if (res.stack.length === 0) {
@@ -233,7 +230,7 @@ export class VerkleTree {
       })
 
       // Update the child node's commitment and path
-      rootNode.children[key[0]] = { commitment: leafNode.commitment, path: key }
+      rootNode.children[key[0]] = { commitment: leafNode.commitment, path: stem }
 
       // Update root node commitment using a zero commitment hash for the old scalar value (since this is a new root node)
       rootNode.commitment = this.verkleCrypto.updateCommitment(
@@ -244,6 +241,8 @@ export class VerkleTree {
       )
       // Add root node to put stack
       putStack.push([ROOT_DB_KEY, rootNode])
+      // TODO: Move depth check to putStack
+      putStack[0][1].depth = 1
       await this.saveStack(putStack)
       // Set trie root to serialized (aka compressed) commitment for later use in verkle proof
       this.root(this.verkleCrypto.serializeCommitment(rootNode.commitment))
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 69ece505b7..56991320ea 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -1,18 +1,15 @@
-import { ROOT_DB_KEY } from '@ethereumjs/trie'
 import { MapDB, equalsBytes, hexToBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { assert, describe, it } from 'vitest'
 
-import { VerkleNodeType, decodeNode } from '../src/index.js'
 import { VerkleTree } from '../src/verkleTree.js'
 
-import type { LeafNode } from '../src/index.js'
 import type { PrefixedHexString } from '@ethereumjs/util'
 
 // Testdata from https://github.com/gballet/go-ethereum/blob/kaustinen-with-shapella/trie/verkle_test.go
 const presentKeys = [
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d01',
-  '0x318dca512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
+  '0x318daa512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0xe6ed6c222e3985050b4fc574b136b0a42c63538e9ab970995cd418ba8e526400',
   '0x18fb432d3b859ec3a1803854e8cceea75d092e52d0d4a4398d13022496745a02',
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
@@ -74,8 +71,8 @@ describe('Verkle tree', () => {
       assert.ok(equalsBytes(retrievedValue, values[i]))
     }
 
-    // const pathToNonExistentNode = await tree.findPath(absentKeys[0])
-    // assert.equal(pathToNonExistentNode.node, null)
-    // assert.equal(pathToNonExistentNode.stack.length, 1, 'contains the root node in the stack')
+    const pathToNonExistentNode = await tree.findPath(absentKeys[0])
+    assert.equal(pathToNonExistentNode.node, null)
+    assert.equal(pathToNonExistentNode.stack.length, 1, 'contains the root node in the stack')
   })
 })

From 7f4ead6181d053f8593f9535d2a5115f3cf9119b Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 13 Jun 2024 22:01:10 -0400
Subject: [PATCH 33/51] Fix bug in internalNode deserialization [no ci]

---
 packages/verkle/src/node/internalNode.ts | 4 ++--
 packages/verkle/src/verkleTree.ts        | 2 +-
 packages/verkle/test/verkle.spec.ts      | 6 +++++-
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 306b1fcf37..769a47898e 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -52,8 +52,8 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     }
 
     const commitment = rawNode[rawNode.length - 1]
-    const childrenCommitments = rawNode.slice(1, NODE_WIDTH)
-    const childrenPaths = rawNode.slice(NODE_WIDTH + 1, NODE_WIDTH * 2)
+    const childrenCommitments = rawNode.slice(1, NODE_WIDTH + 1)
+    const childrenPaths = rawNode.slice(NODE_WIDTH + 1, NODE_WIDTH * 2 + 1)
 
     const children = childrenCommitments.map((commitment, idx) => {
       return { commitment, path: childrenPaths[idx] }
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index f7ab8520bf..563ade4736 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -201,7 +201,7 @@ export class VerkleTree {
     // A stack of nodes to put/update in the DB once the new leaf node is inserted
     const putStack: [Uint8Array, VerkleNode][] = []
     // Find or create the leaf node
-    const res = await this.findPath(key)
+    const res = await this.findPath(stem)
     let leafNode = res.node
     const suffix = key[31]
     if (!(leafNode instanceof LeafNode)) {
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 56991320ea..6d9abf586c 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -9,7 +9,7 @@ import type { PrefixedHexString } from '@ethereumjs/util'
 // Testdata from https://github.com/gballet/go-ethereum/blob/kaustinen-with-shapella/trie/verkle_test.go
 const presentKeys = [
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d01',
-  '0x318daa512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
+  '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0xe6ed6c222e3985050b4fc574b136b0a42c63538e9ab970995cd418ba8e526400',
   '0x18fb432d3b859ec3a1803854e8cceea75d092e52d0d4a4398d13022496745a02',
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
@@ -60,6 +60,7 @@ describe('Verkle tree', () => {
     assert.ok(res.node === null, 'should not find a node when the key is not present')
     assert.deepEqual(res.remaining, presentKeys[0])
 
+    // Test that two keys with the same stem store values in the same leaf node
     for (let i = 0; i < 2; i++) {
       await tree.put(presentKeys[i], values[i])
     }
@@ -71,6 +72,9 @@ describe('Verkle tree', () => {
       assert.ok(equalsBytes(retrievedValue, values[i]))
     }
 
+    // Verify that findPath returns a path that demonstrates the nonexistence of a key
+    // by returning only the root node (in this instance where the trie has only a root internal node and 1 leaf node)
+    // with a different stem than the one passed to `findPath`
     const pathToNonExistentNode = await tree.findPath(absentKeys[0])
     assert.equal(pathToNonExistentNode.node, null)
     assert.equal(pathToNonExistentNode.stack.length, 1, 'contains the root node in the stack')

From abc442d36f05883dac97e7eb61ccc1f452d44b9c Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 13 Jun 2024 22:05:46 -0400
Subject: [PATCH 34/51] Add more comments [no ci]

---
 packages/verkle/src/verkleTree.ts   | 2 ++
 packages/verkle/test/verkle.spec.ts | 4 ++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 563ade4736..c0a4271927 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -169,6 +169,8 @@ export class VerkleTree {
   async get(key: Uint8Array): Promise<Uint8Array | undefined> {
     verifyKeyLength(key)
     const stem = key.slice(0, 31)
+    // TODO: This isn't valid since we should be walking the trie to verify the leaf node is reachable
+    // not just that it's in the db.  We should use `findPath` here
     const nodeRLP = await this._db.get(stem)
 
     if (nodeRLP === undefined) return
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 6d9abf586c..52ca7e6fcc 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -61,10 +61,10 @@ describe('Verkle tree', () => {
     assert.deepEqual(res.remaining, presentKeys[0])
 
     // Test that two keys with the same stem store values in the same leaf node
-    for (let i = 0; i < 2; i++) {
+    for (let i = 0; i < 3; i++) {
       await tree.put(presentKeys[i], values[i])
     }
-    for (let i = 0; i < 2; i++) {
+    for (let i = 0; i < 3; i++) {
       const retrievedValue = await tree.get(presentKeys[i])
       if (retrievedValue === undefined) {
         assert.fail('Value not found')

From eeb2ec8838213fea5ece9a7fdbf23246f56d6201 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 14 Jun 2024 09:41:33 -0400
Subject: [PATCH 35/51] remove duplicative function [no ci]

---
 packages/verkle/src/verkleTree.ts | 34 +++++--------------------------
 1 file changed, 5 insertions(+), 29 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index c0a4271927..0c5d808303 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -1,4 +1,3 @@
-import { RLP } from '@ethereumjs/rlp'
 import {
   KeyEncoding,
   Lock,
@@ -169,21 +168,15 @@ export class VerkleTree {
   async get(key: Uint8Array): Promise<Uint8Array | undefined> {
     verifyKeyLength(key)
     const stem = key.slice(0, 31)
-    // TODO: This isn't valid since we should be walking the trie to verify the leaf node is reachable
-    // not just that it's in the db.  We should use `findPath` here
-    const nodeRLP = await this._db.get(stem)
-
-    if (nodeRLP === undefined) return
-    // We first retrieve the node and decode it
-    const node = decodeNode(nodeRLP, 0, this.verkleCrypto)
-    // TODO: Decide if we need this check since this should always be a leaf node
-    // since internal nodes should have never have a key/stem of 31 bytes
-    if (node instanceof LeafNode) {
+
+    const res = await this.findPath(stem)
+
+    if (res.node instanceof LeafNode) {
       const keyLastByte = key[key.length - 1]
 
       // The retrieved leaf node contains an array of 256 possible values.
       // The index of the value we want is at the key's last byte
-      const value = node.getValue(keyLastByte)
+      const value = res.node.getValue(keyLastByte)
       return value
     }
 
@@ -347,23 +340,6 @@ export class VerkleTree {
     return result
   }
 
-  /**
-   * Tries to find the leaf node leading up to the given key, or null if not found.
-   * @param key - the search key
-   * @param throwIfMissing - if true, throws if any nodes are missing. Used for verifying proofs. (default: false)
-   */
-  async findLeafNode(key: Uint8Array, throwIfMissing = false): Promise<LeafNode | VerkleNode[]> {
-    const { node, stack } = await this.findPath(key)
-    if (!(node instanceof LeafNode)) {
-      if (throwIfMissing) {
-        throw new Error('leaf node not found')
-      }
-      // return depth of remaining nodes
-      return stack
-    }
-    return node
-  }
-
   /**
    * Creates the initial node from an empty tree.
    * @private

From e7e81bf8a8cf2cb97ee778a7fa1d8e51f91f6406 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 14 Jun 2024 13:15:49 -0400
Subject: [PATCH 36/51] more wip [no ci]

---
 packages/verkle/src/verkleTree.ts   | 60 +++++++++++++++++++++++------
 packages/verkle/test/verkle.spec.ts |  2 +
 2 files changed, 51 insertions(+), 11 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 0c5d808303..7cdb6875fe 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -251,31 +251,68 @@ export class VerkleTree {
     // 1. Update `currentNode` child node commitment to leafnode, commitment of `currentNode`, and depth as needed
     // 2. Walk up result.stack doing the same thing (while inserting new internal nodes as needed and updating lower level node depth as needed)
     // 3. Use `saveStack` to put all nodes in DB
+    const currentKey = leafNode.stem
     while (res.stack.length > 0) {
+      console.log(res)
       // Pop the last node off the path stack
       const currentNode: VerkleNode = res.stack.pop()!
-      const currentKey = leafNode.stem
+
       const currentDepth = currentNode.depth
       const index = currentKey[0]
       if (currentNode instanceof InternalNode) {
         if (currentDepth === 0) {
           if (res.stack.length > 0)
             throw new Error('cannot have node of depth zero and more nodes in path')
-          // We're at the root node.  Just update the child commitment/path
+          // We're at the root node and only need to update the child commitment/path
           // using the key and commitment from the last node in the putStack
-          const child: ChildNode = {
-            commitment: putStack[putStack.length - 1][1].commitment,
-            path: putStack[putStack.length - 1][0],
+          if (res.remaining.length === 0) {
+            // If we're at depth 0 but the remaining key length is greater than 0,
+            // that means theres a partially matching key so there is either an internal
+            // or leaf node that partially matches the path of the leaf node we're inserting
+            // so we need to update and/or insert internal nodes
+            const child: ChildNode = {
+              commitment: putStack[putStack.length - 1][1].commitment,
+              path: putStack[putStack.length - 1][0],
+            }
+            currentNode.setChild(index, child)
+            putStack.push([ROOT_DB_KEY, currentNode])
+            // Update root
+            this.root(this.verkleCrypto.serializeCommitment(currentNode.commitment))
+            break
+          } else {
+            // We need to insert a new internal node
+            // New internal node's path is the partial stem up to the the `remaining` stem in the previous findPath result
+            const partialStem = stem.slice(31 - res.remaining.length)
+            const newInternalNode = InternalNode.create(1, this.verkleCrypto)
+            // Update leaf node commitment value in new internal node at the
+            // byte position immediately after the partial stem
+            // e.g. If stem is is 010003... and partial stem is 0100, the leaf node child reference
+            // are set at position 3 in the new internal node's children array
+            newInternalNode.setChild(stem[partialStem.length], {
+              commitment: leafNode.commitment,
+              // Path to the leaf node is the full stem
+              path: stem,
+            })
+            // Update new internal node value array with previous child reference
+            const oldChild = currentNode.children[partialStem.length]
+            // The position of the "old child" in the new internal node children array
+            // should be the index equal to the value of the byte in the old child's path at position
+            // partialStem.length
+            newInternalNode.setChild(oldChild.path[partialStem.length], oldChild)
+            putStack.push([partialStem, newInternalNode])
+
+            const child: ChildNode = {
+              commitment: newInternalNode.commitment,
+              path: partialStem,
+            }
+            // Current node here is the root node
+            currentNode.setChild(index, child)
+            putStack.push([ROOT_DB_KEY, currentNode])
           }
-          currentNode.setChild(index, child)
-          putStack.push([ROOT_DB_KEY, currentNode])
-          // Update root
-          this.root(this.verkleCrypto.serializeCommitment(currentNode.commitment))
-          break
         }
         // const child = currentNode.getChildren(index)
         // const matchingKeyLength = matchingBytesLength(child!.path, currentKey)
-        // We have to update the internal node referenced by `child`
+        // // We have to update the internal node referenced by `child`
       }
     }
     await this.saveStack(putStack)
@@ -288,6 +325,7 @@ export class VerkleTree {
    * @param throwIfMissing - if true, throws if any nodes are missing. Used for verifying proofs. (default: false)
    */
   async findPath(key: Uint8Array): Promise<Path> {
+    // TODO: Decide if we should allow keys longer than 31 bytes (since a verkle stem can never be longer than that)
     const result: Path = {
       node: null,
       stack: [],
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 52ca7e6fcc..db2ffce5c2 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -10,7 +10,9 @@ import type { PrefixedHexString } from '@ethereumjs/util'
 const presentKeys = [
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d01',
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
+  '0x318dfa512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0xe6ed6c222e3985050b4fc574b136b0a42c63538e9ab970995cd418ba8e526400',
+  '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0x18fb432d3b859ec3a1803854e8cceea75d092e52d0d4a4398d13022496745a02',
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0x18fb432d3b859ec3a1803854e8cceea75d092e52d0d4a4398d13022496745a04',

From 991f4d2339e58e915aa2ac5a96681eebcf9e15b4 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 14 Jun 2024 22:47:25 -0400
Subject: [PATCH 37/51] Add code to produce a 2 layer tree [no ci]

---
 packages/verkle/src/verkleTree.ts   | 21 +++++++++++----------
 packages/verkle/test/verkle.spec.ts |  6 +++++-
 2 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 7cdb6875fe..4a27773731 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -253,7 +253,6 @@ export class VerkleTree {
     // 3. Use `saveStack` to put all nodes in DB
     const currentKey = leafNode.stem
     while (res.stack.length > 0) {
-      console.log(res)
       // Pop the last node off the path stack
       const currentNode: VerkleNode = res.stack.pop()!
 
@@ -282,22 +281,23 @@ export class VerkleTree {
           } else {
             // We need to insert a new internal node
             // New internal node's path is the partial stem up to the the `remaining` stem in the previous findPath result
-            const partialStem = stem.slice(31 - res.remaining.length)
+            const partialStem = stem.slice(0, 31 - res.remaining.length)
             const newInternalNode = InternalNode.create(1, this.verkleCrypto)
             // Update leaf node commitment value in new internal node at the
             // byte position immediately after the partial stem
             // e.g. If stem is is 010003... and partial stem is 0100, the leaf node child reference
-            // are set at position 3 in the new internal node's children array
+            // is set at position 3 in the new internal node's children array
             newInternalNode.setChild(stem[partialStem.length], {
               commitment: leafNode.commitment,
               // Path to the leaf node is the full stem
               path: stem,
             })
             // Update new internal node value array with previous child reference
-            const oldChild = currentNode.children[partialStem.length]
+            const oldChild = currentNode.children[stem[0]]
             // The position of the "old child" in the new internal node children array
-            // should be the index equal to the value of the byte in the old child's path at position
-            // partialStem.length
+            // should be set at the same index as in the parent node
+            // e.g. If stem is is 010003... the old child reference should be set at
+            // position 1 in the parent node's children array (since this is the root node)
             newInternalNode.setChild(oldChild.path[partialStem.length], oldChild)
             putStack.push([partialStem, newInternalNode])
 
@@ -306,13 +306,12 @@ export class VerkleTree {
               path: partialStem,
             }
             // Current node here is the root node
-            currentNode.setChild(index, child)
+            // Update the child reference in the root node to point to the new internal node
+            currentNode.setChild(stem[0], child)
             putStack.push([ROOT_DB_KEY, currentNode])
           }
         }
-        // const child = currentNode.getChildren(index)
-        // const matchingKeyLength = matchingBytesLength(child!.path, currentKey)
-        // // We have to update the internal node referenced by `child`
+        // TODO: Add logic for updating/adding multiple internal nodes
       }
     }
     await this.saveStack(putStack)
@@ -371,6 +370,8 @@ export class VerkleTree {
         result.remaining = key.slice(matchingKeyLength)
         return result
       }
+      // Push internal node to path stack
+      result.stack.push(decodedNode)
       // Get the next child node in the path
       const childIndex = key[matchingKeyLength]
       child = decodedNode.children[childIndex]
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index db2ffce5c2..9faf39757b 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -74,11 +74,15 @@ describe('Verkle tree', () => {
       assert.ok(equalsBytes(retrievedValue, values[i]))
     }
 
+    // Get path to node at depth 2 and verify that the whole key is used
+    const pathToDeepNode = await tree.findPath(presentKeys[2].slice(0, 31))
+    assert.ok(pathToDeepNode.node !== null)
+    assert.equal(pathToDeepNode.remaining.length, 0)
     // Verify that findPath returns a path that demonstrates the nonexistence of a key
     // by returning only the root node (in this instance where the trie has only a root internal node and 1 leaf node)
     // with a different stem than the one passed to `findPath`
     const pathToNonExistentNode = await tree.findPath(absentKeys[0])
     assert.equal(pathToNonExistentNode.node, null)
-    assert.equal(pathToNonExistentNode.stack.length, 1, 'contains the root node in the stack')
+    assert.equal(pathToNonExistentNode.stack.length, 2, 'contains the root node in the stack')
   })
 })

From 58e529834423179128a81667e66cb811fd429ff0 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 17 Jun 2024 11:29:54 -0400
Subject: [PATCH 38/51] wip [no ci]

---
 packages/verkle/src/verkleTree.ts   | 6 +++++-
 packages/verkle/test/verkle.spec.ts | 2 ++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 4a27773731..6e2f52cdeb 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -265,7 +265,7 @@ export class VerkleTree {
           // We're at the root node and only need to update the child commitment/path
           // using the key and commitment from the last node in the putStack
           if (res.remaining.length === 0) {
-            // If we're at depth 0 but the remaining key length is greater than 0,
+            // If we're at depth 0 and the remaining key length is 0,
             // that means theres a partially matching key so there is either an internal
             // or leaf node that partially matches the path of the leaf node we're inserting
             // so we need to update and/or insert internal nodes
@@ -279,6 +279,10 @@ export class VerkleTree {
             this.root(this.verkleCrypto.serializeCommitment(currentNode.commitment))
             break
           } else {
+            // If we're at depth 0 but the remaining key length is greater than 0,
+            // that means theres a partially matching key so there is either an internal
+            // or leaf node that partially matches the path of the leaf node we're inserting
+            // so we need to update and/or insert internal nodes
             // We need to insert a new internal node
             // New internal node's path is the partial stem up to the the `remaining` stem in the previous findPath result
             const partialStem = stem.slice(0, 31 - res.remaining.length)
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 9faf39757b..7daab37159 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -11,6 +11,7 @@ const presentKeys = [
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d01',
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0x318dfa512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
+  '0x318dfa513b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0xe6ed6c222e3985050b4fc574b136b0a42c63538e9ab970995cd418ba8e526400',
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0x18fb432d3b859ec3a1803854e8cceea75d092e52d0d4a4398d13022496745a02',
@@ -84,5 +85,6 @@ describe('Verkle tree', () => {
     const pathToNonExistentNode = await tree.findPath(absentKeys[0])
     assert.equal(pathToNonExistentNode.node, null)
     assert.equal(pathToNonExistentNode.stack.length, 2, 'contains the root node in the stack')
+    btoa('bHaJ')
   })
 })

From 06350d098b0c1fa0ad41b24630b3dd7110cbe590 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 17 Jun 2024 15:16:52 -0400
Subject: [PATCH 39/51] Add some initial debug logs [no ci]

---
 package-lock.json                   |   1 +
 packages/verkle/package.json        |   1 +
 packages/verkle/src/verkleTree.ts   | 105 +++++++++++++++++++++++-----
 packages/verkle/test/verkle.spec.ts |  31 +++++++-
 4 files changed, 119 insertions(+), 19 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e5df5574ec..41387b29eb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13618,6 +13618,7 @@
         "@ethereumjs/block": "^5.2.0",
         "@ethereumjs/rlp": "^5.0.2",
         "@ethereumjs/util": "^9.0.3",
+        "debug": "^4.3.4",
         "lru-cache": "10.1.0",
         "verkle-cryptography-wasm": "^0.4.4"
       },
diff --git a/packages/verkle/package.json b/packages/verkle/package.json
index 9644f655f8..eadeb98bec 100644
--- a/packages/verkle/package.json
+++ b/packages/verkle/package.json
@@ -52,6 +52,7 @@
     "tsc": "../../config/cli/ts-compile.sh"
   },
   "dependencies": {
+    "debug": "^4.3.4",
     "lru-cache": "10.1.0",
     "verkle-cryptography-wasm": "^0.4.4",
     "@ethereumjs/block": "^5.2.0",
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 6e2f52cdeb..653b2e32cb 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -7,6 +7,7 @@ import {
   equalsBytes,
   zeros,
 } from '@ethereumjs/util'
+import debug from 'debug'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 
 import { CheckpointDB } from './db/checkpoint.js'
@@ -25,7 +26,7 @@ import { verifyKeyLength } from './util/keys.js'
 
 import type { VerkleCrypto } from './types.js'
 import type { BatchDBOp, DB, PutBatch } from '@ethereumjs/util'
-
+import type { Debugger } from 'debug'
 interface Path {
   node: VerkleNode | null
   remaining: Uint8Array
@@ -53,6 +54,11 @@ export class VerkleTree {
   protected _root: Uint8Array
 
   protected verkleCrypto: VerkleCrypto
+
+  /** Debug logging */
+  protected DEBUG: boolean
+  protected _debug: Debugger = debug('verkle')
+  protected debug: (...args: any) => void
   /**
    * Creates a new verkle tree.
    * @param opts Options for instantiating the verkle tree
@@ -79,6 +85,25 @@ export class VerkleTree {
     }
 
     this.verkleCrypto = opts?.verkleCrypto
+
+    this.DEBUG =
+      typeof window === 'undefined' ? process?.env?.DEBUG?.includes('ethjs') ?? false : false
+    this.debug = this.DEBUG
+      ? (message: string, namespaces: string[] = []) => {
+          let log = this._debug
+          for (const name of namespaces) {
+            log = log.extend(name)
+          }
+          log(message)
+        }
+      : (..._: any) => {}
+
+    this.DEBUG &&
+      this.debug(`Trie created:
+    || Root: ${bytesToHex(this._root)}
+    || Persistent: ${this._opts.useRootPersistence}
+    || CacheSize: ${this._opts.cacheSize}
+    || ----------------`)
   }
 
   static async create(opts?: VerkleTreeOpts) {
@@ -168,15 +193,16 @@ export class VerkleTree {
   async get(key: Uint8Array): Promise<Uint8Array | undefined> {
     verifyKeyLength(key)
     const stem = key.slice(0, 31)
-
+    const suffix = key[key.length - 1]
+    this.DEBUG && this.debug(`Stem: ${bytesToHex(stem)}; Suffix: ${suffix}`, ['GET'])
     const res = await this.findPath(stem)
 
     if (res.node instanceof LeafNode) {
-      const keyLastByte = key[key.length - 1]
-
       // The retrieved leaf node contains an array of 256 possible values.
       // The index of the value we want is at the key's last byte
-      const value = res.node.getValue(keyLastByte)
+      const value = res.node.getValue(suffix)
+      this.DEBUG &&
+        this.debug(`Value: ${value === undefined ? 'undefined' : bytesToHex(value)}`, ['GET'])
       return value
     }
 
@@ -184,15 +210,17 @@ export class VerkleTree {
   }
 
   /**
-   * Stores a given `value` at the given `key` or do a delete if `value` is empty
-   * (delete operations are only executed on DB with `deleteFromDB` set to `true`)
+   * Stores a given `value` at the given `key` or do a delete if `value` is empty Uint8Array
    * @param key - the key to store the value at
    * @param value - the value to store
    * @returns A Promise that resolves once value is stored.
    */
+  // TODO: Decide best path for handling deletes - going with empty array for now
   async put(key: Uint8Array, value: Uint8Array): Promise<void> {
     verifyKeyLength(key)
     const stem = key.slice(0, 31)
+    this.DEBUG && this.debug(`Key: ${bytesToHex(key)}`, ['PUT'])
+    this.DEBUG && this.debug(`Value: ${bytesToHex(value)}`, ['PUT'])
     // A stack of nodes to put/update in the DB once the new leaf node is inserted
     const putStack: [Uint8Array, VerkleNode][] = []
     // Find or create the leaf node
@@ -200,14 +228,17 @@ export class VerkleTree {
     let leafNode = res.node
     const suffix = key[31]
     if (!(leafNode instanceof LeafNode)) {
+      this.DEBUG && this.debug(`Create new leaf node at stem: ${bytesToHex(stem)}`, ['PUT'])
       // If leafNode is missing, create it
       const values: Uint8Array[] = new Array(256).fill(new Uint8Array()) // Create new empty array of 256 values
       values[suffix] = value // Set value at key suffix
-
+      this.DEBUG && this.debug(`Insert value at suffix: ${suffix}`, ['PUT'])
       // Create leaf node
       leafNode = await LeafNode.create(stem, values, res.stack.length, this.verkleCrypto)
     } else {
       // Found the leaf node so update the value (setValue also updates the commitments)
+      this.DEBUG && this.debug(`Foudn leaf node at: ${bytesToHex(stem)}`, ['PUT'])
+      this.DEBUG && this.debug(`Insert value at suffix: ${suffix}`, ['PUT'])
       leafNode.setValue(suffix, value)
     }
 
@@ -225,6 +256,11 @@ export class VerkleTree {
       })
 
       // Update the child node's commitment and path
+      this.DEBUG &&
+        this.debug(
+          `No root node. Creating new root node node and placing leaf commitment at child index: ${key[0]}`,
+          ['PUT']
+        )
       rootNode.children[key[0]] = { commitment: leafNode.commitment, path: stem }
 
       // Update root node commitment using a zero commitment hash for the old scalar value (since this is a new root node)
@@ -262,19 +298,22 @@ export class VerkleTree {
         if (currentDepth === 0) {
           if (res.stack.length > 0)
             throw new Error('cannot have node of depth zero and more nodes in path')
-          // We're at the root node and only need to update the child commitment/path
-          // using the key and commitment from the last node in the putStack
           if (res.remaining.length === 0) {
-            // If we're at depth 0 and the remaining key length is 0,
-            // that means theres a partially matching key so there is either an internal
-            // or leaf node that partially matches the path of the leaf node we're inserting
-            // so we need to update and/or insert internal nodes
+            // We're at the root node and only need to update the child commitment/path
+            // using the key and commitment from the last node in the putStack
             const child: ChildNode = {
               commitment: putStack[putStack.length - 1][1].commitment,
               path: putStack[putStack.length - 1][0],
             }
             currentNode.setChild(index, child)
             putStack.push([ROOT_DB_KEY, currentNode])
+            this.DEBUG &&
+              this.debug(
+                `Updating root node child value at index: ${index} for leaf node with stem: ${bytesToHex(
+                  stem
+                )}`,
+                ['PUT']
+              )
             // Update root
             this.root(this.verkleCrypto.serializeCommitment(currentNode.commitment))
             break
@@ -303,8 +342,13 @@ export class VerkleTree {
             // e.g. If stem is is 010003... the old child reference should be set at
             // position 1 in the parent node's children array (since this is the root node)
             newInternalNode.setChild(oldChild.path[partialStem.length], oldChild)
+            newInternalNode.depth = res.stack.length
             putStack.push([partialStem, newInternalNode])
-
+            this.DEBUG &&
+              this.debug(
+                `Creating new internal node with partial stem: ${bytesToHex(partialStem)} `,
+                ['PUT']
+              )
             const child: ChildNode = {
               commitment: newInternalNode.commitment,
               path: partialStem,
@@ -328,6 +372,7 @@ export class VerkleTree {
    * @param throwIfMissing - if true, throws if any nodes are missing. Used for verifying proofs. (default: false)
    */
   async findPath(key: Uint8Array): Promise<Path> {
+    this.DEBUG && this.debug(`Path (${key.length}): [${bytesToHex(key)}]`, ['FIND_PATH'])
     // TODO: Decide if we should allow keys longer than 31 bytes (since a verkle stem can never be longer than that)
     const result: Path = {
       node: null,
@@ -343,11 +388,16 @@ export class VerkleTree {
 
     const rootNode = decodeNode(rawNode, 0, this.verkleCrypto) as InternalNode
 
+    this.DEBUG &&
+      this.debug(`Starting with Root Node: [${bytesToHex(rootNode.hash())}]`, ['FIND_PATH'])
     result.stack.push(rootNode)
     let child = rootNode.children[key[0]]
 
     // Root node doesn't contain a child node's commitment on the first byte of the path so we're done
-    if (equalsBytes(child.commitment, this.verkleCrypto.zeroCommitment)) return result
+    if (equalsBytes(child.commitment, this.verkleCrypto.zeroCommitment)) {
+      this.DEBUG && this.debug(`Partial Path ${key[0]} - found no child.`, ['FIND_PATH'])
+      return result
+    }
     let finished = false
     while (!finished) {
       rawNode = await this._db.get(child.path)
@@ -365,6 +415,13 @@ export class VerkleTree {
         // i.e. the node doesn't exist in the trie
         finished = true
         if (foundNode) {
+          this.DEBUG &&
+            this.debug(
+              `Path ${bytesToHex(key)} - found full path to node ${bytesToHex(
+                decodedNode.hash()
+              )}.`,
+              ['FIND_PATH']
+            )
           result.node = decodedNode
           result.remaining = new Uint8Array()
           return result
@@ -372,10 +429,26 @@ export class VerkleTree {
         // We found a different node than the one specified by `key`
         // so the sought node doesn't exist
         result.remaining = key.slice(matchingKeyLength)
+        this.DEBUG &&
+          this.debug(
+            `Path ${bytesToHex(
+              key.slice(0, matchingKeyLength)
+            )} - found path to nearest node node ${bytesToHex(
+              decodedNode.hash()
+            )} but target node not found.`,
+            ['FIND_PATH']
+          )
         return result
       }
       // Push internal node to path stack
       result.stack.push(decodedNode)
+      this.DEBUG &&
+        this.debug(
+          `Partial Path ${bytesToHex(
+            key.slice(0, matchingKeyLength)
+          )} - found next node in path ${bytesToHex(decodedNode.hash())}.`,
+          ['FIND_PATH']
+        )
       // Get the next child node in the path
       const childIndex = key[matchingKeyLength]
       child = decodedNode.children[childIndex]
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 7daab37159..42d93a84e1 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -8,9 +8,12 @@ import type { PrefixedHexString } from '@ethereumjs/util'
 
 // Testdata from https://github.com/gballet/go-ethereum/blob/kaustinen-with-shapella/trie/verkle_test.go
 const presentKeys = [
+  // Two keys with the same stem but different suffixes
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d01',
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
+  // A key with a partially matching stem 0x318d to above 2 keys
   '0x318dfa512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
+  // A key with a partially matching stem 0x318dfa51 to above key
   '0x318dfa513b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
   '0xe6ed6c222e3985050b4fc574b136b0a42c63538e9ab970995cd418ba8e526400',
   '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
@@ -64,10 +67,10 @@ describe('Verkle tree', () => {
     assert.deepEqual(res.remaining, presentKeys[0])
 
     // Test that two keys with the same stem store values in the same leaf node
-    for (let i = 0; i < 3; i++) {
+    for (let i = 0; i < 2; i++) {
       await tree.put(presentKeys[i], values[i])
     }
-    for (let i = 0; i < 3; i++) {
+    for (let i = 0; i < 2; i++) {
       const retrievedValue = await tree.get(presentKeys[i])
       if (retrievedValue === undefined) {
         assert.fail('Value not found')
@@ -75,6 +78,29 @@ describe('Verkle tree', () => {
       assert.ok(equalsBytes(retrievedValue, values[i]))
     }
 
+    // Test that one key that partially matches the stems of the two existing keys is inserted (with appropriate internal nodes inserted as well)
+    for (let i = 2; i < 3; i++) {
+      await tree.put(presentKeys[i], values[i])
+    }
+    for (let i = 2; i < 3; i++) {
+      const retrievedValue = await tree.get(presentKeys[i])
+      if (retrievedValue === undefined) {
+        assert.fail('Value not found')
+      }
+      assert.ok(equalsBytes(retrievedValue, values[i]))
+    }
+
+    // Test that one key that with further partial match to the previous key is inserted (with appropriate internal nodes inserted as well)
+    for (let i = 3; i < 4; i++) {
+      await tree.put(presentKeys[i], values[i])
+    }
+    for (let i = 3; i < 4; i++) {
+      const retrievedValue = await tree.get(presentKeys[i])
+      if (retrievedValue === undefined) {
+        assert.fail('Value not found')
+      }
+      assert.ok(equalsBytes(retrievedValue, values[i]))
+    }
     // Get path to node at depth 2 and verify that the whole key is used
     const pathToDeepNode = await tree.findPath(presentKeys[2].slice(0, 31))
     assert.ok(pathToDeepNode.node !== null)
@@ -85,6 +111,5 @@ describe('Verkle tree', () => {
     const pathToNonExistentNode = await tree.findPath(absentKeys[0])
     assert.equal(pathToNonExistentNode.node, null)
     assert.equal(pathToNonExistentNode.stack.length, 2, 'contains the root node in the stack')
-    btoa('bHaJ')
   })
 })

From df22e18e98977a5b60001855d80082bf6375d9f1 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Mon, 17 Jun 2024 18:38:42 -0400
Subject: [PATCH 40/51] More progress [no ci]

---
 packages/verkle/src/verkleTree.ts | 64 +++++++++++++++++++++++++++++--
 1 file changed, 60 insertions(+), 4 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 653b2e32cb..52a60bf3de 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -237,7 +237,7 @@ export class VerkleTree {
       leafNode = await LeafNode.create(stem, values, res.stack.length, this.verkleCrypto)
     } else {
       // Found the leaf node so update the value (setValue also updates the commitments)
-      this.DEBUG && this.debug(`Foudn leaf node at: ${bytesToHex(stem)}`, ['PUT'])
+      this.DEBUG && this.debug(`Found leaf node at: ${bytesToHex(stem)}`, ['PUT'])
       this.DEBUG && this.debug(`Insert value at suffix: ${suffix}`, ['PUT'])
       leafNode.setValue(suffix, value)
     }
@@ -291,8 +291,8 @@ export class VerkleTree {
     while (res.stack.length > 0) {
       // Pop the last node off the path stack
       const currentNode: VerkleNode = res.stack.pop()!
-
       const currentDepth = currentNode.depth
+      // TODO: `index` is computed incorrectly and is invalid at lower levels of the tree.  Figure out how to do this correctly.
       const index = currentKey[0]
       if (currentNode instanceof InternalNode) {
         if (currentDepth === 0) {
@@ -358,8 +358,55 @@ export class VerkleTree {
             currentNode.setChild(stem[0], child)
             putStack.push([ROOT_DB_KEY, currentNode])
           }
+        } else {
+          const updatedChild: ChildNode = {
+            path: putStack[putStack.length - 1][0],
+            commitment: putStack[putStack.length - 1][1].commitment,
+          }
+          // TODO: Figure out if there's an easy to compute the correct partial stem
+          const partialStem = stem.slice(0, matchingBytesLength(key, updatedChild.path) - 2)
+          this.DEBUG && this.debug(`Updating internal node at partial path ${partialStem}`, ['PUT'])
+          currentNode.setChild(updatedChild.path[updatedChild.path.length - 1], updatedChild)
+          putStack.push([partialStem, currentNode])
+        }
+      } else if (currentNode instanceof LeafNode) {
+        // We have a leaf node with a partially matching stem.  We need to insert a new internal node
+        // with a key that is the partial stem up to the the `remaining` stem in the previous findPath result.
+        // This new internal node will contain child references to the existing leaf node as well
+        // as the new leaf node being inserted.
+        const partialStem = stem.slice(0, 31 - res.remaining.length)
+        const newInternalNode = InternalNode.create(currentNode.depth, this.verkleCrypto)
+        // Update leaf node commitment value in new internal node at the
+        // byte position immediately after the partial stem
+        // e.g. If stem is is 010003... and partial stem is 0100, the leaf node child reference
+        // is set at position 3 in the new internal node's children array
+        newInternalNode.setChild(stem[partialStem.length], {
+          commitment: leafNode.commitment,
+          // Path to the leaf node is the full stem
+          path: stem,
+        })
+        // Construct old leaf node child reference
+        const oldLeafNodeChild: ChildNode = {
+          commitment: currentNode.commitment,
+          // Path to the old leaf node
+          path: (currentNode as LeafNode).stem,
         }
-        // TODO: Add logic for updating/adding multiple internal nodes
+        // The position of the "old leaf node child" in the new internal node children array
+        // should be set at the index where the old leaf node's stem diverges from the new leaf node stem
+        // e.g. If the new stem is is 010030... and the old leaf node stem is 010040,
+        // the old child reference should be set at 0x40 and the new leaf node index at 0x30
+        newInternalNode.setChild(oldLeafNodeChild.path[partialStem.length], oldLeafNodeChild)
+
+        // Update the old leaf node depth
+        currentNode.depth = currentNode.depth + 1
+        // Add old leaf node to putStack
+        putStack.push([currentNode.stem, currentNode])
+        // Add new internal node to putStack
+        putStack.push([partialStem, newInternalNode])
+        this.DEBUG &&
+          this.debug(`Creating new internal node with partial stem: ${bytesToHex(partialStem)} `, [
+            'PUT',
+          ])
       }
     }
     await this.saveStack(putStack)
@@ -433,15 +480,17 @@ export class VerkleTree {
           this.debug(
             `Path ${bytesToHex(
               key.slice(0, matchingKeyLength)
-            )} - found path to nearest node node ${bytesToHex(
+            )} - found path to nearest node ${bytesToHex(
               decodedNode.hash()
             )} but target node not found.`,
             ['FIND_PATH']
           )
+        result.stack.push(decodedNode)
         return result
       }
       // Push internal node to path stack
       result.stack.push(decodedNode)
+
       this.DEBUG &&
         this.debug(
           `Partial Path ${bytesToHex(
@@ -453,6 +502,13 @@ export class VerkleTree {
       const childIndex = key[matchingKeyLength]
       child = decodedNode.children[childIndex]
     }
+    this.DEBUG &&
+      this.debug(
+        `Found partial path ${key.slice(
+          31 - result.remaining.length
+        )} but sought node is not present in trie.`,
+        ['FIND_PATH']
+      )
     return result
   }
 

From 69267f71ea33c645f87d4835fcfad5bd332144d4 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Tue, 18 Jun 2024 13:08:46 -0400
Subject: [PATCH 41/51] more half-working fixes [no ci]

---
 packages/verkle/src/node/internalNode.ts | 10 +++---
 packages/verkle/src/verkleTree.ts        | 42 ++++++++++++------------
 packages/verkle/test/verkle.spec.ts      | 13 ++++----
 3 files changed, 33 insertions(+), 32 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 769a47898e..755e51b8ca 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -21,17 +21,17 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
   }
 
   // Updates the commitment value for a child node at the corresponding index
-  setChild(index: number, child: ChildNode) {
+  setChild(childIndex: number, child: ChildNode) {
     // Get previous child commitment at `index`
-    const oldChild = this.children[index]
+    const oldChildReference = this.children[childIndex]
     // Updates the commitment to the child node at `index`
-    this.children[index] = child
+    this.children[childIndex] = { ...child }
     // Updates the overall node commitment based on the update to this child
     this.commitment = this.verkleCrypto.updateCommitment(
       this.commitment,
-      index,
+      childIndex,
       // The hashed child commitments are used when updating the internal node commitment
-      this.verkleCrypto.hashCommitment(oldChild.commitment),
+      this.verkleCrypto.hashCommitment(oldChildReference.commitment),
       this.verkleCrypto.hashCommitment(child.commitment)
     )
   }
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 52a60bf3de..5f25479184 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -30,7 +30,7 @@ import type { Debugger } from 'debug'
 interface Path {
   node: VerkleNode | null
   remaining: Uint8Array
-  stack: VerkleNode[]
+  stack: Array<[VerkleNode, Uint8Array]>
 }
 
 /**
@@ -290,9 +290,9 @@ export class VerkleTree {
     const currentKey = leafNode.stem
     while (res.stack.length > 0) {
       // Pop the last node off the path stack
-      const currentNode: VerkleNode = res.stack.pop()!
+      const [currentNode, currentNodePath] = res.stack.pop()!
       const currentDepth = currentNode.depth
-      // TODO: `index` is computed incorrectly and is invalid at lower levels of the tree.  Figure out how to do this correctly.
+      // TODO: `index` is computed incorrectly and is invalid at lower levels of the tree.  Figure out how to do this correctly (or if needed).
       const index = currentKey[0]
       if (currentNode instanceof InternalNode) {
         if (currentDepth === 0) {
@@ -318,10 +318,7 @@ export class VerkleTree {
             this.root(this.verkleCrypto.serializeCommitment(currentNode.commitment))
             break
           } else {
-            // If we're at depth 0 but the remaining key length is greater than 0,
-            // that means theres a partially matching key so there is either an internal
-            // or leaf node that partially matches the path of the leaf node we're inserting
-            // so we need to update and/or insert internal nodes
+            // TODO: Fix this.  We can't use the res.remaining as a decision point here but should use the last node in the putStack's path
             // We need to insert a new internal node
             // New internal node's path is the partial stem up to the the `remaining` stem in the previous findPath result
             const partialStem = stem.slice(0, 31 - res.remaining.length)
@@ -336,17 +333,20 @@ export class VerkleTree {
               path: stem,
             })
             // Update new internal node value array with previous child reference
-            const oldChild = currentNode.children[stem[0]]
+            const oldChild = { ...currentNode.children[stem[0]] }
+
             // The position of the "old child" in the new internal node children array
             // should be set at the same index as in the parent node
             // e.g. If stem is is 010003... the old child reference should be set at
             // position 1 in the parent node's children array (since this is the root node)
-            newInternalNode.setChild(oldChild.path[partialStem.length], oldChild)
+            newInternalNode.setChild(oldChild.path[0], oldChild)
             newInternalNode.depth = res.stack.length
             putStack.push([partialStem, newInternalNode])
             this.DEBUG &&
               this.debug(
-                `Creating new internal node with partial stem: ${bytesToHex(partialStem)} `,
+                `Creating new internal node at root node with partial stem: ${bytesToHex(
+                  partialStem
+                )} `,
                 ['PUT']
               )
             const child: ChildNode = {
@@ -363,11 +363,11 @@ export class VerkleTree {
             path: putStack[putStack.length - 1][0],
             commitment: putStack[putStack.length - 1][1].commitment,
           }
-          // TODO: Figure out if there's an easy to compute the correct partial stem
-          const partialStem = stem.slice(0, matchingBytesLength(key, updatedChild.path) - 2)
-          this.DEBUG && this.debug(`Updating internal node at partial path ${partialStem}`, ['PUT'])
+
+          this.DEBUG &&
+            this.debug(`Updating internal node at partial path ${currentNodePath}`, ['PUT'])
           currentNode.setChild(updatedChild.path[updatedChild.path.length - 1], updatedChild)
-          putStack.push([partialStem, currentNode])
+          putStack.push([currentNodePath, currentNode])
         }
       } else if (currentNode instanceof LeafNode) {
         // We have a leaf node with a partially matching stem.  We need to insert a new internal node
@@ -404,9 +404,10 @@ export class VerkleTree {
         // Add new internal node to putStack
         putStack.push([partialStem, newInternalNode])
         this.DEBUG &&
-          this.debug(`Creating new internal node with partial stem: ${bytesToHex(partialStem)} `, [
-            'PUT',
-          ])
+          this.debug(
+            `Creating new internal node at depth with partial stem: ${bytesToHex(partialStem)} `,
+            ['PUT']
+          )
       }
     }
     await this.saveStack(putStack)
@@ -437,7 +438,7 @@ export class VerkleTree {
 
     this.DEBUG &&
       this.debug(`Starting with Root Node: [${bytesToHex(rootNode.hash())}]`, ['FIND_PATH'])
-    result.stack.push(rootNode)
+    result.stack.push([rootNode, ROOT_DB_KEY])
     let child = rootNode.children[key[0]]
 
     // Root node doesn't contain a child node's commitment on the first byte of the path so we're done
@@ -485,12 +486,11 @@ export class VerkleTree {
             )} but target node not found.`,
             ['FIND_PATH']
           )
-        result.stack.push(decodedNode)
+        result.stack.push([decodedNode, key.slice(0, matchingKeyLength)])
         return result
       }
       // Push internal node to path stack
-      result.stack.push(decodedNode)
-
+      result.stack.push([decodedNode, key.slice(0, matchingKeyLength)])
       this.DEBUG &&
         this.debug(
           `Partial Path ${bytesToHex(
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 42d93a84e1..5a85a51162 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -101,15 +101,16 @@ describe('Verkle tree', () => {
       }
       assert.ok(equalsBytes(retrievedValue, values[i]))
     }
+    console.log(await tree.findPath(presentKeys[3].slice(0, 31)))
     // Get path to node at depth 2 and verify that the whole key is used
-    const pathToDeepNode = await tree.findPath(presentKeys[2].slice(0, 31))
-    assert.ok(pathToDeepNode.node !== null)
-    assert.equal(pathToDeepNode.remaining.length, 0)
+    // const pathToDeepNode = await tree.findPath(presentKeys[2].slice(0, 31))
+    // assert.ok(pathToDeepNode.node !== null)
+    // assert.equal(pathToDeepNode.remaining.length, 0)
     // Verify that findPath returns a path that demonstrates the nonexistence of a key
     // by returning only the root node (in this instance where the trie has only a root internal node and 1 leaf node)
     // with a different stem than the one passed to `findPath`
-    const pathToNonExistentNode = await tree.findPath(absentKeys[0])
-    assert.equal(pathToNonExistentNode.node, null)
-    assert.equal(pathToNonExistentNode.stack.length, 2, 'contains the root node in the stack')
+    // const pathToNonExistentNode = await tree.findPath(absentKeys[0])
+    // assert.equal(pathToNonExistentNode.node, null)
+    // assert.equal(pathToNonExistentNode.stack.length, 2, 'contains the root node in the stack')
   })
 })

From a38cc80bb3257dcf3a9d6ec197638161893a9b93 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 19 Jun 2024 13:31:15 -0400
Subject: [PATCH 42/51] Fix typing issues and remove walk controller

---
 packages/util/src/verkle.ts                |   2 +
 packages/verkle/src/node/internalNode.ts   |   2 +-
 packages/verkle/src/node/leafNode.ts       |   4 +-
 packages/verkle/src/node/util.ts           |   2 +-
 packages/verkle/src/util/walkController.ts | 145 ---------------------
 packages/verkle/src/verkleTree.ts          |   3 +-
 packages/verkle/test/verkle.spec.ts        |  16 +--
 7 files changed, 15 insertions(+), 159 deletions(-)
 delete mode 100644 packages/verkle/src/util/walkController.ts

diff --git a/packages/util/src/verkle.ts b/packages/util/src/verkle.ts
index 86dc132762..a9bd2918ba 100644
--- a/packages/util/src/verkle.ts
+++ b/packages/util/src/verkle.ts
@@ -43,6 +43,8 @@ export interface VerkleCrypto {
   ) => Uint8Array // Commitment
   zeroCommitment: Uint8Array
   verifyExecutionWitnessPreState: (prestateRoot: string, execution_witness_json: string) => boolean
+  hashCommitment: (commitment: Uint8Array) => Uint8Array
+  serializeCommitment: (commitment: Uint8Array) => Uint8Array
 }
 
 /**
diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 755e51b8ca..4342fab2ea 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -1,4 +1,4 @@
-import { type VerkleCrypto } from '../types.js'
+import { type VerkleCrypto } from '@ethereumjs/util'
 
 import { BaseVerkleNode } from './baseVerkleNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 0008dbf516..480a14410f 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -4,8 +4,8 @@ import { BaseVerkleNode } from './baseVerkleNode.js'
 import { NODE_WIDTH, VerkleNodeType } from './types.js'
 import { createCValues } from './util.js'
 
-import type { VerkleCrypto } from '../types.js'
 import type { VerkleNodeOptions } from './types.js'
+import type { VerkleCrypto } from '@ethereumjs/util'
 
 export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
   public stem: Uint8Array
@@ -151,7 +151,7 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
       setLengthRight(value.slice(16), 32)
     )
     // Update the cCommitment corresponding to the index
-    let oldCCommitment
+    let oldCCommitment: Uint8Array | undefined
     if (index < 128) {
       oldCCommitment = this.c1
       this.c1 = cCommitment
diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
index 4ae17a06e4..cb8a0c33c9 100644
--- a/packages/verkle/src/node/util.ts
+++ b/packages/verkle/src/node/util.ts
@@ -5,7 +5,7 @@ import { InternalNode } from './internalNode.js'
 import { LeafNode } from './leafNode.js'
 import { type VerkleNode, VerkleNodeType } from './types.js'
 
-import type { VerkleCrypto } from '../types.js'
+import type { VerkleCrypto } from '@ethereumjs/util'
 
 // TODO: Make depth optional since we don't always know what it is
 export function decodeRawNode(
diff --git a/packages/verkle/src/util/walkController.ts b/packages/verkle/src/util/walkController.ts
deleted file mode 100644
index 043c742fe9..0000000000
--- a/packages/verkle/src/util/walkController.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import { InternalNode, LeafNode } from '../node/index.js'
-
-import { PrioritizedTaskExecutor } from './tasks.js'
-
-import type { VerkleNode } from '../node/types.js'
-import type { FoundNodeFunction } from '../types.js'
-import type { VerkleTree } from '../verkleTree.js'
-
-/**
- * WalkController is an interface to control how the tree is being traversed.
- */
-export class WalkController {
-  readonly onNode: FoundNodeFunction
-  readonly taskExecutor: PrioritizedTaskExecutor
-  readonly tree: VerkleTree
-  private resolve: Function
-  private reject: Function
-
-  /**
-   * Creates a new WalkController
-   * @param onNode - The `FoundNodeFunction` to call if a node is found.
-   * @param tree - The `VerkleTree` to walk on.
-   * @param poolSize - The size of the task queue.
-   */
-  private constructor(onNode: FoundNodeFunction, tree: VerkleTree, poolSize: number) {
-    this.onNode = onNode
-    this.taskExecutor = new PrioritizedTaskExecutor(poolSize)
-    this.tree = tree
-    this.resolve = () => {}
-    this.reject = () => {}
-  }
-
-  /**
-   * Async function to create and start a new walk over a tree.
-   * @param onNode - The `FoundNodeFunction to call if a node is found.
-   * @param tree - The tree to walk on.
-   * @param root - The root key to walk on.
-   * @param poolSize - Task execution pool size to prevent OOM errors. Defaults to 500.
-   */
-  static async newWalk(
-    onNode: FoundNodeFunction,
-    tree: VerkleTree,
-    root: Uint8Array,
-    poolSize?: number
-  ): Promise<void> {
-    const strategy = new WalkController(onNode, tree, poolSize ?? 500)
-    await strategy.startWalk(root)
-  }
-
-  private async startWalk(root: Uint8Array): Promise<void> {
-    // eslint-disable-next-line no-async-promise-executor
-    return new Promise(async (resolve, reject) => {
-      this.resolve = resolve
-      this.reject = reject
-      let node
-      try {
-        node = await this.tree.lookupNode(root)
-      } catch (error) {
-        return this.reject(error)
-      }
-      this.processNode(root, node, new Uint8Array(0))
-    })
-  }
-
-  /**
-   * Run all children of a node. Priority of these nodes are the key length of the children.
-   * @param node - Node to retrieve all children from of and call onNode on.
-   * @param key - The current `key` which would yield the `node` when trying to get this node with a `get` operation.
-   */
-  allChildren(node: VerkleNode, key: Uint8Array = new Uint8Array()) {
-    if (node instanceof LeafNode) {
-      return
-    }
-
-    const children = node.children.map((nodeRef, index) => ({
-      keyExtension: index,
-      nodeRef,
-    }))
-
-    for (const child of children) {
-      if (child.nodeRef !== null) {
-        const childKey = new Uint8Array([...key, child.keyExtension])
-        this.pushNodeToQueue(child.nodeRef.hash(undefined as any), childKey)
-      }
-    }
-  }
-
-  /**
-   * Push a node to the queue. If the queue has places left for tasks, the node is executed immediately, otherwise it is queued.
-   * @param nodeRef - Push a node reference to the event queue. This reference is a 32-byte keccak hash of the value corresponding to the `key`.
-   * @param key - The current key.
-   * @param priority - Optional priority, defaults to key length
-   */
-  pushNodeToQueue(nodeRef: Uint8Array, key: Uint8Array = new Uint8Array(0), priority?: number) {
-    this.taskExecutor.executeOrQueue(
-      priority ?? key.length,
-      async (taskFinishedCallback: Function) => {
-        let childNode
-        try {
-          childNode = await this.tree.lookupNode(nodeRef)
-        } catch (error: any) {
-          return this.reject(error)
-        }
-        taskFinishedCallback() // this marks the current task as finished. If there are any tasks left in the queue, this will immediately execute the first task.
-        this.processNode(nodeRef, childNode as VerkleNode, key)
-      }
-    )
-  }
-
-  /**
-   * Push the child of an internal node to the event queue.
-   * @param node - The node to select a children from. Should be an InternalNode.
-   * @param key - The current key which leads to the corresponding node.
-   * @param childIndex - The child index to add to the event queue.
-   * @param priority - Optional priority of the event, defaults to the total key length.
-   */
-  pushChildrenAtIndex(
-    node: InternalNode,
-    key: Uint8Array = new Uint8Array(0),
-    childIndex: number,
-    priority?: number
-  ) {
-    if (!(node instanceof InternalNode)) {
-      throw new Error('Expected internal node')
-    }
-    const childRef = node.getChildren(childIndex)
-    if (!childRef) {
-      throw new Error('Could not get node at childIndex')
-    }
-    const childKey = new Uint8Array([...key, childIndex])
-    this.pushNodeToQueue(childRef.hash(undefined as any), childKey, priority ?? childKey.length)
-  }
-
-  private processNode(
-    nodeRef: Uint8Array,
-    node: VerkleNode | null,
-    key: Uint8Array = new Uint8Array(0)
-  ) {
-    this.onNode(nodeRef, node, key, this)
-    if (this.taskExecutor.finished()) {
-      // onNode should schedule new tasks. If no tasks was added and the queue is empty, then we have finished our walk.
-      this.resolve()
-    }
-  }
-}
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 5f25479184..f1130f89f1 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -24,8 +24,7 @@ import {
 import { matchingBytesLength } from './util/index.js'
 import { verifyKeyLength } from './util/keys.js'
 
-import type { VerkleCrypto } from './types.js'
-import type { BatchDBOp, DB, PutBatch } from '@ethereumjs/util'
+import type { BatchDBOp, DB, PutBatch, VerkleCrypto } from '@ethereumjs/util'
 import type { Debugger } from 'debug'
 interface Path {
   node: VerkleNode | null
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 5a85a51162..0fb925ab2e 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -54,7 +54,7 @@ const absentKeys = [
 ].map((key) => hexToBytes(key as PrefixedHexString))
 
 describe('Verkle tree', () => {
-  it('should insert and retrieve values', async () => {
+  it.skip('should insert and retrieve values', async () => {
     const verkleCrypto = await loadVerkleCrypto()
     const tree = await VerkleTree.create({
       verkleCrypto,
@@ -101,16 +101,16 @@ describe('Verkle tree', () => {
       }
       assert.ok(equalsBytes(retrievedValue, values[i]))
     }
-    console.log(await tree.findPath(presentKeys[3].slice(0, 31)))
+
     // Get path to node at depth 2 and verify that the whole key is used
-    // const pathToDeepNode = await tree.findPath(presentKeys[2].slice(0, 31))
-    // assert.ok(pathToDeepNode.node !== null)
-    // assert.equal(pathToDeepNode.remaining.length, 0)
+    const pathToDeepNode = await tree.findPath(presentKeys[2].slice(0, 31))
+    assert.ok(pathToDeepNode.node !== null)
+    assert.equal(pathToDeepNode.remaining.length, 0)
     // Verify that findPath returns a path that demonstrates the nonexistence of a key
     // by returning only the root node (in this instance where the trie has only a root internal node and 1 leaf node)
     // with a different stem than the one passed to `findPath`
-    // const pathToNonExistentNode = await tree.findPath(absentKeys[0])
-    // assert.equal(pathToNonExistentNode.node, null)
-    // assert.equal(pathToNonExistentNode.stack.length, 2, 'contains the root node in the stack')
+    const pathToNonExistentNode = await tree.findPath(absentKeys[0])
+    assert.equal(pathToNonExistentNode.node, null)
+    assert.equal(pathToNonExistentNode.stack.length, 2, 'contains the root node in the stack')
   })
 })

From ce343ae20befcf2d53eeb71f56e2b27a4fb1128c Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 19 Jun 2024 13:31:33 -0400
Subject: [PATCH 43/51] Remove walk controller export [no ci]

---
 packages/verkle/src/util/index.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/verkle/src/util/index.ts b/packages/verkle/src/util/index.ts
index 972e26b441..c9131b1392 100644
--- a/packages/verkle/src/util/index.ts
+++ b/packages/verkle/src/util/index.ts
@@ -1,4 +1,3 @@
 export * from './bytes.js'
 export * from './crypto.js'
 export * from './tasks.js'
-export * from './walkController.js'

From 9c7b214e45a45d73c1d3a6c078a30ad5acecf151 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 19 Jun 2024 14:49:44 -0400
Subject: [PATCH 44/51] Add new test to demonstrate putting values in the trie
 [no ci]

---
 packages/verkle/src/verkleTree.ts   |  20 ++++-
 packages/verkle/test/verkle.spec.ts | 127 +++++++++++++++++++++++++++-
 2 files changed, 141 insertions(+), 6 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index f1130f89f1..fb07776a9f 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -451,6 +451,7 @@ export class VerkleTree {
       // We should always find the node if the path is specified in child.path
       if (rawNode === undefined) throw new Error(`missing node at ${bytesToHex(child.path)}`)
       const decodedNode = decodeNode(rawNode, result.stack.length, this.verkleCrypto)
+
       // Calculate the index of the last matching byte in the key
       const matchingKeyLength = matchingBytesLength(key, child.path)
       const foundNode = equalsBytes(key, child.path)
@@ -512,13 +513,24 @@ export class VerkleTree {
   }
 
   /**
-   * Creates the initial node from an empty tree.
+   * Create empty root node for initializing an empty tree.
    * @private
    */
 
-  // TODO: Decide if we keep this.  I currently have this as part of `put`
-  protected async _createInitialNode(key: Uint8Array, value: Uint8Array): Promise<void> {
-    throw new Error('Not implemented')
+  protected async _createRootNode(): Promise<void> {
+    const rootNode = new InternalNode({
+      commitment: this.verkleCrypto.zeroCommitment,
+      depth: 0,
+      verkleCrypto: this.verkleCrypto,
+    })
+
+    // Update the child node's commitment and path
+    this.DEBUG && this.debug(`No root node. Creating new root node`, ['INITIALIZE'])
+
+    await this.saveStack([[ROOT_DB_KEY, rootNode]])
+    // Set trie root to serialized (aka compressed) commitment for later use in verkle proof
+    this.root(this.verkleCrypto.serializeCommitment(rootNode.commitment))
+    return
   }
 
   /**
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 0fb925ab2e..7cc86bb89f 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -1,10 +1,18 @@
 import { MapDB, equalsBytes, hexToBytes } from '@ethereumjs/util'
 import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
-import { assert, describe, it } from 'vitest'
+import { assert, beforeAll, describe, it } from 'vitest'
 
+import {
+  InternalNode,
+  LeafNode,
+  ROOT_DB_KEY,
+  decodeNode,
+  matchingBytesLength,
+} from '../src/index.js'
 import { VerkleTree } from '../src/verkleTree.js'
 
-import type { PrefixedHexString } from '@ethereumjs/util'
+import type { VerkleNode } from '../src/index.js'
+import type { PrefixedHexString, VerkleCrypto } from '@ethereumjs/util'
 
 // Testdata from https://github.com/gballet/go-ethereum/blob/kaustinen-with-shapella/trie/verkle_test.go
 const presentKeys = [
@@ -114,3 +122,118 @@ describe('Verkle tree', () => {
     assert.equal(pathToNonExistentNode.stack.length, 2, 'contains the root node in the stack')
   })
 })
+
+describe('findPath validation', () => {
+  let verkleCrypto: VerkleCrypto
+  beforeAll(async () => {
+    verkleCrypto = await loadVerkleCrypto()
+  })
+  it('should find the path to various leaf nodes', async () => {
+    const keys = [
+      // Two keys with the same stem but different suffixes
+      '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d01',
+      '0x318dea512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
+      // A key with a partially matching stem 0x318d to above 2 keys
+      '0x318dfa512b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
+      // A key with a partially matching stem 0x318dfa51 to above key
+      '0x318dfa513b6f3237a2d4763cf49bf26de3b617fb0cabe38a97807a5549df4d02',
+    ]
+    const values = [
+      '0x320122e8584be00d000000000000000000000000000000000000000000000000',
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+      '0x0300000000000000000000000000000000000000000000000000000000000000',
+    ]
+    const trie = await VerkleTree.create({
+      verkleCrypto,
+      db: new MapDB<Uint8Array, Uint8Array>(),
+    })
+
+    await trie['_createRootNode']()
+
+    let putStack: [Uint8Array, VerkleNode][] = []
+    const stem1 = hexToBytes(keys[0]).slice(0, 31)
+    // Create first leaf node
+    const leafNode1 = await LeafNode.create(
+      stem1,
+      new Array(256).fill(new Uint8Array(32)),
+      1,
+      verkleCrypto
+    )
+
+    leafNode1.setValue(hexToBytes(keys[0])[31], hexToBytes(values[0]))
+    leafNode1.setValue(hexToBytes(keys[1])[31], hexToBytes(values[1]))
+
+    putStack.push([stem1, leafNode1])
+
+    // Pull root node from DB
+    const rawNode = await trie['_db'].get(ROOT_DB_KEY)
+    const rootNode = decodeNode(rawNode!, 0, verkleCrypto) as InternalNode
+    // Update root node with commitment from leaf node
+    rootNode.setChild(stem1[0], { commitment: leafNode1.commitment, path: stem1 })
+    putStack.push([ROOT_DB_KEY, rootNode])
+    await trie.saveStack(putStack)
+    trie.root(verkleCrypto.serializeCommitment(rootNode.commitment))
+
+    // Verify that path to leaf node can be found from stem
+    const res = await trie.findPath(stem1)
+    assert.deepEqual(res.node?.commitment, leafNode1.commitment)
+
+    // Retrieve a value from the leaf node
+    const val1 = await trie.get(hexToBytes(keys[1]))
+    assert.deepEqual(val1, hexToBytes(values[1]))
+
+    // Put a second leaf node in the tree with a partially matching stem
+    putStack = []
+    const stem2 = hexToBytes(keys[2]).slice(0, 31)
+    const leafNode2 = await LeafNode.create(
+      stem2,
+      new Array(256).fill(new Uint8Array(32)),
+      2,
+      verkleCrypto
+    )
+    leafNode2.setValue(hexToBytes(keys[2])[31], hexToBytes(values[2]))
+    putStack.push([stem2, leafNode2])
+
+    // Update the depth of leafNode1
+    leafNode1.depth = 2
+    putStack.push([stem1, leafNode1])
+
+    // Create new internal node
+    const internalNode1 = InternalNode.create(1, verkleCrypto)
+
+    // Compute the portion of stem1 and stem2 that match
+    // Note: We subtract 1 since we are using 0-indexed arrays
+    const partialMatchingStemIndex = matchingBytesLength(stem1, stem2) - 1
+    // Find the path to the new internal node (the matching portion of stem1 and stem2)
+    const internalNode1Path = stem1.slice(0, partialMatchingStemIndex)
+    // Update the child references for leafNode1 and leafNode 2
+    internalNode1.setChild(stem1[partialMatchingStemIndex], {
+      commitment: leafNode1.commitment,
+      path: stem1,
+    })
+    internalNode1.setChild(stem2[partialMatchingStemIndex], {
+      commitment: leafNode2.commitment,
+      path: stem2,
+    })
+
+    putStack.push([internalNode1Path, internalNode1])
+    // Update rootNode child reference for internal node 1
+    rootNode.setChild(internalNode1Path[0], {
+      commitment: internalNode1.commitment,
+      path: internalNode1Path,
+    })
+    putStack.push([ROOT_DB_KEY, rootNode])
+    await trie.saveStack(putStack)
+    trie.root(verkleCrypto.serializeCommitment(rootNode.commitment))
+    let res2 = await trie.findPath(stem1)
+
+    assert.equal(res2.remaining.length, 0, 'confirm full path was found')
+    assert.equal(res2.stack.length, 2, 'confirm node is at depth 2')
+    res2 = await trie.findPath(stem2)
+    assert.equal(res2.remaining.length, 0, 'confirm full path was found')
+    assert.equal(res2.stack.length, 2, 'confirm node is at depth 2')
+    const val2 = await trie.get(hexToBytes(keys[2]))
+    assert.deepEqual(val2, hexToBytes(values[2]), 'confirm values[2] can be retrieved from trie')
+  })
+})

From ae09bdb2bb43f7c194976c938bf3ce0b9a7ac174 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 19 Jun 2024 14:58:36 -0400
Subject: [PATCH 45/51] Add comment

---
 packages/verkle/test/verkle.spec.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 7cc86bb89f..8f665052e5 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -196,6 +196,7 @@ describe('findPath validation', () => {
     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])
 

From 05bfebdc18be5515b3612e8d70a60b65faf63c6e Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 19 Jun 2024 15:08:30 -0400
Subject: [PATCH 46/51] Remove obsolete references

---
 packages/verkle/src/types.ts | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/packages/verkle/src/types.ts b/packages/verkle/src/types.ts
index 1eb9ae1b87..cf90d0aaad 100644
--- a/packages/verkle/src/types.ts
+++ b/packages/verkle/src/types.ts
@@ -1,7 +1,5 @@
 import { intToBytes, utf8ToBytes } from '@ethereumjs/util'
 
-import type { VerkleNode } from './node/index.js'
-import type { WalkController } from './util/walkController.js'
 import type { DB } from '@ethereumjs/util'
 
 // Field representation of a commitment
@@ -61,13 +59,6 @@ export type Checkpoint = {
   root: Uint8Array
 }
 
-export type FoundNodeFunction = (
-  nodeRef: Uint8Array,
-  node: VerkleNode | null,
-  key: Uint8Array,
-  walkController: WalkController
-) => void
-
 export const ROOT_DB_KEY = utf8ToBytes('__root__')
 
 export enum LeafType {

From 0b4904ccf05a974985cbeb2277ecd7af0cc9d76a Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Wed, 19 Jun 2024 15:30:46 -0400
Subject: [PATCH 47/51] lint

---
 packages/verkle/src/verkleTree.ts | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index fb07776a9f..46a4a6413a 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -537,7 +537,7 @@ export class VerkleTree {
    * Retrieves a node from db by hash.
    */
   // TODO: Decide whether to keep or remove this.  We look up nodes by path/partial path so not sure if we need this or not
-  async lookupNode(node: Uint8Array | Uint8Array[]): Promise<VerkleNode | null> {
+  async lookupNode(_node: Uint8Array | Uint8Array[]): Promise<VerkleNode | null> {
     throw new Error('not implemented')
     // if (isRawNode(node)) {
     //   return decodeRawNode(node)
@@ -562,10 +562,10 @@ export class VerkleTree {
 
   // TODO: Decide if we need this.  Looks like it's left over from the MPT `trie` class
   protected async _updateNode(
-    k: Uint8Array,
-    value: Uint8Array,
-    keyRemainder: Uint8Array,
-    stack: VerkleNode[]
+    _k: Uint8Array,
+    _value: Uint8Array,
+    _keyRemainder: Uint8Array,
+    _stack: VerkleNode[]
   ): Promise<void> {
     throw new Error('Not implemented')
   }
@@ -603,7 +603,7 @@ export class VerkleTree {
    */
 
   // TODO: Decide if we keep or not.
-  async batch(ops: BatchDBOp[]): Promise<void> {
+  async batch(_ops: BatchDBOp[]): Promise<void> {
     throw new Error('Not implemented')
   }
 
@@ -611,7 +611,7 @@ export class VerkleTree {
    * Saves the nodes from a proof into the tree.
    * @param proof
    */
-  async fromProof(proof: Proof): Promise<void> {
+  async fromProof(_proof: Proof): Promise<void> {
     throw new Error('Not implemented')
   }
 
@@ -619,7 +619,7 @@ export class VerkleTree {
    * Creates a proof from a tree and key that can be verified using {@link VerkleTree.verifyProof}.
    * @param key
    */
-  async createProof(key: Uint8Array): Promise<Proof> {
+  async createProof(_key: Uint8Array): Promise<Proof> {
     throw new Error('Not implemented')
   }
 
@@ -635,9 +635,9 @@ export class VerkleTree {
   // TODO: Decide if we need this.  We already have the `verifyProof` functionality in the `verkle-cryptography-wasm` functionality
   // and it doesn't require the use of the trie state to verify.
   async verifyProof(
-    rootHash: Uint8Array,
-    key: Uint8Array,
-    proof: Proof
+    _rootHash: Uint8Array,
+    _key: Uint8Array,
+    _proof: Proof
   ): Promise<Uint8Array | null> {
     throw new Error('Not implemented')
   }

From cd65a9a20daf956130154431f090f1907ab7045f Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Thu, 20 Jun 2024 12:45:29 -0400
Subject: [PATCH 48/51] Remove references to depth and unused API components

---
 packages/verkle/src/node/baseVerkleNode.ts |   2 -
 packages/verkle/src/node/internalNode.ts   |   9 +-
 packages/verkle/src/node/leafNode.ts       |   7 +-
 packages/verkle/src/node/types.ts          |   8 +-
 packages/verkle/src/verkleTree.ts          | 450 +++++++++------------
 packages/verkle/test/crypto.spec.ts        |  12 +-
 packages/verkle/test/internalNode.spec.ts  |  18 +-
 packages/verkle/test/leafNode.spec.ts      |   8 +-
 packages/verkle/test/verkle.spec.ts        |   7 +-
 9 files changed, 214 insertions(+), 307 deletions(-)

diff --git a/packages/verkle/src/node/baseVerkleNode.ts b/packages/verkle/src/node/baseVerkleNode.ts
index d854aa501e..587428a3d6 100644
--- a/packages/verkle/src/node/baseVerkleNode.ts
+++ b/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
   }
 
diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 4342fab2ea..ce1261c409 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/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,
     })
 
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 480a14410f..995297c6bd 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/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
-  }
 }
diff --git a/packages/verkle/src/node/types.ts b/packages/verkle/src/node/types.ts
index 9a9114b6ea..603dba9ed3 100644
--- a/packages/verkle/src/node/types.ts
+++ b/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
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index 46a4a6413a..aa5c75c961 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -13,7 +13,7 @@ import { loadVerkleCrypto } from 'verkle-cryptography-wasm'
 import { CheckpointDB } from './db/checkpoint.js'
 import { InternalNode } from './node/internalNode.js'
 import { LeafNode } from './node/leafNode.js'
-import { type ChildNode, type VerkleNode } from './node/types.js'
+import { type VerkleNode } from './node/types.js'
 import { decodeNode } from './node/util.js'
 import {
   type Proof,
@@ -24,7 +24,7 @@ import {
 import { matchingBytesLength } from './util/index.js'
 import { verifyKeyLength } from './util/keys.js'
 
-import type { BatchDBOp, DB, PutBatch, VerkleCrypto } from '@ethereumjs/util'
+import type { DB, PutBatch, VerkleCrypto } from '@ethereumjs/util'
 import type { Debugger } from 'debug'
 interface Path {
   node: VerkleNode | null
@@ -173,7 +173,7 @@ export class VerkleTree {
    */
   async checkRoot(root: Uint8Array): Promise<boolean> {
     try {
-      const value = await this.lookupNode(root)
+      const value = await this._db.get(root)
       return value !== null
     } catch (error: any) {
       if (error.message === 'Missing node in DB') {
@@ -214,202 +214,196 @@ export class VerkleTree {
    * @param value - the value to store
    * @returns A Promise that resolves once value is stored.
    */
-  // TODO: Decide best path for handling deletes - going with empty array for now
-  async put(key: Uint8Array, value: Uint8Array): Promise<void> {
-    verifyKeyLength(key)
-    const stem = key.slice(0, 31)
-    this.DEBUG && this.debug(`Key: ${bytesToHex(key)}`, ['PUT'])
-    this.DEBUG && this.debug(`Value: ${bytesToHex(value)}`, ['PUT'])
-    // A stack of nodes to put/update in the DB once the new leaf node is inserted
-    const putStack: [Uint8Array, VerkleNode][] = []
-    // Find or create the leaf node
-    const res = await this.findPath(stem)
-    let leafNode = res.node
-    const suffix = key[31]
-    if (!(leafNode instanceof LeafNode)) {
-      this.DEBUG && this.debug(`Create new leaf node at stem: ${bytesToHex(stem)}`, ['PUT'])
-      // If leafNode is missing, create it
-      const values: Uint8Array[] = new Array(256).fill(new Uint8Array()) // Create new empty array of 256 values
-      values[suffix] = value // Set value at key suffix
-      this.DEBUG && this.debug(`Insert value at suffix: ${suffix}`, ['PUT'])
-      // Create leaf node
-      leafNode = await LeafNode.create(stem, values, res.stack.length, this.verkleCrypto)
-    } else {
-      // Found the leaf node so update the value (setValue also updates the commitments)
-      this.DEBUG && this.debug(`Found leaf node at: ${bytesToHex(stem)}`, ['PUT'])
-      this.DEBUG && this.debug(`Insert value at suffix: ${suffix}`, ['PUT'])
-      leafNode.setValue(suffix, value)
-    }
-
-    // Add leaf node to put stack
-    putStack.push([stem, leafNode])
-
-    // No stack returned from `findPath` indicates no root node so let's create one
-    if (res.stack.length === 0) {
-      // Special case where findPath returned early because no root node exists
-      // Create a root node
-      const rootNode = new InternalNode({
-        commitment: this.verkleCrypto.zeroCommitment,
-        depth: 0,
-        verkleCrypto: this.verkleCrypto,
-      })
-
-      // Update the child node's commitment and path
-      this.DEBUG &&
-        this.debug(
-          `No root node. Creating new root node node and placing leaf commitment at child index: ${key[0]}`,
-          ['PUT']
-        )
-      rootNode.children[key[0]] = { commitment: leafNode.commitment, path: stem }
-
-      // Update root node commitment using a zero commitment hash for the old scalar value (since this is a new root node)
-      rootNode.commitment = this.verkleCrypto.updateCommitment(
-        rootNode.commitment,
-        key[0],
-        new Uint8Array(32),
-        this.verkleCrypto.hashCommitment(leafNode.commitment)
-      )
-      // Add root node to put stack
-      putStack.push([ROOT_DB_KEY, rootNode])
-      // TODO: Move depth check to putStack
-      putStack[0][1].depth = 1
-      await this.saveStack(putStack)
-      // Set trie root to serialized (aka compressed) commitment for later use in verkle proof
-      this.root(this.verkleCrypto.serializeCommitment(rootNode.commitment))
-      // We're done so return early
-      return
-    }
+  // TODO: Rewrite following logic in verkle.spec.ts "findPath validation" test
+  async put(_key: Uint8Array, _value: Uint8Array): Promise<void> {
+    throw new Error('not implemented')
+    // verifyKeyLength(key)
+    // const stem = key.slice(0, 31)
+    // this.DEBUG && this.debug(`Key: ${bytesToHex(key)}`, ['PUT'])
+    // this.DEBUG && this.debug(`Value: ${bytesToHex(value)}`, ['PUT'])
+    // // A stack of nodes to put/update in the DB once the new leaf node is inserted
+    // const putStack: [Uint8Array, VerkleNode][] = []
+    // // Find or create the leaf node
+    // const res = await this.findPath(stem)
+    // let leafNode = res.node
+    // const suffix = key[31]
+    // if (!(leafNode instanceof LeafNode)) {
+    //   this.DEBUG && this.debug(`Create new leaf node at stem: ${bytesToHex(stem)}`, ['PUT'])
+    //   // If leafNode is missing, create it
+    //   const values: Uint8Array[] = new Array(256).fill(new Uint8Array()) // Create new empty array of 256 values
+    //   values[suffix] = value // Set value at key suffix
+    //   this.DEBUG && this.debug(`Insert value at suffix: ${suffix}`, ['PUT'])
+    //   // Create leaf node
+    //   leafNode = await LeafNode.create(stem, values, res.stack.length, this.verkleCrypto)
+    // } else {
+    //   // Found the leaf node so update the value (setValue also updates the commitments)
+    //   this.DEBUG && this.debug(`Found leaf node at: ${bytesToHex(stem)}`, ['PUT'])
+    //   this.DEBUG && this.debug(`Insert value at suffix: ${suffix}`, ['PUT'])
+    //   leafNode.setValue(suffix, value)
+    // }
 
-    // Walk up the tree from the nearest node to the leaf and update/insert internal nodes along the way
-
-    // Updating inner nodes
-    // 1. Update `currentNode` child node commitment to leafnode, commitment of `currentNode`, and depth as needed
-    // 2. Walk up result.stack doing the same thing (while inserting new internal nodes as needed and updating lower level node depth as needed)
-    // 3. Use `saveStack` to put all nodes in DB
-    const currentKey = leafNode.stem
-    while (res.stack.length > 0) {
-      // Pop the last node off the path stack
-      const [currentNode, currentNodePath] = res.stack.pop()!
-      const currentDepth = currentNode.depth
-      // TODO: `index` is computed incorrectly and is invalid at lower levels of the tree.  Figure out how to do this correctly (or if needed).
-      const index = currentKey[0]
-      if (currentNode instanceof InternalNode) {
-        if (currentDepth === 0) {
-          if (res.stack.length > 0)
-            throw new Error('cannot have node of depth zero and more nodes in path')
-          if (res.remaining.length === 0) {
-            // We're at the root node and only need to update the child commitment/path
-            // using the key and commitment from the last node in the putStack
-            const child: ChildNode = {
-              commitment: putStack[putStack.length - 1][1].commitment,
-              path: putStack[putStack.length - 1][0],
-            }
-            currentNode.setChild(index, child)
-            putStack.push([ROOT_DB_KEY, currentNode])
-            this.DEBUG &&
-              this.debug(
-                `Updating root node child value at index: ${index} for leaf node with stem: ${bytesToHex(
-                  stem
-                )}`,
-                ['PUT']
-              )
-            // Update root
-            this.root(this.verkleCrypto.serializeCommitment(currentNode.commitment))
-            break
-          } else {
-            // TODO: Fix this.  We can't use the res.remaining as a decision point here but should use the last node in the putStack's path
-            // We need to insert a new internal node
-            // New internal node's path is the partial stem up to the the `remaining` stem in the previous findPath result
-            const partialStem = stem.slice(0, 31 - res.remaining.length)
-            const newInternalNode = InternalNode.create(1, this.verkleCrypto)
-            // Update leaf node commitment value in new internal node at the
-            // byte position immediately after the partial stem
-            // e.g. If stem is is 010003... and partial stem is 0100, the leaf node child reference
-            // is set at position 3 in the new internal node's children array
-            newInternalNode.setChild(stem[partialStem.length], {
-              commitment: leafNode.commitment,
-              // Path to the leaf node is the full stem
-              path: stem,
-            })
-            // Update new internal node value array with previous child reference
-            const oldChild = { ...currentNode.children[stem[0]] }
-
-            // The position of the "old child" in the new internal node children array
-            // should be set at the same index as in the parent node
-            // e.g. If stem is is 010003... the old child reference should be set at
-            // position 1 in the parent node's children array (since this is the root node)
-            newInternalNode.setChild(oldChild.path[0], oldChild)
-            newInternalNode.depth = res.stack.length
-            putStack.push([partialStem, newInternalNode])
-            this.DEBUG &&
-              this.debug(
-                `Creating new internal node at root node with partial stem: ${bytesToHex(
-                  partialStem
-                )} `,
-                ['PUT']
-              )
-            const child: ChildNode = {
-              commitment: newInternalNode.commitment,
-              path: partialStem,
-            }
-            // Current node here is the root node
-            // Update the child reference in the root node to point to the new internal node
-            currentNode.setChild(stem[0], child)
-            putStack.push([ROOT_DB_KEY, currentNode])
-          }
-        } else {
-          const updatedChild: ChildNode = {
-            path: putStack[putStack.length - 1][0],
-            commitment: putStack[putStack.length - 1][1].commitment,
-          }
+    // // Add leaf node to put stack
+    // putStack.push([stem, leafNode])
+
+    // // No stack returned from `findPath` indicates no root node so let's create one
+    // if (res.stack.length === 0) {
+    //   // Special case where findPath returned early because no root node exists
+    //   // Create a root node
+    //   const rootNode = new InternalNode({
+    //     commitment: this.verkleCrypto.zeroCommitment,
+    //     verkleCrypto: this.verkleCrypto,
+    //   })
+
+    //   // Update the child node's commitment and path
+    //   this.DEBUG &&
+    //     this.debug(
+    //       `No root node. Creating new root node node and placing leaf commitment at child index: ${key[0]}`,
+    //       ['PUT']
+    //     )
+    //   rootNode.children[key[0]] = { commitment: leafNode.commitment, path: stem }
+
+    //   // Update root node commitment using a zero commitment hash for the old scalar value (since this is a new root node)
+    //   rootNode.commitment = this.verkleCrypto.updateCommitment(
+    //     rootNode.commitment,
+    //     key[0],
+    //     new Uint8Array(32),
+    //     this.verkleCrypto.hashCommitment(leafNode.commitment)
+    //   )
+    //   // Add root node to put stack
+    //   putStack.push([ROOT_DB_KEY, rootNode])
+    //   await this.saveStack(putStack)
+    //   // Set trie root to serialized (aka compressed) commitment for later use in verkle proof
+    //   this.root(this.verkleCrypto.serializeCommitment(rootNode.commitment))
+    //   // We're done so return early
+    //   return
+    // }
 
-          this.DEBUG &&
-            this.debug(`Updating internal node at partial path ${currentNodePath}`, ['PUT'])
-          currentNode.setChild(updatedChild.path[updatedChild.path.length - 1], updatedChild)
-          putStack.push([currentNodePath, currentNode])
-        }
-      } else if (currentNode instanceof LeafNode) {
-        // We have a leaf node with a partially matching stem.  We need to insert a new internal node
-        // with a key that is the partial stem up to the the `remaining` stem in the previous findPath result.
-        // This new internal node will contain child references to the existing leaf node as well
-        // as the new leaf node being inserted.
-        const partialStem = stem.slice(0, 31 - res.remaining.length)
-        const newInternalNode = InternalNode.create(currentNode.depth, this.verkleCrypto)
-        // Update leaf node commitment value in new internal node at the
-        // byte position immediately after the partial stem
-        // e.g. If stem is is 010003... and partial stem is 0100, the leaf node child reference
-        // is set at position 3 in the new internal node's children array
-        newInternalNode.setChild(stem[partialStem.length], {
-          commitment: leafNode.commitment,
-          // Path to the leaf node is the full stem
-          path: stem,
-        })
-        // Construct old leaf node child reference
-        const oldLeafNodeChild: ChildNode = {
-          commitment: currentNode.commitment,
-          // Path to the old leaf node
-          path: (currentNode as LeafNode).stem,
-        }
-        // The position of the "old leaf node child" in the new internal node children array
-        // should be set at the index where the old leaf node's stem diverges from the new leaf node stem
-        // e.g. If the new stem is is 010030... and the old leaf node stem is 010040,
-        // the old child reference should be set at 0x40 and the new leaf node index at 0x30
-        newInternalNode.setChild(oldLeafNodeChild.path[partialStem.length], oldLeafNodeChild)
-
-        // Update the old leaf node depth
-        currentNode.depth = currentNode.depth + 1
-        // Add old leaf node to putStack
-        putStack.push([currentNode.stem, currentNode])
-        // Add new internal node to putStack
-        putStack.push([partialStem, newInternalNode])
-        this.DEBUG &&
-          this.debug(
-            `Creating new internal node at depth with partial stem: ${bytesToHex(partialStem)} `,
-            ['PUT']
-          )
-      }
-    }
-    await this.saveStack(putStack)
+    // // Walk up the tree from the nearest node to the leaf and update/insert internal nodes along the way
+
+    // // Updating inner nodes
+    // // 1. Update `currentNode` child node commitment to leafnode, commitment of `currentNode`, and depth as needed
+    // // 2. Walk up result.stack doing the same thing (while inserting new internal nodes as needed and updating lower level node depth as needed)
+    // // 3. Use `saveStack` to put all nodes in DB
+    // const currentKey = leafNode.stem
+    // while (res.stack.length > 0) {
+    //   // Pop the last node off the path stack
+    //   const [currentNode, currentNodePath] = res.stack.pop()!
+    //   // TODO: `index` is computed incorrectly and is invalid at lower levels of the tree.  Figure out how to do this correctly (or if needed).
+    //   const index = currentKey[0]
+    //   if (currentNode instanceof InternalNode) {
+    //     if (res.stack.length === 0) {
+    //       if (res.stack.length > 0)
+    //         throw new Error('cannot have node of depth zero and more nodes in path')
+    //       if (res.remaining.length === 0) {
+    //         // We're at the root node and only need to update the child commitment/path
+    //         // using the key and commitment from the last node in the putStack
+    //         const child: ChildNode = {
+    //           commitment: putStack[putStack.length - 1][1].commitment,
+    //           path: putStack[putStack.length - 1][0],
+    //         }
+    //         currentNode.setChild(index, child)
+    //         putStack.push([ROOT_DB_KEY, currentNode])
+    //         this.DEBUG &&
+    //           this.debug(
+    //             `Updating root node child value at index: ${index} for leaf node with stem: ${bytesToHex(
+    //               stem
+    //             )}`,
+    //             ['PUT']
+    //           )
+    //         // Update root
+    //         this.root(this.verkleCrypto.serializeCommitment(currentNode.commitment))
+    //         break
+    //       } else {
+    //         // TODO: Fix this.  We can't use the res.remaining as a decision point here but should use the last node in the putStack's path
+    //         // We need to insert a new internal node
+    //         // New internal node's path is the partial stem up to the the `remaining` stem in the previous findPath result
+    //         const partialStem = stem.slice(0, 31 - res.remaining.length)
+    //         const newInternalNode = InternalNode.create(this.verkleCrypto)
+    //         // Update leaf node commitment value in new internal node at the
+    //         // byte position immediately after the partial stem
+    //         // e.g. If stem is is 010003... and partial stem is 0100, the leaf node child reference
+    //         // is set at position 3 in the new internal node's children array
+    //         newInternalNode.setChild(stem[partialStem.length], {
+    //           commitment: leafNode.commitment,
+    //           // Path to the leaf node is the full stem
+    //           path: stem,
+    //         })
+    //         // Update new internal node value array with previous child reference
+    //         const oldChild = { ...currentNode.children[stem[0]] }
+
+    //         // The position of the "old child" in the new internal node children array
+    //         // should be set at the same index as in the parent node
+    //         // e.g. If stem is is 010003... the old child reference should be set at
+    //         // position 1 in the parent node's children array (since this is the root node)
+    //         newInternalNode.setChild(oldChild.path[0], oldChild)
+    //         putStack.push([partialStem, newInternalNode])
+    //         this.DEBUG &&
+    //           this.debug(
+    //             `Creating new internal node at root node with partial stem: ${bytesToHex(
+    //               partialStem
+    //             )} `,
+    //             ['PUT']
+    //           )
+    //         const child: ChildNode = {
+    //           commitment: newInternalNode.commitment,
+    //           path: partialStem,
+    //         }
+    //         // Current node here is the root node
+    //         // Update the child reference in the root node to point to the new internal node
+    //         currentNode.setChild(stem[0], child)
+    //         putStack.push([ROOT_DB_KEY, currentNode])
+    //       }
+    //     } else {
+    //       const updatedChild: ChildNode = {
+    //         path: putStack[putStack.length - 1][0],
+    //         commitment: putStack[putStack.length - 1][1].commitment,
+    //       }
+
+    //       this.DEBUG &&
+    //         this.debug(`Updating internal node at partial path ${currentNodePath}`, ['PUT'])
+    //       currentNode.setChild(updatedChild.path[updatedChild.path.length - 1], updatedChild)
+    //       putStack.push([currentNodePath, currentNode])
+    //     }
+    //   } else if (currentNode instanceof LeafNode) {
+    //     // We have a leaf node with a partially matching stem.  We need to insert a new internal node
+    //     // with a key that is the partial stem up to the the `remaining` stem in the previous findPath result.
+    //     // This new internal node will contain child references to the existing leaf node as well
+    //     // as the new leaf node being inserted.
+    //     const partialStem = stem.slice(0, 31 - res.remaining.length)
+    //     const newInternalNode = InternalNode.create(this.verkleCrypto)
+    //     // Update leaf node commitment value in new internal node at the
+    //     // byte position immediately after the partial stem
+    //     // e.g. If stem is is 010003... and partial stem is 0100, the leaf node child reference
+    //     // is set at position 3 in the new internal node's children array
+    //     newInternalNode.setChild(stem[partialStem.length], {
+    //       commitment: leafNode.commitment,
+    //       // Path to the leaf node is the full stem
+    //       path: stem,
+    //     })
+    //     // Construct old leaf node child reference
+    //     const oldLeafNodeChild: ChildNode = {
+    //       commitment: currentNode.commitment,
+    //       // Path to the old leaf node
+    //       path: (currentNode as LeafNode).stem,
+    //     }
+    //     // The position of the "old leaf node child" in the new internal node children array
+    //     // should be set at the index where the old leaf node's stem diverges from the new leaf node stem
+    //     // e.g. If the new stem is is 010030... and the old leaf node stem is 010040,
+    //     // the old child reference should be set at 0x40 and the new leaf node index at 0x30
+    //     newInternalNode.setChild(oldLeafNodeChild.path[partialStem.length], oldLeafNodeChild)
+
+    //     // Add old leaf node to putStack
+    //     putStack.push([currentNode.stem, currentNode])
+    //     // Add new internal node to putStack
+    //     putStack.push([partialStem, newInternalNode])
+    //     this.DEBUG &&
+    //       this.debug(
+    //         `Creating new internal node at depth with partial stem: ${bytesToHex(partialStem)} `,
+    //         ['PUT']
+    //       )
+    //   }
+    // }
+    // await this.saveStack(putStack)
   }
 
   /**
@@ -520,7 +514,6 @@ export class VerkleTree {
   protected async _createRootNode(): Promise<void> {
     const rootNode = new InternalNode({
       commitment: this.verkleCrypto.zeroCommitment,
-      depth: 0,
       verkleCrypto: this.verkleCrypto,
     })
 
@@ -533,43 +526,6 @@ export class VerkleTree {
     return
   }
 
-  /**
-   * Retrieves a node from db by hash.
-   */
-  // TODO: Decide whether to keep or remove this.  We look up nodes by path/partial path so not sure if we need this or not
-  async lookupNode(_node: Uint8Array | Uint8Array[]): Promise<VerkleNode | null> {
-    throw new Error('not implemented')
-    // if (isRawNode(node)) {
-    //   return decodeRawNode(node)
-    // }
-    // const value = await this._db.get(node)
-    // if (value !== undefined) {
-    //   return decodeNode(value)
-    // } else {
-    //   // Dev note: this error message text is used for error checking in `checkRoot`, `verifyProof`, and `findPath`
-    //   throw new Error('Missing node in DB')
-    // }
-  }
-
-  /**
-   * Updates a node.
-   * @private
-   * @param key
-   * @param value
-   * @param keyRemainder
-   * @param stack
-   */
-
-  // TODO: Decide if we need this.  Looks like it's left over from the MPT `trie` class
-  protected async _updateNode(
-    _k: Uint8Array,
-    _value: Uint8Array,
-    _keyRemainder: Uint8Array,
-    _stack: VerkleNode[]
-  ): Promise<void> {
-    throw new Error('Not implemented')
-  }
-
   /**
    * Saves a stack of nodes to the database.
    *
@@ -587,26 +543,6 @@ export class VerkleTree {
     await this._db.batch(opStack)
   }
 
-  /**
-   * The given hash of operations (key additions or deletions) are executed on the tree
-   * (delete operations are only executed on DB with `deleteFromDB` set to `true`)
-   * @example
-   * const ops = [
-   *    { type: 'del', key: Uint8Array.from('father') }
-   *  , { type: 'put', key: Uint8Array.from('name'), value: Uint8Array.from('Yuri Irsenovich Kim') }
-   *  , { type: 'put', key: Uint8Array.from('dob'), value: Uint8Array.from('16 February 1941') }
-   *  , { type: 'put', key: Uint8Array.from('spouse'), value: Uint8Array.from('Kim Young-sook') }
-   *  , { type: 'put', key: Uint8Array.from('occupation'), value: Uint8Array.from('Clown') }
-   * ]
-   * await tree.batch(ops)
-   * @param ops
-   */
-
-  // TODO: Decide if we keep or not.
-  async batch(_ops: BatchDBOp[]): Promise<void> {
-    throw new Error('Not implemented')
-  }
-
   /**
    * Saves the nodes from a proof into the tree.
    * @param proof
@@ -631,9 +567,6 @@ export class VerkleTree {
    * @throws If proof is found to be invalid.
    * @returns The value from the key, or null if valid proof of non-existence.
    */
-
-  // TODO: Decide if we need this.  We already have the `verifyProof` functionality in the `verkle-cryptography-wasm` functionality
-  // and it doesn't require the use of the trie state to verify.
   async verifyProof(
     _rootHash: Uint8Array,
     _key: Uint8Array,
@@ -679,6 +612,7 @@ export class VerkleTree {
   /**
    * Persists the root hash in the underlying database
    */
+  // TODO: Fix how we reference the root node in `findPath` so this method will work correctly
   async persistRoot() {
     if (this._opts.useRootPersistence) {
       await this._db.put(ROOT_DB_KEY, this.root())
diff --git a/packages/verkle/test/crypto.spec.ts b/packages/verkle/test/crypto.spec.ts
index c6f21af379..3822185aab 100644
--- a/packages/verkle/test/crypto.spec.ts
+++ b/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 () => {
diff --git a/packages/verkle/test/internalNode.spec.ts b/packages/verkle/test/internalNode.spec.ts
index 09005ca8f1..c3aa908faa 100644
--- a/packages/verkle/test/internalNode.spec.ts
+++ b/packages/verkle/test/internalNode.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 { 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 () => {
@@ -14,15 +12,10 @@ describe('verkle node - internal', () => {
   })
   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,8 +26,7 @@ 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(
@@ -42,7 +34,6 @@ describe('verkle node - internal', () => {
       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()
diff --git a/packages/verkle/test/leafNode.spec.ts b/packages/verkle/test/leafNode.spec.ts
index 1ab4c63de9..94af59863b 100644
--- a/packages/verkle/test/leafNode.spec.ts
+++ b/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 () => {
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 8f665052e5..83d236b755 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/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

From 3ab0700bd04c443b52ce6a9b3e4d7e78dc92eaaf Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 21 Jun 2024 09:10:23 -0400
Subject: [PATCH 49/51] Update packages/verkle/src/node/internalNode.ts

Co-authored-by: Gabriel Rocheleau <contact@rockwaterweb.com>
---
 packages/verkle/src/node/internalNode.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index ce1261c409..03f9c020d2 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -64,7 +64,6 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
   /**
    * Generates a new Internal node with default commitment
    */
-
   static create(verkleCrypto: VerkleCrypto): InternalNode {
     const node = new InternalNode({
       commitment: verkleCrypto.zeroCommitment,

From 720ab09240aae7b53202daaa816f92084bb719e0 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 21 Jun 2024 09:24:59 -0400
Subject: [PATCH 50/51] Address feedback

---
 packages/verkle/src/node/internalNode.ts |   6 +-
 packages/verkle/src/node/leafNode.ts     |   6 +-
 packages/verkle/src/node/util.ts         |  15 +-
 packages/verkle/src/types.ts             |   3 -
 packages/verkle/src/verkleTree.ts        | 192 +----------------------
 5 files changed, 10 insertions(+), 212 deletions(-)

diff --git a/packages/verkle/src/node/internalNode.ts b/packages/verkle/src/node/internalNode.ts
index 03f9c020d2..21d95fdc92 100644
--- a/packages/verkle/src/node/internalNode.ts
+++ b/packages/verkle/src/node/internalNode.ts
@@ -36,11 +36,7 @@ export class InternalNode extends BaseVerkleNode<VerkleNodeType.Internal> {
     )
   }
 
-  static fromRawNode(
-    rawNode: Uint8Array[],
-    depth: number,
-    verkleCrypto: VerkleCrypto
-  ): InternalNode {
+  static fromRawNode(rawNode: Uint8Array[], verkleCrypto: VerkleCrypto): InternalNode {
     const nodeType = rawNode[0][0]
     if (nodeType !== VerkleNodeType.Internal) {
       throw new Error('Invalid node type')
diff --git a/packages/verkle/src/node/leafNode.ts b/packages/verkle/src/node/leafNode.ts
index 995297c6bd..33e0aba77e 100644
--- a/packages/verkle/src/node/leafNode.ts
+++ b/packages/verkle/src/node/leafNode.ts
@@ -24,17 +24,15 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
   }
 
   /**
-   * Create a new leaf node from a stem, values, and depth
+   * Create a new leaf node from a stem and values
    * @param stem the 31 byte stem corresponding to the where the leaf node should be placed in the trie
    * @param values the 256 element array of 32 byte values stored in the leaf node
-   * @param depth the depth of the leafnode
    * @param verkleCrypto the verkle cryptography interface
    * @returns an instantiated leaf node with commitments defined
    */
   static async create(
     stem: Uint8Array,
     values: Uint8Array[],
-    depth: number,
     verkleCrypto: VerkleCrypto
   ): Promise<LeafNode> {
     // Generate the value arrays for c1 and c2
@@ -94,7 +92,7 @@ export class LeafNode extends BaseVerkleNode<VerkleNodeType.Leaf> {
     })
   }
 
-  static fromRawNode(rawNode: Uint8Array[], depth: number, verkleCrypto: VerkleCrypto): LeafNode {
+  static fromRawNode(rawNode: Uint8Array[], verkleCrypto: VerkleCrypto): LeafNode {
     const nodeType = rawNode[0][0]
     if (nodeType !== VerkleNodeType.Leaf) {
       throw new Error('Invalid node type')
diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
index cb8a0c33c9..e160ead71d 100644
--- a/packages/verkle/src/node/util.ts
+++ b/packages/verkle/src/node/util.ts
@@ -7,29 +7,24 @@ import { type VerkleNode, VerkleNodeType } from './types.js'
 
 import type { VerkleCrypto } from '@ethereumjs/util'
 
-// TODO: Make depth optional since we don't always know what it is
-export function decodeRawNode(
-  raw: Uint8Array[],
-  depth: number,
-  verkleCrypto: VerkleCrypto
-): VerkleNode {
+export function decodeRawNode(raw: Uint8Array[], verkleCrypto: VerkleCrypto): VerkleNode {
   const nodeType = raw[0][0]
   switch (nodeType) {
     case VerkleNodeType.Internal:
-      return InternalNode.fromRawNode(raw, depth, verkleCrypto)
+      return InternalNode.fromRawNode(raw, verkleCrypto)
     case VerkleNodeType.Leaf:
-      return LeafNode.fromRawNode(raw, depth, verkleCrypto)
+      return LeafNode.fromRawNode(raw, verkleCrypto)
     default:
       throw new Error('Invalid node type')
   }
 }
 
-export function decodeNode(raw: Uint8Array, depth: number, verkleCrypto: VerkleCrypto) {
+export function decodeNode(raw: Uint8Array, verkleCrypto: VerkleCrypto) {
   const decoded = RLP.decode(Uint8Array.from(raw)) as Uint8Array[]
   if (!Array.isArray(decoded)) {
     throw new Error('Invalid node')
   }
-  return decodeRawNode(decoded, depth, verkleCrypto)
+  return decodeRawNode(decoded, verkleCrypto)
 }
 
 export function isRawNode(node: Uint8Array | Uint8Array[]): node is Uint8Array[] {
diff --git a/packages/verkle/src/types.ts b/packages/verkle/src/types.ts
index cf90d0aaad..1c1374d3d2 100644
--- a/packages/verkle/src/types.ts
+++ b/packages/verkle/src/types.ts
@@ -79,6 +79,3 @@ export const HEADER_STORAGE_OFFSET = 64
 export const CODE_OFFSET = 128
 export const VERKLE_NODE_WIDTH = 256
 export const MAIN_STORAGE_OFFSET = BigInt(256) ** BigInt(31)
-
-export const zeroValues = new Array(256).fill(new Uint8Array())
-export const zeroCValues = new Array(128).fill(new Uint8Array())
diff --git a/packages/verkle/src/verkleTree.ts b/packages/verkle/src/verkleTree.ts
index aa5c75c961..086b501925 100644
--- a/packages/verkle/src/verkleTree.ts
+++ b/packages/verkle/src/verkleTree.ts
@@ -217,193 +217,6 @@ export class VerkleTree {
   // TODO: Rewrite following logic in verkle.spec.ts "findPath validation" test
   async put(_key: Uint8Array, _value: Uint8Array): Promise<void> {
     throw new Error('not implemented')
-    // verifyKeyLength(key)
-    // const stem = key.slice(0, 31)
-    // this.DEBUG && this.debug(`Key: ${bytesToHex(key)}`, ['PUT'])
-    // this.DEBUG && this.debug(`Value: ${bytesToHex(value)}`, ['PUT'])
-    // // A stack of nodes to put/update in the DB once the new leaf node is inserted
-    // const putStack: [Uint8Array, VerkleNode][] = []
-    // // Find or create the leaf node
-    // const res = await this.findPath(stem)
-    // let leafNode = res.node
-    // const suffix = key[31]
-    // if (!(leafNode instanceof LeafNode)) {
-    //   this.DEBUG && this.debug(`Create new leaf node at stem: ${bytesToHex(stem)}`, ['PUT'])
-    //   // If leafNode is missing, create it
-    //   const values: Uint8Array[] = new Array(256).fill(new Uint8Array()) // Create new empty array of 256 values
-    //   values[suffix] = value // Set value at key suffix
-    //   this.DEBUG && this.debug(`Insert value at suffix: ${suffix}`, ['PUT'])
-    //   // Create leaf node
-    //   leafNode = await LeafNode.create(stem, values, res.stack.length, this.verkleCrypto)
-    // } else {
-    //   // Found the leaf node so update the value (setValue also updates the commitments)
-    //   this.DEBUG && this.debug(`Found leaf node at: ${bytesToHex(stem)}`, ['PUT'])
-    //   this.DEBUG && this.debug(`Insert value at suffix: ${suffix}`, ['PUT'])
-    //   leafNode.setValue(suffix, value)
-    // }
-
-    // // Add leaf node to put stack
-    // putStack.push([stem, leafNode])
-
-    // // No stack returned from `findPath` indicates no root node so let's create one
-    // if (res.stack.length === 0) {
-    //   // Special case where findPath returned early because no root node exists
-    //   // Create a root node
-    //   const rootNode = new InternalNode({
-    //     commitment: this.verkleCrypto.zeroCommitment,
-    //     verkleCrypto: this.verkleCrypto,
-    //   })
-
-    //   // Update the child node's commitment and path
-    //   this.DEBUG &&
-    //     this.debug(
-    //       `No root node. Creating new root node node and placing leaf commitment at child index: ${key[0]}`,
-    //       ['PUT']
-    //     )
-    //   rootNode.children[key[0]] = { commitment: leafNode.commitment, path: stem }
-
-    //   // Update root node commitment using a zero commitment hash for the old scalar value (since this is a new root node)
-    //   rootNode.commitment = this.verkleCrypto.updateCommitment(
-    //     rootNode.commitment,
-    //     key[0],
-    //     new Uint8Array(32),
-    //     this.verkleCrypto.hashCommitment(leafNode.commitment)
-    //   )
-    //   // Add root node to put stack
-    //   putStack.push([ROOT_DB_KEY, rootNode])
-    //   await this.saveStack(putStack)
-    //   // Set trie root to serialized (aka compressed) commitment for later use in verkle proof
-    //   this.root(this.verkleCrypto.serializeCommitment(rootNode.commitment))
-    //   // We're done so return early
-    //   return
-    // }
-
-    // // Walk up the tree from the nearest node to the leaf and update/insert internal nodes along the way
-
-    // // Updating inner nodes
-    // // 1. Update `currentNode` child node commitment to leafnode, commitment of `currentNode`, and depth as needed
-    // // 2. Walk up result.stack doing the same thing (while inserting new internal nodes as needed and updating lower level node depth as needed)
-    // // 3. Use `saveStack` to put all nodes in DB
-    // const currentKey = leafNode.stem
-    // while (res.stack.length > 0) {
-    //   // Pop the last node off the path stack
-    //   const [currentNode, currentNodePath] = res.stack.pop()!
-    //   // TODO: `index` is computed incorrectly and is invalid at lower levels of the tree.  Figure out how to do this correctly (or if needed).
-    //   const index = currentKey[0]
-    //   if (currentNode instanceof InternalNode) {
-    //     if (res.stack.length === 0) {
-    //       if (res.stack.length > 0)
-    //         throw new Error('cannot have node of depth zero and more nodes in path')
-    //       if (res.remaining.length === 0) {
-    //         // We're at the root node and only need to update the child commitment/path
-    //         // using the key and commitment from the last node in the putStack
-    //         const child: ChildNode = {
-    //           commitment: putStack[putStack.length - 1][1].commitment,
-    //           path: putStack[putStack.length - 1][0],
-    //         }
-    //         currentNode.setChild(index, child)
-    //         putStack.push([ROOT_DB_KEY, currentNode])
-    //         this.DEBUG &&
-    //           this.debug(
-    //             `Updating root node child value at index: ${index} for leaf node with stem: ${bytesToHex(
-    //               stem
-    //             )}`,
-    //             ['PUT']
-    //           )
-    //         // Update root
-    //         this.root(this.verkleCrypto.serializeCommitment(currentNode.commitment))
-    //         break
-    //       } else {
-    //         // TODO: Fix this.  We can't use the res.remaining as a decision point here but should use the last node in the putStack's path
-    //         // We need to insert a new internal node
-    //         // New internal node's path is the partial stem up to the the `remaining` stem in the previous findPath result
-    //         const partialStem = stem.slice(0, 31 - res.remaining.length)
-    //         const newInternalNode = InternalNode.create(this.verkleCrypto)
-    //         // Update leaf node commitment value in new internal node at the
-    //         // byte position immediately after the partial stem
-    //         // e.g. If stem is is 010003... and partial stem is 0100, the leaf node child reference
-    //         // is set at position 3 in the new internal node's children array
-    //         newInternalNode.setChild(stem[partialStem.length], {
-    //           commitment: leafNode.commitment,
-    //           // Path to the leaf node is the full stem
-    //           path: stem,
-    //         })
-    //         // Update new internal node value array with previous child reference
-    //         const oldChild = { ...currentNode.children[stem[0]] }
-
-    //         // The position of the "old child" in the new internal node children array
-    //         // should be set at the same index as in the parent node
-    //         // e.g. If stem is is 010003... the old child reference should be set at
-    //         // position 1 in the parent node's children array (since this is the root node)
-    //         newInternalNode.setChild(oldChild.path[0], oldChild)
-    //         putStack.push([partialStem, newInternalNode])
-    //         this.DEBUG &&
-    //           this.debug(
-    //             `Creating new internal node at root node with partial stem: ${bytesToHex(
-    //               partialStem
-    //             )} `,
-    //             ['PUT']
-    //           )
-    //         const child: ChildNode = {
-    //           commitment: newInternalNode.commitment,
-    //           path: partialStem,
-    //         }
-    //         // Current node here is the root node
-    //         // Update the child reference in the root node to point to the new internal node
-    //         currentNode.setChild(stem[0], child)
-    //         putStack.push([ROOT_DB_KEY, currentNode])
-    //       }
-    //     } else {
-    //       const updatedChild: ChildNode = {
-    //         path: putStack[putStack.length - 1][0],
-    //         commitment: putStack[putStack.length - 1][1].commitment,
-    //       }
-
-    //       this.DEBUG &&
-    //         this.debug(`Updating internal node at partial path ${currentNodePath}`, ['PUT'])
-    //       currentNode.setChild(updatedChild.path[updatedChild.path.length - 1], updatedChild)
-    //       putStack.push([currentNodePath, currentNode])
-    //     }
-    //   } else if (currentNode instanceof LeafNode) {
-    //     // We have a leaf node with a partially matching stem.  We need to insert a new internal node
-    //     // with a key that is the partial stem up to the the `remaining` stem in the previous findPath result.
-    //     // This new internal node will contain child references to the existing leaf node as well
-    //     // as the new leaf node being inserted.
-    //     const partialStem = stem.slice(0, 31 - res.remaining.length)
-    //     const newInternalNode = InternalNode.create(this.verkleCrypto)
-    //     // Update leaf node commitment value in new internal node at the
-    //     // byte position immediately after the partial stem
-    //     // e.g. If stem is is 010003... and partial stem is 0100, the leaf node child reference
-    //     // is set at position 3 in the new internal node's children array
-    //     newInternalNode.setChild(stem[partialStem.length], {
-    //       commitment: leafNode.commitment,
-    //       // Path to the leaf node is the full stem
-    //       path: stem,
-    //     })
-    //     // Construct old leaf node child reference
-    //     const oldLeafNodeChild: ChildNode = {
-    //       commitment: currentNode.commitment,
-    //       // Path to the old leaf node
-    //       path: (currentNode as LeafNode).stem,
-    //     }
-    //     // The position of the "old leaf node child" in the new internal node children array
-    //     // should be set at the index where the old leaf node's stem diverges from the new leaf node stem
-    //     // e.g. If the new stem is is 010030... and the old leaf node stem is 010040,
-    //     // the old child reference should be set at 0x40 and the new leaf node index at 0x30
-    //     newInternalNode.setChild(oldLeafNodeChild.path[partialStem.length], oldLeafNodeChild)
-
-    //     // Add old leaf node to putStack
-    //     putStack.push([currentNode.stem, currentNode])
-    //     // Add new internal node to putStack
-    //     putStack.push([partialStem, newInternalNode])
-    //     this.DEBUG &&
-    //       this.debug(
-    //         `Creating new internal node at depth with partial stem: ${bytesToHex(partialStem)} `,
-    //         ['PUT']
-    //       )
-    //   }
-    // }
-    // await this.saveStack(putStack)
   }
 
   /**
@@ -414,7 +227,6 @@ export class VerkleTree {
    */
   async findPath(key: Uint8Array): Promise<Path> {
     this.DEBUG && this.debug(`Path (${key.length}): [${bytesToHex(key)}]`, ['FIND_PATH'])
-    // TODO: Decide if we should allow keys longer than 31 bytes (since a verkle stem can never be longer than that)
     const result: Path = {
       node: null,
       stack: [],
@@ -427,7 +239,7 @@ export class VerkleTree {
     if (rawNode === undefined)
       throw new Error('root node should exist when root not empty tree root')
 
-    const rootNode = decodeNode(rawNode, 0, this.verkleCrypto) as InternalNode
+    const rootNode = decodeNode(rawNode, this.verkleCrypto) as InternalNode
 
     this.DEBUG &&
       this.debug(`Starting with Root Node: [${bytesToHex(rootNode.hash())}]`, ['FIND_PATH'])
@@ -444,7 +256,7 @@ export class VerkleTree {
       rawNode = await this._db.get(child.path)
       // We should always find the node if the path is specified in child.path
       if (rawNode === undefined) throw new Error(`missing node at ${bytesToHex(child.path)}`)
-      const decodedNode = decodeNode(rawNode, result.stack.length, this.verkleCrypto)
+      const decodedNode = decodeNode(rawNode, this.verkleCrypto)
 
       // Calculate the index of the last matching byte in the key
       const matchingKeyLength = matchingBytesLength(key, child.path)

From b47fa49cc9335ff9e001c4bf21977ae6d97291f5 Mon Sep 17 00:00:00 2001
From: acolytec3 <17355484+acolytec3@users.noreply.github.com>
Date: Fri, 21 Jun 2024 09:41:15 -0400
Subject: [PATCH 51/51] fix tests

---
 packages/verkle/test/leafNode.spec.ts | 4 ++--
 packages/verkle/test/verkle.spec.ts   | 4 +---
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/packages/verkle/test/leafNode.spec.ts b/packages/verkle/test/leafNode.spec.ts
index 94af59863b..6e59f2537e 100644
--- a/packages/verkle/test/leafNode.spec.ts
+++ b/packages/verkle/test/leafNode.spec.ts
@@ -45,7 +45,7 @@ describe('verkle node - leaf', () => {
     const values = new Array<Uint8Array>(256).fill(new Uint8Array(32))
     values[2] = value
     const stem = key.slice(0, 31)
-    const node = await LeafNode.create(stem, values, 0, verkleCrypto)
+    const node = await LeafNode.create(stem, values, verkleCrypto)
     assert.ok(node instanceof LeafNode)
   })
 
@@ -53,7 +53,7 @@ describe('verkle node - leaf', () => {
     const key = randomBytes(32)
     const stem = key.slice(0, 31)
     const values = new Array<Uint8Array>(256).fill(new Uint8Array(32))
-    const node = await LeafNode.create(stem, values, 0, verkleCrypto)
+    const node = await LeafNode.create(stem, values, verkleCrypto)
     assert.deepEqual(node.c1, verkleCrypto.zeroCommitment)
     node.setValue(0, randomBytes(32))
     assert.notDeepEqual(node.c1, verkleCrypto.zeroCommitment)
diff --git a/packages/verkle/test/verkle.spec.ts b/packages/verkle/test/verkle.spec.ts
index 83d236b755..36a3ff3d5a 100644
--- a/packages/verkle/test/verkle.spec.ts
+++ b/packages/verkle/test/verkle.spec.ts
@@ -157,7 +157,6 @@ describe('findPath validation', () => {
     const leafNode1 = await LeafNode.create(
       stem1,
       new Array(256).fill(new Uint8Array(32)),
-      1,
       verkleCrypto
     )
 
@@ -168,7 +167,7 @@ describe('findPath validation', () => {
 
     // Pull root node from DB
     const rawNode = await trie['_db'].get(ROOT_DB_KEY)
-    const rootNode = decodeNode(rawNode!, 0, verkleCrypto) as InternalNode
+    const rootNode = decodeNode(rawNode!, verkleCrypto) as InternalNode
     // Update root node with commitment from leaf node
     rootNode.setChild(stem1[0], { commitment: leafNode1.commitment, path: stem1 })
     putStack.push([ROOT_DB_KEY, rootNode])
@@ -189,7 +188,6 @@ describe('findPath validation', () => {
     const leafNode2 = await LeafNode.create(
       stem2,
       new Array(256).fill(new Uint8Array(32)),
-      2,
       verkleCrypto
     )
     leafNode2.setValue(hexToBytes(keys[2])[31], hexToBytes(values[2]))