Use node hash as db key (#3472)

* Update findPath to use node hash as db key

* update verkle crypto package to latest [no ci]

* Update test logic to use findPath result in updating trie

* verkle: remove unused imporT

---------

Co-authored-by: Gabriel Rocheleau <[email protected]>

Author: acolytec3

package-lock.json

@@ -87,7 +87,7 @@
     "level": "^8.0.0",
     "memory-level": "^1.0.0",
     "prom-client": "^15.1.0",
-    "verkle-cryptography-wasm": "^0.4.2",
+    "verkle-cryptography-wasm": "^0.4.5",
     "winston": "^3.3.3",
     "winston-daily-rotate-file": "^4.5.5",
     "yargs": "^17.7.1"

packages/client/package.json

@@ -63,6 +63,6 @@
     "@ethereumjs/genesis": "^0.2.2",
     "@types/debug": "^4.1.9",
     "rustbn-wasm": "^0.4.0",
-    "verkle-cryptography-wasm": "^0.4.2"
+    "verkle-cryptography-wasm": "^0.4.5"
   }
 }

packages/statemanager/package.json

@@ -54,7 +54,7 @@
   "dependencies": {
     "debug": "^4.3.4",
     "lru-cache": "10.1.0",
-    "verkle-cryptography-wasm": "^0.4.4",
+    "verkle-cryptography-wasm": "^0.4.5",
     "@ethereumjs/block": "^5.2.0",
     "@ethereumjs/rlp": "^5.0.2",
     "@ethereumjs/util": "^9.0.3"

packages/verkle/package.json

@@ -2,7 +2,7 @@ import { RLP } from '@ethereumjs/rlp'
 
 import { type VerkleNodeInterface, type VerkleNodeOptions, type VerkleNodeType } from './types.js'
 
-import type { VerkleCrypto } from 'verkle-cryptography-wasm'
+import type { VerkleCrypto } from '@ethereumjs/util'
 
 export abstract class BaseVerkleNode<T extends VerkleNodeType> implements VerkleNodeInterface {
   public commitment: Uint8Array

packages/verkle/src/node/baseVerkleNode.ts

@@ -1,6 +1,6 @@
 import type { InternalNode } from './internalNode.js'
 import type { LeafNode } from './leafNode.js'
-import type { VerkleCrypto } from 'verkle-cryptography-wasm'
+import type { VerkleCrypto } from '@ethereumjs/util'
 
 export enum VerkleNodeType {
   Internal,

packages/verkle/src/node/types.ts

@@ -234,15 +234,14 @@ export class VerkleTree {
     if (equalsBytes(this.root(), this.EMPTY_TREE_ROOT)) return result
 
     // Get root node
-    let rawNode = await this._db.get(ROOT_DB_KEY)
+    let rawNode = await this._db.get(this.root())
     if (rawNode === undefined)
       throw new Error('root node should exist when root not empty tree root')
 
     const rootNode = decodeNode(rawNode, this.verkleCrypto) as InternalNode
 
-    this.DEBUG &&
-      this.debug(`Starting with Root Node: [${bytesToHex(rootNode.hash())}]`, ['FIND_PATH'])
-    result.stack.push([rootNode, ROOT_DB_KEY])
+    this.DEBUG && this.debug(`Starting with Root Node: [${bytesToHex(this.root())}]`, ['FIND_PATH'])
+    result.stack.push([rootNode, this.root()])
     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
@@ -252,7 +251,8 @@ export class VerkleTree {
     }
     let finished = false
     while (!finished) {
-      rawNode = await this._db.get(child.path)
+      // Look up child node by node hash
+      rawNode = await this._db.get(this.verkleCrypto.hashCommitment(child.commitment))
       // 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, this.verkleCrypto)
@@ -330,10 +330,9 @@ export class VerkleTree {
 
     // 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))
+    await this.saveStack([[this.root(), rootNode]])
     return
   }
 

packages/verkle/src/verkleTree.ts

@@ -5,7 +5,7 @@ import { assert, beforeAll, describe, it } from 'vitest'
 import {
   InternalNode,
   LeafNode,
-  ROOT_DB_KEY,
+  VerkleNodeType,
   decodeNode,
   matchingBytesLength,
 } from '../src/index.js'
@@ -163,16 +163,16 @@ describe('findPath validation', () => {
     leafNode1.setValue(hexToBytes(keys[0])[31], hexToBytes(values[0]))
     leafNode1.setValue(hexToBytes(keys[1])[31], hexToBytes(values[1]))
 
-    putStack.push([stem1, leafNode1])
+    putStack.push([leafNode1.hash(), leafNode1])
 
     // Pull root node from DB
-    const rawNode = await trie['_db'].get(ROOT_DB_KEY)
+    const rawNode = await trie['_db'].get(trie.root())
     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])
-    await trie.saveStack(putStack)
     trie.root(verkleCrypto.serializeCommitment(rootNode.commitment))
+    putStack.push([trie.root(), rootNode])
+    await trie.saveStack(putStack)
 
     // Verify that path to leaf node can be found from stem
     const res = await trie.findPath(stem1)
@@ -185,41 +185,58 @@ describe('findPath validation', () => {
     // Put a second leaf node in the tree with a partially matching stem
     putStack = []
     const stem2 = hexToBytes(keys[2]).slice(0, 31)
+
+    // Find path to closest node in tree
+    const foundPath = await trie.findPath(stem2)
+
+    // Confirm node with stem2 doesn't exist in trie
+    assert.equal(foundPath.node, null)
+
+    // Create new leaf node
     const leafNode2 = await LeafNode.create(
       stem2,
       new Array(256).fill(new Uint8Array(32)),
       verkleCrypto
     )
     leafNode2.setValue(hexToBytes(keys[2])[31], hexToBytes(values[2]))
-    putStack.push([stem2, leafNode2])
+    putStack.push([leafNode2.hash(), leafNode2])
 
-    // Create new internal node
-    const internalNode1 = InternalNode.create(verkleCrypto)
+    const nearestNode = foundPath.stack.pop()![0]
+    // Verify that another leaf node is "nearest" node
+    assert.equal(nearestNode.type, VerkleNodeType.Leaf)
+    assert.deepEqual(nearestNode, leafNode1)
 
-    // Compute the portion of stem1 and stem2 that match
+    // Compute the portion of stem1 and stem2 that match (i.e. the partial path closest to stem2)
     // 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)
+    // Create new internal node
+    const internalNode1 = InternalNode.create(verkleCrypto)
+
     // Update the child references for leafNode1 and leafNode 2
     internalNode1.setChild(stem1[partialMatchingStemIndex], {
-      commitment: leafNode1.commitment,
-      path: stem1,
+      commitment: nearestNode.commitment,
+      path: (nearestNode as LeafNode).stem,
     })
     internalNode1.setChild(stem2[partialMatchingStemIndex], {
       commitment: leafNode2.commitment,
       path: stem2,
     })
 
-    putStack.push([internalNode1Path, internalNode1])
+    putStack.push([internalNode1.hash(), internalNode1])
     // Update rootNode child reference for internal node 1
-    rootNode.setChild(internalNode1Path[0], {
+
+    const rootNodeFromPath = foundPath.stack.pop()![0] as InternalNode
+    // Confirm node from findPath matches root
+    assert.deepEqual(rootNodeFromPath, rootNode)
+    rootNodeFromPath.setChild(internalNode1Path[0], {
       commitment: internalNode1.commitment,
       path: internalNode1Path,
     })
-    putStack.push([ROOT_DB_KEY, rootNode])
+    trie.root(verkleCrypto.serializeCommitment(rootNodeFromPath.commitment))
+    putStack.push([trie.root(), rootNodeFromPath])
     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')