Fix lint

core/trie/snap_support.go

@@ -4,7 +4,8 @@
 	"github.com/NethermindEth/juno/core/felt"
 )
 
-func (t *Trie) IterateAndGenerateProof(startValue *felt.Felt, consumer func(key, value *felt.Felt) (bool, error)) ([]ProofNode, bool, error) {
+func (t *Trie) IterateAndGenerateProof(startValue *felt.Felt, consumer func(key, value *felt.Felt) (bool, error),
+) ([]ProofNode, bool, error) {
 	var lastKey *felt.Felt
 
 	finished, err := t.Iterate(startValue, func(key, value *felt.Felt) (bool, error) {
@@ -13,7 +14,7 @@
 		return consumer(key, value)
 	})
 	if err != nil {
 		return nil, false, err
 	}
 
 	proofset := map[felt.Felt]ProofNode{}
@@ -26,13 +27,12 @@
 		// actually check that the server did not skip leafs.
 		leftProof, err := GetProof(&startKey, t)
 		if err != nil {
 			return nil, false, err
 		}
 		for _, proof := range leftProof {
 			// Well.. using the trie hash here is kinda slow... but I just need it to work right now.
 			proofset[*proof.Hash(t.hash)] = proof
 		}
-
 	}
 
 	if !finished && lastKey != nil {
@@ -40,7 +40,7 @@
 		lastKey := NewKey(t.height, feltBts[:])
 		rightProof, err := GetProof(&lastKey, t)
 		if err != nil {
 			return nil, false, err
 		}
 
 		for _, proof := range rightProof {
@@ -56,7 +56,9 @@
 	return proofs, finished, nil
 }
 
-func VerifyRange(root, startKey *felt.Felt, keys, values []*felt.Felt, proofs []ProofNode, hash hashFunc) (hasMore bool, valid bool, err error) {
+func VerifyRange(root, startKey *felt.Felt, keys, values []*felt.Felt, proofs []ProofNode, hash hashFunc,
+	treeHeight uint8,
+) (hasMore, valid bool, oerr error) {
 	proofMap := map[felt.Felt]ProofNode{}
 	for _, proof := range proofs {
 		proofHash := proof.Hash(hash)
@@ -67,21 +69,21 @@
 		// Special case where the whole trie is sent in one go.
 		// We just need to completely reconstruct the trie.
 
-		tempTrie, err := newTrie(newMemStorage(), 251, hash) //nolint:gomnd
+		tempTrie, err := newTrie(newMemStorage(), treeHeight, hash)
 		if err != nil {
 			return false, false, err
 		}
 
 		for i, key := range keys {
-			_, err := tempTrie.Put(key, values[i])
+			_, err = tempTrie.Put(key, values[i])
 			if err != nil {
 				return false, false, err
 			}
 		}
 
 		recalculatedRoot, err := tempTrie.Root()
 		if err != nil {
 			return false, false, err
 		}
 
 		if !root.Equal(recalculatedRoot) {
@@ -97,30 +99,20 @@
 	}
 
 	proofKeys := map[felt.Felt]Key{}
-	err = buildKeys(NewKey(0, []byte{}), root, proofMap, proofKeys, 0)
+	err := buildKeys(NewKey(0, []byte{}), root, proofMap, proofKeys, 0)
 	if err != nil {
 		return false, false, err
 	}
 
-	// No idea how this work
-	/*
-		proofValuesArray := []*felt.Felt{}
-		proofKeysArray := []*Key{}
-		for f, key := range proofKeys {
-			proofValuesArray = append(proofValuesArray, &f)
-			proofKeysArray = append(proofKeysArray, &key)
-		}
-
-		VerifyRangeProof(root, keys, values, nil, nil, nil, hash)
-	*/
+	// TODO: Verify here proof here
 
 	hasMoreKeyCheck := startKey
 	if len(keys) > 0 {
 		hasMoreKeyCheck = keys[len(keys)-1]
 	}
 
 	feltBytes := hasMoreKeyCheck.Bytes()
-	hasMoreKeyCheckKey := NewKey(251, feltBytes[:])
+	hasMoreKeyCheckKey := NewKey(treeHeight, feltBytes[:])
 
 	// does this actually work on all case?
 	hasMore = false
@@ -146,7 +138,7 @@
 		ch := proofNode.Edge.Child
 		err := buildKeys(chKey, ch, proofMap, keys, depth+1)
 		if err != nil {
 			return err
 		}
 	} else {
 		binary := proofNode.Binary
@@ -155,14 +147,14 @@
 		ch := binary.LeftHash
 		err := buildKeys(chKey, ch, proofMap, keys, depth+1)
 		if err != nil {
 			return err
 		}
 
 		chKey = currentKey.AppendBit(true)
 		ch = binary.RightHash
 		err = buildKeys(chKey, ch, proofMap, keys, depth+1)
 		if err != nil {
 			return err
 		}
 	}
 

core/trie/snap_support_test.go

@@ -10,6 +10,8 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+const trieHeight = 251
+
 func TestRangeAndVerify(t *testing.T) {
 	scenarios := []struct {
 		name             string
@@ -96,7 +98,7 @@ func TestRangeAndVerify(t *testing.T) {
 			assert.NoError(t, err)
 
 			for i := 0; i < 10; i++ {
-				_, err := testTrie.Put(numToFelt(i*100+1), numToFelt(i*100+2))
+				_, err = testTrie.Put(numToFelt(i*100+1), numToFelt(i*100+2))
 				assert.NoError(t, err)
 			}
 
@@ -126,7 +128,7 @@ func TestRangeAndVerify(t *testing.T) {
 				assert.Empty(t, proofs)
 			}
 
-			hasMore, valid, err := trie.VerifyRange(expectedRoot, startQuery, keys, values, proofs, crypto.Pedersen)
+			hasMore, valid, err := trie.VerifyRange(expectedRoot, startQuery, keys, values, proofs, crypto.Pedersen, trieHeight)
 			assert.NoError(t, err)
 			assert.True(t, valid)
 
@@ -245,7 +247,7 @@ func TestRangeAndVerifyReject(t *testing.T) {
 			assert.NoError(t, err)
 
 			for i := 0; i < 10; i++ {
-				_, err := testTrie.Put(numToFelt(i*100+1), numToFelt(i*100+2))
+				_, err = testTrie.Put(numToFelt(i*100+1), numToFelt(i*100+2))
 				assert.NoError(t, err)
 			}
 
@@ -268,7 +270,7 @@ func TestRangeAndVerifyReject(t *testing.T) {
 
 			keys, values, proofs = scenario.mutator(keys, values, proofs)
 
-			_, valid, err := trie.VerifyRange(expectedRoot, startQuery, keys, values, proofs, crypto.Pedersen)
+			_, valid, err := trie.VerifyRange(expectedRoot, startQuery, keys, values, proofs, crypto.Pedersen, trieHeight)
 			assert.NoError(t, err)
 			assert.False(t, valid)
 		})