Wrap all errors with tracerr

db/statedb/statedb.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/log"
+	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-merkletree"
 	"github.com/iden3/go-merkletree/db"
 	"github.com/iden3/go-merkletree/db/pebble"
@@ -92,18 +93,18 @@ func NewStateDB(path string, typ TypeStateDB, nLevels int) (*StateDB, error) {
 	var err error
 	sto, err = pebble.NewPebbleStorage(path+PathCurrent, false)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	var mt *merkletree.MerkleTree = nil
 	if typ == TypeSynchronizer || typ == TypeBatchBuilder {
 		mt, err = merkletree.NewMerkleTree(sto.WithPrefix(PrefixKeyMT), nLevels)
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 	}
 	if typ == TypeTxSelector && nLevels != 0 {
-		return nil, fmt.Errorf("invalid StateDB parameters: StateDB type==TypeStateDB can not have nLevels!=0")
+		return nil, tracerr.Wrap(fmt.Errorf("invalid StateDB parameters: StateDB type==TypeStateDB can not have nLevels!=0"))
 	}
 
 	sdb := &StateDB{
@@ -116,13 +117,13 @@ func NewStateDB(path string, typ TypeStateDB, nLevels int) (*StateDB, error) {
 	// load currentBatch
 	sdb.currentBatch, err = sdb.GetCurrentBatch()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	// make reset (get checkpoint) at currentBatch
 	err = sdb.reset(sdb.currentBatch, false)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	return sdb, nil
@@ -136,11 +137,11 @@ func (s *StateDB) DB() *pebble.PebbleStorage {
 // GetCurrentBatch returns the current BatchNum stored in the StateDB
 func (s *StateDB) GetCurrentBatch() (common.BatchNum, error) {
 	cbBytes, err := s.db.Get(KeyCurrentBatch)
-	if err == db.ErrNotFound {
+	if tracerr.Unwrap(err) == db.ErrNotFound {
 		return 0, nil
 	}
 	if err != nil {
-		return 0, err
+		return 0, tracerr.Wrap(err)
 	}
 	return common.BatchNumFromBytes(cbBytes)
 }
@@ -149,14 +150,14 @@ func (s *StateDB) GetCurrentBatch() (common.BatchNum, error) {
 func (s *StateDB) setCurrentBatch() error {
 	tx, err := s.db.NewTx()
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	err = tx.Put(KeyCurrentBatch, s.currentBatch.Bytes())
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	if err := tx.Commit(); err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	return nil
 }
@@ -171,23 +172,23 @@ func (s *StateDB) MakeCheckpoint() error {
 
 	err := s.setCurrentBatch()
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 
 	// if checkpoint BatchNum already exist in disk, delete it
 	if _, err := os.Stat(checkpointPath); !os.IsNotExist(err) {
 		err := os.RemoveAll(checkpointPath)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 	} else if err != nil && !os.IsNotExist(err) {
-		return err
+		return tracerr.Wrap(err)
 	}
 
 	// execute Checkpoint
 	err = s.db.Pebble().Checkpoint(checkpointPath)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 
 	return nil
@@ -198,7 +199,7 @@ func (s *StateDB) DeleteCheckpoint(batchNum common.BatchNum) error {
 	checkpointPath := s.path + PathBatchNum + strconv.Itoa(int(batchNum))
 
 	if _, err := os.Stat(checkpointPath); os.IsNotExist(err) {
-		return fmt.Errorf("Checkpoint with batchNum %d does not exist in DB", batchNum)
+		return tracerr.Wrap(fmt.Errorf("Checkpoint with batchNum %d does not exist in DB", batchNum))
 	}
 
 	return os.RemoveAll(checkpointPath)
@@ -209,15 +210,15 @@ func pebbleMakeCheckpoint(source, dest string) error {
 	if _, err := os.Stat(dest); !os.IsNotExist(err) {
 		err := os.RemoveAll(dest)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 	} else if err != nil && !os.IsNotExist(err) {
-		return err
+		return tracerr.Wrap(err)
 	}
 
 	sto, err := pebble.NewPebbleStorage(source, false)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	defer func() {
 		errClose := sto.Pebble().Close()
@@ -229,7 +230,7 @@ func pebbleMakeCheckpoint(source, dest string) error {
 	// execute Checkpoint
 	err = sto.Pebble().Checkpoint(dest)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 
 	return nil
@@ -253,19 +254,19 @@ func (s *StateDB) reset(batchNum common.BatchNum, closeCurrent bool) error {
 
 	if closeCurrent {
 		if err := s.db.Pebble().Close(); err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 	}
 	// remove 'current'
 	err := os.RemoveAll(currentPath)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	if batchNum == 0 {
 		// if batchNum == 0, open the new fresh 'current'
 		sto, err := pebble.NewPebbleStorage(currentPath, false)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		s.db = sto
 		s.idx = 255
@@ -275,7 +276,7 @@ func (s *StateDB) reset(batchNum common.BatchNum, closeCurrent bool) error {
 			// open the MT for the current s.db
 			mt, err := merkletree.NewMerkleTree(s.db.WithPrefix(PrefixKeyMT), s.mt.MaxLevels())
 			if err != nil {
-				return err
+				return tracerr.Wrap(err)
 			}
 			s.mt = mt
 		}
@@ -286,32 +287,32 @@ func (s *StateDB) reset(batchNum common.BatchNum, closeCurrent bool) error {
 	// copy 'BatchNumX' to 'current'
 	err = pebbleMakeCheckpoint(checkpointPath, currentPath)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 
 	// open the new 'current'
 	sto, err := pebble.NewPebbleStorage(currentPath, false)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	s.db = sto
 
 	// get currentBatch num
 	s.currentBatch, err = s.GetCurrentBatch()
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	// idx is obtained from the statedb reset
 	s.idx, err = s.getIdx()
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 
 	if s.mt != nil {
 		// open the MT for the current s.db
 		mt, err := merkletree.NewMerkleTree(s.db.WithPrefix(PrefixKeyMT), s.mt.MaxLevels())
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		s.mt = mt
 	}
@@ -335,18 +336,18 @@ func (s *StateDB) GetAccounts() ([]common.Account, error) {
 	if err := idxDB.Iterate(func(k []byte, v []byte) (bool, error) {
 		idx, err := common.IdxFromBytes(k)
 		if err != nil {
-			return false, err
+			return false, tracerr.Wrap(err)
 		}
 		idxs = append(idxs, idx)
 		return true, nil
 	}); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	accs := []common.Account{}
 	for i := range idxs {
 		acc, err := s.GetAccount(idxs[i])
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		accs = append(accs, *acc)
 	}
@@ -358,21 +359,21 @@ func (s *StateDB) GetAccounts() ([]common.Account, error) {
 func getAccountInTreeDB(sto db.Storage, idx common.Idx) (*common.Account, error) {
 	idxBytes, err := idx.Bytes()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	vBytes, err := sto.Get(append(PrefixKeyIdx, idxBytes[:]...))
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	accBytes, err := sto.Get(append(PrefixKeyAccHash, vBytes...))
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	var b [32 * common.NLeafElems]byte
 	copy(b[:], accBytes)
 	account, err := common.AccountFromBytes(b)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	account.Idx = idx
 	return account, nil
@@ -384,11 +385,11 @@ func getAccountInTreeDB(sto db.Storage, idx common.Idx) (*common.Account, error)
 func (s *StateDB) CreateAccount(idx common.Idx, account *common.Account) (*merkletree.CircomProcessorProof, error) {
 	cpp, err := createAccountInTreeDB(s.db, s.mt, idx, account)
 	if err != nil {
-		return cpp, err
+		return cpp, tracerr.Wrap(err)
 	}
 	// store idx by EthAddr & BJJ
 	err = s.setIdxByEthAddrBJJ(idx, account.EthAddr, account.PublicKey, account.TokenID)
-	return cpp, err
+	return cpp, tracerr.Wrap(err)
 }
 
 // createAccountInTreeDB is abstracted from StateDB to be used from StateDB and
@@ -399,39 +400,39 @@ func createAccountInTreeDB(sto db.Storage, mt *merkletree.MerkleTree, idx common
 	// store at the DB the key: v, and value: leaf.Bytes()
 	v, err := account.HashValue()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	accountBytes, err := account.Bytes()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	// store the Leaf value
 	tx, err := sto.NewTx()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	idxBytes, err := idx.Bytes()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	_, err = tx.Get(append(PrefixKeyIdx, idxBytes[:]...))
-	if err != db.ErrNotFound {
-		return nil, ErrAccountAlreadyExists
+	if tracerr.Unwrap(err) != db.ErrNotFound {
+		return nil, tracerr.Wrap(ErrAccountAlreadyExists)
 	}
 
 	err = tx.Put(append(PrefixKeyAccHash, v.Bytes()...), accountBytes[:])
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	err = tx.Put(append(PrefixKeyIdx, idxBytes[:]...), v.Bytes())
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	if err := tx.Commit(); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	if mt != nil {
@@ -456,32 +457,32 @@ func updateAccountInTreeDB(sto db.Storage, mt *merkletree.MerkleTree, idx common
 	// store at the DB the key: v, and value: account.Bytes()
 	v, err := account.HashValue()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	accountBytes, err := account.Bytes()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	tx, err := sto.NewTx()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	err = tx.Put(append(PrefixKeyAccHash, v.Bytes()...), accountBytes[:])
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	idxBytes, err := idx.Bytes()
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	err = tx.Put(append(PrefixKeyIdx, idxBytes[:]...), v.Bytes())
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	if err := tx.Commit(); err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 
 	if mt != nil {
@@ -493,7 +494,7 @@ func updateAccountInTreeDB(sto db.Storage, mt *merkletree.MerkleTree, idx common
 // MTGetProof returns the CircomVerifierProof for a given Idx
 func (s *StateDB) MTGetProof(idx common.Idx) (*merkletree.CircomVerifierProof, error) {
 	if s.mt == nil {
-		return nil, ErrStateDBWithoutMT
+		return nil, tracerr.Wrap(ErrStateDBWithoutMT)
 	}
 	return s.mt.GenerateCircomVerifierProof(idx.BigInt(), s.mt.Root())
 }
@@ -516,7 +517,7 @@ type LocalStateDB struct {
 func NewLocalStateDB(path string, synchronizerDB *StateDB, typ TypeStateDB, nLevels int) (*LocalStateDB, error) {
 	s, err := NewStateDB(path, typ, nLevels)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	return &LocalStateDB{
 		s,
@@ -540,44 +541,44 @@ func (l *LocalStateDB) Reset(batchNum common.BatchNum, fromSynchronizer bool) er
 		// use checkpoint from SynchronizerStateDB
 		if _, err := os.Stat(synchronizerCheckpointPath); os.IsNotExist(err) {
 			// if synchronizerStateDB does not have checkpoint at batchNum, return err
-			return fmt.Errorf("Checkpoint not exist in Synchronizer")
+			return tracerr.Wrap(fmt.Errorf("Checkpoint not exist in Synchronizer"))
 		}
 
 		if err := l.db.Pebble().Close(); err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		// remove 'current'
 		err := os.RemoveAll(currentPath)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		// copy synchronizer'BatchNumX' to 'current'
 		err = pebbleMakeCheckpoint(synchronizerCheckpointPath, currentPath)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		// copy synchronizer'BatchNumX' to 'BatchNumX'
 		err = pebbleMakeCheckpoint(synchronizerCheckpointPath, checkpointPath)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 
 		// open the new 'current'
 		sto, err := pebble.NewPebbleStorage(currentPath, false)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		l.db = sto
 
 		// get currentBatch num
 		l.currentBatch, err = l.GetCurrentBatch()
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		// open the MT for the current s.db
 		mt, err := merkletree.NewMerkleTree(l.db.WithPrefix(PrefixKeyMT), l.mt.MaxLevels())
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		l.mt = mt
 

db/statedb/statedb_test.go

@@ -12,6 +12,7 @@ import (
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	ethCrypto "github.com/ethereum/go-ethereum/crypto"
 	"github.com/hermeznetwork/hermez-node/common"
+	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 	"github.com/iden3/go-merkletree/db"
 	"github.com/stretchr/testify/assert"
@@ -69,7 +70,7 @@ func TestNewStateDBIntermediateState(t *testing.T) {
 	assert.Nil(t, err)
 	v, err = sdb.db.Get(k0)
 	assert.NotNil(t, err)
-	assert.Equal(t, db.ErrNotFound, err)
+	assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
 	assert.Nil(t, v)
 
 	// store the same data from the beginning that has ben lost since last NewStateDB
@@ -116,7 +117,7 @@ func TestNewStateDBIntermediateState(t *testing.T) {
 
 	v, err = sdb.db.Get(k1)
 	assert.NotNil(t, err)
-	assert.Equal(t, db.ErrNotFound, err)
+	assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
 	assert.Nil(t, v)
 }
 
@@ -138,7 +139,7 @@ func TestStateDBWithoutMT(t *testing.T) {
 	unexistingAccount := common.Idx(1)
 	_, err = sdb.GetAccount(unexistingAccount)
 	assert.NotNil(t, err)
-	assert.Equal(t, db.ErrNotFound, err)
+	assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
 
 	// add test accounts
 	for i := 0; i < len(accounts); i++ {
@@ -159,7 +160,7 @@ func TestStateDBWithoutMT(t *testing.T) {
 	assert.Nil(t, err)
 	_, err = sdb.CreateAccount(common.Idx(256), accounts[1]) // check that can not be created twice
 	assert.NotNil(t, err)
-	assert.Equal(t, ErrAccountAlreadyExists, err)
+	assert.Equal(t, ErrAccountAlreadyExists, tracerr.Unwrap(err))
 
 	// update accounts
 	for i := 0; i < len(accounts); i++ {
@@ -171,7 +172,7 @@ func TestStateDBWithoutMT(t *testing.T) {
 
 	_, err = sdb.MTGetProof(common.Idx(1))
 	assert.NotNil(t, err)
-	assert.Equal(t, ErrStateDBWithoutMT, err)
+	assert.Equal(t, ErrStateDBWithoutMT, tracerr.Unwrap(err))
 }
 
 func TestStateDBWithMT(t *testing.T) {
@@ -191,7 +192,7 @@ func TestStateDBWithMT(t *testing.T) {
 	// get non-existing account, expecting an error
 	_, err = sdb.GetAccount(common.Idx(1))
 	assert.NotNil(t, err)
-	assert.Equal(t, db.ErrNotFound, err)
+	assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
 
 	// add test accounts
 	for i := 0; i < len(accounts); i++ {
@@ -210,7 +211,7 @@ func TestStateDBWithMT(t *testing.T) {
 	assert.Nil(t, err)
 	_, err = sdb.CreateAccount(common.Idx(256), accounts[1]) // check that can not be created twice
 	assert.NotNil(t, err)
-	assert.Equal(t, ErrAccountAlreadyExists, err)
+	assert.Equal(t, ErrAccountAlreadyExists, tracerr.Unwrap(err))
 
 	_, err = sdb.MTGetProof(common.Idx(256))
 	assert.Nil(t, err)

db/statedb/txprocessors.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/log"
+	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 	"github.com/iden3/go-merkletree"
 	"github.com/iden3/go-merkletree/db"
@@ -70,12 +71,12 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 	var createdAccounts []common.Account
 
 	if s.zki != nil {
-		return nil, errors.New("Expected StateDB.zki==nil, something went wrong and it's not empty")
+		return nil, tracerr.Wrap(errors.New("Expected StateDB.zki==nil, something went wrong and it's not empty"))
 	}
 	defer s.resetZKInputs()
 
 	if len(coordIdxs) >= int(ptc.MaxFeeTx) {
-		return nil, fmt.Errorf("CoordIdxs (%d) length must be smaller than MaxFeeTx (%d)", len(coordIdxs), ptc.MaxFeeTx)
+		return nil, tracerr.Wrap(fmt.Errorf("CoordIdxs (%d) length must be smaller than MaxFeeTx (%d)", len(coordIdxs), ptc.MaxFeeTx))
 	}
 
 	s.accumulatedFees = make(map[common.Idx]*big.Int)
@@ -104,7 +105,7 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 	if s.typ == TypeSynchronizer || s.typ == TypeBatchBuilder {
 		tmpDir, err := ioutil.TempDir("", "hermez-statedb-exittree")
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		defer func() {
 			if err := os.RemoveAll(tmpDir); err != nil {
@@ -113,11 +114,11 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 		}()
 		sto, err := pebble.NewPebbleStorage(tmpDir, false)
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		exitTree, err = merkletree.NewMerkleTree(sto, s.mt.MaxLevels())
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 	}
 
@@ -126,7 +127,7 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 		// assumption: l1usertx are sorted by L1Tx.Position
 		exitIdx, exitAccount, newExit, createdAccount, err := s.processL1Tx(exitTree, &l1usertxs[i])
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		if s.typ == TypeSynchronizer && createdAccount != nil {
 			createdAccounts = append(createdAccounts, *createdAccount)
@@ -135,13 +136,13 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 		if s.zki != nil {
 			l1TxData, err := l1usertxs[i].BytesGeneric()
 			if err != nil {
-				return nil, err
+				return nil, tracerr.Wrap(err)
 			}
 			s.zki.Metadata.L1TxsData = append(s.zki.Metadata.L1TxsData, l1TxData)
 
 			l1TxDataAvailability, err := l1usertxs[i].BytesDataAvailability(s.zki.Metadata.NLevels)
 			if err != nil {
-				return nil, err
+				return nil, tracerr.Wrap(err)
 			}
 			s.zki.Metadata.L1TxsDataAvailability = append(s.zki.Metadata.L1TxsDataAvailability, l1TxDataAvailability)
 
@@ -167,7 +168,7 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 	for i := 0; i < len(l1coordinatortxs); i++ {
 		exitIdx, _, _, createdAccount, err := s.processL1Tx(exitTree, &l1coordinatortxs[i])
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		if exitIdx != nil {
 			log.Error("Unexpected Exit in L1CoordinatorTx")
@@ -178,7 +179,7 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 		if s.zki != nil {
 			l1TxData, err := l1coordinatortxs[i].BytesGeneric()
 			if err != nil {
-				return nil, err
+				return nil, tracerr.Wrap(err)
 			}
 			s.zki.Metadata.L1TxsData = append(s.zki.Metadata.L1TxsData, l1TxData)
 
@@ -200,7 +201,7 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 	// created in the current batch, at this point the Idx will be created
 	coordIdxsMap, err := s.getTokenIDsFromIdxs(coordIdxs)
 	if err != nil {
-		return nil, err
+		return nil, tracerr.Wrap(err)
 	}
 	// collectedFees will contain the amount of fee collected for each
 	// TokenID
@@ -217,7 +218,7 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 		feePlanTokens, err := s.getFeePlanTokens(coordIdxs, l2txs)
 		if err != nil {
 			log.Error(err)
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		copy(s.zki.FeePlanTokens, feePlanTokens)
 	}
@@ -226,12 +227,12 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 	for i := 0; i < len(l2txs); i++ {
 		exitIdx, exitAccount, newExit, err := s.processL2Tx(coordIdxsMap, collectedFees, exitTree, &l2txs[i])
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		if s.zki != nil {
 			l2TxData, err := l2txs[i].L2Tx().BytesDataAvailability(s.zki.Metadata.NLevels)
 			if err != nil {
-				return nil, err
+				return nil, tracerr.Wrap(err)
 			}
 			s.zki.Metadata.L2TxsData = append(s.zki.Metadata.L2TxsData, l2TxData)
 
@@ -271,13 +272,13 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 		accCoord, err := s.GetAccount(idx)
 		if err != nil {
 			log.Errorw("Can not distribute accumulated fees to coordinator account: No coord Idx to receive fee", "idx", idx)
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		accCoord.Balance = new(big.Int).Add(accCoord.Balance, accumulatedFee)
 		pFee, err := s.UpdateAccount(idx, accCoord)
 		if err != nil {
 			log.Error(err)
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		if s.zki != nil {
 			s.zki.TokenID3[iFee] = accCoord.TokenID.BigInt()
@@ -315,7 +316,7 @@ func (s *StateDB) ProcessTxs(ptc ProcessTxsConfig, coordIdxs []common.Idx, l1use
 		// 0. generate MerkleProof
 		p, err := exitTree.GenerateCircomVerifierProof(exitIdx.BigInt(), nil)
 		if err != nil {
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		// 1. generate common.ExitInfo
 		ei := common.ExitInfo{
@@ -389,7 +390,7 @@ func (s *StateDB) getFeePlanTokens(coordIdxs []common.Idx, l2txs []common.PoolL2
 		acc, err := s.GetAccount(coordIdxs[i])
 		if err != nil {
 			log.Errorf("could not get account to determine TokenID of CoordIdx %d not found: %s", coordIdxs[i], err.Error())
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		coordTokenIDs[acc.TokenID] = true
 	}
@@ -401,7 +402,7 @@ func (s *StateDB) getFeePlanTokens(coordIdxs []common.Idx, l2txs []common.PoolL2
 		acc, err := s.GetAccount(l2txs[i].FromIdx)
 		if err != nil {
 			log.Errorf("could not get account to determine TokenID of L2Tx: FromIdx %d not found: %s", l2txs[i].FromIdx, err.Error())
-			return nil, err
+			return nil, tracerr.Wrap(err)
 		}
 		if _, ok := coordTokenIDs[acc.TokenID]; ok {
 			tokenIDs[acc.TokenID] = true
@@ -429,7 +430,7 @@ func (s *StateDB) processL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx)
 		s.zki.TxCompressedData[s.i], err = tx.TxCompressedData()
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, nil, err
+			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
 		s.zki.FromIdx[s.i] = tx.FromIdx.BigInt()
 		s.zki.ToIdx[s.i] = tx.ToIdx.BigInt()
@@ -460,7 +461,7 @@ func (s *StateDB) processL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx)
 		err := s.applyTransfer(nil, nil, tx.Tx(), 0)
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, nil, err
+			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
 	case common.TxTypeCreateAccountDeposit:
 		s.computeEffectiveAmounts(tx)
@@ -469,7 +470,7 @@ func (s *StateDB) processL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx)
 		err := s.applyCreateAccount(tx)
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, nil, err
+			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
 		// TODO applyCreateAccount will return the created account,
 		// which in the case type==TypeSynchronizer will be added to an
@@ -481,7 +482,7 @@ func (s *StateDB) processL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx)
 		err := s.applyDeposit(tx, false)
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, nil, err
+			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
 	case common.TxTypeDepositTransfer:
 		s.computeEffectiveAmounts(tx)
@@ -491,7 +492,7 @@ func (s *StateDB) processL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx)
 		err := s.applyDeposit(tx, true)
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, nil, err
+			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
 	case common.TxTypeCreateAccountDepositTransfer:
 		s.computeEffectiveAmounts(tx)
@@ -501,7 +502,7 @@ func (s *StateDB) processL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx)
 		err := s.applyCreateAccountDepositTransfer(tx)
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, nil, err
+			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
 	case common.TxTypeForceExit:
 		s.computeEffectiveAmounts(tx)
@@ -511,7 +512,7 @@ func (s *StateDB) processL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx)
 		exitAccount, newExit, err := s.applyExit(nil, nil, exitTree, tx.Tx())
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, nil, err
+			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
 		return &tx.FromIdx, exitAccount, newExit, nil, nil
 	default:
@@ -523,7 +524,7 @@ func (s *StateDB) processL1Tx(exitTree *merkletree.MerkleTree, tx *common.L1Tx)
 		createdAccount, err = s.GetAccount(s.idx)
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, nil, err
+			return nil, nil, false, nil, tracerr.Wrap(err)
 		}
 	}
 
@@ -542,12 +543,12 @@ func (s *StateDB) processL2Tx(coordIdxsMap map[common.TokenID]common.Idx, collec
 		if s.typ == TypeSynchronizer {
 			// this should never be reached
 			log.Error("WARNING: In StateDB with Synchronizer mode L2.ToIdx can't be 0")
-			return nil, nil, false, fmt.Errorf("In StateDB with Synchronizer mode L2.ToIdx can't be 0")
+			return nil, nil, false, tracerr.Wrap(fmt.Errorf("In StateDB with Synchronizer mode L2.ToIdx can't be 0"))
 		}
 		// case when tx.Type== common.TxTypeTransferToEthAddr or common.TxTypeTransferToBJJ
 		tx.AuxToIdx, err = s.GetIdxByEthAddrBJJ(tx.ToEthAddr, tx.ToBJJ, tx.TokenID)
 		if err != nil {
-			return nil, nil, false, err
+			return nil, nil, false, tracerr.Wrap(err)
 		}
 	}
 
@@ -556,11 +557,11 @@ func (s *StateDB) processL2Tx(coordIdxsMap map[common.TokenID]common.Idx, collec
 		// Txs
 		s.zki.TxCompressedData[s.i], err = tx.TxCompressedData()
 		if err != nil {
-			return nil, nil, false, err
+			return nil, nil, false, tracerr.Wrap(err)
 		}
 		s.zki.TxCompressedDataV2[s.i], err = tx.TxCompressedDataV2()
 		if err != nil {
-			return nil, nil, false, err
+			return nil, nil, false, tracerr.Wrap(err)
 		}
 		s.zki.FromIdx[s.i] = tx.FromIdx.BigInt()
 		s.zki.ToIdx[s.i] = tx.ToIdx.BigInt()
@@ -589,7 +590,7 @@ func (s *StateDB) processL2Tx(coordIdxsMap map[common.TokenID]common.Idx, collec
 		signature, err := tx.Signature.Decompress()
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, err
+			return nil, nil, false, tracerr.Wrap(err)
 		}
 		s.zki.S[s.i] = signature.S
 		s.zki.R8x[s.i] = signature.R8.X
@@ -602,7 +603,7 @@ func (s *StateDB) processL2Tx(coordIdxsMap map[common.TokenID]common.Idx, collec
 		acc, err := s.GetAccount(tx.FromIdx)
 		if err != nil {
 			log.Errorw("GetAccount", "fromIdx", tx.FromIdx, "err", err)
-			return nil, nil, false, err
+			return nil, nil, false, tracerr.Wrap(err)
 		}
 		tx.Nonce = acc.Nonce + 1
 		tx.TokenID = acc.TokenID
@@ -615,14 +616,14 @@ func (s *StateDB) processL2Tx(coordIdxsMap map[common.TokenID]common.Idx, collec
 		err = s.applyTransfer(coordIdxsMap, collectedFees, tx.Tx(), tx.AuxToIdx)
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, err
+			return nil, nil, false, tracerr.Wrap(err)
 		}
 	case common.TxTypeExit:
 		// execute exit flow
 		exitAccount, newExit, err := s.applyExit(coordIdxsMap, collectedFees, exitTree, tx.Tx())
 		if err != nil {
 			log.Error(err)
-			return nil, nil, false, err
+			return nil, nil, false, tracerr.Wrap(err)
 		}
 		return &tx.FromIdx, exitAccount, newExit, nil
 	default:
@@ -643,7 +644,7 @@ func (s *StateDB) applyCreateAccount(tx *common.L1Tx) error {
 
 	p, err := s.CreateAccount(common.Idx(s.idx+1), account)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	if s.zki != nil {
 		s.zki.TokenID1[s.i] = tx.TokenID.BigInt()
@@ -683,7 +684,7 @@ func (s *StateDB) applyDeposit(tx *common.L1Tx, transfer bool) error {
 	// deposit the tx.EffectiveLoadAmount into the sender account
 	accSender, err := s.GetAccount(tx.FromIdx)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	accSender.Balance = new(big.Int).Add(accSender.Balance, tx.EffectiveLoadAmount)
 
@@ -692,7 +693,7 @@ func (s *StateDB) applyDeposit(tx *common.L1Tx, transfer bool) error {
 	if transfer {
 		accReceiver, err = s.GetAccount(tx.ToIdx)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		// subtract amount to the sender
 		accSender.Balance = new(big.Int).Sub(accSender.Balance, tx.EffectiveAmount)
@@ -702,7 +703,7 @@ func (s *StateDB) applyDeposit(tx *common.L1Tx, transfer bool) error {
 	// update sender account in localStateDB
 	p, err := s.UpdateAccount(tx.FromIdx, accSender)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	if s.zki != nil {
 		s.zki.TokenID1[s.i] = accSender.TokenID.BigInt()
@@ -722,7 +723,7 @@ func (s *StateDB) applyDeposit(tx *common.L1Tx, transfer bool) error {
 		// update receiver account in localStateDB
 		p, err := s.UpdateAccount(tx.ToIdx, accReceiver)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		if s.zki != nil {
 			s.zki.TokenID2[s.i] = accReceiver.TokenID.BigInt()
@@ -757,7 +758,7 @@ func (s *StateDB) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 	accSender, err := s.GetAccount(tx.FromIdx)
 	if err != nil {
 		log.Error(err)
-		return err
+		return tracerr.Wrap(err)
 	}
 	if !tx.IsL1 {
 		// increment nonce
@@ -766,7 +767,7 @@ func (s *StateDB) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 		// compute fee and subtract it from the accSender
 		fee, err := common.CalcFeeAmount(tx.Amount, *tx.Fee)
 		if err != nil {
-			return err
+			return tracerr.Wrap(err)
 		}
 		feeAndAmount := new(big.Int).Add(tx.Amount, fee)
 		accSender.Balance = new(big.Int).Sub(accSender.Balance, feeAndAmount)
@@ -798,7 +799,7 @@ func (s *StateDB) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 		accReceiver, err = s.GetAccount(auxToIdx)
 		if err != nil {
 			log.Error(err)
-			return err
+			return tracerr.Wrap(err)
 		}
 	}
 
@@ -809,7 +810,7 @@ func (s *StateDB) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 	pSender, err := s.UpdateAccount(tx.FromIdx, accSender)
 	if err != nil {
 		log.Error(err)
-		return err
+		return tracerr.Wrap(err)
 	}
 	if s.zki != nil {
 		s.zki.TokenID1[s.i] = accSender.TokenID.BigInt()
@@ -826,7 +827,7 @@ func (s *StateDB) applyTransfer(coordIdxsMap map[common.TokenID]common.Idx,
 	// update receiver account in localStateDB
 	pReceiver, err := s.UpdateAccount(auxToIdx, accReceiver)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	if s.zki != nil {
 		s.zki.TokenID2[s.i] = accReceiver.TokenID.BigInt()
@@ -855,7 +856,7 @@ func (s *StateDB) applyCreateAccountDepositTransfer(tx *common.L1Tx) error {
 	}
 	accReceiver, err := s.GetAccount(tx.ToIdx)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	// subtract amount to the sender
 	accSender.Balance = new(big.Int).Sub(accSender.Balance, tx.EffectiveAmount)
@@ -865,7 +866,7 @@ func (s *StateDB) applyCreateAccountDepositTransfer(tx *common.L1Tx) error {
 	// create Account of the Sender
 	p, err := s.CreateAccount(common.Idx(s.idx+1), accSender)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	if s.zki != nil {
 		s.zki.TokenID1[s.i] = tx.TokenID.BigInt()
@@ -895,7 +896,7 @@ func (s *StateDB) applyCreateAccountDepositTransfer(tx *common.L1Tx) error {
 	// update receiver account in localStateDB
 	p, err = s.UpdateAccount(tx.ToIdx, accReceiver)
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	if s.zki != nil {
 		s.zki.TokenID2[s.i] = accReceiver.TokenID.BigInt()
@@ -922,7 +923,7 @@ func (s *StateDB) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 	// add the tx.Amount into the Account (tx.FromIdx) in the ExitMT
 	acc, err := s.GetAccount(tx.FromIdx)
 	if err != nil {
-		return nil, false, err
+		return nil, false, tracerr.Wrap(err)
 	}
 
 	if !tx.IsL1 {
@@ -932,7 +933,7 @@ func (s *StateDB) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 		// compute fee and subtract it from the accSender
 		fee, err := common.CalcFeeAmount(tx.Amount, *tx.Fee)
 		if err != nil {
-			return nil, false, err
+			return nil, false, tracerr.Wrap(err)
 		}
 		feeAndAmount := new(big.Int).Add(tx.Amount, fee)
 		acc.Balance = new(big.Int).Sub(acc.Balance, feeAndAmount)
@@ -956,7 +957,7 @@ func (s *StateDB) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 
 	p, err := s.UpdateAccount(tx.FromIdx, acc)
 	if err != nil {
-		return nil, false, err
+		return nil, false, tracerr.Wrap(err)
 	}
 	if s.zki != nil {
 		s.zki.TokenID1[s.i] = acc.TokenID.BigInt()
@@ -974,7 +975,7 @@ func (s *StateDB) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 		return nil, false, nil
 	}
 	exitAccount, err := getAccountInTreeDB(exitTree.DB(), tx.FromIdx)
-	if err == db.ErrNotFound {
+	if tracerr.Unwrap(err) == db.ErrNotFound {
 		// 1a. if idx does not exist in exitTree:
 		// add new leaf 'ExitTreeLeaf', where ExitTreeLeaf.Balance = exitAmount (exitAmount=tx.Amount)
 		exitAccount := &common.Account{
@@ -985,16 +986,16 @@ func (s *StateDB) applyExit(coordIdxsMap map[common.TokenID]common.Idx,
 			EthAddr:   acc.EthAddr,
 		}
 		_, err = createAccountInTreeDB(exitTree.DB(), exitTree, tx.FromIdx, exitAccount)
-		return exitAccount, true, err
+		return exitAccount, true, tracerr.Wrap(err)
 	} else if err != nil {
-		return exitAccount, false, err
+		return exitAccount, false, tracerr.Wrap(err)
 	}
 
 	// 1b. if idx already exist in exitTree:
 	// update account, where account.Balance += exitAmount
 	exitAccount.Balance = new(big.Int).Add(exitAccount.Balance, tx.Amount)
 	_, err = updateAccountInTreeDB(exitTree.DB(), exitTree, tx.FromIdx, exitAccount)
-	return exitAccount, false, err
+	return exitAccount, false, tracerr.Wrap(err)
 }
 
 // computeEffectiveAmounts checks that the L1Tx data is correct
@@ -1084,11 +1085,11 @@ func (s *StateDB) computeEffectiveAmounts(tx *common.L1Tx) {
 // used for an Account in the localStateDB.
 func (s *StateDB) getIdx() (common.Idx, error) {
 	idxBytes, err := s.DB().Get(keyidx)
-	if err == db.ErrNotFound {
+	if tracerr.Unwrap(err) == db.ErrNotFound {
 		return 0, nil
 	}
 	if err != nil {
-		return 0, err
+		return 0, tracerr.Wrap(err)
 	}
 	return common.IdxFromBytes(idxBytes[:])
 }
@@ -1097,18 +1098,18 @@ func (s *StateDB) getIdx() (common.Idx, error) {
 func (s *StateDB) setIdx(idx common.Idx) error {
 	tx, err := s.DB().NewTx()
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	idxBytes, err := idx.Bytes()
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	err = tx.Put(keyidx, idxBytes[:])
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	if err := tx.Commit(); err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	return nil
 }

db/statedb/utils.go

@@ -8,6 +8,7 @@ import (
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/hermeznetwork/hermez-node/common"
 	"github.com/hermeznetwork/hermez-node/log"
+	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 	"github.com/iden3/go-merkletree"
 )
@@ -46,7 +47,7 @@ func (s *StateDB) setIdxByEthAddrBJJ(idx common.Idx, addr ethCommon.Address, pk
 	}
 
 	if pk == nil {
-		return fmt.Errorf("BabyJubJub pk not defined")
+		return tracerr.Wrap(fmt.Errorf("BabyJubJub pk not defined"))
 	}
 
 	// store idx for EthAddr & BJJ assuming that EthAddr & BJJ still don't
@@ -55,28 +56,28 @@ func (s *StateDB) setIdxByEthAddrBJJ(idx common.Idx, addr ethCommon.Address, pk
 	// (smaller)
 	tx, err := s.db.NewTx()
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	idxBytes, err := idx.Bytes()
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	// store Addr&BJJ-idx
 	k := concatEthAddrBJJTokenID(addr, pk, tokenID)
 	err = tx.Put(append(PrefixKeyAddrBJJ, k...), idxBytes[:])
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 
 	// store Addr-idx
 	k = concatEthAddrTokenID(addr, tokenID)
 	err = tx.Put(append(PrefixKeyAddr, k...), idxBytes[:])
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	err = tx.Commit()
 	if err != nil {
-		return err
+		return tracerr.Wrap(err)
 	}
 	return nil
 }
@@ -88,11 +89,11 @@ func (s *StateDB) GetIdxByEthAddr(addr ethCommon.Address, tokenID common.TokenID
 	k := concatEthAddrTokenID(addr, tokenID)
 	b, err := s.db.Get(append(PrefixKeyAddr, k...))
 	if err != nil {
-		return common.Idx(0), fmt.Errorf("GetIdxByEthAddr: %s: ToEthAddr: %s, TokenID: %d", ErrToIdxNotFound, addr.Hex(), tokenID)
+		return common.Idx(0), tracerr.Wrap(fmt.Errorf("GetIdxByEthAddr: %s: ToEthAddr: %s, TokenID: %d", ErrToIdxNotFound, addr.Hex(), tokenID))
 	}
 	idx, err := common.IdxFromBytes(b)
 	if err != nil {
-		return common.Idx(0), fmt.Errorf("GetIdxByEthAddr: %s: ToEthAddr: %s, TokenID: %d", err, addr.Hex(), tokenID)
+		return common.Idx(0), tracerr.Wrap(fmt.Errorf("GetIdxByEthAddr: %s: ToEthAddr: %s, TokenID: %d", err, addr.Hex(), tokenID))
 	}
 	return idx, nil
 }
@@ -112,16 +113,16 @@ func (s *StateDB) GetIdxByEthAddrBJJ(addr ethCommon.Address, pk *babyjub.PublicK
 		k := concatEthAddrBJJTokenID(addr, pk, tokenID)
 		b, err := s.db.Get(append(PrefixKeyAddrBJJ, k...))
 		if err != nil {
-			return common.Idx(0), fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", ErrToIdxNotFound, addr.Hex(), pk, tokenID)
+			return common.Idx(0), tracerr.Wrap(fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", ErrToIdxNotFound, addr.Hex(), pk, tokenID))
 		}
 		idx, err := common.IdxFromBytes(b)
 		if err != nil {
-			return common.Idx(0), fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", err, addr.Hex(), pk, tokenID)
+			return common.Idx(0), tracerr.Wrap(fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", err, addr.Hex(), pk, tokenID))
 		}
 		return idx, nil
 	}
 	// rest of cases (included case ToEthAddr==0) are not possible
-	return common.Idx(0), fmt.Errorf("GetIdxByEthAddrBJJ: Not found, %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", ErrGetIdxNoCase, addr.Hex(), pk, tokenID)
+	return common.Idx(0), tracerr.Wrap(fmt.Errorf("GetIdxByEthAddrBJJ: Not found, %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", ErrGetIdxNoCase, addr.Hex(), pk, tokenID))
 }
 
 func (s *StateDB) getTokenIDsFromIdxs(idxs []common.Idx) (map[common.TokenID]common.Idx, error) {
@@ -129,7 +130,7 @@ func (s *StateDB) getTokenIDsFromIdxs(idxs []common.Idx) (map[common.TokenID]com
 	for i := 0; i < len(idxs); i++ {
 		a, err := s.GetAccount(idxs[i])
 		if err != nil {
-			return nil, fmt.Errorf("getTokenIDsFromIdxs error on GetAccount with Idx==%d: %s", idxs[i], err.Error())
+			return nil, tracerr.Wrap(fmt.Errorf("getTokenIDsFromIdxs error on GetAccount with Idx==%d: %s", idxs[i], err.Error()))
 		}
 		m[a.TokenID] = idxs[i]
 	}

db/statedb/utils_test.go

@@ -9,6 +9,7 @@ import (
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/hermeznetwork/hermez-node/common"
+	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-iden3-crypto/babyjub"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -84,7 +85,7 @@ func TestGetIdx(t *testing.T) {
 	idxR, err = sdb.GetIdxByEthAddrBJJ(addr2, pk2, tokenID0)
 	assert.NotNil(t, err)
 	expectedErr := fmt.Errorf("GetIdxByEthAddrBJJ: %s: ToEthAddr: %s, ToBJJ: %s, TokenID: %d", ErrToIdxNotFound, addr2.Hex(), pk2, tokenID0)
-	assert.Equal(t, expectedErr, err)
+	assert.Equal(t, expectedErr, tracerr.Unwrap(err))
 	assert.Equal(t, common.Idx(0), idxR)
 	// expect error when trying to get Idx by addr with not used TokenID
 	_, err = sdb.GetIdxByEthAddr(addr, tokenID1)