Add Last db view in kvdb and statedb

Last db view is an opened pebble db which always contains a checkpoint from the
last batch.  Methods to access this last batch are thread safe so that views of
the last checkpoint can be made anywhere and with a consistent view of the
state.

db/statedb/statedb.go

@@ -11,6 +11,7 @@ import (
 	"github.com/hermeznetwork/tracerr"
 	"github.com/iden3/go-merkletree"
 	"github.com/iden3/go-merkletree/db"
+	"github.com/iden3/go-merkletree/db/pebble"
 )
 
 var (
@@ -58,11 +59,46 @@ type TypeStateDB string
 
 // StateDB represents the StateDB object
 type StateDB struct {
-	path string
-	Typ  TypeStateDB
-	db   *kvdb.KVDB
-	MT   *merkletree.MerkleTree
-	keep int
+	path    string
+	Typ     TypeStateDB
+	db      *kvdb.KVDB
+	nLevels int
+	MT      *merkletree.MerkleTree
+	keep    int
+}
+
+// Last offers a subset of view methods of the StateDB that can be
+// called via the LastRead method of StateDB in a thread-safe manner to obtain
+// a consistent view to the last batch of the StateDB.
+type Last struct {
+	db db.Storage
+}
+
+// GetAccount returns the account for the given Idx
+func (s *Last) GetAccount(idx common.Idx) (*common.Account, error) {
+	return GetAccountInTreeDB(s.db, idx)
+}
+
+// GetCurrentBatch returns the current BatchNum stored in Last.db
+func (s *Last) GetCurrentBatch() (common.BatchNum, error) {
+	cbBytes, err := s.db.Get(kvdb.KeyCurrentBatch)
+	if tracerr.Unwrap(err) == db.ErrNotFound {
+		return 0, nil
+	} else if err != nil {
+		return 0, tracerr.Wrap(err)
+	}
+	return common.BatchNumFromBytes(cbBytes)
+}
+
+// DB returns the underlying storage of Last
+func (s *Last) DB() db.Storage {
+	return s.db
+}
+
+// GetAccounts returns all the accounts in the db.  Use for debugging pruposes
+// only.
+func (s *Last) GetAccounts() ([]common.Account, error) {
+	return getAccounts(s.db)
 }
 
 // NewStateDB creates a new StateDB, allowing to use an in-memory or in-disk
@@ -89,14 +125,72 @@ func NewStateDB(pathDB string, keep int, typ TypeStateDB, nLevels int) (*StateDB
 	}
 
 	return &StateDB{
-		path: pathDB,
-		db:   kv,
-		MT:   mt,
-		Typ:  typ,
-		keep: keep,
+		path:    pathDB,
+		db:      kv,
+		nLevels: nLevels,
+		MT:      mt,
+		Typ:     typ,
+		keep:    keep,
 	}, nil
 }
 
+// LastRead is a thread-safe method to query the last checkpoint of the StateDB
+// via the Last type methods
+func (s *StateDB) LastRead(fn func(sdbLast *Last) error) error {
+	return s.db.LastRead(
+		func(db *pebble.Storage) error {
+			return fn(&Last{
+				db: db,
+			})
+		},
+	)
+}
+
+// LastGetAccount is a thread-safe method to query an account in the last
+// checkpoint of the StateDB.
+func (s *StateDB) LastGetAccount(idx common.Idx) (*common.Account, error) {
+	var account *common.Account
+	if err := s.LastRead(func(sdb *Last) error {
+		var err error
+		account, err = sdb.GetAccount(idx)
+		return err
+	}); err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	return account, nil
+}
+
+// LastGetCurrentBatch is a thread-safe method to get the current BatchNum in
+// the last checkpoint of the StateDB.
+func (s *StateDB) LastGetCurrentBatch() (common.BatchNum, error) {
+	var batchNum common.BatchNum
+	if err := s.LastRead(func(sdb *Last) error {
+		var err error
+		batchNum, err = sdb.GetCurrentBatch()
+		return err
+	}); err != nil {
+		return 0, tracerr.Wrap(err)
+	}
+	return batchNum, nil
+}
+
+// LastMTGetRoot returns the root of the underlying Merkle Tree in the last
+// checkpoint of the StateDB.
+func (s *StateDB) LastMTGetRoot() (*big.Int, error) {
+	var root *big.Int
+	if err := s.LastRead(func(sdb *Last) error {
+		mt, err := merkletree.NewMerkleTree(sdb.DB().WithPrefix(PrefixKeyMT), s.nLevels)
+		if err != nil {
+			return tracerr.Wrap(err)
+		}
+		root = mt.Root().BigInt()
+		return nil
+	}); err != nil {
+		return nil, tracerr.Wrap(err)
+	}
+	return root, nil
+}
+
 // MakeCheckpoint does a checkpoint at the given batchNum in the defined path.
 // Internally this advances & stores the current BatchNum, and then stores a
 // Checkpoint of the current state of the StateDB.
@@ -115,8 +209,8 @@ func (s *StateDB) CurrentIdx() common.Idx {
 	return s.db.CurrentIdx
 }
 
-// GetCurrentBatch returns the current BatchNum stored in the StateDB.db
-func (s *StateDB) GetCurrentBatch() (common.BatchNum, error) {
+// getCurrentBatch returns the current BatchNum stored in the StateDB.db
+func (s *StateDB) getCurrentBatch() (common.BatchNum, error) {
 	return s.db.GetCurrentBatch()
 }
 
@@ -157,35 +251,50 @@ func (s *StateDB) GetAccount(idx common.Idx) (*common.Account, error) {
 	return GetAccountInTreeDB(s.db.DB(), idx)
 }
 
-// GetAccounts returns all the accounts in the db.  Use for debugging pruposes
-// only.
-func (s *StateDB) GetAccounts() ([]common.Account, error) {
-	idxDB := s.db.StorageWithPrefix(PrefixKeyIdx)
-	idxs := []common.Idx{}
-	// NOTE: Current implementation of Iterate in the pebble interface is
-	// not efficient, as it iterates over all keys.  Improve it following
-	// this example: https://github.com/cockroachdb/pebble/pull/923/files
+func accountsIter(db db.Storage, fn func(a *common.Account) (bool, error)) error {
+	idxDB := db.WithPrefix(PrefixKeyIdx)
 	if err := idxDB.Iterate(func(k []byte, v []byte) (bool, error) {
 		idx, err := common.IdxFromBytes(k)
 		if err != nil {
 			return false, tracerr.Wrap(err)
 		}
-		idxs = append(idxs, idx)
-		return true, nil
+		acc, err := GetAccountInTreeDB(db, idx)
+		if err != nil {
+			return false, tracerr.Wrap(err)
+		}
+		ok, err := fn(acc)
+		if err != nil {
+			return false, tracerr.Wrap(err)
+		}
+		return ok, nil
 	}); err != nil {
+		return tracerr.Wrap(err)
+	}
+	return nil
+}
+
+func getAccounts(db db.Storage) ([]common.Account, error) {
+	accs := []common.Account{}
+	if err := accountsIter(
+		db,
+		func(a *common.Account) (bool, error) {
+			accs = append(accs, *a)
+			return true, nil
+		},
+	); err != nil {
 		return nil, tracerr.Wrap(err)
 	}
-	accs := []common.Account{}
-	for i := range idxs {
-		acc, err := s.GetAccount(idxs[i])
-		if err != nil {
-			return nil, tracerr.Wrap(err)
-		}
-		accs = append(accs, *acc)
-	}
 	return accs, nil
 }
 
+// TestGetAccounts returns all the accounts in the db.  Use only in tests.
+// Outside tests getting all the accounts is discouraged because it's an
+// expensive operation, but if you must do it, use `LastRead()` method to get a
+// thread-safe and consistent view of the stateDB.
+func (s *StateDB) TestGetAccounts() ([]common.Account, error) {
+	return getAccounts(s.db.DB())
+}
+
 // GetAccountInTreeDB is abstracted from StateDB to be used from StateDB and
 // from ExitTree.  GetAccount returns the account for the given Idx
 func GetAccountInTreeDB(sto db.Storage, idx common.Idx) (*common.Account, error) {
@@ -336,11 +445,6 @@ func (s *StateDB) MTGetProof(idx common.Idx) (*merkletree.CircomVerifierProof, e
 	return p, nil
 }
 
-// MTGetRoot returns the current root of the underlying Merkle Tree
-func (s *StateDB) MTGetRoot() *big.Int {
-	return s.MT.Root().BigInt()
-}
-
 // Close the StateDB
 func (s *StateDB) Close() {
 	s.db.Close()

db/statedb/statedb_test.go

@@ -43,10 +43,10 @@ func newAccount(t *testing.T, i int) *common.Account {
 func TestNewStateDBIntermediateState(t *testing.T) {
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir))
+	defer require.NoError(t, os.RemoveAll(dir))
 
 	sdb, err := NewStateDB(dir, 128, TypeTxSelector, 0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// test values
 	k0 := []byte("testkey0")
@@ -56,19 +56,26 @@ func TestNewStateDBIntermediateState(t *testing.T) {
 
 	// store some data
 	tx, err := sdb.db.DB().NewTx()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = tx.Put(k0, v0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = tx.Commit()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	v, err := sdb.db.DB().Get(k0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, v0, v)
 
-	// Close PebbleDB before creating a new StateDB
-	err = sdb.db.DB().Pebble().Close()
+	// k0 not yet in last
+	err = sdb.LastRead(func(sdb *Last) error {
+		_, err := sdb.DB().Get(k0)
+		assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
+		return nil
+	})
 	require.NoError(t, err)
 
+	// Close PebbleDB before creating a new StateDB
+	sdb.Close()
+
 	// call NewStateDB which should get the db at the last checkpoint state
 	// executing a Reset (discarding the last 'testkey0'&'testvalue0' data)
 	sdb, err = NewStateDB(dir, 128, TypeTxSelector, 0)
@@ -78,54 +85,90 @@ func TestNewStateDBIntermediateState(t *testing.T) {
 	assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
 	assert.Nil(t, v)
 
+	// k0 not in last
+	err = sdb.LastRead(func(sdb *Last) error {
+		_, err := sdb.DB().Get(k0)
+		assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
+		return nil
+	})
+	require.NoError(t, err)
+
 	// store the same data from the beginning that has ben lost since last NewStateDB
 	tx, err = sdb.db.DB().NewTx()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = tx.Put(k0, v0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = tx.Commit()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	v, err = sdb.db.DB().Get(k0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, v0, v)
 
+	// k0 yet not in last
+	err = sdb.LastRead(func(sdb *Last) error {
+		_, err := sdb.DB().Get(k0)
+		assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
+		return nil
+	})
+	require.NoError(t, err)
+
 	// make checkpoints with the current state
-	bn, err := sdb.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	bn, err := sdb.getCurrentBatch()
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(0), bn)
 	err = sdb.db.MakeCheckpoint()
-	assert.NoError(t, err)
-	bn, err = sdb.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	require.NoError(t, err)
+	bn, err = sdb.getCurrentBatch()
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(1), bn)
 
+	// k0 in last
+	err = sdb.LastRead(func(sdb *Last) error {
+		v, err := sdb.DB().Get(k0)
+		require.NoError(t, err)
+		assert.Equal(t, v0, v)
+		return nil
+	})
+	require.NoError(t, err)
+
 	// write more data
 	tx, err = sdb.db.DB().NewTx()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = tx.Put(k1, v1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
+	err = tx.Put(k0, v1) // overwrite k0 with v1
+	require.NoError(t, err)
 	err = tx.Commit()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	v, err = sdb.db.DB().Get(k1)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, v1, v)
 
-	// Close PebbleDB before creating a new StateDB
-	err = sdb.db.DB().Pebble().Close()
+	err = sdb.LastRead(func(sdb *Last) error {
+		v, err := sdb.DB().Get(k0)
+		require.NoError(t, err)
+		assert.Equal(t, v0, v)
+		return nil
+	})
 	require.NoError(t, err)
 
+	// Close PebbleDB before creating a new StateDB
+	sdb.Close()
+
 	// call NewStateDB which should get the db at the last checkpoint state
 	// executing a Reset (discarding the last 'testkey1'&'testvalue1' data)
 	sdb, err = NewStateDB(dir, 128, TypeTxSelector, 0)
 	require.NoError(t, err)
 
-	bn, err = sdb.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	bn, err = sdb.getCurrentBatch()
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(1), bn)
 
+	// we closed the db without doing a checkpoint after overwriting k0, so
+	// it's back to v0
 	v, err = sdb.db.DB().Get(k0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, v0, v)
 
 	v, err = sdb.db.DB().Get(k1)
@@ -137,10 +180,10 @@ func TestNewStateDBIntermediateState(t *testing.T) {
 func TestStateDBWithoutMT(t *testing.T) {
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir))
+	defer require.NoError(t, os.RemoveAll(dir))
 
 	sdb, err := NewStateDB(dir, 128, TypeTxSelector, 0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// create test accounts
 	var accounts []*common.Account
@@ -157,20 +200,20 @@ func TestStateDBWithoutMT(t *testing.T) {
 	// add test accounts
 	for i := 0; i < len(accounts); i++ {
 		_, err = sdb.CreateAccount(accounts[i].Idx, accounts[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	for i := 0; i < len(accounts); i++ {
 		existingAccount := accounts[i].Idx
 		accGetted, err := sdb.GetAccount(existingAccount)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, accounts[i], accGetted)
 	}
 
 	// try already existing idx and get error
 	existingAccount := common.Idx(256)
 	_, err = sdb.GetAccount(existingAccount) // check that exist
-	assert.NoError(t, err)
+	require.NoError(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, tracerr.Unwrap(err))
@@ -180,7 +223,7 @@ func TestStateDBWithoutMT(t *testing.T) {
 		accounts[i].Nonce = accounts[i].Nonce + 1
 		existingAccount = common.Idx(i)
 		_, err = sdb.UpdateAccount(existingAccount, accounts[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	_, err = sdb.MTGetProof(common.Idx(1))
@@ -191,10 +234,10 @@ func TestStateDBWithoutMT(t *testing.T) {
 func TestStateDBWithMT(t *testing.T) {
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir))
+	defer require.NoError(t, os.RemoveAll(dir))
 
 	sdb, err := NewStateDB(dir, 128, TypeSynchronizer, 32)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// create test accounts
 	var accounts []*common.Account
@@ -210,33 +253,33 @@ func TestStateDBWithMT(t *testing.T) {
 	// add test accounts
 	for i := 0; i < len(accounts); i++ {
 		_, err = sdb.CreateAccount(accounts[i].Idx, accounts[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 
 	for i := 0; i < len(accounts); i++ {
 		accGetted, err := sdb.GetAccount(accounts[i].Idx)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.Equal(t, accounts[i], accGetted)
 	}
 
 	// try already existing idx and get error
 	_, err = sdb.GetAccount(common.Idx(256)) // check that exist
-	assert.NoError(t, err)
+	require.NoError(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, tracerr.Unwrap(err))
 
 	_, err = sdb.MTGetProof(common.Idx(256))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// update accounts
 	for i := 0; i < len(accounts); i++ {
 		accounts[i].Nonce = accounts[i].Nonce + 1
 		_, err = sdb.UpdateAccount(accounts[i].Idx, accounts[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
 	a, err := sdb.GetAccount(common.Idx(256)) // check that account value has been updated
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, accounts[0].Nonce, a.Nonce)
 }
 
@@ -245,10 +288,13 @@ func TestStateDBWithMT(t *testing.T) {
 func TestCheckpoints(t *testing.T) {
 	dir, err := ioutil.TempDir("", "sdb")
 	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir))
+	defer require.NoError(t, os.RemoveAll(dir))
 
 	sdb, err := NewStateDB(dir, 128, TypeSynchronizer, 32)
-	assert.NoError(t, err)
+	require.NoError(t, err)
+
+	err = sdb.Reset(0)
+	require.NoError(t, err)
 
 	// create test accounts
 	var accounts []*common.Account
@@ -259,22 +305,33 @@ func TestCheckpoints(t *testing.T) {
 	// add test accounts
 	for i := 0; i < len(accounts); i++ {
 		_, err = sdb.CreateAccount(accounts[i].Idx, accounts[i])
-		assert.NoError(t, err)
+		require.NoError(t, err)
 	}
+	// account doesn't exist in Last checkpoint
+	_, err = sdb.LastGetAccount(accounts[0].Idx)
+	assert.Equal(t, db.ErrNotFound, tracerr.Unwrap(err))
 
 	// do checkpoints and check that currentBatch is correct
-	err = sdb.db.MakeCheckpoint()
-	assert.NoError(t, err)
-	cb, err := sdb.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	err = sdb.MakeCheckpoint()
+	require.NoError(t, err)
+	cb, err := sdb.getCurrentBatch()
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(1), cb)
 
-	for i := 1; i < 10; i++ {
-		err = sdb.db.MakeCheckpoint()
-		assert.NoError(t, err)
+	// account exists in Last checkpoint
+	accCur, err := sdb.GetAccount(accounts[0].Idx)
+	require.NoError(t, err)
+	accLast, err := sdb.LastGetAccount(accounts[0].Idx)
+	require.NoError(t, err)
+	assert.Equal(t, accounts[0], accLast)
+	assert.Equal(t, accCur, accLast)
 
-		cb, err = sdb.db.GetCurrentBatch()
-		assert.NoError(t, err)
+	for i := 1; i < 10; i++ {
+		err = sdb.MakeCheckpoint()
+		require.NoError(t, err)
+
+		cb, err = sdb.getCurrentBatch()
+		require.NoError(t, err)
 		assert.Equal(t, common.BatchNum(i+1), cb)
 	}
 
@@ -282,7 +339,7 @@ func TestCheckpoints(t *testing.T) {
 
 	// reset checkpoint
 	err = sdb.Reset(3)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// check that reset can be repeated (as there exist the 'current' and
 	// 'BatchNum3', from where the 'current' is a copy)
@@ -290,21 +347,21 @@ func TestCheckpoints(t *testing.T) {
 	require.NoError(t, err)
 
 	// check that currentBatch is as expected after Reset
-	cb, err = sdb.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	cb, err = sdb.getCurrentBatch()
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(3), cb)
 
 	// advance one checkpoint and check that currentBatch is fine
-	err = sdb.db.MakeCheckpoint()
-	assert.NoError(t, err)
-	cb, err = sdb.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	err = sdb.MakeCheckpoint()
+	require.NoError(t, err)
+	cb, err = sdb.getCurrentBatch()
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(4), cb)
 
 	err = sdb.db.DeleteCheckpoint(common.BatchNum(1))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = sdb.db.DeleteCheckpoint(common.BatchNum(2))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = sdb.db.DeleteCheckpoint(common.BatchNum(1)) // does not exist, should return err
 	assert.NotNil(t, err)
 	err = sdb.db.DeleteCheckpoint(common.BatchNum(2)) // does not exist, should return err
@@ -313,43 +370,43 @@ func TestCheckpoints(t *testing.T) {
 	// Create a LocalStateDB from the initial StateDB
 	dirLocal, err := ioutil.TempDir("", "ldb")
 	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dirLocal))
+	defer require.NoError(t, os.RemoveAll(dirLocal))
 	ldb, err := NewLocalStateDB(dirLocal, 128, sdb, TypeBatchBuilder, 32)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
 	err = ldb.Reset(4, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// check that currentBatch is 4 after the Reset
-	cb, err = ldb.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	cb, err = ldb.getCurrentBatch()
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(4), cb)
 	// advance one checkpoint in ldb
-	err = ldb.db.MakeCheckpoint()
-	assert.NoError(t, err)
-	cb, err = ldb.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	err = ldb.MakeCheckpoint()
+	require.NoError(t, err)
+	cb, err = ldb.getCurrentBatch()
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(5), cb)
 
 	// Create a 2nd LocalStateDB from the initial StateDB
 	dirLocal2, err := ioutil.TempDir("", "ldb2")
 	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dirLocal2))
+	defer require.NoError(t, os.RemoveAll(dirLocal2))
 	ldb2, err := NewLocalStateDB(dirLocal2, 128, sdb, TypeBatchBuilder, 32)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// get checkpoint 4 from sdb (StateDB) to ldb (LocalStateDB)
 	err = ldb2.Reset(4, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	// check that currentBatch is 4 after the Reset
 	cb, err = ldb2.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(4), cb)
 	// advance one checkpoint in ldb2
 	err = ldb2.db.MakeCheckpoint()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cb, err = ldb2.db.GetCurrentBatch()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, common.BatchNum(5), cb)
 
 	debug := false
@@ -365,7 +422,7 @@ func TestStateDBGetAccounts(t *testing.T) {
 	require.NoError(t, err)
 
 	sdb, err := NewStateDB(dir, 128, TypeTxSelector, 0)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// create test accounts
 	var accounts []common.Account
@@ -380,14 +437,14 @@ func TestStateDBGetAccounts(t *testing.T) {
 		require.NoError(t, err)
 	}
 
-	dbAccounts, err := sdb.GetAccounts()
+	dbAccounts, err := sdb.TestGetAccounts()
 	require.NoError(t, err)
 	assert.Equal(t, accounts, dbAccounts)
 }
 
 func printCheckpoints(t *testing.T, path string) {
 	files, err := ioutil.ReadDir(path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	fmt.Println(path)
 	for _, f := range files {
@@ -409,7 +466,7 @@ func bigFromStr(h string, u int) *big.Int {
 func TestCheckAccountsTreeTestVectors(t *testing.T) {
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir))
+	defer require.NoError(t, os.RemoveAll(dir))
 
 	sdb, err := NewStateDB(dir, 128, TypeSynchronizer, 32)
 	require.NoError(t, err)
@@ -483,7 +540,7 @@ func TestCheckAccountsTreeTestVectors(t *testing.T) {
 func TestListCheckpoints(t *testing.T) {
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir))
+	defer require.NoError(t, os.RemoveAll(dir))
 
 	sdb, err := NewStateDB(dir, 128, TypeSynchronizer, 32)
 	require.NoError(t, err)
@@ -491,7 +548,7 @@ func TestListCheckpoints(t *testing.T) {
 	numCheckpoints := 16
 	// do checkpoints
 	for i := 0; i < numCheckpoints; i++ {
-		err = sdb.db.MakeCheckpoint()
+		err = sdb.MakeCheckpoint()
 		require.NoError(t, err)
 	}
 	list, err := sdb.db.ListCheckpoints()
@@ -515,7 +572,7 @@ func TestListCheckpoints(t *testing.T) {
 func TestDeleteOldCheckpoints(t *testing.T) {
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)
-	defer assert.NoError(t, os.RemoveAll(dir))
+	defer require.NoError(t, os.RemoveAll(dir))
 
 	keep := 16
 	sdb, err := NewStateDB(dir, keep, TypeSynchronizer, 32)
@@ -525,7 +582,7 @@ func TestDeleteOldCheckpoints(t *testing.T) {
 	// do checkpoints and check that we never have more than `keep`
 	// checkpoints
 	for i := 0; i < numCheckpoints; i++ {
-		err = sdb.db.MakeCheckpoint()
+		err = sdb.MakeCheckpoint()
 		require.NoError(t, err)
 		checkpoints, err := sdb.db.ListCheckpoints()
 		require.NoError(t, err)