linter suggestions

addbatch_test.go

@@ -41,13 +41,17 @@ func debugTime(descr string, time1, time2 time.Duration) {
 
 func testInit(c *qt.C, n int) (*Tree, *Tree) {
 	database1 := memdb.New()
-	tree1, err := NewTree(Config{Database: database1, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree1, err := NewTree(Config{
+		Database: database1, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 
 	database2 := memdb.New()
-	tree2, err := NewTree(Config{Database: database2, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		Database: database2, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 
 	bLen := HashFunctionPoseidon.Len()
@@ -73,8 +77,10 @@ func TestAddBatchTreeEmpty(t *testing.T) {
 
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{database, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		database, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -97,8 +103,10 @@ func TestAddBatchTreeEmpty(t *testing.T) {
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 	tree2.dbgInit()
@@ -125,8 +133,10 @@ func TestAddBatchTreeEmptyNotPowerOf2(t *testing.T) {
 
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{database, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		database, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -141,8 +151,10 @@ func TestAddBatchTreeEmptyNotPowerOf2(t *testing.T) {
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -174,15 +186,19 @@ func TestAddBatchTestVector1(t *testing.T) {
 	c := qt.New(t)
 	database1, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{database1, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree1, err := NewTree(Config{
+		database1, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree1.treedb.Close() //nolint:errcheck
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -216,15 +232,19 @@ func TestAddBatchTestVector1(t *testing.T) {
 	// 2nd test vectors
 	database1, err = pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err = NewTree(Config{database1, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree1, err = NewTree(Config{
+		database1, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree1.treedb.Close() //nolint:errcheck
 
 	database2, err = pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err = NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree2, err = NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -266,15 +286,19 @@ func TestAddBatchTestVector2(t *testing.T) {
 
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{database, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree1, err := NewTree(Config{
+		database, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree1.treedb.Close() //nolint:errcheck
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -313,15 +337,19 @@ func TestAddBatchTestVector3(t *testing.T) {
 
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{database, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree1, err := NewTree(Config{
+		database, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree1.treedb.Close() //nolint:errcheck
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -364,15 +392,19 @@ func TestAddBatchTreeEmptyRandomKeys(t *testing.T) {
 
 	database1, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{database1, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree1, err := NewTree(Config{
+		database1, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree1.treedb.Close() //nolint:errcheck
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -716,8 +748,10 @@ func TestAddBatchNotEmptyUnbalanced(t *testing.T) {
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 	tree2.dbgInit()
@@ -794,8 +828,10 @@ func benchAdd(t *testing.T, ks, vs [][]byte) {
 
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{database, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree, err := NewTree(Config{
+		database, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -815,8 +851,10 @@ func benchAddBatch(t *testing.T, ks, vs [][]byte) {
 
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{database, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree, err := NewTree(Config{
+		database, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -849,8 +887,10 @@ func TestDbgStats(t *testing.T) {
 	// 1
 	database1, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{database1, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree1, err := NewTree(Config{
+		database1, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree1.treedb.Close() //nolint:errcheck
 
@@ -864,8 +904,10 @@ func TestDbgStats(t *testing.T) {
 	// 2
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -878,8 +920,10 @@ func TestDbgStats(t *testing.T) {
 	// 3
 	database3, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree3, err := NewTree(Config{database3, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree3, err := NewTree(Config{
+		database3, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree3.treedb.Close() //nolint:errcheck
 
@@ -913,8 +957,10 @@ func TestLoadVT(t *testing.T) {
 	nLeafs := 1024
 
 	database := memdb.New()
-	tree, err := NewTree(Config{database, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		database, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -948,8 +994,10 @@ func TestAddKeysWithEmptyValues(t *testing.T) {
 
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{database, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		database, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -970,8 +1018,10 @@ func TestAddKeysWithEmptyValues(t *testing.T) {
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 	tree2.dbgInit()
@@ -985,8 +1035,10 @@ func TestAddKeysWithEmptyValues(t *testing.T) {
 	// use tree3 to add nil value array
 	database3, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree3, err := NewTree(Config{database3, 256, DefaultThresholdNLeafs,
-		HashFunctionPoseidon})
+	tree3, err := NewTree(Config{
+		database3, 256, DefaultThresholdNLeafs,
+		HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree3.treedb.Close() //nolint:errcheck
 
@@ -1014,8 +1066,10 @@ func TestAddKeysWithEmptyValues(t *testing.T) {
 	c.Check(verif, qt.IsTrue)
 
 	// check with array with 32 zeroes
-	e32 := []byte{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}
+	e32 := []byte{
+		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,
+	}
 	c.Assert(len(e32), qt.Equals, 32)
 	verif, err = CheckProof(tree.hashFunction, keys[9], e32, root, siblings)
 	c.Assert(err, qt.IsNil)
@@ -1035,22 +1089,28 @@ func TestAddBatchThresholdInDisk(t *testing.T) {
 
 	database1, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{database1, 256, testThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree1, err := NewTree(Config{
+		database1, 256, testThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree1.treedb.Close() //nolint:errcheck
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, testThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree2, err := NewTree(Config{
+		database2, 256, testThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
 	database3, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree3, err := NewTree(Config{database3, 256, testThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree3, err := NewTree(Config{
+		database3, 256, testThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree3.treedb.Close() //nolint:errcheck
 
@@ -1103,14 +1163,18 @@ func TestAddBatchThresholdInDisk(t *testing.T) {
 func initTestUpFromSubRoots(c *qt.C) (*Tree, *Tree) {
 	database1, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{database1, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree1, err := NewTree(Config{
+		database1, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{database2, 256, DefaultThresholdNLeafs,
-		HashFunctionBlake2b})
+	tree2, err := NewTree(Config{
+		database2, 256, DefaultThresholdNLeafs,
+		HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	return tree1, tree2
 }

circomproofs_test.go

@@ -14,8 +14,10 @@ func TestCircomVerifierProof(t *testing.T) {
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 4,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 4,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 

helpers_test.go

@@ -40,7 +40,7 @@ func checkRoots(c *qt.C, tree1, tree2 *Tree) {
 func storeTree(c *qt.C, tree *Tree, path string) {
 	dump, err := tree.Dump(nil)
 	c.Assert(err, qt.IsNil)
-	err = os.WriteFile(path+"-"+time.Now().String()+".debug", dump, 0600)
+	err = os.WriteFile(path+"-"+time.Now().String()+".debug", dump, 0o600)
 	c.Assert(err, qt.IsNil)
 }
 
@@ -89,14 +89,18 @@ func TestReadTreeDBG(t *testing.T) {
 
 	database1, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{Database: database1, MaxLevels: 100,
-		HashFunction: HashFunctionBlake2b})
+	tree1, err := NewTree(Config{
+		Database: database1, MaxLevels: 100,
+		HashFunction: HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{Database: database2, MaxLevels: 100,
-		HashFunction: HashFunctionBlake2b})
+	tree2, err := NewTree(Config{
+		Database: database2, MaxLevels: 100,
+		HashFunction: HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 
 	// tree1 is generated by a loop of .Add

testvectors/circom/go-data-generator/generator_test.go

@@ -43,7 +43,7 @@ func TestGenerator(t *testing.T) {
 	jCvp, err := json.Marshal(cvp)
 	c.Assert(err, qt.IsNil)
 	// store the data into a file that will be used at the circom test
-	err = os.WriteFile("go-smt-verifier-inputs.json", jCvp, 0600)
+	err = os.WriteFile("go-smt-verifier-inputs.json", jCvp, 0o600)
 	c.Assert(err, qt.IsNil)
 
 	// proof of non-existence
@@ -53,7 +53,7 @@ func TestGenerator(t *testing.T) {
 	jCvp, err = json.Marshal(cvp)
 	c.Assert(err, qt.IsNil)
 	// store the data into a file that will be used at the circom test
-	err = os.WriteFile("go-smt-verifier-non-existence-inputs.json", jCvp, 0600)
+	err = os.WriteFile("go-smt-verifier-non-existence-inputs.json", jCvp, 0o600)
 	c.Assert(err, qt.IsNil)
 
 	// create a new tree with big.Int keys
@@ -81,6 +81,6 @@ func TestGenerator(t *testing.T) {
 	jCvp, err = json.Marshal(cvp)
 	c.Assert(err, qt.IsNil)
 	// store the data into a file that will be used at the circom test
-	err = os.WriteFile("go-smt-verifier-big-inputs.json", jCvp, 0600)
+	err = os.WriteFile("go-smt-verifier-big-inputs.json", jCvp, 0o600)
 	c.Assert(err, qt.IsNil)
 }

tree.go

@@ -19,11 +19,11 @@ import (
 	"io"
 	"math"
 	"runtime"
+	"slices"
 	"sync"
 
 	"go.vocdoni.io/dvote/db"
 	"go.vocdoni.io/dvote/db/prefixeddb"
-	"slices"
 )
 
 const (
@@ -636,7 +636,8 @@ func (t *Tree) add(wTx db.WriteTx, root []byte, fromLvl int, k, v []byte) ([]byt
 // down goes down to the leaf recursively
 func (t *Tree) down(rTx db.Reader, newKey, currKey []byte, siblings [][]byte,
 	path []bool, currLvl int, getLeaf bool) (
-	[]byte, []byte, [][]byte, error) {
+	[]byte, []byte, [][]byte, error,
+) {
 	if currLvl > t.maxLevels {
 		return nil, nil, nil, ErrMaxLevel
 	}
@@ -710,7 +711,8 @@ func (t *Tree) down(rTx db.Reader, newKey, currKey []byte, siblings [][]byte,
 // downVirtually is used when in a leaf already exists, and a new leaf which
 // shares the path until the existing leaf is being added
 func (t *Tree) downVirtually(siblings [][]byte, oldKey, newKey []byte, oldPath,
-	newPath []bool, currLvl int) ([][]byte, error) {
+	newPath []bool, currLvl int,
+) ([][]byte, error) {
 	var err error
 	if currLvl > t.maxLevels-1 {
 		return nil, ErrMaxVirtualLevel
@@ -730,7 +732,8 @@ func (t *Tree) downVirtually(siblings [][]byte, oldKey, newKey []byte, oldPath,
 
 // up goes up recursively updating the intermediate nodes
 func (t *Tree) up(wTx db.WriteTx, key []byte, siblings [][]byte, path []bool,
-	currLvl, toLvl int) ([]byte, error) {
+	currLvl, toLvl int,
+) ([]byte, error) {
 	var k, v []byte
 	var err error
 	if path[currLvl+toLvl] {
@@ -1255,7 +1258,8 @@ func (t *Tree) IterateWithStop(fromRoot []byte, f func(int, []byte, []byte) bool
 // IterateWithStopWithTx does the same than the IterateWithStop method, but
 // allowing to pass the db.ReadTx that is used.
 func (t *Tree) IterateWithStopWithTx(rTx db.Reader, fromRoot []byte,
-	f func(int, []byte, []byte) bool) error {
+	f func(int, []byte, []byte) bool,
+) error {
 	// allow to define which root to use
 	if fromRoot == nil {
 		var err error
@@ -1268,7 +1272,8 @@ func (t *Tree) IterateWithStopWithTx(rTx db.Reader, fromRoot []byte,
 }
 
 func (t *Tree) iterWithStop(rTx db.Reader, k []byte, currLevel int,
-	f func(int, []byte, []byte) bool) error {
+	f func(int, []byte, []byte) bool,
+) error {
 	var v []byte
 	var err error
 	if bytes.Equal(k, t.emptyHash) {

tree_big.go

@@ -293,6 +293,8 @@ func bigIntToLeafValue(hFn HashFunction, bFullValue []byte) ([]byte, error) {
 }
 
 // splitInGroups splits the items in nGroups groups
+//
+//nolint:unused
 func splitInGroups[T any](items []T, nGroups int) [][]T {
 	groups := make([][]T, nGroups)
 	for i, item := range items {

tree_test.go

@@ -73,8 +73,10 @@ func TestAddTestVectors(t *testing.T) {
 func testAdd(c *qt.C, hashFunc HashFunction, testVectors []string) {
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: hashFunc})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: hashFunc,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -106,8 +108,10 @@ func TestAddBatch(t *testing.T) {
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -125,8 +129,10 @@ func TestAddBatch(t *testing.T) {
 
 	database, err = pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -149,8 +155,10 @@ func TestAddDifferentOrder(t *testing.T) {
 	c := qt.New(t)
 	database1, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{Database: database1, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree1, err := NewTree(Config{
+		Database: database1, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree1.treedb.Close() //nolint:errcheck
 
@@ -165,8 +173,10 @@ func TestAddDifferentOrder(t *testing.T) {
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{Database: database2, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		Database: database2, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -191,8 +201,10 @@ func TestAddRepeatedIndex(t *testing.T) {
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -210,8 +222,10 @@ func TestUpdate(t *testing.T) {
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -264,8 +278,10 @@ func TestAux(t *testing.T) { // TODO split in proper tests
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -304,8 +320,10 @@ func TestGet(t *testing.T) {
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -330,17 +348,21 @@ func TestBitmapBytes(t *testing.T) {
 
 	b := []byte{15}
 	bits := bytesToBitmap(b)
-	c.Assert(bits, qt.DeepEquals, []bool{true, true, true, true,
-		false, false, false, false})
+	c.Assert(bits, qt.DeepEquals, []bool{
+		true, true, true, true,
+		false, false, false, false,
+	})
 	b2 := bitmapToBytes(bits)
 	c.Assert(b2, qt.DeepEquals, b)
 
 	b = []byte{0, 15, 50}
 	bits = bytesToBitmap(b)
-	c.Assert(bits, qt.DeepEquals, []bool{false, false, false,
+	c.Assert(bits, qt.DeepEquals, []bool{
+		false, false, false,
 		false, false, false, false, false, true, true, true, true,
 		false, false, false, false, false, true, false, false, true,
-		true, false, false})
+		true, false, false,
+	})
 	b2 = bitmapToBytes(bits)
 	c.Assert(b2, qt.DeepEquals, b)
 
@@ -429,8 +451,10 @@ func TestGenProofAndVerify(t *testing.T) {
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -470,8 +494,10 @@ func testDumpAndImportDump(t *testing.T, inFile bool) {
 	c := qt.New(t)
 	database1, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{Database: database1, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree1, err := NewTree(Config{
+		Database: database1, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree1.treedb.Close() //nolint:errcheck
 
@@ -499,8 +525,10 @@ func testDumpAndImportDump(t *testing.T, inFile bool) {
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{Database: database2, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		Database: database2, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree2.treedb.Close() //nolint:errcheck
 
@@ -527,8 +555,10 @@ func TestRWMutex(t *testing.T) {
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -611,14 +641,18 @@ func TestAddBatchFullyUsed(t *testing.T) {
 
 	database1, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree1, err := NewTree(Config{Database: database1, MaxLevels: 4,
-		HashFunction: HashFunctionPoseidon})
+	tree1, err := NewTree(Config{
+		Database: database1, MaxLevels: 4,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 
 	database2, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree2, err := NewTree(Config{Database: database2, MaxLevels: 4,
-		HashFunction: HashFunctionPoseidon})
+	tree2, err := NewTree(Config{
+		Database: database2, MaxLevels: 4,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 
 	var keys, values [][]byte
@@ -672,8 +706,10 @@ func TestSetRoot(t *testing.T) {
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 
 	expectedRoot := "13742386369878513332697380582061714160370929283209286127733983161245560237407"
@@ -729,8 +765,10 @@ func TestSnapshot(t *testing.T) {
 	c := qt.New(t)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 
 	// fill the tree
@@ -780,8 +818,10 @@ func TestGetFromSnapshotExpectArboErrKeyNotFound(t *testing.T) {
 
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 256,
-		HashFunction: HashFunctionPoseidon})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 256,
+		HashFunction: HashFunctionPoseidon,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 
@@ -803,8 +843,10 @@ func TestKeyLen(t *testing.T) {
 	c.Assert(err, qt.IsNil)
 	// maxLevels is 100, keyPath length = ceil(maxLevels/8) = 13
 	maxLevels := 100
-	tree, err := NewTree(Config{Database: database, MaxLevels: maxLevels,
-		HashFunction: HashFunctionBlake2b})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: maxLevels,
+		HashFunction: HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 
 	// expect no errors when adding a key of only 4 bytes (when the
@@ -836,8 +878,10 @@ func TestKeyLen(t *testing.T) {
 	maxLevels = 32
 	database, err = pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err = NewTree(Config{Database: database, MaxLevels: maxLevels,
-		HashFunction: HashFunctionBlake2b})
+	tree, err = NewTree(Config{
+		Database: database, MaxLevels: maxLevels,
+		HashFunction: HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 
 	maxKeyLen := int(math.Ceil(float64(maxLevels) / float64(8))) //nolint:gomnd
@@ -907,8 +951,10 @@ func TestKeyLenBiggerThan32(t *testing.T) {
 	maxLevels := 264
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: maxLevels,
-		HashFunction: HashFunctionBlake2b})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: maxLevels,
+		HashFunction: HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 
 	bLen := 33
@@ -950,8 +996,10 @@ func benchmarkAdd(b *testing.B, hashFunc HashFunction, ks, vs [][]byte) {
 	c := qt.New(b)
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: 140,
-		HashFunction: hashFunc})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: 140,
+		HashFunction: hashFunc,
+	})
 	c.Assert(err, qt.IsNil)
 	defer tree.treedb.Close() //nolint:errcheck
 

vt.go

@@ -434,7 +434,7 @@ func (n *node) add(p *params, currLvl int, leaf *node) error {
 	switch t {
 	case vtMid:
 		if leaf.path[currLvl] {
-			//right
+			// right
 			if n.r == nil {
 				// empty sub-node, add the leaf here
 				n.r = leaf
@@ -566,7 +566,8 @@ func flp2(n int) int {
 // computeHashes computes the hashes under the node from which is called the
 // method. Returns an array of key-values to store in the db
 func (n *node) computeHashes(currLvl, maxLvl int, p *params, pairs [][2][]byte) (
-	[][2][]byte, error) {
+	[][2][]byte, error,
+) {
 	if n == nil || currLvl >= maxLvl {
 		// no need to compute any hash
 		return pairs, nil

vt_test.go

@@ -19,8 +19,10 @@ func testVirtualTree(c *qt.C, maxLevels int, keys, values [][]byte) {
 	// normal tree, to have an expected root value
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: maxLevels,
-		HashFunction: HashFunctionSha256})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: maxLevels,
+		HashFunction: HashFunctionSha256,
+	})
 	c.Assert(err, qt.IsNil)
 	for i := 0; i < len(keys); i++ {
 		err := tree.Add(keys[i], values[i])
@@ -125,8 +127,10 @@ func TestVirtualTreeAddBatch(t *testing.T) {
 	// normal tree, to have an expected root value
 	database, err := pebbledb.New(db.Options{Path: c.TempDir()})
 	c.Assert(err, qt.IsNil)
-	tree, err := NewTree(Config{Database: database, MaxLevels: maxLevels,
-		HashFunction: HashFunctionBlake2b})
+	tree, err := NewTree(Config{
+		Database: database, MaxLevels: maxLevels,
+		HashFunction: HashFunctionBlake2b,
+	})
 	c.Assert(err, qt.IsNil)
 	for i := 0; i < len(keys); i++ {
 		err := tree.Add(keys[i], values[i])