tidy

core/trie/key.go

@@ -28,10 +28,6 @@ func (k *Key) SubKey(n uint8) (*Key, error) {
 	if n > k.len {
 		return nil, errors.New(fmt.Sprint("cannot subtract key of length %i from key of length %i", n, k.len))
 	}
-	if n == k.len {
-		newkey := NewKey(k.len, k.bitset[:])
-		return &newkey, nil
-	}
 
 	newKey := &Key{len: n}
 	copy(newKey.bitset[:], k.bitset[len(k.bitset)-int((k.len+7)/8):]) //nolint:gomnd

core/trie/node.go

@@ -12,8 +12,8 @@
 	Value     *felt.Felt
 	Left      *Key
 	Right     *Key
-	LeftHash  *felt.Felt // To verify proofs, we need to store the hash of children
-	RightHash *felt.Felt // even when we can't derive their key
+	LeftHash  *felt.Felt
+	RightHash *felt.Felt
 }
 
 // Hash calculates the hash of a [Node]
@@ -56,33 +56,33 @@
 		wrote, errInner := n.Left.WriteTo(buf)
 		totalBytes += wrote
 		if err != nil {
 			return totalBytes, errInner
 		}
 		wrote, errInner = n.Right.WriteTo(buf) // n.Right is non-nil by design
 		totalBytes += wrote
 		if err != nil {
 			return totalBytes, errInner
 		}
 	}
 
 	if n.LeftHash == nil && n.RightHash == nil {
 		return totalBytes, nil
 	} else if (n.LeftHash != nil && n.RightHash == nil) || (n.LeftHash == nil && n.RightHash != nil) {
 		return totalBytes, errors.New("cannot store only one lefthash or righthash")
 	}
 
 	leftHashB := n.LeftHash.Bytes()
 	wrote, err = buf.Write(leftHashB[:])
 	totalBytes += int64(wrote)
 	if err != nil {
 		return totalBytes, err
 	}
 
 	rightHashB := n.RightHash.Bytes()
 	wrote, err = buf.Write(rightHashB[:])
 	totalBytes += int64(wrote)
 	if err != nil {
 		return totalBytes, err
 	}
 
 	return totalBytes, nil
@@ -117,7 +117,7 @@
 	}
 	data = data[n.Left.EncodedLen():]
 	if err := n.Right.UnmarshalBinary(data); err != nil {
 		return err
 	}
 	data = data[n.Right.EncodedLen():]
 
@@ -131,7 +131,7 @@
 		return nil
 	}
 	if len(data) != 2*felt.Bytes {
 		return errors.New("the node does not contain both left and right hash")
 	}
 	n.LeftHash.SetBytes(data[:felt.Bytes])
 	data = data[felt.Bytes:]

core/trie/proof.go

@@ -46,7 +46,6 @@
 		fmt.Printf("  Edge:\n")
 		fmt.Printf("    Child: %v\n", pn.Edge.Child)
 		fmt.Printf("    Path: %v\n", pn.Edge.Path)
-		fmt.Printf("    Value: %v\n", pn.Edge.Value)
 	}
 }
 
@@ -58,18 +57,17 @@
 type Edge struct {
 	Child *felt.Felt // child hash
 	Path  *Key       // path from parent to child
-	Value *felt.Felt // this nodes hash
 }
 
 func GetBoundaryProofs(leftBoundary, rightBoundary *Key, tri *Trie) ([2][]ProofNode, error) {
 	proofs := [2][]ProofNode{}
 	leftProof, err := GetProof(leftBoundary, tri)
 	if err != nil {
 		return proofs, err
 	}
 	rightProof, err := GetProof(rightBoundary, tri)
 	if err != nil {
 		return proofs, err
 	}
 	proofs[0] = leftProof
 	proofs[1] = rightProof
@@ -192,10 +190,11 @@
 				return false
 			}
 
+			// Todo:
 			// If we are verifying the key doesn't exist, then we should
 			// update subKey to point in the other direction
 			if value == nil && i == len(proofs)-1 {
-				return true // todo: hack for non-set proof nodes
+				return true
 			}
 
 			if !proofNode.Edge.Path.Equal(subKey) {
@@ -220,18 +219,18 @@
 ) (bool, error) {
 	// Step 0: checks
 	if len(keys) != len(values) {
 		return false, fmt.Errorf("inconsistent proof data, number of keys: %d, number of values: %d", len(keys), len(values))
 	}
 
 	// Ensure all keys are monotonic increasing
 	if err := ensureMonotonicIncreasing(proofKeys, keys); err != nil {
 		return false, err
 	}
 
 	// Ensure the inner values contain no deletions
 	for _, value := range values {
 		if value.Equal(&felt.Zero) {
 			return false, errors.New("range contains deletion")
 		}
 	}
 
@@ -241,29 +240,29 @@
 	for i := 0; i < 2; i++ {
 		if proofs[i] != nil {
 			if !VerifyProof(root, proofKeys[i], proofValues[i], proofs[i], hash) {
 				return false, fmt.Errorf("invalid proof for key %x", proofKeys[i].String())
 			}
 
 			proofPaths[i], err = ProofToPath(proofs[i], proofKeys[i], hash)
 			if err != nil {
 				return false, err
 			}
 		}
 	}
 
 	// Step 2: Build trie from proofPaths and keys
-	tmpTrie, err := BuildTrie(proofPaths[0], proofPaths[1], keys, values) // Todo: left points to itself
+	tmpTrie, err := BuildTrie(proofPaths[0], proofPaths[1], keys, values)
 	if err != nil {
 		return false, err
 	}
 
 	// Verify that the recomputed root hash matches the provided root hash
 	recomputedRoot, err := tmpTrie.Root()
 	if err != nil {
 		return false, err
 	}
 	if !recomputedRoot.Equal(root) {
 		return false, errors.New("root hash mismatch")
 	}
 
 	return true, nil
@@ -273,19 +272,19 @@
 	if proofKeys[0] != nil {
 		leftProofFelt := proofKeys[0].Felt()
 		if leftProofFelt.Cmp(keys[0]) >= 0 {
 			return errors.New("range is not monotonically increasing")
 		}
 	}
 	if proofKeys[1] != nil {
 		rightProofFelt := proofKeys[1].Felt()
 		if keys[len(keys)-1].Cmp(&rightProofFelt) >= 0 {
 			return errors.New("range is not monotonically increasing")
 		}
 	}
 	if len(keys) >= 2 {
 		for i := 0; i < len(keys)-1; i++ {
 			if keys[i].Cmp(keys[i+1]) >= 0 {
 				return errors.New("range is not monotonically increasing")
 			}
 		}
 	}
@@ -296,13 +295,13 @@
 func shouldSquish(idx int, proofNodes []ProofNode, hashF hashFunc) (int, uint8, error) {
 	parent := &proofNodes[idx]
 	if idx == len(proofNodes)-1 { // The node may have children, but we can only derive their hashes here
-		var hack int
+		var isEdge int
 		if parent.Edge != nil {
-			hack = 1
+			isEdge = 1
 		} else if parent.Binary != nil {
-			hack = 0
+			isEdge = 0
 		}
-		return hack, parent.Len(), nil
+		return isEdge, parent.Len(), nil
 	}
 
 	child := &proofNodes[idx+1]
@@ -318,7 +317,7 @@
 		} else if parent.Binary.RightHash.Equal(childHash) {
 			return 1, child.Edge.Path.len, nil
 		} else {
 			return 0, 0, errors.New("can't determine the child hash from the parent and child")
 		}
 	}
 
@@ -326,7 +325,7 @@
 		return 0, 1, nil
 	}
 
 	return 0, 1, nil
 }
 
 func assignChild(crntNode *Node, nilKey, childKey *Key, isRight bool) {
@@ -346,7 +345,7 @@
 func ProofToPath(proofNodes []ProofNode, leafKey *Key, hashF hashFunc) ([]StorageNode, error) {
 	pathNodes := []StorageNode{}
 
-	// Hack: this allows us to store a right without an existing left node.
+	// Child keys that can't be derived are set to nilKey, so that we can store the node
 	zeroFeltBytes := new(felt.Felt).Bytes()
 	nilKey := NewKey(0, zeroFeltBytes[:])
 
@@ -374,11 +373,11 @@
 		// Set the key of the current node
 		squishedParent, squishParentOffset, err := shouldSquish(i, proofNodes, hashF)
 		if err != nil {
 			return nil, err
 		}
 		crntKey, err = getCrntKey(height, squishParentOffset, leafKey, pNode)
 		if err != nil {
 			return nil, err
 		}
 
 		// Set the value of the current node
@@ -386,14 +385,14 @@
 
 		// End of the line, no children
 		if crntKey.len == 251 { //nolint:gomnd
 			break
 		}
 
 		// Set the child key of the current node.
 		childInd := i + squishedParent + 1
 		childKey, err := getChildKey(childInd, crntKey, leafKey, &nilKey, proofNodes, hashF)
 		if err != nil {
 			return nil, err
 		}
 		childIsRight := leafKey.Test(leafKey.len - crntKey.len - 1)
 		assignChild(&crntNode, &nilKey, childKey, childIsRight)
@@ -447,7 +446,7 @@
 	} else {
 		squishChild, squishChildOffset, err = shouldSquish(childIdx, proofNodes, hashF)
 		if err != nil {
 			return nil, err
 		}
 	}
 	if crntKey.len+uint8(squishChild)+squishChildOffset == 251 { //nolint:gomnd
@@ -460,7 +459,7 @@
 func getHeight(idx int, pathNodes []StorageNode, proofNodes []ProofNode) uint8 {
 	if len(pathNodes) > 0 {
 		if proofNodes[idx].Edge != nil {
 			return pathNodes[len(pathNodes)-1].key.len + proofNodes[idx].Edge.Path.len
 		} else {
 			return pathNodes[len(pathNodes)-1].key.len + 1
 		}
@@ -473,7 +472,7 @@
 func BuildTrie(leftProofPath, rightProofPath []StorageNode, keys, values []*felt.Felt) (*Trie, error) { //nolint:gocyclo
 	tempTrie, err := NewTriePedersen(newMemStorage(), 251) //nolint:gomnd
 	if err != nil {
 		return nil, err
 	}
 
 	// merge proof paths
@@ -481,40 +480,40 @@
 		// Can't store nil keys so stop merging
 		if leftProofPath[i].node.Left == nil || leftProofPath[i].node.Right == nil ||
 			rightProofPath[i].node.Left == nil || rightProofPath[i].node.Right == nil {
 			break
 		}
 		if leftProofPath[i].key.Equal(rightProofPath[i].key) {
 			leftProofPath[i].node.Right = rightProofPath[i].node.Right
 			rightProofPath[i].node.Left = leftProofPath[i].node.Left
 		} else {
 			break
 		}
 	}
 
 	for _, sNode := range leftProofPath {
 		if sNode.node.Left == nil || sNode.node.Right == nil {
 			break
 		}
 		_, err := tempTrie.PutInner(sNode.key, sNode.node)
 		if err != nil {
 			return nil, err
 		}
 	}
 
 	for _, sNode := range rightProofPath {
 		if sNode.node.Left == nil || sNode.node.Right == nil {
 			break
 		}
 		_, err := tempTrie.PutInner(sNode.key, sNode.node)
 		if err != nil {
 			return nil, err
 		}
 	}
 
 	for i := range len(keys) {
 		_, err := tempTrie.PutWithProof(keys[i], values[i], leftProofPath, rightProofPath)
 		if err != nil {
 			return nil, err
 		}
 	}
 	return tempTrie, nil

core/trie/trie.go

@@ -143,8 +143,8 @@
 	return sn.node
 }
 
 func NewStorageNode(key *Key, node *Node) *StorageNode {
 	return &StorageNode{key: key, node: node}
 }
 
 // nodesFromRoot enumerates the set of [Node] objects that need to be traversed from the root
@@ -266,7 +266,7 @@
 	if siblingIsParentProof {
 		newParent, err = t.GetNodeFromKey(&commonKey)
 		if err != nil {
 			return nil
 		}
 		if nodeKey.Test(nodeKey.Len() - commonKey.Len() - 1) {
 			newParent.Right = nodeKey
@@ -276,7 +276,7 @@
 			newParent.LeftHash = node.Hash(nodeKey, t.hash)
 		}
 		if err := t.storage.Put(&commonKey, newParent); err != nil {
 			return err
 		}
 		t.dirtyNodes = append(t.dirtyNodes, &commonKey)
 	} else {
@@ -293,7 +293,7 @@
 
 		newParent.Value = t.hash(leftChild.Hash(&leftPath, t.hash), rightChild.Hash(&rightPath, t.hash))
 		if err := t.storage.Put(&commonKey, newParent); err != nil {
 			return err
 		}
 
 		if len(nodes) > 1 { // sibling has a parent
@@ -301,7 +301,7 @@
 
 			t.replaceLinkWithNewParent(sibling.key, commonKey, siblingParent)
 			if err := t.storage.Put(siblingParent.key, siblingParent.node); err != nil {
 				return err
 			}
 			t.dirtyNodes = append(t.dirtyNodes, &commonKey)
 		} else {
@@ -360,7 +360,7 @@
 		}
 		err := t.insertOrUpdateValue(&nodeKey, node, nodes, sibling, false)
 		if err != nil {
 			return nil, err
 		}
 		return &old, nil
 	}
@@ -369,7 +369,7 @@
 // Put updates the corresponding `value` for a `key`
 func (t *Trie) PutWithProof(key, value *felt.Felt, lProofPath, rProofPath []StorageNode) (*felt.Felt, error) {
 	if key.Cmp(t.maxKey) > 0 {
 		return nil, fmt.Errorf("key %s exceeds trie height %d", key, t.height)
 	}
 
 	old := felt.Zero
@@ -381,12 +381,12 @@
 	oldValue, err := t.updateLeaf(nodeKey, node, value)
 	// xor operation, because we don't want to return result if the error is nil and the old value is nil
 	if (err != nil) != (oldValue != nil) {
 		return oldValue, err
 	}
 
 	nodes, err := t.nodesFromRoot(&nodeKey) // correct for key,value
 	if err != nil {
 		return nil, err
 	}
 	defer func() {
 		for _, n := range nodes {
@@ -404,10 +404,10 @@
 		oldValue, err = t.deleteExistingKey(sibling, nodeKey, nodes)
 		// xor operation, because we don't want to return if the error is nil and the old value is nil
 		if (err != nil) != (oldValue != nil) {
 			return oldValue, err
 		} else if value.IsZero() {
 			// trying to insert 0 to a key that does not exist
 			return nil, nil // no-op
 		}
 
 		// override the sibling to be the parent if it's a proof
@@ -441,7 +441,7 @@
 // Put updates the corresponding `value` for a `key`
 func (t *Trie) PutInner(key *Key, node *Node) (*felt.Felt, error) {
 	if err := t.storage.Put(key, node); err != nil {
 		return nil, err
 	}
 	if t.rootKey == nil {
 		t.setRootKey(key)
@@ -454,7 +454,6 @@
 	t.rootKeyIsDirty = true
 }
 
-// Todo: update so that the proof nodes are always updated
 func (t *Trie) updateValueIfDirty(key *Key) (*Node, error) { //nolint:gocyclo
 	zeroFeltBytes := new(felt.Felt).Bytes()
 	nilKey := NewKey(0, zeroFeltBytes[:])
@@ -481,7 +480,7 @@
 
 	// Update inner proof nodes
 	if node.Left.Equal(&nilKey) && node.Right.Equal(&nilKey) { // leaf
 		shouldUpdate = false
 	} else if node.Left.Equal(&nilKey) || node.Right.Equal(&nilKey) { // inner
 		shouldUpdate = true
 	}
@@ -536,13 +535,13 @@
 	if !leftIsProof {
 		leftChild, err = t.updateValueIfDirty(root.Left)
 		if err != nil {
 			return nil, nil, err
 		}
 	}
 	if !rightIsProof {
 		rightChild, err = t.updateValueIfDirty(root.Right)
 		if err != nil {
 			return nil, nil, err
 		}
 	}
 	return leftChild, rightChild, nil

core/trie/trie_test.go

@@ -7,7 +7,6 @@ import (
 	"github.com/NethermindEth/juno/core/felt"
 	"github.com/NethermindEth/juno/core/trie"
 	"github.com/NethermindEth/juno/db"
-	"github.com/NethermindEth/juno/db/pebble"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -83,37 +82,6 @@ func TestTriePut(t *testing.T) {
 	})
 }
 
-func TestTriePutInner(t *testing.T) {
-	t.Run("put node to empty trie", func(t *testing.T) {
-		memdb := pebble.NewMemTest(t)
-		txn, err := memdb.NewTransaction(true)
-		require.NoError(t, err)
-
-		tempTrie, err := trie.NewTriePedersen(trie.NewStorage(txn, []byte{0}), 251)
-		require.NoError(t, err)
-
-		keyFeltBytes := new(felt.Felt).SetUint64(123).Bytes()
-		key := trie.NewKey(10, keyFeltBytes[:])
-
-		leftKeyFeltBytes := new(felt.Felt).SetUint64(789).Bytes()
-		leftKey := trie.NewKey(11, leftKeyFeltBytes[:])
-		rightKeyFeltBytes := new(felt.Felt).SetUint64(135).Bytes()
-		rightKey := trie.NewKey(11, rightKeyFeltBytes[:])
-		node := trie.Node{
-			Value: new(felt.Felt).SetUint64(456),
-			Left:  &leftKey,
-			Right: &rightKey,
-		}
-
-		_, err = tempTrie.PutInner(&key, &node)
-		require.NoError(t, err)
-
-		gotNode, err := tempTrie.GetNodeFromKey(&key)
-		require.NoError(t, err)
-		require.Equal(t, node, *gotNode)
-	})
-}
-
 func TestTrieDeleteBasic(t *testing.T) {
 	// left branch
 	leftKeyNum, err := strconv.ParseUint("100", 2, 64)