wip - twriting leaves overwrites boundarys..

core/trie/proof.go

@@ -264,7 +264,7 @@ func VerifyRangeProof(root *felt.Felt, keys []*felt.Felt, values []*felt.Felt, p
 	return true, nil
 }
 
-// Only the path down to leaf Key will be set correctly. Not neightbouring keys
+// Only the path down to leaf Key will be set correctly. Not neighbouring keys
 func ProofToPath(proofNodes []ProofNode, leaf *felt.Felt, hashF hashFunc) ([]StorageNode, error) {
 
 	zeroFeltBytes := new(felt.Felt).SetUint64(0).Bytes()
@@ -306,6 +306,15 @@ func ProofToPath(proofNodes []ProofNode, leaf *felt.Felt, hashF hashFunc) ([]Sto
 	offset := 0
 	// totalOffset := 0
 	for i <= len(proofNodes)-1 {
+
+		if len(pathNodes) > 0 {
+			if proofNodes[i].Edge != nil {
+				height = pathNodes[len(pathNodes)-1].key.len + proofNodes[i].Edge.Path.len
+			} else {
+				height = pathNodes[len(pathNodes)-1].key.len + 1
+			}
+		}
+
 		var crntKey *Key
 		crntNode := Node{}
 
@@ -347,7 +356,8 @@ func ProofToPath(proofNodes []ProofNode, leaf *felt.Felt, hashF hashFunc) ([]Sto
 					crntNode.Right = &nilKey
 					crntNode.Left = &leafKey
 				}
-				offset++ // Hack
+				// offset++ // Hack
+				// height += proofNodes[i+int(squishedParent)+1].Edge.Path.len
 			} else {
 				qwe := getLen(&proofNodes[i+int(squishedParent)+1])
 				if leafKey.Test(leafKey.len - crntKey.len - 1) {
@@ -357,8 +367,12 @@ func ProofToPath(proofNodes []ProofNode, leaf *felt.Felt, hashF hashFunc) ([]Sto
 					crntNode.Right = &nilKey
 					crntNode.Left = leafKey.SubKey(crntKey.len + qwe)
 				}
+				// height += 1
+			}
+		} else { // Point to leaf (if is leaf then make leaf)
+			if proofNodes[i].Edge != nil {
+				break
 			}
-		} else { // Point to leaf
 			if leafKey.Test(leafKey.len - crntKey.len - 1) {
 				crntNode.Right = &leafKey
 				crntNode.Left = &nilKey
@@ -367,10 +381,17 @@ func ProofToPath(proofNodes []ProofNode, leaf *felt.Felt, hashF hashFunc) ([]Sto
 				crntNode.Left = &leafKey
 			}
 		}
-		height = crntKey.len + 1
+
 		pathNodes = append(pathNodes, StorageNode{key: crntKey, node: &crntNode})
 		i += 1 + offset
 	}
+	// Add leaf
+	lastNode := pathNodes[len(pathNodes)-1].node
+	if lastNode.Left.Equal(&leafKey) || lastNode.Right.Equal(&leafKey) {
+		leafNode := Node{}
+		leafNode.Value = proofNodes[len(proofNodes)-1].Hash(hashF)
+		pathNodes = append(pathNodes, StorageNode{key: &leafKey, node: &leafNode})
+	}
 	return pathNodes, nil
 }
 
@@ -391,24 +412,34 @@ func BuildTrie(leftProof, rightProof []StorageNode, keys []*felt.Felt, values []
 	}
 
 	for _, sNode := range leftProof {
-		_, err := tempTrie.PutInner(sNode.key, sNode.node)
+		_, err := tempTrie.PutInner(sNode.key, sNode.node) // Correctly sets root.left here (len is correct)
 		if err != nil {
 			return nil, err
 		}
 	}
 
-	for _, sNode := range rightProof {
+	for _, sNode := range rightProof { // Note setting the leaf..
 		_, err := tempTrie.PutInner(sNode.key, sNode.node)
 		if err != nil {
 			return nil, err
 		}
 	}
 
+	builtRootKey := tempTrie.RootKey()
+	builtRootNode, err := tempTrie.GetNodeFromKey(builtRootKey)         // correct
+	builtLeftNode, err := tempTrie.GetNodeFromKey(builtRootNode.Left)   // correct
+	builtRightNode, err := tempTrie.GetNodeFromKey(builtRootNode.Right) // correct
+
 	for i := range len(keys) {
 		_, err := tempTrie.Put(keys[i], values[i])
 		if err != nil {
 			return nil, err
 		}
 	}
+	builtRootNode, err = tempTrie.GetNodeFromKey(builtRootKey)         // correct
+	builtLeftNode, err = tempTrie.GetNodeFromKey(builtRootNode.Left)   // leftPath gets overwritten...
+	builtRightNode, err = tempTrie.GetNodeFromKey(builtRootNode.Right) // correct
+	fmt.Println(builtLeftNode, builtRightNode)
+
 	return tempTrie, nil
 }

core/trie/proof_test.go

@@ -438,7 +438,7 @@ func TestProofToPath(t *testing.T) {
 			},
 		}
 		leafKey := new(felt.Felt).SetUint64(0)
-		sns, err := trie.ProofToPath(proofNodes, leafKey, crypto.Pedersen)
+		sns, err := trie.ProofToPath(proofNodes, leafKey, crypto.Pedersen) // Todo : we should be able to set the leaf as well
 		require.NoError(t, err)
 
 		rootKey := tempTrie.RootKey()
@@ -527,37 +527,51 @@ func TestBuildTrie(t *testing.T) {
 
 	t.Run("Simple binary trie proof to path", func(t *testing.T) {
 		tri := build3KeyTrie(t)
+		rootKey := tri.RootKey()
+		rootNode, err := tri.GetNodeFromKey(rootKey)
+		require.NoError(t, err)
+		leftNode, err := tri.GetNodeFromKey(rootNode.Left)
+		require.NoError(t, err)
+		rightNode, err := tri.GetNodeFromKey(rootNode.Right)
+		require.NoError(t, err)
 
 		key1 := new(felt.Felt).SetUint64(0)
 		key3 := new(felt.Felt).SetUint64(2)
 		bProofs, err := trie.GetBoundaryProofs(key1, key3, tri)
 		require.NoError(t, err)
 
-		leftProof, err := trie.ProofToPath(bProofs[0], key1, crypto.Pedersen)
+		leftProof, err := trie.ProofToPath(bProofs[0], key1, crypto.Pedersen) // correct
 		require.NoError(t, err)
 
-		rightProof, err := trie.ProofToPath(bProofs[1], key3, crypto.Pedersen)
+		rightProof, err := trie.ProofToPath(bProofs[1], key3, crypto.Pedersen) // correct
 		require.NoError(t, err)
 
 		keys := []*felt.Felt{new(felt.Felt).SetUint64(1)}
 		values := []*felt.Felt{new(felt.Felt).SetUint64(5)}
-		reconstructedTrie, err := trie.BuildTrie(leftProof, rightProof, keys, values)
+		builtTrie, err := trie.BuildTrie(leftProof, rightProof, keys, values)
 		require.NoError(t, err)
 
+		builtRootKey := builtTrie.RootKey()
+		builtRootNode, err := builtTrie.GetNodeFromKey(builtRootKey) // looks correct
+		require.NoError(t, err)
+		builtLeftNode, err := builtTrie.GetNodeFromKey(builtRootNode.Left) // left len incorrect ...
+		require.NoError(t, err)
+		builtRightNode, err := builtTrie.GetNodeFromKey(builtRootNode.Right) // looks correct
+		require.NoError(t, err)
+
+		require.Equal(t, rootKey, builtRootKey)
+		require.Equal(t, rootNode.Left, builtRootNode.Left)
+		require.Equal(t, rootNode.Right, builtRootNode.Right)
+		require.Equal(t, rootNode.Value.String(), builtRootNode.Value.String())
+		require.Equal(t, leftNode, builtLeftNode)
+		require.Equal(t, rightNode, builtRightNode)
+
 		// reconstructedRoot, err := reconstructedTrie.Root() // Todo: fails at updating dirty values..
 		// require.NoError(t, err)
 
-		// Hack (should call Root())
-		reconstructedRootKey := reconstructedTrie.RootKey()
-		// PrettyPrint(reconstructedTrie, reconstructedRootKey)
-		rkn, err := reconstructedTrie.GetNodeFromKey(reconstructedRootKey)
-		commitment := rkn.Hash(reconstructedRootKey, crypto.Pedersen)
-		require.NoError(t, err)
-		fmt.Print(rkn)
+		// expectedRoot, err := tri.Root()
+		// require.NoError(t, err)
 
-		expectedRoot, err := tri.Root()
-		require.NoError(t, err)
-		require.Equal(t, expectedRoot.String(), commitment.String())
 	})
 }
 

core/trie/trie.go

@@ -352,10 +352,10 @@ func (t *Trie) Put(key, value *felt.Felt) (*felt.Felt, error) {
 // Note only a single node is modified. It's the callers responsibility
 // To ensure it doesn't break the trie.
 func (t *Trie) PutInner(key *Key, node *Node) (*felt.Felt, error) {
-	if key.len == t.height {
-		keyFelt := key.Felt()
-		return t.Put(&keyFelt, node.Value)
-	}
+	// if key.len == t.height {
+	// 	keyFelt := key.Felt()
+	// 	return t.Put(&keyFelt, node.Value)
+	// }
 	if err := t.storage.Put(key, node); err != nil {
 		return nil, err
 	}