diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index c1b52315af7..4c935a052ad 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -20,7 +20,7 @@ jobs:
       - name: Setup Go
         uses: actions/setup-go@v1
         with:
-          go-version: '1.14.13' 
+          go-version: '1.15.13'
       
       - if: matrix.os == 'windows-latest'
         name: Install make in windows
diff --git a/.run/Template Go Test.run.xml b/.run/Template Go Test.run.xml
index 5688851050a..56d84c3ebf1 100644
--- a/.run/Template Go Test.run.xml	
+++ b/.run/Template Go Test.run.xml	
@@ -12,4 +12,4 @@
       <option name="RunConfigurationTask" enabled="true" run_configuration_name="go-env-test" run_configuration_type="MAKEFILE_TARGET_RUN_CONFIGURATION" />
     </method>
   </configuration>
-</component>
\ No newline at end of file
+</component>
diff --git a/activation/activation.go b/activation/activation.go
index df36591083e..f5fa3729cdc 100644
--- a/activation/activation.go
+++ b/activation/activation.go
@@ -231,14 +231,14 @@ func (b *Builder) StartSmeshing(ctx context.Context, coinbase types.Address, opt
 	doneChan, err := b.postSetupProvider.StartSession(opts)
 	if err != nil {
 		b.status = smeshingStatusIdle
-		return fmt.Errorf("failed to start Post setup session: %v", err)
+		return fmt.Errorf("failed to start post setup session: %w", err)
 	}
 
 	go func() {
 		<-doneChan
 		if s := b.postSetupProvider.Status(); s.State != postSetupStateComplete {
 			b.status = smeshingStatusIdle
-			b.log.Error("failed to complete Post setup: %v", b.postSetupProvider.LastError())
+			b.log.With().Error("failed to complete post setup", log.Err(b.postSetupProvider.LastError()))
 			return
 		}
 
@@ -300,7 +300,7 @@ func (b *Builder) loop(ctx context.Context) {
 	// TODO(moshababo): don't generate the commitment every time smeshing is starting, but once only.
 	b.initialPost, _, err = b.postSetupProvider.GenerateProof(shared.ZeroChallenge)
 	if err != nil {
-		b.log.Error("Post execution failed: %v", err)
+		b.log.Error("post execution failed: %v", err)
 		b.status = smeshingStatusIdle
 		return
 	}
@@ -542,7 +542,7 @@ func (b *Builder) createAtx(ctx context.Context) (*types.ActivationTx, error) {
 		log.FieldNamed("current_layer", b.layerClock.GetCurrentLayer()),
 	)
 	if err := b.waitOrStop(ctx, b.layerClock.AwaitLayer(pubEpoch.FirstLayer())); err != nil {
-		return nil, fmt.Errorf("failed to wait of publication epoch: %w", err)
+		return nil, fmt.Errorf("failed to wait for publication epoch: %w", err)
 	}
 	b.log.Info("publication epoch has arrived!")
 	if discarded := b.discardChallengeIfStale(); discarded {
diff --git a/activation/activationdb_test.go b/activation/activationdb_test.go
index 6623ecbb522..0a3efe78172 100644
--- a/activation/activationdb_test.go
+++ b/activation/activationdb_test.go
@@ -14,7 +14,6 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
 	"github.com/spacemeshos/ed25519"
@@ -52,7 +51,7 @@ func createLayerWithAtx2(t require.TestingT, msh *mesh.Mesh, id types.LayerID, n
 
 type MeshValidatorMock struct{}
 
-func (m *MeshValidatorMock) Persist() error {
+func (m *MeshValidatorMock) Persist(context.Context) error {
 	return nil
 }
 
@@ -60,12 +59,12 @@ func (m *MeshValidatorMock) LatestComplete() types.LayerID {
 	panic("implement me")
 }
 
-func (m *MeshValidatorMock) HandleIncomingLayer(layer *types.Layer) (types.LayerID, types.LayerID) {
-	return layer.Index().Sub(1), layer.Index()
+func (m *MeshValidatorMock) HandleIncomingLayer(_ context.Context, layerID types.LayerID) (types.LayerID, types.LayerID, bool) {
+	return layerID.Sub(1), layerID, false
 }
 
-func (m *MeshValidatorMock) HandleLateBlock(bl *types.Block) (types.LayerID, types.LayerID) {
-	return bl.Layer().Sub(1), bl.Layer()
+func (m *MeshValidatorMock) HandleLateBlocks(_ context.Context, blocks []*types.Block) (types.LayerID, types.LayerID) {
+	return blocks[0].Layer().Sub(1), blocks[0].Layer()
 }
 
 type MockState struct{}
@@ -74,7 +73,7 @@ func (MockState) GetAllAccounts() (*types.MultipleAccountsState, error) {
 	panic("implement me")
 }
 
-func (MockState) ValidateAndAddTxToPool(tx *types.Transaction) error {
+func (MockState) ValidateAndAddTxToPool(*types.Transaction) error {
 	panic("implement me")
 }
 
@@ -105,33 +104,17 @@ func (MockState) AddressExists(types.Address) bool {
 	return true
 }
 
-func (MockState) GetLayerStateRoot(layer types.LayerID) (types.Hash32, error) {
+func (MockState) GetLayerStateRoot(types.LayerID) (types.Hash32, error) {
 	panic("implement me")
 }
 
-func (MockState) GetBalance(addr types.Address) uint64 {
+func (MockState) GetBalance(types.Address) uint64 {
 	panic("implement me")
 }
-
-func (MockState) GetNonce(addr types.Address) uint64 {
+func (MockState) GetNonce(types.Address) uint64 {
 	panic("implement me")
 }
 
-type ATXDBMock struct {
-	mock.Mock
-	counter     int
-	workSymLock sync.Mutex
-	activeSet   uint32
-}
-
-func (mock *ATXDBMock) CalcMinerWeights(types.EpochID, map[types.BlockID]struct{}) (map[string]uint64, error) {
-	mock.workSymLock.Lock()
-	defer mock.workSymLock.Unlock()
-
-	mock.counter++
-	return map[string]uint64{"aaaaac": 1, "aaabddb": 2, "aaaccc": 3}, nil
-}
-
 type MockTxMemPool struct{}
 
 func (MockTxMemPool) Get(types.TransactionID) (*types.Transaction, error) {
@@ -141,15 +124,6 @@ func (MockTxMemPool) Get(types.TransactionID) (*types.Transaction, error) {
 func (MockTxMemPool) Put(types.TransactionID, *types.Transaction) {}
 func (MockTxMemPool) Invalidate(types.TransactionID)              {}
 
-type MockAtxMemPool struct{}
-
-func (MockAtxMemPool) Get(types.ATXID) (*types.ActivationTx, error) {
-	return &types.ActivationTx{}, nil
-}
-
-func (MockAtxMemPool) Put(*types.ActivationTx) {}
-func (MockAtxMemPool) Invalidate(types.ATXID)  {}
-
 func ConfigTst() mesh.Config {
 	return mesh.Config{
 		BaseReward: big.NewInt(5000),
@@ -173,14 +147,24 @@ func rndStr() string {
 	return string(a)
 }
 
-func createLayerWithAtx(t *testing.T, msh *mesh.Mesh, id types.LayerID, numOfBlocks int, atxs []*types.ActivationTx, votes []types.BlockID, views []types.BlockID) (created []types.BlockID) {
+func processAtxs(db *DB, atxs []*types.ActivationTx) error {
+	for _, atx := range atxs {
+		err := db.ProcessAtx(atx)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func createLayerWithAtx(t *testing.T, msh *mesh.Mesh, atxdb *DB, id types.LayerID, numOfBlocks int, atxs []*types.ActivationTx, votes []types.BlockID, views []types.BlockID) (created []types.BlockID) {
 	if numOfBlocks < len(atxs) {
 		panic("not supported")
 	}
 	for i := 0; i < numOfBlocks; i++ {
 		block1 := types.NewExistingBlock(id, []byte(rand.String(8)), nil)
 		block1.ForDiff = append(block1.ForDiff, votes...)
-		activeSet := []types.ATXID{}
+		var activeSet []types.ATXID
 		if i < len(atxs) {
 			activeSet = append(activeSet, atxs[i].ID())
 		}
@@ -198,7 +182,7 @@ func createLayerWithAtx(t *testing.T, msh *mesh.Mesh, id types.LayerID, numOfBlo
 		if i < len(atxs) {
 			actualAtxs = atxs[i : i+1]
 		}
-		msh.ProcessAtxs(actualAtxs)
+		require.NoError(t, processAtxs(atxdb, actualAtxs))
 		block1.Initialize()
 		err := msh.AddBlockWithTxs(context.TODO(), block1)
 		require.NoError(t, err)
@@ -233,14 +217,14 @@ func TestATX_ActiveSetForLayerView(t *testing.T) {
 		assert.NoError(t, err)
 		atx.NIPost = NewNIPostWithChallenge(hash, poetRef)
 	}
-	blocks := createLayerWithAtx(t, layers, types.NewLayerID(1), 6, atxs, []types.BlockID{}, []types.BlockID{})
+	blocks := createLayerWithAtx(t, layers, atxdb, types.NewLayerID(1), 6, atxs, []types.BlockID{}, []types.BlockID{})
 	before := blocks[:2]
 	two := blocks[2:3]
 	after := blocks[3:]
 	for i := uint32(2); i <= 10; i++ {
-		before = createLayerWithAtx(t, layers, types.NewLayerID(i), 1, []*types.ActivationTx{}, before, before)
-		two = createLayerWithAtx(t, layers, types.NewLayerID(i), 1, []*types.ActivationTx{}, two, two)
-		after = createLayerWithAtx(t, layers, types.NewLayerID(i), 1, []*types.ActivationTx{}, after, after)
+		before = createLayerWithAtx(t, layers, atxdb, types.NewLayerID(i), 1, []*types.ActivationTx{}, before, before)
+		two = createLayerWithAtx(t, layers, atxdb, types.NewLayerID(i), 1, []*types.ActivationTx{}, two, two)
+		after = createLayerWithAtx(t, layers, atxdb, types.NewLayerID(i), 1, []*types.ActivationTx{}, after, after)
 	}
 	for _, x := range before {
 		blocksMap[x] = struct{}{}
@@ -380,7 +364,7 @@ func TestMesh_processBlockATXs(t *testing.T) {
 		atx.NIPost = NewNIPostWithChallenge(hash, poetRef)
 	}
 
-	err = atxdb.ProcessAtxs(atxs)
+	err = processAtxs(atxdb, atxs)
 	assert.NoError(t, err)
 
 	// check that further atxs dont affect current epoch count
@@ -394,7 +378,7 @@ func TestMesh_processBlockATXs(t *testing.T) {
 		assert.NoError(t, err)
 		atx.NIPost = NewNIPostWithChallenge(hash, poetRef)
 	}
-	err = atxdb.ProcessAtxs(atxs2)
+	err = processAtxs(atxdb, atxs2)
 	assert.NoError(t, err)
 
 	assertEpochWeight(t, atxdb, 2, 100*100*4) // 1 posATX + 3 from `atxs`
@@ -432,9 +416,9 @@ func TestActivationDB_ValidateAtx(t *testing.T) {
 		atx.NIPost = NewNIPostWithChallenge(hash, poetRef)
 	}
 
-	blocks := createLayerWithAtx(t, layers, types.NewLayerID(1), 10, atxs, []types.BlockID{}, []types.BlockID{})
-	blocks = createLayerWithAtx(t, layers, types.NewLayerID(10), 10, []*types.ActivationTx{}, blocks, blocks)
-	blocks = createLayerWithAtx(t, layers, types.NewLayerID(100), 10, []*types.ActivationTx{}, blocks, blocks)
+	blocks := createLayerWithAtx(t, layers, atxdb, types.NewLayerID(1), 10, atxs, []types.BlockID{}, []types.BlockID{})
+	blocks = createLayerWithAtx(t, layers, atxdb, types.NewLayerID(10), 10, []*types.ActivationTx{}, blocks, blocks)
+	blocks = createLayerWithAtx(t, layers, atxdb, types.NewLayerID(100), 10, []*types.ActivationTx{}, blocks, blocks)
 
 	prevAtx := newActivationTx(idx1, 0, *types.EmptyATXID, *types.EmptyATXID, types.NewLayerID(100), 0, 100, coinbase1, 100, &types.NIPost{})
 	hash, err := prevAtx.NIPostChallenge.Hash()
@@ -477,9 +461,9 @@ func TestActivationDB_ValidateAtxErrors(t *testing.T) {
 		newActivationTx(id3, 0, *types.EmptyATXID, *types.EmptyATXID, types.NewLayerID(1), 0, 100, coinbase, 100, &types.NIPost{}),
 	}
 
-	blocks := createLayerWithAtx(t, layers, types.NewLayerID(1), 10, atxs, []types.BlockID{}, []types.BlockID{})
-	blocks = createLayerWithAtx(t, layers, types.NewLayerID(10), 10, []*types.ActivationTx{}, blocks, blocks)
-	blocks = createLayerWithAtx(t, layers, types.NewLayerID(100), 10, []*types.ActivationTx{}, blocks, blocks)
+	blocks := createLayerWithAtx(t, layers, atxdb, types.NewLayerID(1), 10, atxs, []types.BlockID{}, []types.BlockID{})
+	blocks = createLayerWithAtx(t, layers, atxdb, types.NewLayerID(10), 10, []*types.ActivationTx{}, blocks, blocks)
+	blocks = createLayerWithAtx(t, layers, atxdb, types.NewLayerID(100), 10, []*types.ActivationTx{}, blocks, blocks)
 
 	chlng := types.HexToHash32("0x3333")
 	poetRef := []byte{0xba, 0xbe}
@@ -653,9 +637,9 @@ func TestActivationDB_ValidateAndInsertSorted(t *testing.T) {
 		newActivationTx(id3, 0, *types.EmptyATXID, *types.EmptyATXID, types.NewLayerID(1), 0, 100, coinbase, 100, &types.NIPost{}),
 	}
 
-	blocks := createLayerWithAtx(t, layers, types.NewLayerID(1), 10, atxs, []types.BlockID{}, []types.BlockID{})
-	blocks = createLayerWithAtx(t, layers, types.NewLayerID(10), 10, []*types.ActivationTx{}, blocks, blocks)
-	blocks = createLayerWithAtx(t, layers, types.NewLayerID(100), 10, []*types.ActivationTx{}, blocks, blocks)
+	blocks := createLayerWithAtx(t, layers, atxdb, types.NewLayerID(1), 10, atxs, []types.BlockID{}, []types.BlockID{})
+	blocks = createLayerWithAtx(t, layers, atxdb, types.NewLayerID(10), 10, []*types.ActivationTx{}, blocks, blocks)
+	blocks = createLayerWithAtx(t, layers, atxdb, types.NewLayerID(100), 10, []*types.ActivationTx{}, blocks, blocks)
 
 	chlng := types.HexToHash32("0x3333")
 	poetRef := []byte{0x56, 0xbe}
@@ -834,7 +818,7 @@ func BenchmarkNewActivationDb(b *testing.B) {
 	pPrevAtxs := make([]types.ATXID, numOfMiners)
 	posAtx := prevAtxID
 	var atx *types.ActivationTx
-	layer := types.LayerID(postGenesisEpochLayer)
+	layer := postGenesisEpochLayer
 
 	start := time.Now()
 	eStart := time.Now()
diff --git a/activation/atxdb.go b/activation/atxdb.go
index fba957f3915..feb5f52887f 100644
--- a/activation/atxdb.go
+++ b/activation/atxdb.go
@@ -136,26 +136,6 @@ func (db *DB) UnsubscribeAtx(id types.ATXID) {
 	}
 }
 
-// ProcessAtxs processes the list of given atxs using ProcessAtx method
-func (db *DB) ProcessAtxs(atxs []*types.ActivationTx) error {
-	// seenMinerIds := map[string]struct{}{}
-	for _, atx := range atxs {
-		/* minerID := atx.NodeID.Key
-		if _, found := seenMinerIds[minerID]; found {
-			// TODO: Blacklist this miner
-			// TODO: Ensure that these are two different, syntactically valid ATXs for the same epoch, otherwise the
-			//  miner did nothing wrong
-			db.log.With().Error("found miner with multiple ATXs published in same block",
-				log.FieldNamed("atx_node_id", atx.NodeID), atx.ID())
-		}*/
-		err := db.ProcessAtx(atx)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 // ProcessAtx validates the active set size declared in the atx, and contextually validates the atx according to atx
 // validation rules it then stores the atx with flag set to validity of the atx.
 //
@@ -362,11 +342,11 @@ func (db *DB) SyntacticallyValidateAtx(atx *types.ActivationTx) error {
 		return fmt.Errorf("failed to compute NIPost's expected challenge hash: %v", err)
 	}
 
-	db.log.With().Info("Validating NIPost", log.String("expected_challenge_hash", expectedChallengeHash.String()), atx.ID())
+	db.log.With().Info("validating nipost", log.String("expected_challenge_hash", expectedChallengeHash.String()), atx.ID())
 
 	pubKey := signing.NewPublicKey(util.Hex2Bytes(atx.NodeID.Key))
 	if err = db.nipostValidator.Validate(*pubKey, atx.NIPost, *expectedChallengeHash, atx.NumUnits); err != nil {
-		return fmt.Errorf("invalid NIPost: %v", err)
+		return fmt.Errorf("invalid nipost: %v", err)
 	}
 
 	return nil
@@ -746,7 +726,7 @@ func (db *DB) HandleAtxData(ctx context.Context, data []byte, fetcher service.Fe
 	}
 
 	if err := db.FetchAtxReferences(ctx, atx, fetcher); err != nil {
-		return fmt.Errorf("received ATX with missing references of prev or pos id %v, %v, %v, %v",
+		return fmt.Errorf("received atx with missing references of prev or pos id %v, %v, %v, %v",
 			atx.ID().ShortString(), atx.PrevATXID.ShortString(), atx.PositioningATX.ShortString(), log.Err(err))
 	}
 
@@ -770,19 +750,19 @@ func (db *DB) HandleAtxData(ctx context.Context, data []byte, fetcher service.Fe
 func (db *DB) FetchAtxReferences(ctx context.Context, atx *types.ActivationTx, f service.Fetcher) error {
 	logger := db.log.WithContext(ctx)
 	if atx.PositioningATX != *types.EmptyATXID && atx.PositioningATX != db.goldenATXID {
-		logger.With().Info("going to fetch pos atx", atx.PositioningATX, atx.ID())
+		logger.With().Debug("going to fetch pos atx", atx.PositioningATX, atx.ID())
 		if err := f.FetchAtx(ctx, atx.PositioningATX); err != nil {
 			return err
 		}
 	}
 
 	if atx.PrevATXID != *types.EmptyATXID {
-		logger.With().Info("going to fetch prev atx", atx.PrevATXID, atx.ID())
+		logger.With().Debug("going to fetch prev atx", atx.PrevATXID, atx.ID())
 		if err := f.FetchAtx(ctx, atx.PrevATXID); err != nil {
 			return err
 		}
 	}
-	logger.With().Info("done fetching references for atx", atx.ID())
+	logger.With().Debug("done fetching references for atx", atx.ID())
 
 	return nil
 }
diff --git a/activation/nipost.go b/activation/nipost.go
index f22c1b32fb4..1ca2119e3e9 100644
--- a/activation/nipost.go
+++ b/activation/nipost.go
@@ -43,16 +43,13 @@ func nipostBuildStateKey() []byte {
 }
 
 func (nb *NIPostBuilder) load(challenge types.Hash32) {
-	bts, err := nb.store.Get(nipostBuildStateKey())
-	if err != nil {
-		nb.log.Warning("cannot load NIPost state %v", err)
+	if bts, err := nb.store.Get(nipostBuildStateKey()); err != nil {
+		nb.log.With().Warning("cannot load nipost state", log.Err(err))
 		return
-	}
-	if len(bts) > 0 {
+	} else if len(bts) > 0 {
 		var state builderState
-		err = types.BytesToInterface(bts, &state)
-		if err != nil {
-			nb.log.Error("cannot load NIPost state %v", err)
+		if err := types.BytesToInterface(bts, &state); err != nil {
+			nb.log.With().Error("cannot load nipost state", log.Err(err))
 		}
 		if state.Challenge == challenge {
 			nb.state = &state
@@ -63,14 +60,11 @@ func (nb *NIPostBuilder) load(challenge types.Hash32) {
 }
 
 func (nb *NIPostBuilder) persist() {
-	bts, err := types.InterfaceToBytes(&nb.state)
-	if err != nil {
-		nb.log.Warning("cannot store NIPost state %v", err)
+	if bts, err := types.InterfaceToBytes(&nb.state); err != nil {
+		nb.log.With().Warning("cannot store nipost state", log.Err(err))
 		return
-	}
-	err = nb.store.Put(nipostBuildStateKey(), bts)
-	if err != nil {
-		nb.log.Warning("cannot store NIPost state %v", err)
+	} else if err := nb.store.Put(nipostBuildStateKey(), bts); err != nil {
+		nb.log.With().Warning("cannot store nipost state", log.Err(err))
 	}
 }
 
@@ -143,7 +137,7 @@ func (nb *NIPostBuilder) BuildNIPost(ctx context.Context, challenge *types.Hash3
 		poetChallenge := challenge
 		nb.state.Challenge = *challenge
 
-		nb.log.Debug("submitting challenge to PoET proving service (PoET id: %x, challenge: %x)",
+		nb.log.Debug("submitting challenge to poet proving service (poet id: %x, challenge: %x)",
 			nb.state.PoetServiceID, poetChallenge)
 
 		round, err := nb.poetProver.Submit(ctx, *poetChallenge)
@@ -151,7 +145,7 @@ func (nb *NIPostBuilder) BuildNIPost(ctx context.Context, challenge *types.Hash3
 			return nil, fmt.Errorf("%w: failed to submit challenge to poet service: %v", ErrPoetServiceUnstable, err)
 		}
 
-		nb.log.Info("challenge submitted to PoET proving service (PoET id: %x, round id: %v, challenge: %x)",
+		nb.log.Info("challenge submitted to poet proving service (poet id: %x, round id: %v, challenge: %x)",
 			nb.state.PoetServiceID, round.ID, poetChallenge)
 
 		nipost.Challenge = poetChallenge
@@ -173,7 +167,7 @@ func (nb *NIPostBuilder) BuildNIPost(ctx context.Context, challenge *types.Hash3
 
 		membership, err := nb.poetDB.GetMembershipMap(poetProofRef)
 		if err != nil {
-			nb.log.With().Panic("failed to fetch membership for PoET proof",
+			nb.log.With().Panic("failed to fetch membership for poet proof",
 				log.String("challenge", fmt.Sprintf("%x", nb.state.PoetProofRef))) // TODO: handle inconsistent state
 		}
 		if !membership[*nipost.Challenge] {
@@ -188,7 +182,7 @@ func (nb *NIPostBuilder) BuildNIPost(ctx context.Context, challenge *types.Hash3
 
 	// Phase 2: Post execution.
 	if nipost.Post == nil {
-		nb.log.With().Info("starting Post execution",
+		nb.log.With().Info("starting post execution",
 			log.String("challenge", fmt.Sprintf("%x", nb.state.PoetProofRef)))
 		startTime := time.Now()
 		proof, proofMetadata, err := nb.postSetupProvider.GenerateProof(nb.state.PoetProofRef)
@@ -196,7 +190,7 @@ func (nb *NIPostBuilder) BuildNIPost(ctx context.Context, challenge *types.Hash3
 			return nil, fmt.Errorf("failed to execute Post: %v", err)
 		}
 
-		nb.log.With().Info("finished Post execution",
+		nb.log.With().Info("finished post execution",
 			log.Duration("duration", time.Now().Sub(startTime)))
 
 		nipost.Post = proof
@@ -205,7 +199,7 @@ func (nb *NIPostBuilder) BuildNIPost(ctx context.Context, challenge *types.Hash3
 		nb.persist()
 	}
 
-	nb.log.Info("finished NIPost construction")
+	nb.log.Info("finished nipost construction")
 
 	nb.state = &builderState{
 		NIPost: &types.NIPost{},
diff --git a/activation/poetdb.go b/activation/poetdb.go
index 810e746ec37..a58f477fca0 100644
--- a/activation/poetdb.go
+++ b/activation/poetdb.go
@@ -78,7 +78,7 @@ func (db *PoetDb) Validate(proof types.PoetProof, poetID []byte, roundID string,
 func (db *PoetDb) storeProof(proofMessage *types.PoetProofMessage) error {
 	ref, err := proofMessage.Ref()
 	if err != nil {
-		return fmt.Errorf("failed to get PoET proof message reference: %v", err)
+		return fmt.Errorf("failed to get poet proof message reference: %v", err)
 	}
 
 	messageBytes, err := types.InterfaceToBytes(proofMessage)
@@ -100,7 +100,7 @@ func (db *PoetDb) storeProof(proofMessage *types.PoetProofMessage) error {
 		return fmt.Errorf("failed to store poet proof and index for poetId %x round %s: %v",
 			proofMessage.PoetServiceID[:5], proofMessage.RoundID, err)
 	}
-	db.log.With().Info("stored PoET proof",
+	db.log.With().Info("stored poet proof",
 		log.String("poet_proof_id", fmt.Sprintf("%x", ref[:5])),
 		log.String("round_id", proofMessage.RoundID),
 		log.String("poet_service_id", fmt.Sprintf("%x", proofMessage.PoetServiceID[:5])),
diff --git a/activation/poetlistener.go b/activation/poetlistener.go
index c889e0376a5..5d2f9829ab7 100644
--- a/activation/poetlistener.go
+++ b/activation/poetlistener.go
@@ -61,16 +61,16 @@ func (l *PoetListener) handlePoetProofMessage(ctx context.Context, gossipMessage
 	// ⚠️ IMPORTANT: We must not ensure that the node is synced! PoET messages must be propagated regardless.
 	var proofMessage types.PoetProofMessage
 	if err := types.BytesToInterface(gossipMessage.Bytes(), &proofMessage); err != nil {
-		l.Log.Error("failed to unmarshal PoET membership proof: %v", err)
+		l.Log.Error("failed to unmarshal poet membership proof: %v", err)
 		return
 	}
 	if err := l.poetDb.Validate(proofMessage.PoetProof, proofMessage.PoetServiceID,
 		proofMessage.RoundID, proofMessage.Signature); err != nil {
 
 		if types.IsProcessingError(err) {
-			l.Log.Error("failed to validate PoET proof: %v", err)
+			l.Log.Error("failed to validate poet proof: %v", err)
 		} else {
-			l.Log.Warning("PoET proof not valid: %v", err)
+			l.Log.Warning("poet proof not valid: %v", err)
 		}
 		return
 	}
@@ -78,7 +78,7 @@ func (l *PoetListener) handlePoetProofMessage(ctx context.Context, gossipMessage
 	gossipMessage.ReportValidation(ctx, PoetProofProtocol)
 
 	if err := l.poetDb.storeProof(&proofMessage); err != nil {
-		l.Log.Error("failed to store PoET proof: %v", err)
+		l.Log.Error("failed to store poet proof: %v", err)
 	}
 }
 
diff --git a/activation/post.go b/activation/post.go
index 2a03ef0e07c..2cbe0b28957 100644
--- a/activation/post.go
+++ b/activation/post.go
@@ -209,7 +209,7 @@ func (mgr *PostSetupManager) StartSession(opts PostSetupOpts) (chan struct{}, er
 	mgr.initStatusMtx.Lock()
 	if mgr.state == postSetupStateInProgress {
 		mgr.initStatusMtx.Unlock()
-		return nil, fmt.Errorf("Post setup session in-progress")
+		return nil, fmt.Errorf("post setup session in progress")
 	}
 	if mgr.state == postSetupStateComplete {
 		// Check whether the new request invalidates the current status.
@@ -232,7 +232,7 @@ func (mgr *PostSetupManager) StartSession(opts PostSetupOpts) (chan struct{}, er
 			return nil, err
 		}
 
-		mgr.logger.Info("Found best compute provider: id: %d, model: %v, computeAPI: %v", p.ID, p.Model, p.ComputeAPI)
+		mgr.logger.Info("found best compute provider: id: %d, model: %v, computeAPI: %v", p.ID, p.Model, p.ComputeAPI)
 		opts.ComputeProviderID = int(p.ID)
 	}
 
@@ -256,7 +256,7 @@ func (mgr *PostSetupManager) StartSession(opts PostSetupOpts) (chan struct{}, er
 			close(mgr.doneChan)
 		}()
 
-		mgr.logger.With().Info("Post setup session starting...",
+		mgr.logger.With().Info("post setup session starting",
 			log.String("data_dir", opts.DataDir),
 			log.String("num_units", fmt.Sprintf("%d", opts.NumUnits)),
 			log.String("labels_per_unit", fmt.Sprintf("%d", mgr.cfg.LabelsPerUnit)),
@@ -266,7 +266,7 @@ func (mgr *PostSetupManager) StartSession(opts PostSetupOpts) (chan struct{}, er
 
 		if err := newInit.Initialize(); err != nil {
 			if err == initialization.ErrStopped {
-				mgr.logger.Info("Post setup session stopped")
+				mgr.logger.Info("post setup session stopped")
 				mgr.state = postSetupStateNotStarted
 			} else {
 				mgr.state = postSetupStateError
@@ -275,7 +275,7 @@ func (mgr *PostSetupManager) StartSession(opts PostSetupOpts) (chan struct{}, er
 			return
 		}
 
-		mgr.logger.With().Info("Post setup completed",
+		mgr.logger.With().Info("post setup completed",
 			log.String("datadir", opts.DataDir),
 			log.String("num_units", fmt.Sprintf("%d", opts.NumUnits)),
 			log.String("labels_per_unit", fmt.Sprintf("%d", mgr.cfg.LabelsPerUnit)),
diff --git a/api/grpcserver/globalstate_service.go b/api/grpcserver/globalstate_service.go
index adcaaf86e63..955bb9e8fb4 100644
--- a/api/grpcserver/globalstate_service.go
+++ b/api/grpcserver/globalstate_service.go
@@ -445,7 +445,7 @@ func (s GlobalStateService) GlobalStateStream(in *pb.GlobalStateStreamRequest, s
 		channelAccount chan types.Address
 		channelReward  chan events.Reward
 		channelReceipt chan events.TxReceipt
-		channelLayer   chan events.NewLayer
+		channelLayer   chan events.LayerUpdate
 	)
 	if filterAccount {
 		channelAccount = events.GetAccountChannel()
@@ -540,7 +540,7 @@ func (s GlobalStateService) GlobalStateStream(in *pb.GlobalStateStreamRequest, s
 				log.Info("layer channel closed, shutting down")
 				return nil
 			}
-			root, err := s.Mesh.GetLayerStateRoot(layer.Layer.Index())
+			root, err := s.Mesh.GetLayerStateRoot(layer.LayerID)
 			if err != nil {
 				log.Error("error retrieving layer data: %s", err)
 				return status.Errorf(codes.Internal, "error retrieving layer data")
@@ -548,7 +548,7 @@ func (s GlobalStateService) GlobalStateStream(in *pb.GlobalStateStreamRequest, s
 			if err := stream.Send(&pb.GlobalStateStreamResponse{Datum: &pb.GlobalStateData{Datum: &pb.GlobalStateData_GlobalState{
 				GlobalState: &pb.GlobalStateHash{
 					RootHash: root.Bytes(),
-					Layer:    &pb.LayerNumber{Number: layer.Layer.Index().Uint32()},
+					Layer:    &pb.LayerNumber{Number: layer.LayerID.Uint32()},
 				},
 			}}}); err != nil {
 				return err
diff --git a/api/grpcserver/grpc.go b/api/grpcserver/grpc.go
index a233c7e4835..b5d647eb4c6 100644
--- a/api/grpcserver/grpc.go
+++ b/api/grpcserver/grpc.go
@@ -66,7 +66,7 @@ func (s *Server) startInternal(started chan<- struct{}) {
 
 // Close stops the server
 func (s *Server) Close() error {
-	log.Info("Stopping new grpc server...")
+	log.Info("stopping new grpc server")
 	s.GrpcServer.Stop()
 
 	// We don't return any errors but we want to conform to io.Closer so return a nil error
diff --git a/api/grpcserver/grpcserver_test.go b/api/grpcserver/grpcserver_test.go
index 776c32abba5..76d2edeaf79 100644
--- a/api/grpcserver/grpcserver_test.go
+++ b/api/grpcserver/grpcserver_test.go
@@ -5,6 +5,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/spacemeshos/go-spacemesh/rand"
 	"io"
 	"io/ioutil"
 	"math"
@@ -106,6 +107,9 @@ var (
 )
 
 func init() {
+	// run on a random port
+	cfg.GrpcServerPort = 1024 + rand.Intn(9999)
+
 	// These create circular dependencies so they have to be initialized
 	// after the global vars
 	block1.ATXID = globalAtx.ID()
@@ -2424,9 +2428,9 @@ func TestGlobalStateStream_comprehensive(t *testing.T) {
 	// publish a new layer
 	layer, err := txAPI.GetLayer(layerFirst)
 	require.NoError(t, err)
-	events.ReportNewLayer(events.NewLayer{
-		Layer:  layer,
-		Status: events.LayerStatusTypeConfirmed,
+	events.ReportLayerUpdate(events.LayerUpdate{
+		LayerID: layer.Index(),
+		Status:  events.LayerStatusTypeConfirmed,
 	})
 
 	// close the stream
@@ -2488,9 +2492,9 @@ func TestLayerStream_comprehensive(t *testing.T) {
 
 	layer, err := txAPI.GetLayer(layerFirst)
 	require.NoError(t, err)
-	events.ReportNewLayer(events.NewLayer{
-		Layer:  layer,
-		Status: events.LayerStatusTypeConfirmed,
+	events.ReportLayerUpdate(events.LayerUpdate{
+		LayerID: layer.Index(),
+		Status:  events.LayerStatusTypeConfirmed,
 	})
 
 	// close the stream
diff --git a/api/grpcserver/mesh_service.go b/api/grpcserver/mesh_service.go
index fe4616dc741..8bc0dee3121 100644
--- a/api/grpcserver/mesh_service.go
+++ b/api/grpcserver/mesh_service.go
@@ -297,13 +297,28 @@ func convertActivation(a *types.ActivationTx) (*pb.Activation, error) {
 	}, nil
 }
 
-func (s MeshService) readLayer(ctx context.Context, layer *types.Layer, layerStatus pb.Layer_LayerStatus) (*pb.Layer, error) {
+func (s MeshService) readLayer(ctx context.Context, layerID types.LayerID, layerStatus pb.Layer_LayerStatus) (*pb.Layer, error) {
 	// Load all block data
 	var blocks []*pb.Block
 
 	// Save activations too
 	var activations []types.ATXID
 
+	// read layer blocks
+	layer, err := s.Mesh.GetLayer(layerID)
+
+	// TODO: Be careful with how we handle missing layers here.
+	// A layer that's newer than the currentLayer (defined above)
+	// is clearly an input error. A missing layer that's older than
+	// lastValidLayer is clearly an internal error. A missing layer
+	// between these two is a gray area: do we define this as an
+	// internal or an input error? For now, all missing layers produce
+	// internal errors.
+	if err != nil {
+		log.With().Error("could not read layer from database", layerID, log.Err(err))
+		return nil, status.Errorf(codes.Internal, "error reading layer data")
+	}
+
 	for _, b := range layer.Blocks() {
 		txs, missing := s.Mesh.GetTransactions(b.TxIDs)
 		// TODO: Do we ever expect txs to be missing here?
@@ -382,7 +397,7 @@ func (s MeshService) LayersQuery(ctx context.Context, in *pb.LayersQueryRequest)
 	lastLayerPassedHare := s.Mesh.LatestLayerInState()
 	lastLayerPassedTortoise := s.Mesh.ProcessedLayer()
 
-	layers := []*pb.Layer{}
+	var layers []*pb.Layer
 	for l := startLayer; !l.After(endLayer); l = l.Add(1) {
 		layerStatus := pb.Layer_LAYER_STATUS_UNSPECIFIED
 
@@ -408,7 +423,7 @@ func (s MeshService) LayersQuery(ctx context.Context, in *pb.LayersQueryRequest)
 			return nil, status.Errorf(codes.Internal, "error retrieving layer data")
 		}
 
-		pbLayer, err := s.readLayer(ctx, layer, layerStatus)
+		pbLayer, err := s.readLayer(ctx, l, layerStatus)
 		if err != nil {
 			return nil, err
 		}
@@ -522,7 +537,7 @@ func (s MeshService) LayerStream(_ *pb.LayerStreamRequest, stream pb.MeshService
 				log.Info("LayerStream closed, shutting down")
 				return nil
 			}
-			pbLayer, err := s.readLayer(stream.Context(), layer.Layer, convertLayerStatus(layer.Status))
+			pbLayer, err := s.readLayer(stream.Context(), layer.LayerID, convertLayerStatus(layer.Status))
 			if err != nil {
 				return err
 			}
diff --git a/api/grpcserver/node_service.go b/api/grpcserver/node_service.go
index 47d39103a2b..5b0be3000eb 100644
--- a/api/grpcserver/node_service.go
+++ b/api/grpcserver/node_service.go
@@ -202,6 +202,11 @@ func (s NodeService) ErrorStream(_ *pb.ErrorStreamRequest, stream pb.NodeService
 	}
 }
 
+// Close closes underlying services
+func (s NodeService) Close() {
+	s.PeerCounter.Close()
+}
+
 // Convert internal error level into level understood by the API
 func convertErrorLevel(level zapcore.Level) pb.LogLevel {
 	switch level {
diff --git a/api/grpcserver/transaction_service.go b/api/grpcserver/transaction_service.go
index 295660e2f57..7605c189f62 100644
--- a/api/grpcserver/transaction_service.go
+++ b/api/grpcserver/transaction_service.go
@@ -225,11 +225,25 @@ func (s TransactionService) TransactionsStateStream(in *pb.TransactionsStateStre
 				log.Info("layer channel closed, shutting down")
 				return nil
 			}
+
+			// Transaction objects do not have an associated status. The status we assign them here is based on the
+			// status of the layer (really, the block) they're contained in. Here, we receive updates to layer status.
+			// In order to update tx status, we have to read every transaction in the layer.
+			// TODO: this is inefficient, come up with a more optimal way of doing this
+			// TODO: tx status should depend upon block status, not layer status
+
+			// In order to read transactions, we first need to read layer blocks
+			layerObj, err := s.Mesh.GetLayer(layer.LayerID)
+			if err != nil {
+				log.With().Error("error reading layer data for updated layer", layer.LayerID, log.Err(err))
+				return status.Error(codes.Internal, "error reading layer data")
+			}
+
 			// Filter for any matching transactions in the reported layer
-			for _, b := range layer.Layer.Blocks() {
+			for _, b := range layerObj.Blocks() {
 				blockTXIDSet := make(map[types.TransactionID]struct{})
 
-				//create a set for the block transaction IDs
+				// create a set for the block transaction IDs
 				for _, txid := range b.TxIDs {
 					blockTXIDSet[txid] = struct{}{}
 				}
diff --git a/api/node.go b/api/node.go
index 061dc2a49f3..bad5e2031a1 100644
--- a/api/node.go
+++ b/api/node.go
@@ -60,12 +60,13 @@ type TxAPI interface {
 	GetBalance(types.Address) uint64
 	GetNonce(types.Address) uint64
 	GetAllAccounts() (*types.MultipleAccountsState, error)
-	//TODO: fix the discrepancy between SmesherID and NodeID (see https://github.com/spacemeshos/go-spacemesh/issues/2269)
 	GetRewardsBySmesherID(types.NodeID) ([]types.Reward, error)
+	// TODO: fix the discrepancy between SmesherID and NodeID (see https://github.com/spacemeshos/go-spacemesh/issues/2269)
 }
 
 // PeerCounter is an api to get amount of connected peers
 type PeerCounter interface {
+	Close()
 	PeerCount() uint64
 }
 
diff --git a/blocks/blockeligibilityvalidator.go b/blocks/blockeligibilityvalidator.go
index 1cbf0de4387..3723dcf8307 100644
--- a/blocks/blockeligibilityvalidator.go
+++ b/blocks/blockeligibilityvalidator.go
@@ -107,7 +107,7 @@ func (v BlockEligibilityValidator) BlockSignedAndEligible(block *types.Block) (b
 			beaconShortString, epochNumber, counter, types.BytesToHash(vrfSig).ShortString())
 	}
 
-	v.log.Info("validated tortoise beacon eligibility VRF of beacon %v in epoch %v (counter: %v)", beaconShortString, epochNumber, counter)
+	v.log.Info("validated tortoise beacon eligibility vrf of beacon %v in epoch %v (counter: %v)", beaconShortString, epochNumber, counter)
 
 	eligibleLayer := calcEligibleLayer(epochNumber, v.layersPerEpoch, vrfSig)
 
diff --git a/blocks/blockoracle.go b/blocks/blockoracle.go
index 11801c1d317..05dba8585ae 100644
--- a/blocks/blockoracle.go
+++ b/blocks/blockoracle.go
@@ -110,7 +110,7 @@ func (bo *Oracle) calcEligibilityProofs(epochNumber types.EpochID) (map[types.La
 	}
 
 	beaconDbgStr := types.BytesToHash(epochBeacon).ShortString()
-	bo.log.With().Info("Got beacon",
+	bo.log.With().Info("got beacon",
 		log.Uint64("epoch_id", uint64(epochNumber)),
 		log.String("epoch_beacon", beaconDbgStr))
 
@@ -150,7 +150,7 @@ func (bo *Oracle) calcEligibilityProofs(epochNumber types.EpochID) (map[types.La
 		}
 		vrfSig := bo.vrfSigner.Sign(message)
 
-		bo.log.Debug("signed VRF message, beacon %v, epoch %v, counter: %v, vrfSig: %v",
+		bo.log.Debug("signed vrf message, beacon %v, epoch %v, counter: %v, vrfSig: %v",
 			types.BytesToHash(epochBeacon).ShortString(), epochNumber, counter, types.BytesToHash(vrfSig).ShortString())
 
 		eligibleLayer := calcEligibleLayer(epochNumber, bo.layersPerEpoch, vrfSig)
@@ -180,7 +180,7 @@ func (bo *Oracle) calcEligibilityProofs(epochNumber types.EpochID) (map[types.La
 	// Pretty-print the number of blocks per eligible layer
 	var strs []string
 	for k := range keys {
-		strs = append(strs, fmt.Sprintf("Layer %d: %d", keys[k], len(eligibilityProofs[keys[k]])))
+		strs = append(strs, fmt.Sprintf("Layer %s: %d", keys[k].String(), len(eligibilityProofs[keys[k]])))
 	}
 
 	bo.log.With().Info("block eligibility calculated",
diff --git a/blocks/blocks.go b/blocks/blocks.go
index 79acb2c12b1..80888667c1e 100644
--- a/blocks/blocks.go
+++ b/blocks/blocks.go
@@ -27,7 +27,7 @@ type mesh interface {
 	GetBlock(types.BlockID) (*types.Block, error)
 	AddBlockWithTxs(context.Context, *types.Block) error
 	ProcessedLayer() types.LayerID
-	HandleLateBlock(*types.Block)
+	HandleLateBlock(context.Context, *types.Block)
 	ForBlockInView(view map[types.BlockID]struct{}, layer types.LayerID, blockHandler func(block *types.Block) (bool, error)) error
 }
 
@@ -117,10 +117,10 @@ func (bh *BlockHandler) HandleBlockData(ctx context.Context, data []byte, fetche
 		logger.With().Error("block is late",
 			log.FieldNamed("processed_layer", bh.mesh.ProcessedLayer()),
 			log.FieldNamed("miner_id", blk.MinerID()))
-		bh.mesh.HandleLateBlock(&blk)
+		bh.mesh.HandleLateBlock(ctx, &blk)
 	}
 
-	logger.With().Info("time to process block", log.Duration("duration", time.Since(start)))
+	logger.With().Debug("time to process block", log.Duration("duration", time.Since(start)))
 	return nil
 }
 
@@ -151,6 +151,9 @@ func (bh BlockHandler) blockSyntacticValidation(ctx context.Context, block *type
 	}
 
 	// fast validation checks if there are no duplicate ATX in active set and no duplicate TXs as well
+	// TODO: validate that there are no conflicts in the vote exception lists (e.g., that the block does not both
+	//   support and vote against a given block)
+	//   See https://github.com/spacemeshos/go-spacemesh/issues/2369
 	if err := bh.fastValidation(block); err != nil {
 		bh.WithContext(ctx).With().Error("failed fast validation", block.ID(), log.Err(err))
 		return err
@@ -200,7 +203,7 @@ func (bh *BlockHandler) fetchAllReferencedAtxs(ctx context.Context, blk *types.B
 func (bh *BlockHandler) fastValidation(block *types.Block) error {
 	// block eligibility
 	if eligible, err := bh.validator.BlockSignedAndEligible(block); err != nil || !eligible {
-		return fmt.Errorf("block eligibility check failed - err %v", err)
+		return fmt.Errorf("block eligibility check failed: %w", err)
 	}
 
 	// validate unique tx atx
@@ -208,7 +211,6 @@ func (bh *BlockHandler) fastValidation(block *types.Block) error {
 		return err
 	}
 	return nil
-
 }
 
 func validateUniqueTxAtx(b *types.Block) error {
diff --git a/blocks/blocks_test.go b/blocks/blocks_test.go
index c5f49161b1a..de3410f5811 100644
--- a/blocks/blocks_test.go
+++ b/blocks/blocks_test.go
@@ -138,7 +138,7 @@ func (m meshMock) ForBlockInView(view map[types.BlockID]struct{}, layer types.La
 	panic("implement me")
 }
 
-func (m meshMock) GetBlock(ID types.BlockID) (*types.Block, error) {
+func (m meshMock) GetBlock(types.BlockID) (*types.Block, error) {
 	panic("implement me")
 }
 
@@ -150,14 +150,14 @@ func (m meshMock) ProcessedLayer() types.LayerID {
 	panic("implement me")
 }
 
-func (m meshMock) HandleLateBlock(blk *types.Block) {
+func (m meshMock) HandleLateBlock(context.Context, *types.Block) {
 	panic("implement me")
 }
 
 type verifierMock struct {
 }
 
-func (v verifierMock) BlockSignedAndEligible(block *types.Block) (bool, error) {
+func (v verifierMock) BlockSignedAndEligible(*types.Block) (bool, error) {
 	return true, nil
 }
 
diff --git a/cmd/hare/hare.go b/cmd/hare/hare.go
index 93b102936ca..4dd7e68024d 100644
--- a/cmd/hare/hare.go
+++ b/cmd/hare/hare.go
@@ -52,14 +52,17 @@ func init() {
 type mockBlockProvider struct {
 }
 
-func (mbp *mockBlockProvider) HandleValidatedLayer(ctx context.Context, validatedLayer types.LayerID, layer []types.BlockID) {
+func (mbp *mockBlockProvider) HandleValidatedLayer(context.Context, types.LayerID, []types.BlockID) {
 }
 
-func (mbp *mockBlockProvider) LayerBlockIds(types.LayerID) ([]types.BlockID, error) {
-	return buildSet(), nil
+func (mbp *mockBlockProvider) InvalidateLayer(context.Context, types.LayerID) {
 }
 
-func (mbp *mockBlockProvider) RecordCoinflip(ctx context.Context, layerID types.LayerID, coinflip bool) {
+func (mbp *mockBlockProvider) RecordCoinflip(context.Context, types.LayerID, bool) {
+}
+
+func (mbp *mockBlockProvider) LayerBlockIds(types.LayerID) ([]types.BlockID, error) {
+	return buildSet(), nil
 }
 
 // HareApp represents an Hare application
@@ -114,10 +117,6 @@ func (msq mockStateQuerier) IsIdentityActiveOnConsensusView(ctx context.Context,
 	return true, nil
 }
 
-func validateBlocks(blocks []types.BlockID) bool {
-	return true
-}
-
 // Start the app
 func (app *HareApp) Start(cmd *cobra.Command, args []string) {
 	log.Info("starting hare main")
@@ -159,7 +158,7 @@ func (app *HareApp) Start(cmd *cobra.Command, args []string) {
 	//app.clock = timesync.NewClock(timesync.RealClock{}, ld, gTime, lg)
 	lt := make(timesync.LayerTimer)
 
-	hareI := hare.New(app.Config.HARE, app.p2p, app.sgn, types.NodeID{Key: app.sgn.PublicKey().String(), VRFPublicKey: []byte{}}, validateBlocks, IsSynced, &mockBlockProvider{}, hareOracle, uint16(app.Config.LayersPerEpoch), &mockIDProvider{}, &mockStateQuerier{}, lt, lg)
+	hareI := hare.New(app.Config.HARE, app.p2p, app.sgn, types.NodeID{Key: app.sgn.PublicKey().String(), VRFPublicKey: []byte{}}, IsSynced, &mockBlockProvider{}, hareOracle, uint16(app.Config.LayersPerEpoch), &mockIDProvider{}, &mockStateQuerier{}, lt, lg)
 	log.Info("starting hare service")
 	app.ha = hareI
 	if err = app.ha.Start(cmdp.Ctx); err != nil {
diff --git a/cmd/node/app_test.go b/cmd/node/app_test.go
index 18337ba82d8..bbd24b16ef2 100644
--- a/cmd/node/app_test.go
+++ b/cmd/node/app_test.go
@@ -12,6 +12,7 @@ import (
 	"path/filepath"
 	"regexp"
 	"runtime"
+	"sync"
 	"testing"
 	"time"
 
@@ -38,8 +39,10 @@ import (
 
 type AppTestSuite struct {
 	suite.Suite
-	log         log.Log
 	apps        []*App
+	killedApps  []*App
+	killEpoch   types.EpochID
+	log         log.Log
 	poetCleanup func(cleanup bool) error
 }
 
@@ -68,10 +71,13 @@ func Test_PoETHarnessSanity(t *testing.T) {
 	require.NotNil(t, h)
 }
 
-func (suite *AppTestSuite) initMultipleInstances(cfg *config.Config, rolacle *eligibility.FixedRolacle, numOfInstances int, storeFormat string, genesisTime string, poetClient *activation.HTTPPoetClient, clock TickProvider, network network) {
+func (suite *AppTestSuite) initMultipleInstances(cfg *config.Config, rolacle *eligibility.FixedRolacle, numOfInstances int, genesisTime string, poetClient *activation.HTTPPoetClient, clock TickProvider, network network) (firstDir string) {
 	name := 'a'
 	for i := 0; i < numOfInstances; i++ {
-		dbStorepath := storeFormat + string(name)
+		dbStorepath := suite.T().TempDir()
+		if i == 0 {
+			firstDir = dbStorepath
+		}
 		database.SwitchCreationContext(dbStorepath, string(name))
 		edSgn := signing.NewEdSigner()
 		smApp, err := InitSingleInstance(logtest.New(suite.T()), *cfg, i, genesisTime, dbStorepath, rolacle, poetClient, clock, network, edSgn)
@@ -79,6 +85,7 @@ func (suite *AppTestSuite) initMultipleInstances(cfg *config.Config, rolacle *el
 		suite.apps = append(suite.apps, smApp)
 		name++
 	}
+	return
 }
 
 func (suite *AppTestSuite) ClosePoet() {
@@ -92,6 +99,22 @@ var tests = []TestScenario{
 	sameRootTester([]int{0}),
 	reachedEpochTester([]int{}),
 	txWithUnorderedNonceGenerator([]int{1}),
+	healingTester([]int{}), // run last as it kills some of the running apps!
+}
+
+type sharedClock struct {
+	logger log.Log
+	*timesync.TimeClock
+}
+
+func (clock sharedClock) Close() {
+	// wrap the Close method so closing one app doesn't close the clock for other listeners
+	clock.logger.Info("simulating clock close")
+}
+
+func (clock sharedClock) RealClose() {
+	// actually close the underlying clock
+	clock.TimeClock.Close()
 }
 
 func (suite *AppTestSuite) TestMultipleNodes() {
@@ -100,14 +123,13 @@ func (suite *AppTestSuite) TestMultipleNodes() {
 		numberOfEpochs = 5 // first 2 epochs are genesis
 		numOfInstances = 5
 	)
-	cfg := getTestDefaultConfig(numOfInstances)
+	cfg := getTestDefaultConfig()
 	types.SetLayersPerEpoch(cfg.LayersPerEpoch)
-	path := suite.T().TempDir()
 	lg := logtest.New(suite.T())
 
 	genesisTime := time.Now().Add(20 * time.Second).Format(time.RFC3339)
 	poetHarness, err := activation.NewHTTPPoetHarness(false)
-	require.NoError(suite.T(), err, "failed creating poet client harness: %v", err)
+	suite.NoError(err, "failed creating poet client harness: %v", err)
 	suite.poetCleanup = poetHarness.Teardown
 
 	// Scan and print the poet output, and catch errors early
@@ -118,7 +140,7 @@ func (suite *AppTestSuite) TestMultipleNodes() {
 		for scanner.Scan() {
 			line := scanner.Text()
 			matched, err := regexp.MatchString(`\bERROR\b`, line)
-			require.NoError(suite.T(), err)
+			suite.NoError(err)
 			// Fail fast if we encounter a poet error
 			// Must use a channel since we're running inside a goroutine
 			if matched {
@@ -135,29 +157,33 @@ func (suite *AppTestSuite) TestMultipleNodes() {
 	if err != nil {
 		suite.log.With().Error("cannot parse genesis time", log.Err(err))
 	}
-	ld := time.Duration(20) * time.Second
-	clock := timesync.NewClock(timesync.RealClock{}, ld, gTime, logtest.New(suite.T()))
-	suite.initMultipleInstances(cfg, rolacle, numOfInstances, path, genesisTime, poetHarness.HTTPPoetClient, clock, net)
+	ld := 20 * time.Second
+	clock := sharedClock{suite.log, timesync.NewClock(timesync.RealClock{}, ld, gTime, logtest.New(suite.T()))}
+	firstDir := suite.initMultipleInstances(cfg, rolacle, numOfInstances, genesisTime, poetHarness.HTTPPoetClient, clock, net)
 
 	// We must shut down before running the rest of the tests or we'll get an error about resource unavailable
 	// when we try to allocate more database files. Wrap this context neatly in an inline func.
 	var oldRoot types.Hash32
 	var edSgn *signing.EdSigner
 	func() {
-		defer GracefulShutdown(suite.apps)
+		// wrap so apps list is lazily evaluated
+		defer func() {
+			GracefulShutdown(suite.apps)
+		}()
 		defer suite.ClosePoet()
+		defer clock.RealClose()
 
 		for _, a := range suite.apps {
-			a.startServices(context.TODO(), logtest.New(suite.T()))
+			suite.NoError(a.startServices(context.TODO()))
 		}
 
 		ActivateGrpcServer(suite.apps[0])
 
-		if err := poetHarness.Start(context.TODO(), []string{"127.0.0.1:9094"}); err != nil {
+		if err := poetHarness.Start(context.TODO(), []string{fmt.Sprintf("127.0.0.1:%d", suite.apps[0].grpcAPIService.Port)}); err != nil {
 			suite.T().Fatalf("failed to start poet server: %v", err)
 		}
 
-		timeout := time.After(6 * time.Minute)
+		timeout := time.After(10 * time.Minute)
 
 		// Run setup first. We need to allow this to timeout, and monitor the failure channel too,
 		// as this can also loop forever.
@@ -199,14 +225,11 @@ func (suite *AppTestSuite) TestMultipleNodes() {
 		edSgn = suite.apps[0].edSgn
 	}()
 
-	// this tests loading of previous state, maybe it's not the best place to put this here...
-	smApp, err := InitSingleInstance(lg, *cfg, 0, genesisTime, path+"a", rolacle, poetHarness.HTTPPoetClient, clock, net, edSgn)
-	assert.NoError(suite.T(), err)
+	// initialize a new app using the same database as the first node and make sure the state roots match
+	smApp, err := InitSingleInstance(lg, *cfg, 0, genesisTime, firstDir, rolacle, poetHarness.HTTPPoetClient, clock, net, edSgn)
+	suite.NoError(err)
 	// test that loaded root is equal
-	assert.Equal(suite.T(), oldRoot, smApp.state.GetStateRoot())
-	// start and stop and test for no panics
-	smApp.startServices(context.TODO(), logtest.New(suite.T()))
-	smApp.stopServices()
+	suite.validateReloadStateRoot(smApp, oldRoot)
 }
 
 type (
@@ -222,7 +245,7 @@ type (
 func txWithUnorderedNonceGenerator(dependencies []int) TestScenario {
 	acc1Signer, err := signing.NewEdSignerFromBuffer(util.FromHex(apicfg.Account2Private))
 	if err != nil {
-		log.Panic("could not build ed signer", log.Err(err))
+		log.With().Panic("could not build ed signer", log.Err(err))
 	}
 	addr := types.Address{}
 	addr.SetBytes(acc1Signer.PublicKey().Bytes())
@@ -232,24 +255,35 @@ func txWithUnorderedNonceGenerator(dependencies []int) TestScenario {
 		for i := 0; i < txsSent; i++ {
 			tx, err := types.NewSignedTx(uint64(txsSent-i), dst, 10, 1, 1, acc1Signer)
 			if err != nil {
-				log.Panic("panicked creating signed tx", log.Err(err))
+				suite.log.With().Panic("panicked creating signed tx", log.Err(err))
 			}
 			txbytes, _ := types.InterfaceToBytes(tx)
 			pbMsg := &pb.SubmitTransactionRequest{Transaction: txbytes}
 			_, err = suite.apps[0].txService.SubmitTransaction(nil, pbMsg)
-			assert.Error(suite.T(), err)
+			suite.Error(err)
+			suite.log.With().Info("got expected error submitting tx with out of order nonce", log.Err(err))
 		}
 	}
 
-	teardown := func(suite *AppTestSuite, t *testing.T) bool {
+	test := func(suite *AppTestSuite, t *testing.T) bool {
 		ok := true
 		for _, app := range suite.apps {
+			suite.log.With().Info("zero acc current balance",
+				app.nodeID,
+				log.FieldNamed("sender", addr),
+				log.FieldNamed("dest", dst),
+				log.Uint64("dest_balance", app.state.GetBalance(dst)),
+				log.Uint64("sender_nonce", app.state.GetNonce(addr)),
+				log.Uint64("sender_balance", app.state.GetBalance(addr)))
 			ok = ok && 0 == app.state.GetBalance(dst) && app.state.GetNonce(addr) == 0
 		}
+		if ok {
+			suite.log.Info("zero addresses ok")
+		}
 		return ok
 	}
 
-	return TestScenario{setup, teardown, dependencies}
+	return TestScenario{setup, test, dependencies}
 }
 
 func txWithRunningNonceGenerator(dependencies []int) TestScenario {
@@ -274,6 +308,7 @@ func txWithRunningNonceGenerator(dependencies []int) TestScenario {
 
 		for i := 0; i < txsSent; i++ {
 			actNonce := getNonce()
+			suite.log.Info("waiting for nonce: %d, current projected nonce: %d", i, actNonce)
 
 			// Note: this may loop forever if the nonce is not advancing for some reason, but the entire
 			// setup process will timeout above if this happens
@@ -290,15 +325,25 @@ func txWithRunningNonceGenerator(dependencies []int) TestScenario {
 		}
 	}
 
-	teardown := func(suite *AppTestSuite, t *testing.T) bool {
+	test := func(suite *AppTestSuite, t *testing.T) bool {
 		ok := true
 		for _, app := range suite.apps {
-			ok = ok && 250 <= app.state.GetBalance(dst) && app.state.GetNonce(addr) == uint64(txsSent)
+			suite.log.With().Info("valid tx recipient acc current balance",
+				app.nodeID,
+				log.FieldNamed("sender", addr),
+				log.FieldNamed("dest", dst),
+				log.Uint64("dest_balance", app.state.GetBalance(dst)),
+				log.Uint64("sender_nonce", app.state.GetNonce(addr)),
+				log.Uint64("sender_balance", app.state.GetBalance(addr)))
+			ok = ok && app.state.GetBalance(dst) >= 250 && app.state.GetNonce(addr) == uint64(txsSent)
+		}
+		if ok {
+			suite.log.Info("addresses ok")
 		}
 		return ok
 	}
 
-	return TestScenario{setup, teardown, dependencies}
+	return TestScenario{setup, test, dependencies}
 }
 
 func reachedEpochTester(dependencies []int) TestScenario {
@@ -313,6 +358,8 @@ func reachedEpochTester(dependencies []int) TestScenario {
 			}
 			suite.validateLastATXTotalWeight(app, numberOfEpochs, expectedTotalWeight)
 		}
+		suite.log.Info("epoch ok")
+
 		// weakcoin test runs once, after epoch has been reached
 		suite.healingWeakcoinTester()
 		return true
@@ -344,6 +391,65 @@ func (suite *AppTestSuite) healingWeakcoinTester() {
 	}
 }
 
+func healingTester(dependencies []int) TestScenario {
+	var lastVerifiedLayer types.LayerID
+	var ok1, ok2 map[int]bool
+	confidenceInterval := uint32(2)
+	once := sync.Once{}
+	setup := func(suite *AppTestSuite, t *testing.T) {}
+
+	test := func(suite *AppTestSuite, t *testing.T) bool {
+		// we can't actually use setup() as it's destructive to other tests, so run setup here
+		once.Do(func() {
+			// immediately kill half of the participating nodes.
+			// poet communicates with GRPC server on the first app, so leave first one alone
+			// we need to kill at least half, so round up.
+			// the last apps in the list have the largest voting weight so we should remove them.
+			firstAppToKill := len(suite.apps) - (len(suite.apps)/2 + 1)
+
+			// save data on the nodes we're about to kill for posterity
+			suite.killedApps = suite.apps[firstAppToKill:]
+			GracefulShutdown(suite.apps[firstAppToKill:])
+
+			// make sure we don't attempt to shut down the same apps twice
+			suite.apps = suite.apps[:firstAppToKill]
+
+			lastVerifiedLayer = suite.apps[0].mesh.LatestLayerInState()
+			suite.killEpoch = lastVerifiedLayer.GetEpoch()
+
+			// initialize maps
+			ok1 = make(map[int]bool, len(suite.apps))
+			ok2 = make(map[int]bool, len(suite.apps))
+		})
+
+		// now wait for healing to kick in and advance the verified layer
+		success := true
+		for i, app := range suite.apps {
+			lyrProcessed := app.mesh.ProcessedLayer()
+			lyrVerified := app.mesh.LatestLayerInState()
+			suite.log.With().Info("node latest layers",
+				log.FieldNamed("old_verified", lastVerifiedLayer),
+				log.Uint32("confidence_interval", confidenceInterval),
+				log.FieldNamed("processed", lyrProcessed),
+				log.FieldNamed("verified", lyrVerified),
+				log.Int("app", i),
+				log.FieldNamed("nodeid", app.nodeID))
+
+			// two success conditions:
+			//   1. make sure verified layer gets stuck (healing is needed)
+			ok1[i] = ok1[i] || lyrProcessed.After(lyrVerified.Add(confidenceInterval))
+
+			//   2. make sure healing actually kicks in
+			//   (verified needs to advance, and to nearly catch up to last received)
+			ok2[i] = ok1[i] && lyrVerified.After(lastVerifiedLayer.Add(confidenceInterval))
+			ok2[i] = ok2[i] && !lyrVerified.Add(confidenceInterval).Before(lyrProcessed)
+			success = success && ok2[i]
+		}
+		return success
+	}
+	return TestScenario{setup, test, dependencies}
+}
+
 func configuredTotalWeight(apps []*App) uint64 {
 	expectedTotalWeight := uint64(0)
 	for _, app := range apps {
@@ -367,6 +473,7 @@ func sameRootTester(dependencies []int) TestScenario {
 					if r1 == r2 {
 						clientsDone++
 						if clientsDone == len(suite.apps)-1 {
+							suite.log.Info("%d roots confirmed out of %d return ok", clientsDone, len(suite.apps))
 							return true
 						}
 					}
@@ -379,6 +486,7 @@ func sameRootTester(dependencies []int) TestScenario {
 
 		if maxClientsDone != stickyClientsDone {
 			stickyClientsDone = maxClientsDone
+			suite.log.Info("%d roots confirmed out of %d", maxClientsDone, len(suite.apps))
 		}
 		return false
 	}
@@ -403,6 +511,7 @@ func runTests(suite *AppTestSuite, finished map[int]bool) bool {
 		}
 		if depsOk && !finished[i] {
 			finished[i] = test.Criteria(suite, suite.T())
+			suite.log.Info("test %d completion state: %v", i, finished[i])
 		}
 		if !finished[i] {
 			// at least one test isn't completed, pre-empt and return to keep looping
@@ -412,6 +521,15 @@ func runTests(suite *AppTestSuite, finished map[int]bool) bool {
 	return true
 }
 
+func (suite *AppTestSuite) validateReloadStateRoot(app *App, oldRoot types.Hash32) {
+	// test that loaded root is equal
+	assert.Equal(suite.T(), oldRoot, app.state.GetStateRoot())
+
+	// start and stop and test for no panics
+	suite.NoError(app.startServices(context.TODO()))
+	app.stopServices()
+}
+
 func (suite *AppTestSuite) validateBlocksAndATXs(untilLayer types.LayerID) {
 	type nodeData struct {
 		layertoblocks map[types.LayerID][]types.BlockID
@@ -443,28 +561,22 @@ func (suite *AppTestSuite) validateBlocksAndATXs(untilLayer types.LayerID) {
 		}
 	}
 
-	lateNodeKey := suite.apps[len(suite.apps)-1].nodeID.Key
 	for i, d := range datamap {
-		if i == lateNodeKey { // skip late node
-			continue
-		}
+		suite.log.Info("node %v: len(layerstoblocks) %v", i, len(d.layertoblocks))
 		for i2, d2 := range datamap {
 			if i == i2 {
 				continue
 			}
-			if i2 == lateNodeKey { // skip late node
-				continue
-			}
 
-			assert.Equal(suite.T(), len(d.layertoblocks), len(d2.layertoblocks), "%v has not matching layer to %v. %v not %v", i, i2, len(d.layertoblocks), len(d2.layertoblocks))
+			suite.Equal(len(d.layertoblocks), len(d2.layertoblocks), "%v layer block count mismatch with %v: %v not %v", i, i2, len(d.layertoblocks), len(d2.layertoblocks))
 
 			for l, bl := range d.layertoblocks {
-				assert.Equal(suite.T(), len(bl), len(d2.layertoblocks[l]),
+				suite.Equal(len(bl), len(d2.layertoblocks[l]),
 					fmt.Sprintf("%v and %v had different block maps for layer: %v: %v: %v \r\n %v: %v", i, i2, l, i, bl, i2, d2.layertoblocks[l]))
 			}
 
 			for e, atx := range d.atxPerEpoch {
-				assert.Equal(suite.T(), atx, d2.atxPerEpoch[e],
+				suite.Equal(atx, d2.atxPerEpoch[e],
 					fmt.Sprintf("%v and %v had different atx counts for epoch: %v: %v: %v \r\n %v: %v", i, i2, e, i, atx, i2, d2.atxPerEpoch[e]))
 			}
 		}
@@ -472,43 +584,54 @@ func (suite *AppTestSuite) validateBlocksAndATXs(untilLayer types.LayerID) {
 
 	// assuming all nodes have the same results
 	layerAvgSize := suite.apps[0].Config.LayerAvgSize
-	patient := datamap[suite.apps[0].nodeID.Key]
+	nodedata := datamap[suite.apps[0].nodeID.Key]
 
-	lastLayer := len(patient.layertoblocks) + 5
+	lastLayer := len(nodedata.layertoblocks) + 5
+	suite.log.Info("node %v", suite.apps[0].nodeID.ShortString())
 
 	totalBlocks := 0
-	for _, l := range patient.layertoblocks {
+	for id, l := range nodedata.layertoblocks {
 		totalBlocks += len(l)
+		suite.log.Info("node %v: layer %v, blocks %v", suite.apps[0].nodeID.ShortString(), id, len(l))
 	}
 
 	genesisBlocks := 0
 	for i := uint32(0); i < layersPerEpoch*2; i++ {
-		if l, ok := patient.layertoblocks[types.NewLayerID(i)]; ok {
+		if l, ok := nodedata.layertoblocks[types.NewLayerID(i)]; ok {
 			genesisBlocks += len(l)
 		}
 	}
 
 	// assert number of blocks
 	totalEpochs := int(untilLayer.GetEpoch()) + 1
-	expectedEpochWeight := configuredTotalWeight(suite.apps)
-	blocksPerEpochTarget := uint32(layerAvgSize) * layersPerEpoch
+	blocksPerEpochTarget := layerAvgSize * int(layersPerEpoch)
+
+	allApps := append(suite.apps, suite.killedApps...)
+	expectedEpochWeight := configuredTotalWeight(allApps)
+
+	// note: expected no. blocks per epoch should remain the same even after some nodes are killed, since the
+	// remaining nodes will be eligible for proportionally more blocks per layer
 	expectedBlocksPerEpoch := 0
-	for _, app := range suite.apps {
-		expectedBlocksPerEpoch += max(int(blocksPerEpochTarget)*int(app.Config.SMESHING.Opts.NumUnits)/int(expectedEpochWeight), 1)
+	for _, app := range allApps {
+		expectedBlocksPerEpoch += max(blocksPerEpochTarget*int(app.Config.SMESHING.Opts.NumUnits)/int(expectedEpochWeight), 1)
 	}
 
+	// note: we expect the number of blocks to be a bit less than the expected number since, after some apps were
+	// killed and before healing kicked in, some blocks should be missing
 	expectedTotalBlocks := (totalEpochs - 2) * expectedBlocksPerEpoch
 	actualTotalBlocks := totalBlocks - genesisBlocks
-	assert.Equal(suite.T(), expectedTotalBlocks, actualTotalBlocks,
-		fmt.Sprintf("not good num of blocks got: %v, want: %v. totalBlocks: %v, genesisBlocks: %v, lastLayer: %v, layersPerEpoch: %v layerAvgSize: %v totalEpochs: %v datamap: %v",
+	suite.Equal(expectedTotalBlocks, actualTotalBlocks,
+		fmt.Sprintf("got unexpected block count! got: %v, want: %v. totalBlocks: %v, genesisBlocks: %v, lastLayer: %v, layersPerEpoch: %v, layerAvgSize: %v, totalEpochs: %v, datamap: %v",
 			actualTotalBlocks, expectedTotalBlocks, totalBlocks, genesisBlocks, lastLayer, layersPerEpoch, layerAvgSize, totalEpochs, datamap))
 
-	totalWeightAllEpochs := calcTotalWeight(assert.New(suite.T()), suite.apps)
+	totalWeightAllEpochs := calcTotalWeight(suite, suite.apps[0].atxDb, allApps, types.EpochID(totalEpochs))
 
-	// assert number of ATXs
-	allMiners := len(suite.apps)
+	// assert total ATX weight
 	expectedTotalWeight := uint64(totalEpochs) * expectedEpochWeight
-	assert.Equal(suite.T(), expectedTotalWeight, totalWeightAllEpochs, fmt.Sprintf("not good total atx weight. got: %v, want: %v.\ntotalEpochs: %v, allMiners: %v", totalWeightAllEpochs, expectedTotalWeight, totalEpochs, allMiners))
+	suite.Equal(int(expectedTotalWeight), int(totalWeightAllEpochs),
+		fmt.Sprintf("total atx weight is wrong, got: %v, want: %v\n"+
+			"totalEpochs: %v, numApps: %v, expectedWeight: %v",
+			totalWeightAllEpochs, expectedTotalWeight, totalEpochs, len(allApps), expectedEpochWeight))
 }
 
 func max(i, j int) int {
@@ -518,22 +641,35 @@ func max(i, j int) int {
 	return j
 }
 
-func calcTotalWeight(assert *assert.Assertions, apps []*App) (totalWeightAllEpochs uint64) {
-	app := apps[0]
-	atxDb := app.atxDb
-
+func calcTotalWeight(
+	suite *AppTestSuite,
+	atxDb *activation.DB,
+	apps []*App,
+	untilEpoch types.EpochID) (totalWeightAllEpochs uint64) {
+	r := require.New(suite.T())
 	for _, app := range apps {
 		atxID, err := atxDb.GetNodeLastAtxID(app.nodeID)
-		assert.NoError(err)
+		r.NoError(err)
 
 		for atxID != *types.EmptyATXID {
 			atx, err := atxDb.GetAtxHeader(atxID)
-			assert.NoError(err)
-			totalWeightAllEpochs += atx.GetWeight()
+			r.NoError(err)
+			if atx.TargetEpoch() < untilEpoch+2 {
+				totalWeightAllEpochs += atx.GetWeight()
+				suite.log.With().Info("added atx weight",
+					log.FieldNamed("pub_layer", atx.PubLayerID),
+					log.FieldNamed("target_epoch", atx.TargetEpoch()),
+					log.Uint64("weight", atx.GetWeight()))
+			} else {
+				suite.log.With().Info("ignoring atx after final epoch",
+					log.FieldNamed("pub_layer", atx.PubLayerID),
+					log.FieldNamed("target_epoch", atx.TargetEpoch()),
+					log.Uint64("weight", atx.GetWeight()))
+			}
 			atxID = atx.PrevATXID
 		}
 	}
-	return totalWeightAllEpochs
+	return
 }
 
 func (suite *AppTestSuite) validateLastATXTotalWeight(app *App, numberOfEpochs int, expectedTotalWeight uint64) {
@@ -545,7 +681,7 @@ func (suite *AppTestSuite) validateLastATXTotalWeight(app *App, numberOfEpochs i
 		atx, _ := app.atxDb.GetAtxHeader(atxID)
 		totalWeight += atx.GetWeight()
 	}
-	suite.Equal(expectedTotalWeight, totalWeight, "node: %v", app.nodeID.ShortString())
+	suite.Equal(int(expectedTotalWeight), int(totalWeight), "node: %v", app.nodeID.ShortString())
 }
 
 func TestAppTestSuite(t *testing.T) {
@@ -560,7 +696,7 @@ func TestShutdown(t *testing.T) {
 		t.Skip()
 	}
 
-	// make sure previous goroutines has stopped
+	// make sure previous goroutines have stopped
 	time.Sleep(3 * time.Second)
 	gCount := runtime.NumGoroutine()
 	net := service.NewSimulator()
@@ -576,7 +712,7 @@ func TestShutdown(t *testing.T) {
 	smApp.Config.SMESHING.Start = true
 	smApp.Config.SMESHING.CoinbaseAccount = "0x123"
 	smApp.Config.SMESHING.Opts.DataDir, _ = ioutil.TempDir("", "sm-test-post")
-	smApp.Config.SMESHING.Opts.ComputeProviderID = int(initialization.CPUProviderID())
+	smApp.Config.SMESHING.Opts.ComputeProviderID = initialization.CPUProviderID()
 
 	smApp.Config.HARE.N = 5
 	smApp.Config.HARE.F = 2
@@ -597,7 +733,7 @@ func TestShutdown(t *testing.T) {
 	smApp.Config.FETCH.RequestTimeout = 1
 	smApp.Config.FETCH.BatchTimeout = 1
 	smApp.Config.FETCH.BatchSize = 5
-	smApp.Config.FETCH.MaxRetiresForPeer = 5
+	smApp.Config.FETCH.MaxRetriesForPeer = 5
 
 	rolacle := eligibility.New(logtest.New(t))
 	types.SetLayersPerEpoch(smApp.Config.LayersPerEpoch)
@@ -621,11 +757,8 @@ func TestShutdown(t *testing.T) {
 	gTime := genesisTime
 	ld := time.Duration(20) * time.Second
 	clock := timesync.NewClock(timesync.RealClock{}, ld, gTime, logtest.New(t))
-	err = smApp.initServices(context.TODO(), nodeID, swarm, dbStorepath, edSgn, false, hareOracle, uint32(smApp.Config.LayerAvgSize), poetHarness.HTTPPoetClient, vrfSigner, smApp.Config.LayersPerEpoch, clock)
-
-	r.NoError(err)
-
-	smApp.startServices(context.TODO(), logtest.New(t))
+	r.NoError(smApp.initServices(context.TODO(), nodeID, swarm, dbStorepath, edSgn, false, hareOracle, uint32(smApp.Config.LayerAvgSize), poetHarness.HTTPPoetClient, vrfSigner, smApp.Config.LayersPerEpoch, clock))
+	r.NoError(smApp.startServices(context.TODO()))
 	ActivateGrpcServer(smApp)
 
 	r.NoError(poetHarness.Teardown(true))
@@ -635,9 +768,9 @@ func TestShutdown(t *testing.T) {
 	gCount2 := runtime.NumGoroutine()
 
 	if gCount != gCount2 {
-		buf := make([]byte, 4096)
-		runtime.Stack(buf, true)
-		logtest.New(t).Error(string(buf))
+		buf := make([]byte, 1<<16)
+		numbytes := runtime.Stack(buf, true)
+		t.Log(string(buf[:numbytes]))
 	}
 	require.Equal(t, gCount, gCount2)
 }
diff --git a/cmd/node/multi_node.go b/cmd/node/multi_node.go
index f19f34f556f..b19fd700068 100644
--- a/cmd/node/multi_node.go
+++ b/cmd/node/multi_node.go
@@ -125,7 +125,7 @@ func (clk *ManualClock) GetGenesisTime() time.Time {
 // Close does nothing because this clock is manual
 func (clk *ManualClock) Close() {}
 
-func getTestDefaultConfig(numOfInstances int) *config.Config {
+func getTestDefaultConfig() *config.Config {
 	cfg, err := LoadConfigFromFile()
 	if err != nil {
 		log.Error("cannot load config from file")
@@ -141,12 +141,13 @@ func getTestDefaultConfig(numOfInstances int) *config.Config {
 	cfg.SMESHING.Start = true
 	cfg.SMESHING.Opts.NumUnits = cfg.POST.MinNumUnits + 1
 	cfg.SMESHING.Opts.NumFiles = 1
-	cfg.SMESHING.Opts.ComputeProviderID = int(initialization.CPUProviderID())
+	cfg.SMESHING.Opts.ComputeProviderID = initialization.CPUProviderID()
 
+	// note: these need to be set sufficiently low enough that turbohare finishes well before the LayerDurationSec
+	cfg.HARE.RoundDuration = 2
+	cfg.HARE.WakeupDelta = 1
 	cfg.HARE.N = 5
 	cfg.HARE.F = 2
-	cfg.HARE.RoundDuration = 3
-	cfg.HARE.WakeupDelta = 5
 	cfg.HARE.ExpectedLeaders = 5
 	cfg.HARE.SuperHare = true
 	cfg.LayerAvgSize = 5
@@ -162,7 +163,7 @@ func getTestDefaultConfig(numOfInstances int) *config.Config {
 	cfg.SyncValidationDelta = 5
 
 	cfg.FETCH.RequestTimeout = 10
-	cfg.FETCH.MaxRetiresForPeer = 5
+	cfg.FETCH.MaxRetriesForPeer = 5
 	cfg.FETCH.BatchSize = 5
 	cfg.FETCH.BatchTimeout = 5
 
@@ -195,7 +196,7 @@ func ActivateGrpcServer(smApp *App) {
 
 // GracefulShutdown stops the current services running in apps
 func GracefulShutdown(apps []*App) {
-	log.Info("Graceful shutdown begin")
+	log.Info("graceful shutdown begin")
 
 	var wg sync.WaitGroup
 	for _, app := range apps {
@@ -207,7 +208,7 @@ func GracefulShutdown(apps []*App) {
 	}
 	wg.Wait()
 
-	log.Info("Graceful shutdown end")
+	log.Info("graceful shutdown end")
 }
 
 type network interface {
@@ -219,7 +220,6 @@ type network interface {
 func InitSingleInstance(lg log.Log, cfg config.Config, i int, genesisTime string, storePath string, rolacle *eligibility.FixedRolacle, poetClient *activation.HTTPPoetClient, clock TickProvider, net network, edSgn *signing.EdSigner) (*App, error) {
 	smApp := New(WithLog(lg))
 	smApp.Config = &cfg
-
 	smApp.Config.GenesisTime = genesisTime
 
 	smApp.Config.SMESHING.CoinbaseAccount = strconv.Itoa(i + 1)
@@ -254,7 +254,7 @@ func InitSingleInstance(lg log.Log, cfg config.Config, i int, genesisTime string
 // StartMultiNode Starts the run of a number of nodes, running in process consensus between them.
 // this also runs a single transaction between the nodes.
 func StartMultiNode(logger log.Log, numOfInstances, layerAvgSize int, runTillLayer uint32, dbPath string) {
-	cfg := getTestDefaultConfig(numOfInstances)
+	cfg := getTestDefaultConfig()
 	cfg.LayerAvgSize = layerAvgSize
 	net := service.NewSimulator()
 	path := dbPath + time.Now().Format(time.RFC3339)
@@ -263,7 +263,7 @@ func StartMultiNode(logger log.Log, numOfInstances, layerAvgSize int, runTillLay
 
 	poetHarness, err := activation.NewHTTPPoetHarness(false)
 	if err != nil {
-		logger.Panic("failed creating poet client harness: %v", err)
+		logger.With().Panic("failed creating poet client harness", log.Err(err))
 	}
 	defer func() {
 		err := poetHarness.Teardown(true)
@@ -275,7 +275,7 @@ func StartMultiNode(logger log.Log, numOfInstances, layerAvgSize int, runTillLay
 	rolacle := eligibility.New(logger)
 	gTime, err := time.Parse(time.RFC3339, genesisTime)
 	if err != nil {
-		logger.Error("cannot parse genesis time %v", err)
+		logger.With().Error("cannot parse genesis time", log.Err(err))
 	}
 	events.CloseEventPubSub()
 	pubsubAddr := "tcp://localhost:55666"
@@ -292,7 +292,7 @@ func StartMultiNode(logger log.Log, numOfInstances, layerAvgSize int, runTillLay
 		edSgn := signing.NewEdSigner()
 		smApp, err := InitSingleInstance(logger, *cfg, i, genesisTime, dbStorepath, rolacle, poetHarness.HTTPPoetClient, clock, net, edSgn)
 		if err != nil {
-			logger.Error("cannot run multi node %v", err)
+			logger.With().Error("cannot run multi node", log.Err(err))
 			return
 		}
 		apps = append(apps, smApp)
@@ -302,7 +302,7 @@ func StartMultiNode(logger log.Log, numOfInstances, layerAvgSize int, runTillLay
 	eventDb := collector.NewMemoryCollector()
 	collect := collector.NewCollector(eventDb, pubsubAddr)
 	for _, a := range apps {
-		a.startServices(context.TODO(), logger)
+		a.startServices(context.TODO())
 	}
 	collect.Start(false)
 	ActivateGrpcServer(apps[0])
@@ -315,11 +315,11 @@ func StartMultiNode(logger log.Log, numOfInstances, layerAvgSize int, runTillLay
 				return
 			}
 			if err != nil {
-				logger.Error("Failed to read PoET stdout: %v", err)
+				logger.Error("failed to read poet stdout: %v", err)
 				return
 			}
 
-			logger.Info("[PoET stdout] %v\n", string(line))
+			logger.Info("[poet stdout] %v\n", string(line))
 		}
 	}()
 	go func() {
@@ -330,11 +330,11 @@ func StartMultiNode(logger log.Log, numOfInstances, layerAvgSize int, runTillLay
 				return
 			}
 			if err != nil {
-				logger.Error("Failed to read PoET stderr: %v", err)
+				logger.Error("failed to read poet stderr: %v", err)
 				return
 			}
 
-			logger.Info("[PoET stderr] %v", string(line))
+			logger.Info("[poet stderr] %v", string(line))
 		}
 	}()
 
diff --git a/cmd/node/node.go b/cmd/node/node.go
index d92e607ffe4..4350faa66b9 100644
--- a/cmd/node/node.go
+++ b/cmd/node/node.go
@@ -89,7 +89,6 @@ const (
 	HareLogger           = "hare"
 	BlockBuilderLogger   = "blockBuilder"
 	BlockListenerLogger  = "blockListener"
-	BlockHandlerLogger   = "blockHandler"
 	PoetListenerLogger   = "poetListener"
 	NipostBuilderLogger  = "nipostBuilder"
 	AtxBuilderLogger     = "atxBuilder"
@@ -605,21 +604,43 @@ func (app *App) initServices(ctx context.Context,
 	)
 
 	ld := time.Duration(app.Config.LayerDurationSec) * time.Second
-	tBeacon := tortoisebeacon.New(app.Config.TortoiseBeacon, ld, nodeID, swarm, atxDB, tBeaconDB, sgn, edVerifier, vrfSigner, vrfVerifier, wc, clock, app.addLogger(TBeaconLogger, lg))
+	tBeacon := tortoisebeacon.New(
+		app.Config.TortoiseBeacon,
+		ld,
+		nodeID,
+		swarm,
+		atxDB,
+		tBeaconDB,
+		sgn,
+		edVerifier,
+		vrfSigner,
+		vrfVerifier,
+		wc,
+		clock,
+		app.addLogger(TBeaconLogger, lg))
 
 	var msh *mesh.Mesh
 	var trtl *tortoise.ThreadSafeVerifyingTortoise
 	trtlCfg := tortoise.Config{
-		LayerSize: int(layerSize),
-		Database:  mdb,
-		Hdist:     app.Config.Hdist,
-		Log:       app.addLogger(TrtlLogger, lg),
-		Recovered: mdb.PersistentData(),
-	}
+		LayerSize:       int(layerSize),
+		Database:        mdb,
+		ATXDB:           atxDB,
+		Clock:           clock,
+		Hdist:           app.Config.Hdist,
+		Zdist:           app.Config.Zdist,
+		ConfidenceParam: app.Config.ConfidenceParam,
+		WindowSize:      app.Config.WindowSize,
+		GlobalThreshold: app.Config.GlobalThreshold,
+		LocalThreshold:  app.Config.LocalThreshold,
+		Log:             app.addLogger(TrtlLogger, lg),
+		Recovered:       mdb.PersistentData(),
+		RerunInterval:   time.Minute * time.Duration(app.Config.TortoiseRerunInterval),
+	}
+
+	trtl = tortoise.NewVerifyingTortoise(ctx, trtlCfg)
 
-	trtl = tortoise.NewVerifyingTortoise(trtlCfg)
 	if trtlCfg.Recovered {
-		msh = mesh.NewRecoveredMesh(mdb, atxDB, app.Config.REWARD, trtl, app.txPool, processor, app.addLogger(MeshLogger, lg))
+		msh = mesh.NewRecoveredMesh(ctx, mdb, atxDB, app.Config.REWARD, trtl, app.txPool, processor, app.addLogger(MeshLogger, lg))
 		go msh.CacheWarmUp(app.Config.LayerAvgSize)
 	} else {
 		msh = mesh.NewMesh(mdb, atxDB, app.Config.REWARD, trtl, app.txPool, processor, app.addLogger(MeshLogger, lg))
@@ -660,9 +681,9 @@ func (app *App) initServices(ctx context.Context,
 		ValidationDelta: time.Duration(app.Config.SyncValidationDelta) * time.Second,
 		AlwaysListen:    app.Config.AlwaysListen,
 	}
-	syncer := syncer.NewSyncer(ctx, syncerConf, clock, msh, layerFetch, app.addLogger(SyncLogger, lg))
+	newSyncer := syncer.NewSyncer(ctx, syncerConf, clock, msh, layerFetch, app.addLogger(SyncLogger, lg))
 
-	blockOracle := blocks.NewMinerBlockOracle(layerSize, layersPerEpoch, atxDB, tBeacon, vrfSigner, nodeID, syncer.ListenToGossip, app.addLogger(BlockOracle, lg))
+	blockOracle := blocks.NewMinerBlockOracle(layerSize, layersPerEpoch, atxDB, tBeacon, vrfSigner, nodeID, newSyncer.ListenToGossip, app.addLogger(BlockOracle, lg))
 
 	// TODO: we should probably decouple the apptest and the node (and duplicate as necessary) (#1926)
 	var hOracle hare.Rolacle
@@ -671,15 +692,13 @@ func (app *App) initServices(ctx context.Context,
 		hOracle = rolacle
 	} else {
 		// regular oracle, build and use it
-		// TODO: this mock will be replaced by the real Tortoise beacon once
-		//   https://github.com/spacemeshos/go-spacemesh/pull/2267 is complete
 		beacon := eligibility.NewBeacon(tBeacon, app.Config.HareEligibility.ConfidenceParam, app.addLogger(HareBeaconLogger, lg))
 		hOracle = eligibility.New(beacon, atxDB, mdb, signing.VRFVerify, vrfSigner, app.Config.LayersPerEpoch, app.Config.HareEligibility, app.addLogger(HareOracleLogger, lg))
 		// TODO: genesisMinerWeight is set to app.Config.SpaceToCommit, because PoET ticks are currently hardcoded to 1
 	}
 
-	gossipListener := service.NewListener(swarm, layerFetch, syncer.ListenToGossip, app.addLogger(GossipListener, lg))
-	rabbit := app.HareFactory(ctx, mdb, swarm, sgn, nodeID, syncer, msh, hOracle, idStore, clock, lg)
+	gossipListener := service.NewListener(swarm, layerFetch, newSyncer.ListenToGossip, app.addLogger(GossipListener, lg))
+	rabbit := app.HareFactory(ctx, mdb, swarm, sgn, nodeID, newSyncer, msh, hOracle, idStore, clock, lg)
 
 	stateAndMeshProjector := pendingtxs.NewStateAndMeshProjector(processor, msh)
 	minerCfg := miner.Config{
@@ -691,13 +710,24 @@ func (app *App) initServices(ctx context.Context,
 	}
 
 	database.SwitchCreationContext(dbStorepath, "") // currently only blockbuilder uses this mechanism
-	blockProducer := miner.NewBlockBuilder(minerCfg, sgn, swarm, clock.Subscribe(), msh, trtl, blockOracle, syncer, stateAndMeshProjector, app.txPool, app.addLogger(BlockBuilderLogger, lg))
+	blockProducer := miner.NewBlockBuilder(
+		minerCfg,
+		sgn,
+		swarm,
+		clock.Subscribe(),
+		msh,
+		trtl,
+		blockOracle,
+		newSyncer,
+		stateAndMeshProjector,
+		app.txPool,
+		app.addLogger(BlockBuilderLogger, lg))
 
 	poetListener := activation.NewPoetListener(swarm, poetDb, app.addLogger(PoetListenerLogger, lg))
 
 	postSetupMgr, err := activation.NewPostSetupManager(util.Hex2Bytes(nodeID.Key), app.Config.POST, app.addLogger(PostLogger, lg))
 	if err != nil {
-		app.log.Panic("failed to create Post setup manager: %v", err)
+		app.log.Panic("failed to create post setup manager: %v", err)
 	}
 
 	nipostBuilder := activation.NewNIPostBuilder(util.Hex2Bytes(nodeID.Key), postSetupMgr, poetClient, poetDb, store, app.addLogger(NipostBuilderLogger, lg))
@@ -715,7 +745,7 @@ func (app *App) initServices(ctx context.Context,
 		LayersPerEpoch:  layersPerEpoch,
 	}
 
-	atxBuilder := activation.NewBuilder(builderConfig, nodeID, sgn, atxDB, swarm, msh, layersPerEpoch, nipostBuilder, postSetupMgr, clock, syncer, store, app.addLogger("atxBuilder", lg))
+	atxBuilder := activation.NewBuilder(builderConfig, nodeID, sgn, atxDB, swarm, msh, layersPerEpoch, nipostBuilder, postSetupMgr, clock, newSyncer, store, app.addLogger("atxBuilder", lg))
 
 	gossipListener.AddListener(ctx, state.IncomingTxProtocol, priorityq.Low, processor.HandleTxGossipData)
 	gossipListener.AddListener(ctx, activation.AtxProtocol, priorityq.Low, atxDB.HandleGossipAtx)
@@ -729,7 +759,7 @@ func (app *App) initServices(ctx context.Context,
 	app.blockListener = blockListener
 	app.gossipListener = gossipListener
 	app.mesh = msh
-	app.syncer = syncer
+	app.syncer = newSyncer
 	app.clock = clock
 	app.state = processor
 	app.hare = rabbit
@@ -776,42 +806,49 @@ func (app *App) checkTimeDrifts() {
 	}
 }
 
-// HareFactory returns a hare consensus algorithm according to the parameters is app.Config.Hare.SuperHare
-func (app *App) HareFactory(ctx context.Context, mdb *mesh.DB, swarm service.Service, sgn hare.Signer, nodeID types.NodeID, syncer *syncer.Syncer, msh *mesh.Mesh, hOracle hare.Rolacle, idStore *activation.IdentityStore, clock TickProvider, lg log.Log) HareService {
+// HareFactory returns a hare consensus algorithm according to the parameters in app.Config.Hare.SuperHare
+func (app *App) HareFactory(
+	ctx context.Context,
+	mdb *mesh.DB,
+	swarm service.Service,
+	sgn hare.Signer,
+	nodeID types.NodeID,
+	syncer *syncer.Syncer,
+	msh *mesh.Mesh,
+	hOracle hare.Rolacle,
+	idStore *activation.IdentityStore,
+	clock TickProvider,
+	lg log.Log,
+) HareService {
 	if app.Config.HARE.SuperHare {
 		hr := turbohare.New(ctx, app.Config.HARE, msh, clock.Subscribe(), app.addLogger(HareLogger, lg))
 		mdb.InputVectorBackupFunc = hr.GetResult
 		return hr
 	}
 
-	// a function to validate we know the blocks
-	validationFunc := func(ids []types.BlockID) bool {
-		for _, b := range ids {
-			res, err := mdb.GetBlock(b)
-			if err != nil {
-				app.log.WithContext(ctx).With().Error("output set block not in database", b, log.Err(err))
-				return false
-			}
-			if res == nil {
-				app.log.WithContext(ctx).With().Error("output set block not in database (BUG BUG BUG - FetchBlock return err nil and res nil)", b)
-				return false
-			}
-		}
-
-		return true
-	}
-	ha := hare.New(app.Config.HARE, swarm, sgn, nodeID, validationFunc, syncer.IsSynced, msh, hOracle, uint16(app.Config.LayersPerEpoch), idStore, hOracle, clock.Subscribe(), app.addLogger(HareLogger, lg))
+	ha := hare.New(
+		app.Config.HARE,
+		swarm,
+		sgn,
+		nodeID,
+		syncer.IsSynced,
+		msh,
+		hOracle,
+		uint16(app.Config.LayersPerEpoch),
+		idStore,
+		hOracle,
+		clock.Subscribe(),
+		app.addLogger(HareLogger, lg))
 	return ha
 }
 
-func (app *App) startServices(ctx context.Context, logger log.Log) error {
+func (app *App) startServices(ctx context.Context) error {
 	app.layerFetch.Start()
 	go app.startSyncer(ctx)
 
 	if err := app.tortoiseBeacon.Start(ctx); err != nil {
 		return fmt.Errorf("cannot start tortoise beacon: %w", err)
 	}
-
 	if err := app.hare.Start(ctx); err != nil {
 		return fmt.Errorf("cannot start hare: %w", err)
 	}
@@ -825,11 +862,11 @@ func (app *App) startServices(ctx context.Context, logger log.Log) error {
 		coinbaseAddr := types.HexToAddress(app.Config.SMESHING.CoinbaseAccount)
 		go func() {
 			if err := app.atxBuilder.StartSmeshing(ctx, coinbaseAddr, app.Config.SMESHING.Opts); err != nil {
-				log.Panic("failed to start smeshing: %v", err)
+				log.With().Panic("failed to start smeshing", log.Err(err))
 			}
 		}()
 	} else {
-		log.Info("Smeshing not started, waiting to be triggered via Smesher API")
+		log.Info("smeshing not started, waiting to be triggered via smesher api")
 	}
 
 	app.clock.StartNotifying()
@@ -872,7 +909,9 @@ func (app *App) startAPIServices(ctx context.Context, net api.NetworkAPI) {
 		registerService(grpcserver.NewMeshService(app.mesh, app.txPool, app.clock, app.Config.LayersPerEpoch, app.Config.P2P.NetworkID, layerDuration, app.Config.LayerAvgSize, app.Config.TxsPerBlock))
 	}
 	if apiConf.StartNodeService {
-		registerService(grpcserver.NewNodeService(net, app.mesh, app.clock, app.syncer, app.atxBuilder))
+		nodeService := grpcserver.NewNodeService(net, app.mesh, app.clock, app.syncer, app.atxBuilder)
+		registerService(nodeService)
+		app.closers = append(app.closers, nodeService)
 	}
 	if apiConf.StartSmesherService {
 		registerService(grpcserver.NewSmesherService(app.postSetupMgr, app.atxBuilder))
@@ -941,7 +980,7 @@ func (app *App) stopServices() {
 	}
 
 	if app.tortoiseBeacon != nil {
-		app.log.Info("Stopping tortoise beacon...")
+		app.log.Info("stopping tortoise beacon")
 		app.tortoiseBeacon.Close()
 	}
 
@@ -987,6 +1026,7 @@ func (app *App) stopServices() {
 
 	events.CloseEventReporter()
 	events.CloseEventPubSub()
+
 	// Close all databases.
 	for _, closer := range app.closers {
 		if closer != nil {
@@ -1176,10 +1216,12 @@ func (app *App) Start() error {
 			swarm.LocalNode().PublicKey().String(), strconv.Itoa(int(app.Config.P2P.NetworkID)))
 	}
 
-	app.startServices(ctx, logger)
+	if err := app.startServices(ctx); err != nil {
+		return fmt.Errorf("error starting services: %w", err)
+	}
 
 	// P2P must start last to not block when sending messages to protocols
-	if err = app.P2P.Start(ctx); err != nil {
+	if err := app.P2P.Start(ctx); err != nil {
 		return fmt.Errorf("error starting p2p services: %w", err)
 	}
 
diff --git a/cmd/node/node_test.go b/cmd/node/node_test.go
index 26bde5ba568..b244a71db10 100644
--- a/cmd/node/node_test.go
+++ b/cmd/node/node_test.go
@@ -561,7 +561,7 @@ func TestSpacemeshApp_NodeService(t *testing.T) {
 
 	clock := timesync.NewClock(timesync.RealClock{}, time.Duration(1)*time.Second, time.Now(), logtest.New(t))
 	localNet := service.NewSimulator()
-	cfg := getTestDefaultConfig(1)
+	cfg := getTestDefaultConfig()
 
 	poetHarness, err := activation.NewHTTPPoetHarness(false)
 	require.NoError(t, err)
diff --git a/cmd/sync/mocks.go b/cmd/sync/mocks.go
index a5c70ef6843..54003612243 100644
--- a/cmd/sync/mocks.go
+++ b/cmd/sync/mocks.go
@@ -39,20 +39,21 @@ type meshValidatorMock struct {
 }
 
 func (m *meshValidatorMock) LatestComplete() types.LayerID { return m.vl }
-func (m *meshValidatorMock) Persist() error                { return nil }
-func (m *meshValidatorMock) HandleIncomingLayer(lyr *types.Layer) (types.LayerID, types.LayerID) {
+func (m *meshValidatorMock) Persist(context.Context) error { return nil }
+func (m *meshValidatorMock) HandleIncomingLayer(_ context.Context, lyr types.LayerID) (types.LayerID, types.LayerID, bool) {
 	m.countValidate++
 	m.calls++
-	m.vl = lyr.Index()
+	m.vl = lyr
 	if m.validatedLayers == nil {
 		m.validatedLayers = make(map[types.LayerID]struct{})
 	}
-	m.validatedLayers[lyr.Index()] = struct{}{}
+	m.validatedLayers[lyr] = struct{}{}
 	time.Sleep(m.delay)
-	return lyr.Index(), lyr.Index().Sub(1)
+	return lyr, lyr.Sub(1), false
 }
-func (m *meshValidatorMock) HandleLateBlock(bl *types.Block) (types.LayerID, types.LayerID) {
-	return bl.Layer(), bl.Layer().Sub(1)
+
+func (m *meshValidatorMock) HandleLateBlocks(_ context.Context, blocks []*types.Block) (types.LayerID, types.LayerID) {
+	return blocks[0].Layer(), blocks[0].Layer().Sub(1)
 }
 
 type mockState struct{}
@@ -146,7 +147,7 @@ func createMeshWithMock(dbs *allDbs, txpool *state.TxMempool, lg log.Log) *mesh.
 	var msh *mesh.Mesh
 	if dbs.mshdb.PersistentData() {
 		lg.Info("persistent data found")
-		msh = mesh.NewRecoveredMesh(dbs.mshdb, dbs.atxdb, configTst(), &meshValidatorMock{}, txpool, &mockState{}, lg)
+		msh = mesh.NewRecoveredMesh(context.TODO(), dbs.mshdb, dbs.atxdb, configTst(), &meshValidatorMock{}, txpool, &mockState{}, lg)
 	} else {
 		lg.Info("no persistent data found")
 		msh = mesh.NewMesh(dbs.mshdb, dbs.atxdb, configTst(), &meshValidatorMock{}, txpool, &mockState{}, lg)
diff --git a/cmd/sync/sync.go b/cmd/sync/sync.go
index 0eef7e17639..9fe953f8ea7 100644
--- a/cmd/sync/sync.go
+++ b/cmd/sync/sync.go
@@ -187,7 +187,7 @@ func (app *syncApp) start(_ *cobra.Command, _ []string) {
 			}
 		} else {
 			lg.With().Info("loaded layer from disk", types.NewLayerID(i))
-			msh.ValidateLayer(lyr)
+			msh.ValidateLayer(cmdp.Ctx, lyr)
 		}
 	}
 
@@ -203,7 +203,7 @@ func (app *syncApp) start(_ *cobra.Command, _ []string) {
 
 	lg.Event().Info("sync done",
 		log.String("node_id", app.BaseApp.Config.P2P.NodeID),
-		log.FieldNamed("verified_layers", msh.ProcessedLayer()),
+		log.FieldNamed("processed", msh.ProcessedLayer()),
 	)
 	app.sync.Close()
 	for {
diff --git a/common/types/activation.go b/common/types/activation.go
index ac3d3ee1548..6323185e991 100644
--- a/common/types/activation.go
+++ b/common/types/activation.go
@@ -5,7 +5,6 @@ import (
 	"encoding/hex"
 	"fmt"
 	"sort"
-	"strings"
 
 	poetShared "github.com/spacemeshos/poet/shared"
 	postShared "github.com/spacemeshos/post/shared"
@@ -66,19 +65,6 @@ func (t ATXID) Compare(other ATXID) bool {
 	return bytes.Compare(t.Bytes(), other.Bytes()) < 0
 }
 
-// CalcAtxHash32Presorted returns the 32-byte sha256 sum of the Atx IDs, in the order given. The pre-image is
-// prefixed with additionalBytes.
-func CalcAtxHash32Presorted(sortedView []ATXID, additionalBytes []byte) Hash32 {
-	hash := sha256.New()
-	hash.Write(additionalBytes)
-	for _, id := range sortedView {
-		hash.Write(id.Bytes()) // this never returns an error: https://golang.org/pkg/hash/#Hash
-	}
-	var res Hash32
-	hash.Sum(res[:0])
-	return res
-}
-
 // EmptyATXID is a canonical empty ATXID.
 var EmptyATXID = &ATXID{}
 
@@ -236,15 +222,6 @@ func (atx *ActivationTx) Fields(size int) []log.LoggableField {
 	}
 }
 
-// AtxIdsField returns a list of loggable fields for a given list of ATXIDs
-func AtxIdsField(ids []ATXID) log.Field {
-	strs := []string{}
-	for _, a := range ids {
-		strs = append(strs, a.ShortString())
-	}
-	return log.String("atx_ids", strings.Join(strs, ", "))
-}
-
 // CalcAndSetID calculates and sets the cached ID field. This field must be set before calling the ID() method.
 func (atx *ActivationTx) CalcAndSetID() {
 	id := ATXID(CalcATXHash32(atx))
@@ -362,12 +339,3 @@ func SortAtxIDs(ids []ATXID) []ATXID {
 	sort.Slice(ids, func(i, j int) bool { return ids[i].Compare(ids[j]) })
 	return ids
 }
-
-// CalcATXIdsHash32 returns the 32-byte sha256 sum of the atx IDs, sorted in lexicographic order. The pre-image is
-// prefixed with additionalBytes.
-func CalcATXIdsHash32(view []ATXID, additionalBytes []byte) Hash32 {
-	sortedView := make([]ATXID, len(view))
-	copy(sortedView, view)
-	SortAtxIDs(sortedView)
-	return CalcAtxHash32Presorted(sortedView, additionalBytes)
-}
diff --git a/common/types/block.go b/common/types/block.go
index 90b00664cc1..7a701d838d7 100644
--- a/common/types/block.go
+++ b/common/types/block.go
@@ -40,12 +40,12 @@ func (id BlockID) AsHash32() Hash32 {
 
 var (
 	layersPerEpoch uint32
-	// effectiveGenesis marks when actual blocks would start being created in the network, this will take into account the first
-	// genesis epoch and the following epoch in which ATXs are published
+	// effectiveGenesis marks when actual blocks would start being created in the network. It takes into account
+	// the first genesis epoch and the following epoch in which ATXs are published.
 	effectiveGenesis uint32
 )
 
-// SetLayersPerEpoch sets global parameter of layers per epoch, all conversion from layer to epoch use this param
+// SetLayersPerEpoch sets global parameter of layers per epoch, all conversions from layer to epoch use this param
 func SetLayersPerEpoch(layers uint32) {
 	atomic.StoreUint32(&layersPerEpoch, layers)
 	atomic.StoreUint32(&effectiveGenesis, layers*2-1)
@@ -238,13 +238,18 @@ type BlockHeader struct {
 	ATXID            ATXID
 	EligibilityProof BlockEligibilityProof
 	Data             []byte
-	Coin             bool
 
 	BaseBlock BlockID
 
-	AgainstDiff []BlockID
-	ForDiff     []BlockID
-	NeutralDiff []BlockID
+	AgainstDiff []BlockID // base block explicitly supports a block that we want to vote against
+	ForDiff     []BlockID // any additional blocks we want to support that base block doesn't (incl. in newer layers)
+	NeutralDiff []BlockID // blocks that the base block is explicitly for or against for which we are neutral.
+	// NOTE on neutral votes: a base block is by default neutral on all blocks and layers that come after it, so
+	// there's no need to explicitly add neutral votes for more recent layers.
+	// TODO: optimize this data structure in two ways:
+	//   - neutral votes are only ever for an entire layer, never for a subset of blocks.
+	//   - collapse AgainstDiff and ForDiff into a single list.
+	//   see https://github.com/spacemeshos/go-spacemesh/issues/2369.
 }
 
 // Layer returns the block's LayerID.
@@ -256,8 +261,7 @@ func (b BlockHeader) Layer() LayerID {
 // produce the block signature.
 type MiniBlock struct {
 	BlockHeader
-	TxIDs []TransactionID
-	// ATXIDs    []ATXID
+	TxIDs     []TransactionID
 	ActiveSet *[]ATXID
 	RefBlock  *BlockID
 }
@@ -372,7 +376,7 @@ func BlockIDs(blocks []*Block) []BlockID {
 
 // BlockIdsField returns a list of loggable fields for a given list of BlockIDs
 func BlockIdsField(ids []BlockID) log.Field {
-	strs := []string{}
+	var strs []string
 	for _, a := range ids {
 		strs = append(strs, a.String())
 	}
@@ -401,6 +405,15 @@ func (l *Layer) Blocks() []*Block {
 	return l.blocks
 }
 
+// BlocksIDs returns the list of IDs of blocks in this layer.
+func (l *Layer) BlocksIDs() []BlockID {
+	blockIDs := make([]BlockID, len(l.blocks))
+	for i := range l.blocks {
+		blockIDs[i] = l.blocks[i].ID()
+	}
+	return blockIDs
+}
+
 // Hash returns the 32-byte sha256 sum of the block IDs of both contextually valid and invalid blocks in this layer,
 // sorted in lexicographic order.
 func (l Layer) Hash() Hash32 {
diff --git a/config/config.go b/config/config.go
index b8deb9aea99..91e87dc24cd 100644
--- a/config/config.go
+++ b/config/config.go
@@ -30,9 +30,8 @@ const (
 )
 
 var (
-	defaultHomeDir  = filesystem.GetUserHomeDirectory()
-	defaultDataDir  = filepath.Join(defaultHomeDir, defaultDataDirName, "/")
-	defaultTestMode = false
+	defaultHomeDir = filesystem.GetUserHomeDirectory()
+	defaultDataDir = filepath.Join(defaultHomeDir, defaultDataDirName, "/")
 )
 
 // Config defines the top level configuration for a spacemesh node
@@ -83,7 +82,15 @@ type BaseConfig struct {
 	LayerDurationSec int    `mapstructure:"layer-duration-sec"`
 	LayerAvgSize     int    `mapstructure:"layer-average-size"`
 	LayersPerEpoch   uint32 `mapstructure:"layers-per-epoch"`
-	Hdist            uint32 `mapstructure:"hdist"`
+	Hdist            uint32 `mapstructure:"hdist"`                     // hare/input vector lookback distance
+	Zdist            uint32 `mapstructure:"zdist"`                     // hare result wait distance
+	ConfidenceParam  uint32 `mapstructure:"tortoise-confidence-param"` // layers to wait for global consensus
+	WindowSize       uint32 `mapstructure:"tortoise-window-size"`      // size of the tortoise sliding window (in layers)
+	GlobalThreshold  uint8  `mapstructure:"tortoise-global-threshold"` // threshold for finalizing blocks and layers
+	LocalThreshold   uint8  `mapstructure:"tortoise-local-threshold"`  // threshold for choosing when to use weak coin
+
+	// how often we rerun tortoise from scratch, in minutes
+	TortoiseRerunInterval uint32 `mapstructure:"tortoise-rerun-interval"`
 
 	PoETServer string `mapstructure:"poet-server"`
 
@@ -180,29 +187,35 @@ func DefaultTestConfig() Config {
 // DefaultBaseConfig returns a default configuration for spacemesh
 func defaultBaseConfig() BaseConfig {
 	return BaseConfig{
-		DataDirParent:       defaultDataDir,
-		ConfigFile:          defaultConfigFileName,
-		TestMode:            defaultTestMode,
-		CollectMetrics:      false,
-		MetricsPort:         1010,
-		MetricsPush:         "", // "" = doesn't push
-		MetricsPushPeriod:   60,
-		ProfilerURL:         "",
-		ProfilerName:        "gp-spacemesh",
-		OracleServer:        "http://localhost:3030",
-		OracleServerWorldID: 0,
-		GenesisTime:         time.Now().Format(time.RFC3339),
-		LayerDurationSec:    30,
-		LayersPerEpoch:      3,
-		PoETServer:          "127.0.0.1",
-		GoldenATXID:         "0x5678", // TODO: Change the value
-		Hdist:               5,
-		BlockCacheSize:      20,
-		SyncRequestTimeout:  2000,
-		SyncInterval:        10,
-		SyncValidationDelta: 300,
-		AtxsPerBlock:        100,
-		TxsPerBlock:         100,
+		DataDirParent:         defaultDataDir,
+		ConfigFile:            defaultConfigFileName,
+		TestMode:              false,
+		CollectMetrics:        false,
+		MetricsPort:           1010,
+		MetricsPush:           "", // "" = doesn't push
+		MetricsPushPeriod:     60,
+		ProfilerURL:           "",
+		ProfilerName:          "gp-spacemesh",
+		OracleServer:          "http://localhost:3030",
+		OracleServerWorldID:   0,
+		GenesisTime:           time.Now().Format(time.RFC3339),
+		LayerDurationSec:      30,
+		LayersPerEpoch:        3,
+		PoETServer:            "127.0.0.1",
+		GoldenATXID:           "0x5678", // TODO: Change the value
+		Hdist:                 10,
+		Zdist:                 5,
+		ConfidenceParam:       5,
+		WindowSize:            100,     // should be "a few thousand layers" in production
+		GlobalThreshold:       60,      // in percentage terms, must be in interval [0, 100]
+		LocalThreshold:        20,      // in percentage terms, must be in interval [0, 100]
+		TortoiseRerunInterval: 60 * 24, // in minutes, once per day
+		BlockCacheSize:        20,
+		SyncRequestTimeout:    2000,
+		SyncInterval:          10,
+		SyncValidationDelta:   300,
+		AtxsPerBlock:          100,
+		TxsPerBlock:           100,
 	}
 }
 
diff --git a/database/database.go b/database/database.go
index 2a1576b5293..a52c517d39f 100644
--- a/database/database.go
+++ b/database/database.go
@@ -61,7 +61,7 @@ func NewLDBDatabase(file string, cache int, handles int, logger log.Log) (*LDBDa
 	if handles < 16 {
 		handles = 16
 	}
-	logger.With().Info("Allocated cache and file handles",
+	logger.With().Info("allocated cache and file handles",
 		log.Int("cache_size", cache),
 		log.Int("num_handles", handles))
 
diff --git a/database/interface.go b/database/interface.go
index 307787bebb1..7b63fc02722 100644
--- a/database/interface.go
+++ b/database/interface.go
@@ -114,8 +114,8 @@ func SwitchCreationContext(path, context string) {
 	Create = c.CreateRealDB
 }
 
-// SwitchToMemCreationContext switches global DB creation function to create memory DBs (this funciton should be called in
-// tests 'init' function
+// SwitchToMemCreationContext switches global DB creation function to create memory DBs (this function should be called
+// in tests 'init' function)
 func SwitchToMemCreationContext() {
 	var c = ContextDBCreator{}
 	Create = c.CreateMemDB
diff --git a/events/reporter.go b/events/reporter.go
index e2eb62bced9..f1be41fa2d7 100644
--- a/events/reporter.go
+++ b/events/reporter.go
@@ -174,21 +174,21 @@ func ReportCalculatedTortoiseBeacon(epoch types.EpochID, beacon string) {
 	})
 }
 
-// ReportNewLayer reports a new layer
-func ReportNewLayer(layer NewLayer) {
+// ReportLayerUpdate reports a new layer, or an update to an existing layer
+func ReportLayerUpdate(layer LayerUpdate) {
 	mu.RLock()
 	defer mu.RUnlock()
 
 	if reporter != nil {
 		if reporter.blocking {
 			reporter.channelLayer <- layer
-			log.With().Debug("reported new layer", layer)
+			log.With().Debug("reported new or updated layer", layer)
 		} else {
 			select {
 			case reporter.channelLayer <- layer:
-				log.With().Debug("reported new layer", layer)
+				log.With().Debug("reported new or updated layer", layer)
 			default:
-				log.With().Debug("not reporting new layer as no one is listening", layer)
+				log.With().Debug("not reporting new or updated layer as no one is listening", layer)
 			}
 		}
 	}
@@ -308,7 +308,7 @@ func GetActivationsChannel() chan *types.ActivationTx {
 }
 
 // GetLayerChannel returns a channel of all layer data
-func GetLayerChannel() chan NewLayer {
+func GetLayerChannel() chan LayerUpdate {
 	mu.RLock()
 	defer mu.RUnlock()
 
@@ -418,24 +418,22 @@ func SubscribeToLayers(newLayerCh timesync.LayerTimer) {
 }
 
 // The status of a layer
+// TODO: this list is woefully inadequate and does not map to reality. See https://github.com/spacemeshos/api/issues/144.
 const (
 	LayerStatusTypeUnknown   = iota
 	LayerStatusTypeApproved  // approved by Hare
 	LayerStatusTypeConfirmed // confirmed by Tortoise
 )
 
-// NewLayer packages up a layer with its status (which a layer does not
-// ordinarily contain)
-type NewLayer struct {
-	Layer  *types.Layer
-	Status int
+// LayerUpdate packages up a layer with its status (which a layer does not ordinarily contain)
+type LayerUpdate struct {
+	LayerID types.LayerID
+	Status  int
 }
 
 // Field returns a log field. Implements the LoggableField interface.
-func (nl NewLayer) Field() log.Field {
-	return log.String("layer",
-		fmt.Sprintf("status: %d, number: %d, numblocks: %d",
-			nl.Status, nl.Layer.Index(), len(nl.Layer.Blocks())))
+func (nl LayerUpdate) Field() log.Field {
+	return log.String("layer", fmt.Sprintf("status: %d, number: %d", nl.Status, nl.LayerID))
 }
 
 // NodeError represents an internal error to be reported
@@ -478,7 +476,7 @@ type TransactionWithValidity struct {
 type EventReporter struct {
 	channelTransaction chan TransactionWithValidity
 	channelActivation  chan *types.ActivationTx
-	channelLayer       chan NewLayer
+	channelLayer       chan LayerUpdate
 	channelError       chan NodeError
 	channelStatus      chan struct{}
 	channelAccount     chan types.Address
@@ -492,7 +490,7 @@ func newEventReporter(bufsize int, blocking bool) *EventReporter {
 	return &EventReporter{
 		channelTransaction: make(chan TransactionWithValidity, bufsize),
 		channelActivation:  make(chan *types.ActivationTx, bufsize),
-		channelLayer:       make(chan NewLayer, bufsize),
+		channelLayer:       make(chan LayerUpdate, bufsize),
 		channelStatus:      make(chan struct{}, bufsize),
 		channelAccount:     make(chan types.Address, bufsize),
 		channelReward:      make(chan Reward, bufsize),
diff --git a/fetch/fetch.go b/fetch/fetch.go
index b302cec83d3..4e3a29e68bc 100644
--- a/fetch/fetch.go
+++ b/fetch/fetch.go
@@ -128,7 +128,7 @@ type responseBatch struct {
 // Config is the configuration file of the Fetch component
 type Config struct {
 	BatchTimeout         int // in milliseconds
-	MaxRetiresForPeer    int
+	MaxRetriesForPeer    int
 	BatchSize            int
 	RequestTimeout       int // in seconds
 	MaxRetriesForRequest int
@@ -138,7 +138,7 @@ type Config struct {
 func DefaultConfig() Config {
 	return Config{
 		BatchTimeout:         50,
-		MaxRetiresForPeer:    2,
+		MaxRetriesForPeer:    2,
 		BatchSize:            20,
 		RequestTimeout:       10,
 		MaxRetriesForRequest: 20,
@@ -147,6 +147,8 @@ func DefaultConfig() Config {
 
 type peersProvider interface {
 	GetPeers() []peers.Peer
+	PeerCount() uint64
+	Close()
 }
 
 // MessageNetwork is a network interface that allows fetch to communicate with other nodes with 'fetch servers'
@@ -156,6 +158,12 @@ type MessageNetwork struct {
 	log.Log
 }
 
+// Close closes the message network
+func (mn MessageNetwork) Close() {
+	mn.MessageServer.Close()
+	mn.peersProvider.Close()
+}
+
 // NewMessageNetwork creates a new instance of the fetch network server
 func NewMessageNetwork(ctx context.Context, requestTimeOut int, net service.Service, protocol string, log log.Log) *MessageNetwork {
 	return &MessageNetwork{
@@ -168,18 +176,19 @@ func NewMessageNetwork(ctx context.Context, requestTimeOut int, net service.Serv
 // GetRandomPeer returns a random peer from current peer list
 func GetRandomPeer(peers []peers.Peer) peers.Peer {
 	if len(peers) == 0 {
-		log.Panic("cannot send fetch - no peers found")
+		log.Panic("cannot send fetch: no peers found")
 	}
 	return peers[rand.Intn(len(peers))]
 }
 
 // GetPeers return active peers
-func (f MessageNetwork) GetPeers() []peers.Peer {
-	return f.peersProvider.GetPeers()
+func (mn MessageNetwork) GetPeers() []peers.Peer {
+	return mn.peersProvider.GetPeers()
 }
 
 type network interface {
 	GetPeers() []peers.Peer
+	PeerCount() uint64
 	SendRequest(ctx context.Context, msgType server.MessageType, payload []byte, address p2pcrypto.PublicKey, resHandler func(msg []byte), failHandler func(err error)) error
 	RegisterBytesMsgHandler(msgType server.MessageType, reqHandler func(ctx context.Context, b []byte) []byte)
 	Close()
@@ -203,7 +212,6 @@ type Fetch struct {
 	stop                 chan struct{}
 	activeReqM           sync.RWMutex
 	activeBatchM         sync.RWMutex
-	stopM                sync.RWMutex
 	onlyOnce             sync.Once
 	doneChan             chan struct{}
 	dbLock               sync.RWMutex
@@ -242,8 +250,8 @@ func (f *Fetch) Start() {
 func (f *Fetch) Stop() {
 	f.log.Info("stopping fetch")
 	f.batchTimeout.Stop()
-	f.net.Close()
 	close(f.stop)
+	f.net.Close()
 	f.activeReqM.Lock()
 	for _, batch := range f.activeRequests {
 		for _, req := range batch {
@@ -355,12 +363,12 @@ func (f *Fetch) FetchRequestHandler(ctx context.Context, data []byte) []byte {
 		db, ok := f.dbs[r.Hint]
 		f.dbLock.RUnlock()
 		if !ok {
-			f.log.WithContext(ctx).With().Warning("db not found", log.String("hint", string(r.Hint)))
+			f.log.WithContext(ctx).With().Warning("hint not found in database", log.String("hint", string(r.Hint)))
 			continue
 		}
 		res, err := db.Get(r.Hash.Bytes())
 		if err != nil {
-			f.log.WithContext(ctx).With().Info("remote peer requested non existing hash",
+			f.log.WithContext(ctx).With().Info("remote peer requested nonexistent hash",
 				log.String("hash", r.Hash.ShortString()),
 				log.String("hint", string(r.Hint)),
 				log.Err(err))
@@ -380,14 +388,14 @@ func (f *Fetch) FetchRequestHandler(ctx context.Context, data []byte) []byte {
 
 	bts, err := types.InterfaceToBytes(&resBatch)
 	if err != nil {
-		f.log.WithContext(ctx).With().Error("cannot parse message for batch ID",
-			log.String("batchHash", resBatch.ID.ShortString()))
+		f.log.WithContext(ctx).With().Error("cannot parse message for batch id",
+			log.String("batch_hash", resBatch.ID.ShortString()))
 		return nil
 	}
 	f.log.WithContext(ctx).With().Debug("returning response for batch",
-		log.String("batchHash", resBatch.ID.ShortString()),
-		log.Int("numResponse", len(resBatch.Responses)),
-		log.Int("dataSize", len(bts)))
+		log.String("batch_hash", resBatch.ID.ShortString()),
+		log.Int("count_responses", len(resBatch.Responses)),
+		log.Int("data_size", len(bts)))
 	return bts
 }
 
@@ -447,7 +455,8 @@ func (f *Fetch) receiveResponse(data []byte) {
 		f.activeReqM.Unlock()
 	}
 
-	// iterate all requests that didn't return value from peer and notify - they will be retried for MaxRetriesForRequest
+	// iterate all requests that didn't return value from peer and notify
+	// they will be retried for MaxRetriesForRequest
 	err = fmt.Errorf("failed to fetch hash after max retries")
 	for h := range batchMap {
 		if f.stopped() {
@@ -463,7 +472,8 @@ func (f *Fetch) receiveResponse(data []byte) {
 		for _, req := range reqs {
 			req.retries++
 			if req.retries > f.cfg.MaxRetriesForRequest {
-				f.log.With().Debug("gave up on hash after max retries", log.String("hash", req.hash.ShortString()))
+				f.log.With().Debug("gave up on hash after max retries",
+					log.String("hash", req.hash.ShortString()))
 				req.returnChan <- HashDataPromiseResult{
 					Err:     ErrExceedMaxRetries,
 					Hash:    req.hash,
@@ -524,7 +534,7 @@ func (f *Fetch) sendBatch(requests []requestMessage) {
 	f.activeBatchM.Unlock()
 	// timeout function will be called if no response was received for the hashes sent
 	timeoutFunc := func(err error) {
-		f.log.With().Error("request timed out", log.String("batchHash", batch.ID.ShortString()))
+		f.log.With().Error("request timed out", log.String("batch_hash", batch.ID.ShortString()))
 		f.handleHashError(batch.ID, err)
 	}
 
@@ -540,21 +550,29 @@ func (f *Fetch) sendBatch(requests []requestMessage) {
 			return
 		}
 
+		if f.net.PeerCount() == 0 {
+			f.log.With().Error("no peers found, unable to send request batch",
+				batch.ID,
+				log.Int("items", len(batch.Requests)))
+			return
+		}
+
 		// get random peer
 		p = GetRandomPeer(f.net.GetPeers())
 		f.log.With().Debug("sending request batch to peer",
-			log.String("batchHash", batch.ID.ShortString()),
-			log.Int("numRequests", len(batch.Requests)),
+			log.String("batch_hash", batch.ID.ShortString()),
+			log.Int("num_requests", len(batch.Requests)),
 			log.String("peer", p.String()))
 		batch.peer = p
 		f.activeBatchM.Lock()
 		f.activeBatches[batch.ID] = batch
 		f.activeBatchM.Unlock()
 		err := f.net.SendRequest(context.TODO(), server.Fetch, bytes, p, f.receiveResponse, timeoutFunc)
+
 		// if call succeeded, continue to other requests
 		if err != nil {
 			retries++
-			if retries > f.cfg.MaxRetiresForPeer {
+			if retries > f.cfg.MaxRetriesForPeer {
 				f.handleHashError(batch.ID, ErrCouldNotSend(fmt.Errorf("could not send message: %w", err)))
 				break
 			}
@@ -638,7 +656,8 @@ func (f *Fetch) GetHash(hash types.Hash32, h Hint, validateHash bool) chan HashD
 	db, ok := f.dbs[h]
 	f.dbLock.RUnlock()
 	if !ok {
-		f.log.With().Panic("tried to fetch Data from DB that doesn't exist locally", log.String("hint", string(h)))
+		f.log.With().Panic("tried to fetch Data from DB that doesn't exist locally",
+			log.String("hint", string(h)))
 	}
 
 	if b, err := db.Get(hash.Bytes()); err == nil {
diff --git a/fetch/fetch_test.go b/fetch/fetch_test.go
index 585ee49f0a6..8a39e0c2efa 100644
--- a/fetch/fetch_test.go
+++ b/fetch/fetch_test.go
@@ -35,10 +35,10 @@ type mockNet struct {
 func (m mockNet) Close() {
 }
 
-func (m mockNet) RegisterBytesMsgHandler(msgType server.MessageType, reqHandler func(context.Context, []byte) []byte) {
+func (m mockNet) RegisterBytesMsgHandler(_ server.MessageType, reqHandler func(context.Context, []byte) []byte) {
 }
 
-func (m mockNet) Start(ctx context.Context) error {
+func (m mockNet) Start(context.Context) error {
 	return nil
 }
 
@@ -60,7 +60,7 @@ func (m mockNet) SubscribePeerEvents() (new chan p2pcrypto.PublicKey, del chan p
 	return nil, nil
 }
 
-func (m mockNet) Broadcast(ctx context.Context, protocol string, payload []byte) error {
+func (m mockNet) Broadcast(_ context.Context, protocol string, payload []byte) error {
 	return nil
 }
 
@@ -71,15 +71,20 @@ func (m mockNet) RegisterDirectProtocolWithChannel(protocol string, ingressChann
 	return nil
 }
 
-func (m mockNet) SendWrappedMessage(ctx context.Context, nodeID p2pcrypto.PublicKey, protocol string, payload *service.DataMsgWrapper) error {
+func (m mockNet) SendWrappedMessage(_ context.Context, nodeID p2pcrypto.PublicKey, protocol string, payload *service.DataMsgWrapper) error {
 	return nil
 }
 
+func (m mockNet) PeerCount() uint64 {
+	return 1
+}
+
 func (m mockNet) GetPeers() []peers.Peer {
 	_, pub1, _ := p2pcrypto.GenerateKeyPair()
 	return []peers.Peer{pub1}
 }
-func (m *mockNet) SendRequest(ctx context.Context, msgType server.MessageType, payload []byte, address p2pcrypto.PublicKey, resHandler func(msg []byte), failHandler func(err error)) error {
+
+func (m *mockNet) SendRequest(_ context.Context, msgType server.MessageType, payload []byte, address p2pcrypto.PublicKey, resHandler func(msg []byte), failHandler func(err error)) error {
 	m.TotalBatchCalls++
 	if m.ReturnError {
 		if m.AckChannel != nil {
@@ -272,7 +277,7 @@ func TestFetch_GetHash_failNetwork(t *testing.T) {
 		priority:             0,
 		validateResponseHash: false,
 		hint:                 hint,
-		returnChan:           make(chan HashDataPromiseResult, f.cfg.MaxRetiresForPeer),
+		returnChan:           make(chan HashDataPromiseResult, f.cfg.MaxRetriesForPeer),
 	}
 	f.activeRequests[h1] = []*request{&request1, &request1, &request1}
 	f.requestHashBatchFromPeers()
@@ -288,7 +293,7 @@ func TestFetch_Loop_BatchRequestMax(t *testing.T) {
 	h3 := randomHash()
 	f, net := customFetch(t, Config{
 		BatchTimeout:      1,
-		MaxRetiresForPeer: 2,
+		MaxRetriesForPeer: 2,
 		BatchSize:         2,
 	})
 
@@ -372,7 +377,7 @@ func TestFetch_handleNewRequest_MultipleReqsForSameHashHighPriority(t *testing.T
 	req5 := makeRequest(hash3, High, hint)
 	f, net := customFetch(t, Config{
 		BatchTimeout:      1,
-		MaxRetiresForPeer: 2,
+		MaxRetriesForPeer: 2,
 		BatchSize:         2,
 	})
 
@@ -444,14 +449,14 @@ func TestFetch_handleNewRequest_MultipleReqsForSameHashHighPriority(t *testing.T
 }
 
 func TestFetch_GetRandomPeer(t *testing.T) {
-	peers := make([]peers.Peer, 1000)
-	for i := 0; i < len(peers); i++ {
+	myPeers := make([]peers.Peer, 1000)
+	for i := 0; i < len(myPeers); i++ {
 		_, pub, _ := p2pcrypto.GenerateKeyPair()
-		peers[i] = pub
+		myPeers[i] = pub
 	}
 	allTheSame := true
 	for i := 0; i < 20; i++ {
-		if GetRandomPeer(peers) != GetRandomPeer(peers) {
+		if GetRandomPeer(myPeers) != GetRandomPeer(myPeers) {
 			allTheSame = false
 		}
 	}
diff --git a/hare/eligibility/beacon.go b/hare/eligibility/beacon.go
index 2ffe6d8b78d..2c9ce9cd009 100644
--- a/hare/eligibility/beacon.go
+++ b/hare/eligibility/beacon.go
@@ -27,9 +27,9 @@ type Beacon struct {
 // NewBeacon returns a new beacon
 // confidenceParam is the number of layers that the Beacon assumes for consensus view.
 func NewBeacon(beaconGetter blocks.BeaconGetter, confidenceParam uint32, logger log.Log) *Beacon {
-	c, e := lru.New(activesCacheSize)
-	if e != nil {
-		logger.Panic("could not create lru cache, err: %v", e)
+	c, err := lru.New(activesCacheSize)
+	if err != nil {
+		logger.With().Panic("could not create lru cache", log.Err(err))
 	}
 	return &Beacon{
 		beaconGetter:    beaconGetter,
@@ -41,7 +41,6 @@ func NewBeacon(beaconGetter blocks.BeaconGetter, confidenceParam uint32, logger
 
 // Value returns the beacon value for an epoch
 // Note: Value is concurrency-safe but not concurrency-optimized
-// TODO: does this ever return an error? If not, remove it
 func (b *Beacon) Value(ctx context.Context, epochID types.EpochID) (uint32, error) {
 	// check cache
 	if val, ok := b.cache.Get(epochID); ok {
diff --git a/hare/flows_test.go b/hare/flows_test.go
index 2547be5be37..b234e0999fe 100644
--- a/hare/flows_test.go
+++ b/hare/flows_test.go
@@ -183,10 +183,6 @@ func Test_consensusIterations(t *testing.T) {
 	test.WaitForTimedTermination(t, 30*time.Second)
 }
 
-func validateBlock([]types.BlockID) bool {
-	return true
-}
-
 func isSynced(context.Context) bool {
 	return true
 }
@@ -222,11 +218,14 @@ type mockBlockProvider struct {
 func (mbp *mockBlockProvider) HandleValidatedLayer(context.Context, types.LayerID, []types.BlockID) {
 }
 
-func (mbp *mockBlockProvider) LayerBlockIds(types.LayerID) ([]types.BlockID, error) {
-	return buildSet(), nil
+func (mbp *mockBlockProvider) InvalidateLayer(context.Context, types.LayerID) {
 }
 
-func (mbp *mockBlockProvider) RecordCoinflip(ctx context.Context, layerID types.LayerID, coinflip bool) {
+func (mbp *mockBlockProvider) RecordCoinflip(context.Context, types.LayerID, bool) {
+}
+
+func (mbp *mockBlockProvider) LayerBlockIds(types.LayerID) ([]types.BlockID, error) {
+	return buildSet(), nil
 }
 
 func createMaatuf(tb testing.TB, tcfg config.Config, layersCh chan types.LayerID, p2p NetworkService, rolacle Rolacle, name string) *Hare {
@@ -237,7 +236,7 @@ func createMaatuf(tb testing.TB, tcfg config.Config, layersCh chan types.LayerID
 		panic("failed to create vrf signer")
 	}
 	nodeID := types.NodeID{Key: pub.String(), VRFPublicKey: vrfPub}
-	hare := New(tcfg, p2p, ed, nodeID, validateBlock, isSynced, &mockBlockProvider{}, rolacle, 10, &mockIdentityP{nid: nodeID},
+	hare := New(tcfg, p2p, ed, nodeID, isSynced, &mockBlockProvider{}, rolacle, 10, &mockIdentityP{nid: nodeID},
 		&MockStateQuerier{true, nil}, layersCh, logtest.New(tb).WithName(name+"_"+ed.PublicKey().ShortString()))
 
 	return hare
diff --git a/hare/hare.go b/hare/hare.go
index ea5dd92d772..abdf34ffa99 100644
--- a/hare/hare.go
+++ b/hare/hare.go
@@ -39,15 +39,16 @@ type TerminationOutput interface {
 }
 
 type meshProvider interface {
+	// LayerBlockIds returns the block IDs stored for a layer
 	LayerBlockIds(layerID types.LayerID) ([]types.BlockID, error)
+	// HandleValidatedLayer receives Hare output when it succeeds
 	HandleValidatedLayer(ctx context.Context, validatedLayer types.LayerID, layer []types.BlockID)
+	// InvalidateLayer receives the signal that Hare failed for a layer
+	InvalidateLayer(ctx context.Context, layerID types.LayerID)
 	// RecordCoinflip records the weak coinflip result for a layer
 	RecordCoinflip(ctx context.Context, layerID types.LayerID, coinflip bool)
 }
 
-// checks if the collected output is valid
-type outputValidationFunc func(blocks []types.BlockID) bool
-
 // Hare is the orchestrator that starts new consensus processes and collects their output.
 type Hare struct {
 	util.Closer
@@ -61,7 +62,7 @@ type Hare struct {
 
 	sign Signer
 
-	msh     meshProvider
+	mesh    meshProvider
 	rolacle Rolacle
 
 	networkDelta time.Duration
@@ -77,18 +78,26 @@ type Hare struct {
 
 	factory consensusFactory
 
-	validate outputValidationFunc
-
 	nid types.NodeID
 
 	totalCPs int32
 }
 
 // New returns a new Hare struct.
-func New(conf config.Config, p2p NetworkService, sign Signer, nid types.NodeID, validate outputValidationFunc,
-	syncState syncStateFunc, obp meshProvider, rolacle Rolacle,
-	layersPerEpoch uint16, idProvider identityProvider, stateQ StateQuerier,
-	beginLayer chan types.LayerID, logger log.Log) *Hare {
+func New(
+	conf config.Config,
+	p2p NetworkService,
+	sign Signer,
+	nid types.NodeID,
+	syncState syncStateFunc,
+	mesh meshProvider,
+	rolacle Rolacle,
+	layersPerEpoch uint16,
+	idProvider identityProvider,
+	stateQ StateQuerier,
+	beginLayer chan types.LayerID,
+	logger log.Log,
+) *Hare {
 	h := new(Hare)
 
 	h.Closer = util.NewCloser()
@@ -101,7 +110,8 @@ func New(conf config.Config, p2p NetworkService, sign Signer, nid types.NodeID,
 	ev := newEligibilityValidator(rolacle, layersPerEpoch, idProvider, conf.N, conf.ExpectedLeaders, logger)
 	h.broker = newBroker(p2p, ev, stateQ, syncState, layersPerEpoch, conf.LimitConcurrent, h.Closer, logger)
 	h.sign = sign
-	h.msh = obp
+
+	h.mesh = mesh
 	h.rolacle = rolacle
 
 	h.networkDelta = time.Duration(conf.WakeupDelta) * time.Second
@@ -113,7 +123,6 @@ func New(conf config.Config, p2p NetworkService, sign Signer, nid types.NodeID,
 		return newConsensusProcess(conf, instanceId, s, oracle, stateQ, layersPerEpoch, signing, nid, p2p, terminationReport, ev, logger)
 	}
 
-	h.validate = validate
 	h.nid = nid
 
 	return h
@@ -163,13 +172,9 @@ func (h *Hare) collectOutput(ctx context.Context, output TerminationOutput) erro
 		i++
 	}
 
-	// check validity of the collected output
-	if !h.validate(blocks) {
-		h.WithContext(ctx).Error("failed to validate the collected output set")
-	}
-
 	id := output.ID()
-	h.msh.HandleValidatedLayer(ctx, types.LayerID(id), blocks)
+	h.mesh.HandleValidatedLayer(ctx, id, blocks)
+
 	if h.outOfBufferRange(id) {
 		return ErrTooLate
 	}
@@ -179,7 +184,7 @@ func (h *Hare) collectOutput(ctx context.Context, output TerminationOutput) erro
 	if uint32(len(h.outputs)) >= h.bufferSize {
 		delete(h.outputs, h.oldestResultInBuffer())
 	}
-	h.outputs[types.LayerID(id)] = blocks
+	h.outputs[id] = blocks
 
 	return nil
 }
@@ -187,7 +192,6 @@ func (h *Hare) collectOutput(ctx context.Context, output TerminationOutput) erro
 // the logic that happens when a new layer arrives.
 // this function triggers the start of new consensus processes.
 func (h *Hare) onTick(ctx context.Context, id types.LayerID) (err error) {
-
 	logger := h.WithContext(ctx).WithFields(id)
 	h.layerLock.Lock()
 	if id.After(h.lastLayer) {
@@ -244,7 +248,7 @@ func (h *Hare) onTick(ctx context.Context, id types.LayerID) (err error) {
 	logger.Debug("get hare results")
 
 	// retrieve set from orphan blocks
-	blocks, err := h.msh.LayerBlockIds(h.lastLayer)
+	blocks, err := h.mesh.LayerBlockIds(h.lastLayer)
 	if err != nil {
 		logger.With().Error("no blocks found for hare, using empty set", log.Err(err))
 		// just fail here, it will end hare with empty set result
@@ -254,10 +258,7 @@ func (h *Hare) onTick(ctx context.Context, id types.LayerID) (err error) {
 	}
 
 	logger.With().Debug("received new blocks", log.Int("count", len(blocks)))
-	set := NewEmptySet(len(blocks))
-	for _, b := range blocks {
-		set.Add(b)
-	}
+	set := NewSet(blocks)
 
 	instID := id
 	c, err := h.broker.Register(ctx, instID)
@@ -272,7 +273,7 @@ func (h *Hare) onTick(ctx context.Context, id types.LayerID) (err error) {
 		h.broker.Unregister(ctx, cp.ID())
 		return
 	}
-	logger.With().Info("number of consensus processes (after +1)",
+	logger.With().Info("number of consensus processes (after register)",
 		log.Int32("count", atomic.AddInt32(&h.totalCPs, 1)))
 	metrics.TotalConsensusProcesses.With("layer", id.String()).Add(1)
 	return
@@ -284,7 +285,7 @@ var (
 )
 
 // GetResult returns the hare output for the provided range.
-// Returns error iff the request for the upper is too old.
+// Returns error if the requested layer is too old.
 func (h *Hare) GetResult(lid types.LayerID) ([]types.BlockID, error) {
 	if h.outOfBufferRange(lid) {
 		return nil, errTooOld
@@ -296,7 +297,6 @@ func (h *Hare) GetResult(lid types.LayerID) ([]types.BlockID, error) {
 	if !ok {
 		return nil, errNoResult
 	}
-
 	return blks, nil
 }
 
@@ -305,14 +305,14 @@ func (h *Hare) outputCollectionLoop(ctx context.Context) {
 	for {
 		select {
 		case out := <-h.outputChan:
-			layerID := types.LayerID(out.ID())
+			layerID := out.ID()
 			coin := out.Coinflip()
 			logger := h.WithContext(ctx).WithFields(layerID)
 
 			// collect coinflip, regardless of success
 			logger.With().Info("recording weak coinflip result for layer",
 				log.Bool("coinflip", coin))
-			h.msh.RecordCoinflip(ctx, layerID, coin)
+			h.mesh.RecordCoinflip(ctx, layerID, coin)
 
 			if out.Completed() { // CP completed, collect the output
 				logger.With().Info("collecting results for completed hare instance", layerID)
@@ -320,8 +320,13 @@ func (h *Hare) outputCollectionLoop(ctx context.Context) {
 					logger.With().Warning("error collecting output from hare", log.Err(err))
 				}
 			}
+			if !out.Completed() {
+				// Notify the mesh that Hare failed
+				h.WithContext(ctx).With().Info("recording hare instance failure", layerID)
+				h.mesh.InvalidateLayer(ctx, layerID)
+			}
 			h.broker.Unregister(ctx, out.ID())
-			logger.With().Info("number of consensus processes (after -1)",
+			logger.With().Info("number of consensus processes (after unregister)",
 				log.Int32("count", atomic.AddInt32(&h.totalCPs, -1)))
 			metrics.TotalConsensusProcesses.With("layer", out.ID().String()).Add(-1)
 		case <-h.CloseChannel():
@@ -335,7 +340,11 @@ func (h *Hare) tickLoop(ctx context.Context) {
 	for {
 		select {
 		case layer := <-h.beginLayer:
-			go h.onTick(ctx, layer)
+			go func() {
+				if err := h.onTick(ctx, layer); err != nil {
+					h.WithContext(ctx).With().Error("error processing hare tick", log.Err(err))
+				}
+			}()
 		case <-h.CloseChannel():
 			return
 		}
diff --git a/hare/hare_rounds_test.go b/hare/hare_rounds_test.go
index ba777f6ccfd..9b259e7fce1 100644
--- a/hare/hare_rounds_test.go
+++ b/hare/hare_rounds_test.go
@@ -83,13 +83,16 @@ func (h *testHare) HandleValidatedLayer(ctx context.Context, layer types.LayerID
 func (h *testHare) LayerBlockIds(layer types.LayerID) ([]types.BlockID, error) {
 	return h.layers(layer, h)
 }
+func (h *testHare) InvalidateLayer(ctx context.Context, layerID types.LayerID) {
+	panic("implement me")
+}
 func (h *testHare) RecordCoinflip(ctx context.Context, layerID types.LayerID, coinflip bool) {}
 
 func createTestHare(tb testing.TB, tcfg config.Config, layersCh chan types.LayerID, p2p NetworkService, rolacle Rolacle, name string, bp meshProvider) *Hare {
 	ed := signing.NewEdSigner()
 	pub := ed.PublicKey()
 	nodeID := types.NodeID{Key: pub.String(), VRFPublicKey: pub.Bytes()}
-	hare := New(tcfg, p2p, ed, nodeID, validateBlock, isSynced, bp, rolacle, 10, &mockIdentityP{nid: nodeID},
+	hare := New(tcfg, p2p, ed, nodeID, isSynced, bp, rolacle, 10, &mockIdentityP{nid: nodeID},
 		&MockStateQuerier{true, nil}, layersCh, logtest.New(tb).WithName(name+"_"+ed.PublicKey().ShortString()))
 	return hare
 }
diff --git a/hare/hare_test.go b/hare/hare_test.go
index b44589d3a57..01c1c25b4e8 100644
--- a/hare/hare_test.go
+++ b/hare/hare_test.go
@@ -21,10 +21,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func validateBlocks([]types.BlockID) bool {
-	return true
-}
-
 type mockReport struct {
 	id       types.LayerID
 	set      *Set
@@ -56,7 +52,7 @@ type mockConsensusProcess struct {
 	set  *Set
 }
 
-func (mcp *mockConsensusProcess) Start(ctx context.Context) error {
+func (mcp *mockConsensusProcess) Start(context.Context) error {
 	if mcp.term != nil {
 		<-mcp.term
 	}
@@ -90,7 +86,7 @@ func newMockConsensusProcess(cfg config.Config, instanceID types.LayerID, s *Set
 }
 
 func createHare(n1 p2p.Service, logger log.Log) *Hare {
-	return New(cfg, n1, signing2.NewEdSigner(), types.NodeID{}, validateBlocks, (&mockSyncer{true}).IsSynced, new(orphanMock), eligibility.New(logger), 10, &mockIDProvider{}, NewMockStateQuerier(), make(chan types.LayerID), logger)
+	return New(cfg, n1, signing2.NewEdSigner(), types.NodeID{}, (&mockSyncer{true}).IsSynced, new(orphanMock), eligibility.New(logger), 10, &mockIDProvider{}, NewMockStateQuerier(), make(chan types.LayerID), logger)
 }
 
 var _ Consensus = (*mockConsensusProcess)(nil)
@@ -112,7 +108,7 @@ func TestHare_Start(t *testing.T) {
 
 	h := createHare(n1, logtest.New(t).WithName(t.Name()))
 
-	_ = h.broker.Start(context.TODO()) // todo: fix that hack. this will cause h.Start to return err
+	require.NoError(t, h.broker.Start(context.TODO())) // todo: fix that hack. this will cause h.Start to return err
 
 	/*err := h.Start()
 	require.Error(t, err)*/
@@ -135,11 +131,11 @@ func TestHare_GetResult(t *testing.T) {
 	mockid := types.NewLayerID(0)
 	set := NewSetFromValues(value1)
 
-	_ = h.collectOutput(context.TODO(), mockReport{mockid, set, true, false})
+	r.NoError(h.collectOutput(context.TODO(), mockReport{mockid, set, true, false}))
 
 	res, err = h.GetResult(types.NewLayerID(0))
 	r.NoError(err)
-	r.Equal(res[0].Bytes(), value1.Bytes())
+	r.Equal(value1.Bytes(), res[0].Bytes())
 }
 
 func TestHare_GetResult2(t *testing.T) {
@@ -154,7 +150,7 @@ func TestHare_GetResult2(t *testing.T) {
 	}
 
 	h := createHare(n1, logtest.New(t).WithName(t.Name()))
-	h.msh = om
+	h.mesh = om
 
 	h.networkDelta = 0
 
@@ -181,30 +177,6 @@ func TestHare_GetResult2(t *testing.T) {
 	require.Equal(t, err, errTooOld)
 }
 
-func TestHare_collectOutputCheckValidation(t *testing.T) {
-	sim := service.NewSimulator()
-	n1 := sim.NewNode()
-
-	h := createHare(n1, logtest.New(t).WithName(t.Name()))
-
-	mockid := instanceID1
-	set := NewSetFromValues(value1)
-
-	// default validation is true
-	_ = h.collectOutput(context.TODO(), mockReport{mockid, set, true, false})
-	output, ok := h.outputs[types.LayerID(mockid)]
-	require.True(t, ok)
-	require.Equal(t, output[0], value1)
-
-	h.validate = func(blocks []types.BlockID) bool {
-		return false
-	}
-	err := h.collectOutput(context.TODO(), mockReport{mockid, set, true, false})
-	require.NoError(t, err)
-	_, ok = h.outputs[types.LayerID(mockid)]
-	require.True(t, ok, "failure to validate should only log an error and succeed")
-}
-
 func TestHare_collectOutput(t *testing.T) {
 	sim := service.NewSimulator()
 	n1 := sim.NewNode()
@@ -214,7 +186,7 @@ func TestHare_collectOutput(t *testing.T) {
 	mockid := instanceID1
 	set := NewSetFromValues(value1)
 
-	_ = h.collectOutput(context.TODO(), mockReport{mockid, set, true, false})
+	require.NoError(t, h.collectOutput(context.TODO(), mockReport{mockid, set, true, false}))
 	output, ok := h.outputs[types.LayerID(mockid)]
 	require.True(t, ok)
 	require.Equal(t, output[0], value1)
@@ -237,7 +209,7 @@ func TestHare_collectOutput2(t *testing.T) {
 	mockid := instanceID0
 	set := NewSetFromValues(value1)
 
-	_ = h.collectOutput(context.TODO(), mockReport{mockid, set, true, false})
+	require.NoError(t, h.collectOutput(context.TODO(), mockReport{mockid, set, true, false}))
 	output, ok := h.outputs[types.LayerID(mockid)]
 	require.True(t, ok)
 	require.Equal(t, output[0], value1)
@@ -293,7 +265,7 @@ func TestHare_onTick(t *testing.T) {
 		return blockset
 	}
 
-	h := New(cfg, n1, signing, types.NodeID{}, validateBlocks, (&mockSyncer{true}).IsSynced, om, oracle, 10, &mockIDProvider{}, NewMockStateQuerier(), layerTicker, logtest.New(t).WithName("Hare"))
+	h := New(cfg, n1, signing, types.NodeID{}, (&mockSyncer{true}).IsSynced, om, oracle, 10, &mockIDProvider{}, NewMockStateQuerier(), layerTicker, log.AppLog.WithName("Hare"))
 	h.networkDelta = 0
 	h.bufferSize = 1
 
@@ -305,7 +277,7 @@ func TestHare_onTick(t *testing.T) {
 		createdChan <- struct{}{}
 		return nmcp
 	}
-	_ = h.Start(context.TODO())
+	require.NoError(t, h.Start(context.TODO()))
 
 	var wg sync.WaitGroup
 
@@ -477,7 +449,7 @@ func TestHare_WeakCoin(t *testing.T) {
 		r.True(b)
 		done <- struct{}{}
 	}}
-	h := New(cfg, n1, signing, types.NodeID{}, validateBlocks, (&mockSyncer{true}).IsSynced, om, oracle, 10, &mockIDProvider{}, NewMockStateQuerier(), layerTicker, logtest.New(t).WithName("Hare"))
+	h := New(cfg, n1, signing, types.NodeID{}, (&mockSyncer{true}).IsSynced, om, oracle, 10, &mockIDProvider{}, NewMockStateQuerier(), layerTicker, logtest.New(t).WithName("Hare"))
 	defer h.Close()
 	h.lastLayer = layerID
 	set := NewSetFromValues(value1)
diff --git a/hare/orphan_mock.go b/hare/orphan_mock.go
index a96ac2c8a93..e1980f982f3 100644
--- a/hare/orphan_mock.go
+++ b/hare/orphan_mock.go
@@ -13,6 +13,9 @@ type orphanMock struct {
 func (op *orphanMock) HandleValidatedLayer(context.Context, types.LayerID, []types.BlockID) {
 }
 
+func (op *orphanMock) InvalidateLayer(context.Context, types.LayerID) {
+}
+
 func (op *orphanMock) GetOrphanBlocks() []types.BlockID {
 	if op.f != nil {
 		return op.f()
diff --git a/layerfetcher/layers.go b/layerfetcher/layers.go
index c47abfcd31e..1e056db8260 100644
--- a/layerfetcher/layers.go
+++ b/layerfetcher/layers.go
@@ -70,6 +70,7 @@ type tortoiseBeaconDB interface {
 // network defines network capabilities used
 type network interface {
 	GetPeers() []peers.Peer
+	PeerCount() uint64
 	SendRequest(ctx context.Context, msgType server.MessageType, payload []byte, address p2pcrypto.PublicKey, resHandler func(msg []byte), timeoutHandler func(err error)) error
 	Close()
 }
@@ -83,9 +84,6 @@ var ErrNoPeers = errors.New("no peers")
 // ErrTooManyPeerErrors is returned when too many (> 1/2) peers return error
 var ErrTooManyPeerErrors = errors.New("too many peers returned error")
 
-// ErrBeaconNotReceived is returned when no valid beacon was received.
-var ErrBeaconNotReceived = errors.New("no peer sent a valid beacon")
-
 // peerResult captures the response from each peer.
 type peerResult struct {
 	data []byte
@@ -205,7 +203,7 @@ func (l *Logic) layerHashReqReceiver(ctx context.Context, msg []byte) []byte {
 			log.String("hash", lyrHash.Hash.ShortString()),
 			log.String("aggregatedHash", lyrHash.AggregatedHash.ShortString()))
 	} else {
-		l.log.WithContext(ctx).With().Debug("responded layer hash request",
+		l.log.WithContext(ctx).With().Debug("responding to layer hash request",
 			lyr,
 			log.String("hash", lyrHash.Hash.ShortString()),
 			log.String("aggregatedHash", lyrHash.AggregatedHash.ShortString()))
@@ -213,11 +211,13 @@ func (l *Logic) layerHashReqReceiver(ctx context.Context, msg []byte) []byte {
 	return out
 }
 
-// epochATXsReqReceiver returns the ATXs for the specified epoch.
+// epochATXsReqReceiver returns the ATXs for the specified epoch
 func (l *Logic) epochATXsReqReceiver(ctx context.Context, msg []byte) []byte {
 	epoch := types.EpochID(util.BytesToUint32(msg))
 	atxs := l.atxIds.GetEpochAtxs(epoch)
-	l.log.WithContext(ctx).With().Debug("responded epoch atxs request", epoch, log.Int("numATXs", len(atxs)))
+	l.log.WithContext(ctx).With().Debug("responded to epoch atxs request",
+		epoch,
+		log.Int("count", len(atxs)))
 	bts, err := types.InterfaceToBytes(atxs)
 	if err != nil {
 		l.log.WithContext(ctx).With().Warning("cannot find epoch atxs", epoch, log.Err(err))
@@ -234,8 +234,9 @@ func (l *Logic) layerHashBlocksReqReceiver(ctx context.Context, msg []byte) []by
 	vector, err := l.layerDB.GetLayerInputVector(h)
 	// best effort with input vector
 	if err != nil {
-		// TODO: We need to diff empty set and no results in sync somehow.
-		l.log.WithContext(ctx).With().Debug("didn't have input vector for layer", log.String("layerHash", h.ShortString()))
+		// TODO: differentiate between empty set and no results in sync
+		l.log.WithContext(ctx).With().Debug("no input vector for layer",
+			log.String("layer_hash", h.ShortString()))
 	}
 	// latest := l.gossipBlocks.Get() todo: implement this
 	b := layerBlocks{
@@ -275,7 +276,7 @@ func (l *Logic) tortoiseBeaconReqReceiver(ctx context.Context, msg []byte) []byt
 // PollLayerHash polls peers on the layer hash. it returns a channel for the caller to be notified when
 // responses are received from all peers.
 func (l *Logic) PollLayerHash(ctx context.Context, layerID types.LayerID) chan LayerHashResult {
-	l.log.WithContext(ctx).With().Info("polling layer hash", layerID)
+	l.log.WithContext(ctx).With().Info("polling for layer hash", layerID)
 	resChannel := make(chan LayerHashResult, 1)
 
 	remotePeers := l.net.GetPeers()
@@ -547,6 +548,9 @@ func (l *Logic) GetEpochATXs(ctx context.Context, id types.EpochID) error {
 			Atxs:  nil,
 		}
 	}
+	if l.net.PeerCount() == 0 {
+		return errors.New("no peers")
+	}
 	err := l.net.SendRequest(ctx, server.AtxIDsMsg, id.ToBytes(), fetch.GetRandomPeer(l.net.GetPeers()), receiveForPeerFunc, errFunc)
 	if err != nil {
 		return err
@@ -648,7 +652,7 @@ func (l *Logic) GetAtxs(ctx context.Context, IDs []types.ATXID) error {
 	for _, atxID := range IDs {
 		hashes = append(hashes, atxID.Hash32())
 	}
-	// todo: atx Id is currently only the header bytes - should we change it?
+	// TODO: atx Id is currently only the header bytes - should we change it?
 	results := l.fetcher.GetHashes(hashes, fetch.ATXDB, false)
 	for hash, resC := range results {
 		res := <-resC
@@ -659,7 +663,7 @@ func (l *Logic) GetAtxs(ctx context.Context, IDs []types.ATXID) error {
 			return res.Err
 		}
 		if !res.IsLocal {
-			err := l.getAtxResults(nil, hash, res.Data)
+			err := l.getAtxResults(ctx, res.Hash, res.Data)
 			if err != nil {
 				return err
 			}
@@ -668,8 +672,8 @@ func (l *Logic) GetAtxs(ctx context.Context, IDs []types.ATXID) error {
 	return nil
 }
 
-// GetBlocks gets the data for given block ids and validates the blocks. returns an error if a single atx failed to be fetched
-// or validated
+// GetBlocks gets the data for given block ids and validates the blocks. returns an error if a single atx failed to be
+// fetched or validated
 func (l *Logic) GetBlocks(ctx context.Context, IDs []types.BlockID) error {
 	l.log.WithContext(ctx).With().Debug("requesting blocks from peer", log.Int("numBlocks", len(IDs)))
 	hashes := make([]types.Hash32, 0, len(IDs))
@@ -790,7 +794,9 @@ func (l *Logic) GetTortoiseBeacon(ctx context.Context, id types.EpochID) error {
 
 	makeErrFunc := func(peer fmt.Stringer) func(error) {
 		return func(err error) {
-			l.log.WithContext(ctx).With().Warning("error in tortoise beacon response", log.String("peer", peer.String()), log.Err(err))
+			l.log.WithContext(ctx).With().Warning("error in tortoise beacon response",
+				log.String("peer", peer.String()),
+				log.Err(err))
 		}
 	}
 
@@ -802,10 +808,14 @@ func (l *Logic) GetTortoiseBeacon(ctx context.Context, id types.EpochID) error {
 			case <-cancelCtx.Done():
 				return
 			default:
-				l.log.WithContext(ctx).With().Debug("requesting tortoise beacon from peer", id, log.String("peer", peer.String()))
+				l.log.WithContext(ctx).With().Debug("requesting tortoise beacon from peer",
+					id,
+					log.String("peer", peer.String()))
 				err := l.net.SendRequest(cancelCtx, server.TortoiseBeaconMsg, id.ToBytes(), peer, makeReceiveFunc(peer), makeErrFunc(peer))
 				if err != nil {
-					l.log.WithContext(ctx).Warning("failed to send tortoise beacon request", log.String("peer", peer.String()), log.Err(err))
+					l.log.WithContext(ctx).Warning("failed to send tortoise beacon request",
+						log.String("peer", peer.String()),
+						log.Err(err))
 				}
 			}
 		}(p)
@@ -828,7 +838,9 @@ func (l *Logic) GetTortoiseBeacon(ctx context.Context, id types.EpochID) error {
 
 	case res := <-resCh:
 		resHash := types.BytesToHash(res)
-		l.log.WithContext(ctx).With().Info("received tortoise beacon", id, log.String("beacon", resHash.ShortString()))
+		l.log.WithContext(ctx).With().Info("received tortoise beacon",
+			id,
+			log.String("beacon", resHash.String()))
 		return l.tbDB.SetTortoiseBeacon(id, resHash)
 	}
 }
diff --git a/layerfetcher/layers_test.go b/layerfetcher/layers_test.go
index 8d0b2f116e9..a4128e05b04 100644
--- a/layerfetcher/layers_test.go
+++ b/layerfetcher/layers_test.go
@@ -57,6 +57,7 @@ func newMockNet() *mockNet {
 	}
 }
 func (m *mockNet) GetPeers() []peers.Peer    { return m.peers }
+func (m *mockNet) PeerCount() uint64         { return uint64(len(m.peers)) }
 func (m *mockNet) GetRandomPeer() peers.Peer { return m.peers[0] }
 func (m *mockNet) SendRequest(_ context.Context, msgType server.MessageType, _ []byte, address p2pcrypto.PublicKey, resHandler func(msg []byte), timeoutHandler func(err error)) error {
 	if _, ok := m.timeouts[address]; ok {
diff --git a/log/logtest/log.go b/log/logtest/log.go
index 6a1fafd7a5d..8f8b99b60b8 100644
--- a/log/logtest/log.go
+++ b/log/logtest/log.go
@@ -12,10 +12,10 @@ import (
 const testLogLevel = "TEST_LOG_LEVEL"
 
 // New creates log.Log instance that will use testing.TB.Log internally.
-func New(tb testing.TB, overvwrite ...zapcore.Level) log.Log {
+func New(tb testing.TB, override ...zapcore.Level) log.Log {
 	var level zapcore.Level
-	if len(overvwrite) > 0 {
-		level = overvwrite[0]
+	if len(override) > 0 {
+		level = override[0]
 	} else {
 		lvl := os.Getenv(testLogLevel)
 		if len(lvl) == 0 {
diff --git a/mesh/mesh.go b/mesh/mesh.go
index 35d45aafde5..97e61b09355 100644
--- a/mesh/mesh.go
+++ b/mesh/mesh.go
@@ -37,15 +37,15 @@ var TORTOISE = []byte("tortoise")
 var VERIFIED = []byte("verified")
 
 type tortoise interface {
-	HandleIncomingLayer(layer *types.Layer) (types.LayerID, types.LayerID)
+	HandleIncomingLayer(context.Context, types.LayerID) (oldPbase, newPbase types.LayerID, reverted bool)
 	LatestComplete() types.LayerID
-	Persist() error
-	HandleLateBlock(bl *types.Block) (types.LayerID, types.LayerID)
+	Persist(context.Context) error
+	HandleLateBlocks(context.Context, []*types.Block) (types.LayerID, types.LayerID)
 }
 
 // Validator interface to be used in tests to mock validation flow
 type Validator interface {
-	ValidateLayer(layer *types.Layer)
+	ValidateLayer(context.Context, *types.Layer)
 }
 
 type txProcessor interface {
@@ -71,7 +71,6 @@ type txMemPool interface {
 
 // AtxDB holds logic for working with atxs
 type AtxDB interface {
-	ProcessAtxs(atxs []*types.ActivationTx) error
 	GetAtxHeader(id types.ATXID) (*types.ActivationTxHeader, error)
 	GetFullAtx(id types.ATXID) (*types.ActivationTx, error)
 	SyntacticallyValidateAtx(atx *types.ActivationTx) error
@@ -128,7 +127,7 @@ func NewMesh(db *DB, atxDb AtxDB, rewardConfig Config, trtl tortoise, txPool txM
 }
 
 // NewRecoveredMesh creates new instance of mesh with recovered mesh data fom database
-func NewRecoveredMesh(db *DB, atxDb AtxDB, rewardConfig Config, trtl tortoise, txPool txMemPool, pr txProcessor, logger log.Log) *Mesh {
+func NewRecoveredMesh(ctx context.Context, db *DB, atxDb AtxDB, rewardConfig Config, trtl tortoise, txPool txMemPool, pr txProcessor, logger log.Log) *Mesh {
 	msh := NewMesh(db, atxDb, rewardConfig, trtl, txPool, pr, logger)
 
 	latest, err := db.general.Get(constLATEST)
@@ -157,12 +156,12 @@ func NewRecoveredMesh(db *DB, atxDb AtxDB, rewardConfig Config, trtl tortoise, t
 	if msh.LatestLayerInState().Add(1).Before(msh.trtl.LatestComplete()) {
 		// todo: add test for this case, or add random kill test on node
 		logger.Info("playing layers %v to %v to state", msh.LatestLayerInState().Add(1), msh.trtl.LatestComplete())
-		msh.pushLayersToState(msh.LatestLayerInState().Add(1), msh.trtl.LatestComplete())
+		msh.pushLayersToState(ctx, msh.LatestLayerInState().Add(1), msh.trtl.LatestComplete())
 	}
 
 	msh.With().Info("recovered mesh from disk",
-		log.FieldNamed("latest_layer", msh.LatestLayer()),
-		log.FieldNamed("validated_layer", msh.ProcessedLayer()),
+		log.FieldNamed("latest", msh.LatestLayer()),
+		log.FieldNamed("processed", msh.ProcessedLayer()),
 		log.String("layer_hash", msh.ProcessedLayerHash().ShortString()),
 		log.String("root_hash", pr.GetStateRoot().String()))
 
@@ -177,7 +176,7 @@ func (msh *Mesh) CacheWarmUp(layerSize int) {
 	}
 
 	if err := msh.cacheWarmUpFromTo(start, msh.ProcessedLayer()); err != nil {
-		msh.Error("cache warm up failed during recovery", err)
+		msh.With().Error("cache warm up failed during recovery", log.Err(err))
 	}
 
 	msh.Info("cache warm up done")
@@ -199,18 +198,10 @@ func (msh *Mesh) LatestLayer() types.LayerID {
 
 // setLatestLayer sets the latest layer we saw from the network
 func (msh *Mesh) setLatestLayer(idx types.LayerID) {
-	// Report the status update, as well as the layer itself
-	layer, err := msh.GetLayer(idx)
-	if err != nil {
-		if !errors.Is(err, database.ErrNotFound) {
-			msh.With().Error("error reading layer data", idx, log.Err(err))
-		}
-	} else {
-		events.ReportNewLayer(events.NewLayer{
-			Layer:  layer,
-			Status: events.LayerStatusTypeUnknown,
-		})
-	}
+	events.ReportLayerUpdate(events.LayerUpdate{
+		LayerID: idx,
+		Status:  events.LayerStatusTypeUnknown,
+	})
 	defer msh.mutex.Unlock()
 	msh.mutex.Lock()
 	if idx.After(msh.latestLayer) {
@@ -272,7 +263,9 @@ func (msh *Mesh) setProcessedLayerFromRecoveredData(pLayer *ProcessedLayer) {
 	msh.mutex.Lock()
 	defer msh.mutex.Unlock()
 	msh.processedLayer = *pLayer
-	msh.Event().Info("processed layer set from recovered data", pLayer.ID, log.String("layer_hash", pLayer.Hash.ShortString()))
+	msh.Event().Info("processed layer set from recovered data",
+		pLayer.ID,
+		log.String("layer_hash", pLayer.Hash.ShortString()))
 }
 
 func (msh *Mesh) setProcessedLayer(layer *types.Layer) {
@@ -281,17 +274,17 @@ func (msh *Mesh) setProcessedLayer(layer *types.Layer) {
 	defer msh.mutex.Unlock()
 	if !layer.Index().After(msh.processedLayer.ID) {
 		msh.With().Info("trying to set processed layer to an older layer",
-			log.FieldNamed("processed_layer", msh.processedLayer.ID),
+			log.FieldNamed("processed", msh.processedLayer.ID),
 			log.FieldNamed("old_layer", layer.Index()))
 		for i := layer.Index(); !i.After(msh.processedLayer.ID); i = i.Add(1) {
 			lyr, err := msh.GetLayer(i)
 			if err != nil {
-				msh.With().Error("failed to get layer", i)
+				msh.With().Error("failed to get layer", i, log.Err(err))
 				return
 			}
 			prevHash, err := msh.getAggregatedLayerHash(i.Sub(1))
 			if err != nil {
-				msh.With().Error("failed to get previous aggregated hash", i)
+				msh.With().Error("failed to get previous aggregated hash", i, log.Err(err))
 				return
 			}
 			newAggHash := msh.calcAggregatedLayerHash(lyr, prevHash)
@@ -305,7 +298,7 @@ func (msh *Mesh) setProcessedLayer(layer *types.Layer) {
 		}
 		if err := msh.persistProcessedLayer(&msh.processedLayer); err != nil {
 			msh.With().Error("failed to persist processed layer",
-				log.FieldNamed("processed_layer", msh.processedLayer.ID),
+				log.FieldNamed("processed", msh.processedLayer.ID),
 				log.String("processed_layer_hash", msh.processedLayer.Hash.ShortString()),
 				log.Err(err))
 		}
@@ -318,7 +311,7 @@ func (msh *Mesh) setProcessedLayer(layer *types.Layer) {
 
 	if layer.Index() != msh.processedLayer.ID.Add(1) {
 		msh.With().Info("trying to set processed layer out of order",
-			log.FieldNamed("processed_layer", msh.processedLayer.ID),
+			log.FieldNamed("processed", msh.processedLayer.ID),
 			log.FieldNamed("new_layer", layer.Index()))
 		msh.nextProcessedLayers[layer.Index()] = layer
 		return
@@ -334,102 +327,142 @@ func (msh *Mesh) setProcessedLayer(layer *types.Layer) {
 		}
 		aggHash := msh.calcAggregatedLayerHash(lyr, lastProcessed.Hash)
 		msh.persistAggregatedLayerHash(i, aggHash)
-		msh.With().Info("aggregated hash set for layer", i, log.String("layer_hash", aggHash.ShortString()))
+		msh.With().Info("aggregated hash set for layer",
+			i,
+			log.String("layer_hash", aggHash.ShortString()))
 		lastProcessed = ProcessedLayer{ID: i, Hash: aggHash}
 		delete(msh.nextProcessedLayers, i)
 	}
 	msh.processedLayer = lastProcessed
 	events.ReportNodeStatusUpdate()
-	msh.Event().Info("processed layer set", msh.processedLayer.ID, log.String("layer_hash", msh.processedLayer.Hash.ShortString()))
+	msh.Event().Info("processed layer set",
+		msh.processedLayer.ID,
+		log.String("layer_hash", msh.processedLayer.Hash.ShortString()))
 
 	if err := msh.persistProcessedLayer(&lastProcessed); err != nil {
 		msh.With().Error("failed to persist processed layer",
-			log.FieldNamed("processed_layer", lastProcessed.ID),
+			log.FieldNamed("processed", lastProcessed.ID),
 			log.String("processed_layer_hash", lastProcessed.Hash.ShortString()),
 			log.Err(err))
 	}
 }
 
+// ValidateLayer performs fairly heavy lifting: it triggers tortoise to process the full contents of the layer (i.e.,
+// all of its blocks), then to attempt to validate all unvalidated layers up to this layer. It also applies state for
+// newly-validated layers.
+// TODO: rename this. When tortoise passes a layer, we call that "verify." "Validate" sounds too similar and it's
+//   confusing that a layer can be validated without being verified.
+//   See https://github.com/spacemeshos/go-spacemesh/issues/2669
+func (vl *validator) ValidateLayer(ctx context.Context, lyr *types.Layer) {
+	layerID := lyr.Index()
+	logger := vl.WithContext(ctx).WithFields(layerID)
+	logger.Info("validate layer")
+
+	// pass the layer to tortoise for processing
+	oldPbase, newPbase, reverted := vl.trtl.HandleIncomingLayer(ctx, layerID)
+	logger.With().Info("tortoise results",
+		log.Bool("reverted", reverted),
+		log.FieldNamed("old_pbase", oldPbase),
+		log.FieldNamed("new_pbase", newPbase))
+
+	// check for a state reversion: if tortoise reran and detected changes to historical data, it will request that
+	// state be reverted and reapplied. pushLayersToState, below, will handle the reapplication.
+	if reverted {
+		if err := vl.revertState(ctx, oldPbase); err != nil {
+			logger.Error("state reversion failed, unable to validate layer")
+			return
+		}
+	}
+
+	if err := vl.trtl.Persist(ctx); err != nil {
+		logger.With().Error("could not persist tortoise", log.Err(err))
+	}
+	vl.pushLayersToState(ctx, oldPbase, newPbase)
+	vl.setProcessedLayer(lyr)
+	for newlyVerifiedLayer := oldPbase.Add(1); !newlyVerifiedLayer.After(newPbase); newlyVerifiedLayer = newlyVerifiedLayer.Add(1) {
+		events.ReportLayerUpdate(events.LayerUpdate{
+			LayerID: newlyVerifiedLayer,
+			Status:  events.LayerStatusTypeConfirmed,
+		})
+	}
+	logger.Info("done validating layer")
+}
+
 // HandleLateBlock process a late (contextually invalid) block.
-func (msh *Mesh) HandleLateBlock(b *types.Block) {
-	msh.With().Info("validate late block", b.ID())
-	oldPbase, newPbase := msh.trtl.HandleLateBlock(b)
-	if err := msh.trtl.Persist(); err != nil {
-		msh.With().Error("could not persist tortoise on late block", b.ID(), b.Layer())
+func (msh *Mesh) HandleLateBlock(ctx context.Context, b *types.Block) {
+	msh.WithContext(ctx).With().Info("validate late block", b.ID())
+	// TODO: handle late blocks in batches, see https://github.com/spacemeshos/go-spacemesh/issues/2412
+	oldPbase, newPbase := msh.trtl.HandleLateBlocks(ctx, []*types.Block{b})
+	if err := msh.trtl.Persist(ctx); err != nil {
+		msh.WithContext(ctx).With().Error("could not persist tortoise on late block", b.ID(), b.Layer())
 	}
-	msh.pushLayersToState(oldPbase, newPbase)
+	msh.pushLayersToState(ctx, oldPbase, newPbase)
 }
 
 type validator struct {
 	*Mesh
 }
 
-func (vl *validator) ValidateLayer(lyr *types.Layer) {
-	vl.With().Info("validate layer", lyr.Index())
-	if len(lyr.Blocks()) == 0 {
-		vl.With().Info("skip validation of layer with no blocks", lyr)
-		vl.setProcessedLayer(lyr)
-		events.ReportNewLayer(events.NewLayer{
-			Layer:  lyr,
-			Status: events.LayerStatusTypeConfirmed,
-		})
-		return
-	}
-
-	oldPbase, newPbase := vl.trtl.HandleIncomingLayer(lyr)
-	if err := vl.trtl.Persist(); err != nil {
-		vl.With().Error("could not persist tortoise", lyr, log.Err(err))
-	}
-	vl.pushLayersToState(oldPbase, newPbase)
-	vl.setProcessedLayer(lyr)
-	events.ReportNewLayer(events.NewLayer{
-		Layer:  lyr,
-		Status: events.LayerStatusTypeConfirmed,
-	})
-	vl.With().Info("done validating layer", lyr.Index())
-}
+// apply the state of a range of layers, including re-adding transactions from invalid blocks to the mempool
+func (msh *Mesh) pushLayersToState(ctx context.Context, oldPbase, newPbase types.LayerID) {
+	logger := msh.WithContext(ctx).WithFields(
+		log.FieldNamed("old_pbase", oldPbase),
+		log.FieldNamed("new_pbase", newPbase))
+	logger.Info("pushing layers to state")
 
-func (msh *Mesh) pushLayersToState(oldPbase types.LayerID, newPbase types.LayerID) {
+	// TODO: does this need to be hardcoded? can we use types.GetEffectiveGenesis instead?
+	//   see https://github.com/spacemeshos/go-spacemesh/issues/2670
 	layerTwo := types.NewLayerID(2)
 	if oldPbase.Before(layerTwo) {
 		msh.With().Warning("tried to push layer < 2",
-			log.FieldNamed("old_pbase", oldPbase), log.FieldNamed("new_pbase", newPbase))
+			log.FieldNamed("old_pbase", oldPbase),
+			log.FieldNamed("new_pbase", newPbase))
 		if newPbase.Before(types.NewLayerID(3)) {
 			return
 		}
 		oldPbase = layerTwo
 	}
+
 	for layerID := oldPbase; layerID.Before(newPbase); layerID = layerID.Add(1) {
 		l, err := msh.GetLayer(layerID)
 		// TODO: propagate/handle error
 		if err != nil || l == nil {
 			if layerID.GetEpoch().IsGenesis() {
-				msh.With().Info("failed to get layer (expected for genesis layers)", layerID, log.Err(err))
+				logger.With().Info("failed to get layer (expected for genesis layers)", layerID, log.Err(err))
 			} else {
-				msh.With().Error("failed to get layer", layerID, log.Err(err))
+				logger.With().Error("failed to get layer", layerID, log.Err(err))
 			}
 			return
 		}
 		validBlocks, invalidBlocks := msh.BlocksByValidity(l.Blocks())
-		msh.updateStateWithLayer(layerID, types.NewExistingLayer(layerID, validBlocks))
+		msh.updateStateWithLayer(types.NewExistingLayer(layerID, validBlocks))
 		msh.logStateRoot(l.Index())
 		msh.persistLayerHash(l.Index(), msh.calcSimpleLayerHash(l))
 		msh.reInsertTxsToPool(validBlocks, invalidBlocks, l.Index())
 	}
 }
 
+// RevertState reverts to state as of a previous layer
+func (msh *Mesh) revertState(ctx context.Context, layerID types.LayerID) error {
+	logger := msh.WithContext(ctx).WithFields(layerID)
+	logger.Info("attempting to roll back state to previous layer")
+	if err := msh.LoadState(layerID); err != nil {
+		return fmt.Errorf("failed to revert state to layer %v: %w", layerID, err)
+	}
+	return nil
+}
+
 func (msh *Mesh) reInsertTxsToPool(validBlocks, invalidBlocks []*types.Block, l types.LayerID) {
 	seenTxIds := make(map[types.TransactionID]struct{})
-	uniqueTxIds(validBlocks, seenTxIds)
+	uniqueTxIds(validBlocks, seenTxIds) // run for the side effect, updating seenTxIds
 	returnedTxs := msh.getTxs(uniqueTxIds(invalidBlocks, seenTxIds), l)
 	grouped, accounts := msh.removeFromUnappliedTxs(returnedTxs)
 	for account := range accounts {
 		msh.removeRejectedFromAccountTxs(account, grouped, l)
 	}
 	for _, tx := range returnedTxs {
-		err := msh.ValidateAndAddTxToPool(tx)
-		// We ignore errors here, since they mean that the tx is no longer valid and we shouldn't re-add it
-		if err == nil {
+		if err := msh.ValidateAndAddTxToPool(tx); err == nil {
+			// We ignore errors here, since they mean that the tx is no longer valid and we shouldn't re-add it
 			msh.With().Info("transaction from contextually invalid block re-added to mempool", tx.ID())
 		}
 	}
@@ -439,43 +472,36 @@ func (msh *Mesh) applyState(l *types.Layer) {
 	msh.accumulateRewards(l, msh.config)
 	msh.pushTransactions(l)
 	msh.setLatestLayerInState(l.Index())
-	events.ReportNewLayer(events.NewLayer{
-		Layer:  l,
-		Status: events.LayerStatusTypeApproved,
-	})
 }
 
-// HandleValidatedLayer handles layer valid blocks as decided by hare
+// HandleValidatedLayer receives hare output once it finishes running for a given layer
 func (msh *Mesh) HandleValidatedLayer(ctx context.Context, validatedLayer types.LayerID, layer []types.BlockID) {
+	logger := msh.WithContext(ctx).WithFields(validatedLayer)
 	var blocks []*types.Block
 
 	for _, blockID := range layer {
 		block, err := msh.GetBlock(blockID)
 		if err != nil {
 			// stop processing this hare result, wait until tortoise pushes this layer into state
-			msh.WithContext(ctx).Error("hare terminated with block that is not present in mesh")
+			logger.Error("hare terminated with block that is not present in mesh")
 			return
 		}
 		blocks = append(blocks, block)
 	}
-	lyr := types.NewExistingLayer(validatedLayer, blocks)
-	invalidBlocks := msh.getInvalidBlocksByHare(ctx, lyr)
-	// Reporting of the validated layer happens deep inside this call stack, below
-	// updateStateWithLayer, inside applyState. No need to report here.
-	msh.updateStateWithLayer(validatedLayer, lyr)
-	msh.reInsertTxsToPool(blocks, invalidBlocks, lyr.Index())
 
-	// get the full layer incl invalid blocks
-	for _, bl := range invalidBlocks {
-		lyr.AddBlock(bl)
-	}
+	// report that hare "approved" this layer
+	events.ReportLayerUpdate(events.LayerUpdate{
+		LayerID: validatedLayer,
+		Status:  events.LayerStatusTypeApproved,
+	})
 
-	msh.Log.With().Info("mesh validating layer", lyr.Index().Field(), log.Int("valid_blocks", len(blocks)), log.Int("invalid_blocks", len(invalidBlocks)))
+	logger.With().Info("saving input vector for layer", log.Int("count_valid_blocks", len(blocks)))
 
-	if err := msh.SaveLayerInputVectorByID(ctx, lyr.Index(), types.BlockIDs(blocks)); err != nil {
-		msh.Log.With().Error("failed to save input vector", lyr.Index())
+	if err := msh.SaveLayerInputVectorByID(ctx, validatedLayer, types.BlockIDs(blocks)); err != nil {
+		logger.Error("saving layer input vector failed")
 	}
-	msh.ValidateLayer(lyr)
+	lyr := types.NewExistingLayer(validatedLayer, blocks)
+	msh.ValidateLayer(ctx, lyr)
 }
 
 func (msh *Mesh) getInvalidBlocksByHare(ctx context.Context, hareLayer *types.Layer) (invalid []*types.Block) {
@@ -497,29 +523,31 @@ func (msh *Mesh) getInvalidBlocksByHare(ctx context.Context, hareLayer *types.La
 	return
 }
 
-func (msh *Mesh) updateStateWithLayer(validatedLayer types.LayerID, layer *types.Layer) {
+// apply the state for a single layer. stores layer results for early layers, and applies previously stored results for
+// now-older layers.
+func (msh *Mesh) updateStateWithLayer(layer *types.Layer) {
 	msh.txMutex.Lock()
 	defer msh.txMutex.Unlock()
 	latest := msh.LatestLayerInState()
-	if !validatedLayer.After(latest) {
+	if !layer.Index().After(latest) {
 		msh.With().Warning("result received after state has advanced",
-			log.FieldNamed("validatedLayer", validatedLayer),
-			log.FieldNamed("latestLayer", latest))
+			log.FieldNamed("validated", layer.Index()),
+			log.FieldNamed("latest", latest))
 		return
 	}
-	if msh.maxValidatedLayer.Before(validatedLayer) {
-		msh.maxValidatedLayer = validatedLayer
+	if msh.maxValidatedLayer.Before(layer.Index()) {
+		msh.maxValidatedLayer = layer.Index()
 	}
-	if validatedLayer.After(latest.Add(1)) {
+	if layer.Index().After(latest.Add(1)) {
 		msh.With().Warning("early layer result received",
-			log.FieldNamed("validatedLayer", validatedLayer),
-			log.FieldNamed("maxValidatedLayer", msh.maxValidatedLayer),
-			log.FieldNamed("latestLayer", latest))
-		msh.nextValidLayers[validatedLayer] = layer
+			log.FieldNamed("validated", layer.Index()),
+			log.FieldNamed("max_validated", msh.maxValidatedLayer),
+			log.FieldNamed("latest", latest))
+		msh.nextValidLayers[layer.Index()] = layer
 		return
 	}
 	msh.applyState(layer)
-	for i := validatedLayer.Add(1); !i.After(msh.maxValidatedLayer); i = i.Add(1) {
+	for i := layer.Index().Add(1); !i.After(msh.maxValidatedLayer); i = i.Add(1) {
 		nxtLayer, has := msh.nextValidLayers[i]
 		if !has {
 			break
@@ -542,7 +570,8 @@ func (msh *Mesh) setLatestLayerInState(lyr types.LayerID) {
 }
 
 func (msh *Mesh) logStateRoot(layerID types.LayerID) {
-	msh.Event().Info("end of layer state root", layerID,
+	msh.Event().Info("end of layer state root",
+		layerID,
 		log.String("state_root", util.Bytes2Hex(msh.txProcessor.GetStateRoot().Bytes())),
 	)
 }
@@ -563,7 +592,9 @@ func (msh *Mesh) calcSimpleLayerHash(layer *types.Layer) types.Hash32 {
 
 func (msh *Mesh) persistAggregatedLayerHash(layerID types.LayerID, hash types.Hash32) {
 	if err := msh.general.Put(msh.getAggregatedLayerHashKey(layerID), hash.Bytes()); err != nil {
-		msh.With().Error("failed to persist running layer hash", log.Err(err), msh.ProcessedLayer(),
+		msh.With().Error("failed to persist running layer hash",
+			log.Err(err),
+			msh.ProcessedLayer(),
 			log.String("layer_hash", hash.ShortString()))
 	}
 }
@@ -673,7 +704,7 @@ func (msh *Mesh) pushTransactions(l *types.Layer) {
 		msh.With().Error("failed to apply transactions",
 			l.Index(), log.Int("num_failed_txs", numFailedTxs), log.Err(err))
 		// TODO: We want to panic here once we have a way to "remember" that we didn't apply these txs
-		//  e.g. persist the last layer transactions were applied from and use that instead of `oldBase`
+		//  e.g. persist the last layer transactions were applied from and use that instead of `oldPbase`
 	}
 	msh.removeFromUnappliedTxs(validBlockTxs)
 	msh.With().Info("applied transactions",
@@ -794,11 +825,11 @@ func (msh *Mesh) handleOrphanBlocks(blk *types.Block) {
 		msh.orphanBlocks[blk.Layer()] = make(map[types.BlockID]struct{})
 	}
 	msh.orphanBlocks[blk.Layer()][blk.ID()] = struct{}{}
-	msh.Debug("Added block %s to orphans", blk.ID())
+	msh.With().Debug("added block to orphans", blk.ID())
 	for _, b := range append(blk.ForDiff, append(blk.AgainstDiff, blk.NeutralDiff...)...) {
 		for layerID, layermap := range msh.orphanBlocks {
 			if _, has := layermap[b]; has {
-				msh.Log.With().Debug("delete block from orphans", b)
+				msh.With().Debug("delete block from orphans", b)
 				delete(layermap, b)
 				if len(layermap) == 0 {
 					delete(msh.orphanBlocks, layerID)
diff --git a/mesh/mesh_test.go b/mesh/mesh_test.go
index 36b1e7ec420..2d377414507 100644
--- a/mesh/mesh_test.go
+++ b/mesh/mesh_test.go
@@ -52,7 +52,7 @@ type MeshValidatorMock struct {
 	mdb *DB
 }
 
-func (m *MeshValidatorMock) Persist() error {
+func (m *MeshValidatorMock) Persist(context.Context) error {
 	return nil
 }
 
@@ -60,16 +60,17 @@ func (m *MeshValidatorMock) LatestComplete() types.LayerID {
 	panic("implement me")
 }
 
-func (m *MeshValidatorMock) HandleIncomingLayer(layer *types.Layer) (types.LayerID, types.LayerID) {
-	return layer.Index().Sub(1), layer.Index()
+func (m *MeshValidatorMock) HandleIncomingLayer(_ context.Context, layerID types.LayerID) (types.LayerID, types.LayerID, bool) {
+	return layerID.Sub(1), layerID, false
 }
-func (m *MeshValidatorMock) HandleLateBlock(bl *types.Block) (types.LayerID, types.LayerID) {
-	return bl.Layer().Sub(1), bl.Layer()
+
+func (m *MeshValidatorMock) HandleLateBlocks(_ context.Context, bl []*types.Block) (types.LayerID, types.LayerID) {
+	return bl[0].Layer().Sub(1), bl[0].Layer()
 }
 
 type MockState struct{}
 
-func (MockState) ValidateAndAddTxToPool(tx *types.Transaction) error {
+func (MockState) ValidateAndAddTxToPool(*types.Transaction) error {
 	panic("implement me")
 }
 
@@ -104,14 +105,15 @@ func (MockState) GetAllAccounts() (*types.MultipleAccountsState, error) {
 	panic("implement me")
 }
 
-func (MockState) GetLayerStateRoot(layer types.LayerID) (types.Hash32, error) {
+func (MockState) GetLayerStateRoot(types.LayerID) (types.Hash32, error) {
 	panic("implement me")
 }
 
-func (MockState) GetBalance(addr types.Address) uint64 {
+func (MockState) GetBalance(types.Address) uint64 {
 	panic("implement me")
 }
-func (MockState) GetNonce(addr types.Address) uint64 {
+
+func (MockState) GetNonce(types.Address) uint64 {
 	panic("implement me")
 }
 
@@ -145,7 +147,7 @@ func getMesh(tb testing.TB, id string) *Mesh {
 
 func addLayer(r *require.Assertions, id types.LayerID, layerSize int, msh *Mesh) *types.Layer {
 	if layerSize == 0 {
-		msh.SetZeroBlockLayer(id)
+		r.NoError(msh.SetZeroBlockLayer(id))
 	} else {
 		for i := 0; i < layerSize; i++ {
 			log.Info("creating block for layer %v", id)
@@ -155,7 +157,7 @@ func addLayer(r *require.Assertions, id types.LayerID, layerSize int, msh *Mesh)
 			log.Info("block created for layer %v", block.LayerIndex)
 			err := msh.AddBlockWithTxs(context.TODO(), block)
 			r.NoError(err, "cannot add data to test")
-			msh.contextualValidity.Put(block.ID().Bytes(), []byte{1})
+			r.NoError(msh.contextualValidity.Put(block.ID().Bytes(), []byte{1}))
 		}
 	}
 	log.Info("getting layer %v", id)
@@ -178,7 +180,7 @@ func TestMesh_GetLayerHash(t *testing.T) {
 
 	numBlocks := 10
 	lyr = addLayer(r, lyrID, numBlocks, msh)
-	msh.SaveContextualValidity(lyr.Blocks()[0].ID(), false)
+	r.NoError(msh.SaveContextualValidity(lyr.Blocks()[0].ID(), lyrID, false))
 
 	// before a layer is validated, all blocks count towards its hash, valid or not
 	lyr, err = msh.GetLayer(lyrID)
@@ -187,7 +189,7 @@ func TestMesh_GetLayerHash(t *testing.T) {
 	assert.Equal(t, lyr.Hash(), msh.GetLayerHash(lyrID))
 
 	validBlocks := lyr.Blocks()[1:]
-	msh.ValidateLayer(lyr)
+	msh.ValidateLayer(context.TODO(), lyr)
 	// after a layer is validated, only contextually valid blocks count towards its hash
 	expHash := types.CalcBlocksHash32(types.SortBlockIDs(types.BlockIDs(validBlocks)), nil)
 	assert.Equal(t, expHash, msh.GetLayerHash(lyrID))
@@ -202,12 +204,12 @@ func TestMesh_GetLayerHash(t *testing.T) {
 	lyr, err = msh.GetLayer(lyrID)
 	r.NoError(err)
 	assert.Equal(t, numBlocks+1, len(lyr.Blocks()))
-	msh.ValidateLayer(lyr)
+	msh.ValidateLayer(context.TODO(), lyr)
 	assert.Equal(t, expHash, msh.GetLayerHash(lyrID))
 
 	// now if the late block is determined valid, the hash should be updated
-	msh.SaveContextualValidity(block.ID(), true)
-	msh.ValidateLayer(lyr)
+	r.NoError(msh.SaveContextualValidity(block.ID(), lyrID, true))
+	msh.ValidateLayer(context.TODO(), lyr)
 	newExpectedHash := types.CalcBlocksHash32(types.SortBlockIDs(types.BlockIDs(append(validBlocks, block))), nil)
 	assert.Equal(t, newExpectedHash, msh.GetLayerHash(lyrID))
 }
@@ -229,7 +231,7 @@ func TestMesh_SetZeroBlockLayer(t *testing.T) {
 
 	// it's ok to add to an empty layer
 	lyr = addLayer(r, lyrID, 10, msh)
-	msh.ValidateLayer(lyr)
+	msh.ValidateLayer(context.TODO(), lyr)
 	lyr, err = msh.GetLayer(lyrID)
 	r.NoError(err)
 	assert.Equal(t, 10, len(lyr.Blocks()))
@@ -275,7 +277,7 @@ func TestMesh_GetAggregatedLayerHash(t *testing.T) {
 	prevHash := EmptyLayerHash
 	for i := types.NewLayerID(1); i.Before(gLyr); i = i.Add(1) {
 		lyr := addLayer(r, i, 0, msh)
-		msh.ValidateLayer(lyr)
+		msh.ValidateLayer(context.TODO(), lyr)
 		aggHash := types.CalcBlocksHash32([]types.BlockID{}, prevHash.Bytes())
 		assert.Equal(t, aggHash, msh.GetAggregatedLayerHash(lyr.Index()))
 		prevHash = aggHash
@@ -283,7 +285,7 @@ func TestMesh_GetAggregatedLayerHash(t *testing.T) {
 	lyr, err := msh.GetLayer(gLyr)
 	r.NoError(err)
 	assert.Equal(t, 1, len(lyr.Blocks()))
-	msh.ValidateLayer(lyr)
+	msh.ValidateLayer(context.TODO(), lyr)
 	aggHash := types.CalcBlocksHash32(types.SortBlockIDs(types.BlockIDs(lyr.Blocks())), prevHash.Bytes())
 	assert.Equal(t, aggHash, msh.GetAggregatedLayerHash(lyr.Index()))
 	prevHash = aggHash
@@ -292,8 +294,8 @@ func TestMesh_GetAggregatedLayerHash(t *testing.T) {
 	lyrID := gLyr.Add(1)
 	lyr = addLayer(r, lyrID, 5, msh)
 	r.Equal(5, len(lyr.Blocks()))
-	r.NoError(msh.SaveContextualValidity(lyr.Blocks()[0].ID(), false))
-	msh.ValidateLayer(lyr)
+	r.NoError(msh.SaveContextualValidity(lyr.Blocks()[0].ID(), lyrID, false))
+	msh.ValidateLayer(context.TODO(), lyr)
 	// aggregated layer hash only includes valid blocks
 	aggHash = types.CalcBlocksHash32(types.SortBlockIDs(types.BlockIDs(lyr.Blocks()[1:])), prevHash.Bytes())
 	assert.Equal(t, aggHash, msh.GetAggregatedLayerHash(lyr.Index()))
@@ -633,7 +635,7 @@ func TestMesh_AddBlockWithTxs_PushTransactions_UpdateUnappliedTxs(t *testing.T)
 		r.Equal(111, int(txns[i].TotalAmount))
 	}
 
-	msh.pushLayersToState(types.GetEffectiveGenesis().Add(1), types.GetEffectiveGenesis().Add(2))
+	msh.pushLayersToState(context.TODO(), types.GetEffectiveGenesis().Add(1), types.GetEffectiveGenesis().Add(2))
 	r.Equal(4, len(state.Txs))
 
 	r.ElementsMatch(GetTransactionIds(tx5), GetTransactionIds(state.Pool...))
@@ -741,7 +743,7 @@ func addBlockWithTxs(r *require.Assertions, msh *Mesh, id types.LayerID, valid b
 		msh.txPool.Put(tx.ID(), tx)
 	}
 	blk.Initialize()
-	err := msh.SaveContextualValidity(blk.ID(), valid)
+	err := msh.SaveContextualValidity(blk.ID(), blk.LayerIndex, valid)
 	r.NoError(err)
 
 	err = msh.AddBlockWithTxs(context.TODO(), blk)
diff --git a/mesh/meshdb.go b/mesh/meshdb.go
index 87709446f8d..d7f5b945cea 100644
--- a/mesh/meshdb.go
+++ b/mesh/meshdb.go
@@ -23,6 +23,9 @@ type layerMutex struct {
 	layerWorkers uint32
 }
 
+// ErrInvalidLayer signifies that hare has failed for a given layer, thus marking it invalid
+var ErrInvalidLayer = errors.New("layer invalid")
+
 // DB represents a mesh database instance
 type DB struct {
 	log.Log
@@ -37,7 +40,8 @@ type DB struct {
 	unappliedTxsMutex     sync.Mutex
 	blockMutex            sync.RWMutex
 	orphanBlocks          map[types.LayerID]map[types.BlockID]struct{}
-	coinflips             map[types.LayerID]bool // weak coinflip results from Hare
+	invalidatedLayers     map[types.LayerID]struct{} // layers for which Hare has failed
+	coinflips             map[types.LayerID]bool     // weak coinflip results from Hare
 	layerMutex            map[types.LayerID]*layerMutex
 	lhMutex               sync.Mutex
 	InputVectorBackupFunc func(id types.LayerID) ([]types.BlockID, error)
@@ -86,21 +90,22 @@ func NewPersistentMeshDB(path string, blockCacheSize int, logger log.Log) (*DB,
 		unappliedTxs:       utx,
 		inputVector:        iv,
 		orphanBlocks:       make(map[types.LayerID]map[types.BlockID]struct{}),
+		invalidatedLayers:  make(map[types.LayerID]struct{}),
 		coinflips:          make(map[types.LayerID]bool),
 		layerMutex:         make(map[types.LayerID]*layerMutex),
 		exit:               make(chan struct{}),
 	}
 	for _, blk := range GenesisLayer().Blocks() {
-		ll.Log.With().Info("Adding genesis block ", blk.ID(), blk.LayerIndex)
-		if err := ll.AddBlock(blk); err != nil {
-			ll.Log.With().Error("Error inserting genesis block to db", blk.ID(), blk.LayerIndex)
+		ll.Log.With().Info("adding genesis block", blk.ID(), blk.LayerIndex)
+		if err = ll.AddBlock(blk); err != nil {
+			ll.Log.With().Error("error inserting genesis block to db", blk.ID(), blk.LayerIndex, log.Err(err))
 		}
-		if err := ll.SaveContextualValidity(blk.ID(), true); err != nil {
-			ll.Log.With().Error("Error inserting genesis block to db", blk.ID(), blk.LayerIndex)
+		if err = ll.SaveContextualValidity(blk.ID(), blk.LayerIndex, true); err != nil {
+			ll.Log.With().Error("error inserting genesis block to db", blk.ID(), blk.LayerIndex, log.Err(err))
 		}
 	}
-	if err := ll.SaveLayerInputVectorByID(context.Background(), GenesisLayer().Index(), types.BlockIDs(GenesisLayer().Blocks())); err != nil {
-		log.With().Error("Error inserting genesis input vector to db", GenesisLayer().Index())
+	if err = ll.SaveLayerInputVectorByID(context.Background(), GenesisLayer().Index(), types.BlockIDs(GenesisLayer().Blocks())); err != nil {
+		log.With().Error("error inserting genesis input vector to db", GenesisLayer().Index(), log.Err(err))
 	}
 	return ll, err
 }
@@ -116,9 +121,9 @@ func (m *DB) PersistentData() bool {
 }
 
 // NewMemMeshDB is a mock used for testing
-func NewMemMeshDB(log log.Log) *DB {
+func NewMemMeshDB(logger log.Log) *DB {
 	ll := &DB{
-		Log:                log,
+		Log:                logger,
 		blockCache:         newBlockCache(100 * layerSize),
 		blocks:             database.NewMemDatabase(),
 		layers:             database.NewMemDatabase(),
@@ -128,16 +133,18 @@ func NewMemMeshDB(log log.Log) *DB {
 		unappliedTxs:       database.NewMemDatabase(),
 		inputVector:        database.NewMemDatabase(),
 		orphanBlocks:       make(map[types.LayerID]map[types.BlockID]struct{}),
+		invalidatedLayers:  make(map[types.LayerID]struct{}),
 		coinflips:          make(map[types.LayerID]bool),
 		layerMutex:         make(map[types.LayerID]*layerMutex),
 		exit:               make(chan struct{}),
 	}
 	for _, blk := range GenesisLayer().Blocks() {
-		ll.AddBlock(blk)
-		ll.SaveContextualValidity(blk.ID(), true)
+		// these are only used for testing so we can safely ignore errors here
+		_ = ll.AddBlock(blk)
+		_ = ll.SaveContextualValidity(blk.ID(), blk.LayerIndex, true)
 	}
 	if err := ll.SaveLayerInputVectorByID(context.Background(), GenesisLayer().Index(), types.BlockIDs(GenesisLayer().Blocks())); err != nil {
-		log.With().Error("Error inserting genesis input vector to db", GenesisLayer().Index())
+		logger.With().Error("error inserting genesis input vector to db", GenesisLayer().Index(), log.Err(err))
 	}
 	return ll
 }
@@ -324,17 +331,38 @@ func (m *DB) ContextualValidity(id types.BlockID) (bool, error) {
 }
 
 // SaveContextualValidity persists opinion on block to the database
-func (m *DB) SaveContextualValidity(id types.BlockID, valid bool) error {
+func (m *DB) SaveContextualValidity(id types.BlockID, _ types.LayerID, valid bool) error {
 	var v []byte
 	if valid {
 		v = constTrue
 	} else {
 		v = constFalse
 	}
-	m.Debug("save contextual validity %v %v", id, valid)
+	m.With().Debug("save block contextual validity", id, log.Bool("validity", valid))
 	return m.contextualValidity.Put(id.Bytes(), v)
 }
 
+// SaveLayerInputVector saves the input vote vector for a layer (hare results)
+func (m *DB) SaveLayerInputVector(hash types.Hash32, vector []types.BlockID) error {
+	bytes, err := types.InterfaceToBytes(vector)
+	if err != nil {
+		return err
+	}
+
+	return m.inputVector.Put(hash.Bytes(), bytes)
+}
+
+// InvalidateLayer receives notification from Hare that it failed for a layer. If Hare explicitly fails for a
+// layer, we consider all blocks in that layer to be invalid. Note that simply not having received a layer from Hare
+// as _validated_ is not sufficient information since we might still be waiting for Hare to finish for the layer. This
+// method lets us know that Hare has given up.
+// Note: this method is only called from the Hare's outputCollectionLoop, and there should only ever be one of those
+// running. If it is called on any other code paths, it will need to be made goroutine safe.
+func (m *DB) InvalidateLayer(ctx context.Context, layerID types.LayerID) {
+	m.WithContext(ctx).With().Info("recording hare invalidated layer in mesh", layerID)
+	m.invalidatedLayers[layerID] = struct{}{}
+}
+
 // RecordCoinflip saves the weak coinflip result to memory for the given layer
 func (m *DB) RecordCoinflip(ctx context.Context, layerID types.LayerID, coinflip bool) {
 	m.WithContext(ctx).With().Info("recording coinflip result for layer in mesh",
@@ -344,17 +372,24 @@ func (m *DB) RecordCoinflip(ctx context.Context, layerID types.LayerID, coinflip
 }
 
 // GetCoinflip returns the weak coinflip result for the given layer
-func (m *DB) GetCoinflip(ctx context.Context, layerID types.LayerID) (bool, bool) {
+func (m *DB) GetCoinflip(_ context.Context, layerID types.LayerID) (bool, bool) {
 	coin, exists := m.coinflips[layerID]
 	return coin, exists
 }
 
-func (m *DB) defaulGetLayerInputVectorByID(id types.LayerID) ([]types.BlockID, error) {
-	by, err := m.inputVector.Get(types.CalcHash32(id.Bytes()).Bytes())
+func (m *DB) defaultGetLayerInputVectorByID(lyrid types.LayerID) ([]types.BlockID, error) {
+	by, err := m.inputVector.Get(types.CalcHash32(lyrid.Bytes()).Bytes())
 	if err != nil {
+		// check if this layer was marked invalid
+		if _, ok := m.invalidatedLayers[lyrid]; ok {
+			return nil, ErrInvalidLayer
+		}
+
+		// otherwise, no result, so we're still waiting for Hare results (or won't ever get them) for this layer
 		return nil, err
 	}
 	var v []types.BlockID
+	// note: an EMPTY (non-nil) vector will come back as NIL here (this appears to be a quirk of XDR)
 	err = types.BytesToInterface(by, &v)
 	return v, err
 }
@@ -370,12 +405,25 @@ func (m *DB) GetLayerInputVector(hash types.Hash32) ([]types.BlockID, error) {
 	return v, err
 }
 
+// InputVectorBackupFunc specifies a backup function for testing
+type InputVectorBackupFunc func(id types.LayerID) ([]types.BlockID, error)
+
 // GetLayerInputVectorByID gets the input vote vector for a layer (hare results)
 func (m *DB) GetLayerInputVectorByID(id types.LayerID) ([]types.BlockID, error) {
 	if m.InputVectorBackupFunc != nil {
 		return m.InputVectorBackupFunc(id)
 	}
-	return m.defaulGetLayerInputVectorByID(id)
+	return m.defaultGetLayerInputVectorByID(id)
+}
+
+// SetInputVectorBackupFunc sets the backup function for testing
+func (m *DB) SetInputVectorBackupFunc(fn InputVectorBackupFunc) {
+	m.InputVectorBackupFunc = fn
+}
+
+// GetInputVectorBackupFunc gets the backup function for testing
+func (m *DB) GetInputVectorBackupFunc() InputVectorBackupFunc {
+	return m.InputVectorBackupFunc
 }
 
 // SaveLayerInputVectorByID gets the input vote vector for a layer (hare results)
@@ -385,12 +433,12 @@ func (m *DB) SaveLayerInputVectorByID(ctx context.Context, id types.LayerID, blk
 		id,
 		log.String("iv_hash", hash.ShortString()))
 
-	bytes, err := types.InterfaceToBytes(blks)
+	ifBytes, err := types.InterfaceToBytes(blks)
 	if err != nil {
 		return err
 	}
 
-	return m.inputVector.Put(hash.Bytes(), bytes)
+	return m.inputVector.Put(hash.Bytes(), ifBytes)
 }
 
 func (m *DB) persistProcessedLayer(lyr *ProcessedLayer) error {
@@ -427,9 +475,9 @@ func (m *DB) writeBlock(bl *types.Block) error {
 		Signature: bl.Signature,
 		MinerID:   bl.MinerID().Bytes(),
 	}
-	if bytes, err := types.InterfaceToBytes(block); err != nil {
+	if ifBytes, err := types.InterfaceToBytes(block); err != nil {
 		return fmt.Errorf("could not encode block: %w", err)
-	} else if err := m.blocks.Put(bl.ID().AsHash32().Bytes(), bytes); err != nil {
+	} else if err := m.blocks.Put(bl.ID().AsHash32().Bytes(), ifBytes); err != nil {
 		return fmt.Errorf("could not add block %v to database: %w", bl.ID(), err)
 	} else if err := m.updateLayerWithBlock(bl); err != nil {
 		return fmt.Errorf("could not update layer %v with new block %v: %w", bl.Layer(), bl.ID(), err)
@@ -454,20 +502,23 @@ func (m *DB) updateLayerWithBlock(blk *types.Block) error {
 	} else {
 		blockIds, err = types.BytesToBlockIds(ids)
 		if err != nil {
-			return errors.New("could not get all blocks from database")
+			return fmt.Errorf("could not get all blocks from database for layer %v: %w", blk.LayerIndex, err)
 		}
 	}
-	m.Debug("added block %v to layer %v", blk.ID(), blk.LayerIndex)
+	m.With().Debug("added block to database layer index", blk.ID(), blk.LayerIndex)
 
 	blockIds = append(blockIds, blk.ID())
 	types.SortBlockIDs(blockIds)
 	w, err := types.BlockIdsToBytes(blockIds)
 	if err != nil {
-		return errors.New("could not encode layer blk ids")
+		return fmt.Errorf("could not encode layer block ids for layer %v: %w", blk.LayerIndex, err)
+	}
+	err = m.layers.Put(blk.LayerIndex.Bytes(), w)
+	if err != nil {
+		return fmt.Errorf("could not write updated layer index to database for layer %v: %w", blk.LayerIndex, err)
 	}
 
-	m.layers.Put(blk.LayerIndex.Bytes(), w)
-	return nil
+	return m.layers.Put(blk.LayerIndex.Bytes(), w)
 }
 
 func (m *DB) getLayerHashKey(layerID types.LayerID) []byte {
@@ -690,7 +741,7 @@ func (m *DB) writeTransactions(block *types.Block, txs ...*types.Transaction) er
 		if err != nil {
 			return fmt.Errorf("could not marshall tx %v to bytes: %v", t.ID().ShortString(), err)
 		}
-		m.Log.Info("storing tx id %v size %v", t.ID().ShortString(), len(bytes))
+		m.Log.With().Debug("storing transaction", t.ID(), log.Int("tx_length", len(bytes)))
 		if err := batch.Put(t.ID().Bytes(), bytes); err != nil {
 			return fmt.Errorf("could not write tx %v to database: %v", t.ID().ShortString(), err)
 		}
@@ -1006,7 +1057,7 @@ func (m *DB) BlocksByValidity(blocks []*types.Block) (validBlocks, invalidBlocks
 	for _, b := range blocks {
 		valid, err := m.ContextualValidity(b.ID())
 		if err != nil {
-			m.With().Warning("could not get contextual validity by block", b.ID(), log.Err(err))
+			m.With().Warning("could not get contextual validity for block in list", b.ID(), log.Err(err))
 		}
 		if valid {
 			validBlocks = append(validBlocks, b)
@@ -1046,6 +1097,7 @@ func (m *DB) LayerContextuallyValidBlocks(layer types.LayerID) (map[types.BlockI
 	for _, b := range blockIds {
 		valid, err := m.ContextualValidity(b)
 		if err != nil {
+			m.With().Warning("could not get contextual validity for block in layer", b, layer, log.Err(err))
 			cvErrors[err.Error()] = append(cvErrors[err.Error()], b)
 			cvErrorCount++
 		}
@@ -1057,7 +1109,7 @@ func (m *DB) LayerContextuallyValidBlocks(layer types.LayerID) (map[types.BlockI
 		validBlks[b] = struct{}{}
 	}
 
-	m.With().Info("count of contextually valid blocks in layer",
+	m.With().Debug("count of contextually valid blocks in layer",
 		layer,
 		log.Int("count_valid", len(validBlks)),
 		log.Int("count_error", cvErrorCount),
diff --git a/mesh/reward_test.go b/mesh/reward_test.go
index 0de43097754..38d019e7d19 100644
--- a/mesh/reward_test.go
+++ b/mesh/reward_test.go
@@ -189,7 +189,7 @@ func TestMesh_integration(t *testing.T) {
 
 		l, err := layers.GetLayer(types.NewLayerID(uint32(i)))
 		assert.NoError(t, err)
-		layers.ValidateLayer(l)
+		layers.ValidateLayer(context.TODO(), l)
 	}
 	// since there can be a difference of up to x lerners where x is the number of blocks due to round up of penalties when distributed among all blocks
 	totalPayout := l3Rewards + ConfigTst().BaseReward.Int64()
@@ -201,8 +201,7 @@ func TestMesh_updateStateWithLayer(t *testing.T) {
 	// test state is the same if receiving result from tortoise after same result from hare received
 	// test state is the same after late block
 	// test panic after block from hare was not found in mesh
-	// test that state does not advance when layer x +2 is received before layer x+1, and then test that all layers are pushed
-
+	// test that state does not advance when layer x+2 is received before layer x+1, and then test that all layers are pushed
 	numOfLayers := 10
 	numOfBlocks := 10
 	maxTxs := 20
@@ -215,25 +214,30 @@ func TestMesh_updateStateWithLayer(t *testing.T) {
 		createLayer(t, mesh, types.NewLayerID(uint32(i)), numOfBlocks, maxTxs, atxDB)
 		l, err := mesh.GetLayer(types.NewLayerID(uint32(i)))
 		assert.NoError(t, err)
-		mesh.ValidateLayer(l)
+		mesh.ValidateLayer(context.TODO(), l)
 	}
 
 	s2 := &MockMapState{Rewards: make(map[types.Address]*big.Int)}
 	mesh2, atxDB2 := getMeshWithMapState(t, "t2", s2)
 
-	// this should be played until numOfLayers -1 if we want to compare states
+	// this should be played until numOfLayers-1 if we want to compare states
 	for i := 1; i <= numOfLayers-1; i++ {
 		blockIds := copyLayer(t, mesh, mesh2, atxDB2, types.NewLayerID(uint32(i)))
 		mesh2.HandleValidatedLayer(context.TODO(), types.NewLayerID(uint32(i)), blockIds)
 	}
+
 	// test states are the same when one input is from tortoise and the other from hare
-	assert.Equal(t, s.Txs, s2.Txs)
+	assert.NotEqual(t, s.Txs, s2.Txs)
 
 	for i := 1; i <= numOfLayers; i++ {
 		l, err := mesh.GetLayer(types.NewLayerID(uint32(i)))
 		assert.NoError(t, err)
-		mesh2.ValidateLayer(l)
+		mesh2.ValidateLayer(context.TODO(), l)
 	}
+
+	// test states are the same when one input is from tortoise and the other from hare
+	assert.Equal(t, s.Txs, s2.Txs)
+
 	// test state is the same if receiving result from tortoise after same result from hare received
 	assert.ObjectsAreEqualValues(s.Txs, s2.Txs)
 
@@ -242,14 +246,14 @@ func TestMesh_updateStateWithLayer(t *testing.T) {
 	assert.NoError(t, err)
 
 	blk := layer4.Blocks()[0]
-	mesh2.HandleLateBlock(blk)
+	mesh2.HandleLateBlock(context.TODO(), blk)
 	assert.Equal(t, s.Txs, s2.Txs)
 
-	// test that state does not advance when layer x +2 is received before layer x+1, and then test that all layers are pushed
+	// test that state does not advance when layer x+2 is received before layer x+1, and then test that all layers are pushed
 	s3 := &MockMapState{Rewards: make(map[types.Address]*big.Int)}
 	mesh3, atxDB3 := getMeshWithMapState(t, "t3", s3)
 
-	// this should be played until numOfLayers -1 if we want to compare states
+	// this should be played until numOfLayers-1 if we want to compare states
 	for i := 1; i <= numOfLayers-3; i++ {
 		blockIds := copyLayer(t, mesh, mesh3, atxDB3, types.NewLayerID(uint32(i)))
 		mesh3.HandleValidatedLayer(context.TODO(), types.NewLayerID(uint32(i)), blockIds)
@@ -261,6 +265,22 @@ func TestMesh_updateStateWithLayer(t *testing.T) {
 
 	blockIds = copyLayer(t, mesh, mesh3, atxDB3, types.NewLayerID(uint32(numOfLayers)-2))
 	mesh3.HandleValidatedLayer(context.TODO(), types.NewLayerID(uint32(numOfLayers)-2), blockIds)
+	assert.Greater(t, len(s3.Txs), s3Len) // expect txs from layer 6 to have been applied
+	s3Len = len(s3.Txs)
+
+	// re-validate layer 8 (applying layer 7 state)
+	mesh3.HandleValidatedLayer(context.TODO(), types.NewLayerID(uint32(numOfLayers)-1), blockIds)
+	assert.Greater(t, len(s3.Txs), s3Len) // expect txs from layer 7 to have been applied
+	s3Len = len(s3.Txs)
+
+	// validate layer 9 (applying layer 8 state)
+	blockIds = copyLayer(t, mesh, mesh3, atxDB3, types.NewLayerID(uint32(numOfLayers)))
+	mesh3.HandleValidatedLayer(context.TODO(), types.NewLayerID(uint32(numOfLayers)), blockIds)
+	assert.Greater(t, len(s3.Txs), s3Len) // expect txs from layer 9 to have been applied
+
+	// now everything should have been applied
+	blockIds = copyLayer(t, mesh, mesh3, atxDB3, types.NewLayerID(uint32(numOfLayers)-1))
+	mesh3.HandleValidatedLayer(context.TODO(), types.NewLayerID(uint32(numOfLayers)-1), blockIds)
 	assert.Equal(t, s.Txs, s3.Txs)
 }
 
@@ -293,18 +313,18 @@ type meshValidatorBatchMock struct {
 	layerHash      types.Hash32
 }
 
-func (m *meshValidatorBatchMock) ValidateLayer(lyr *types.Layer) {
+func (m *meshValidatorBatchMock) ValidateLayer(_ context.Context, lyr *types.Layer) {
 	m.mesh.setProcessedLayer(lyr)
 	layerID := lyr.Index()
 	if layerID.Uint32() == 0 {
 		return
 	}
 	if layerID.Uint32()%m.batchSize == 0 {
-		m.mesh.pushLayersToState(layerID.Sub(m.batchSize), layerID)
+		m.mesh.pushLayersToState(context.TODO(), layerID.Sub(m.batchSize), layerID)
 		return
 	}
 	prevPBase := layerID.Sub(layerID.Uint32() % m.batchSize)
-	m.mesh.pushLayersToState(prevPBase, prevPBase)
+	m.mesh.pushLayersToState(context.TODO(), prevPBase, prevPBase)
 }
 
 func TestMesh_AccumulateRewards(t *testing.T) {
@@ -333,19 +353,19 @@ func TestMesh_AccumulateRewards(t *testing.T) {
 	l4, err := mesh.GetLayer(types.NewLayerID(4))
 	assert.NoError(t, err)
 	// Test negative case
-	mesh.ValidateLayer(l4)
+	mesh.ValidateLayer(context.TODO(), l4)
 	assert.Equal(t, oldTotal, s.TotalReward)
 
 	l5, err := mesh.GetLayer(types.NewLayerID(5))
 	assert.NoError(t, err)
 	// Since batch size is 6, rewards will not be applied yet at this point
-	mesh.ValidateLayer(l5)
+	mesh.ValidateLayer(context.TODO(), l5)
 	assert.Equal(t, oldTotal, s.TotalReward)
 
 	l6, err := mesh.GetLayer(types.NewLayerID(6))
 	assert.NoError(t, err)
 	// Rewards will be applied at this point
-	mesh.ValidateLayer(l6)
+	mesh.ValidateLayer(context.TODO(), l6)
 
 	// When distributing rewards to blocks they are rounded down, so we have to allow up to numOfBlocks difference
 	totalPayout := firstLayerRewards + ConfigTst().BaseReward.Int64()
diff --git a/miner/block_builder.go b/miner/block_builder.go
index f524e93babb..6b4d27df91a 100644
--- a/miner/block_builder.go
+++ b/miner/block_builder.go
@@ -95,20 +95,20 @@ func NewBlockBuilder(
 	syncer syncer,
 	projector projector,
 	txPool txPool,
-	lg log.Log,
+	logger log.Log,
 ) *BlockBuilder {
 	seed := binary.BigEndian.Uint64(md5.New().Sum([]byte(config.MinerID.Key)))
 
-	db, err := database.Create("builder", 16, 16, lg)
+	db, err := database.Create("builder", 16, 16, logger)
 	if err != nil {
-		lg.Panic("cannot create block builder DB %v", err)
+		logger.With().Panic("cannot create block builder database", log.Err(err))
 	}
 
 	return &BlockBuilder{
 		minerID:         config.MinerID,
 		signer:          sgn,
 		hdist:           config.Hdist,
-		Log:             lg,
+		Log:             logger,
 		rnd:             rand.New(rand.NewSource(int64(seed))),
 		beginRoundEvent: beginRoundEvent,
 		stopChan:        make(chan struct{}),
@@ -186,11 +186,20 @@ func (t *BlockBuilder) stopped() bool {
 	}
 }
 
-func (t *BlockBuilder) createBlock(ctx context.Context, id types.LayerID, atxID types.ATXID, eligibilityProof types.BlockEligibilityProof, txids []types.TransactionID, activeSet []types.ATXID) (*types.Block, error) {
+func (t *BlockBuilder) createBlock(
+	ctx context.Context,
+	id types.LayerID,
+	atxID types.ATXID,
+	eligibilityProof types.BlockEligibilityProof,
+	txids []types.TransactionID,
+	activeSet []types.ATXID,
+) (*types.Block, error) {
+	logger := t.WithContext(ctx)
 	if !id.After(types.GetEffectiveGenesis()) {
 		return nil, errors.New("cannot create blockBytes in genesis layer")
 	}
 
+	// get the most up-to-date base block, and a list of diffs versus local opinion
 	base, diffs, err := t.baseBlockP.BaseBlock(ctx)
 	if err != nil {
 		return nil, err
@@ -212,14 +221,14 @@ func (t *BlockBuilder) createBlock(ctx context.Context, id types.LayerID, atxID
 	epoch := id.GetEpoch()
 	refBlock, err := t.getRefBlock(epoch)
 	if err != nil {
-		t.With().Debug("creating block with active set (no reference block for epoch)",
+		logger.With().Debug("creating block with active set (no reference block for epoch)",
 			log.Int("active_set_size", len(activeSet)),
 			log.FieldNamed("ref_block", refBlock),
 			log.Err(err))
 		atxs := activeSet
 		b.ActiveSet = &atxs
 	} else {
-		t.With().Debug("creating block with reference block (no active set)",
+		logger.With().Debug("creating block with reference block (no active set)",
 			log.Int("active_set_size", len(activeSet)),
 			log.FieldNamed("ref_block", refBlock))
 		b.RefBlock = &refBlock
@@ -235,14 +244,14 @@ func (t *BlockBuilder) createBlock(ctx context.Context, id types.LayerID, atxID
 	bl.Initialize()
 
 	if b.ActiveSet != nil {
-		t.With().Info("storing ref block", epoch, bl.ID())
+		logger.With().Debug("storing ref block", epoch, bl.ID())
 		if err := t.storeRefBlock(epoch, bl.ID()); err != nil {
-			t.With().Error("cannot store ref block", epoch, log.Err(err))
+			logger.With().Error("cannot store ref block", epoch, log.Err(err))
 			//todo: panic?
 		}
 	}
 
-	t.Event().Info("block created", bl.Fields()...)
+	logger.Event().Info("block created", bl.Fields()...)
 	return bl, nil
 }
 
@@ -255,7 +264,8 @@ func (t *BlockBuilder) createBlockLoop(ctx context.Context) {
 			return
 
 		case layerID := <-t.beginRoundEvent:
-			logger.With().Debug("builder got layer", layerID)
+			logger := logger.WithFields(layerID, layerID.GetEpoch())
+			logger.Info("builder got layer")
 			if !t.syncer.IsSynced(ctx) {
 				logger.Info("not synced yet, not building a block in this round")
 				continue
@@ -277,9 +287,7 @@ func (t *BlockBuilder) createBlockLoop(ctx context.Context) {
 			}
 			// TODO: include multiple proofs in each block and weigh blocks where applicable
 
-			logger.With().Info("eligible for one or more blocks in layer",
-				log.Int("count", len(proofs)),
-				layerID)
+			logger.With().Info("eligible for one or more blocks in layer", log.Int("count", len(proofs)))
 			for _, eligibilityProof := range proofs {
 				txList, _, err := t.TransactionPool.GetTxsForBlock(t.txsPerBlock, t.projector.GetProjection)
 				if err != nil {
@@ -288,7 +296,6 @@ func (t *BlockBuilder) createBlockLoop(ctx context.Context) {
 					continue
 				}
 				blk, err := t.createBlock(ctx, layerID, atxID, eligibilityProof, txList, atxs)
-
 				if err != nil {
 					events.ReportDoneCreatingBlock(true, layerID.Uint32(), "cannot create new block")
 					logger.With().Error("failed to create new block", log.Err(err))
diff --git a/miner/builder_test.go b/miner/builder_test.go
index 92a7f305552..0bd9d713fab 100644
--- a/miner/builder_test.go
+++ b/miner/builder_test.go
@@ -290,55 +290,6 @@ var (
 	atx5 = types.ATXID(five)
 )
 
-var (
-	b1 = types.NewExistingBlock(types.NewLayerID(1), []byte{1}, nil)
-	b2 = types.NewExistingBlock(types.NewLayerID(1), []byte{2}, nil)
-	b3 = types.NewExistingBlock(types.NewLayerID(1), []byte{3}, nil)
-	b4 = types.NewExistingBlock(types.NewLayerID(1), []byte{4}, nil)
-	b5 = types.NewExistingBlock(types.NewLayerID(1), []byte{5}, nil)
-	b6 = types.NewExistingBlock(types.NewLayerID(1), []byte{6}, nil)
-	b7 = types.NewExistingBlock(types.NewLayerID(1), []byte{7}, nil)
-)
-
-func genBlockIds() []types.BlockID {
-	bids := []types.BlockID{b1.ID(), b2.ID(), b3.ID(), b4.ID(), b5.ID(), b6.ID(), b7.ID()}
-	for i := 0; i < len(bids)*2; i++ {
-		l := rand.Int() % len(bids)
-		j := rand.Int() % len(bids)
-		bids[l], bids[j] = bids[j], bids[l]
-	}
-
-	return bids
-}
-
-type mockResult struct {
-	err error
-	ids map[types.LayerID][]types.BlockID
-}
-
-func newMockResult() *mockResult {
-	m := &mockResult{}
-	m.ids = make(map[types.LayerID][]types.BlockID)
-	return m
-}
-
-func (m *mockResult) set(id types.LayerID) []types.BlockID {
-	bids := genBlockIds()
-	m.ids[id] = bids
-
-	return bids
-}
-
-func (m *mockResult) GetResult(id types.LayerID) ([]types.BlockID, error) {
-	bl, ok := m.ids[id]
-	if ok {
-		return bl, nil
-	}
-	return nil, m.err
-}
-
-var errExample = errors.New("example errExample")
-
 type mockMesh struct {
 	b   []*types.Block
 	err error
diff --git a/p2p/discovery/addrbook.go b/p2p/discovery/addrbook.go
index c1460acc755..57384861ab9 100644
--- a/p2p/discovery/addrbook.go
+++ b/p2p/discovery/addrbook.go
@@ -523,12 +523,11 @@ func (a *addrBook) Start() {
 // Stop gracefully shuts down the address manager by stopping the main handler.
 func (a *addrBook) Stop() {
 	if atomic.AddInt32(&a.shutdown, 1) != 1 {
-		a.logger.Warning("Address manager is already in the process of " +
-			"shutting down")
+		a.logger.Warning("address manager is already in the process of shutting down")
 		return
 	}
 
-	a.logger.Info("Address manager shutting down")
+	a.logger.Info("address manager shutting down")
 	close(a.quit)
 	a.wg.Wait()
 	return
diff --git a/p2p/discovery/getaddress.go b/p2p/discovery/getaddress.go
index 58504596d15..3a7c3fb2144 100644
--- a/p2p/discovery/getaddress.go
+++ b/p2p/discovery/getaddress.go
@@ -80,7 +80,11 @@ func (p *protocol) GetAddresses(ctx context.Context, remoteID p2pcrypto.PublicKe
 			return
 		}
 
-		ch <- nodes
+		select {
+		case ch <- nodes:
+		default:
+			plogger.With().Error("get addresses listener timed out, dropping response")
+		}
 	}
 
 	err = p.msgServer.SendRequest(ctx, server.GetAddresses, []byte(""), remoteID, resHandler, func(err error) {})
diff --git a/p2p/discovery/ping.go b/p2p/discovery/ping.go
index cb0fa91d670..1843b6edf0c 100644
--- a/p2p/discovery/ping.go
+++ b/p2p/discovery/ping.go
@@ -65,7 +65,7 @@ func (p *protocol) verifyPinger(from net.Addr, pi *node.Info) error {
 // Ping notifies `peer` about our p2p identity.
 func (p *protocol) Ping(ctx context.Context, peer p2pcrypto.PublicKey) error {
 	plogger := p.logger.WithFields(log.String("type", "ping"), log.String("to", peer.String()))
-	plogger.Debug("send request")
+	plogger.Debug("send ping request")
 
 	data, err := types.InterfaceToBytes(p.local)
 	if err != nil {
@@ -74,19 +74,22 @@ func (p *protocol) Ping(ctx context.Context, peer p2pcrypto.PublicKey) error {
 	ch := make(chan []byte)
 	foo := func(msg []byte) {
 		defer close(ch)
-		plogger.Debug("handle response")
+		plogger.Debug("handle ping response")
 		sender := &node.Info{}
 		err := types.BytesToInterface(msg, sender)
 
 		if err != nil {
-			plogger.Warning("got unreadable pong. err=%v", err)
+			plogger.With().Warning("got unreadable pong", log.Err(err))
 			return
 		}
 
-		// todo: if we pinged it we already have id so no need to update
-		// todo : but what if id or listen address has changed ?
-
-		ch <- sender.ID.Bytes()
+		// TODO: if we pinged it we already have id so no need to update,
+		//   but what if id or listen address has changed?
+		select {
+		case ch <- sender.ID.Bytes():
+		default:
+			plogger.With().Error("ping listener timed out, dropping response")
+		}
 	}
 
 	err = p.msgServer.SendRequest(ctx, server.PingPong, data, peer, foo, func(err error) {})
diff --git a/p2p/discovery/protocol_test.go b/p2p/discovery/protocol_test.go
index 0c102aa2a88..19dfd3811a3 100644
--- a/p2p/discovery/protocol_test.go
+++ b/p2p/discovery/protocol_test.go
@@ -35,7 +35,6 @@ func newTestNode(tb testing.TB, simulator *service.Simulator) *testNode {
 }
 
 func TestPing_Ping(t *testing.T) {
-
 	sim := service.NewSimulator()
 	p1 := newTestNode(t, sim)
 	p2 := newTestNode(t, sim)
@@ -98,7 +97,6 @@ func TestPing_Ping_Concurrency(t *testing.T) {
 // todo : test verifypinger
 
 func TestFindNodeProtocol_FindNode(t *testing.T) {
-
 	sim := service.NewSimulator()
 	n1 := newTestNode(t, sim)
 	n2 := newTestNode(t, sim)
@@ -113,7 +111,6 @@ func TestFindNodeProtocol_FindNode(t *testing.T) {
 
 //
 func TestFindNodeProtocol_FindNode2(t *testing.T) {
-
 	sim := service.NewSimulator()
 
 	n1 := newTestNode(t, sim)
@@ -147,7 +144,6 @@ func TestFindNodeProtocol_FindNode2(t *testing.T) {
 }
 
 func TestFindNodeProtocol_FindNode_Concurrency(t *testing.T) {
-
 	concurrency := 100
 
 	sim := service.NewSimulator()
diff --git a/p2p/gossip/protocol.go b/p2p/gossip/protocol.go
index 9580f40ea21..51667820e0a 100644
--- a/p2p/gossip/protocol.go
+++ b/p2p/gossip/protocol.go
@@ -22,6 +22,7 @@ const propagateHandleBufferSize = 5000 // number of MessageValidation that we al
 type peersManager interface {
 	GetPeers() []peers.Peer
 	PeerCount() uint64
+	Close()
 }
 
 // Interface for the underlying p2p layer
@@ -229,6 +230,7 @@ func (p *Protocol) propagationEventLoop(ctx context.Context) {
 
 		case <-p.shutdownCtx.Done():
 			p.pq.Close()
+			p.peers.Close()
 			p.WithContext(ctx).Error("propagate event loop stopped: protocol shutdown")
 			return
 		}
diff --git a/p2p/gossip/protocol_mock_test.go b/p2p/gossip/protocol_mock_test.go
index 5fb0513e9c4..24509570f9e 100644
--- a/p2p/gossip/protocol_mock_test.go
+++ b/p2p/gossip/protocol_mock_test.go
@@ -64,6 +64,18 @@ func (mr *MockpeersManagerMockRecorder) PeerCount() *gomock.Call {
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeerCount", reflect.TypeOf((*MockpeersManager)(nil).PeerCount))
 }
 
+// Close mocks base method
+func (m *MockpeersManager) Close() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Close")
+}
+
+// Close indicates an expected call of Close
+func (mr *MockpeersManagerMockRecorder) Close() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockpeersManager)(nil).Close))
+}
+
 // MockbaseNetwork is a mock of baseNetwork interface
 type MockbaseNetwork struct {
 	ctrl     *gomock.Controller
diff --git a/p2p/gossip/protocol_test.go b/p2p/gossip/protocol_test.go
index 1ce9d741f4a..cc4e1e70c3f 100644
--- a/p2p/gossip/protocol_test.go
+++ b/p2p/gossip/protocol_test.go
@@ -106,7 +106,11 @@ func (mpq *mockPriorityQueue) Length() int {
 
 func TestPropagationEventLoop(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
-	protocol := NewProtocol(ctx, config.SwarmConfig{}, nil, nil, nil, logtest.New(t))
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	peersManager := NewMockpeersManager(ctrl)
+	peersManager.EXPECT().Close()
+	protocol := NewProtocol(ctx, config.SwarmConfig{}, nil, peersManager, nil, logtest.New(t))
 	called := make(chan struct{})
 	mpq := mockPriorityQueue{called: called, bus: make(chan struct{}, 10)}
 	protocol.pq = &mpq
diff --git a/p2p/peers/peers.go b/p2p/peers/peers.go
index 87ed6062c1c..7f1027d5b5a 100644
--- a/p2p/peers/peers.go
+++ b/p2p/peers/peers.go
@@ -145,7 +145,8 @@ func (p *Peers) listen(added, expired chan p2pcrypto.PublicKey) {
 			}
 			isAdded = true
 			peerSet[peer] = struct{}{}
-			p.log.With().Debug("new peer", log.String("peer", peer.String()),
+			p.log.With().Debug("new peer",
+				log.String("peer", peer.String()),
 				log.Int("total", len(peerSet)),
 			)
 		case peer, ok := <-expired:
@@ -154,7 +155,8 @@ func (p *Peers) listen(added, expired chan p2pcrypto.PublicKey) {
 			}
 			isAdded = false
 			delete(peerSet, peer)
-			p.log.With().Debug("expired peer", log.String("peer", peer.String()),
+			p.log.With().Debug("expired peer",
+				log.String("peer", peer.String()),
 				log.Int("total", len(peerSet)),
 			)
 		case req := <-p.requests:
diff --git a/p2p/server/msgserver.go b/p2p/server/msgserver.go
index 8d573d79735..a155d4f8dd6 100644
--- a/p2p/server/msgserver.go
+++ b/p2p/server/msgserver.go
@@ -107,9 +107,9 @@ func NewMsgServer(ctx context.Context, network Service, name string, requestLife
 
 // Close stops the MessageServer
 func (p *MessageServer) Close() {
-	p.With().Info("closing MessageServer")
+	p.With().Info("closing message server")
 	p.cancel()
-	p.With().Info("waiting for message workers to finish...")
+	p.With().Info("waiting for message workers to finish")
 	p.tg.Wait()
 	p.With().Info("message workers all done")
 }
diff --git a/p2p/service/sim.go b/p2p/service/sim.go
index 5ae664df606..5e25b4560f3 100644
--- a/p2p/service/sim.go
+++ b/p2p/service/sim.go
@@ -3,6 +3,7 @@ package service
 import (
 	"context"
 	"errors"
+	"fmt"
 	"io"
 	"net"
 	"sync"
@@ -78,7 +79,12 @@ func (s *Simulator) SubscribeToPeerEvents(myid p2pcrypto.Key) (chan p2pcrypto.Pu
 func (s *Simulator) publishNewPeer(peer p2pcrypto.PublicKey) {
 	s.subLock.Lock()
 	for _, ch := range s.newPeersSubs {
-		ch <- peer
+		log.Debug("publish new peer on chan with len %v, cap %v", len(ch), cap(ch))
+		select {
+		case ch <- peer:
+		default:
+			log.Warning("unable to publish new peer event to subscriber")
+		}
 	}
 	s.subLock.Unlock()
 }
@@ -87,7 +93,11 @@ func (s *Simulator) publishNewPeer(peer p2pcrypto.PublicKey) {
 func (s *Simulator) publishDelPeer(peer p2pcrypto.PublicKey) {
 	s.subLock.Lock()
 	for _, ch := range s.delPeersSubs {
-		ch <- peer
+		select {
+		case ch <- peer:
+		default:
+			log.Warning("unable to publish delete peer event to subscriber")
+		}
 	}
 	s.subLock.Unlock()
 }
@@ -278,10 +288,14 @@ func (sn *Node) sendMessageImpl(_ context.Context, nodeID p2pcrypto.PublicKey, p
 	thec, ok := sn.sim.protocolDirectHandler[nodeID][protocol]
 	sn.sim.mutex.RUnlock()
 	if ok {
-		thec <- simDirectMessage{simulatorMetadata(), payload, sn.Info.PublicKey()}
+		select {
+		case thec <- simDirectMessage{simulatorMetadata(), payload, sn.Info.PublicKey()}:
+		default:
+			return fmt.Errorf("unable to send direct message for protocol %v node %v", protocol, nodeID.String())
+		}
 		return nil
 	}
-	return errors.New("could not find " + protocol + " handler for node: " + nodeID.String())
+	return fmt.Errorf("could not find %v handler for node %v", protocol, nodeID.String())
 }
 
 func (sn *Node) sleep(delay uint32) {
@@ -364,22 +378,12 @@ func (sn *Node) RegisterDirectProtocolWithChannel(protocol string, ingressChanne
 	return ingressChannel
 }
 
-// Shutdown closes all node channels are remove it from the Simulator map
+// Shutdown closes all node channels and removes them from the Simulator map
 func (sn *Node) Shutdown() {
 	sn.sim.mutex.Lock()
-	// TODO: close all chans, but that makes us send on nil chan.
 	delete(sn.sim.protocolDirectHandler, sn.Info.PublicKey())
 	delete(sn.sim.protocolGossipHandler, sn.Info.PublicKey())
+	delete(sn.sim.nodes, sn.Info.PublicKey())
 	sn.sim.mutex.Unlock()
-
-	sn.sim.subLock.Lock()
-	for _, ch := range sn.sim.newPeersSubs {
-		close(ch)
-	}
-	sn.sim.newPeersSubs = nil
-	for _, ch := range sn.sim.delPeersSubs {
-		close(ch)
-	}
-	sn.sim.delPeersSubs = nil
-	sn.sim.subLock.Unlock()
+	sn.sim.publishDelPeer(sn.Info.PublicKey())
 }
diff --git a/p2p/switch.go b/p2p/switch.go
index 0ff20da1208..86ea23ea5c1 100644
--- a/p2p/switch.go
+++ b/p2p/switch.go
@@ -442,11 +442,11 @@ func (s *Switch) Shutdown() {
 
 		for i := range s.directProtocolHandlers {
 			delete(s.directProtocolHandlers, i)
-			// close(prt) //todo: signal protocols to shutdown with closing chan. (this makes us send on closed chan. )
+			//close(prt) //todo: signal protocols to shutdown with closing chan. (this makes us send on closed chan.)
 		}
 		for i := range s.gossipProtocolHandlers {
 			delete(s.gossipProtocolHandlers, i)
-			// close(prt) //todo: signal protocols to shutdown with closing chan. (this makes us send on closed chan. )
+			//close(prt) //todo: signal protocols to shutdown with closing chan. (this makes us send on closed chan.)
 		}
 
 		s.peerLock.Lock()
diff --git a/state/dump.go b/state/dump.go
index 6cf492882b2..01ca641c022 100644
--- a/state/dump.go
+++ b/state/dump.go
@@ -48,10 +48,10 @@ func (state *DB) RawDump() types.MultipleAccountsState {
 
 // Dump dumps the current state into json form, encoded into bytes.
 func (state *DB) Dump() []byte {
-	json, err := json.MarshalIndent(state.RawDump(), "", "	")
+	stateJSON, err := json.MarshalIndent(state.RawDump(), "", "	")
 	if err != nil {
 		fmt.Println("dump err", err)
 	}
 
-	return json
+	return stateJSON
 }
diff --git a/state/global_state.go b/state/global_state.go
index 39bdd3b1693..0e738448801 100644
--- a/state/global_state.go
+++ b/state/global_state.go
@@ -160,6 +160,7 @@ func (state *DB) updateStateObj(StateObj *Object) {
 func (state *DB) getStateObj(addr types.Address) (StateObj *Object) {
 	state.lock.Lock()
 	defer state.lock.Unlock()
+
 	// Prefer 'live' objects.
 	if obj := state.stateObjects[addr]; obj != nil {
 		/*if obj.deleted {
@@ -179,6 +180,7 @@ func (state *DB) getStateObj(addr types.Address) (StateObj *Object) {
 		log.Error("Failed to decode state object", "addr", addr, "err", err)
 		return nil
 	}
+
 	// Insert into the live set.
 	obj := newObject(state, addr, data)
 	state.setStateObj(obj)
@@ -265,6 +267,7 @@ func (state *DB) Copy() *DB {
 func (state *DB) Commit() (root types.Hash32, err error) {
 	state.lock.Lock()
 	defer state.lock.Unlock()
+
 	// Commit objects to the trie.
 	for addr, stateObject := range state.stateObjects {
 		_, isDirty := state.stateObjectsDirty[addr]
@@ -273,6 +276,7 @@ func (state *DB) Commit() (root types.Hash32, err error) {
 			state.updateStateObj(stateObject)
 		}
 	}
+
 	// Write trie changes.
 	root, err = state.globalTrie.Commit(nil)
 	return root, err
diff --git a/state/processor.go b/state/processor.go
index d0cb1927a5c..826c60b4597 100644
--- a/state/processor.go
+++ b/state/processor.go
@@ -111,7 +111,8 @@ func (tp *TransactionProcessor) ValidateNonceAndBalance(tx *types.Transaction) e
 	return nil
 }
 
-// ApplyTransactions receives a batch of transaction to apply on state. Returns the number of transaction that failed to apply.
+// ApplyTransactions receives a batch of transactions to apply to state. Returns the number of transactions that we
+// failed to apply.
 func (tp *TransactionProcessor) ApplyTransactions(layer types.LayerID, txs []*types.Transaction) (int, error) {
 	if len(txs) == 0 {
 		err := tp.addStateToHistory(layer, tp.GetStateRoot())
@@ -122,7 +123,10 @@ func (tp *TransactionProcessor) ApplyTransactions(layer types.LayerID, txs []*ty
 	defer tp.mu.Unlock()
 	remaining := txs
 	remainingCount := len(remaining)
-	for { // Loop until there's nothing left to process
+
+	// loop over the transactions until there's nothing left to process
+	for {
+		tp.With().Debug("applying transactions", log.Int("count_remaining", remainingCount))
 		remaining = tp.Process(remaining, layer)
 		if remainingCount == len(remaining) {
 			break
@@ -131,13 +135,10 @@ func (tp *TransactionProcessor) ApplyTransactions(layer types.LayerID, txs []*ty
 	}
 
 	newHash, err := tp.Commit()
-
 	if err != nil {
-		return remainingCount, fmt.Errorf("failed to commit global state: %v", err)
+		return remainingCount, fmt.Errorf("failed to commit global state: %w", err)
 	}
-
 	err = tp.addStateToHistory(layer, newHash)
-
 	return remainingCount, err
 }
 
@@ -147,7 +148,7 @@ func (tp *TransactionProcessor) addStateToHistory(layer types.LayerID, newHash t
 	if err != nil {
 		return err
 	}
-	err = tp.addState(newHash, layer)
+	err = tp.saveStateRoot(newHash, layer)
 	if err != nil {
 		return err
 	}
@@ -159,7 +160,7 @@ func getStateRootLayerKey(layer types.LayerID) []byte {
 	return append([]byte(newRootKey), layer.Bytes()...)
 }
 
-func (tp *TransactionProcessor) addState(stateRoot types.Hash32, layer types.LayerID) error {
+func (tp *TransactionProcessor) saveStateRoot(stateRoot types.Hash32, layer types.LayerID) error {
 	if err := tp.processorDb.Put(getStateRootLayerKey(layer), stateRoot.Bytes()); err != nil {
 		return err
 	}
@@ -218,7 +219,7 @@ func (tp *TransactionProcessor) LoadState(layer types.LayerID) error {
 	}
 
 	tp.Log.With().Info("reverted",
-		log.FieldNamed("root_hash", newState.IntermediateRoot(false)))
+		log.String("root_hash", newState.IntermediateRoot(false).String()))
 
 	tp.DB = newState
 	tp.rootMu.Lock()
@@ -252,17 +253,17 @@ var (
 	errNonce  = "incorrect nonce"
 )
 
-// ApplyTransaction applies provided transaction trans to the current state, but does not commit it to persistent
-// storage. it returns error if there is not enough balance in src account to perform the transaction and pay
-// fee or if the nonce is invalid
-func (tp *TransactionProcessor) ApplyTransaction(trans *types.Transaction, layerID types.LayerID) error {
-	if !tp.Exist(trans.Origin()) {
+// ApplyTransaction applies provided transaction to the current state, but does not commit it to persistent
+// storage. It returns an error if the transaction is invalid, i.e., if there is not enough balance in the source
+// account to perform the transaction and pay the fee or if the nonce is incorrect.
+func (tp *TransactionProcessor) ApplyTransaction(tx *types.Transaction, layerID types.LayerID) error {
+	if !tp.Exist(tx.Origin()) {
 		return fmt.Errorf(errOrigin)
 	}
 
-	origin := tp.GetOrNewStateObj(trans.Origin())
+	origin := tp.GetOrNewStateObj(tx.Origin())
 
-	amountWithFee := trans.Fee + trans.Amount
+	amountWithFee := tx.Fee + tx.Amount
 
 	// todo: should we allow to spend all accounts balance?
 	if origin.Balance() <= amountWithFee {
@@ -272,22 +273,22 @@ func (tp *TransactionProcessor) ApplyTransaction(trans *types.Transaction, layer
 		return fmt.Errorf(errFunds)
 	}
 
-	if !tp.checkNonce(trans) {
+	if !tp.checkNonce(tx) {
 		tp.Log.With().Error(errNonce,
-			log.Uint64("nonce_correct", tp.GetNonce(trans.Origin())),
-			log.Uint64("nonce_actual", trans.AccountNonce))
+			log.Uint64("nonce_correct", tp.GetNonce(tx.Origin())),
+			log.Uint64("nonce_actual", tx.AccountNonce))
 		return fmt.Errorf(errNonce)
 	}
 
-	tp.SetNonce(trans.Origin(), tp.GetNonce(trans.Origin())+1) // TODO: Not thread-safe
-	transfer(tp, trans.Origin(), trans.Recipient, trans.Amount)
+	tp.SetNonce(tx.Origin(), tp.GetNonce(tx.Origin())+1) // TODO: Not thread-safe
+	transfer(tp, tx.Origin(), tx.Recipient, tx.Amount)
 
 	// subtract fee from account, fee will be sent to miners in layers after
-	tp.SubBalance(trans.Origin(), trans.Fee)
-	if err := tp.processorDb.Put(trans.ID().Bytes(), layerID.Bytes()); err != nil {
+	tp.SubBalance(tx.Origin(), tx.Fee)
+	if err := tp.processorDb.Put(tx.ID().Bytes(), layerID.Bytes()); err != nil {
 		return fmt.Errorf("failed to add to applied txs: %v", err)
 	}
-	tp.With().Info("transaction processed", log.String("transaction", trans.String()))
+	tp.With().Info("transaction processed", log.String("transaction", tx.String()))
 	return nil
 }
 
diff --git a/state/processor_test.go b/state/processor_test.go
index c956f4a6358..c1d6c631da0 100644
--- a/state/processor_test.go
+++ b/state/processor_test.go
@@ -224,7 +224,8 @@ func (s *ProcessorStateSuite) TestTransactionProcessor_ApplyTransaction_OrderByN
 	obj1 := createAccount(s.processor, SignerToAddr(signer), 25, 0)
 	obj2 := createAccount(s.processor, toAddr([]byte{0x01, 02}), 1, 10)
 	obj3 := createAccount(s.processor, toAddr([]byte{0x02}), 44, 0)
-	s.processor.Commit()
+	_, err = s.processor.Commit()
+	assert.NoError(s.T(), err)
 
 	transactions := []*types.Transaction{
 		createTransaction(s.T(), obj1.Nonce()+3, obj3.address, 1, 5, signer),
@@ -390,10 +391,9 @@ func (s *ProcessorStateSuite) TestTransactionProcessor_Multilayer() {
 	var want string
 	for i := 0; i < testCycles; i++ {
 		numOfTransactions := rand.Intn(maxTransactions-minTransactions) + minTransactions
-		trns := []*types.Transaction{}
+		var trns []*types.Transaction
 		nonceTrack := make(map[*Object]int)
 		for j := 0; j < numOfTransactions; j++ {
-
 			src := int(rand.Uint32() % (uint32(len(accounts) - 1)))
 			srcAccount := accounts[src]
 			dstAccount := accounts[int(rand.Uint32()%(uint32(len(accounts)-1)))]
@@ -428,11 +428,9 @@ func (s *ProcessorStateSuite) TestTransactionProcessor_Multilayer() {
 				s.T().Errorf("dump mismatch:\ngot: %s\nwant: %s\n", got, want)
 			}
 		}
-
 	}
 
 	writtenMore := db.Len()
-
 	assert.True(s.T(), writtenMore > written)
 }
 
@@ -526,7 +524,7 @@ func TestTransactionProcessor_GetStateRoot(t *testing.T) {
 	r.NotEqual(types.Hash32{}, proc.rootHash)
 
 	expectedRoot := types.Hash32{1, 2, 3}
-	r.NoError(proc.addState(expectedRoot, types.NewLayerID(1)))
+	r.NoError(proc.saveStateRoot(expectedRoot, types.NewLayerID(1)))
 
 	actualRoot := proc.GetStateRoot()
 	r.Equal(expectedRoot, actualRoot)
@@ -548,7 +546,8 @@ func TestTransactionProcessor_ApplyTransactions(t *testing.T) {
 	obj1 := createAccount(processor, SignerToAddr(signer), 21, 0)
 	obj2 := createAccount(processor, toAddr([]byte{0x01, 02}), 1, 10)
 	createAccount(processor, toAddr([]byte{0x02}), 44, 0)
-	processor.Commit()
+	_, err = processor.Commit()
+	assert.NoError(t, err)
 
 	transactions := []*types.Transaction{
 		createTransaction(t, obj1.Nonce(), obj2.address, 1, 5, signer),
diff --git a/syncer/syncer.go b/syncer/syncer.go
index 82b8613bccc..168f90749f5 100644
--- a/syncer/syncer.go
+++ b/syncer/syncer.go
@@ -133,23 +133,24 @@ func (s *Syncer) RegisterChForSynced(ctx context.Context, ch chan struct{}) {
 	s.awaitSyncedCh = append(s.awaitSyncedCh, ch)
 }
 
-// ListenToGossip returns true if the node is listening to gossip for blocks/TXs/ATXs data.
+// ListenToGossip returns true if the node is listening to gossip for blocks/TXs/ATXs data
 func (s *Syncer) ListenToGossip() bool {
 	return s.conf.AlwaysListen || s.getSyncState() >= gossipSync
 }
 
-// IsSynced returns true if the nodes is in synced state.
+// IsSynced returns true if the node is in synced state
 func (s *Syncer) IsSynced(ctx context.Context) bool {
+	// TODO: at startup, ctx contains no sessionId here
 	res := s.getSyncState() == synced
 	s.logger.WithContext(ctx).With().Info("node sync state",
 		log.Bool("synced", res),
 		log.FieldNamed("current", s.ticker.GetCurrentLayer()),
 		log.FieldNamed("latest", s.mesh.LatestLayer()),
-		log.FieldNamed("validated", s.mesh.ProcessedLayer()))
+		log.FieldNamed("processed", s.mesh.ProcessedLayer()))
 	return res
 }
 
-// Start starts the main sync loop that tries to sync data for every SyncInterval.
+// Start starts the main sync loop that tries to sync data for every SyncInterval
 func (s *Syncer) Start(ctx context.Context) {
 	s.syncOnce.Do(func() {
 		if s.ticker.GetCurrentLayer().Uint32() <= 1 {
@@ -195,7 +196,7 @@ func (s *Syncer) setSyncState(ctx context.Context, newState syncState) {
 			log.String("to_state", newState.String()),
 			log.FieldNamed("current", s.ticker.GetCurrentLayer()),
 			log.FieldNamed("latest", s.mesh.LatestLayer()),
-			log.FieldNamed("validated", s.mesh.ProcessedLayer()))
+			log.FieldNamed("processed", s.mesh.ProcessedLayer()))
 		events.ReportNodeStatusUpdate()
 		if newState != synced {
 			return
@@ -228,7 +229,7 @@ func (s *Syncer) setTargetSyncedLayer(ctx context.Context, layerID types.LayerID
 		log.Uint32("to_layer", layerID.Uint32()),
 		log.FieldNamed("current", s.ticker.GetCurrentLayer()),
 		log.FieldNamed("latest", s.mesh.LatestLayer()),
-		log.FieldNamed("validated", s.mesh.ProcessedLayer()))
+		log.FieldNamed("processed", s.mesh.ProcessedLayer()))
 }
 
 func (s *Syncer) getTargetSyncedLayer() types.LayerID {
@@ -254,7 +255,7 @@ func (s *Syncer) synchronize(ctx context.Context) bool {
 		log.String("sync_state", s.getSyncState().String()),
 		log.FieldNamed("current", s.ticker.GetCurrentLayer()),
 		log.FieldNamed("latest", s.mesh.LatestLayer()),
-		log.FieldNamed("validated", s.mesh.ProcessedLayer()))
+		log.FieldNamed("processed", s.mesh.ProcessedLayer()))
 
 	s.setStateBeforeSync(ctx)
 	// start a dedicated process for validation.
@@ -273,7 +274,7 @@ func (s *Syncer) synchronize(ctx context.Context) bool {
 			log.String("sync_state", s.getSyncState().String()),
 			log.FieldNamed("current", s.ticker.GetCurrentLayer()),
 			log.FieldNamed("latest", s.mesh.LatestLayer()),
-			log.FieldNamed("validated", s.mesh.ProcessedLayer()))
+			log.FieldNamed("processed", s.mesh.ProcessedLayer()))
 		s.setSyncerIdle()
 	}()
 
@@ -289,7 +290,7 @@ func (s *Syncer) synchronize(ctx context.Context) bool {
 		}
 
 		if len(layer.Blocks()) == 0 {
-			logger.Info("setting layer %v to zero-block", layerID)
+			logger.With().Info("setting layer to zero-block", layerID)
 			if err := s.mesh.SetZeroBlockLayer(layerID); err != nil {
 				logger.With().Error("failed to set zero-block for layer", layerID, log.Err(err))
 			}
@@ -298,12 +299,12 @@ func (s *Syncer) synchronize(ctx context.Context) bool {
 		if s.shouldValidateLayer(layerID) {
 			vQueue <- layer
 		}
-		logger.Debug("finished data sync for layer %v", layerID)
+		logger.With().Debug("finished data sync", layerID)
 	}
-	logger.With().Info("data is synced. waiting for validation",
+	logger.With().Debug("data is synced, waiting for validation",
 		log.FieldNamed("current", s.ticker.GetCurrentLayer()),
 		log.FieldNamed("latest", s.mesh.LatestLayer()),
-		log.FieldNamed("validated", s.mesh.ProcessedLayer()))
+		log.FieldNamed("processed", s.mesh.ProcessedLayer()))
 	success = true
 	return true
 }
@@ -319,7 +320,7 @@ func (s *Syncer) setStateBeforeSync(ctx context.Context) {
 		s.logger.WithContext(ctx).With().Info("node is too far behind",
 			log.FieldNamed("current", current),
 			log.FieldNamed("latest", latest),
-			log.Uint32("behindThreshold", outOfSyncThreshold))
+			log.Uint32("behind_threshold", outOfSyncThreshold))
 		s.setSyncState(ctx, notSynced)
 	}
 }
@@ -392,7 +393,7 @@ func (s *Syncer) getLayerFromPeers(ctx context.Context, layerID types.LayerID) (
 
 func (s *Syncer) getATXs(ctx context.Context, layerID types.LayerID) error {
 	if layerID.GetEpoch() == 0 {
-		s.logger.WithContext(ctx).Info("skip getting ATX in epoch 0")
+		s.logger.WithContext(ctx).Info("skip getting atx in epoch 0")
 		return nil
 	}
 	epoch := layerID.GetEpoch()
@@ -403,15 +404,15 @@ func (s *Syncer) getATXs(ctx context.Context, layerID types.LayerID) error {
 	// - layerID is the last layer of a previous epoch
 	// i.e. for older epochs we sync ATXs once per epoch. for current epoch we sync ATXs in every layer
 	if atCurrentEpoch || atLastLayerOfEpoch {
-		s.logger.WithContext(ctx).With().Debug("getting ATXs", epoch, layerID)
+		s.logger.WithContext(ctx).With().Debug("getting atxs", epoch, layerID)
 		ctx = log.WithNewRequestID(ctx, layerID.GetEpoch())
 		if err := s.fetcher.GetEpochATXs(ctx, epoch); err != nil {
-			// dont fail sync if we cannot fetch ATXs for the current epoch before the last layer
+			// dont fail sync if we cannot fetch atxs for the current epoch before the last layer
 			if !atCurrentEpoch || atLastLayerOfEpoch {
-				s.logger.WithContext(ctx).With().Error("failed to fetch epoch ATXs", layerID, epoch, log.Err(err))
+				s.logger.WithContext(ctx).With().Error("failed to fetch epoch atxs", layerID, epoch, log.Err(err))
 				return err
 			}
-			s.logger.WithContext(ctx).With().Warning("failed to fetch epoch ATXs", layerID, epoch, log.Err(err))
+			s.logger.WithContext(ctx).With().Warning("failed to fetch epoch atxs", layerID, epoch, log.Err(err))
 		}
 	}
 	return nil
@@ -433,7 +434,10 @@ func (s *Syncer) getTortoiseBeacon(ctx context.Context, layerID types.LayerID) e
 		s.logger.WithContext(ctx).With().Debug("getting tortoise beacons", epoch, layerID)
 		ctx = log.WithNewRequestID(ctx, layerID.GetEpoch())
 		if err := s.fetcher.GetTortoiseBeacon(ctx, epoch); err != nil {
-			s.logger.WithContext(ctx).With().Error("failed to fetch epoch tortoise beacons", layerID, epoch, log.Err(err))
+			s.logger.WithContext(ctx).With().Error("failed to fetch epoch tortoise beacons",
+				layerID,
+				epoch,
+				log.Err(err))
 			return err
 		}
 	}
@@ -452,7 +456,7 @@ func (s *Syncer) shouldValidateLayer(layerID types.LayerID) bool {
 
 // start a dedicated process to validate layers one by one
 func (s *Syncer) startValidating(ctx context.Context, run uint64, queue chan *types.Layer, done chan struct{}) {
-	logger := s.logger.WithName("validation")
+	logger := s.logger.WithContext(ctx).WithName("validation")
 	logger.Debug("validation started for run #%v", run)
 	defer func() {
 		logger.Debug("validation done for run #%v", run)
@@ -475,5 +479,10 @@ func (s *Syncer) validateLayer(ctx context.Context, layer *types.Layer) {
 	s.logger.WithContext(ctx).With().Debug("validating layer",
 		layer.Index(),
 		log.String("blocks", fmt.Sprint(types.BlockIDs(layer.Blocks()))))
-	s.mesh.ValidateLayer(layer)
+
+	// TODO: re-architect this so the syncer does not need to actually wait for tortoise to finish running.
+	//   It should be sufficient to call GetLayer (above), and maybe, to queue a request to tortoise to analyze this
+	//   layer (without waiting for this to finish -- it should be able to run async).
+	//   See https://github.com/spacemeshos/go-spacemesh/issues/2415
+	s.mesh.ValidateLayer(ctx, layer)
 }
diff --git a/syncer/syncer_test.go b/syncer/syncer_test.go
index 1b267cbc9f9..a080977e817 100644
--- a/syncer/syncer_test.go
+++ b/syncer/syncer_test.go
@@ -149,13 +149,13 @@ func (mf *mockFetcher) setTBErrors(epoch types.EpochID, err error) {
 type mockValidator struct{}
 
 func (mv *mockValidator) LatestComplete() types.LayerID { return types.LayerID{} }
-func (mv *mockValidator) Persist() error                { return nil }
-func (mv *mockValidator) HandleIncomingLayer(layer *types.Layer) (types.LayerID, types.LayerID) {
-	return layer.Index(), layer.Index().Sub(1)
+func (mv *mockValidator) Persist(context.Context) error { return nil }
+func (mv *mockValidator) HandleIncomingLayer(_ context.Context, layerID types.LayerID) (types.LayerID, types.LayerID, bool) {
+	return layerID, layerID.Sub(1), false
 }
 
-func (mv *mockValidator) HandleLateBlock(block *types.Block) (types.LayerID, types.LayerID) {
-	return block.Layer(), block.Layer().Sub(1)
+func (mv *mockValidator) HandleLateBlocks(_ context.Context, blocks []*types.Block) (types.LayerID, types.LayerID) {
+	return blocks[0].Layer(), blocks[0].Layer().Sub(1)
 }
 
 func newMemMesh(lg log.Log) *mesh.Mesh {
diff --git a/tests/queries.py b/tests/queries.py
index 64213f25594..bd90e63e8bb 100644
--- a/tests/queries.py
+++ b/tests/queries.py
@@ -70,12 +70,12 @@ def get_app_started_msgs(namespace, pod_name):
 
 
 def get_tortoise_beacon_msgs(namespace, pod_name):
-    beacon_msg = "Calculated beacon"
+    beacon_msg = "calculated beacon"
     return get_all_msg_containing(namespace, pod_name, beacon_msg)
 
 
 def get_tortoise_beacon_weak_coin_msgs(namespace, pod_name):
-    weak_coin_msg = "Calculated weak coin"
+    weak_coin_msg = "calculated weak coin"
     return get_all_msg_containing(namespace, pod_name, weak_coin_msg)
 
 
diff --git a/timesync/clock.go b/timesync/clock.go
index 2fa049ef6d9..1a32d7632b6 100644
--- a/timesync/clock.go
+++ b/timesync/clock.go
@@ -61,6 +61,9 @@ func (t *TimeClock) startClock() {
 			log.FieldNamed("curr_layer", currLayer))
 		select {
 		case <-tmr.C:
+			t.log.With().Info("clock notifying subscribers of new layer tick",
+				log.Int("subscriber_count", len(t.subscribers)),
+				t.TimeToLayer(t.clock.Now()))
 			// notify subscribers
 			if missed, err := t.Notify(); err != nil {
 				t.log.With().Error("could not notify subscribers",
diff --git a/tortoise/util.go b/tortoise/util.go
index c3ffa645984..bb4377203e0 100644
--- a/tortoise/util.go
+++ b/tortoise/util.go
@@ -1,79 +1,95 @@
 package tortoise
 
 import (
+	"errors"
 	"fmt"
 	"github.com/spacemeshos/go-spacemesh/common/types"
 	"github.com/spacemeshos/go-spacemesh/log"
 )
 
-type vec [2]int
+type vec [2]uint64
 
-const (
-	globalThreshold = 0.6
-)
-
-var ( //correction vectors type
-	// Opinion vectors
-	support = vec{1, 0}
-	against = vec{0, 1}
-	abstain = vec{0, 0}
+var (
+	support     = vec{1, 0}
+	against     = vec{0, 1}
+	abstain     = vec{0, 0}
+	errOverflow = errors.New("vector arithmetic overflow")
 )
 
 // Field returns a log field. Implements the LoggableField interface.
 func (a vec) Field() log.Field {
-	return log.String("vote_vector", fmt.Sprint(a))
+	return log.String("vote_vector", fmt.Sprintf("%s (+%d, -%d)", a, a[0], a[1]))
 }
 
 func (a vec) Add(v vec) vec {
-	return vec{a[0] + v[0], a[1] + v[1]}
+	a[0] += v[0]
+	a[1] += v[1]
+	// prevent overflow/wraparound
+	if a[0] < v[0] || a[1] < v[1] {
+		panic(errOverflow)
+	}
+	return a
 }
 
-func (a vec) Negate() vec {
-	a[0] = a[0] * -1
-	a[1] = a[1] * -1
-	return a
+func (a vec) Multiply(x uint64) vec {
+	one := a[0] * x
+	two := a[1] * x
+	// prevent overflow/wraparound
+	if x != 0 && (one/x != a[0] || two/x != a[1]) {
+		panic(errOverflow)
+	}
+	return vec{one, two}
 }
 
-func (a vec) Multiply(x int) vec {
-	a[0] = a[0] * x
-	a[1] = a[1] * x
-	return a
+func (a vec) netVote() int64 {
+	// prevent overflow/wraparound
+	one := int64(a[0])
+	two := int64(a[1])
+	if one < 0 || two < 0 {
+		panic(errOverflow)
+	}
+	return one - two
 }
 
 func simplifyVote(v vec) vec {
 	if v[0] > v[1] {
 		return support
 	}
-
 	if v[1] > v[0] {
 		return against
 	}
-
 	return abstain
 }
 
 func (a vec) String() string {
 	v := simplifyVote(a)
-
 	if v == support {
 		return "support"
 	}
-
 	if v == against {
 		return "against"
 	}
-
 	return "abstain"
 }
 
-func calculateGlobalOpinion(logger log.Log, v vec, layerSize int, delta float64) vec {
-	threshold := globalThreshold * delta * float64(layerSize)
-	logger.With().Debug("global opinion", v, log.String("threshold", fmt.Sprint(threshold)))
-	if float64(v[0]) > threshold {
+func calculateOpinionWithThreshold(logger log.Log, v vec, layerSize int, theta uint8, delta float64) vec {
+	threshold := float64(theta) / 100 * delta * float64(layerSize)
+	netVote := float64(v.netVote())
+	logger.With().Debug("threshold opinion",
+		v,
+		log.Int("theta", int(theta)),
+		log.Int("layer_size", layerSize),
+		log.String("delta", fmt.Sprint(delta)),
+		log.String("threshold", fmt.Sprint(threshold)),
+		log.String("net_vote", fmt.Sprint(netVote)))
+	if netVote > threshold {
+		// try net positive vote
 		return support
-	} else if float64(v[1]) > threshold {
+	} else if netVote < -1*threshold {
+		// try net negative vote
 		return against
 	} else {
+		// neither threshold was crossed, so abstain
 		return abstain
 	}
 }
@@ -91,10 +107,10 @@ func (blt blockIDLayerTuple) id() types.BlockID {
 	return blt.BlockID
 }
 
-// Opinion is a tuple of block and layer id and its opinions on other blocks.
+// Opinion is a tuple of block and layer id. It stores a block's opinion about many other blocks.
 type Opinion struct {
-	BILT          blockIDLayerTuple
-	BlocksOpinion map[types.BlockID]vec
+	BlockAndLayer blockIDLayerTuple
+	BlockOpinions map[types.BlockID]vec
 }
 
 type retriever interface {
diff --git a/tortoise/verifying_algorithm.go b/tortoise/verifying_algorithm.go
index c6b8c306115..254cc0734f1 100644
--- a/tortoise/verifying_algorithm.go
+++ b/tortoise/verifying_algorithm.go
@@ -2,7 +2,9 @@ package tortoise
 
 import (
 	"context"
+	"fmt"
 	"sync"
+	"time"
 
 	"github.com/spacemeshos/go-spacemesh/common/types"
 	"github.com/spacemeshos/go-spacemesh/log"
@@ -11,52 +13,104 @@ import (
 
 // ThreadSafeVerifyingTortoise is a thread safe verifying tortoise wrapper, it just locks all actions.
 type ThreadSafeVerifyingTortoise struct {
-	trtl  *turtle
-	mutex sync.RWMutex
+	trtl      *turtle
+	logger    log.Log
+	lastRerun time.Time
+	mutex     sync.RWMutex
 }
 
 // Config holds the arguments and dependencies to create a verifying tortoise instance.
 type Config struct {
-	LayerSize int
-	Database  blockDataProvider
-	Hdist     uint32
-	Log       log.Log
-	Recovered bool
+	LayerSize       int
+	Database        blockDataProvider
+	ATXDB           atxDataProvider
+	Clock           layerClock
+	Hdist           uint32 // hare lookback distance: the distance over which we use the input vector/hare results
+	Zdist           uint32 // hare result wait distance: the distance over which we're willing to wait for hare results
+	ConfidenceParam uint32 // confidence wait distance: how long we wait for global consensus to be established
+	GlobalThreshold uint8  // threshold required to finalize blocks and layers (0-100)
+	LocalThreshold  uint8  // threshold that determines whether a node votes based on local or global opinion (0-100)
+	WindowSize      uint32 // tortoise sliding window: how many layers we store data for
+	Log             log.Log
+	Recovered       bool
+	RerunInterval   time.Duration // how often to rerun from genesis
 }
 
 // NewVerifyingTortoise creates a new verifying tortoise wrapper
-func NewVerifyingTortoise(cfg Config) *ThreadSafeVerifyingTortoise {
+func NewVerifyingTortoise(ctx context.Context, cfg Config) *ThreadSafeVerifyingTortoise {
 	if cfg.Recovered {
-		return recoveredVerifyingTortoise(cfg.Database, cfg.Log)
+		return recoveredVerifyingTortoise(cfg.Database, cfg.ATXDB, cfg.Clock, cfg.Log)
 	}
-	return verifyingTortoise(cfg.LayerSize, cfg.Database, cfg.Hdist, cfg.Log)
+	return verifyingTortoise(
+		ctx,
+		cfg.LayerSize,
+		cfg.Database,
+		cfg.ATXDB,
+		cfg.Clock,
+		cfg.Hdist,
+		cfg.Zdist,
+		cfg.ConfidenceParam,
+		cfg.WindowSize,
+		cfg.GlobalThreshold,
+		cfg.LocalThreshold,
+		cfg.RerunInterval,
+		cfg.Log)
 }
 
 // verifyingTortoise creates a new verifying tortoise wrapper
-func verifyingTortoise(layerSize int, mdb blockDataProvider, hdist uint32, lg log.Log) *ThreadSafeVerifyingTortoise {
-	alg := &ThreadSafeVerifyingTortoise{trtl: newTurtle(mdb, hdist, layerSize)}
-	alg.trtl.SetLogger(lg)
-	alg.trtl.init(mesh.GenesisLayer())
+func verifyingTortoise(
+	ctx context.Context,
+	layerSize int,
+	mdb blockDataProvider,
+	atxdb atxDataProvider,
+	clock layerClock,
+	hdist,
+	zdist,
+	confidenceParam,
+	windowSize uint32,
+	globalThreshold,
+	localThreshold uint8,
+	rerunInterval time.Duration,
+	logger log.Log,
+) *ThreadSafeVerifyingTortoise {
+	if hdist < zdist {
+		logger.With().Panic("hdist must be >= zdist", log.Uint32("hdist", hdist), log.Uint32("zdist", zdist))
+	}
+	if globalThreshold > 100 || localThreshold > 100 {
+		logger.With().Panic("global and local threshold values must be in the interval [0, 100]")
+	}
+	alg := &ThreadSafeVerifyingTortoise{
+		trtl: newTurtle(mdb, atxdb, clock, hdist, zdist, confidenceParam, windowSize, layerSize, globalThreshold, localThreshold, rerunInterval),
+	}
+	alg.logger = logger
+	alg.lastRerun = time.Now()
+	alg.trtl.SetLogger(logger.WithFields(log.String("tortoise_rerun", "false")))
+	alg.trtl.init(ctx, mesh.GenesisLayer())
 	return alg
 }
 
 // NewRecoveredVerifyingTortoise recovers a previously persisted tortoise copy from mesh.DB
-func recoveredVerifyingTortoise(mdb blockDataProvider, lg log.Log) *ThreadSafeVerifyingTortoise {
+func recoveredVerifyingTortoise(mdb blockDataProvider, atxdb atxDataProvider, clock layerClock, logger log.Log) *ThreadSafeVerifyingTortoise {
 	tmp, err := RecoverVerifyingTortoise(mdb)
 	if err != nil {
-		lg.Panic("could not recover tortoise state from disc ", err)
+		logger.With().Panic("could not recover tortoise state from disk", log.Err(err))
 	}
 
-	trtl := tmp.(*turtle)
+	trtl, ok := tmp.(*turtle)
+	if !ok {
+		logger.Panic("type error reading recovered tortoise state")
+	}
 
-	lg.Info("recovered tortoise from disc")
+	logger.Info("recovered tortoise from disk")
 	trtl.bdp = mdb
-	trtl.logger = lg
+	trtl.atxdb = atxdb
+	trtl.clock = clock
+	trtl.logger = logger
 
-	return &ThreadSafeVerifyingTortoise{trtl: trtl}
+	return &ThreadSafeVerifyingTortoise{trtl: trtl, lastRerun: time.Now(), logger: logger}
 }
 
-// LatestComplete returns the latest verified layer. TODO: rename?
+// LatestComplete returns the latest verified layer
 func (trtl *ThreadSafeVerifyingTortoise) LatestComplete() types.LayerID {
 	trtl.mutex.RLock()
 	verified := trtl.trtl.Verified
@@ -75,32 +129,131 @@ func (trtl *ThreadSafeVerifyingTortoise) BaseBlock(ctx context.Context) (types.B
 	return block, diffs, err
 }
 
-//HandleIncomingLayer processes all layer block votes
-// returns the old verified layer and new verified layer after taking into account the blocks votes
-func (trtl *ThreadSafeVerifyingTortoise) HandleIncomingLayer(ll *types.Layer) (types.LayerID, types.LayerID) {
+// HandleLateBlocks processes votes and goodness for late blocks (for late block definition see white paper).
+// Returns the old verified layer and new verified layer after taking into account the blocks' votes.
+func (trtl *ThreadSafeVerifyingTortoise) HandleLateBlocks(ctx context.Context, blocks []*types.Block) (types.LayerID, types.LayerID) {
 	trtl.mutex.Lock()
 	defer trtl.mutex.Unlock()
 	oldVerified := trtl.trtl.Verified
-	trtl.trtl.HandleIncomingLayer(ll)
+	if err := trtl.trtl.ProcessNewBlocks(ctx, blocks); err != nil {
+		// consider panicking here instead, since it means tortoise is stuck
+		trtl.logger.WithContext(ctx).With().Error("tortoise errored handling late blocks", log.Err(err))
+	}
 	newVerified := trtl.trtl.Verified
 	return oldVerified, newVerified
 }
 
-// HandleLateBlock processes a late blocks votes (for late block definition see white paper)
+// HandleIncomingLayer processes all layer block votes
 // returns the old verified layer and new verified layer after taking into account the blocks votes
-func (trtl *ThreadSafeVerifyingTortoise) HandleLateBlock(b *types.Block) (types.LayerID, types.LayerID) {
-	//todo feed all layers from b's layer to tortoise
-	l := types.NewLayer(b.Layer())
-	l.AddBlock(b)
-	oldVerified, newVerified := trtl.HandleIncomingLayer(l) // block wasn't in input vector for sure.
-	trtl.trtl.logger.With().Debug("late block ", b.Layer(), b.ID())
-	return oldVerified, newVerified
+func (trtl *ThreadSafeVerifyingTortoise) HandleIncomingLayer(ctx context.Context, layerID types.LayerID) (oldVerified, newVerified types.LayerID, reverted bool) {
+	trtl.mutex.Lock()
+	defer trtl.mutex.Unlock()
+
+	oldVerified = trtl.trtl.Verified
+
+	// first check if it's time for a total rerun
+	trtl.logger.With().Debug("checking if tortoise needs to rerun from genesis",
+		log.Duration("rerun_interval", trtl.trtl.RerunInterval),
+		log.Time("last_rerun", trtl.lastRerun))
+
+	// TODO: in future we can do something more sophisticated, using accounting to determine when enough changes to old
+	//   layers have accumulated (in terms of block weight) that our opinion could actually change. For now, we do the
+	//   Simplest Possible Thing (TM) and just rerun from genesis once in a while. This requires a different instance of
+	//   tortoise since we don't want to mess with the state of the main tortoise. We re-stream layer data from genesis
+	//   using the sliding window, simulating a full resync.
+	//   See https://github.com/spacemeshos/go-spacemesh/issues/2551
+	if time.Now().Sub(trtl.lastRerun) > trtl.trtl.RerunInterval {
+		var revertLayer types.LayerID
+		if reverted, revertLayer = trtl.rerunFromGenesis(ctx); reverted {
+			// make sure state is reapplied from far enough back if there was a state reversion
+			oldVerified = revertLayer
+		}
+		trtl.lastRerun = time.Now()
+	}
+
+	// Even after a rerun, we still need to process the new incoming layer
+	trtl.logger.WithContext(ctx).With().Info("handling incoming layer",
+		log.FieldNamed("old_pbase", oldVerified),
+		log.FieldNamed("incoming_layer", layerID))
+	if err := trtl.trtl.HandleIncomingLayer(ctx, layerID); err != nil {
+		// consider panicking here instead, since it means tortoise is stuck
+		trtl.logger.WithContext(ctx).With().Error("tortoise errored handling incoming layer", log.Err(err))
+	}
+
+	newVerified = trtl.trtl.Verified
+	trtl.logger.WithContext(ctx).With().Info("finished handling incoming layer",
+		log.FieldNamed("old_pbase", oldVerified),
+		log.FieldNamed("new_pbase", newVerified),
+		log.FieldNamed("incoming_layer", layerID))
+
+	return
+}
+
+// this wrapper monitors the tortoise rerun for database changes that would cause us to need to revert state
+type bdpWrapper struct {
+	blockDataProvider
+	firstUpdatedLayer *types.LayerID
+}
+
+// SaveContextualValidity overrides the method in the embedded type to check if we've made changes
+func (bdp *bdpWrapper) SaveContextualValidity(bid types.BlockID, lid types.LayerID, validityNew bool) error {
+	// we only need to know about the first updated layer
+	if bdp.firstUpdatedLayer == nil {
+		// first, get current value
+		validityCur, err := bdp.ContextualValidity(bid)
+		if err != nil {
+			return fmt.Errorf("error reading contextual validity of block %v: %w", bid, err)
+		}
+		if validityCur != validityNew {
+			bdp.firstUpdatedLayer = &lid
+		}
+	}
+	return bdp.blockDataProvider.SaveContextualValidity(bid, lid, validityNew)
+}
+
+// trigger a rerun from genesis once in a while
+func (trtl *ThreadSafeVerifyingTortoise) rerunFromGenesis(ctx context.Context) (reverted bool, revertLayer types.LayerID) {
+	// TODO: should this happen "in the background" in a separate goroutine? Should it hold the mutex?
+	logger := trtl.logger.WithContext(ctx)
+	logger.With().Info("triggering tortoise full rerun from genesis")
+
+	// start from scratch with a new tortoise instance for each rerun
+	trtlForRerun := trtl.trtl.cloneTurtleParams()
+	trtlForRerun.SetLogger(logger.WithFields(log.String("tortoise_rerun", "true")))
+	trtlForRerun.init(ctx, mesh.GenesisLayer())
+	bdp := bdpWrapper{blockDataProvider: trtlForRerun.bdp}
+	trtlForRerun.bdp = &bdp
+
+	for layerID := types.GetEffectiveGenesis(); !layerID.After(trtl.trtl.Last); layerID = layerID.Add(1) {
+		logger.With().Debug("rerunning tortoise for layer", layerID)
+		if err := trtlForRerun.HandleIncomingLayer(ctx, layerID); err != nil {
+			logger.With().Error("tortoise rerun errored", log.Err(err))
+			// bail out completely if we encounter an error: don't revert state and don't swap out the trtl
+			// TODO: give this some more thought
+			return
+		}
+	}
+
+	// revert state if necessary
+	// state will be reapplied in mesh after we return, no need to reapply here
+	if bdp.firstUpdatedLayer != nil {
+		logger.With().Warning("turtle rerun detected state changes, attempting to reapply state from first changed layer",
+			log.FieldNamed("first_layer", bdp.firstUpdatedLayer))
+		reverted = true
+		revertLayer = *bdp.firstUpdatedLayer
+	}
+
+	// swap out the turtle instances so its state is up to date
+	trtlForRerun.bdp = trtl.trtl.bdp
+	trtlForRerun.logger = trtl.logger
+	trtl.trtl = trtlForRerun
+	return
 }
 
 // Persist saves a copy of the current tortoise state to the database
-func (trtl *ThreadSafeVerifyingTortoise) Persist() error {
+func (trtl *ThreadSafeVerifyingTortoise) Persist(ctx context.Context) error {
 	trtl.mutex.Lock()
 	defer trtl.mutex.Unlock()
-	trtl.trtl.logger.Debug("persist tortoise ")
+	trtl.logger.WithContext(ctx).Info("persist tortoise")
 	return trtl.trtl.persist()
 }
diff --git a/tortoise/verifying_tortoise.go b/tortoise/verifying_tortoise.go
index 83e8400a0d6..53e9bcce2f5 100644
--- a/tortoise/verifying_tortoise.go
+++ b/tortoise/verifying_tortoise.go
@@ -4,25 +4,50 @@ import (
 	"context"
 	"errors"
 	"fmt"
-
 	"github.com/spacemeshos/go-spacemesh/common/types"
 	"github.com/spacemeshos/go-spacemesh/log"
 	"github.com/spacemeshos/go-spacemesh/mesh"
 	"github.com/syndtr/goleveldb/leveldb"
+	"time"
 )
 
 type blockDataProvider interface {
+	LayerContextuallyValidBlocks(types.LayerID) (map[types.BlockID]struct{}, error)
 	GetBlock(types.BlockID) (*types.Block, error)
-	LayerBlockIds(types.LayerID) (ids []types.BlockID, err error)
+	LayerBlockIds(types.LayerID) ([]types.BlockID, error)
+	LayerBlocks(types.LayerID) ([]*types.Block, error)
 
+	GetCoinflip(context.Context, types.LayerID) (bool, bool)
 	GetLayerInputVectorByID(types.LayerID) ([]types.BlockID, error)
-
-	SaveContextualValidity(id types.BlockID, valid bool) error
+	SaveContextualValidity(types.BlockID, types.LayerID, bool) error
+	ContextualValidity(types.BlockID) (bool, error)
 
 	Persist(key []byte, v interface{}) error
 	Retrieve(key []byte, v interface{}) (interface{}, error)
 }
 
+type atxDataProvider interface {
+	GetAtxHeader(types.ATXID) (*types.ActivationTxHeader, error)
+	GetAtxTimestamp(types.ATXID) (time.Time, error)
+}
+
+type layerClock interface {
+	LayerToTime(types.LayerID) time.Time
+}
+
+var (
+	errNoBaseBlockFound                 = errors.New("no good base block within exception vector limit")
+	errBaseBlockNotInDatabase           = errors.New("inconsistent state: can't find base block in database")
+	errNotSorted                        = errors.New("input blocks are not sorted by layerID")
+	errstrNoCoinflip                    = "no weak coin value for layer"
+	errstrTooManyExceptions             = "too many exceptions to base block vote"
+	errstrBaseBlockLayerMissing         = "base block layer not found"
+	errstrBaseBlockNotFoundInLayer      = "base block opinions not found in layer"
+	errstrConflictingVotes              = "conflicting votes found in block"
+	errstrCantFindLayer                 = "inconsistent state: can't find layer in database"
+	errstrUnableToCalculateLocalOpinion = "unable to calculate local opinion for layer"
+)
+
 func blockMapToArray(m map[types.BlockID]struct{}) []types.BlockID {
 	arr := make([]types.BlockID, len(m))
 	i := 0
@@ -36,11 +61,38 @@ func blockMapToArray(m map[types.BlockID]struct{}) []types.BlockID {
 type turtle struct {
 	logger log.Log
 
-	bdp blockDataProvider
+	atxdb atxDataProvider
+	bdp   blockDataProvider
+	clock layerClock
+
+	// note: the rest of these are exported for purposes of serialization only
+
+	// last layer processed: note that tortoise does not have a concept of "current" layer (and it's not aware of the
+	// current time or latest tick). As far as Tortoise is concerned, Last is the current layer. This is a subjective
+	// view of time, but Tortoise receives layers as soon as Hare finishes processing them or when they are received via
+	// gossip, and there's nothing for Tortoise to verify without new data anyway.
+	Last types.LayerID
 
-	Last  types.LayerID
+	// last evicted layer
+	LastEvicted types.LayerID
+
+	// hare lookback (distance): up to Hdist layers back, we only consider hare results/input vector
 	Hdist uint32
-	Evict types.LayerID
+
+	// hare abort distance: we wait up to Zdist layers for hare results/input vector, before invalidating a layer
+	// without hare results.
+	Zdist uint32
+
+	// the number of layers we wait until we have confidence that w.h.p. all honest nodes have reached consensus on the
+	// contents of a layer
+	ConfidenceParam uint32
+
+	// the size of the tortoise sliding window which controls how far back the tortoise stores data
+	WindowSize uint32
+
+	// thresholds used for determining finality, and whether to use local or global results, respectively
+	GlobalThreshold uint8
+	LocalThreshold  uint8
 
 	AvgLayerSize  int
 	MaxExceptions int
@@ -49,73 +101,133 @@ type turtle struct {
 
 	Verified types.LayerID
 
-	// use 2D array to be able to iterate from latest elements easily
-	BlockOpinionsByLayer map[types.LayerID]map[types.BlockID]Opinion // records hdist, for each block, its votes about every
-	// previous block
+	// this matrix stores the opinion of each block about other blocks. blocks are indexed by layer.
+	// it stores good and bad blocks
+	BlockOpinionsByLayer map[types.LayerID]map[types.BlockID]Opinion
 
-	// TODO: Tal says: We keep a vector containing our vote totals (positive and negative) for every previous block
-	// that's not needed here, probably for self healing?
+	// how often we want to rerun from genesis
+	RerunInterval time.Duration
 }
 
 // SetLogger sets the Log instance for this turtle
-func (t *turtle) SetLogger(log2 log.Log) {
-	t.logger = log2
+func (t *turtle) SetLogger(logger log.Log) {
+	t.logger = logger
 }
 
-// newTurtle creates a new verifying tortoise algorithm instance. XXX: maybe rename?
-func newTurtle(bdp blockDataProvider, hdist uint32, avgLayerSize int) *turtle {
-	t := &turtle{
-		logger:               log.NewNop(),
+// newTurtle creates a new verifying tortoise algorithm instance
+func newTurtle(
+	bdp blockDataProvider,
+	atxdb atxDataProvider,
+	clock layerClock,
+	hdist,
+	zdist,
+	confidenceParam,
+	windowSize uint32,
+	avgLayerSize int,
+	globalThreshold,
+	localThreshold uint8,
+	rerun time.Duration,
+) *turtle {
+	return &turtle{
+		logger:               log.NewDefault("trtl"),
 		Hdist:                hdist,
+		Zdist:                zdist,
+		ConfidenceParam:      confidenceParam,
+		WindowSize:           windowSize,
+		GlobalThreshold:      globalThreshold,
+		LocalThreshold:       localThreshold,
 		bdp:                  bdp,
+		atxdb:                atxdb,
+		clock:                clock,
+		Last:                 types.NewLayerID(0),
 		AvgLayerSize:         avgLayerSize,
 		GoodBlocksIndex:      make(map[types.BlockID]struct{}),
-		BlockOpinionsByLayer: make(map[types.LayerID]map[types.BlockID]Opinion, hdist),
+		BlockOpinionsByLayer: make(map[types.LayerID]map[types.BlockID]Opinion, windowSize),
 		MaxExceptions:        int(hdist) * avgLayerSize * 100,
+		RerunInterval:        rerun,
 	}
-	return t
 }
 
-func (t *turtle) init(genesisLayer *types.Layer) {
+// cloneTurtleParams creates a new verifying tortoise instance using the params of this instance
+func (t *turtle) cloneTurtleParams() *turtle {
+	return newTurtle(
+		t.bdp,
+		t.atxdb,
+		t.clock,
+		t.Hdist,
+		t.Zdist,
+		t.ConfidenceParam,
+		t.WindowSize,
+		t.AvgLayerSize,
+		t.GlobalThreshold,
+		t.LocalThreshold,
+		t.RerunInterval,
+	)
+}
+
+func (t *turtle) init(ctx context.Context, genesisLayer *types.Layer) {
 	// Mark the genesis layer as “good”
-	t.logger.With().Debug("initializing genesis layer for verifying tortoise",
+	t.logger.WithContext(ctx).With().Info("initializing genesis layer for verifying tortoise",
 		genesisLayer.Index(),
 		genesisLayer.Hash().Field())
 	t.BlockOpinionsByLayer[genesisLayer.Index()] = make(map[types.BlockID]Opinion)
 	for _, blk := range genesisLayer.Blocks() {
 		id := blk.ID()
 		t.BlockOpinionsByLayer[genesisLayer.Index()][blk.ID()] = Opinion{
-			BlocksOpinion: make(map[types.BlockID]vec),
+			BlockOpinions: make(map[types.BlockID]vec),
 		}
 		t.GoodBlocksIndex[id] = struct{}{}
 	}
 	t.Last = genesisLayer.Index()
-	t.Evict = genesisLayer.Index()
+	// set last evicted one layer earlier since we look for things starting one layer after last evicted
+	t.LastEvicted = genesisLayer.Index().Sub(1)
 	t.Verified = genesisLayer.Index()
 }
 
+func (t *turtle) lookbackWindowStart() (types.LayerID, bool) {
+	// prevent overflow/wraparound
+	if t.Verified.Before(types.NewLayerID(t.WindowSize)) {
+		return types.NewLayerID(0), false
+	}
+	return t.Verified.Sub(t.WindowSize), true
+}
+
 // evict makes sure we only keep a window of the last hdist layers.
-func (t *turtle) evict() {
-	// Don't evict before we've verified more than hdist
-	// TODO: fix potential leak when we can't verify but keep receiving layers
+func (t *turtle) evict(ctx context.Context) {
+	logger := t.logger.WithContext(ctx)
 
+	// Don't evict before we've verified at least hdist layers
 	if !t.Verified.After(types.GetEffectiveGenesis().Add(t.Hdist)) {
 		return
 	}
-	// The window is the last [Verified - hdist] layers.
-	window := t.Verified.Sub(t.Hdist)
-	t.logger.Info("window starts %v", window)
-	// evict from last evicted to the beginning of our window.
-	for lyr := t.Evict; lyr.Before(window); lyr = lyr.Add(1) {
-		t.logger.Info("removing layer %v", lyr)
-		for blk := range t.BlockOpinionsByLayer[lyr] {
+
+	// TODO: fix potential leak when we can't verify but keep receiving layers
+	//    see https://github.com/spacemeshos/go-spacemesh/issues/2671
+
+	windowStart, ok := t.lookbackWindowStart()
+	if !ok {
+		return
+	}
+	if !windowStart.After(t.LastEvicted) {
+		return
+	}
+	logger.With().Info("attempting eviction",
+		log.FieldNamed("effective_genesis", types.GetEffectiveGenesis()),
+		log.Uint32("hdist", t.Hdist),
+		log.FieldNamed("verified", t.Verified),
+		log.Uint32("window_size", t.WindowSize),
+		log.FieldNamed("last_evicted", t.LastEvicted),
+		log.FieldNamed("window_start", windowStart))
+
+	// evict from last evicted to the beginning of our window
+	for layerToEvict := t.LastEvicted.Add(1); layerToEvict.Before(windowStart); layerToEvict = layerToEvict.Add(1) {
+		logger.With().Debug("evicting layer", layerToEvict)
+		for blk := range t.BlockOpinionsByLayer[layerToEvict] {
 			delete(t.GoodBlocksIndex, blk)
 		}
-		delete(t.BlockOpinionsByLayer, lyr)
-		t.logger.Debug("evict block %v from maps", lyr)
-
+		delete(t.BlockOpinionsByLayer, layerToEvict)
 	}
-	t.Evict = window
+	t.LastEvicted = windowStart.Sub(1)
 }
 
 func blockIDsToString(input []types.BlockID) string {
@@ -130,24 +242,33 @@ func blockIDsToString(input []types.BlockID) string {
 	return str
 }
 
-// TODO: cache but somehow check for changes (hare that didn't finish finishes..) maybe check hash?
-func (t *turtle) getSingleInputVectorFromDB(lyrid types.LayerID, blockid types.BlockID) (vec, error) {
-	if !lyrid.After(types.GetEffectiveGenesis()) {
+// returns the local opinion on the validity of a block in a layer (support, against, or abstain)
+// TODO: cache but somehow check for changes (e.g., late-finishing Hare), maybe check hash?
+//    see https://github.com/spacemeshos/go-spacemesh/issues/2672
+func (t *turtle) getLocalBlockOpinion(ctx context.Context, layerID types.LayerID, blockid types.BlockID) (vec, error) {
+	if !layerID.After(types.GetEffectiveGenesis()) {
 		return support, nil
 	}
 
-	input, err := t.bdp.GetLayerInputVectorByID(lyrid)
+	input, err := t.layerOpinionVector(ctx, layerID)
+	// an error here signifies a real database failure
 	if err != nil {
 		return abstain, err
 	}
+	// otherwise, nil means we should abstain
+	if input == nil {
+		return abstain, nil
+	}
 
-	t.logger.With().Debug("got input vector from db",
-		lyrid,
+	t.logger.WithContext(ctx).With().Debug("got layer opinion vector",
+		layerID,
 		log.FieldNamed("query_block", blockid),
 		log.String("input", blockIDsToString(input)))
 
 	for _, bl := range input {
 		if bl == blockid {
+			// note: we never abstain on individual blocks, only on a whole layer, which would have been captured
+			// above.
 			return support, nil
 		}
 	}
@@ -155,38 +276,38 @@ func (t *turtle) getSingleInputVectorFromDB(lyrid types.LayerID, blockid types.B
 	return against, nil
 }
 
-func (t *turtle) checkBlockAndGetInputVector(
+func (t *turtle) checkBlockAndGetLocalOpinion(
+	ctx context.Context,
 	diffList []types.BlockID,
 	className string,
 	voteVector vec,
-	sourceBlockID types.BlockID,
-	layerIndex types.LayerID,
+	baseBlockLayer types.LayerID,
 ) bool {
+	logger := t.logger.WithContext(ctx)
 	for _, exceptionBlockID := range diffList {
 		if exceptionBlock, err := t.bdp.GetBlock(exceptionBlockID); err != nil {
-			t.logger.Panic("can't find %v from block's %v diff ", exceptionBlockID, sourceBlockID)
-		} else if exceptionBlock.LayerIndex.Before(layerIndex) {
-			t.logger.With().Debug("not marking block good because it points to block older than base block",
-				sourceBlockID,
+			logger.With().Error("inconsistent state: can't find block from diff list",
+				log.FieldNamed("exception_block_id", exceptionBlockID))
+			return false
+		} else if exceptionBlock.LayerIndex.Before(baseBlockLayer) {
+			logger.With().Error("good block candidate contains exception for block older than its base block",
 				log.FieldNamed("older_block", exceptionBlockID),
 				log.FieldNamed("older_layer", exceptionBlock.LayerIndex),
-				log.FieldNamed("base_block_lyr", layerIndex))
+				log.FieldNamed("base_block_layer", baseBlockLayer))
 			return false
-		} else if v, err := t.getSingleInputVectorFromDB(exceptionBlock.LayerIndex, exceptionBlockID); err != nil {
-			t.logger.With().Error("unable to get single input vector for exception block",
-				sourceBlockID,
+		} else if v, err := t.getLocalBlockOpinion(ctx, exceptionBlock.LayerIndex, exceptionBlockID); err != nil {
+			logger.With().Error("unable to get single block opinion for block in exception list",
 				log.FieldNamed("older_block", exceptionBlockID),
 				log.FieldNamed("older_layer", exceptionBlock.LayerIndex),
-				log.FieldNamed("base_block_lyr", layerIndex),
+				log.FieldNamed("base_block_layer", baseBlockLayer),
 				log.Err(err))
 			return false
 		} else if v != voteVector {
-			t.logger.With().Debug("not adding block to good blocks because its vote differs from input vector",
-				sourceBlockID,
+			logger.With().Debug("not adding block to good blocks because its vote differs from local opinion",
 				log.FieldNamed("older_block", exceptionBlock.ID()),
 				log.FieldNamed("older_layer", exceptionBlock.LayerIndex),
-				log.String("input_vote", v.String()),
-				log.String("block_vote", className))
+				log.FieldNamed("local_opinion", v),
+				log.String("block_exception_vote", className))
 			return false
 		}
 	}
@@ -194,171 +315,236 @@ func (t *turtle) checkBlockAndGetInputVector(
 	return true
 }
 
-func (t *turtle) inputVectorForLayer(layerBlocks []types.BlockID, input []types.BlockID) (layerResult map[types.BlockID]vec) {
-	layerResult = make(map[types.BlockID]vec, len(layerBlocks))
-	// XXX: input vector must be a pointer so we can differentiate
-	// between no support votes and no results at all.
-	if input == nil {
-		// hare didn't finish, so we have no opinion on blocks in this layer
-		// TODO: get hare Opinion when hare finishes
-		for _, b := range layerBlocks {
-			layerResult[b] = abstain
+// convert two vectors, of (1) raw candidate block IDs for a layer and (2) an opinion vector of blocks we believe belong
+// in the layer, into a map of votes for each of these blocks
+func (t *turtle) voteVectorForLayer(
+	candidateBlocks []types.BlockID, opinionVec []types.BlockID) (voteMap map[types.BlockID]vec) {
+	voteMap = make(map[types.BlockID]vec, len(candidateBlocks))
+	if opinionVec == nil {
+		// nil means abstain, i.e., we have no opinion on blocks in this layer
+		for _, b := range candidateBlocks {
+			voteMap[b] = abstain
 		}
 		return
 	}
 
 	// add support for all blocks in input vector
-	for _, b := range input {
-		layerResult[b] = support
+	for _, b := range opinionVec {
+		voteMap[b] = support
 	}
 
 	// vote against all layer blocks not in input vector
-	for _, b := range layerBlocks {
-		if _, ok := layerResult[b]; !ok {
-			layerResult[b] = against
+	for _, b := range candidateBlocks {
+		if _, ok := voteMap[b]; !ok {
+			voteMap[b] = against
 		}
 	}
 	return
 }
 
+// BaseBlock finds and returns a good block from a recent layer that's suitable to serve as a base block for opinions
+// for newly-constructed blocks. Also includes vectors of exceptions, where the current local opinion differs from
+// (or is newer than) that of the base block.
 func (t *turtle) BaseBlock(ctx context.Context) (types.BlockID, [][]types.BlockID, error) {
-	// Try to find a block counting only good blocks
-	// TODO: could we do better than just grabbing the first non-error, good block, as below?
-	// e.g., trying to minimize the size of the exception list instead
-	window := types.LayerID{}
-	if t.Hdist < t.Last.Uint32() {
-		window = t.Last.Sub(t.Hdist)
-	}
-	for i := t.Last; i.After(window); i = i.Sub(1) {
-		for block, opinion := range t.BlockOpinionsByLayer[i] {
-			if _, ok := t.GoodBlocksIndex[block]; !ok {
-				t.logger.With().Debug("skipping block not marked good",
-					log.FieldNamed("last_layer", t.Last),
-					i,
-					block)
+	logger := t.logger.WithContext(ctx)
+
+	// look at good blocks backwards from most recent processed layer to find a suitable base block
+	// TODO: optimize by, e.g., trying to minimize the size of the exception list (rather than first match)
+	// see https://github.com/spacemeshos/go-spacemesh/issues/2402
+	for layerID := t.Last; layerID.After(t.LastEvicted); layerID = layerID.Sub(1) {
+		logger := logger.WithFields(
+			log.FieldNamed("last_layer", t.Last),
+			log.FieldNamed("last_evicted", t.LastEvicted),
+			log.FieldNamed("base_block_candidate_layer", layerID))
+		for blockID, opinion := range t.BlockOpinionsByLayer[layerID] {
+			if _, ok := t.GoodBlocksIndex[blockID]; !ok {
+				logger.With().Info("not considering block not marked good as base block candidate", blockID)
 				continue
 			}
 
-			// Calculate the set of exceptions
-			exceptionVectorMap, err := t.calculateExceptions(i, block, opinion)
+			// Calculate the set of exceptions between the base block opinion and latest local opinion
+			logger.With().Debug("found candidate base block", blockID)
+			exceptionVectorMap, err := t.calculateExceptions(ctx, layerID, opinion)
 			if err != nil {
-				t.logger.With().Debug("can't use block: error %v",
-					log.FieldNamed("last_layer", t.Last),
-					i,
-					block,
-					log.Err(err))
+				logger.With().Warning("error calculating vote exceptions for block", blockID, log.Err(err))
 				continue
 			}
 
-			t.logger.With().Info("chose baseblock",
-				log.FieldNamed("last_layer", t.Last),
-				log.FieldNamed("base_block_layer", i),
-				block,
+			logger.With().Info("chose base block",
+				blockID,
 				log.Int("against_count", len(exceptionVectorMap[0])),
 				log.Int("support_count", len(exceptionVectorMap[1])),
 				log.Int("neutral_count", len(exceptionVectorMap[2])))
 
-			return block, [][]types.BlockID{
+			return blockID, [][]types.BlockID{
 				blockMapToArray(exceptionVectorMap[0]),
 				blockMapToArray(exceptionVectorMap[1]),
 				blockMapToArray(exceptionVectorMap[2]),
 			}, nil
 		}
 	}
+
 	// TODO: special error encoding when exceeding exception list size
-	return types.BlockID{0}, nil, errors.New("no good base block within exception vector limit")
+	return types.BlockID{0}, nil, errNoBaseBlockFound
 }
 
-func (t *turtle) calculateExceptions(layerid types.LayerID, blockid types.BlockID, opinion2 Opinion) ([]map[types.BlockID]struct{}, error) {
+// calculate and return a list of exceptions, i.e., differences between the opinions of a base block and the local
+// opinion
+func (t *turtle) calculateExceptions(
+	ctx context.Context,
+	baseBlockLayerID types.LayerID,
+	baseBlockOpinion Opinion, // candidate base block's opinion vector
+) ([]map[types.BlockID]struct{}, error) {
+	logger := t.logger.WithContext(ctx).WithFields(log.FieldNamed("base_block_layer_id", baseBlockLayerID))
+
 	// using maps prevents duplicates
 	againstDiff := make(map[types.BlockID]struct{})
 	forDiff := make(map[types.BlockID]struct{})
 	neutralDiff := make(map[types.BlockID]struct{})
 
-	// all genesis blocks get a for vote
-	if layerid == types.GetEffectiveGenesis() {
+	// we support all genesis blocks by default
+	if baseBlockLayerID == types.GetEffectiveGenesis() {
 		for _, i := range types.BlockIDs(mesh.GenesisLayer().Blocks()) {
 			forDiff[i] = struct{}{}
 		}
-		return []map[types.BlockID]struct{}{againstDiff, forDiff, neutralDiff}, nil
 	}
 
-	// TODO: maybe we should vote back hdist but drill down check the base blocks
-
-	// Add latest layers input vector results to the diff.
-	for i := layerid; !i.After(t.Last); i = i.Add(1) {
-		t.logger.With().Debug("checking input vector diffs", i)
+	// Add latest layers input vector results to the diff
+	// Note: a block may only be selected as a candidate base block if it's marked "good", and it may only be marked
+	// "good" if its own base block is marked "good" and all exceptions it contains agree with our local opinion.
+	// We only look for and store exceptions within the sliding window set of layers as an optimization, but a block
+	// can contain exceptions from any layer, back to genesis.
+	startLayer := t.LastEvicted.Add(1)
+	if startLayer.Before(types.GetEffectiveGenesis()) {
+		startLayer = types.GetEffectiveGenesis()
+	}
+	for layerID := startLayer; !layerID.After(t.Last); layerID = layerID.Add(1) {
+		logger := logger.WithFields(log.FieldNamed("diff_layer_id", layerID))
+		logger.Debug("checking input vector diffs")
 
-		layerBlockIds, err := t.bdp.LayerBlockIds(i)
+		layerBlockIds, err := t.bdp.LayerBlockIds(layerID)
 		if err != nil {
 			if err != leveldb.ErrClosed {
-				// todo: empty layer? maybe skip verify differently
-				t.logger.Panic("can't find old layer %v", i)
+				// this should not happen! we only look at layers up to the last processed layer, and we only process
+				// layers with valid block data.
+				logger.With().Error("no block ids for layer in database", log.Err(err))
 			}
 			return nil, err
 		}
 
-		// TODO: how to differentiate between missing Hare results, and Hare failed/gave up waiting?
-		layerInputVector, err := t.bdp.GetLayerInputVectorByID(i)
+		// helper function for adding diffs
+		addDiffs := func(bid types.BlockID, voteClass string, voteVec vec, diffMap map[types.BlockID]struct{}) {
+			if v, ok := baseBlockOpinion.BlockOpinions[bid]; !ok || simplifyVote(v) != voteVec {
+				logger.With().Debug("added vote diff",
+					log.FieldNamed("diff_block", bid),
+					log.String("diff_class", voteClass))
+				if layerID.Before(baseBlockLayerID) {
+					logger.With().Warning("added exception before base block layer, this block will not be marked good",
+						log.FieldNamed("diff_block", bid),
+						log.String("diff_class", voteClass))
+				}
+				diffMap[bid] = struct{}{}
+			}
+		}
+
+		// get local opinion for layer
+		layerInputVector, err := t.layerOpinionVector(ctx, layerID)
 		if err != nil {
-			t.logger.With().Debug("input vector is empty, adding neutral diffs", i, log.Err(err))
+			// an error here signifies a real database failure
+			logger.With().Error(errstrUnableToCalculateLocalOpinion, log.Err(err))
+			return nil, err
+		}
+
+		// otherwise, nil means we should abstain
+		if layerInputVector == nil {
+			// still waiting for Hare results, vote neutral and move on
+			logger.With().Debug("input vector is empty, adding neutral diffs", log.Err(err))
 			for _, b := range layerBlockIds {
-				if v, ok := opinion2.BlocksOpinion[b]; !ok || v != abstain {
-					t.logger.With().Debug("added diff",
-						log.FieldNamed("base_block_candidate", blockid),
-						log.FieldNamed("diff_block", b),
-						log.String("diff", "neutral"))
-					neutralDiff[b] = struct{}{}
-				}
+				addDiffs(b, "neutral", abstain, neutralDiff)
 			}
 			continue
 		}
+		logger.With().Debug("got local opinion vector for layer", log.Int("count", len(layerInputVector)))
 
 		inInputVector := make(map[types.BlockID]struct{})
 
+		// Add diffs FOR blocks that are in the input vector, but where the base block has no opinion or does not
+		// explicitly support the block
 		for _, b := range layerInputVector {
 			inInputVector[b] = struct{}{}
-			if v, ok := opinion2.BlocksOpinion[b]; !ok || v != support {
-				// Block is in input vector but no base block vote or base block doesn't support it:
-				// add diff FOR this block
-				t.logger.With().Debug("added diff",
-					log.FieldNamed("base_block_candidate", blockid),
-					log.FieldNamed("diff_block", b),
-					log.String("diff", "support"))
-				forDiff[b] = struct{}{}
-			}
+			addDiffs(b, "support", support, forDiff)
 		}
 
-		for _, b := range layerBlockIds {
-			// Matches input vector, no diff (i.e., both support)
-			if _, ok := inInputVector[b]; ok {
-				continue
-			}
-
-			// TODO: maybe we don't need this if it is not included
-			if v, ok := opinion2.BlocksOpinion[b]; !ok || v != against {
-				// Layer block has no base block vote or base block supports, but not in input vector:
-				// add diff AGAINST this block
-				t.logger.With().Debug("added diff",
-					log.FieldNamed("base_block_candidate", blockid),
-					log.FieldNamed("diff_block", b),
-					log.String("diff", "against"))
-				againstDiff[b] = struct{}{}
-			}
-		}
+		// Finally, we need to consider the case where the base block supports a block in this layer that is not in our
+		// input vector (e.g., one we haven't seen), by adding a diff against the block.
+		// We do not explicitly add votes against blocks that the base block does _not_ support, since by not voting to
+		// support a block in an old layer, we are implicitly voting against it. But if the base block does explicitly
+		// support a block and we disagree, we need to add a vote against here.
+		// TODO: this is not currently possible since base block opinions aren't indexed by layer. See
+		//   https://github.com/spacemeshos/go-spacemesh/issues/2424
+		//for b, v := range baseBlockOpinion.BlockOpinions {
+		//	if _, ok := inInputVector[b]; !ok && v != against {
+		//		addDiffs(b, "against", against, againstDiff)
+		//	}
+		//}
 	}
 
 	// check if exceeded max no. exceptions
 	explen := len(againstDiff) + len(forDiff) + len(neutralDiff)
 	if explen > t.MaxExceptions {
-		return nil, fmt.Errorf("too many exceptions to base block vote (%v)", explen)
+		return nil, fmt.Errorf("%s (%v)", errstrTooManyExceptions, explen)
 	}
 
 	return []map[types.BlockID]struct{}{againstDiff, forDiff, neutralDiff}, nil
 }
 
-func (t *turtle) BlockWeight(voting, voted types.BlockID) int {
-	return 1
+// voteWeight returns the weight to assign to one block's vote for another.
+// Note: weight depends on more than just the weight of the voting block. It also depends on contextual factors such as
+// whether or not the block's ATX was received on time, and on how old the layer is.
+// TODO: for now it's probably sufficient to adjust weight based on whether the ATX was received on time, or late, for
+//   the current epoch. See https://github.com/spacemeshos/go-spacemesh/issues/2540.
+func (t *turtle) voteWeight(ctx context.Context, votingBlock *types.Block) (uint64, error) {
+	logger := t.logger.WithContext(ctx)
+
+	atxHeader, err := t.atxdb.GetAtxHeader(votingBlock.ATXID)
+	if err != nil {
+		return 0, err
+	}
+	atxTimestamp, err := t.atxdb.GetAtxTimestamp(votingBlock.ATXID)
+	if err != nil {
+		return 0, err
+	}
+	atxEpoch := atxHeader.PubLayerID.GetEpoch()
+	nextEpochStart := t.clock.LayerToTime((atxEpoch + 1).FirstLayer())
+
+	// check if the ATX was received on time
+	// TODO: add an exception for sync, when we expect everything to be received late
+	if atxTimestamp.Before(nextEpochStart) {
+		blockWeight := atxHeader.GetWeight()
+		logger.With().Debug("voting block atx was timely",
+			log.FieldNamed("next_epoch", atxEpoch+1),
+			log.Time("next_epoch_start", nextEpochStart),
+			log.Time("atx_timestamp", atxTimestamp),
+			votingBlock.ID(),
+			votingBlock.ATXID,
+			log.Uint64("block_weight", blockWeight))
+		return blockWeight, nil
+	}
+	logger.With().Warning("voting block atx was untimely, zeroing block vote weight",
+		log.FieldNamed("next_epoch", atxEpoch+1),
+		log.Time("next_epoch_start", nextEpochStart),
+		log.Time("atx_timestamp", atxTimestamp),
+		votingBlock.ID(),
+		votingBlock.ATXID)
+	return 0, nil
+}
+
+func (t *turtle) voteWeightByID(ctx context.Context, votingBlockID, blockVotedOn types.BlockID) (uint64, error) {
+	block, err := t.bdp.GetBlock(votingBlockID)
+	if err != nil {
+		return 0, err
+	}
+	return t.voteWeight(ctx, block)
 }
 
 // Persist saves the current tortoise state to the database
@@ -366,256 +552,697 @@ func (t *turtle) persist() error {
 	return t.bdp.Persist(mesh.TORTOISE, t)
 }
 
-// RecoverVerifyingTortoise retrieve latest saved tortoise from the database
+// RecoverVerifyingTortoise retrieves the latest saved tortoise from the database
 func RecoverVerifyingTortoise(mdb retriever) (interface{}, error) {
 	return mdb.Retrieve(mesh.TORTOISE, &turtle{})
 }
 
-func (t *turtle) processBlock(block *types.Block) error {
+func (t *turtle) processBlock(ctx context.Context, block *types.Block) error {
+	logger := t.logger.WithContext(ctx).WithFields(
+		log.FieldNamed("processing_block_id", block.ID()),
+		log.FieldNamed("processing_block_layer", block.LayerIndex))
+
 	// When a new block arrives, we look up the block it points to in our table,
 	// and add the corresponding vector (multiplied by the block weight) to our own vote-totals vector.
 	// We then add the vote difference vector and the explicit vote vector to our vote-totals vector.
-	t.logger.With().Debug("processing block", block.Fields()...)
-	t.logger.With().Debug("getting baseblock", block.BaseBlock)
+	logger.With().Debug("processing block", block.Fields()...)
+	logger.With().Debug("getting base block", log.FieldNamed("base_block_id", block.BaseBlock))
 
-	base, err := t.bdp.GetBlock(block.BaseBlock)
+	baseBlock, err := t.bdp.GetBlock(block.BaseBlock)
 	if err != nil {
-		return fmt.Errorf("can't find baseblock")
+		return errBaseBlockNotInDatabase
 	}
 
-	t.logger.With().Debug("block supports", types.BlockIdsField(block.BlockHeader.ForDiff))
-	t.logger.With().Debug("checking baseblock", base.Fields()...)
+	logger.With().Debug("block adds support for",
+		log.Int("count", len(block.BlockHeader.ForDiff)),
+		types.BlockIdsField(block.BlockHeader.ForDiff))
+	logger.With().Debug("checking base block", baseBlock.Fields()...)
 
-	layerOpinions, ok := t.BlockOpinionsByLayer[base.LayerIndex]
+	layerOpinions, ok := t.BlockOpinionsByLayer[baseBlock.LayerIndex]
 	if !ok {
-		return fmt.Errorf("baseblock layer not found %v, %v", block.BaseBlock, base.LayerIndex)
+		return fmt.Errorf("%s: %v, %v", errstrBaseBlockLayerMissing, block.BaseBlock, baseBlock.LayerIndex)
 	}
 
-	baseBlockOpinion, ok := layerOpinions[base.ID()]
+	baseBlockOpinion, ok := layerOpinions[baseBlock.ID()]
 	if !ok {
-		return fmt.Errorf("baseblock not found in layer %v, %v", block.BaseBlock, base.LayerIndex)
+		return fmt.Errorf("%s: %v, %v", errstrBaseBlockNotFoundInLayer, block.BaseBlock, baseBlock.LayerIndex)
 	}
 
+	voteWeight, err := t.voteWeight(ctx, block)
+	if err != nil {
+		return fmt.Errorf("error getting vote weight for block %v: %w", block.ID(), err)
+	}
+
+	// TODO: this logic would be simpler if For and Against were a single list
+	//   see https://github.com/spacemeshos/go-spacemesh/issues/2369
 	// TODO: save and vote against blocks that exceed the max exception list size (DoS prevention)
+	//   see https://github.com/spacemeshos/go-spacemesh/issues/2673
 	opinion := make(map[types.BlockID]vec)
-	for blk, vote := range baseBlockOpinion.BlocksOpinion {
+
+	for _, bid := range block.ForDiff {
+		opinion[bid] = support.Multiply(voteWeight)
+	}
+	for _, bid := range block.AgainstDiff {
+		// this could only happen in malicious blocks, and they should not pass a syntax check, but check here just
+		// to be extra safe
+		if _, alreadyVoted := opinion[bid]; alreadyVoted {
+			return fmt.Errorf("%s %v", errstrConflictingVotes, block.ID())
+		}
+		opinion[bid] = against.Multiply(voteWeight)
+	}
+	for _, bid := range block.NeutralDiff {
+		if _, alreadyVoted := opinion[bid]; alreadyVoted {
+			return fmt.Errorf("%s %v", errstrConflictingVotes, block.ID())
+		}
+		opinion[bid] = abstain
+	}
+	for blk, vote := range baseBlockOpinion.BlockOpinions {
+		// ignore opinions of very old blocks
 		fblk, err := t.bdp.GetBlock(blk)
 		if err != nil {
-			return fmt.Errorf("voted block not in db voting_block_id: %v, voting_block_layer_id: %v, voted_block_id: %v", block.ID().String(), block.LayerIndex, blk.String())
+			return fmt.Errorf(
+				"block in base block opinion list not in db! "+
+					"voting_block_id: %v, voting_block_layer: %v, base_block_id: %v, base_block_layer: %v, block_id: %v",
+				block.ID().String(), block.LayerIndex, baseBlock.ID(), baseBlock.LayerIndex, blk.String())
 		}
-		window := types.LayerID{}
-		if block.LayerIndex.Uint32() > t.Hdist {
-			window = block.LayerIndex.Sub(t.Hdist)
-		}
-		if fblk.LayerIndex.Before(window) {
+		if fblk.LayerIndex.Before(t.LastEvicted) {
 			continue
 		}
 
-		opinion[blk] = vote
-	}
-
-	for _, b := range block.ForDiff {
-		opinion[b] = opinion[b].Add(support.Multiply(t.BlockWeight(block.ID(), b)))
-	}
-	for _, b := range block.AgainstDiff {
-		opinion[b] = opinion[b].Add(against.Multiply(t.BlockWeight(block.ID(), b)))
+		// add base block vote only if there weren't already exceptions (support/against/abstain) for this block.
+		// and re-weight vote since we want the voting block's weight, not the base block's weight.
+		if _, exists := opinion[blk]; !exists {
+			opinion[blk] = simplifyVote(vote).Multiply(voteWeight)
+		}
 	}
 
-	// TODO: neutral ?
-	t.logger.With().Debug("adding block to blocks table", block.Fields()...)
-	t.BlockOpinionsByLayer[block.LayerIndex][block.ID()] = Opinion{BlocksOpinion: opinion}
+	logger.With().Debug("adding or updating block opinion")
+	t.BlockOpinionsByLayer[block.LayerIndex][block.ID()] = Opinion{BlockOpinions: opinion}
 	return nil
 }
 
-// HandleIncomingLayer processes all layer block votes
-// returns the old pbase and new pbase after taking into account the blocks votes
-// TODO: inputVector is unused here, fix this
-func (t *turtle) HandleIncomingLayer(newlyr *types.Layer) (pbaseOld, pbaseNew types.LayerID) {
-	// These are our starting values
-	pbaseOld = t.Verified
-	pbaseNew = t.Verified
-
-	if t.Last.Before(newlyr.Index()) {
-		t.Last = newlyr.Index()
+// ProcessNewBlocks processes the votes of a set of blocks, records their opinions, and marks good blocks good.
+// The blocks do not all have to be in the same layer, but if they span multiple layers, they must be sorted by LayerID.
+func (t *turtle) ProcessNewBlocks(ctx context.Context, blocks []*types.Block) error {
+	if len(blocks) == 0 {
+		// nothing to do
+		t.logger.WithContext(ctx).Warning("cannot process empty block list")
+		return nil
 	}
-
-	if len(newlyr.Blocks()) == 0 {
-		t.logger.With().Warning("attempted to handle empty layer", newlyr)
-		return
-		// todo: something else to do on empty layer?
+	if err := t.processBlocks(ctx, blocks); err != nil {
+		return err
 	}
 
-	if !newlyr.Index().After(types.GetEffectiveGenesis()) {
-		t.logger.With().Debug("not attempting to handle genesis layer", newlyr)
-		return
-	}
-
-	// TODO: handle late blocks
+	// attempt to verify layers up to the latest one for which we have new block data
+	return t.verifyLayers(ctx)
+}
 
-	defer t.evict()
+func (t *turtle) processBlocks(ctx context.Context, blocks []*types.Block) error {
+	logger := t.logger.WithContext(ctx)
+	lastLayerID := types.NewLayerID(0)
 
-	t.logger.With().Info("start handling incoming layer",
-		newlyr.Index(),
-		log.Int("num_blocks", len(newlyr.Blocks())))
+	logger.With().Info("tortoise handling incoming block data", log.Int("num_blocks", len(blocks)))
 
 	// process the votes in all layer blocks and update tables
-	for _, b := range newlyr.Blocks() {
+	filteredBlocks := make([]*types.Block, 0, len(blocks))
+	for _, b := range blocks {
+		logger := logger.WithFields(b.ID(), b.LayerIndex)
+		// make sure we don't write data on old blocks whose layer has already been evicted
+		if b.LayerIndex.Before(t.LastEvicted) {
+			logger.With().Warning("not processing block from layer older than last evicted layer",
+				log.FieldNamed("last_evicted", t.LastEvicted))
+			continue
+		}
+		if b.LayerIndex.Before(lastLayerID) {
+			return errNotSorted
+		} else if b.LayerIndex.After(lastLayerID) {
+			lastLayerID = b.LayerIndex
+		}
 		if _, ok := t.BlockOpinionsByLayer[b.LayerIndex]; !ok {
 			t.BlockOpinionsByLayer[b.LayerIndex] = make(map[types.BlockID]Opinion, t.AvgLayerSize)
 		}
-		if err := t.processBlock(b); err != nil {
-			t.logger.Panic(fmt.Sprintf("error processing block %v: %v", b.ID(), err))
-		}
-	}
-
-	blockscount := len(newlyr.Blocks())
-	goodblocks := len(t.GoodBlocksIndex)
-	// Go over all blocks, in order. Mark block i “good” if:
-	for _, b := range newlyr.Blocks() {
-		// (1) the base block is marked as good
-		if _, good := t.GoodBlocksIndex[b.BaseBlock]; !good {
-			t.logger.With().Debug("not marking block as good because baseblock is not good",
-				newlyr.Index(),
-				b.ID(),
-				log.FieldNamed("base_block", b.BaseBlock))
-		} else if baseBlock, err := t.bdp.GetBlock(b.BaseBlock); err != nil {
-			t.logger.Panic(fmt.Sprint("block not found ", b.BaseBlock, "err", err))
-		} else if t.checkBlockAndGetInputVector(b.ForDiff, "support", support, b.ID(), baseBlock.LayerIndex) &&
-			t.checkBlockAndGetInputVector(b.AgainstDiff, "against", against, b.ID(), baseBlock.LayerIndex) &&
-			t.checkBlockAndGetInputVector(b.NeutralDiff, "abstain", abstain, b.ID(), baseBlock.LayerIndex) {
-			// (2) all diffs appear after the base block and are consistent with the input vote vector
-			t.logger.With().Debug("marking good block", b.ID(), b.LayerIndex)
+		if err := t.processBlock(ctx, b); err != nil {
+			logger.With().Error("error processing block", log.Err(err))
+		} else {
+			filteredBlocks = append(filteredBlocks, b)
+		}
+	}
+
+	t.scoreBlocks(ctx, filteredBlocks)
+
+	if t.Last.Before(lastLayerID) {
+		logger.With().Warning("got blocks for new layer before receiving layer, updating highest layer seen",
+			log.FieldNamed("previous_highest", t.Last),
+			log.FieldNamed("new_highest", lastLayerID))
+		t.Last = lastLayerID
+	}
+
+	return nil
+}
+
+func (t *turtle) scoreBlocksByLayerID(ctx context.Context, layerID types.LayerID) error {
+	blocks, err := t.bdp.LayerBlocks(layerID)
+	if err != nil {
+		return err
+	}
+	t.scoreBlocks(ctx, blocks)
+	return nil
+}
+
+func (t *turtle) scoreBlocks(ctx context.Context, blocks []*types.Block) {
+	logger := t.logger.WithContext(ctx)
+	logger.With().Debug("marking good blocks", log.Int("count", len(blocks)))
+	numGood := 0
+	for _, b := range blocks {
+		if t.determineBlockGoodness(ctx, b) {
+			// note: we have no way of warning if a block was previously marked as not good
+			logger.With().Info("marking block good", b.ID(), b.LayerIndex)
 			t.GoodBlocksIndex[b.ID()] = struct{}{}
+			numGood++
 		} else {
-			t.logger.With().Debug("not marking block good", b.ID(), b.LayerIndex)
+			logger.With().Info("not marking block good", b.ID(), b.LayerIndex)
+			if _, isGood := t.GoodBlocksIndex[b.ID()]; isGood {
+				logger.With().Warning("marking previously good block as not good", b.ID(), b.LayerIndex)
+				delete(t.GoodBlocksIndex, b.ID())
+			}
 		}
 	}
 
-	t.logger.With().Info("finished marking good blocks", log.Int("total_blocks", blockscount), log.Int("good_blocks", len(t.GoodBlocksIndex)-goodblocks))
+	logger.With().Info("finished marking good blocks",
+		log.Int("total_blocks", len(blocks)),
+		log.Int("good_blocks", numGood))
+}
+
+func (t *turtle) determineBlockGoodness(ctx context.Context, block *types.Block) bool {
+	logger := t.logger.WithContext(ctx).WithFields(
+		block.ID(),
+		block.LayerIndex,
+		log.FieldNamed("base_block_id", block.BaseBlock))
+	// Go over all blocks, in order. Mark block i "good" if:
+	// (1) the base block is marked as good
+	if _, good := t.GoodBlocksIndex[block.BaseBlock]; !good {
+		logger.Debug("base block is not good")
+	} else if baseBlock, err := t.bdp.GetBlock(block.BaseBlock); err != nil {
+		logger.With().Error("inconsistent state: base block not found", log.Err(err))
+	} else if true &&
+		// (2) all diffs appear after the base block and are consistent with the current local opinion
+		t.checkBlockAndGetLocalOpinion(ctx, block.ForDiff, "support", support, baseBlock.LayerIndex) &&
+		t.checkBlockAndGetLocalOpinion(ctx, block.AgainstDiff, "against", against, baseBlock.LayerIndex) &&
+		t.checkBlockAndGetLocalOpinion(ctx, block.NeutralDiff, "abstain", abstain, baseBlock.LayerIndex) {
+		logger.Debug("block is good")
+		return true
+	}
+	logger.Debug("block is not good")
+	return false
+}
+
+// HandleIncomingLayer processes all layer block votes
+// returns the old pbase and new pbase after taking into account block votes
+func (t *turtle) HandleIncomingLayer(ctx context.Context, layerID types.LayerID) error {
+	if err := t.handleLayerBlocks(ctx, layerID); err != nil {
+		return err
+	}
+
+	// attempt to verify layers up to the latest one for which we have new block data
+	return t.verifyLayers(ctx)
+}
+
+func (t *turtle) handleLayerBlocks(ctx context.Context, layerID types.LayerID) error {
+	logger := t.logger.WithContext(ctx).WithFields(layerID)
+
+	if !layerID.After(types.GetEffectiveGenesis()) {
+		logger.Debug("not attempting to handle genesis layer")
+		return nil
+	}
+
+	// Note: we don't compare newlyr and t.Verified, so this method could be called again on an already-verified layer.
+	// That would update the stored block opinions but it would not attempt to re-verify an already-verified layer.
+
+	// read layer blocks
+	layerBlocks, err := t.bdp.LayerBlocks(layerID)
+	if err != nil {
+		return fmt.Errorf("unable to read contents of layer %v: %w", layerID, err)
+	}
+	if len(layerBlocks) == 0 {
+		// nothing to do
+		t.logger.WithContext(ctx).Warning("cannot process empty layer block list")
+		return nil
+	}
+
+	if t.Last.Before(layerID) {
+		t.Last = layerID
+	}
+
+	logger.With().Info("tortoise handling incoming layer", log.Int("num_blocks", len(layerBlocks)))
+	return t.processBlocks(ctx, layerBlocks)
+}
+
+// loops over all layers from the last verified up to a new target layer and attempts to verify each in turn
+func (t *turtle) verifyLayers(ctx context.Context) error {
+	logger := t.logger.WithContext(ctx).WithFields(
+		log.FieldNamed("verification_target", t.Last),
+		log.FieldNamed("old_verified", t.Verified))
+	logger.Info("starting layer verification")
+
+	// we perform eviction here because it should happen after the verified layer advances
+	defer t.evict(ctx)
+
+	// attempt to verify each layer from the last verified up to one prior to the newly-arrived layer.
+	// this is the full range of unverified layers that we might possibly be able to verify at this point.
+	// Note: t.Verified is initialized to the effective genesis layer, so the first candidate layer here necessarily
+	// follows and is post-genesis. There's no need for an additional check here.
+candidateLayerLoop:
+	for candidateLayerID := t.Verified.Add(1); candidateLayerID.Before(t.Last); candidateLayerID = candidateLayerID.Add(1) {
+		logger := logger.WithFields(log.FieldNamed("candidate_layer", candidateLayerID))
+
+		// it's possible that self healing already verified a layer
+		if !t.Verified.Before(candidateLayerID) {
+			logger.Info("self healing already verified this layer")
+			continue
+		}
 
-	idx := newlyr.Index()
-	pbaseOld = t.Verified
-	t.logger.With().Info("starting layer verification",
-		log.FieldNamed("was_verified", pbaseOld),
-		log.FieldNamed("target_verification", newlyr.Index()))
+		logger.Info("attempting to verify candidate layer")
 
-layerLoop:
-	for i := pbaseOld.Add(1); i.Before(idx); i = i.Add(1) {
-		t.logger.With().Info("verifying layer", i)
+		// note: if the following checks fail, we just return rather than trying to verify later layers.
+		// we don't presently support verifying layer N+1 when layer N hasn't been verified.
 
-		layerBlockIds, err := t.bdp.LayerBlockIds(i)
+		layerBlockIds, err := t.bdp.LayerBlockIds(candidateLayerID)
 		if err != nil {
-			t.logger.With().Warning("can't find layer in db, skipping verification", i)
-			continue // Panic? can't get layer
+			return fmt.Errorf("%s %v: %w", errstrCantFindLayer, candidateLayerID, err)
 		}
 
-		// TODO: implement handling hare terminating with no valid blocks.
-		// 	currently input vector is nil if hare hasn't terminated yet.
-		//	 ACT: hare should save something in the db when terminating empty set, sync should check it.
-		rawLayerInputVector, err := t.bdp.GetLayerInputVectorByID(i)
+		// get the local opinion for this layer. below, we calculate the global opinion on each block in the layer and
+		// check if it agrees with this local opinion.
+		rawLayerInputVector, err := t.layerOpinionVector(ctx, candidateLayerID)
 		if err != nil {
-			// this sets the input to abstain
-			t.logger.With().Warning("input vector abstains on all blocks", i)
+			// an error here signifies a real database failure
+			return fmt.Errorf("%s %v: %w", errstrUnableToCalculateLocalOpinion, candidateLayerID, err)
 		}
-		layerVotes := t.inputVectorForLayer(layerBlockIds, rawLayerInputVector)
-		if len(layerVotes) == 0 {
-			t.logger.With().Warning("no blocks in input vector, can't verify layer", i)
-			break
+
+		// otherwise, nil means we should abstain
+		if rawLayerInputVector == nil {
+			logger.With().Warning("input vector abstains on all blocks in layer", candidateLayerID)
+		}
+		localLayerOpinionVec := t.voteVectorForLayer(layerBlockIds, rawLayerInputVector)
+		if len(localLayerOpinionVec) == 0 {
+			// warn about this to be safe, but we do allow empty layers and must be able to verify them
+			logger.With().Warning("empty vote vector for layer", candidateLayerID)
 		}
 
 		contextualValidity := make(map[types.BlockID]bool, len(layerBlockIds))
 
-		// Count the votes of good blocks. vote is our opinion on this block.
-		// Declare the vote vector “verified” up to position k if the total weight exceeds the confidence threshold in
-		// all positions up to k
-		for blk, vote := range layerVotes {
-			// Count the votes for the input vote vector by summing the weight of the good blocks
-			sum := abstain
-
-			// Step backwards from the latest received layer to i+1, but only count votes for the interval [i, i+Hdist]
-			var startLayer types.LayerID
-			if t.Last.Before(i.Add(t.Hdist)) {
-				startLayer = t.Last
-			} else {
-				startLayer = i.Add(t.Hdist).Sub(1)
+		// Count the votes of good blocks. localOpinionOnBlock is our local opinion on this block.
+		// Declare the vote vector "verified" up to position k if the total weight exceeds the confidence threshold in
+		// all positions up to k: in other words, we can verify a layer k if the total weight of the global opinion
+		// exceeds the confidence threshold, and agrees with local opinion.
+		for blockID, localOpinionOnBlock := range localLayerOpinionVec {
+			// count the votes of the input vote vector by summing the voting weight of good blocks
+			logger.With().Debug("summing votes for candidate layer block",
+				blockID,
+				log.FieldNamed("layer_start", candidateLayerID.Add(1)),
+				log.FieldNamed("layer_end", t.Last))
+			sum, err := t.sumVotesForBlock(ctx, blockID, candidateLayerID.Add(1), func(votingBlockID types.BlockID) bool {
+				if _, isgood := t.GoodBlocksIndex[votingBlockID]; !isgood {
+					logger.With().Debug("not counting vote of block not marked good",
+						log.FieldNamed("voting_block", votingBlockID))
+					return false
+				}
+				return true
+			})
+			if err != nil {
+				return fmt.Errorf("error summing votes for block %v in candidate layer %v: %w",
+					blockID, candidateLayerID, err)
+			}
+
+			// check that the total weight exceeds the global threshold
+			globalOpinionOnBlock := calculateOpinionWithThreshold(
+				t.logger, sum, t.AvgLayerSize, t.GlobalThreshold, float64(t.Last.Difference(candidateLayerID)))
+			logger.With().Debug("verifying tortoise calculated global opinion on block",
+				log.FieldNamed("block_voted_on", blockID),
+				candidateLayerID,
+				log.FieldNamed("global_vote_sum", sum),
+				log.FieldNamed("global_opinion", globalOpinionOnBlock),
+				log.FieldNamed("local_opinion", localOpinionOnBlock))
+
+			// At this point, we have all of the data we need to make a decision on this block. There are three possible
+			// outcomes:
+			// 1. record our opinion on this block and go on evaluating the rest of the blocks in this layer to see if
+			//    we can verify the layer (if local and global consensus match, and global consensus is decided)
+			// 2. keep waiting to verify the layer (if not, and the layer is relatively recent)
+			// 3. trigger self healing (if not, and the layer is sufficiently old)
+			consensusMatches := globalOpinionOnBlock == localOpinionOnBlock
+			globalOpinionDecided := globalOpinionOnBlock != abstain
+
+			if consensusMatches && globalOpinionDecided {
+				// Opinion on this block is decided, save and keep going
+				contextualValidity[blockID] = globalOpinionOnBlock == support
+				continue
 			}
-			for j := startLayer; j.After(i); j = j.Sub(1) {
-				// check if the block is good
-				for bid, op := range t.BlockOpinionsByLayer[j] {
-					if _, isgood := t.GoodBlocksIndex[bid]; !isgood {
-						t.logger.With().Debug("not counting vote of block not marked good",
-							log.FieldNamed("voting_block", bid),
-							log.FieldNamed("voted_block", blk))
-						continue
-					}
 
-					// check if this block has an opinion on this block (TODO: maybe no opinion means AGAINST?)
-					opinionVote, ok := op.BlocksOpinion[blk]
-					if !ok {
-						t.logger.With().Debug("no opinion on block",
-							log.FieldNamed("voting_block", bid),
-							log.FieldNamed("voted_block", blk))
-						continue
+			// If, for any block in this layer, the global opinion (summed block votes) disagrees with our vote (the
+			// input vector), or if the global opinion is abstain, then we do not verify this layer. This could be the
+			// result of a reorg (e.g., resolution of a network partition), or a malicious peer during sync, or
+			// disagreement about Hare success.
+			if !consensusMatches {
+				logger.With().Warning("global opinion on block differs from our vote, cannot verify layer",
+					blockID,
+					log.FieldNamed("global_opinion", globalOpinionOnBlock),
+					log.FieldNamed("local_opinion", localOpinionOnBlock))
+			}
+
+			// There are only two scenarios that could result in a global opinion of abstain: if everyone is still
+			// waiting for Hare to finish for a layer (i.e., it has not yet succeeded or failed), or a balancing attack.
+			// The former is temporary and will go away after `zdist' layers. And it should be true of an entire layer,
+			// not just of a single block. The latter could cause the global opinion of a single block to permanently
+			// be abstain. As long as the contextual validity of any block in a layer is unresolved, we cannot verify
+			// the layer (since the effectiveness of each transaction in the layer depends upon the contents of the
+			// entire layer and transaction ordering). Therefore we have to enter self healing in this case.
+			// TODO: abstain only for entire layer at a time, not for individual blocks (optimization)
+			//   see https://github.com/spacemeshos/go-spacemesh/issues/2674
+			if !globalOpinionDecided {
+				logger.With().Warning("global opinion on block is abstain, cannot verify layer",
+					blockID,
+					log.FieldNamed("global_opinion", globalOpinionOnBlock),
+					log.FieldNamed("local_opinion", localOpinionOnBlock))
+			}
+
+			// Verifying tortoise will wait `zdist' layers for consensus, then an additional `ConfidenceParam'
+			// layers until all other nodes achieve consensus. If it's still stuck after this point, i.e., if the gap
+			// between this unverified candidate layer and the latest layer is greater than this distance, then we trigger
+			// self healing. But there's no point in trying to heal a layer that's not at least Hdist layers old since
+			// we only consider the local opinion for recent layers.
+			if candidateLayerID.After(t.Last) {
+				logger.With().Panic("candidate layer is higher than last layer received",
+					log.FieldNamed("last_layer", t.Last))
+			}
+			logger.With().Debug("considering attempting to heal layer",
+				log.FieldNamed("layer_cutoff", t.layerCutoff()),
+				log.Uint32("zdist", t.Zdist),
+				log.FieldNamed("last_layer_received", t.Last),
+				log.Uint32("confidence_param", t.ConfidenceParam))
+			if candidateLayerID.Before(t.layerCutoff()) && t.Last.Difference(candidateLayerID) > t.Zdist+t.ConfidenceParam {
+				lastLayer := t.Last
+				// don't attempt to heal layers newer than Hdist
+				if lastLayer.After(t.layerCutoff()) {
+					lastLayer = t.layerCutoff()
+				}
+				lastVerified := t.Verified
+				t.heal(ctx, lastLayer)
+
+				// if self healing made progress, short-circuit processing of this layer, but allow verification of
+				// later layers to continue
+				if t.Verified.After(lastVerified) {
+					// rescore goodness of blocks in all intervening layers on the basis of new information
+					// TODO: this is inefficient and we can probably do better
+					//   see https://github.com/spacemeshos/go-spacemesh/issues/2522
+					for layerID := lastVerified.Add(1); !layerID.After(t.Last); layerID = layerID.Add(1) {
+						// TODO LANE: this operation can be very expensive and very slow after a few layers,
+						//   since no caching is currently performed. it needs to be optimized and cached.
+						//   see https://github.com/spacemeshos/go-spacemesh/issues/2672
+						if err := t.scoreBlocksByLayerID(ctx, layerID); err != nil {
+							// if we fail to process a layer, there's probably no point in trying to rescore blocks
+							// in later layers, so just print an error and bail
+							logger.With().Error("error trying to rescore good blocks in healed layers",
+								log.FieldNamed("layer_from", lastVerified),
+								log.FieldNamed("layer_to", t.Last),
+								log.Err(err))
+							break
+						}
 					}
 
-					t.logger.With().Debug("adding block opinion to vote sum",
-						log.FieldNamed("voting_block", bid),
-						log.FieldNamed("voted_block", blk),
-						log.String("vote", opinionVote.String()),
-						log.String("sum", fmt.Sprintf("[%v, %v]", sum[0], sum[1])))
-					sum = sum.Add(opinionVote.Multiply(t.BlockWeight(bid, blk)))
+					continue candidateLayerLoop
+				}
+				// otherwise, if self healing didn't make any progress, there's no point in continuing to attempt
+				// verification
+			}
+
+			// give up trying to verify layers and keep waiting
+			// TODO: continue to verify later layers, even after failing to verify a layer.
+			//   See https://github.com/spacemeshos/go-spacemesh/issues/2403
+			logger.With().Info("failed to verify candidate layer, will reattempt later")
+			return nil
+		}
+
+		// Declare the vote vector "verified" up to this layer and record the contextual validity for all blocks in this
+		// layer
+		for blk, v := range contextualValidity {
+			if err := t.bdp.SaveContextualValidity(blk, candidateLayerID, v); err != nil {
+				logger.With().Error("error saving contextual validity on block", blk, log.Err(err))
+			}
+		}
+		t.Verified = candidateLayerID
+		logger.With().Info("verified candidate layer", log.FieldNamed("new_verified", t.Verified))
+	}
+
+	return nil
+}
+
+// for layers older than this point, we vote according to global opinion (rather than local opinion)
+func (t *turtle) layerCutoff() types.LayerID {
+	// if we haven't seen at least Hdist layers yet, we always rely on local opinion
+	if t.Last.Before(types.NewLayerID(t.Hdist)) {
+		return types.NewLayerID(0)
+	}
+	return t.Last.Sub(t.Hdist)
+}
+
+// return the set of blocks we currently consider valid for the layer. it's based on both local and global opinion,
+// depending how old the layer is, and uses weak coin to break ties.
+func (t *turtle) layerOpinionVector(ctx context.Context, layerID types.LayerID) ([]types.BlockID, error) {
+	logger := t.logger.WithContext(ctx).WithFields(layerID)
+	var voteAbstain, voteAgainstAll []types.BlockID // nil slice, by default
+	voteAgainstAll = make([]types.BlockID, 0, 0)
+
+	// for layers older than hdist, we vote according to global opinion
+	if layerID.Before(t.layerCutoff()) {
+		if layerID.After(t.Verified) {
+			// this layer has not yet been verified
+			// we must have an opinion about older layers at this point. if the layer hasn't been verified yet, count votes
+			// and see if they pass the local threshold. if not, use the current weak coin instead to determine our vote for
+			// the blocks in the layer.
+			// TODO: do we need to/can we somehow cache this?
+			//   see https://github.com/spacemeshos/go-spacemesh/issues/2675
+			layerBlockIds, err := t.bdp.LayerBlockIds(layerID)
+			logger.With().Debug("counting votes for and against blocks in old, unverified layer",
+				log.Int("num_blocks", len(layerBlockIds)))
+			if err != nil {
+				return nil, err
+			}
+			layerBlocks := make(map[types.BlockID]struct{}, len(layerBlockIds))
+			for _, blockID := range layerBlockIds {
+				logger := logger.WithFields(log.FieldNamed("candidate_block_id", blockID))
+				// TODO: this operation can be expensive, it needs to be cached
+				//   see https://github.com/spacemeshos/go-spacemesh/issues/2676
+				sum, err := t.sumVotesForBlock(ctx, blockID, layerID.Add(1), func(id types.BlockID) bool { return true })
+				if err != nil {
+					return nil, fmt.Errorf("error summing votes for block %v in old layer %v: %w",
+						blockID, layerID, err)
 				}
+
+				// TODO: should delta here represent layer depth, or should it always be 1?
+				//   votes are counted for all layers!
+				//   see https://github.com/spacemeshos/go-spacemesh/issues/2677
+				localOpinionOnBlock := calculateOpinionWithThreshold(t.logger, sum, t.AvgLayerSize, t.LocalThreshold, 1)
+				logger.With().Debug("local opinion on block in old layer",
+					sum,
+					log.FieldNamed("local_opinion", localOpinionOnBlock))
+				if localOpinionOnBlock == support {
+					layerBlocks[blockID] = struct{}{}
+				} else if localOpinionOnBlock == abstain {
+					// abstain means the votes for and against this block did not cross the local threshold.
+					// if any block in this layer doesn't cross the local threshold, rescore the entire layer using the
+					// weak coin.
+					// note: we use the weak coin not for the layer of the block being voted on but rather for the
+					// layer in which the voting block is created. this is because the weak coin must be generated late
+					// enough that any adversarial block that depends on the value of the coin will not be accepted by
+					// honest parties.
+					// we use the weak coin for the _previous_ layer since we expect to receive blocks for a layer
+					// before hare finishes for that layer, i.e., before the weak coin value is ready for the layer.
+					// TODO: update this logic per https://github.com/spacemeshos/go-spacemesh/issues/2688
+
+					// TODO: if we rescore old blocks, it's very likely that newly-created blocks will contain
+					//   exceptions for those blocks, and their opinion will differ from their base blocks for blocks
+					//   older than the base blocks, which will cause those blocks not to be marked good. is there
+					//   anything we can do about this? e.g., explicitly pick base blocks that agree with the new
+					//   opinion, or pick older base blocks.
+					//   see https://github.com/spacemeshos/go-spacemesh/issues/2678
+					if coin, exists := t.bdp.GetCoinflip(ctx, t.Last.Sub(1)); exists {
+						logger.With().Info("rescoring all blocks in old layer using weak coin",
+							log.Int("count", len(layerBlockIds)),
+							log.Bool("coinflip", coin),
+							log.FieldNamed("coinflip_layer", t.Last.Sub(1)))
+						if coin {
+							// heads on the weak coin means vote for all blocks in the layer
+							return layerBlockIds, nil
+						}
+						// tails on the weak coin means vote against all blocks in the layer
+						return voteAgainstAll, nil
+					}
+					return nil, fmt.Errorf("%s %v", errstrNoCoinflip, t.Last.Sub(1))
+				} // (nothing to do if local opinion is against, just don't include block in output)
 			}
+			logger.With().Debug("local opinion supports blocks in old, unverified layer",
+				log.Int("count", len(layerBlocks)))
+			return blockMapToArray(layerBlocks), nil
+		}
+		// this layer has been verified, so we should be able to read the set of contextual blocks
+		logger.Debug("using contextually valid blocks as opinion on old, verified layer")
+		layerBlocks, err := t.bdp.LayerContextuallyValidBlocks(layerID)
+		if err != nil {
+			return nil, err
+		}
+		logger.With().Debug("got contextually valid blocks for layer",
+			log.Int("count", len(layerBlocks)))
+		return blockMapToArray(layerBlocks), nil
+	}
+
+	// for newer layers, we vote according to the local opinion (input vector, from hare or sync)
+	opinionVec, err := t.bdp.GetLayerInputVectorByID(layerID)
+	if err != nil {
+		if errors.Is(err, mesh.ErrInvalidLayer) {
+			// Hare already failed for this layer, so we want to vote against all blocks in the layer. Just return an
+			// empty list.
+			logger.Debug("local opinion is against all blocks in layer where hare failed")
+			return voteAgainstAll, nil
+		} else if t.Last.After(types.NewLayerID(t.Zdist)) && layerID.Before(t.Last.Sub(t.Zdist)) {
+			// Layer has passed the Hare abort distance threshold, so we give up waiting for Hare results. At this point
+			// our opinion on this layer is that we vote against blocks (i.e., we support an empty layer).
+			logger.With().Debug("local opinion on layer beyond hare abort window is against all blocks",
+				log.Err(err))
+			return voteAgainstAll, nil
+		} else {
+			// Hare hasn't failed and layer has not passed the Hare abort threshold, so we abstain while we keep waiting
+			// for Hare results.
+			logger.With().Warning("local opinion abstains on all blocks in layer", log.Err(err))
+			return voteAbstain, nil
+		}
+	}
+	logger.With().Debug("got input vector for layer", log.Int("count", len(opinionVec)))
+	return opinionVec, nil
+}
 
-			// check that the total weight exceeds the confidence threshold in all positions up
-			globalOpinion := calculateGlobalOpinion(t.logger, sum, t.AvgLayerSize, float64(i.Difference(pbaseOld)))
-			t.logger.With().Debug("calculated global opinion on block",
-				log.FieldNamed("voted_block", blk),
-				i,
-				log.String("global_opinion", globalOpinion.String()),
-				log.String("sum", fmt.Sprintf("[%v, %v]", sum[0], sum[1])))
-
-			// If, for any block in this layer, the global opinion (summed votes) disagrees with our vote (what the
-			// input vector says), or if the global opinion is abstain, then we do not verify this layer. Otherwise,
-			// we do.
-
-			if globalOpinion != vote {
-				// TODO: trigger self healing after a while?
-				t.logger.With().Warning("global opinion on block differs from our vote, cannot verify layer",
-					blk,
-					log.String("global_opinion", globalOpinion.String()),
-					log.String("vote", vote.String()))
-				break layerLoop
+func (t *turtle) sumVotesForBlock(
+	ctx context.Context,
+	blockID types.BlockID, // the block we're summing votes for/against
+	startLayer types.LayerID,
+	filter func(types.BlockID) bool,
+) (sum vec, err error) {
+	sum = abstain
+	logger := t.logger.WithContext(ctx).WithFields(
+		log.FieldNamed("start_layer", startLayer),
+		log.FieldNamed("end_layer", t.Last),
+		log.FieldNamed("block_voting_on", blockID),
+		log.FieldNamed("layer_voting_on", startLayer.Sub(1)))
+	for voteLayer := startLayer; !voteLayer.After(t.Last); voteLayer = voteLayer.Add(1) {
+		logger := logger.WithFields(voteLayer)
+		logger.With().Debug("summing layer votes",
+			log.Int("count", len(t.BlockOpinionsByLayer[voteLayer])))
+		for votingBlockID, votingBlockOpinion := range t.BlockOpinionsByLayer[voteLayer] {
+			logger := logger.WithFields(log.FieldNamed("voting_block", votingBlockID))
+			if !filter(votingBlockID) {
+				logger.Debug("voting block did not pass filter, not counting its vote")
+				continue
 			}
 
-			// An abstain vote on a single block in this layer means that we should abstain from voting on the entire
-			// layer. This usually means everyone is still waiting for Hare to finish, so we cannot verify this layer.
-			// This condition should be temporary, except during a balancing attack. The verifying tortoise is not
-			// equipped to handle this scenario, but the full tortoise is.
-			// TODO: should we trigger self-healing in this scenario, after a while?
-			// TODO: should we give up trying to verify later layers, too?
-			if globalOpinion == abstain {
-				t.logger.With().Warning("global opinion on block is abstain, cannot verify layer",
-					blk,
-					log.String("global_opinion", globalOpinion.String()),
-					log.String("vote", vote.String()))
-				break layerLoop
+			// check if this block has an opinion on the block to vote on.
+			// no opinion (on a block in an older layer) counts as an explicit vote against the block.
+			// note: in this case, the weight is already factored into the vote, so no need to fetch weight.
+			if opinionVote, exists := votingBlockOpinion.BlockOpinions[blockID]; exists {
+				sum = sum.Add(opinionVote)
+				logger.With().Debug("added block opinion to vote sum",
+					log.FieldNamed("vote", opinionVote),
+					sum)
+			} else {
+				// in this case, we still need to fetch the block's voting weight.
+				weight, err := t.voteWeightByID(ctx, votingBlockID, blockID)
+				if err != nil {
+					return sum, fmt.Errorf("error getting vote weight for block %v: %w",
+						votingBlockID, err)
+				}
+				sum = sum.Add(against.Multiply(weight))
+				logger.With().Debug("no opinion on older block, counted vote against",
+					log.Uint64("weight", weight),
+					sum)
 			}
+		}
+	}
+	return
+}
 
-			contextualValidity[blk] = globalOpinion == support
+// Manually count all votes for all layers since the last verified layer, up to the newly-arrived layer (there's no
+// point in going further since we have no new information about any newer layers). Self-healing does not take into
+// consideration local opinion, it relies solely on global opinion.
+func (t *turtle) heal(ctx context.Context, targetLayerID types.LayerID) {
+	// These are our starting values
+	pbaseOld := t.Verified
+	pbaseNew := t.Verified
+
+	for candidateLayerID := pbaseOld.Add(1); candidateLayerID.Before(targetLayerID); candidateLayerID = candidateLayerID.Add(1) {
+		logger := t.logger.WithContext(ctx).WithFields(
+			log.FieldNamed("old_verified_layer", pbaseOld),
+			log.FieldNamed("last_verified_layer", pbaseNew),
+			log.FieldNamed("target_layer", targetLayerID),
+			log.FieldNamed("candidate_layer", candidateLayerID),
+			log.FieldNamed("last_layer_received", t.Last),
+			log.Uint32("hdist", t.Hdist))
+
+		// we should never run on layers newer than Hdist back (from last layer received)
+		// when bootstrapping, don't attempt any verification at all
+		var latestLayerWeCanVerify types.LayerID
+		if t.Last.Before(types.NewLayerID(t.Hdist)) {
+			latestLayerWeCanVerify = mesh.GenesisLayer().Index()
+		} else {
+			latestLayerWeCanVerify = t.Last.Sub(t.Hdist)
+		}
+		if candidateLayerID.After(latestLayerWeCanVerify) {
+			logger.With().Error("cannot heal layer that's not at least hdist layers old",
+				log.FieldNamed("highest_healable_layer", latestLayerWeCanVerify))
+			return
 		}
 
-		// Declare the vote vector “verified” up to position k (up to this layer)
-		// and record the contextual validity for all blocks in this layer
-		for blk, v := range contextualValidity {
-			if err := t.bdp.SaveContextualValidity(blk, v); err != nil {
-				// panic?
-				t.logger.With().Error("error saving contextual validity on block", blk.Field(), log.Err(err))
+		// Calculate the global opinion on all blocks in the layer
+		// Note: we look at ALL blocks we've seen for the layer, not just those we've previously marked contextually valid
+		logger.Info("self healing attempting to verify candidate layer")
+
+		layerBlockIds, err := t.bdp.LayerBlockIds(candidateLayerID)
+		if err != nil {
+			logger.Error("inconsistent state: can't find layer in database, cannot heal")
+
+			// there's no point in trying to verify later layers so just give up now
+			return
+		}
+
+		// record the contextual validity for all blocks in this layer
+		for _, blockID := range layerBlockIds {
+			logger := logger.WithFields(log.FieldNamed("candidate_block_id", blockID))
+
+			// count all votes for or against this block by all blocks in later layers: don't filter out any
+			sum, err := t.sumVotesForBlock(ctx, blockID, candidateLayerID.Add(1), func(id types.BlockID) bool { return true })
+			if err != nil {
+				logger.Error("error summing votes for candidate block in candidate layer", log.Err(err))
+				return
+			}
+
+			// check that the total weight exceeds the global threshold
+			globalOpinionOnBlock := calculateOpinionWithThreshold(t.logger, sum, t.AvgLayerSize, t.GlobalThreshold, float64(t.Last.Difference(candidateLayerID)))
+			logger.With().Debug("self healing calculated global opinion on candidate block",
+				log.FieldNamed("global_opinion", globalOpinionOnBlock),
+				sum)
+
+			if globalOpinionOnBlock == abstain {
+				logger.With().Info("self healing failed to verify candidate layer, will reattempt later")
+				return
+			}
+
+			isValid := globalOpinionOnBlock == support
+			if err := t.bdp.SaveContextualValidity(blockID, candidateLayerID, isValid); err != nil {
+				logger.With().Error("error saving block contextual validity", blockID, log.Err(err))
 			}
 		}
-		t.Verified = i
-		pbaseNew = i
-		t.logger.With().Info("verified layer", i)
+
+		t.Verified = candidateLayerID
+		pbaseNew = candidateLayerID
+		logger.Info("self healing verified candidate layer")
 	}
 
 	return
diff --git a/tortoise/verifying_tortoise_test.go b/tortoise/verifying_tortoise_test.go
index e1ab810f96a..f0133098394 100644
--- a/tortoise/verifying_tortoise_test.go
+++ b/tortoise/verifying_tortoise_test.go
@@ -3,17 +3,20 @@ package tortoise
 import (
 	"context"
 	"errors"
-	"fmt"
-	"os"
+	"github.com/spacemeshos/go-spacemesh/log"
+	"github.com/spacemeshos/go-spacemesh/rand"
+	"github.com/spacemeshos/go-spacemesh/timesync"
+	"math"
 	"strconv"
 	"testing"
+	"time"
 
 	"github.com/spacemeshos/go-spacemesh/common/types"
 	"github.com/spacemeshos/go-spacemesh/config"
+	"github.com/spacemeshos/go-spacemesh/database"
 	"github.com/spacemeshos/go-spacemesh/log/logtest"
 	"github.com/spacemeshos/go-spacemesh/mesh"
 	"github.com/spacemeshos/go-spacemesh/signing"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -21,25 +24,90 @@ func init() {
 	types.SetLayersPerEpoch(4)
 }
 
-const Path = "../tmp/tortoise/"
+type blockDataWriter interface {
+	blockDataProvider
+	AddBlock(*types.Block) error
+	SaveLayerInputVectorByID(context.Context, types.LayerID, []types.BlockID) error
+	SetInputVectorBackupFunc(mesh.InputVectorBackupFunc)
+	GetInputVectorBackupFunc() mesh.InputVectorBackupFunc
+}
+
+type meshWrapper struct {
+	blockDataWriter
+	inputVectorBackupFn      func(types.LayerID) ([]types.BlockID, error)
+	saveContextualValidityFn func(types.BlockID, types.LayerID, bool) error
+}
+
+func (mw meshWrapper) SaveContextualValidity(bid types.BlockID, lid types.LayerID, valid bool) error {
+	if mw.saveContextualValidityFn != nil {
+		return mw.saveContextualValidityFn(bid, lid, valid)
+	}
+	return mw.blockDataWriter.SaveContextualValidity(bid, lid, valid)
+}
 
-func getPersistentMash(tb testing.TB) (*mesh.DB, func() error) {
-	path := Path + "ninje_tortoise"
-	teardown := func() error { return os.RemoveAll(path) }
-	if err := teardown(); err != nil {
-		panic(err)
+func (mw meshWrapper) GetLayerInputVectorByID(lid types.LayerID) ([]types.BlockID, error) {
+	if mw.inputVectorBackupFn != nil {
+		return mw.inputVectorBackupFn(lid)
 	}
-	db, _ := mesh.NewPersistentMeshDB(fmt.Sprintf(path+
-		"/"), 10, logtest.New(tb).WithName("ninje_tortoise"))
-	return db, teardown
+	return mw.blockDataWriter.GetLayerInputVectorByID(lid)
+}
+
+func (mw meshWrapper) GetCoinflip(context.Context, types.LayerID) (bool, bool) {
+	return true, true
+}
+
+type atxDataWriter interface {
+	atxDataProvider
+	StoreAtx(types.EpochID, *types.ActivationTx) error
+}
+
+func getAtxDB() *mockAtxDataProvider {
+	return &mockAtxDataProvider{atxDB: make(map[types.ATXID]*types.ActivationTxHeader)}
+}
+
+type mockAtxDataProvider struct {
+	mockAtxHeader *types.ActivationTxHeader
+	atxDB         map[types.ATXID]*types.ActivationTxHeader
+	firstTime     time.Time
+}
+
+func (madp *mockAtxDataProvider) GetAtxHeader(atxID types.ATXID) (*types.ActivationTxHeader, error) {
+	if madp.mockAtxHeader != nil {
+		return madp.mockAtxHeader, nil
+	}
+	if atxHeader, ok := madp.atxDB[atxID]; ok {
+		return atxHeader, nil
+	}
+
+	// return a mocked value
+	return &types.ActivationTxHeader{NIPostChallenge: types.NIPostChallenge{NodeID: types.NodeID{Key: "fakekey"}}}, nil
+}
+
+func (madp mockAtxDataProvider) GetAtxTimestamp(types.ATXID) (time.Time, error) {
+	return madp.firstTime, nil
+}
+
+func (madp *mockAtxDataProvider) StoreAtx(_ types.EpochID, atx *types.ActivationTx) error {
+	// store only the header
+	madp.atxDB[atx.ID()] = atx.ActivationTxHeader
+	if madp.firstTime.IsZero() {
+		madp.firstTime = time.Now()
+	}
+	return nil
+}
+
+func getPersistentMesh(tb testing.TB) *mesh.DB {
+	db, err := mesh.NewPersistentMeshDB(tb.TempDir(), 10, log.NewNop())
+	require.NoError(tb, err)
+	return db
 }
 
 func getInMemMesh(tb testing.TB) *mesh.DB {
 	return mesh.NewMemMeshDB(logtest.New(tb))
 }
 
-func AddLayer(m *mesh.DB, layer *types.Layer) error {
-	//add blocks to mDB
+func addLayerToMesh(m *mesh.DB, layer *types.Layer) error {
+	// add blocks to mDB
 	for _, bl := range layer.Blocks() {
 		if err := m.AddBlock(bl); err != nil {
 			return err
@@ -48,9 +116,30 @@ func AddLayer(m *mesh.DB, layer *types.Layer) error {
 	return nil
 }
 
-var defaultTestHdist = config.DefaultConfig().Hdist
+func randomBlockID() types.BlockID {
+	rand.Seed(time.Now().UnixNano())
+	b := make([]byte, 8)
+	_, err := rand.Read(b)
+	// Note that err == nil only if we read len(b) bytes.
+	if err != nil {
+		return types.BlockID{}
+	}
+	return types.BlockID(types.CalcHash32(b).ToHash20())
+}
+
+var (
+	defaultTestLayerSize       = 3
+	defaultTestHdist           = config.DefaultConfig().Hdist
+	defaultTestZdist           = config.DefaultConfig().Zdist
+	defaultTestWindowSize      = uint32(30)
+	defaultTestGlobalThreshold = uint8(60)
+	defaultTestLocalThreshold  = uint8(20)
+	defaultTestRerunInterval   = time.Hour
+	defaultTestConfidenceParam = config.DefaultConfig().ConfidenceParam
+)
 
 func requireVote(t *testing.T, trtl *turtle, vote vec, blocks ...types.BlockID) {
+	logger := logtest.New(t)
 	for _, i := range blocks {
 		sum := abstain
 		blk, _ := trtl.bdp.GetBlock(i)
@@ -64,38 +153,76 @@ func requireVote(t *testing.T, trtl *turtle, vote vec, blocks ...types.BlockID)
 		}
 
 		for l := trtl.Last; l.After(blk.LayerIndex); l = l.Sub(1) {
-
-			trtl.logger.Info("Counting votes of blocks in layer %v on %v (lyr: %v)", l, i.String(), blk.LayerIndex)
+			logger.Info("counting votes of blocks in layer %v on %v (lyr: %v)",
+				l,
+				i.String(),
+				blk.LayerIndex)
 
 			for bid, opinionVote := range trtl.BlockOpinionsByLayer[l] {
-				opinionVote, ok := opinionVote.BlocksOpinion[i]
+				opinionVote, ok := opinionVote.BlockOpinions[i]
 				if !ok {
 					continue
 				}
 
-				//t.logger.Info("block %v is good and voting vote %v", vopinion.id, opinionVote)
-				sum = sum.Add(opinionVote.Multiply(trtl.BlockWeight(bid, i)))
+				weight, err := trtl.voteWeightByID(context.TODO(), bid, i)
+				require.NoError(t, err)
+				sum = sum.Add(opinionVote.Multiply(weight))
 			}
 		}
-		gop := calculateGlobalOpinion(trtl.logger, sum, trtl.AvgLayerSize, 1)
-		if gop != vote {
-			require.Fail(t, fmt.Sprintf("crashing test block %v should be %v but %v", i, vote, sum))
-		}
+		globalOpinion := calculateOpinionWithThreshold(trtl.logger, sum, trtl.AvgLayerSize, trtl.GlobalThreshold, 1)
+		require.Equal(t, vote, globalOpinion, "test block %v expected vote %v but got %v", i, vote, sum)
 	}
 }
 
-func TestTurtle_HandleIncomingLayerHappyFlow(t *testing.T) {
-	layers := types.GetEffectiveGenesis().Add(28)
-	avgPerLayer := 10
-	voteNegative := 0
-	trtl, _, _ := turtleSanity(t, layers, avgPerLayer, voteNegative, 0)
-	require.Equal(t, layers.Sub(1), trtl.Verified)
-	blkids := make([]types.BlockID, 0, avgPerLayer*int(layers.Uint32()))
-	for l := types.NewLayerID(0); l.Before(layers); l = l.Add(1) {
-		lids, _ := trtl.bdp.LayerBlockIds(l)
-		blkids = append(blkids, lids...)
-	}
-	requireVote(t, trtl, support, blkids...)
+func TestHandleIncomingLayer(t *testing.T) {
+	t.Run("HappyFlow", func(t *testing.T) {
+		topLayer := types.GetEffectiveGenesis().Add(28)
+		avgPerLayer := 10
+		// no negative votes, no abstain votes
+		trtl, _, _ := turtleSanity(t, topLayer, avgPerLayer, 0, 0)
+		require.Equal(t, int(topLayer.Sub(1).Uint32()), int(trtl.Verified.Uint32()))
+		blkids := make([]types.BlockID, 0, avgPerLayer*int(topLayer.Uint32()))
+		for l := types.NewLayerID(0); l.Before(topLayer); l = l.Add(1) {
+			lids, _ := trtl.bdp.LayerBlockIds(l)
+			blkids = append(blkids, lids...)
+		}
+		requireVote(t, trtl, support, blkids...)
+	})
+
+	t.Run("VoteNegative", func(t *testing.T) {
+		lyrsAfterGenesis := types.NewLayerID(10)
+		layers := types.GetEffectiveGenesis().Add(lyrsAfterGenesis.Uint32())
+		avgPerLayer := 10
+		voteNegative := 2
+		// just a couple of negative votes
+		trtl, negs, abs := turtleSanity(t, layers, avgPerLayer, voteNegative, 0)
+		require.Equal(t, int(layers.Sub(1).Uint32()), int(trtl.Verified.Uint32()))
+		poblkids := make([]types.BlockID, 0, avgPerLayer*int(layers.Uint32()))
+		for l := types.NewLayerID(0); l.Before(layers); l = l.Add(1) {
+			lids, _ := trtl.bdp.LayerBlockIds(l)
+			for _, lid := range lids {
+				if !inArr(lid, negs) {
+					poblkids = append(poblkids, lid)
+				}
+			}
+		}
+		require.Len(t, abs, 0)
+		require.Equal(t, len(negs), int(lyrsAfterGenesis.Sub(1).Uint32())*voteNegative) // don't count last layer because no one is voting on it
+
+		// this test is called VoteNegative, but in fact we just abstain on blocks that we disagree with, unless
+		// the base block explicitly supports them.
+		// TODO: add a test for this, pending https://github.com/spacemeshos/go-spacemesh/issues/2424
+		requireVote(t, trtl, abstain, negs...)
+		requireVote(t, trtl, support, poblkids...)
+	})
+
+	t.Run("VoteAbstain", func(t *testing.T) {
+		layers := types.NewLayerID(10)
+		avgPerLayer := 10
+		trtl, _, abs := turtleSanity(t, layers, avgPerLayer, 0, 10)
+		require.Equal(t, int(types.GetEffectiveGenesis().Uint32()), int(trtl.Verified.Uint32()), "when all votes abstain verification should stay at first layer")
+		requireVote(t, trtl, abstain, abs...)
+	})
 }
 
 func inArr(id types.BlockID, list []types.BlockID) bool {
@@ -107,44 +234,14 @@ func inArr(id types.BlockID, list []types.BlockID) bool {
 	return false
 }
 
-func TestTurtle_HandleIncomingLayer_VoteNegative(t *testing.T) {
-	lyrsAfterGenesis := uint32(10)
-	layers := types.GetEffectiveGenesis().Add(lyrsAfterGenesis)
-	avgPerLayer := 10
-	voteNegative := 2
-	trtl, negs, abs := turtleSanity(t, layers, avgPerLayer, voteNegative, 0)
-	require.Equal(t, layers.Sub(1), trtl.Verified)
-	poblkids := make([]types.BlockID, 0, avgPerLayer*int(layers.Uint32()))
-	for l := types.NewLayerID(0); l.Before(layers); l = l.Add(1) {
-		lids, _ := trtl.bdp.LayerBlockIds(l)
-		for _, lid := range lids {
-			if !inArr(lid, negs) {
-				poblkids = append(poblkids, lid)
-			}
-		}
-	}
-	require.Len(t, abs, 0)
-	require.Equal(t, len(negs), int(lyrsAfterGenesis-1)*voteNegative) // don't count last layer because no one is voting on it
-	requireVote(t, trtl, against, negs...)
-	requireVote(t, trtl, support, poblkids...)
-}
-
-func TestTurtle_HandleIncomingLayer_VoteAbstain(t *testing.T) {
-	layers := types.NewLayerID(10)
-	avgPerLayer := 10
-	trtl, _, abs := turtleSanity(t, layers, avgPerLayer, 0, 10)
-	require.Equal(t, types.GetEffectiveGenesis(), trtl.Verified, "when all votes abstain verification should stay at first layer and advance")
-	requireVote(t, trtl, abstain, abs...)
-}
-
-// voteNegative - the amoutn of blocks to vote negative per layer
-// voteAbstain - the amoutn of layers to vote abstain because we always abstain on a whole layer
-func turtleSanity(t *testing.T, layers types.LayerID, blocksPerLayer, voteNegative int, voteAbstain int) (trtl *turtle, negative []types.BlockID, abstains []types.BlockID) {
+// voteNegative - the number of blocks to vote negative per layer
+// voteAbstain - the number of layers to vote abstain because we always abstain on a whole layer
+func turtleSanity(t *testing.T, numLayers types.LayerID, blocksPerLayer, voteNegative, voteAbstain int) (trtl *turtle, negative, abstain []types.BlockID) {
 	msh := getInMemMesh(t)
 	logger := logtest.New(t)
 	newlyrs := make(map[types.LayerID]struct{})
 
-	hm := func(l types.LayerID) (ids []types.BlockID, err error) {
+	inputVectorFn := func(l types.LayerID) (ids []types.BlockID, err error) {
 		if l.Before(mesh.GenesisLayer().Index()) {
 			panic("shouldn't happen")
 		}
@@ -154,7 +251,7 @@ func turtleSanity(t *testing.T, layers types.LayerID, blocksPerLayer, voteNegati
 
 		_, exist := newlyrs[l]
 
-		if !exist && l != layers {
+		if !exist && l != numLayers {
 			newlyrs[l] = struct{}{}
 		}
 
@@ -165,9 +262,9 @@ func turtleSanity(t *testing.T, layers types.LayerID, blocksPerLayer, voteNegati
 		}
 
 		if voteAbstain > 0 {
-			if !exist && l != layers {
+			if !exist && l != numLayers {
 				voteAbstain--
-				abstains = append(abstains, blks...)
+				abstain = append(abstain, blks...)
 			}
 			return nil, errors.New("hare didn't finish")
 		}
@@ -176,32 +273,35 @@ func turtleSanity(t *testing.T, layers types.LayerID, blocksPerLayer, voteNegati
 			return blks, nil
 		}
 
-		//if voteNegative >= len(blks) {
-		//	if !exist {
-		//		negative = append(negative, blks...)
-		//	}
-		//	return []types.BlockID{}, nil
-		//}
 		sorted := types.SortBlockIDs(blks)
 
-		if !exist && l != layers {
+		if !exist && l != numLayers {
 			negative = append(negative, sorted[:voteNegative]...)
 		}
 		return sorted[voteNegative:], nil
 	}
 
-	trtl = newTurtle(msh, defaultTestHdist, blocksPerLayer)
-	gen := mesh.GenesisLayer()
-	trtl.init(gen)
+	trtl = defaultTurtle(t)
+	trtl.AvgLayerSize = blocksPerLayer
+	trtl.bdp = msh
+	trtl.init(context.TODO(), mesh.GenesisLayer())
 
 	var l types.LayerID
-	for l = mesh.GenesisLayer().Index().Add(1); !l.After(layers); l = l.Add(1) {
-		turtleMakeAndProcessLayer(t, l, trtl, blocksPerLayer, msh, hm)
+	atxdb := getAtxDB()
+	trtl.atxdb = atxdb
+	for l = mesh.GenesisLayer().Index().Add(1); !l.After(numLayers); l = l.Add(1) {
+		makeAndProcessLayer(t, l, trtl, blocksPerLayer, atxdb, msh, inputVectorFn)
+		logger.Debug("======================== handled layer", l)
 		lastlyr := trtl.BlockOpinionsByLayer[l]
 		for _, v := range lastlyr {
-			logger.Debug("block opinion map size", len(v.BlocksOpinion))
-			if (len(v.BlocksOpinion)) > int(blocksPerLayer*int(trtl.Hdist)) {
-				t.Errorf("layer opinion table exceeded max size, LEAK! size:%v, maxsize:%v", len(v.BlocksOpinion), int(blocksPerLayer*int(trtl.Hdist)))
+			logger.Debug("block opinion map size", len(v.BlockOpinions))
+			// the max. number of layers we store opinions for is the window size (since last evicted) + 3.
+			// eviction happens _after_ blocks for a new layer N have been processed, and that layer hasn't yet
+			// been verified. at this point in time,
+			// tortoise window := N - 1 (last verified) - windowSize - 1 (first layer to evict) - 1 (layer not yet evicted)
+			if (len(v.BlockOpinions)) > blocksPerLayer*int(trtl.WindowSize+3) {
+				t.Errorf("layer opinion table exceeded max size, LEAK! size: %v, maxsize: %v",
+					len(v.BlockOpinions), blocksPerLayer*int(trtl.WindowSize+3))
 			}
 			break
 		}
@@ -210,61 +310,275 @@ func turtleSanity(t *testing.T, layers types.LayerID, blocksPerLayer, voteNegati
 	return
 }
 
-func turtleMakeAndProcessLayer(t *testing.T, l types.LayerID, trtl *turtle, blocksPerLayer int, msh *mesh.DB, hm func(id types.LayerID) ([]types.BlockID, error)) {
+func makeAndProcessLayer(t *testing.T, l types.LayerID, trtl *turtle, blocksPerLayer int, atxdb atxDataWriter, msh blockDataWriter, inputVectorFn func(id types.LayerID) ([]types.BlockID, error)) {
+	lyr := makeLayer(t, l, trtl, blocksPerLayer, atxdb, msh, inputVectorFn)
 	logger := logtest.New(t)
-	logger.Debug("choosing base block layer ", l)
-	msh.InputVectorBackupFunc = hm
-	b, lists, err := trtl.BaseBlock(context.TODO())
-	logger.Debug("the base block for ", l, "is ", b)
-	if err != nil {
-		panic(fmt.Sprint("no base - ", err))
+
+	// write blocks to database first; the verifying tortoise will subsequently read them
+	if inputVectorFn == nil {
+		// just save the layer contents as the input layer vector (the default behavior)
+		require.NoError(t, msh.SaveLayerInputVectorByID(context.TODO(), lyr.Index(), lyr.BlocksIDs()))
+	} else if blocks, err := inputVectorFn(l); err != nil {
+		logger.With().Warning("error from input vector fn", log.Err(err))
+	} else {
+		// save blocks to db for this layer
+		require.NoError(t, msh.SaveLayerInputVectorByID(context.TODO(), l, blocks))
 	}
-	lyr := types.NewLayer(l)
+
+	require.NoError(t, trtl.HandleIncomingLayer(context.TODO(), l))
+}
+
+var (
+	atxHeader = makeAtxHeaderWithWeight(1)
+	atx       = &types.ActivationTx{InnerActivationTx: &types.InnerActivationTx{ActivationTxHeader: atxHeader}}
+)
+
+func makeLayer(t *testing.T, layerID types.LayerID, trtl *turtle, blocksPerLayer int, atxdb atxDataWriter, msh blockDataWriter, inputVectorFn func(id types.LayerID) ([]types.BlockID, error)) *types.Layer {
+	logger := logtest.New(t)
+	logger.Debug("======================== choosing base block for layer", layerID)
+	if inputVectorFn != nil {
+		oldInputVectorFn := msh.GetInputVectorBackupFunc()
+		defer func() {
+			msh.SetInputVectorBackupFunc(oldInputVectorFn)
+		}()
+		msh.SetInputVectorBackupFunc(inputVectorFn)
+	}
+	baseBlockID, lists, err := trtl.BaseBlock(context.TODO())
+	require.NoError(t, err)
+	logger.Debug("base block for layer", layerID, "is", baseBlockID)
+	logger.Debug("exception lists for layer", layerID, "(against, support, neutral):", lists)
+	lyr := types.NewLayer(layerID)
+
+	// for now just create a single ATX for all of the blocks with a weight of one
+	atx.CalcAndSetID()
+	require.NoError(t, atxdb.StoreAtx(layerID.GetEpoch(), atx))
 
 	for i := 0; i < blocksPerLayer; i++ {
 		blk := &types.Block{
 			MiniBlock: types.MiniBlock{
 				BlockHeader: types.BlockHeader{
-					LayerIndex: l,
+					ATXID:      atxHeader.ID(),
+					LayerIndex: layerID,
 					Data:       []byte(strconv.Itoa(i))},
 				TxIDs: nil,
 			}}
-		blk.BaseBlock = b
+		blk.BaseBlock = baseBlockID
 		blk.AgainstDiff = lists[0]
 		blk.ForDiff = lists[1]
 		blk.NeutralDiff = lists[2]
-		blk.Signature = signing.NewEdSigner().Sign(b.Bytes())
+		blk.Signature = signing.NewEdSigner().Sign(baseBlockID.Bytes())
 		blk.Initialize()
 		lyr.AddBlock(blk)
-		err = msh.AddBlock(blk)
-		if err != nil {
-			t.Log("Err inserting to db - ", err)
-		}
+		require.NoError(t, msh.AddBlock(blk))
+		logger.Debug("generated block", blk.ID(), "in layer", layerID)
 	}
 
-	// write blocks to database first; the verifying tortoise will subsequently read them
-	blocks, err := hm(l)
-	if err == nil {
-		// save blocks to db for this layer
-		require.NoError(t, msh.SaveLayerInputVectorByID(context.TODO(), l, blocks))
+	return lyr
+}
+
+func testLayerPattern(t *testing.T, atxdb atxDataWriter, db blockDataWriter, trtl *turtle, blocksPerLayer int, successPattern []bool) {
+	logger := logtest.New(t)
+	badLayerFn := func(layerID types.LayerID) ([]types.BlockID, error) {
+		logger.Debug("giving bad results for layer", layerID)
+		return nil, errors.New("simulated hare failure")
+	}
+	for i, success := range successPattern {
+		thisLayerID := types.GetEffectiveGenesis().Add(uint32(i) + 1)
+		logger.Debug("======================== processing layer", thisLayerID)
+		if success {
+			makeAndProcessLayer(t, thisLayerID, trtl, blocksPerLayer, atxdb, db, nil)
+		} else {
+			makeAndProcessLayer(t, thisLayerID, trtl, blocksPerLayer, atxdb, db, badLayerFn)
+		}
 	}
+}
+
+func TestLayerPatterns(t *testing.T) {
+	blocksPerLayer := 10 // more blocks means a longer test
+	t.Run("many good layers", func(t *testing.T) {
+		msh := getInMemMesh(t)
+		atxdb := getAtxDB()
+		trtl := defaultTurtle(t)
+		trtl.AvgLayerSize = blocksPerLayer
+		trtl.bdp = msh
+		trtl.atxdb = atxdb
+		trtl.init(context.TODO(), mesh.GenesisLayer())
+		numGood := 5
+		pattern := make([]bool, numGood)
+		for i := 0; i < numGood; i++ {
+			pattern[i] = true
+		}
+		testLayerPattern(t, atxdb, msh, trtl, blocksPerLayer, pattern)
+		require.Equal(t, int(types.GetEffectiveGenesis().Add(uint32(numGood-1)).Uint32()), int(trtl.Verified.Uint32()))
+	})
+
+	t.Run("heal after bad layers", func(t *testing.T) {
+		// use a mesh wrapper to simulate weakcoin, needed for healing
+		msh := &meshWrapper{blockDataWriter: getInMemMesh(t)}
+		atxdb := getAtxDB()
+		trtl := defaultTurtle(t)
+		trtl.AvgLayerSize = blocksPerLayer
+		trtl.bdp = msh
+		trtl.atxdb = atxdb
+		trtl.init(context.TODO(), mesh.GenesisLayer())
+
+		// calculate the number of layers needed to accumulate enough votes to cross the global threshold and
+		// invalidate earlier bad blocks
+		// run a quick simulation to check how many layers it will take to accumulate enough votes against the
+		// bad blocks
+		vote := abstain
+		numLayersToFullyHeal := 0
+		for i := 0; vote == abstain; i++ {
+			// fast-forward to the point where Zdist is past, we've stopped waiting for hare results for the bad
+			// layers and started voting against them, and we've accumulated votes for ConfidenceParam layers
+			netVote := vec{0, uint64(i * blocksPerLayer)}
+			// Zdist + ConfidenceParam (+ a margin of one due to the math) layers have already passed, so that's our
+			// delta
+			vote = calculateOpinionWithThreshold(trtl.logger, netVote, blocksPerLayer, trtl.GlobalThreshold, float64(uint32(i+1)+trtl.Zdist+trtl.ConfidenceParam))
+			// safety cutoff
+			if i > 100 {
+				panic("failed to accumulate enough votes")
+			}
+			numLayersToFullyHeal++
+		}
+		t.Log("layers to fully heal:", numLayersToFullyHeal)
+
+		// five good layers, then two bad, then enough good to heal
+		// after healing, verifying tortoise should be able to start verifying again
+		pattern := []bool{
+			true,  // 8  verified
+			true,  // 9  verified
+			true,  // 10 verified
+			true,  // 11 verified
+			true,  // 12 verification stalled: zdist
+			false, // 13 verification stalled: zdist, simulated hare failure
+			false, // 14 verification stalled: zdist, simulated hare failure
+			true,  // 15 verification stalled: zdist
+			true,  // 16 verification stalled: zdist
+			true,  // 17 verification stalled: confidence interval
+			true,  // 18 verification stalled: confidence interval
+			true,  // 19 verification stalled: confidence interval
+			true,  // 20 verification stalled: confidence interval
+			true,  // 21 verification stalled: confidence interval
+			true,  // 22 verification resumes zdist+confidence interval layers before
+			true,  // 23 verification resumes zdist+confidence interval layers before
+		}
+		testLayerPattern(t, atxdb, msh, trtl, blocksPerLayer, pattern)
+		lastProcessed := types.GetEffectiveGenesis().Add(uint32(len(pattern)))
+
+		// at this point, verified layer should still be stuck before the bad layers
+		lastVerified := types.GetEffectiveGenesis().Add(5)
+		require.Equal(t, int(lastVerified.Uint32()), int(trtl.Verified.Uint32()))
+
+		// now, we need a few layers to accumulate enough votes to heal
+		for i := 1; i < numLayersToFullyHeal; i++ {
+			lastProcessed = lastProcessed.Add(uint32(1))
+			makeAndProcessLayer(t, lastProcessed, trtl, blocksPerLayer, atxdb, msh, nil)
+		}
+
+		// still no progress
+		require.Equal(t, int(lastVerified.Uint32()), int(trtl.Verified.Uint32()))
+
+		// after one more layer, self healing should have verified a single layer
+		lastProcessed = lastProcessed.Add(1)
+		makeAndProcessLayer(t, lastProcessed, trtl, blocksPerLayer, atxdb, msh, nil)
+		lastVerified = lastVerified.Add(1)
+		require.Equal(t, int(lastVerified.Uint32()), int(trtl.Verified.Uint32()))
+
+		// verified layer should now lag by zdist+confidence interval+layers to heal
+		require.Equal(t, lastVerified, types.GetEffectiveGenesis().Add(uint32(len(pattern))-trtl.Zdist-trtl.ConfidenceParam))
+
+		// after a few more good layers, verifying tortoise should catch up and start verifying again
+		// TODO: calculate this hardcoded number using the same simulation we used to do so above
+		lastVerified = lastVerified.Add(trtl.Zdist + trtl.ConfidenceParam + uint32(numLayersToFullyHeal-1))
+		for i := 1; i < 8; i++ {
+			lastProcessed = lastProcessed.Add(1)
+			makeAndProcessLayer(t, lastProcessed, trtl, blocksPerLayer, atxdb, msh, nil)
+			lastVerified = lastVerified.Add(1)
+		}
+		require.Equal(t, int(lastVerified.Uint32()), int(trtl.Verified.Uint32()))
+		require.Equal(t, int(lastVerified.Uint32()), int(lastProcessed.Uint32()-1))
+
+		// make sure verifying tortoise is working again, without healing
+		// (healing wouldn't kick in again until zdist+confidence interval have passed)
+		lastProcessed = lastProcessed.Add(1)
+		lastVerified = lastVerified.Add(1)
+		makeAndProcessLayer(t, lastProcessed, trtl, blocksPerLayer, atxdb, msh, nil)
+		require.Equal(t, int(lastVerified.Uint32()), int(trtl.Verified.Uint32()))
+	})
+
+	t.Run("heal after good bad good bad good pattern", func(t *testing.T) {
+		pattern := []bool{
+			true,
+			true,
+			true,
+			true,
+			true,
+			false,
+			true,
+			true,
+			false,
+			false,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+			true,
+		}
 
-	trtl.HandleIncomingLayer(lyr)
+		// use a mesh wrapper to simulate weakcoin, needed for healing
+		msh := &meshWrapper{blockDataWriter: getInMemMesh(t)}
+		atxdb := getAtxDB()
+		trtl := defaultTurtle(t)
+		trtl.AvgLayerSize = blocksPerLayer
+		trtl.bdp = msh
+		trtl.atxdb = atxdb
+		trtl.init(context.TODO(), mesh.GenesisLayer())
+		testLayerPattern(t, atxdb, msh, trtl, blocksPerLayer, pattern)
+		finalVerified := types.GetEffectiveGenesis().Add(uint32(len(pattern)) - 1)
+		require.Equal(t, int(finalVerified.Uint32()), int(trtl.Verified.Uint32()))
+	})
 }
 
-func Test_TurtleAbstainsInMiddle(t *testing.T) {
+func TestAbstainsInMiddle(t *testing.T) {
 	logger := logtest.New(t)
 	layers := types.NewLayerID(15)
+	initialNumGood := 5
 	blocksPerLayer := 10
 
 	msh := getInMemMesh(t)
-
-	layerfuncs := make([]func(id types.LayerID) (ids []types.BlockID, err error), 0, layers.Uint32())
+	layerfuncs := make([]func(types.LayerID) ([]types.BlockID, error), 0, layers.Uint32())
 
 	// first 5 layers incl genesis just work
-	for i := 0; i <= 5; i++ {
+	for i := 0; i <= initialNumGood; i++ {
 		layerfuncs = append(layerfuncs, func(id types.LayerID) (ids []types.BlockID, err error) {
-			logger.Debug("Giving good results for layer", id)
+			logger.Debug("giving good results for layer", id)
 			return msh.LayerBlockIds(id)
 		})
 	}
@@ -273,8 +587,8 @@ func Test_TurtleAbstainsInMiddle(t *testing.T) {
 	newlastlyr := types.NewLayerID(uint32(len(layerfuncs)))
 	for i := newlastlyr; i.Before(newlastlyr.Add(2)); i = i.Add(1) {
 		layerfuncs = append(layerfuncs, func(id types.LayerID) (ids []types.BlockID, err error) {
-			logger.Debug("Giving bad result for layer ", id)
-			return nil, errors.New("idontknow")
+			logger.Debug("giving bad result for layer", id)
+			return nil, errors.New("simulated hare failure")
 		})
 	}
 
@@ -286,43 +600,54 @@ func Test_TurtleAbstainsInMiddle(t *testing.T) {
 		})
 	}
 
-	trtl := newTurtle(msh, defaultTestHdist, blocksPerLayer)
+	trtl := defaultTurtle(t)
+	trtl.AvgLayerSize = blocksPerLayer
+	trtl.bdp = msh
 	gen := mesh.GenesisLayer()
-	trtl.init(gen)
+	trtl.init(context.TODO(), gen)
 
 	var l types.LayerID
-	for l = types.GetEffectiveGenesis().Add(1); l.Before(layers); l = l.Add(1) {
-		turtleMakeAndProcessLayer(t, l, trtl, blocksPerLayer, msh, layerfuncs[l.Difference(types.GetEffectiveGenesis())-1])
-		logger.Debug("Handled ", l, " Verified ", trtl.Verified, "========================================================================")
+	atxdb := getAtxDB()
+	trtl.atxdb = atxdb
+	for l = types.GetEffectiveGenesis().Add(1); l.Before(types.GetEffectiveGenesis().Add(layers.Uint32())); l = l.Add(1) {
+		makeAndProcessLayer(t, l, trtl, blocksPerLayer, atxdb, msh, layerfuncs[l.Difference(types.GetEffectiveGenesis())-1])
+		logger.Debug("handled layer", l, "verified layer", trtl.Verified,
+			"========================================================================")
 	}
 
-	require.Equal(t, types.GetEffectiveGenesis().Add(5), trtl.Verified, "verification should advance after hare finishes")
+	// verification will get stuck as of the first layer with conflicting local and global opinions.
+	// block votes aren't counted because blocks aren't marked good, because they contain exceptions older
+	// than their base block.
+	// self-healing will not run because the layers aren't old enough.
+	require.Equal(t, int(types.GetEffectiveGenesis().Add(uint32(initialNumGood)).Uint32()), int(trtl.Verified.Uint32()),
+		"verification should advance after hare finishes")
 	//todo: also check votes with requireVote
 }
 
-type baseBlockProvider func(ctx context.Context) (types.BlockID, [][]types.BlockID, error)
-type inputVectorProvider func(l types.LayerID) ([]types.BlockID, error)
-
-func createTurtleLayer(ctx context.Context, l types.LayerID, msh *mesh.DB, bbp baseBlockProvider, ivp inputVectorProvider, blocksPerLayer int) *types.Layer {
-	msh.InputVectorBackupFunc = ivp
-	b, lists, err := bbp(ctx)
-	if err != nil {
-		panic(fmt.Sprint("no base - ", err))
-	}
-	lyr := types.NewLayer(l)
+type baseBlockProvider func(context.Context) (types.BlockID, [][]types.BlockID, error)
+type inputVectorProvider func(types.LayerID) ([]types.BlockID, error)
 
-	blocks, err := ivp(l.Sub(1))
-	if err != nil {
-		blocks = nil
-	}
-	if err := msh.SaveLayerInputVectorByID(context.TODO(), l.Sub(1), blocks); err != nil {
-		panic("can't save layuer input vector")
-	}
-
-	for i := 0; i < blocksPerLayer; i++ {
+func generateBlocks(t *testing.T, l types.LayerID, n int, bbp baseBlockProvider, atxdb atxDataWriter, weight uint) (blocks []*types.Block) {
+	logger := logtest.New(t)
+	logger.Debug("======================== choosing base block for layer", l)
+	b, lists, err := bbp(context.TODO())
+	require.NoError(t, err)
+	logger.Debug("the base block for layer", l, "is", b, ". exception lists:")
+	logger.Debug("\tagainst\t", lists[0])
+	logger.Debug("\tfor\t", lists[1])
+	logger.Debug("\tneutral\t", lists[2])
+
+	// for now just create a single ATX for all of the blocks with a constant weight
+	atxHeader := makeAtxHeaderWithWeight(weight)
+	atx := &types.ActivationTx{InnerActivationTx: &types.InnerActivationTx{ActivationTxHeader: atxHeader}}
+	atx.CalcAndSetID()
+	require.NoError(t, atxdb.StoreAtx(l.GetEpoch(), atx))
+
+	for i := 0; i < n; i++ {
 		blk := &types.Block{
 			MiniBlock: types.MiniBlock{
 				BlockHeader: types.BlockHeader{
+					ATXID:      atx.ID(),
 					LayerIndex: l,
 					Data:       []byte(strconv.Itoa(i))},
 				TxIDs: nil,
@@ -333,102 +658,2426 @@ func createTurtleLayer(ctx context.Context, l types.LayerID, msh *mesh.DB, bbp b
 		blk.NeutralDiff = lists[2]
 		blk.Signature = signing.NewEdSigner().Sign(b.Bytes())
 		blk.Initialize()
-		lyr.AddBlock(blk)
+		blocks = append(blocks, blk)
+		logger.Debug("generated block", blk.ID(), "in layer", l)
 	}
+	return
+}
+
+func generateBlock(t *testing.T, l types.LayerID, bbp baseBlockProvider, atxdb atxDataWriter, weight uint) *types.Block {
+	b, lists, err := bbp(context.TODO())
+	require.NoError(t, err)
+	atxHeader := makeAtxHeaderWithWeight(weight)
+	atx := &types.ActivationTx{InnerActivationTx: &types.InnerActivationTx{ActivationTxHeader: atxHeader}}
+	atx.CalcAndSetID()
+	require.NoError(t, atxdb.StoreAtx(l.GetEpoch(), atx))
+
+	blk := &types.Block{
+		MiniBlock: types.MiniBlock{
+			BlockHeader: types.BlockHeader{
+				ATXID:      atx.ID(),
+				LayerIndex: l,
+				Data:       []byte{0}},
+			TxIDs: nil,
+		}}
+	blk.BaseBlock = b
+	blk.AgainstDiff = lists[0]
+	blk.ForDiff = lists[1]
+	blk.NeutralDiff = lists[2]
+	blk.Signature = signing.NewEdSigner().Sign(b.Bytes())
+	blk.Initialize()
+	return blk
+}
+
+func createTurtleLayer(t *testing.T, l types.LayerID, msh *mesh.DB, atxdb atxDataWriter, bbp baseBlockProvider, ivp inputVectorProvider, blocksPerLayer int) *types.Layer {
+	oldInputVectorFn := msh.InputVectorBackupFunc
+	defer func() {
+		msh.InputVectorBackupFunc = oldInputVectorFn
+	}()
+	msh.InputVectorBackupFunc = ivp
+	blocks, err := ivp(l.Sub(1))
+	if err != nil {
+		blocks = nil
+	}
+	if err := msh.SaveLayerInputVectorByID(context.TODO(), l.Sub(1), blocks); err != nil {
+		panic("database error")
+	}
+	lyr := types.NewLayer(l)
+	for _, block := range generateBlocks(t, l, blocksPerLayer, bbp, atxdb, 1) {
+		lyr.AddBlock(block)
+	}
+
 	return lyr
 }
 
-func TestTurtle_Eviction(t *testing.T) {
-	defaultTestHdist = 12
+func TestEviction(t *testing.T) {
 	logger := logtest.New(t)
-	layers := types.NewLayerID(defaultTestHdist * 5)
+	layers := types.NewLayerID(defaultTestWindowSize * 5)
 	avgPerLayer := 20 // more blocks = longer test
-	voteNegative := 0
-	trtl, _, _ := turtleSanity(t, layers, avgPerLayer, voteNegative, 0)
-	require.EqualValues(t, len(trtl.BlockOpinionsByLayer),
-		(defaultTestHdist + 2))
+	trtl, _, _ := turtleSanity(t, layers, avgPerLayer, 0, 0)
+	require.Equal(t, int(trtl.WindowSize+2), len(trtl.BlockOpinionsByLayer))
+
+	// verified layer was advanced
+	require.Equal(t, int(layers.Sub(1).Uint32()), int(trtl.Verified.Uint32()))
+
+	// old data were evicted
+	require.Equal(t, int(trtl.Verified.Sub(trtl.WindowSize+1).Uint32()), int(trtl.LastEvicted.Uint32()))
+
+	checkBlockLayer := func(bid types.BlockID, layerAfter types.LayerID) types.LayerID {
+		blk, err := trtl.bdp.GetBlock(bid)
+		require.NoError(t, err, "error reading block data")
+		require.True(t, !blk.LayerIndex.Before(layerAfter),
+			"opinion on ancient block should have been evicted: block %v layer %v maxdepth %v lastevicted %v windowsize %v",
+			blk.ID(), blk.LayerIndex, layerAfter, trtl.LastEvicted, trtl.WindowSize)
+		return blk.LayerIndex
+	}
+
+	count := 0
+	for _, blks := range trtl.BlockOpinionsByLayer {
+		count += len(blks)
+		for blockID, opinion := range blks {
+			lid := checkBlockLayer(blockID, trtl.LastEvicted)
+
+			// check deep opinion layers
+			for bid := range opinion.BlockOpinions {
+				// check that child (opinion) block layer is within window size from parent block layer
+				// we allow a leeway of three layers:
+				// 1. eviction evicts one layer prior to window start (Verified - WindowSize)
+				// 2. Verified layer lags Last processed layer by one
+				// 3. block opinions are added before block layer is finished processing
+				checkBlockLayer(bid, lid.Sub(trtl.WindowSize+3))
+			}
+		}
+	}
+
+	require.Equal(t, (int(trtl.WindowSize)+2)*avgPerLayer, count)
+	logger.Debug("=======================================================================")
+	logger.Debug("count blocks on blocks layers ", len(trtl.BlockOpinionsByLayer))
+	logger.Debug("count blocks on blocks blocks ", count)
+	require.Equal(t, int(trtl.WindowSize+2)*avgPerLayer, len(trtl.GoodBlocksIndex)) // all blocks should be good
+	logger.Debug("count good blocks ", len(trtl.GoodBlocksIndex))
+
+}
 
+func TestEviction2(t *testing.T) {
+	layers := types.NewLayerID(uint32(defaultTestWindowSize) * 3)
+	avgPerLayer := 10
+	trtl, _, _ := turtleSanity(t, layers, avgPerLayer, 0, 0)
+	require.Equal(t, int(defaultTestWindowSize)+2, len(trtl.BlockOpinionsByLayer))
 	count := 0
 	for _, blks := range trtl.BlockOpinionsByLayer {
 		count += len(blks)
 	}
-	require.Equal(t, count,
-		int(defaultTestHdist+2)*avgPerLayer)
+	require.Equal(t, (int(defaultTestWindowSize)+2)*avgPerLayer, count)
+	require.Equal(t, (int(defaultTestWindowSize)+2)*avgPerLayer, len(trtl.GoodBlocksIndex)) // all blocks should be good
+}
 
-	logger.Debug("Count blocks on blocks layers ", len(trtl.BlockOpinionsByLayer))
-	logger.Debug("Count blocks on blocks blocks ", count)
-	//t.Log("mem Size: ", size(trtl.BlockOpinionsByLayer))
-	require.Equal(t, len(trtl.GoodBlocksIndex),
-		int(defaultTestHdist+2)*avgPerLayer) // all blocks should be good
-	logger.Debug("Count good blocks ", len(trtl.GoodBlocksIndex))
+func TestLayerCutoff(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	alg := defaultAlgorithm(t, mdb)
+
+	// cutoff should be zero if we haven't seen at least Hdist layers yet
+	alg.trtl.Last = types.NewLayerID(alg.trtl.Hdist - 1)
+	r.Equal(0, int(alg.trtl.layerCutoff().Uint32()))
+	alg.trtl.Last = types.NewLayerID(alg.trtl.Hdist)
+	r.Equal(0, int(alg.trtl.layerCutoff().Uint32()))
+
+	// otherwise, cutoff should be Hdist layers before Last
+	alg.trtl.Last = types.NewLayerID(alg.trtl.Hdist + 1)
+	r.Equal(1, int(alg.trtl.layerCutoff().Uint32()))
+	alg.trtl.Last = types.NewLayerID(alg.trtl.Hdist + 100)
+	r.Equal(100, int(alg.trtl.layerCutoff().Uint32()))
 }
 
-func TestTurtle_Recovery(t *testing.T) {
-	mdb, teardown := getPersistentMash(t)
+func TestAddToMesh(t *testing.T) {
+	logger := logtest.New(t)
+	mdb := getInMemMesh(t)
+
+	getHareResults := mdb.LayerBlockIds
+
+	mdb.InputVectorBackupFunc = getHareResults
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	l := mesh.GenesisLayer()
+
+	logger.With().Info("genesis is", l.Index(), types.BlockIdsField(types.BlockIDs(l.Blocks())))
+	logger.With().Info("genesis is", l.Blocks()[0].Fields()...)
+
+	l1 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(1), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	require.NoError(t, addLayerToMesh(mdb, l1))
+
+	logger.With().Info("first is", l1.Index(), types.BlockIdsField(types.BlockIDs(l1.Blocks())))
+	logger.With().Info("first bb is", l1.Index(), l1.Blocks()[0].BaseBlock, types.BlockIdsField(l1.Blocks()[0].ForDiff))
+
+	alg.HandleIncomingLayer(context.TODO(), l1.Index())
+
+	l2 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(2), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	require.NoError(t, addLayerToMesh(mdb, l2))
+	alg.HandleIncomingLayer(context.TODO(), l2.Index())
+
+	require.Equal(t, int(types.GetEffectiveGenesis().Add(1).Uint32()), int(alg.LatestComplete().Uint32()))
+
+	l3a := createTurtleLayer(t, types.GetEffectiveGenesis().Add(3), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize+1)
+
+	// this should fail as the blocks for this layer have not been added to the mesh yet
+	alg.HandleIncomingLayer(context.TODO(), l3a.Index())
+	require.Equal(t, int(types.GetEffectiveGenesis().Add(1).Uint32()), int(alg.LatestComplete().Uint32()))
+
+	l3 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(3), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	require.NoError(t, addLayerToMesh(mdb, l3))
+	alg.HandleIncomingLayer(context.TODO(), l3.Index())
+
+	l4 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(4), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	require.NoError(t, addLayerToMesh(mdb, l4))
+	alg.HandleIncomingLayer(context.TODO(), l4.Index())
+	require.Equal(t, int(types.GetEffectiveGenesis().Add(3).Uint32()), int(alg.LatestComplete().Uint32()), "wrong latest complete layer")
+}
+
+func TestPersistAndRecover(t *testing.T) {
+	mdb := getPersistentMesh(t)
+
+	getHareResults := mdb.LayerBlockIds
+
+	mdb.InputVectorBackupFunc = getHareResults
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+
+	l1 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(1), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	require.NoError(t, addLayerToMesh(mdb, l1))
+	alg.HandleIncomingLayer(context.TODO(), l1.Index())
+	require.NoError(t, alg.Persist(context.TODO()))
+
+	l2 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(2), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	require.NoError(t, addLayerToMesh(mdb, l2))
+	alg.HandleIncomingLayer(context.TODO(), l2.Index())
+	require.NoError(t, alg.Persist(context.TODO()))
+	require.Equal(t, int(types.GetEffectiveGenesis().Add(1).Uint32()), int(alg.LatestComplete().Uint32()))
+
+	// now recover
+	alg2 := recoveredVerifyingTortoise(mdb, alg.trtl.atxdb, alg.trtl.clock, alg.logger)
+	require.Equal(t, alg.LatestComplete(), alg2.LatestComplete())
+	require.Equal(t, alg.trtl.bdp, alg2.trtl.bdp)
+	require.Equal(t, alg.trtl.LastEvicted, alg2.trtl.LastEvicted)
+	require.Equal(t, alg.trtl.Verified, alg2.trtl.Verified)
+	require.Equal(t, alg.trtl.WindowSize, alg2.trtl.WindowSize)
+	require.Equal(t, alg.trtl.Last, alg2.trtl.Last)
+	require.Equal(t, alg.trtl.Hdist, alg2.trtl.Hdist)
+	require.Equal(t, alg.trtl.ConfidenceParam, alg2.trtl.ConfidenceParam)
+	require.Equal(t, alg.trtl.Zdist, alg2.trtl.Zdist)
+	require.Equal(t, alg.trtl.RerunInterval, alg2.trtl.RerunInterval)
+
+	l3 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(3), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	require.NoError(t, addLayerToMesh(mdb, l3))
+	alg.HandleIncomingLayer(context.TODO(), l3.Index())
+	alg2.HandleIncomingLayer(context.TODO(), l3.Index())
+
+	// expect identical results
+	require.Equal(t, int(types.GetEffectiveGenesis().Add(2).Uint32()), int(alg.LatestComplete().Uint32()), "wrong latest complete layer")
+	require.Equal(t, int(types.GetEffectiveGenesis().Add(2).Uint32()), int(alg2.LatestComplete().Uint32()), "wrong latest complete layer")
+}
 
-	getHareResults := func(l types.LayerID) ([]types.BlockID, error) {
-		return mdb.LayerBlockIds(l)
+func TestRerunInterval(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	lastRerun := alg.lastRerun
+
+	mdb.InputVectorBackupFunc = mdb.LayerBlockIds
+
+	// no rerun
+	l1 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(1), mdb, atxdb, alg.BaseBlock, mdb.LayerBlockIds, defaultTestLayerSize)
+	alg.HandleIncomingLayer(context.TODO(), l1.Index())
+	r.Equal(lastRerun, alg.lastRerun)
+
+	// force a rerun
+	alg.lastRerun = time.Now().Add(-alg.trtl.RerunInterval)
+	alg.HandleIncomingLayer(context.TODO(), l1.Index())
+	r.NotEqual(lastRerun, alg.lastRerun)
+	lastRerun = alg.lastRerun
+
+	// no rerun
+	alg.HandleIncomingLayer(context.TODO(), l1.Index())
+	r.Equal(lastRerun, alg.lastRerun)
+}
+
+func TestLayerOpinionVector(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+
+	mdb.InputVectorBackupFunc = mdb.LayerBlockIds
+	l0 := mesh.GenesisLayer()
+
+	// recent layer missing from mesh: should abstain and keep waiting
+	l1ID := l0.Index().Add(1)
+	opinionVec, err := alg.trtl.layerOpinionVector(context.TODO(), l1ID)
+	r.NoError(err)
+	r.Nil(opinionVec)
+
+	// hare failed for layer: should vote against all blocks
+	mdb.InputVectorBackupFunc = func(types.LayerID) ([]types.BlockID, error) {
+		return nil, mesh.ErrInvalidLayer
+	}
+	opinionVec, err = alg.trtl.layerOpinionVector(context.TODO(), l1ID)
+	r.NoError(err)
+	r.Equal(make([]types.BlockID, 0, 0), opinionVec)
+
+	// old layer missing from mesh: should vote against all blocks
+	// older than zdist, not as old as hdist
+	// simulate old layer by advancing Last
+	l2ID := l1ID.Add(1)
+	alg.trtl.Last = types.NewLayerID(defaultTestZdist).Add(l2ID.Uint32()).Add(1)
+	mdb.InputVectorBackupFunc = mdb.LayerBlockIds
+	opinionVec, err = alg.trtl.layerOpinionVector(context.TODO(), l2ID)
+	r.NoError(err)
+	r.Equal(make([]types.BlockID, 0, 0), opinionVec)
+
+	// very old layer (more than hdist layers back)
+	// if the layer isn't in the mesh, it's an error
+	alg.trtl.Last = types.NewLayerID(defaultTestHdist).Add(l2ID.Uint32()).Add(1)
+	opinionVec, err = alg.trtl.layerOpinionVector(context.TODO(), l2ID)
+	r.Equal(database.ErrNotFound, err)
+	r.Nil(opinionVec)
+
+	// same layer in mesh, but no contextual validity info
+	// expect error about missing weak coin
+	alg.trtl.Last = l0.Index()
+	l1 := createTurtleLayer(t, l1ID, mdb, atxdb, alg.BaseBlock, mdb.LayerBlockIds, defaultTestLayerSize)
+	for _, b := range l1.Blocks() {
+		r.NoError(mdb.AddBlock(b))
 	}
+	alg.trtl.Last = l1ID
+	l2 := createTurtleLayer(t, l2ID, mdb, atxdb, alg.BaseBlock, mdb.LayerBlockIds, defaultTestLayerSize)
+	for _, b := range l2.Blocks() {
+		r.NoError(mdb.AddBlock(b))
+	}
+	alg.trtl.Last = types.NewLayerID(defaultTestHdist).Add(l2ID.Uint32()).Add(1)
+	opinionVec, err = alg.trtl.layerOpinionVector(context.TODO(), l2ID)
+	r.Error(err)
+	r.Contains(err.Error(), errstrNoCoinflip)
+	r.Nil(opinionVec)
+
+	// coinflip true: expect support for all layer blocks
+	mdb.RecordCoinflip(context.TODO(), alg.trtl.Last.Sub(1), true)
+	opinionVec, err = alg.trtl.layerOpinionVector(context.TODO(), l2ID)
+	r.NoError(err)
+	r.Equal(l2.Hash(), types.CalcBlocksHash32(types.SortBlockIDs(opinionVec), nil))
+
+	// coinflip false: expect vote against all blocks in layer
+	mdb.RecordCoinflip(context.TODO(), alg.trtl.Last.Sub(1), false)
+	opinionVec, err = alg.trtl.layerOpinionVector(context.TODO(), l2ID)
+	r.NoError(err)
+	r.Equal(make([]types.BlockID, 0, 0), opinionVec)
+
+	// for a verified layer, we expect the set of contextually valid blocks
+	for _, b := range l2.Blocks() {
+		r.NoError(mdb.SaveContextualValidity(b.ID(), l2ID, true))
+	}
+	alg.trtl.Verified = l2ID
+	opinionVec, err = alg.trtl.layerOpinionVector(context.TODO(), l2ID)
+	r.NoError(err)
+	// this is the easiest way to compare a set of blockIDs
+	r.Equal(l2.Hash(), types.CalcBlocksHash32(types.SortBlockIDs(opinionVec), nil))
+}
 
+func TestBaseBlock(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+
+	getHareResults := mdb.LayerBlockIds
 	mdb.InputVectorBackupFunc = getHareResults
 
-	lg := logtest.New(t)
-	alg := verifyingTortoise(3, mdb, 5, lg)
-	l := mesh.GenesisLayer()
+	l0 := mesh.GenesisLayer()
+	expectBaseBlockLayer := func(layerID types.LayerID, numAgainst, numSupport, numNeutral int) {
+		baseBlockID, exceptions, err := alg.BaseBlock(context.TODO())
+		r.NoError(err)
+		// expect no exceptions
+		r.Len(exceptions, 3, "expected three vote exception arrays")
+		r.Len(exceptions[0], numAgainst, "wrong number of against exception votes")
+		r.Len(exceptions[1], numSupport, "wrong number of support exception votes")
+		r.Len(exceptions[2], numNeutral, "wrong number of neutral exception votes")
+		// expect a valid genesis base block
+		baseBlock, err := alg.trtl.bdp.GetBlock(baseBlockID)
+		r.NoError(err)
+		r.Equal(layerID, baseBlock.Layer(), "base block is from wrong layer")
+	}
+	// it should support all genesis blocks
+	expectBaseBlockLayer(l0.Index(), 0, len(mesh.GenesisLayer().Blocks()), 0)
+
+	// add a couple of incoming layers and make sure the base block layer advances as well
+	l1 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(1), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	require.NoError(t, addLayerToMesh(mdb, l1))
+	alg.HandleIncomingLayer(context.TODO(), l1.Index())
+	expectBaseBlockLayer(l1.Index(), 0, defaultTestLayerSize, 0)
+
+	l2 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(2), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	require.NoError(t, addLayerToMesh(mdb, l2))
+	alg.HandleIncomingLayer(context.TODO(), l2.Index())
+	require.Equal(t, int(types.GetEffectiveGenesis().Add(1).Uint32()), int(alg.LatestComplete().Uint32()))
+	expectBaseBlockLayer(l2.Index(), 0, defaultTestLayerSize, 0)
+
+	// add a layer that's not in the mesh and make sure it does not advance
+	l3 := createTurtleLayer(t, types.GetEffectiveGenesis().Add(3), mdb, atxdb, alg.BaseBlock, getHareResults, defaultTestLayerSize)
+	alg.HandleIncomingLayer(context.TODO(), l3.Index())
+	require.Equal(t, int(types.GetEffectiveGenesis().Add(1).Uint32()), int(alg.LatestComplete().Uint32()))
+	expectBaseBlockLayer(l2.Index(), 0, defaultTestLayerSize, 0)
+
+	// mark all blocks bad
+	alg.trtl.GoodBlocksIndex = make(map[types.BlockID]struct{}, 0)
+	baseBlockID, exceptions, err := alg.BaseBlock(context.TODO())
+	r.Equal(errNoBaseBlockFound, err)
+	r.Equal(types.BlockID{0}, baseBlockID)
+	r.Nil(exceptions)
+}
+
+func defaultClock(tb testing.TB) layerClock {
+	genesisTime := time.Now().Add(time.Second * 10)
+	ld := time.Duration(10) * time.Second
+	return timesync.NewClock(timesync.RealClock{}, ld, genesisTime, logtest.New(tb))
+}
+
+func defaultTurtle(tb testing.TB) *turtle {
+	mdb := getInMemMesh(tb)
+	return newTurtle(
+		mdb,
+		getAtxDB(),
+		defaultClock(tb),
+		defaultTestHdist,
+		defaultTestZdist,
+		defaultTestConfidenceParam,
+		defaultTestWindowSize,
+		defaultTestLayerSize,
+		defaultTestGlobalThreshold,
+		defaultTestLocalThreshold,
+		defaultTestRerunInterval,
+	)
+}
+
+func TestCloneTurtle(t *testing.T) {
+	r := require.New(t)
+	trtl := defaultTurtle(t)
+	trtl.AvgLayerSize++              // make sure defaults aren't being read
+	trtl.Last = types.NewLayerID(10) // state should not be cloned
+	trtl2 := trtl.cloneTurtleParams()
+	r.Equal(trtl.bdp, trtl2.bdp)
+	r.Equal(trtl.Hdist, trtl2.Hdist)
+	r.Equal(trtl.Zdist, trtl2.Zdist)
+	r.Equal(trtl.ConfidenceParam, trtl2.ConfidenceParam)
+	r.Equal(trtl.WindowSize, trtl2.WindowSize)
+	r.Equal(trtl.AvgLayerSize, trtl2.AvgLayerSize)
+	r.Equal(trtl.GlobalThreshold, trtl2.GlobalThreshold)
+	r.Equal(trtl.LocalThreshold, trtl2.LocalThreshold)
+	r.Equal(trtl.RerunInterval, trtl2.RerunInterval)
+	r.NotEqual(trtl.Last, trtl2.Last)
+}
+
+func defaultAlgorithm(t *testing.T, mdb *mesh.DB) *ThreadSafeVerifyingTortoise {
+	return verifyingTortoise(
+		context.TODO(),
+		defaultTestLayerSize,
+		mdb,
+		getAtxDB(),
+		defaultClock(t),
+		defaultTestHdist,
+		defaultTestZdist,
+		defaultTestConfidenceParam,
+		defaultTestWindowSize,
+		defaultTestGlobalThreshold,
+		defaultTestLocalThreshold,
+		defaultTestRerunInterval,
+		logtest.New(t),
+	)
+}
+
+func TestGetLocalBlockOpinion(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	blocks := generateBlocks(t, l1ID, 2, alg.BaseBlock, atxdb, 1)
+
+	// no input vector for recent layer: expect abstain vote
+	vec, err := alg.trtl.getLocalBlockOpinion(context.TODO(), l1ID, blocks[0].ID())
+	r.NoError(err)
+	r.Equal(abstain, vec)
+
+	// block included in input vector
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), l1ID, []types.BlockID{blocks[0].ID()}))
+	vec, err = alg.trtl.getLocalBlockOpinion(context.TODO(), l1ID, blocks[0].ID())
+	r.NoError(err)
+	r.Equal(support, vec)
+
+	// block not included in input vector
+	vec, err = alg.trtl.getLocalBlockOpinion(context.TODO(), l1ID, blocks[1].ID())
+	r.NoError(err)
+	r.Equal(against, vec)
+}
+
+func TestCheckBlockAndGetInputVector(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	blocks := generateBlocks(t, l1ID, 3, alg.BaseBlock, atxdb, 1)
+	diffList := []types.BlockID{blocks[0].ID()}
+
+	// missing block
+	r.False(alg.trtl.checkBlockAndGetLocalOpinion(context.TODO(), diffList, "foo", support, l1ID))
+
+	// exception block older than base block
+	blocks[0].LayerIndex = mesh.GenesisLayer().Index()
+	r.NoError(mdb.AddBlock(blocks[0]))
+	r.False(alg.trtl.checkBlockAndGetLocalOpinion(context.TODO(), diffList, "foo", support, l1ID))
+
+	// missing input vector for layer
+	r.NoError(mdb.AddBlock(blocks[1]))
+	diffList[0] = blocks[1].ID()
+	r.False(alg.trtl.checkBlockAndGetLocalOpinion(context.TODO(), diffList, "foo", support, l1ID))
+
+	// good
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), l1ID, diffList))
+	r.True(alg.trtl.checkBlockAndGetLocalOpinion(context.TODO(), diffList, "foo", support, l1ID))
+
+	// vote differs from input vector
+	diffList[0] = blocks[2].ID()
+	r.NoError(mdb.AddBlock(blocks[2]))
+	r.False(alg.trtl.checkBlockAndGetLocalOpinion(context.TODO(), diffList, "foo", support, l1ID))
+}
 
-	lg.With().Info("The genesis is ", l.Index(), types.BlockIdsField(types.BlockIDs(l.Blocks())))
-	lg.With().Info("The genesis is ", l.Blocks()[0].Fields()...)
+func TestCalculateExceptions(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+
+	// helper function for checking votes
+	expectVotes := func(votes []map[types.BlockID]struct{}, numAgainst, numFor, numNeutral int) {
+		r.Len(votes, 3, "vote vector size is wrong")
+		r.Len(votes[0], numAgainst) // against
+		r.Len(votes[1], numFor)     // for
+		r.Len(votes[2], numNeutral) // neutral
+	}
 
-	l1 := createTurtleLayer(context.TODO(), types.GetEffectiveGenesis().Add(1), mdb, alg.BaseBlock, getHareResults, 3)
-	require.NoError(t, AddLayer(mdb, l1))
+	// genesis layer
+	l0ID := types.GetEffectiveGenesis()
+	votes, err := alg.trtl.calculateExceptions(context.TODO(), l0ID, Opinion{})
+	r.NoError(err)
+	// expect votes in support of all genesis blocks
+	expectVotes(votes, 0, len(mesh.GenesisLayer().Blocks()), 0)
+
+	// layer greater than last processed: expect support only for genesis
+	l1ID := l0ID.Add(1)
+	votes, err = alg.trtl.calculateExceptions(context.TODO(), l1ID, Opinion{})
+	r.NoError(err)
+	expectVotes(votes, 0, 1, 0)
+
+	// now advance the processed layer
+	alg.trtl.Last = l1ID
+
+	// missing layer data
+	votes, err = alg.trtl.calculateExceptions(context.TODO(), l1ID, Opinion{})
+	r.Equal(database.ErrNotFound, err)
+	r.Nil(votes)
+
+	// layer opinion vector is nil (abstains): recent layer, in mesh, no input vector
+	alg.trtl.Last = l0ID
+	l1 := createTurtleLayer(t, l1ID, mdb, atxdb, alg.BaseBlock, mdb.LayerBlockIds, defaultTestLayerSize)
+	r.NoError(addLayerToMesh(mdb, l1))
+	alg.trtl.Last = l1ID
+	mdb.InputVectorBackupFunc = nil
+	votes, err = alg.trtl.calculateExceptions(context.TODO(), l1ID, Opinion{})
+	r.NoError(err)
+	// expect no against, FOR only for l0, and NEUTRAL for l1
+	expectVotes(votes, 0, len(mesh.GenesisLayer().Blocks()), defaultTestLayerSize)
+
+	// adding diffs for: support all blocks in the layer
+	mdb.InputVectorBackupFunc = mdb.LayerBlockIds
+	votes, err = alg.trtl.calculateExceptions(context.TODO(), l1ID, Opinion{})
+	r.NoError(err)
+	expectVotes(votes, 0, len(mesh.GenesisLayer().Blocks())+defaultTestLayerSize, 0)
+
+	// adding diffs against: vote against all blocks in the layer
+	mdb.InputVectorBackupFunc = nil
+	// we cannot store an empty vector here (it comes back as nil), so just put another block ID in it
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), l1ID, []types.BlockID{mesh.GenesisBlock().ID()}))
+	votes, err = alg.trtl.calculateExceptions(context.TODO(), l1ID, Opinion{})
+	r.NoError(err)
+
+	// we don't explicitly vote against blocks in the layer, we implicitly vote against them by not voting for them
+	expectVotes(votes, 0, len(mesh.GenesisLayer().Blocks()), 0)
+
+	// compare opinions: all agree, no exceptions
+	mdb.InputVectorBackupFunc = mdb.LayerBlockIds
+	opinion := Opinion{BlockOpinions: map[types.BlockID]vec{
+		mesh.GenesisBlock().ID(): support,
+		l1.Blocks()[0].ID():      support,
+		l1.Blocks()[1].ID():      support,
+		l1.Blocks()[2].ID():      support,
+	}}
+	votes, err = alg.trtl.calculateExceptions(context.TODO(), l1ID, opinion)
+	r.NoError(err)
+	expectVotes(votes, 0, 0, 0)
+
+	// compare opinions: all disagree, adds exceptions
+	opinion = Opinion{BlockOpinions: map[types.BlockID]vec{
+		mesh.GenesisBlock().ID(): against,
+		l1.Blocks()[0].ID():      against,
+		l1.Blocks()[1].ID():      against,
+		l1.Blocks()[2].ID():      against,
+	}}
+	votes, err = alg.trtl.calculateExceptions(context.TODO(), l1ID, opinion)
+	r.NoError(err)
+	expectVotes(votes, 0, 4, 0)
+
+	l2ID := l1ID.Add(1)
+	l3ID := l2ID.Add(1)
+	var l3 *types.Layer
+
+	// exceeding max exceptions
+	t.Run("exceeding max exceptions", func(t *testing.T) {
+		alg.trtl.MaxExceptions = 10
+		l2 := createTurtleLayer(t, l2ID, mdb, atxdb, alg.BaseBlock, mdb.LayerBlockIds, alg.trtl.MaxExceptions+1)
+		for _, block := range l2.Blocks() {
+			r.NoError(mdb.AddBlock(block))
+		}
+		l3 = createTurtleLayer(t, l3ID, mdb, atxdb, alg.BaseBlock, mdb.LayerBlockIds, defaultTestLayerSize)
+		alg.trtl.Last = l2ID
+		votes, err = alg.trtl.calculateExceptions(context.TODO(), l2ID, Opinion{})
+		r.Error(err)
+		r.Contains(err.Error(), errstrTooManyExceptions, "expected too many exceptions error")
+		r.Nil(votes)
+	})
+
+	// TODO: test adding base block opinion in support of a block that disagrees with the local opinion, e.g., a block
+	//   that this node has not seen yet. See https://github.com/spacemeshos/go-spacemesh/issues/2424.
+
+	t.Run("advance sliding window", func(t *testing.T) {
+		// advance the evicted layer until the exception layer slides outside the sliding window
+		for _, block := range l3.Blocks() {
+			r.NoError(mdb.AddBlock(block))
+		}
+		l4ID := l3ID.Add(1)
+		alg.trtl.LastEvicted = l2ID
+		r.NoError(alg.trtl.HandleIncomingLayer(context.TODO(), l3ID))
+		l4 := createTurtleLayer(t, l4ID, mdb, atxdb, alg.BaseBlock, mdb.LayerBlockIds, defaultTestLayerSize)
+		for _, block := range l4.Blocks() {
+			r.NoError(mdb.AddBlock(block))
+		}
+		l5ID := l4ID.Add(1)
+		createTurtleLayer(t, l5ID, mdb, atxdb, alg.BaseBlock, mdb.LayerBlockIds, defaultTestLayerSize)
+		alg.trtl.Last = l4ID
+		votes, err = alg.trtl.calculateExceptions(context.TODO(), l3ID, Opinion{})
+		r.NoError(err)
+		// expect votes FOR the blocks in the two intervening layers between the base block layer and the last layer
+		expectVotes(votes, 0, 2*defaultTestLayerSize, 0)
+	})
+}
+func TestDetermineBlockGoodness(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	l1Blocks := generateBlocks(t, l1ID, 3, alg.BaseBlock, atxdb, 1)
+
+	// block marked good
+	r.True(alg.trtl.determineBlockGoodness(context.TODO(), l1Blocks[0]))
+
+	// base block not found
+	randBlockID := randomBlockID()
+	alg.trtl.GoodBlocksIndex[randBlockID] = struct{}{}
+	l1Blocks[1].BaseBlock = randBlockID
+	r.False(alg.trtl.determineBlockGoodness(context.TODO(), l1Blocks[1]))
+
+	// base block not good
+	l1Blocks[1].BaseBlock = l1Blocks[2].ID()
+	r.False(alg.trtl.determineBlockGoodness(context.TODO(), l1Blocks[1]))
+
+	// diff inconsistent with local opinion
+	l1Blocks[2].AgainstDiff = []types.BlockID{mesh.GenesisBlock().ID()}
+	r.False(alg.trtl.determineBlockGoodness(context.TODO(), l1Blocks[2]))
+
+	// can run again on the same block with no change (idempotency)
+	r.True(alg.trtl.determineBlockGoodness(context.TODO(), l1Blocks[0]))
+	r.False(alg.trtl.determineBlockGoodness(context.TODO(), l1Blocks[2]))
+}
 
-	lg.With().Info("The first is ", l1.Index(), types.BlockIdsField(types.BlockIDs(l1.Blocks())))
-	lg.With().Info("The first bb is ", l1.Index(), l1.Blocks()[0].BaseBlock, types.BlockIdsField(l1.Blocks()[0].ForDiff))
+func TestScoreBlocks(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	l1Blocks := generateBlocks(t, l1ID, 3, alg.BaseBlock, atxdb, 1)
+
+	// adds a block not already marked good
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[0].ID())
+	alg.trtl.scoreBlocks(context.TODO(), []*types.Block{l1Blocks[0]})
+	r.Contains(alg.trtl.GoodBlocksIndex, l1Blocks[0].ID())
+
+	// no change if already marked good
+	alg.trtl.scoreBlocks(context.TODO(), []*types.Block{l1Blocks[0]})
+	r.Contains(alg.trtl.GoodBlocksIndex, l1Blocks[0].ID())
+
+	// removes a block previously marked good
+	// diff inconsistent with local opinion
+	l1Blocks[0].AgainstDiff = []types.BlockID{mesh.GenesisBlock().ID()}
+	alg.trtl.scoreBlocks(context.TODO(), []*types.Block{l1Blocks[0]})
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[0].ID())
+
+	// try a few blocks
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[1].ID())
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[2].ID())
+	alg.trtl.scoreBlocks(context.TODO(), l1Blocks)
+
+	// adds new blocks
+	r.Contains(alg.trtl.GoodBlocksIndex, l1Blocks[1].ID())
+	r.Contains(alg.trtl.GoodBlocksIndex, l1Blocks[2].ID())
+
+	// no change if already not marked good
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[0].ID())
+}
 
-	alg.HandleIncomingLayer(l1)
-	require.NoError(t, alg.Persist())
+func TestProcessBlock(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	blocksPerLayer := 4
+	baseBlockVoteWeight := uint(2)
+
+	// blocks in this layer will use the genesis block as their base block
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	l1Blocks := generateBlocks(t, l1ID, blocksPerLayer, alg.BaseBlock, atxdb, 1)
+	// add one block from the layer
+	blockWithMissingBaseBlock := l1Blocks[0]
+	r.NoError(mdb.AddBlock(blockWithMissingBaseBlock))
+	blockWithMissingBaseBlock.BaseBlock = l1Blocks[1].ID()
+
+	// missing base block
+	err := alg.trtl.processBlock(context.TODO(), blockWithMissingBaseBlock)
+	r.Equal(errBaseBlockNotInDatabase, err)
+
+	// blocks in this layer will use a block from the previous layer as their base block
+	baseBlockProviderFn := func(context.Context) (types.BlockID, [][]types.BlockID, error) {
+		return blockWithMissingBaseBlock.ID(), make([][]types.BlockID, blocksPerLayer), nil
+	}
+	l2ID := l1ID.Add(1)
+	l2Blocks := generateBlocks(t, l2ID, blocksPerLayer, baseBlockProviderFn, atxdb, baseBlockVoteWeight)
+
+	// base block layer missing
+	alg.trtl.BlockOpinionsByLayer[l2ID] = make(map[types.BlockID]Opinion, defaultTestLayerSize)
+	err = alg.trtl.processBlock(context.TODO(), l2Blocks[0])
+	r.Error(err)
+	r.Contains(err.Error(), errstrBaseBlockLayerMissing)
+
+	// base block opinion missing from layer
+	alg.trtl.BlockOpinionsByLayer[l1ID] = make(map[types.BlockID]Opinion, defaultTestLayerSize)
+	err = alg.trtl.processBlock(context.TODO(), l2Blocks[0])
+	r.Error(err)
+	r.Contains(err.Error(), errstrBaseBlockNotFoundInLayer)
+
+	// malicious (conflicting) voting pattern
+	l2Blocks[0].BaseBlock = mesh.GenesisBlock().ID()
+	l2Blocks[0].ForDiff = []types.BlockID{l1Blocks[1].ID()}
+	l2Blocks[0].AgainstDiff = l2Blocks[0].ForDiff
+	err = alg.trtl.processBlock(context.TODO(), l2Blocks[0])
+	r.Error(err)
+	r.Contains(err.Error(), errstrConflictingVotes)
+
+	// add vote diffs: make sure that base block votes flow through, but that block votes override them, and that the
+	// data structure is correctly updated, and that weights are calculated correctly
+
+	// add base block to DB
+	r.NoError(mdb.AddBlock(l2Blocks[0]))
+	baseBlockProviderFn = func(context.Context) (types.BlockID, [][]types.BlockID, error) {
+		return l2Blocks[0].ID(), make([][]types.BlockID, blocksPerLayer), nil
+	}
+	baseBlockOpinionVector := Opinion{BlockOpinions: map[types.BlockID]vec{
+		l1Blocks[0].ID(): against.Multiply(uint64(baseBlockVoteWeight)), // disagrees with block below
+		l1Blocks[1].ID(): support.Multiply(uint64(baseBlockVoteWeight)), // disagrees with block below
+		l1Blocks[2].ID(): abstain,                                       // disagrees with block below
+		l1Blocks[3].ID(): against.Multiply(uint64(baseBlockVoteWeight)), // agrees with block below
+	}}
+	alg.trtl.BlockOpinionsByLayer[l2ID][l2Blocks[0].ID()] = baseBlockOpinionVector
+	l3ID := l2ID.Add(1)
+	blockVoteWeight := uint(3)
+	l3Blocks := generateBlocks(t, l3ID, blocksPerLayer, baseBlockProviderFn, atxdb, blockVoteWeight)
+	l3Blocks[0].AgainstDiff = []types.BlockID{
+		l1Blocks[1].ID(),
+	}
+	l3Blocks[0].ForDiff = []types.BlockID{}
+	l3Blocks[0].NeutralDiff = []types.BlockID{
+		l1Blocks[0].ID(),
+	}
+	alg.trtl.BlockOpinionsByLayer[l3ID] = make(map[types.BlockID]Opinion, blocksPerLayer)
+	// these must be in the mesh or we'll get an error when processing a block (l3Blocks[0])
+	// with a base block (l2Blocks[0]) that contains an opinion on them
+	r.NoError(mdb.AddBlock(l1Blocks[1]))
+	r.NoError(mdb.AddBlock(l1Blocks[2]))
+	r.NoError(mdb.AddBlock(l1Blocks[3]))
+	r.NoError(alg.trtl.processBlock(context.TODO(), l3Blocks[0]))
+	expectedOpinionVector := Opinion{BlockOpinions: map[types.BlockID]vec{
+		l1Blocks[0].ID(): abstain,                                   // from exception
+		l1Blocks[1].ID(): against.Multiply(uint64(blockVoteWeight)), // from exception
+		l1Blocks[2].ID(): abstain,                                   // from base block
+		l1Blocks[3].ID(): against.Multiply(uint64(blockVoteWeight)), // from base block, reweighted
+	}}
+	r.Equal(baseBlockOpinionVector, alg.trtl.BlockOpinionsByLayer[l2ID][l2Blocks[0].ID()])
+	r.Equal(expectedOpinionVector, alg.trtl.BlockOpinionsByLayer[l3ID][l3Blocks[0].ID()])
+}
 
-	l2 := createTurtleLayer(context.TODO(), types.GetEffectiveGenesis().Add(2), mdb, alg.BaseBlock, getHareResults, 3)
-	require.NoError(t, AddLayer(mdb, l2))
-	alg.HandleIncomingLayer(l2)
+func TestLateBlocks(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	alg := defaultAlgorithm(t, mdb)
+	atxdb := getAtxDB()
+	alg.trtl.atxdb = atxdb
+
+	// process a bunch of layers normally
+	l0ID := types.GetEffectiveGenesis()
+	makeAndProcessLayer(t, l0ID.Add(1), alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(2), alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(3), alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(4), alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(5), alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(4))
+
+	// send some late blocks that are in the input vector
+	layerLate := l0ID.Add(2)
+	lyr := makeLayer(t, layerLate, alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), layerLate, lyr.BlocksIDs()))
+	oldVerified, newVerified := alg.HandleLateBlocks(context.TODO(), lyr.Blocks())
+	r.Equal(oldVerified, newVerified)
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(4))
+
+	// send some late blocks that are not in the input vector
+	lyr = makeLayer(t, layerLate, alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	oldVerified, newVerified = alg.HandleLateBlocks(context.TODO(), lyr.Blocks())
+	r.Equal(oldVerified, newVerified)
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(4))
+
+	// TODO: send enough valid late blocks to overwhelm verifying tortoise's opinion
+}
 
-	require.NoError(t, alg.Persist())
+func makeAtxHeaderWithWeight(weight uint) (mockAtxHeader *types.ActivationTxHeader) {
+	mockAtxHeader = &types.ActivationTxHeader{NIPostChallenge: types.NIPostChallenge{NodeID: types.NodeID{Key: "fakekey"}}}
+	mockAtxHeader.StartTick = 0
+	mockAtxHeader.EndTick = 1
+	mockAtxHeader.NumUnits = weight
+	return
+}
 
-	require.Equal(t, types.GetEffectiveGenesis().Add(1), alg.LatestComplete())
+func TestVoteWeight(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	totalSpace := 100
+	atxdb.mockAtxHeader = makeAtxHeaderWithWeight(uint(totalSpace))
+	someBlocks := generateBlocks(t, types.GetEffectiveGenesis().Add(1), 1, alg.BaseBlock, atxdb, 1)
+	weight, err := alg.trtl.voteWeight(context.TODO(), someBlocks[0])
+	r.NoError(err)
+	r.Equal(totalSpace, int(weight))
+}
 
-	l31 := createTurtleLayer(context.TODO(), types.GetEffectiveGenesis().Add(3), mdb, alg.BaseBlock, getHareResults, 4)
+func TestVoteWeightInOpinion(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	weight := uint(2)
+
+	// add one base block that votes for (genesis) base block with weight > 1
+	atxdb.mockAtxHeader = makeAtxHeaderWithWeight(weight)
+	genesisBlockID := mesh.GenesisBlock().ID()
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	makeAndProcessLayer(t, l1ID, alg.trtl, 1, atxdb, mdb, mdb.LayerBlockIds)
+	layerBlockIDs, err := mdb.LayerBlockIds(l1ID)
+	r.NoError(err)
+	r.Len(layerBlockIDs, 1)
+	blockID := layerBlockIDs[0]
+
+	// make sure opinion is set correctly
+	r.Equal(support.Multiply(uint64(weight)), alg.trtl.BlockOpinionsByLayer[l1ID][blockID].BlockOpinions[genesisBlockID])
+
+	// make sure the only exception added was for the base block itself
+	l2 := makeLayer(t, l1ID, alg.trtl, 1, atxdb, mdb, mdb.LayerBlockIds)
+	r.Len(l2.BlocksIDs(), 1)
+	l2Block := l2.Blocks()[0]
+	r.Len(l2Block.ForDiff, 1)
+	r.Equal(blockID, l2Block.ForDiff[0])
+}
 
-	l32 := createTurtleLayer(context.TODO(), types.GetEffectiveGenesis().Add(3), mdb, func(ctx context.Context) (types.BlockID, [][]types.BlockID, error) {
-		diffs := make([][]types.BlockID, 3)
-		diffs[0] = make([]types.BlockID, 0)
-		diffs[1] = types.BlockIDs(l.Blocks())
-		diffs[2] = make([]types.BlockID, 0)
+func TestProcessNewBlocks(t *testing.T) {
+	r := require.New(t)
 
-		return l31.Blocks()[0].ID(), diffs, nil
-	}, getHareResults, 5)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	l2ID := l1ID.Add(1)
+	l1Blocks := generateBlocks(t, l1ID, defaultTestLayerSize, alg.BaseBlock, atxdb, 1)
+	l2Blocks := generateBlocks(t, l2ID, defaultTestLayerSize, alg.BaseBlock, atxdb, 1)
 
-	defer func() {
-		if r := recover(); r != nil {
-			lg.Debug("Recovered from", r)
+	for _, block := range l1Blocks {
+		r.NoError(mdb.AddBlock(block))
+	}
+	mdb.InputVectorBackupFunc = mdb.LayerBlockIds
+
+	// empty input
+	r.Nil(alg.trtl.ProcessNewBlocks(context.TODO(), []*types.Block{}))
+
+	// input not sorted by layer
+	blocksOutOfOrder := []*types.Block{l2Blocks[0], l1Blocks[0]}
+	err := alg.trtl.ProcessNewBlocks(context.TODO(), blocksOutOfOrder)
+	r.Equal(errNotSorted, err)
+
+	// process some blocks: make sure opinions updated and block marked good
+	l1Blocks[0].ForDiff = []types.BlockID{l1Blocks[1].ID(), l1Blocks[2].ID()}
+	r.NoError(alg.trtl.ProcessNewBlocks(context.TODO(), []*types.Block{l1Blocks[0]}))
+	r.Contains(alg.trtl.BlockOpinionsByLayer, l1ID)
+	r.Contains(alg.trtl.BlockOpinionsByLayer[l1ID], l1Blocks[0].ID())
+	r.Equal(alg.trtl.BlockOpinionsByLayer[l1ID][l1Blocks[0].ID()], Opinion{BlockOpinions: map[types.BlockID]vec{
+		l1Blocks[1].ID(): support,
+		l1Blocks[2].ID(): support,
+	}})
+	r.Contains(alg.trtl.GoodBlocksIndex, l1Blocks[0].ID())
+	r.Equal(alg.trtl.GoodBlocksIndex[l1Blocks[0].ID()], struct{}{})
+
+	// base block opinion missing: input block should also not be marked good
+	l1Blocks[1].BaseBlock = l1Blocks[2].ID()
+	r.NoError(alg.trtl.ProcessNewBlocks(context.TODO(), []*types.Block{l1Blocks[1]}))
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[1].ID())
+
+	// base block not marked good: input block should also not be marked good
+	alg.trtl.BlockOpinionsByLayer[l1ID][l1Blocks[2].ID()] = Opinion{BlockOpinions: map[types.BlockID]vec{}}
+	l1Blocks[1].BaseBlock = l1Blocks[2].ID()
+	r.NoError(alg.trtl.ProcessNewBlocks(context.TODO(), []*types.Block{l1Blocks[1]}))
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[1].ID())
+
+	// base block not found
+	l1Blocks[2].BaseBlock = l2Blocks[0].ID()
+	r.NoError(alg.trtl.ProcessNewBlocks(context.TODO(), []*types.Block{l1Blocks[2]}))
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[2].ID())
+
+	// diffs appear before base block layer and/or are not consistent
+	// base block in L1 but this block contains a FOR vote for the genesis block in L0
+	l2Blocks[0].BaseBlock = l1Blocks[0].ID()
+	r.NoError(alg.trtl.ProcessNewBlocks(context.TODO(), []*types.Block{l2Blocks[0]}))
+	r.NotContains(alg.trtl.GoodBlocksIndex, l2Blocks[0].ID())
+
+	// test eviction
+	r.Equal(int(mesh.GenesisLayer().Index().Sub(1).Uint32()), int(alg.trtl.LastEvicted.Uint32()))
+	// move verified up a bunch to make sure eviction occurs
+	alg.trtl.Verified = types.GetEffectiveGenesis().Add(alg.trtl.Hdist).Add(alg.trtl.WindowSize)
+	r.Contains(alg.trtl.BlockOpinionsByLayer, l1ID)
+	r.Contains(alg.trtl.GoodBlocksIndex, l1Blocks[0].ID())
+	r.NoError(alg.trtl.ProcessNewBlocks(context.TODO(), []*types.Block{l2Blocks[0]}))
+	r.Equal(int(alg.trtl.Verified.Uint32())-int(alg.trtl.WindowSize)-1, int(alg.trtl.LastEvicted.Uint32()))
+	r.NotContains(alg.trtl.BlockOpinionsByLayer, l1ID)
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[0].ID())
+
+	// make sure we don't add data on blocks older than the eviction window
+	lenBefore := len(alg.trtl.GoodBlocksIndex)
+	r.NoError(alg.trtl.ProcessNewBlocks(context.TODO(), []*types.Block{l1Blocks[0]}))
+	r.Equal(lenBefore, len(alg.trtl.GoodBlocksIndex))
+	r.NotContains(alg.trtl.BlockOpinionsByLayer, l1ID)
+	r.NotContains(alg.trtl.GoodBlocksIndex, l1Blocks[0].ID())
+}
+
+func TestHandleLateBlocks(t *testing.T) {
+	//r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	l2ID := l1ID.Add(1)
+
+	// increase the layer size so a few blocks won't finalize a layer
+	testLayerSize := 10
+	alg.trtl.AvgLayerSize = testLayerSize
+	checkVerifiedLayer(t, alg.trtl, types.GetEffectiveGenesis())
+
+	// one good layer
+	makeAndProcessLayer(t, l1ID, alg.trtl, testLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	checkVerifiedLayer(t, alg.trtl, types.GetEffectiveGenesis())
+
+	// generate and handle a small number of blocks: should not be able to verify layer
+	makeAndProcessLayer(t, l2ID, alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	checkVerifiedLayer(t, alg.trtl, types.GetEffectiveGenesis())
+
+	// after late blocks arrive, verification should succeed
+	lyr := makeLayer(t, l2ID, alg.trtl, testLayerSize-defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	alg.HandleLateBlocks(context.TODO(), lyr.Blocks())
+	checkVerifiedLayer(t, alg.trtl, l1ID)
+}
+
+func TestVerifyLayers(t *testing.T) {
+	r := require.New(t)
+
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	l2ID := l1ID.Add(1)
+	l2Blocks := generateBlocks(t, l2ID, defaultTestLayerSize, alg.BaseBlock, atxdb, 1)
+	l3ID := l2ID.Add(1)
+	l3Blocks := generateBlocks(t, l3ID, defaultTestLayerSize, alg.BaseBlock, atxdb, 1)
+	l4ID := l3ID.Add(1)
+	l4Blocks := generateBlocks(t, l4ID, defaultTestLayerSize, alg.BaseBlock, atxdb, 1)
+	l5ID := l4ID.Add(1)
+	l5Blocks := generateBlocks(t, l5ID, defaultTestLayerSize, alg.BaseBlock, atxdb, 1)
+	l6ID := l5ID.Add(1)
+	l6Blocks := generateBlocks(t, l6ID, defaultTestLayerSize, alg.BaseBlock, atxdb, 1)
+
+	// layer missing in database
+	alg.trtl.Last = l2ID
+	err := alg.trtl.verifyLayers(context.TODO())
+	r.Error(err)
+	r.Contains(err.Error(), errstrCantFindLayer)
+
+	// empty layer: local opinion vector is nil, abstains on all blocks in layer
+	// no contextual validity data recorded
+	// layer should be verified
+	r.NoError(mdb.AddZeroBlockLayer(l1ID))
+
+	mdbWrapper := meshWrapper{
+		blockDataWriter: mdb,
+		saveContextualValidityFn: func(types.BlockID, types.LayerID, bool) error {
+			r.Fail("should not save contextual validity")
+			return nil
+		},
+	}
+	alg.trtl.bdp = mdbWrapper
+	err = alg.trtl.verifyLayers(context.TODO())
+	r.NoError(err)
+	r.Equal(int(l1ID.Uint32()), int(alg.trtl.Verified.Uint32()))
+
+	for _, block := range l2Blocks {
+		r.NoError(mdb.AddBlock(block))
+	}
+	// L3 blocks support all L2 blocks
+	l2SupportVec := Opinion{BlockOpinions: map[types.BlockID]vec{
+		l2Blocks[0].ID(): support,
+		l2Blocks[1].ID(): support,
+		l2Blocks[2].ID(): support,
+	}}
+	alg.trtl.BlockOpinionsByLayer[l3ID] = map[types.BlockID]Opinion{
+		l3Blocks[0].ID(): l2SupportVec,
+		l3Blocks[1].ID(): l2SupportVec,
+		l3Blocks[2].ID(): l2SupportVec,
+	}
+	alg.trtl.Last = l3ID
+
+	// voting blocks not marked good, both global and local opinion is abstain, verified layer does not advance
+	r.NoError(alg.trtl.verifyLayers(context.TODO()))
+	r.Equal(int(l1ID.Uint32()), int(alg.trtl.Verified.Uint32()))
+
+	// now mark voting blocks good
+	alg.trtl.GoodBlocksIndex[l3Blocks[0].ID()] = struct{}{}
+	alg.trtl.GoodBlocksIndex[l3Blocks[1].ID()] = struct{}{}
+	alg.trtl.GoodBlocksIndex[l3Blocks[2].ID()] = struct{}{}
+
+	var l2BlockIDs, l3BlockIDs, l4BlockIDs, l5BlockIDs []types.BlockID
+	for _, block := range l3Blocks {
+		r.NoError(mdb.AddBlock(block))
+		l3BlockIDs = append(l3BlockIDs, block.ID())
+	}
+
+	// consensus doesn't match: fail to verify candidate layer
+	// global opinion: good, local opinion: abstain
+	r.NoError(alg.trtl.verifyLayers(context.TODO()))
+	r.Equal(int(l1ID.Uint32()), int(alg.trtl.Verified.Uint32()))
+
+	// mark local opinion of L2 good so verified layer advances
+	// do the reverse for L3: local opinion is good, global opinion is undecided
+	for _, block := range l2Blocks {
+		l2BlockIDs = append(l2BlockIDs, block.ID())
+	}
+	mdbWrapper.inputVectorBackupFn = mdb.LayerBlockIds
+	mdbWrapper.saveContextualValidityFn = nil
+	alg.trtl.bdp = mdbWrapper
+	for _, block := range l4Blocks {
+		r.NoError(mdb.AddBlock(block))
+		l4BlockIDs = append(l4BlockIDs, block.ID())
+	}
+	for _, block := range l5Blocks {
+		r.NoError(mdb.AddBlock(block))
+		l5BlockIDs = append(l5BlockIDs, block.ID())
+	}
+	for _, block := range l6Blocks {
+		r.NoError(mdb.AddBlock(block))
+	}
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), l3ID, l3BlockIDs))
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), l4ID, l4BlockIDs))
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), l5ID, l5BlockIDs))
+	l4Votes := Opinion{BlockOpinions: map[types.BlockID]vec{
+		// support these so global opinion is support
+		l2Blocks[0].ID(): support,
+		l2Blocks[1].ID(): support,
+		l2Blocks[2].ID(): support,
+
+		// abstain
+		l3Blocks[0].ID(): abstain,
+		l3Blocks[1].ID(): abstain,
+		l3Blocks[2].ID(): abstain,
+	}}
+	alg.trtl.BlockOpinionsByLayer[l4ID] = map[types.BlockID]Opinion{
+		l4Blocks[0].ID(): l4Votes,
+		l4Blocks[1].ID(): l4Votes,
+		l4Blocks[2].ID(): l4Votes,
+	}
+	alg.trtl.Last = l4ID
+	alg.trtl.GoodBlocksIndex[l4Blocks[0].ID()] = struct{}{}
+	alg.trtl.GoodBlocksIndex[l4Blocks[1].ID()] = struct{}{}
+	alg.trtl.GoodBlocksIndex[l4Blocks[2].ID()] = struct{}{}
+	l5Votes := Opinion{BlockOpinions: map[types.BlockID]vec{
+		l2Blocks[0].ID(): support,
+		l2Blocks[1].ID(): support,
+		l2Blocks[2].ID(): support,
+		l3Blocks[0].ID(): abstain,
+		l3Blocks[1].ID(): abstain,
+		l3Blocks[2].ID(): abstain,
+		l4Blocks[0].ID(): support,
+		l4Blocks[1].ID(): support,
+		l4Blocks[2].ID(): support,
+	}}
+	alg.trtl.BlockOpinionsByLayer[l5ID] = map[types.BlockID]Opinion{
+		l5Blocks[0].ID(): l5Votes,
+		l5Blocks[1].ID(): l5Votes,
+		l5Blocks[2].ID(): l5Votes,
+	}
+	alg.trtl.GoodBlocksIndex[l5Blocks[0].ID()] = struct{}{}
+	alg.trtl.GoodBlocksIndex[l5Blocks[1].ID()] = struct{}{}
+	alg.trtl.GoodBlocksIndex[l5Blocks[2].ID()] = struct{}{}
+	l6Votes := Opinion{BlockOpinions: map[types.BlockID]vec{
+		l2Blocks[0].ID(): support,
+		l2Blocks[1].ID(): support,
+		l2Blocks[2].ID(): support,
+		l3Blocks[0].ID(): abstain,
+		l3Blocks[1].ID(): abstain,
+		l3Blocks[2].ID(): abstain,
+		l4Blocks[0].ID(): support,
+		l4Blocks[1].ID(): support,
+		l4Blocks[2].ID(): support,
+		l5Blocks[0].ID(): support,
+		l5Blocks[1].ID(): support,
+		l5Blocks[2].ID(): support,
+	}}
+	alg.trtl.BlockOpinionsByLayer[l6ID] = map[types.BlockID]Opinion{
+		l6Blocks[0].ID(): l6Votes,
+		l6Blocks[1].ID(): l6Votes,
+		l6Blocks[2].ID(): l6Votes,
+	}
+	alg.trtl.GoodBlocksIndex[l6Blocks[0].ID()] = struct{}{}
+	alg.trtl.GoodBlocksIndex[l6Blocks[1].ID()] = struct{}{}
+	alg.trtl.GoodBlocksIndex[l6Blocks[2].ID()] = struct{}{}
+
+	// verified layer advances one step, but L3 is not verified because global opinion is undecided, so verification
+	// stops there
+	t.Run("global opinion undecided", func(t *testing.T) {
+		err = alg.trtl.verifyLayers(context.TODO())
+		r.NoError(err)
+		r.Equal(int(l2ID.Uint32()), int(alg.trtl.Verified.Uint32()))
+	})
+
+	l4Votes = Opinion{BlockOpinions: map[types.BlockID]vec{
+		l2Blocks[0].ID(): support,
+		l2Blocks[1].ID(): support,
+		l2Blocks[2].ID(): support,
+
+		// change from abstain to support
+		l3Blocks[0].ID(): support,
+		l3Blocks[1].ID(): support,
+		l3Blocks[2].ID(): support,
+	}}
+
+	// weight not exceeded
+	t.Run("weight not exceeded", func(t *testing.T) {
+		// modify vote so one block votes in support of L3 blocks, two blocks continue to abstain, so threshold not met
+		alg.trtl.BlockOpinionsByLayer[l4ID][l4Blocks[0].ID()] = l4Votes
+		err = alg.trtl.verifyLayers(context.TODO())
+		r.NoError(err)
+		r.Equal(int(l2ID.Uint32()), int(alg.trtl.Verified.Uint32()))
+	})
+
+	t.Run("healing handoff", func(t *testing.T) {
+		// test self-healing: self-healing can verify layers that are stuck for specific reasons, i.e., where local and
+		// global opinion differ (or local opinion is missing).
+		alg.trtl.Hdist = 1
+		alg.trtl.Zdist = 1
+		alg.trtl.ConfidenceParam = 1
+
+		// add more votes in favor of l3 blocks
+		alg.trtl.BlockOpinionsByLayer[l4ID][l4Blocks[1].ID()] = l4Votes
+		alg.trtl.BlockOpinionsByLayer[l4ID][l4Blocks[2].ID()] = l4Votes
+		l5Votes := Opinion{BlockOpinions: map[types.BlockID]vec{
+			l2Blocks[0].ID(): support,
+			l2Blocks[1].ID(): support,
+			l2Blocks[2].ID(): support,
+			l3Blocks[0].ID(): support,
+			l3Blocks[1].ID(): support,
+			l3Blocks[2].ID(): support,
+			l4Blocks[0].ID(): support,
+			l4Blocks[1].ID(): support,
+			l4Blocks[2].ID(): support,
+		}}
+		alg.trtl.BlockOpinionsByLayer[l5ID] = map[types.BlockID]Opinion{
+			l5Blocks[0].ID(): l5Votes,
+			l5Blocks[1].ID(): l5Votes,
+			l5Blocks[2].ID(): l5Votes,
+		}
+		l6Votes := Opinion{BlockOpinions: map[types.BlockID]vec{
+			l2Blocks[0].ID(): support,
+			l2Blocks[1].ID(): support,
+			l2Blocks[2].ID(): support,
+			l3Blocks[0].ID(): support,
+			l3Blocks[1].ID(): support,
+			l3Blocks[2].ID(): support,
+			l4Blocks[0].ID(): support,
+			l4Blocks[1].ID(): support,
+			l4Blocks[2].ID(): support,
+			l5Blocks[0].ID(): support,
+			l5Blocks[1].ID(): support,
+			l5Blocks[2].ID(): support,
+		}}
+		alg.trtl.BlockOpinionsByLayer[l6ID] = map[types.BlockID]Opinion{
+			l6Blocks[0].ID(): l6Votes,
+			l6Blocks[1].ID(): l6Votes,
+			l6Blocks[2].ID(): l6Votes,
+		}
+
+		// simulate a layer that's older than the LayerCutoff, and older than Zdist+ConfidenceParam, but not verified,
+		// that has no contextually valid blocks in the database. this should trigger self-healing.
+
+		// perform some surgery: erase just enough good blocks data so that ordinary tortoise verification fails for
+		// one layer, triggering self-healing, but leave enough good blocks data so that ordinary tortoise can
+		// subsequently verify a later layer after self-healing has finished. this works because self-healing does not
+		// rely on local data, including the set of good blocks.
+		delete(alg.trtl.GoodBlocksIndex, l4Blocks[0].ID())
+		delete(alg.trtl.GoodBlocksIndex, l4Blocks[1].ID())
+		delete(alg.trtl.GoodBlocksIndex, l4Blocks[2].ID())
+		delete(alg.trtl.GoodBlocksIndex, l5Blocks[0].ID())
+
+		// self-healing should advance verification two steps, over the
+		// previously stuck layer (l3) and the following layer (l4) since it's old enough, then hand control back to the
+		// ordinary verifying tortoise which should continue and verify l5.
+		alg.trtl.Last = l4ID.Add(alg.trtl.Hdist + 1)
+		r.NoError(alg.trtl.verifyLayers(context.TODO()))
+		r.Equal(int(l5ID.Uint32()), int(alg.trtl.Verified.Uint32()))
+	})
+}
+
+func TestVoteVectorForLayer(t *testing.T) {
+	r := require.New(t)
+
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	l1Blocks := generateBlocks(t, l1ID, 3, alg.BaseBlock, atxdb, 1)
+	var blockIDs []types.BlockID
+	for _, block := range l1Blocks {
+		blockIDs = append(blockIDs, block.ID())
+	}
+
+	// empty input: expect empty output
+	emptyVec := make([]types.BlockID, 0, 0)
+	voteMap := alg.trtl.voteVectorForLayer(emptyVec, emptyVec)
+	r.Equal(map[types.BlockID]vec{}, voteMap)
+
+	// nil input vector: abstain on all blocks in layer
+	voteMap = alg.trtl.voteVectorForLayer(blockIDs, nil)
+	r.Len(blockIDs, 3)
+	r.Equal(map[types.BlockID]vec{
+		blockIDs[0]: abstain,
+		blockIDs[1]: abstain,
+		blockIDs[2]: abstain,
+	}, voteMap)
+
+	// empty input vector: vote against everything
+	voteMap = alg.trtl.voteVectorForLayer(blockIDs, make([]types.BlockID, 0, 0))
+	r.Len(blockIDs, 3)
+	r.Equal(map[types.BlockID]vec{
+		blockIDs[0]: against,
+		blockIDs[1]: against,
+		blockIDs[2]: against,
+	}, voteMap)
+
+	// adds support for blocks in input vector
+	voteMap = alg.trtl.voteVectorForLayer(blockIDs, blockIDs[1:])
+	r.Len(blockIDs, 3)
+	r.Equal(map[types.BlockID]vec{
+		blockIDs[0]: against,
+		blockIDs[1]: support,
+		blockIDs[2]: support,
+	}, voteMap)
+}
+
+func TestSumVotesForBlock(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+
+	// store a bunch of votes against a block
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	l1Blocks := generateBlocks(t, l1ID, 4, alg.BaseBlock, atxdb, 1)
+	for _, block := range l1Blocks {
+		r.NoError(mdb.AddBlock(block))
+	}
+	blockWeReallyDislike := l1Blocks[0]
+	blockWeReallyLike := l1Blocks[1]
+	blockWeReallyDontCare := l1Blocks[2]
+	blockWeNeverSaw := l1Blocks[3]
+	l2ID := l1ID.Add(1)
+	l2Blocks := generateBlocks(t, l2ID, 9, alg.BaseBlock, atxdb, 1)
+	for _, block := range l2Blocks {
+		r.NoError(mdb.AddBlock(block))
+	}
+	alg.trtl.BlockOpinionsByLayer[l2ID] = map[types.BlockID]Opinion{
+		l2Blocks[0].ID(): {BlockOpinions: map[types.BlockID]vec{blockWeReallyDislike.ID(): against}},
+		l2Blocks[1].ID(): {BlockOpinions: map[types.BlockID]vec{blockWeReallyDislike.ID(): against}},
+		l2Blocks[2].ID(): {BlockOpinions: map[types.BlockID]vec{blockWeReallyDislike.ID(): against}},
+	}
+
+	// test filter
+	filterPassAll := func(types.BlockID) bool { return true }
+	filterRejectAll := func(types.BlockID) bool { return false }
+
+	// if we reject all blocks, we expect an abstain outcome
+	alg.trtl.Last = l2ID
+	sum, err := alg.trtl.sumVotesForBlock(context.TODO(), blockWeReallyDislike.ID(), l2ID, filterRejectAll)
+	r.NoError(err)
+	r.Equal(abstain, sum)
+
+	// if we allow all blocks to vote, we expect an against outcome
+	sum, err = alg.trtl.sumVotesForBlock(context.TODO(), blockWeReallyDislike.ID(), l2ID, filterPassAll)
+	r.NoError(err)
+	r.Equal(against.Multiply(3), sum)
+
+	// add more blocks
+	alg.trtl.BlockOpinionsByLayer[l2ID] = map[types.BlockID]Opinion{
+		l2Blocks[0].ID(): {BlockOpinions: map[types.BlockID]vec{blockWeReallyDislike.ID(): against}},
+		l2Blocks[1].ID(): {BlockOpinions: map[types.BlockID]vec{blockWeReallyDislike.ID(): against}},
+		l2Blocks[2].ID(): {BlockOpinions: map[types.BlockID]vec{blockWeReallyDislike.ID(): against}},
+		l2Blocks[3].ID(): {BlockOpinions: map[types.BlockID]vec{blockWeReallyLike.ID(): support}},
+		l2Blocks[4].ID(): {BlockOpinions: map[types.BlockID]vec{blockWeReallyLike.ID(): support}},
+		l2Blocks[5].ID(): {BlockOpinions: map[types.BlockID]vec{blockWeReallyDontCare.ID(): abstain}},
+		l2Blocks[6].ID(): {BlockOpinions: map[types.BlockID]vec{}},
+		l2Blocks[7].ID(): {BlockOpinions: map[types.BlockID]vec{}},
+		l2Blocks[8].ID(): {BlockOpinions: map[types.BlockID]vec{}},
+	}
+	// some blocks explicitly vote against, others have no opinion
+	sum, err = alg.trtl.sumVotesForBlock(context.TODO(), blockWeReallyDislike.ID(), l2ID, filterPassAll)
+	r.NoError(err)
+	r.Equal(against.Multiply(9), sum)
+	// some blocks vote for, others have no opinion
+	sum, err = alg.trtl.sumVotesForBlock(context.TODO(), blockWeReallyLike.ID(), l2ID, filterPassAll)
+	r.NoError(err)
+	r.Equal(support.Multiply(2).Add(against.Multiply(7)), sum)
+	// one block votes neutral, others have no opinion
+	sum, err = alg.trtl.sumVotesForBlock(context.TODO(), blockWeReallyDontCare.ID(), l2ID, filterPassAll)
+	r.NoError(err)
+	r.Equal(abstain.Multiply(1).Add(against.Multiply(8)), sum)
+
+	// vote missing: counts against
+	sum, err = alg.trtl.sumVotesForBlock(context.TODO(), blockWeNeverSaw.ID(), l2ID, filterPassAll)
+	r.NoError(err)
+	r.Equal(against.Multiply(9), sum)
+}
+
+func TestSumWeightedVotesForBlock(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	numBlocks := 5
+	genesisBlockID := mesh.GenesisBlock().ID()
+	l1ID := types.GetEffectiveGenesis().Add(1)
+	filterPassAll := func(types.BlockID) bool { return true }
+
+	// use the same base block for all newly-created blocks
+	b, lists, err := alg.BaseBlock(context.TODO())
+	r.NoError(err)
+	bbp := func(context.Context) (types.BlockID, [][]types.BlockID, error) {
+		return b, lists, nil
+	}
+
+	// create several voting blocks with different weights
+	netWeight := uint(0)
+	for i := 0; i < numBlocks; i++ {
+		thisWeight := uint(1) << i
+		netWeight += thisWeight
+		block := generateBlock(t, l1ID, bbp, atxdb, thisWeight)
+		r.NoError(mdb.AddBlock(block))
+
+		// update t.Last and process block votes
+		r.NoError(alg.trtl.handleLayerBlocks(context.TODO(), l1ID))
+
+		// check
+		sum, err := alg.trtl.sumVotesForBlock(context.TODO(), genesisBlockID, l1ID, filterPassAll)
+		r.NoError(err)
+		r.Equal(int(netWeight), int(sum.netVote()))
+	}
+}
+
+func checkVerifiedLayer(t *testing.T, trtl *turtle, layerID types.LayerID) {
+	require.Equal(t, int(layerID.Uint32()), int(trtl.Verified.Uint32()), "got unexpected value for last verified layer")
+}
+
+func TestHealing(t *testing.T) {
+	r := require.New(t)
+
+	mdb := getInMemMesh(t)
+	alg := defaultAlgorithm(t, mdb)
+
+	l0ID := types.GetEffectiveGenesis()
+	l1ID := l0ID.Add(1)
+	l2ID := l1ID.Add(1)
+
+	// don't attempt to heal recent layers
+	t.Run("don't heal recent layers", func(t *testing.T) {
+		checkVerifiedLayer(t, alg.trtl, l0ID)
+
+		// while bootstrapping there should be no healing
+		alg.trtl.heal(context.TODO(), l2ID)
+		checkVerifiedLayer(t, alg.trtl, l0ID)
+
+		// later, healing should not occur on layers not at least Hdist back
+		alg.trtl.Last = types.NewLayerID(alg.trtl.Hdist + 1)
+		alg.trtl.heal(context.TODO(), l2ID)
+		checkVerifiedLayer(t, alg.trtl, l0ID)
+	})
+
+	alg.trtl.Last = l0ID
+	atxdb := getAtxDB()
+	alg.trtl.atxdb = atxdb
+	l1 := makeLayer(t, l1ID, alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	l2 := makeLayer(t, l2ID, alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+
+	// healing should work even when there is no local opinion on a layer (i.e., no output vector, while waiting
+	// for hare results)
+	t.Run("does not depend on local opinion", func(t *testing.T) {
+		checkVerifiedLayer(t, alg.trtl, l0ID)
+		r.NoError(alg.trtl.HandleIncomingLayer(context.TODO(), l1ID))
+		r.NoError(alg.trtl.HandleIncomingLayer(context.TODO(), l2ID))
+
+		// reducing hdist will allow verification to start happening
+		alg.trtl.Hdist = 1
+		//alg.trtl.Last = l2ID
+		alg.trtl.heal(context.TODO(), l2ID)
+		checkVerifiedLayer(t, alg.trtl, l1ID)
+	})
+
+	l3ID := l2ID.Add(1)
+
+	// can heal when global and local opinion differ
+	t.Run("local and global opinions differ", func(t *testing.T) {
+		checkVerifiedLayer(t, alg.trtl, l1ID)
+
+		// store input vector for already-processed layers
+		var l1BlockIDs, l2BlockIDs []types.BlockID
+		for _, block := range l1.Blocks() {
+			l1BlockIDs = append(l1BlockIDs, block.ID())
+		}
+		for _, block := range l2.Blocks() {
+			l2BlockIDs = append(l2BlockIDs, block.ID())
+		}
+		require.NoError(t, mdb.SaveLayerInputVectorByID(context.TODO(), l1ID, l1BlockIDs))
+		require.NoError(t, mdb.SaveLayerInputVectorByID(context.TODO(), l2ID, l2BlockIDs))
+
+		// then create and process one more new layer
+		// prevent base block from referencing earlier (approved) layers
+		alg.trtl.Last = l0ID
+		makeLayer(t, l3ID, alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+		require.NoError(t, alg.trtl.HandleIncomingLayer(context.TODO(), l3ID))
+
+		// make sure local opinion supports L2
+		layerInputVector, err := alg.trtl.layerOpinionVector(context.TODO(), l2ID)
+		r.NoError(err)
+		localOpinionVec := alg.trtl.voteVectorForLayer(l2BlockIDs, layerInputVector)
+		for _, bid := range l2BlockIDs {
+			r.Contains(localOpinionVec, bid)
+			r.Equal(support, localOpinionVec[bid])
 		}
-		alg := recoveredVerifyingTortoise(mdb, lg)
 
-		alg.HandleIncomingLayer(l2)
+		alg.trtl.heal(context.TODO(), l3ID)
+		checkVerifiedLayer(t, alg.trtl, l2ID)
 
-		l3 := createTurtleLayer(context.TODO(), types.GetEffectiveGenesis().Add(3), mdb, alg.BaseBlock, getHareResults, 3)
-		AddLayer(mdb, l3)
-		alg.HandleIncomingLayer(l3)
-		alg.Persist()
+		// make sure contextual validity is updated
+		for _, bid := range l2BlockIDs {
+			valid, err := mdb.ContextualValidity(bid)
+			r.NoError(err)
+			// global opinion should be against all of the blocks in this layer since blocks in subsequent
+			// layers don't vote for them
+			r.False(valid)
+		}
+	})
 
-		l4 := createTurtleLayer(context.TODO(), types.GetEffectiveGenesis().Add(4), mdb, alg.BaseBlock, getHareResults, 3)
-		AddLayer(mdb, l4)
-		alg.HandleIncomingLayer(l4)
-		alg.Persist()
-		assert.True(t, alg.LatestComplete() == types.GetEffectiveGenesis().Add(3))
+	l4ID := l3ID.Add(1)
 
-		require.NoError(t, teardown())
+	// healing should count votes of non-good blocks
+	t.Run("counts votes of non-good blocks", func(t *testing.T) {
+		checkVerifiedLayer(t, alg.trtl, l2ID)
 
-	}()
+		// create and process several more layers
+		// but don't save layer input vectors, so local opinion is abstain
+		makeLayer(t, l4ID, alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+		require.NoError(t, alg.trtl.HandleIncomingLayer(context.TODO(), l4ID))
+
+		// delete good blocks data
+		alg.trtl.GoodBlocksIndex = make(map[types.BlockID]struct{}, 0)
+
+		alg.trtl.heal(context.TODO(), l4ID)
+		checkVerifiedLayer(t, alg.trtl, l3ID)
+	})
+}
+
+// can heal when half of votes are missing (doesn't meet threshold)
+// this requires waiting an epoch or two before the active set size is reduced enough to cross the threshold
+// see https://github.com/spacemeshos/go-spacemesh/issues/2497 for an idea about making this faster
+func TestHealingAfterPartition(t *testing.T) {
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	l0ID := types.GetEffectiveGenesis()
+
+	// use a larger number of blocks per layer to give us more scope for testing
+	goodLayerSize := defaultTestLayerSize * 10
+	alg.trtl.AvgLayerSize = goodLayerSize
+
+	// create several good layers
+	makeAndProcessLayer(t, l0ID.Add(1), alg.trtl, goodLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(2), alg.trtl, goodLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(3), alg.trtl, goodLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(4), alg.trtl, goodLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(5), alg.trtl, goodLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(4))
+
+	// create a few layers with half the number of blocks
+	makeAndProcessLayer(t, l0ID.Add(6), alg.trtl, goodLayerSize/2, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(7), alg.trtl, goodLayerSize/2, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(8), alg.trtl, goodLayerSize/2, atxdb, mdb, mdb.LayerBlockIds)
+
+	// verification should fail, global opinion should be abstain since not enough votes
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(4))
+
+	// once we start receiving full layers again, verification should restart immediately. this scenario doesn't
+	// actually require healing, since local and global opinions are the same, and the threshold is just > 1/2.
+	makeAndProcessLayer(t, l0ID.Add(9), alg.trtl, goodLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(8))
+
+	// then we start receiving fewer blocks again
+	for i := 0; types.NewLayerID(uint32(i)).Before(types.NewLayerID(alg.trtl.Zdist + alg.trtl.ConfidenceParam)); i++ {
+		makeAndProcessLayer(t, l0ID.Add(10+uint32(i)), alg.trtl, goodLayerSize/2, atxdb, mdb, mdb.LayerBlockIds)
+	}
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(8))
+
+	// healing would begin here, but without enough blocks to accumulate votes to cross the global threshold, we're
+	// effectively stuck (until, in practice, active set size would be reduced in a following epoch and the remaining
+	// miners would produce more blocks--this is tested in the app tests)
+	firstHealedLayer := l0ID.Add(10 + uint32(alg.trtl.Zdist+alg.trtl.ConfidenceParam))
+	makeAndProcessLayer(t, firstHealedLayer, alg.trtl, goodLayerSize/2, atxdb, mdb, mdb.LayerBlockIds)
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(8))
+}
+
+func TestRerunAndRevert(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	mdb.InputVectorBackupFunc = mdb.LayerBlockIds
+
+	// process a couple of layers
+	l0ID := types.GetEffectiveGenesis()
+	l1ID := l0ID.Add(1)
+	l2ID := l1ID.Add(1)
+	makeLayer(t, l1ID, alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	l1IDs, err := mdb.LayerBlockIds(l1ID)
+	r.NoError(err)
+	block1ID := l1IDs[0]
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), l1ID, l1IDs))
+	alg.HandleIncomingLayer(context.TODO(), l1ID)
+	makeLayer(t, l2ID, alg.trtl, defaultTestLayerSize, atxdb, mdb, mdb.LayerBlockIds)
+	l2IDs, err := mdb.LayerBlockIds(l2ID)
+	r.NoError(err)
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), l2ID, l2IDs))
+	oldVerified, newVerified, reverted := alg.HandleIncomingLayer(context.TODO(), l2ID)
+	r.Equal(int(l0ID.Uint32()), int(oldVerified.Uint32()))
+	r.Equal(int(l1ID.Uint32()), int(newVerified.Uint32()))
+	r.False(reverted)
+	r.Equal(int(l1ID.Uint32()), int(alg.trtl.Verified.Uint32()))
+	isValid, err := mdb.ContextualValidity(block1ID)
+	r.NoError(err)
+	r.True(isValid)
+
+	// now change some state so that the opinion on layer/block validity changes
+
+	// local opinion
+	mdb.InputVectorBackupFunc = func(types.LayerID) ([]types.BlockID, error) {
+		// empty slice means vote against all
+		return []types.BlockID{}, nil
+	}
+
+	// global opinion: add a bunch of blocks that vote against l1 blocks
+	// for these blocks to be good, they must have an old base block, since they'll get exception votes on
+	// more recent blocks
+	baseBlockFn := func(ctx context.Context) (types.BlockID, [][]types.BlockID, error) {
+		return mesh.GenesisBlock().ID(), [][]types.BlockID{nil, nil, nil}, nil
+	}
+	l2 := createTurtleLayer(t, l2ID, mdb, atxdb, baseBlockFn, mdb.LayerBlockIds, defaultTestLayerSize*3)
+	for _, block := range l2.Blocks() {
+		r.NoError(mdb.AddBlock(block))
+	}
+
+	// force a rerun and make sure there was a reversion
+	alg.lastRerun = time.Now().Add(-alg.trtl.RerunInterval)
+	oldVerified, newVerified, reverted = alg.HandleIncomingLayer(context.TODO(), l2ID)
+	r.Equal(int(l1ID.Uint32()), int(oldVerified.Uint32()))
+	r.Equal(int(l1ID.Uint32()), int(newVerified.Uint32()))
+	r.True(reverted)
+	r.Equal(int(l1ID.Uint32()), int(alg.trtl.Verified.Uint32()))
+	isValid, err = mdb.ContextualValidity(block1ID)
+	r.NoError(err)
+	r.False(isValid)
+}
+
+func TestHealBalanceAttack(t *testing.T) {
+	r := require.New(t)
+	mdb := getInMemMesh(t)
+	atxdb := getAtxDB()
+	alg := defaultAlgorithm(t, mdb)
+	alg.trtl.atxdb = atxdb
+	l0ID := types.GetEffectiveGenesis()
+	layerSize := 4
+	l4ID := l0ID.Add(4)
+	l5ID := l4ID.Add(1)
+
+	// create several good layers and make sure verified layer advances
+	makeAndProcessLayer(t, l0ID.Add(1), alg.trtl, layerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(2), alg.trtl, layerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l0ID.Add(3), alg.trtl, layerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeAndProcessLayer(t, l4ID, alg.trtl, layerSize, atxdb, mdb, mdb.LayerBlockIds)
+	makeLayer(t, l5ID, alg.trtl, layerSize, atxdb, mdb, mdb.LayerBlockIds)
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(3))
+
+	// everyone will agree on the validity of these blocks
+	l5blockIDs, err := mdb.LayerBlockIds(l5ID)
+	r.NoError(err)
+	l5BaseBlock1 := l5blockIDs[0]
+	l5BaseBlock2 := l5blockIDs[1]
+
+	// opinions will differ about the validity of this block
+	// note: we are NOT adding it to the layer input vector, so this node thinks the block is invalid (late)
+	// this means that later blocks/layers with a base block or vote that supports this block will not be marked good
+	l4lateblock := generateBlocks(t, l4ID, 1, alg.BaseBlock, atxdb, 1)[0]
+	r.NoError(mdb.AddBlock(l4lateblock))
+
+	// this primes the block opinions for these blocks, without attempting to verify the previous layer
+	r.NoError(alg.trtl.handleLayerBlocks(context.TODO(), l5ID))
+
+	// make one of the base blocks support it, and make one vote against it. note: these base blocks have already been
+	// marked good. this means that blocks that use one of these as a base block will also be marked good (as long as
+	// they don't add explicit exception votes for or against the late block).
+	alg.trtl.BlockOpinionsByLayer[l5ID][l5BaseBlock1].BlockOpinions[l4lateblock.ID()] = support
+	alg.trtl.BlockOpinionsByLayer[l5ID][l5BaseBlock2].BlockOpinions[l4lateblock.ID()] = against
+	alg.trtl.BlockOpinionsByLayer[l5ID][l5blockIDs[2]].BlockOpinions[l4lateblock.ID()] = support
+	alg.trtl.BlockOpinionsByLayer[l5ID][l5blockIDs[3]].BlockOpinions[l4lateblock.ID()] = against
+
+	// now process l5
+	r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), l5ID, l5blockIDs))
+	r.NoError(alg.trtl.verifyLayers(context.TODO()))
+	checkVerifiedLayer(t, alg.trtl, l0ID.Add(3))
+
+	// we can trick calculateExceptions into not adding explicit exception votes for or against this block by
+	// making it think we've already evicted its layer
+	// basically, this is a shortcut: it lets us be lazy and just use our tortoise instance's calculateExceptions
+	// method to fill in the exceptions for later layers, but not make every new block vote for or against the
+	// late block (based on local opinion). without this, we'd need to override that method, too, and manually
+	// generate the exceptions list.
+	// TODO: but, eventually, when it's old enough, we do need exceptions to be added so healing can happen
+	alg.trtl.LastEvicted = l4ID
+
+	counter := 0
+	bbp := func(context.Context) (types.BlockID, [][]types.BlockID, error) {
+		defer func() { counter++ }()
+
+		// half the time, return a base block that supports the late block
+		// half the time, return one that does not support it
+		var baseBlockID types.BlockID
+		if counter%2 == 0 {
+			baseBlockID = l5BaseBlock1
+		} else {
+			baseBlockID = l5BaseBlock2
+		}
+
+		evm, err := alg.trtl.calculateExceptions(context.TODO(), l5ID, alg.trtl.BlockOpinionsByLayer[l5ID][baseBlockID])
+		r.NoError(err)
+		return baseBlockID, [][]types.BlockID{
+			blockMapToArray(evm[0]),
+			blockMapToArray(evm[1]),
+			blockMapToArray(evm[2]),
+		}, nil
+	}
+
+	// create a series of layers, each with half of blocks supporting and half against this block
+	healingDistance := alg.trtl.Zdist + alg.trtl.ConfidenceParam
+
+	// check our assumptions: local opinion will be disregarded after Hdist layers, which is also when healing
+	// should kick in
+	r.Equal(int(alg.trtl.Hdist), int(healingDistance))
+	lastUnhealedLayer := l0ID.Add(6 + uint32(healingDistance))
+
+	// note: a single coinflip will do it. it's only needed once, for one layer before the candidate layer that
+	// first counts votes in order to determine the local opinion on the layer with the late block. once the local
+	// opinion has been established, blocks will immediately begin explicitly voting for or against the block, and
+	// the local opinion will no longer be abstain.
+	mdb.RecordCoinflip(context.TODO(), lastUnhealedLayer.Sub(2), true)
+
+	// after healing begins, we need a few more layers until the global opinion of the block passes the threshold
+	finalLayer := lastUnhealedLayer.Add(9)
+
+	for layerID := l0ID.Add(6); !layerID.After(finalLayer); layerID = layerID.Add(1) {
+		// allow exceptions to be added again after this distance
+		if layerID == lastUnhealedLayer {
+			alg.trtl.LastEvicted = l0ID.Add(3)
+		}
 
-	alg.HandleIncomingLayer(l32) //crash
+		// half of blocks use a base block that supports the late block
+		// half use a base block that doesn't support it
+		for j := 0; j < 2; j++ {
+			blocks := generateBlocks(t, layerID, layerSize/2, bbp, atxdb, 1)
+			for _, block := range blocks {
+				r.NoError(mdb.AddBlock(block))
+			}
+		}
+
+		blockIDs, err := mdb.LayerBlockIds(layerID)
+		r.NoError(err)
+		r.NoError(mdb.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+		r.NoError(alg.trtl.HandleIncomingLayer(context.TODO(), layerID))
+	}
+	checkVerifiedLayer(t, alg.trtl, finalLayer.Sub(1))
+
+	// layer validity should match recent coinflip value
+	valid, err := mdb.ContextualValidity(l4lateblock.ID())
+	r.NoError(err)
+	r.Equal(true, valid)
+}
+
+func TestVectorArithmetic(t *testing.T) {
+	r := require.New(t)
+	r.Equal(abstain, abstain.Add(abstain))
+	r.Equal(support, abstain.Add(support))
+	r.Equal(support, support.Add(abstain))
+	r.Equal(against, abstain.Add(against))
+	r.Equal(against, against.Add(abstain))
+	r.Equal(vec{1, 1}, against.Add(support))
+	r.Equal(abstain, simplifyVote(against.Add(support)))
+	r.Equal(vec{1, 1}, support.Add(against))
+	r.Equal(abstain, simplifyVote(support.Add(against)))
+	r.Equal(support, simplifyVote(support.Add(support)))
+	r.Equal(against, simplifyVote(against.Add(against)))
+	r.Equal(support, simplifyVote(vec{100, 10}))
+	r.Equal(against, simplifyVote(vec{10, 100}))
+	r.Equal(abstain, simplifyVote(abstain))
+	r.Equal(abstain, abstain.Multiply(1))
+	r.Equal(support, support.Multiply(1))
+	r.Equal(against, against.Multiply(1))
+	r.Equal(abstain, abstain.Multiply(0))
+	r.Equal(abstain, support.Multiply(0))
+	r.Equal(abstain, against.Multiply(0))
+	r.Equal(support.Add(abstain), abstain.Add(support))
+	r.Equal(against.Add(abstain), abstain.Add(against))
+	r.Equal(support.Multiply(2), support.Add(support))
+	r.Equal(against.Multiply(2), against.Add(against))
+
+	// test wraparound
+	bigVec := vec{math.MaxUint64, math.MaxUint64}
+	r.NotPanics(func() { bigVec.Add(abstain) })
+	r.NotPanics(func() { abstain.Add(bigVec) })
+	r.PanicsWithError(errOverflow.Error(), func() { bigVec.Add(support) })
+	r.PanicsWithError(errOverflow.Error(), func() { support.Add(bigVec) })
+	r.NotPanics(func() { bigVec.Multiply(0) })
+	r.NotPanics(func() { bigVec.Multiply(1) })
+	r.PanicsWithError(errOverflow.Error(), func() { bigVec.Multiply(2) })
+	r.NotPanics(func() { support.Multiply(math.MaxUint64) })
+	r.PanicsWithError(errOverflow.Error(), func() { support.Add(support).Multiply(math.MaxUint64) })
+
+	// test netvote
+	r.Equal(int64(0), abstain.netVote())
+	r.Equal(int64(1), support.netVote())
+	r.Equal(int64(-1), against.netVote())
+	r.Equal(int64(0), support.Add(against).netVote())
+	r.Equal(int64(10), vec{25, 15}.netVote())
+	r.Equal(int64(-10), vec{15, 25}.netVote())
+	r.NotPanics(func() { vec{math.MaxInt64, 0}.netVote() })
+	r.NotPanics(func() { vec{0, math.MaxInt64}.netVote() })
+	r.PanicsWithError(errOverflow.Error(), func() { bigVec.netVote() })
+	r.PanicsWithError(errOverflow.Error(), func() { vec{0, math.MaxUint64}.netVote() })
+	r.PanicsWithError(errOverflow.Error(), func() { vec{0, math.MaxInt64 + 1}.netVote() })
+	r.PanicsWithError(errOverflow.Error(), func() { vec{math.MaxInt64 + 1, 0}.netVote() })
+	r.Equal(int64(math.MaxInt64), vec{math.MaxInt64, 0}.netVote())
+	r.Equal(int64(-math.MaxInt64), vec{0, math.MaxInt64}.netVote())
+}
+
+func TestCalculateOpinionWithThreshold(t *testing.T) {
+	r := require.New(t)
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, abstain, 1, 1, 1))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, abstain, 10, 1, 1))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, abstain, 1, 10, 1))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, abstain, 1, 1, 10))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, abstain, 1, 10, 10))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, abstain, 10, 10, 1))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, abstain, 10, 1, 10))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, abstain, 10, 10, 10))
+	r.Equal(support, calculateOpinionWithThreshold(log.AppLog, support.Multiply(10), 1, 1, 1))
+	r.Equal(support, calculateOpinionWithThreshold(log.AppLog, support.Multiply(10), 10, 1, 1))
+	r.Equal(support, calculateOpinionWithThreshold(log.AppLog, support.Multiply(10), 1, 10, 1))
+	r.Equal(support, calculateOpinionWithThreshold(log.AppLog, support.Multiply(10), 1, 1, 10))
+	r.Equal(support, calculateOpinionWithThreshold(log.AppLog, support.Multiply(10), 10, 1, 10))
+	r.Equal(support, calculateOpinionWithThreshold(log.AppLog, support.Multiply(10), 10, 10, 1))
+	r.Equal(support, calculateOpinionWithThreshold(log.AppLog, support.Multiply(10), 1, 10, 10))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, support.Multiply(10), 10, 10, 10))
+	r.Equal(support, calculateOpinionWithThreshold(log.AppLog, support.Multiply(11), 10, 10, 10))
+	r.Equal(against, calculateOpinionWithThreshold(log.AppLog, against.Multiply(10), 1, 1, 1))
+	r.Equal(against, calculateOpinionWithThreshold(log.AppLog, against.Multiply(10), 10, 1, 1))
+	r.Equal(against, calculateOpinionWithThreshold(log.AppLog, against.Multiply(10), 1, 10, 1))
+	r.Equal(against, calculateOpinionWithThreshold(log.AppLog, against.Multiply(10), 1, 1, 10))
+	r.Equal(against, calculateOpinionWithThreshold(log.AppLog, against.Multiply(10), 10, 1, 10))
+	r.Equal(against, calculateOpinionWithThreshold(log.AppLog, against.Multiply(10), 10, 10, 1))
+	r.Equal(against, calculateOpinionWithThreshold(log.AppLog, against.Multiply(10), 1, 10, 10))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, against.Multiply(10), 10, 10, 10))
+	r.Equal(against, calculateOpinionWithThreshold(log.AppLog, against.Multiply(11), 10, 10, 10))
+
+	// a more realistic example
+	r.Equal(support, calculateOpinionWithThreshold(log.AppLog, vec{72, 9}, defaultTestLayerSize, defaultTestGlobalThreshold, 3))
+	r.Equal(abstain, calculateOpinionWithThreshold(log.AppLog, vec{12, 9}, defaultTestLayerSize, defaultTestGlobalThreshold, 3))
+	r.Equal(against, calculateOpinionWithThreshold(log.AppLog, vec{9, 18}, defaultTestLayerSize, defaultTestGlobalThreshold, 3))
+}
+
+func TestMultiTortoise(t *testing.T) {
+	r := require.New(t)
+
+	t.Run("happy path", func(t *testing.T) {
+		layerSize := defaultTestLayerSize * 2
+
+		mdb1 := getInMemMesh(t)
+		atxdb1 := getAtxDB()
+		alg1 := defaultAlgorithm(t, mdb1)
+		alg1.trtl.atxdb = atxdb1
+		alg1.trtl.AvgLayerSize = layerSize
+		alg1.logger = alg1.logger.Named("trtl1")
+		alg1.trtl.logger = alg1.logger
+
+		mdb2 := getInMemMesh(t)
+		atxdb2 := getAtxDB()
+		alg2 := defaultAlgorithm(t, mdb2)
+		alg2.trtl.atxdb = atxdb2
+		alg2.trtl.AvgLayerSize = layerSize
+		alg2.logger = alg2.logger.Named("trtl2")
+		alg2.trtl.logger = alg2.logger
+
+		makeAndProcessLayerMultiTortoise := func(layerID types.LayerID) {
+			// simulate producing blocks in parallel
+			blocksA := generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+			blocksB := generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+
+			// these will produce identical sets of blocks, so throw away half of each
+			// (we could probably get away with just using, say, A's blocks, but to be more thorough we also want
+			// to test the BaseBlock provider of each tortoise)
+			blocksA = blocksA[:layerSize/2]
+			blocksB = blocksB[len(blocksA):]
+			blocks := append(blocksA, blocksB...)
+
+			// add all blocks to both tortoises
+			var blockIDs []types.BlockID
+			for _, block := range blocks {
+				blockIDs = append(blockIDs, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+		}
+
+		// make and process a bunch of layers and make sure both tortoises can verify them
+		for i := 1; i < 5; i++ {
+			layerID := types.GetEffectiveGenesis().Add(uint32(i))
+
+			makeAndProcessLayerMultiTortoise(layerID)
+
+			checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+			checkVerifiedLayer(t, alg2.trtl, layerID.Sub(1))
+		}
+	})
+
+	t.Run("unequal partition and rejoin", func(t *testing.T) {
+		layerSize := 10
+
+		mdb1 := getInMemMesh(t)
+		atxdb1 := getAtxDB()
+		alg1 := defaultAlgorithm(t, mdb1)
+		alg1.trtl.atxdb = atxdb1
+		alg1.trtl.AvgLayerSize = layerSize
+		alg1.logger = alg1.logger.Named("trtl1")
+		alg1.trtl.logger = alg1.logger
+
+		mdb2 := getInMemMesh(t)
+		atxdb2 := getAtxDB()
+		alg2 := defaultAlgorithm(t, mdb2)
+		alg2.trtl.atxdb = atxdb2
+		alg2.trtl.AvgLayerSize = layerSize
+		alg2.logger = alg2.logger.Named("trtl2")
+		alg2.trtl.logger = alg2.logger
+
+		makeBlocks := func(layerID types.LayerID) (blocksA, blocksB []*types.Block) {
+			// simulate producing blocks in parallel
+			blocksA = generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+			blocksB = generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+
+			// 90/10 split
+			blocksA = blocksA[:layerSize-1]
+			blocksB = blocksB[layerSize-1:]
+			return
+		}
+
+		// a bunch of good layers
+		lastVerified := types.GetEffectiveGenesis()
+		layerID := types.GetEffectiveGenesis()
+		for i := 0; i < 10; i++ {
+			layerID = layerID.Add(1)
+			blocksA, blocksB := makeBlocks(layerID)
+			var blocks []*types.Block
+			blocks = append(blocksA, blocksB...)
+
+			// add all blocks to both tortoises
+			var blockIDs []types.BlockID
+			for _, block := range blocks {
+				blockIDs = append(blockIDs, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			// both should make progress
+			checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+			checkVerifiedLayer(t, alg2.trtl, layerID.Sub(1))
+			lastVerified = layerID.Sub(1)
+		}
+
+		// keep track of all blocks on each side of the partition
+		var forkBlocksA, forkBlocksB []*types.Block
+
+		// simulate a partition
+		for i := 0; i < 10; i++ {
+			layerID = layerID.Add(1)
+			blocksA, blocksB := makeBlocks(layerID)
+			forkBlocksA = append(forkBlocksA, blocksA...)
+			forkBlocksB = append(forkBlocksB, blocksB...)
+
+			// add A's blocks to A only, B's to B
+			var blockIDsA, blockIDsB []types.BlockID
+			for _, block := range blocksA {
+				blockIDsA = append(blockIDsA, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsA))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+			for _, block := range blocksB {
+				blockIDsB = append(blockIDsB, block.ID())
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsB))
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			// majority tortoise is unaffected, minority tortoise gets stuck
+			checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+			checkVerifiedLayer(t, alg2.trtl, lastVerified)
+		}
+
+		// these extra layers account for the time needed to generate enough votes to "catch up" and pass
+		// the threshold.
+		healingDistance := 12
+
+		// after a while (we simulate the distance here), minority tortoise eventually begins producing more blocks
+		for i := 0; i < healingDistance; i++ {
+			layerID = layerID.Add(1)
+
+			// these blocks will be nearly identical but they will have different base blocks, since the set of blocks
+			// for recent layers has been bifurcated, so we have to generate and store blocks separately to simulate
+			// an ongoing partition.
+			blocksA := generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+			forkBlocksA = append(forkBlocksA, blocksA...)
+			var blockIDsA, blockIDsB []types.BlockID
+			for _, block := range blocksA {
+				blockIDsA = append(blockIDsA, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsA))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+
+			blocksB := generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+			forkBlocksB = append(forkBlocksB, blocksB...)
+			for _, block := range blocksB {
+				blockIDsB = append(blockIDsB, block.ID())
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsB))
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			// majority tortoise is unaffected, minority tortoise is still stuck
+			checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+			checkVerifiedLayer(t, alg2.trtl, lastVerified)
+		}
+
+		// finally, the minority tortoise heals and regains parity with the majority tortoise
+		layerID = layerID.Add(1)
+		blocksA := generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+		forkBlocksA = append(forkBlocksA, blocksA...)
+		var blockIDsA, blockIDsB []types.BlockID
+		for _, block := range blocksA {
+			blockIDsA = append(blockIDsA, block.ID())
+			r.NoError(mdb1.AddBlock(block))
+		}
+		r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsA))
+		alg1.HandleIncomingLayer(context.TODO(), layerID)
+
+		blocksB := generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+		forkBlocksB = append(forkBlocksB, blocksB...)
+		for _, block := range blocksB {
+			blockIDsB = append(blockIDsB, block.ID())
+			r.NoError(mdb2.AddBlock(block))
+		}
+		r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsB))
+		alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+		// minority node is healed
+		lastVerified = layerID.Sub(1)
+		checkVerifiedLayer(t, alg1.trtl, lastVerified)
+		checkVerifiedLayer(t, alg2.trtl, lastVerified)
+
+		// now simulate a rejoin
+		// send each tortoise's blocks to the other (simulated resync)
+		// (of layers 18-40)
+		var forkBlockIDsA, forkBlockIDsB []types.BlockID
+		for _, block := range forkBlocksA {
+			forkBlockIDsA = append(forkBlockIDsA, block.ID())
+			r.NoError(mdb2.AddBlock(block))
+		}
+		alg2.HandleLateBlocks(context.TODO(), forkBlocksA)
+
+		for _, block := range forkBlocksB {
+			forkBlockIDsB = append(forkBlockIDsB, block.ID())
+			r.NoError(mdb1.AddBlock(block))
+		}
+		alg1.HandleLateBlocks(context.TODO(), forkBlocksB)
+
+		// now continue for a few layers after rejoining, during which the minority tortoise will be stuck
+		// because its opinions about which blocks are valid/invalid are wrong and disagree with the majority
+		// opinion. these ten layers represent its healing distance. after it heals, it will converge to the
+		// majority opinion.
+		for i := 0; i < 10; i++ {
+			layerID = layerID.Add(1)
+			blocksA, blocksB := makeBlocks(layerID)
+			var blocks []*types.Block
+			blocks = append(blocksA, blocksB...)
+
+			// add all blocks to both tortoises
+			var blockIDs []types.BlockID
+			for _, block := range blocks {
+				blockIDs = append(blockIDs, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			// majority tortoise is unaffected, minority tortoise remains stuck
+			checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+			checkVerifiedLayer(t, alg2.trtl, lastVerified)
+		}
+
+		// minority tortoise begins healing
+		for i := 0; i < 10; i++ {
+			layerID = layerID.Add(1)
+			blocksA, blocksB := makeBlocks(layerID)
+			var blocks []*types.Block
+			blocks = append(blocksA, blocksB...)
+
+			// add all blocks to both tortoises
+			var blockIDs []types.BlockID
+			for _, block := range blocks {
+				blockIDs = append(blockIDs, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			// majority tortoise is unaffected, minority tortoise begins to heal but its verifying tortoise
+			// is still stuck
+			checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+			checkVerifiedLayer(t, alg2.trtl, lastVerified.Add(uint32(i+1)))
+		}
+
+		// TODO: finish adding support for reorgs. minority tortoise should complete healing and successfully
+		//   hand off back to verifying tortoise.
+	})
+
+	t.Run("equal partition", func(t *testing.T) {
+		layerSize := 10
+
+		mdb1 := getInMemMesh(t)
+		atxdb1 := getAtxDB()
+		alg1 := defaultAlgorithm(t, mdb1)
+		alg1.trtl.atxdb = atxdb1
+		alg1.trtl.AvgLayerSize = layerSize
+		alg1.logger = alg1.logger.Named("trtl1")
+		alg1.trtl.logger = alg1.logger
+
+		mdb2 := getInMemMesh(t)
+		atxdb2 := getAtxDB()
+		alg2 := defaultAlgorithm(t, mdb2)
+		alg2.trtl.atxdb = atxdb2
+		alg2.trtl.AvgLayerSize = layerSize
+		alg2.logger = alg2.logger.Named("trtl2")
+		alg2.trtl.logger = alg2.logger
+
+		makeBlocks := func(layerID types.LayerID) (blocksA, blocksB []*types.Block) {
+			// simulate producing blocks in parallel
+			blocksA = generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+			blocksB = generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+
+			// 50/50 split
+			blocksA = blocksA[:layerSize/2]
+			blocksB = blocksB[layerSize/2:]
+			return
+		}
+
+		// a bunch of good layers
+		lastVerified := types.GetEffectiveGenesis()
+		layerID := types.GetEffectiveGenesis()
+		for i := 0; i < 10; i++ {
+			layerID = layerID.Add(1)
+			blocksA, blocksB := makeBlocks(layerID)
+			var blocks []*types.Block
+			blocks = append(blocksA, blocksB...)
+
+			// add all blocks to both tortoises
+			var blockIDs []types.BlockID
+			for _, block := range blocks {
+				blockIDs = append(blockIDs, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			// both should make progress
+			checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+			checkVerifiedLayer(t, alg2.trtl, layerID.Sub(1))
+			lastVerified = layerID.Sub(1)
+		}
+
+		// simulate a partition
+		for i := 0; i < 10; i++ {
+			layerID = layerID.Add(1)
+			blocksA, blocksB := makeBlocks(layerID)
+
+			// add A's blocks to A only, B's to B
+			var blockIDsA, blockIDsB []types.BlockID
+			for _, block := range blocksA {
+				blockIDsA = append(blockIDsA, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsA))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+			for _, block := range blocksB {
+				blockIDsB = append(blockIDsB, block.ID())
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsB))
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			// both nodes get stuck
+			checkVerifiedLayer(t, alg1.trtl, lastVerified)
+			checkVerifiedLayer(t, alg2.trtl, lastVerified)
+		}
+
+		// after a while (we simulate the distance here), both nodes eventually begin producing more blocks
+		// in the case of a 50/50 split, this happens quickly
+		for i := uint32(0); i < 2; i++ {
+			layerID = layerID.Add(1)
+
+			// these blocks will be nearly identical but they will have different base blocks, since the set of blocks
+			// for recent layers has been bifurcated, so we have to generate and store blocks separately to simulate
+			// an ongoing partition.
+			blocksA := generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+			var blockIDsA, blockIDsB []types.BlockID
+			for _, block := range blocksA {
+				blockIDsA = append(blockIDsA, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsA))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+
+			blocksB := generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+			for _, block := range blocksB {
+				blockIDsB = append(blockIDsB, block.ID())
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsB))
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			// both nodes still stuck
+			checkVerifiedLayer(t, alg1.trtl, lastVerified)
+			checkVerifiedLayer(t, alg2.trtl, lastVerified)
+		}
+
+		// finally, both nodes heal and get unstuck
+		layerID = layerID.Add(1)
+		blocksA := generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+		var blockIDsA, blockIDsB []types.BlockID
+		for _, block := range blocksA {
+			blockIDsA = append(blockIDsA, block.ID())
+			r.NoError(mdb1.AddBlock(block))
+		}
+		r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsA))
+		alg1.HandleIncomingLayer(context.TODO(), layerID)
+
+		blocksB := generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+		for _, block := range blocksB {
+			blockIDsB = append(blockIDsB, block.ID())
+			r.NoError(mdb2.AddBlock(block))
+		}
+		r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsB))
+		alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+		// both nodes are healed
+		checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+		checkVerifiedLayer(t, alg2.trtl, layerID.Sub(1))
+	})
+
+	t.Run("three-way partition", func(t *testing.T) {
+		layerSize := 12
+
+		mdb1 := getInMemMesh(t)
+		atxdb1 := getAtxDB()
+		alg1 := defaultAlgorithm(t, mdb1)
+		alg1.trtl.atxdb = atxdb1
+		alg1.trtl.AvgLayerSize = layerSize
+		alg1.logger = alg1.logger.Named("trtl1")
+		alg1.trtl.logger = alg1.logger
+
+		mdb2 := getInMemMesh(t)
+		atxdb2 := getAtxDB()
+		alg2 := defaultAlgorithm(t, mdb2)
+		alg2.trtl.atxdb = atxdb2
+		alg2.trtl.AvgLayerSize = layerSize
+		alg2.logger = alg2.logger.Named("trtl2")
+		alg2.trtl.logger = alg2.logger
+
+		mdb3 := getInMemMesh(t)
+		atxdb3 := getAtxDB()
+		alg3 := defaultAlgorithm(t, mdb3)
+		alg3.trtl.atxdb = atxdb3
+		alg3.trtl.AvgLayerSize = layerSize
+		alg3.logger = alg3.logger.Named("trtl3")
+		alg3.trtl.logger = alg3.logger
+
+		makeBlocks := func(layerID types.LayerID) (blocksA, blocksB, blocksC []*types.Block) {
+			// simulate producing blocks in parallel
+			blocksA = generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+			blocksB = generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+			blocksC = generateBlocks(t, layerID, layerSize, alg3.BaseBlock, atxdb3, 1)
+
+			// three-way split
+			blocksA = blocksA[:layerSize/3]
+			blocksB = blocksB[layerSize/3 : layerSize*2/3]
+			blocksC = blocksC[layerSize*2/3:]
+			return
+		}
+
+		// a bunch of good layers
+		lastVerified := types.GetEffectiveGenesis()
+		layerID := types.GetEffectiveGenesis()
+		for i := 0; i < 10; i++ {
+			layerID = layerID.Add(1)
+			blocksA, blocksB, blocksC := makeBlocks(layerID)
+			var blocks []*types.Block
+			blocks = append(blocksA, blocksB...)
+			blocks = append(blocks, blocksC...)
+
+			// add all blocks to all tortoises
+			var blockIDs []types.BlockID
+			for _, block := range blocks {
+				blockIDs = append(blockIDs, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+				r.NoError(mdb2.AddBlock(block))
+				r.NoError(mdb3.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			r.NoError(mdb3.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDs))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+			alg3.HandleIncomingLayer(context.TODO(), layerID)
+
+			// all should make progress
+			checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+			checkVerifiedLayer(t, alg2.trtl, layerID.Sub(1))
+			checkVerifiedLayer(t, alg3.trtl, layerID.Sub(1))
+			lastVerified = layerID.Sub(1)
+		}
+
+		// simulate a partition
+		for i := 0; i < 10; i++ {
+			layerID = layerID.Add(1)
+			blocksA, blocksB, blocksC := makeBlocks(layerID)
+
+			// add each blocks to their own
+			var blockIDsA, blockIDsB, blockIDsC []types.BlockID
+			for _, block := range blocksA {
+				blockIDsA = append(blockIDsA, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsA))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+
+			for _, block := range blocksB {
+				blockIDsB = append(blockIDsB, block.ID())
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsB))
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			for _, block := range blocksC {
+				blockIDsC = append(blockIDsC, block.ID())
+				r.NoError(mdb3.AddBlock(block))
+			}
+			r.NoError(mdb3.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsC))
+			alg3.HandleIncomingLayer(context.TODO(), layerID)
+
+			// all nodes get stuck
+			checkVerifiedLayer(t, alg1.trtl, lastVerified)
+			checkVerifiedLayer(t, alg2.trtl, lastVerified)
+			checkVerifiedLayer(t, alg3.trtl, lastVerified)
+		}
+
+		// after a while (we simulate the distance here), all nodes eventually begin producing more blocks
+		for i := uint32(0); i < 6; i++ {
+			layerID = layerID.Add(1)
+
+			// these blocks will be nearly identical but they will have different base blocks, since the set of blocks
+			// for recent layers has been bifurcated, so we have to generate and store blocks separately to simulate
+			// an ongoing partition.
+			blocksA := generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+			var blockIDsA, blockIDsB, blockIDsC []types.BlockID
+			for _, block := range blocksA {
+				blockIDsA = append(blockIDsA, block.ID())
+				r.NoError(mdb1.AddBlock(block))
+			}
+			r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsA))
+			alg1.HandleIncomingLayer(context.TODO(), layerID)
+
+			blocksB := generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+			for _, block := range blocksB {
+				blockIDsB = append(blockIDsB, block.ID())
+				r.NoError(mdb2.AddBlock(block))
+			}
+			r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsB))
+			alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+			blocksC := generateBlocks(t, layerID, layerSize, alg3.BaseBlock, atxdb3, 1)
+			for _, block := range blocksC {
+				blockIDsC = append(blockIDsC, block.ID())
+				r.NoError(mdb3.AddBlock(block))
+			}
+			r.NoError(mdb3.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsC))
+			alg3.HandleIncomingLayer(context.TODO(), layerID)
+
+			// nodes still stuck
+			checkVerifiedLayer(t, alg1.trtl, lastVerified)
+			checkVerifiedLayer(t, alg2.trtl, lastVerified)
+			checkVerifiedLayer(t, alg3.trtl, lastVerified)
+		}
+
+		// finally, all nodes heal and get unstuck
+		layerID = layerID.Add(1)
+		blocksA := generateBlocks(t, layerID, layerSize, alg1.BaseBlock, atxdb1, 1)
+		var blockIDsA, blockIDsB, blockIDsC []types.BlockID
+		for _, block := range blocksA {
+			blockIDsA = append(blockIDsA, block.ID())
+			r.NoError(mdb1.AddBlock(block))
+		}
+		r.NoError(mdb1.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsA))
+		alg1.HandleIncomingLayer(context.TODO(), layerID)
+
+		blocksB := generateBlocks(t, layerID, layerSize, alg2.BaseBlock, atxdb2, 1)
+		for _, block := range blocksB {
+			blockIDsB = append(blockIDsB, block.ID())
+			r.NoError(mdb2.AddBlock(block))
+		}
+		r.NoError(mdb2.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsB))
+		alg2.HandleIncomingLayer(context.TODO(), layerID)
+
+		blocksC := generateBlocks(t, layerID, layerSize, alg3.BaseBlock, atxdb3, 1)
+		for _, block := range blocksC {
+			blockIDsC = append(blockIDsC, block.ID())
+			r.NoError(mdb3.AddBlock(block))
+		}
+		r.NoError(mdb3.SaveLayerInputVectorByID(context.TODO(), layerID, blockIDsC))
+		alg3.HandleIncomingLayer(context.TODO(), layerID)
+
+		// all nodes are healed
+		checkVerifiedLayer(t, alg1.trtl, layerID.Sub(1))
+		checkVerifiedLayer(t, alg2.trtl, layerID.Sub(1))
+		checkVerifiedLayer(t, alg3.trtl, layerID.Sub(1))
+	})
 }
diff --git a/tortoisebeacon/beacon_calc.go b/tortoisebeacon/beacon_calc.go
index c43552303bb..c7e89568c94 100644
--- a/tortoisebeacon/beacon_calc.go
+++ b/tortoisebeacon/beacon_calc.go
@@ -10,19 +10,17 @@ import (
 )
 
 func (tb *TortoiseBeacon) calcBeacon(epoch types.EpochID, lastRoundVotes allVotes) error {
-	tb.Log.With().Info("Calculating beacon",
-		log.Uint32("epoch_id", uint32(epoch)))
+	tb.Log.With().Info("calculating beacon", log.Uint32("epoch_id", uint32(epoch)))
 
 	allHashes := lastRoundVotes.valid.sort()
 
-	tb.Log.With().Debug("Going to calculate tortoise beacon from this hash list",
+	tb.Log.With().Debug("calculating tortoise beacon from this hash list",
 		log.Uint32("epoch_id", uint32(epoch)),
 		log.String("hashes", strings.Join(allHashes, ", ")))
 
 	beacon := allHashes.hash()
 
-	tb.Log.With().Info("Calculated beacon",
-		log.Uint32("epoch_id", uint32(epoch)),
+	tb.Log.With().Info("calculated beacon", log.Uint32("epoch_id", uint32(epoch)),
 		log.String("beacon", beacon.String()))
 
 	events.ReportCalculatedTortoiseBeacon(epoch, beacon.String())
@@ -32,12 +30,12 @@ func (tb *TortoiseBeacon) calcBeacon(epoch types.EpochID, lastRoundVotes allVote
 	tb.beaconsMu.Unlock()
 
 	if tb.tortoiseBeaconDB != nil {
-		tb.Log.With().Info("Writing beacon to database",
+		tb.Log.With().Info("writing beacon to database",
 			log.Uint32("epoch_id", uint32(epoch)),
 			log.String("beacon", beacon.String()))
 
 		if err := tb.tortoiseBeaconDB.SetTortoiseBeacon(epoch, beacon); err != nil {
-			tb.Log.With().Error("Failed to write tortoise beacon to DB",
+			tb.Log.With().Error("failed to write tortoise beacon to database",
 				log.Uint32("epoch_id", uint32(epoch)),
 				log.String("beacon", beacon.String()))
 
@@ -45,7 +43,7 @@ func (tb *TortoiseBeacon) calcBeacon(epoch types.EpochID, lastRoundVotes allVote
 		}
 	}
 
-	tb.Log.With().Debug("Beacon updated for this epoch",
+	tb.Log.With().Debug("beacon updated for this epoch",
 		log.Uint32("epoch_id", uint32(epoch)),
 		log.String("beacon", beacon.String()))
 
diff --git a/tortoisebeacon/handlers.go b/tortoisebeacon/handlers.go
index e8d31d74359..e0b0f18f259 100644
--- a/tortoisebeacon/handlers.go
+++ b/tortoisebeacon/handlers.go
@@ -44,20 +44,18 @@ func (tb *TortoiseBeacon) HandleSerializedProposalMessage(ctx context.Context, d
 
 	receivedTime := time.Now()
 
-	tb.Log.With().Debug("New proposal message",
-		log.String("sender", data.Sender().String()))
+	tb.Log.With().Debug("new proposal message", log.String("sender", data.Sender().String()))
 
 	var message ProposalMessage
 	if err := types.BytesToInterface(data.Bytes(), &message); err != nil {
-		tb.Log.With().Error("Received malformed proposal message",
-			log.Err(err))
+		tb.Log.With().Error("received malformed proposal message", log.Err(err))
 
 		return
 	}
 
 	currentEpoch := tb.currentEpoch()
 	if message.EpochID < currentEpoch {
-		tb.Log.With().Debug("Received proposal message from previous epoch, ignoring",
+		tb.Log.With().Debug("received proposal message from previous epoch, ignoring",
 			log.Uint64("message_epoch", uint64(message.EpochID)),
 			log.Uint32("current_epoch", uint32(currentEpoch)))
 
@@ -123,7 +121,7 @@ func (tb *TortoiseBeacon) classifyProposalMessage(m ProposalMessage, atxID types
 
 	switch {
 	case tb.isValidProposalMessage(currentEpoch, atxTimestamp, nextEpochStart, receivedTime):
-		tb.Log.With().Debug("Received valid proposal message",
+		tb.Log.With().Debug("received valid proposal message",
 			log.Uint32("epoch_id", uint32(currentEpoch)),
 			log.String("message", m.String()),
 			log.String("atx_timestamp", atxTimestamp.String()),
@@ -134,7 +132,7 @@ func (tb *TortoiseBeacon) classifyProposalMessage(m ProposalMessage, atxID types
 		tb.incomingProposals.valid = append(tb.incomingProposals.valid, m.VRFSignature)
 
 	case tb.isPotentiallyValidProposalMessage(currentEpoch, atxTimestamp, nextEpochStart, receivedTime):
-		tb.Log.With().Debug("Received potentially valid proposal message",
+		tb.Log.With().Debug("received potentially valid proposal message",
 			log.Uint32("epoch_id", uint32(currentEpoch)),
 			log.String("message", m.String()),
 			log.String("atx_timestamp", atxTimestamp.String()),
@@ -145,7 +143,7 @@ func (tb *TortoiseBeacon) classifyProposalMessage(m ProposalMessage, atxID types
 		tb.incomingProposals.potentiallyValid = append(tb.incomingProposals.potentiallyValid, m.VRFSignature)
 
 	default:
-		tb.Log.With().Warning("Received invalid proposal message",
+		tb.Log.With().Warning("received invalid proposal message",
 			log.Uint32("epoch_id", uint32(currentEpoch)),
 			log.String("atx_timestamp", atxTimestamp.String()),
 			log.String("next_epoch_start", nextEpochStart.String()),
@@ -177,7 +175,7 @@ func (tb *TortoiseBeacon) verifyProposalMessage(m ProposalMessage, currentEpoch
 	vrfPK := signing.NewPublicKey(m.NodeID.VRFPublicKey)
 	if !tb.vrfVerifier.Verify(vrfPK, currentEpochProposal, m.VRFSignature) {
 		// TODO(nkryuchkov): attach telemetry
-		tb.Log.With().Warning("Received malformed proposal message: VRF is not verified",
+		tb.Log.With().Warning("received malformed proposal message: vrf is not verified",
 			log.String("sender", m.NodeID.ShortString()))
 
 		// TODO(nkryuchkov): add a test for this case
@@ -202,7 +200,7 @@ func (tb *TortoiseBeacon) verifyProposalMessage(m ProposalMessage, currentEpoch
 	}
 
 	if !passes {
-		tb.Log.With().Warning("Rejected proposal message which doesn't pass threshold",
+		tb.Log.With().Warning("rejected proposal message which doesn't pass threshold",
 			log.String("proposal", proposalShortString))
 
 		return types.ATXID{}, ErrProposalDoesntPassThreshold
@@ -231,12 +229,11 @@ func (tb *TortoiseBeacon) HandleSerializedFirstVotingMessage(ctx context.Context
 		return
 	}
 
-	tb.Log.With().Debug("New voting message",
-		log.String("sender", data.Sender().String()))
+	tb.Log.With().Debug("new voting message", log.String("sender", data.Sender().String()))
 
 	var m FirstVotingMessage
 	if err := types.BytesToInterface(data.Bytes(), &m); err != nil {
-		tb.Log.With().Error("Received invalid voting message",
+		tb.Log.With().Error("received invalid voting message",
 			log.String("message", string(data.Bytes())),
 			log.Err(err))
 
@@ -244,7 +241,7 @@ func (tb *TortoiseBeacon) HandleSerializedFirstVotingMessage(ctx context.Context
 	}
 
 	if err := tb.handleFirstVotingMessage(m); err != nil {
-		tb.Log.With().Error("Failed to handle first voting message",
+		tb.Log.With().Error("failed to handle first voting message",
 			log.Err(err))
 
 		return
@@ -272,7 +269,7 @@ func (tb *TortoiseBeacon) handleFirstVotingMessage(message FirstVotingMessage) e
 
 	voteWeight := new(big.Int).SetUint64(atx.GetWeight())
 
-	tb.Log.With().Debug("Received first voting message, storing its votes",
+	tb.Log.With().Debug("received first voting message, storing its votes",
 		log.String("miner_id", minerPK.ShortString()),
 		log.Uint32("epoch_id", uint32(currentEpoch)),
 		log.Uint32("round_id", uint32(firstRound)))
@@ -298,7 +295,7 @@ func (tb *TortoiseBeacon) verifyFirstVotingMessage(message FirstVotingMessage, c
 	nodeID := types.NodeID{Key: minerPK.String()}
 	atxID, err := tb.atxDB.GetNodeAtxIDForEpoch(nodeID, currentEpoch-1)
 	if errors.Is(err, database.ErrNotFound) {
-		tb.Log.With().Warning("Miner has no ATXs in the previous epoch",
+		tb.Log.With().Warning("miner has no atxs in the previous epoch",
 			log.String("miner_id", minerPK.ShortString()))
 
 		return nil, types.ATXID{}, database.ErrNotFound
@@ -309,7 +306,7 @@ func (tb *TortoiseBeacon) verifyFirstVotingMessage(message FirstVotingMessage, c
 	}
 
 	if !signing.Verify(minerPK, messageBytes, message.Signature) {
-		tb.Log.With().Warning("Received malformed first voting message, bad signature",
+		tb.Log.With().Warning("received malformed first voting message, bad signature",
 			log.String("miner_id", minerPK.ShortString()),
 			log.Uint32("epoch_id", uint32(currentEpoch)))
 
@@ -325,7 +322,8 @@ func (tb *TortoiseBeacon) verifyFirstVotingMessage(message FirstVotingMessage, c
 
 	// TODO(nkryuchkov): consider having a separate table for an epoch with one bit in it if atx/miner is voted already
 	if _, ok := tb.hasVoted[firstRound][string(minerPK.Bytes())]; ok {
-		tb.Log.With().Warning("Received malformed first voting message, already received a voting message for these PK and round",
+		tb.Log.With().Warning("received malformed first voting message, "+
+			"already received a voting message for this pk and round",
 			log.String("miner_id", minerPK.ShortString()),
 			log.Uint32("epoch_id", uint32(currentEpoch)),
 			log.Uint32("round_id", uint32(firstRound)))
@@ -421,7 +419,7 @@ func (tb *TortoiseBeacon) handleFollowingVotingMessage(message FollowingVotingMe
 
 	voteWeight := new(big.Int).SetUint64(atx.GetWeight())
 
-	tb.Log.With().Debug("Received following voting message, counting its votes",
+	tb.Log.With().Debug("received following voting message, counting its votes",
 		log.String("miner_id", minerPK.ShortString()),
 		log.Uint32("epoch_id", uint32(currentEpoch)),
 		log.Uint32("round_id", uint32(messageRound)))
@@ -445,7 +443,7 @@ func (tb *TortoiseBeacon) verifyFollowingVotingMessage(message FollowingVotingMe
 	nodeID := types.NodeID{Key: minerPK.String()}
 	atxID, err := tb.atxDB.GetNodeAtxIDForEpoch(nodeID, currentEpoch-1)
 	if errors.Is(err, database.ErrNotFound) {
-		tb.Log.With().Warning("Miner has no ATXs in the previous epoch",
+		tb.Log.With().Warning("miner has no ATXs in the previous epoch",
 			log.String("miner_id", minerPK.ShortString()))
 
 		return nil, types.ATXID{}, database.ErrNotFound
@@ -456,7 +454,7 @@ func (tb *TortoiseBeacon) verifyFollowingVotingMessage(message FollowingVotingMe
 	}
 
 	if !signing.Verify(minerPK, messageBytes, message.Signature) {
-		tb.Log.With().Warning("Received malformed following voting message, bad signature",
+		tb.Log.With().Warning("received malformed following voting message, bad signature",
 			log.String("miner_id", minerPK.ShortString()),
 			log.Uint32("epoch_id", uint32(currentEpoch)))
 
@@ -471,7 +469,7 @@ func (tb *TortoiseBeacon) verifyFollowingVotingMessage(message FollowingVotingMe
 	}
 
 	if _, ok := tb.hasVoted[message.RoundID-firstRound][string(minerPK.Bytes())]; ok {
-		tb.Log.With().Warning("Received malformed following voting message, already received a voting message for these PK and round",
+		tb.Log.With().Warning("received malformed following voting message, already received a voting message for these PK and round",
 			log.String("miner_id", minerPK.ShortString()),
 			log.Uint32("epoch_id", uint32(currentEpoch)),
 			log.Uint32("round_id", uint32(message.RoundID-firstRound)))
diff --git a/tortoisebeacon/tortoise_beacon.go b/tortoisebeacon/tortoise_beacon.go
index a7615706d05..1f044c534f4 100644
--- a/tortoisebeacon/tortoise_beacon.go
+++ b/tortoisebeacon/tortoise_beacon.go
@@ -63,10 +63,10 @@ type (
 
 type layerClock interface {
 	Subscribe() timesync.LayerTimer
-	Unsubscribe(timer timesync.LayerTimer)
-	AwaitLayer(layerID types.LayerID) chan struct{}
+	Unsubscribe(timesync.LayerTimer)
+	AwaitLayer(types.LayerID) chan struct{}
 	GetCurrentLayer() types.LayerID
-	LayerToTime(id types.LayerID) time.Time
+	LayerToTime(types.LayerID) time.Time
 }
 
 // New returns a new TortoiseBeacon.
@@ -162,7 +162,7 @@ func (tb *TortoiseBeacon) Start(ctx context.Context) error {
 		tb.Log.Warning("attempt to start tortoise beacon more than once")
 		return nil
 	}
-	tb.Log.Info("Starting %v with the following config: %+v", protoName, tb.config)
+	tb.Log.Info("starting %v with the following config: %+v", protoName, tb.config)
 
 	ctx, cancel := context.WithCancel(ctx)
 	tb.tg = taskgroup.New(taskgroup.WithContext(ctx))
@@ -188,7 +188,7 @@ func (tb *TortoiseBeacon) Close() {
 	if !atomic.CompareAndSwapUint64(&tb.closed, 1, 0) {
 		return
 	}
-	tb.Log.Info("Closing %v", protoName)
+	tb.Log.Info("closing %v", protoName)
 	tb.cancel()
 	if err := tb.tg.Wait(); err != nil {
 		tb.Log.Warning("taskgroup: Wait returned an error",
@@ -216,7 +216,7 @@ func (tb *TortoiseBeacon) GetBeacon(epochID types.EpochID) ([]byte, error) {
 		}
 
 		if !errors.Is(err, database.ErrNotFound) {
-			tb.Log.Error("Failed to get tortoise beacon for epoch %v from DB: %v", epochID-1, err)
+			tb.Log.Error("failed to get tortoise beacon for epoch %v from DB: %v", epochID-1, err)
 
 			return nil, fmt.Errorf("get beacon from DB: %w", err)
 		}
@@ -231,7 +231,7 @@ func (tb *TortoiseBeacon) GetBeacon(epochID types.EpochID) ([]byte, error) {
 
 	beacon, ok := tb.beacons[epochID-1]
 	if !ok {
-		tb.Log.With().Error("Beacon is not calculated",
+		tb.Log.With().Error("beacon is not calculated",
 			log.Uint32("target_epoch", uint32(epochID)),
 			log.Uint32("beacon_epoch", uint32(epochID-1)))
 
@@ -251,7 +251,7 @@ func (tb *TortoiseBeacon) initGenesisBeacons() {
 
 		if tb.tortoiseBeaconDB != nil {
 			if err := tb.tortoiseBeaconDB.SetTortoiseBeacon(epoch, genesis); err != nil {
-				tb.Log.With().Error("Failed to write tortoise beacon to DB",
+				tb.Log.With().Error("failed to write tortoise beacon to DB",
 					log.Uint32("epoch_id", uint32(epoch)),
 					log.String("beacon", genesis.String()))
 			}
@@ -276,14 +276,14 @@ func (tb *TortoiseBeacon) cleanupVotes() {
 
 // listens to new layers.
 func (tb *TortoiseBeacon) listenLayers(ctx context.Context) {
-	tb.Log.With().Info("Starting listening layers")
+	tb.Log.With().Info("starting listening layers")
 
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case layer := <-tb.layerTicker:
-			tb.Log.With().Info("Received tick", layer)
+			tb.Log.With().Info("received tick", layer)
 			err := tb.tg.Go(func(ctx context.Context) error {
 				tb.handleLayer(ctx, layer)
 				return nil
@@ -301,10 +301,9 @@ func (tb *TortoiseBeacon) listenLayers(ctx context.Context) {
 func (tb *TortoiseBeacon) handleLayer(ctx context.Context, layer types.LayerID) {
 	tb.layerMu.Lock()
 	if layer.After(tb.lastLayer) {
-		tb.Log.With().Debug("Updating layer",
+		tb.Log.With().Debug("updating layer",
 			log.Uint32("old_value", tb.lastLayer.Uint32()),
 			log.Uint32("new_value", layer.Uint32()))
-
 		tb.lastLayer = layer
 	}
 
@@ -320,7 +319,7 @@ func (tb *TortoiseBeacon) handleLayer(ctx context.Context, layer types.LayerID)
 		return
 	}
 
-	tb.Log.With().Info("Layer is first in epoch, proceeding",
+	tb.Log.With().Info("layer is first in epoch, proceeding",
 		log.Uint32("layer", layer.Uint32()))
 
 	tb.seenEpochsMu.Lock()
@@ -360,7 +359,7 @@ func (tb *TortoiseBeacon) handleEpoch(ctx context.Context, epoch types.EpochID)
 		return
 	}
 
-	tb.Log.With().Info("Handling epoch",
+	tb.Log.With().Info("handling epoch",
 		log.Uint32("epoch_id", uint32(epoch)))
 
 	defer tb.cleanupVotes()
@@ -393,12 +392,12 @@ func (tb *TortoiseBeacon) handleEpoch(ctx context.Context, epoch types.EpochID)
 	// K rounds passed
 	// After K rounds had passed, tally up votes for proposals using simple tortoise vote counting
 	if err := tb.calcBeacon(epoch, lastRoundOwnVotes); err != nil {
-		tb.Log.With().Error("Failed to calculate beacon",
+		tb.Log.With().Error("failed to calculate beacon",
 			log.Uint32("epoch_id", uint32(epoch)),
 			log.Err(err))
 	}
 
-	tb.Log.With().Debug("Finished handling epoch",
+	tb.Log.With().Debug("finished handling epoch",
 		log.Uint32("epoch_id", uint32(epoch)))
 }
 
@@ -414,7 +413,7 @@ func (tb *TortoiseBeacon) readProposalMessagesLoop(ctx context.Context, ch chan
 			}
 
 			if err := tb.handleProposalMessage(em.message, em.receivedTime); err != nil {
-				tb.Log.With().Error("Failed to handle proposal message",
+				tb.Log.With().Error("failed to handle proposal message",
 					log.String("sender", em.gossip.Sender().String()),
 					log.String("message", em.message.String()),
 					log.Err(err))
@@ -449,7 +448,7 @@ func (tb *TortoiseBeacon) getOrCreateProposalChannel(epoch types.EpochID) chan *
 }
 
 func (tb *TortoiseBeacon) runProposalPhase(ctx context.Context, epoch types.EpochID) {
-	tb.Log.With().Debug("Starting proposal phase",
+	tb.Log.With().Debug("starting proposal phase",
 		log.Uint32("epoch_id", uint32(epoch)))
 
 	var cancel func()
@@ -457,16 +456,16 @@ func (tb *TortoiseBeacon) runProposalPhase(ctx context.Context, epoch types.Epoc
 	defer cancel()
 
 	err := tb.tg.Go(func(ctx context.Context) error {
-		tb.Log.With().Debug("Starting proposal message sender",
+		tb.Log.With().Debug("starting proposal message sender",
 			log.Uint32("epoch_id", uint32(epoch)))
 
 		if err := tb.proposalPhaseImpl(ctx, epoch); err != nil {
-			tb.Log.With().Error("Failed to send proposal message",
+			tb.Log.With().Error("failed to send proposal message",
 				log.Uint32("epoch_id", uint32(epoch)),
 				log.Err(err))
 		}
 
-		tb.Log.With().Debug("Proposal message sender finished",
+		tb.Log.With().Debug("proposal message sender finished",
 			log.Uint32("epoch_id", uint32(epoch)))
 		return nil
 	})
@@ -478,7 +477,7 @@ func (tb *TortoiseBeacon) runProposalPhase(ctx context.Context, epoch types.Epoc
 	<-ctx.Done()
 	tb.markProposalPhaseFinished(epoch)
 
-	tb.Log.With().Debug("Proposal phase finished",
+	tb.Log.With().Debug("proposal phase finished",
 		log.Uint32("epoch_id", uint32(epoch)))
 }
 
@@ -488,7 +487,7 @@ func (tb *TortoiseBeacon) proposalPhaseImpl(ctx context.Context, epoch types.Epo
 		return fmt.Errorf("calculate signed proposal: %w", err)
 	}
 
-	tb.Log.With().Debug("Calculated proposal signature",
+	tb.Log.With().Debug("calculated proposal signature",
 		log.Uint32("epoch_id", uint32(epoch)),
 		log.String("signature", string(proposedSignature)))
 
@@ -503,7 +502,7 @@ func (tb *TortoiseBeacon) proposalPhaseImpl(ctx context.Context, epoch types.Epo
 	}
 
 	if !passes {
-		tb.Log.With().Debug("Proposal to be sent doesn't pass threshold",
+		tb.Log.With().Debug("proposal to be sent doesn't pass threshold",
 			log.Uint32("epoch_id", uint32(epoch)),
 			log.String("proposal", string(proposedSignature)),
 			log.Uint64("weight", epochWeight))
@@ -523,7 +522,7 @@ func (tb *TortoiseBeacon) proposalPhaseImpl(ctx context.Context, epoch types.Epo
 		VRFSignature: proposedSignature,
 	}
 
-	tb.Log.With().Debug("Going to send proposal",
+	tb.Log.With().Debug("going to send proposal",
 		log.Uint32("epoch_id", uint32(epoch)),
 		log.String("message", m.String()))
 
@@ -531,7 +530,7 @@ func (tb *TortoiseBeacon) proposalPhaseImpl(ctx context.Context, epoch types.Epo
 		return fmt.Errorf("broadcast proposal message: %w", err)
 	}
 
-	tb.Log.With().Info("Sent proposal",
+	tb.Log.With().Info("sent proposal",
 		log.Uint32("epoch_id", uint32(epoch)),
 		log.String("message", m.String()))
 
@@ -545,7 +544,7 @@ func (tb *TortoiseBeacon) proposalPhaseImpl(ctx context.Context, epoch types.Epo
 
 // runConsensusPhase runs K voting rounds and returns result from last weak coin round.
 func (tb *TortoiseBeacon) runConsensusPhase(ctx context.Context, epoch types.EpochID) (allVotes, error) {
-	tb.Log.With().Debug("Starting consensus phase",
+	tb.Log.With().Debug("starting consensus phase",
 		log.Uint32("epoch_id", uint32(epoch)))
 
 	tb.startWeakCoinEpoch(epoch)
@@ -651,14 +650,14 @@ func (tb *TortoiseBeacon) startWeakCoinEpoch(epoch types.EpochID) {
 	// we need to pass a map with spacetime unit allowances before any round is started
 	_, atxs, err := tb.atxDB.GetEpochWeight(epoch)
 	if err != nil {
-		tb.Log.With().Panic("can't load list of atxs", log.Err(err))
+		tb.Log.With().Panic("unable to load list of atxs", log.Err(err))
 	}
 
 	ua := weakcoin.UnitAllowances{}
 	for _, id := range atxs {
 		header, err := tb.atxDB.GetAtxHeader(id)
 		if err != nil {
-			tb.Log.With().Panic("can't load atx header", log.Err(err))
+			tb.Log.With().Panic("unable to load atx header", log.Err(err))
 		}
 		ua[string(header.NodeID.VRFPublicKey)] += uint64(header.NumUnits)
 	}
@@ -709,7 +708,7 @@ func (tb *TortoiseBeacon) startWeakCoinRound(ctx context.Context, epoch types.Ep
 	// TODO(nkryuchkov):
 	// should be published only after we should have received them
 	if err := tb.weakCoin.StartRound(ctx, round); err != nil {
-		tb.Log.With().Error("Failed to publish weak coin proposal",
+		tb.Log.With().Error("failed to publish weak coin proposal",
 			log.Uint32("epoch_id", uint32(epoch)),
 			log.Uint32("round_id", uint32(round)),
 			log.Err(err))
@@ -742,7 +741,7 @@ func (tb *TortoiseBeacon) sendFirstRoundVote(ctx context.Context, epoch types.Ep
 		Signature:              sig,
 	}
 
-	tb.Log.With().Debug("Going to send first round vote",
+	tb.Log.With().Debug("sending first round vote",
 		log.Uint32("epoch_id", uint32(epoch)),
 		log.Uint32("round_id", uint32(firstRound)),
 		log.String("message", m.String()))
@@ -774,7 +773,7 @@ func (tb *TortoiseBeacon) sendFollowingVote(ctx context.Context, epoch types.Epo
 		Signature:                  sig,
 	}
 
-	tb.Log.With().Debug("Going to send following round vote",
+	tb.Log.With().Debug("sending following round vote",
 		log.Uint32("epoch_id", uint32(epoch)),
 		log.Uint32("round_id", uint32(round)),
 		log.String("message", m.String()))
@@ -856,7 +855,7 @@ func (tb *TortoiseBeacon) getSignedProposal(epoch types.EpochID) ([]byte, error)
 	}
 
 	signature := tb.vrfSigner.Sign(p)
-	tb.Log.With().Debug("Calculated signature",
+	tb.Log.With().Debug("calculated signature",
 		log.Uint32("epoch_id", uint32(epoch)),
 		log.String("proposal", util.Bytes2Hex(p)),
 		log.String("signature", string(signature)))
@@ -920,7 +919,7 @@ func (tb *TortoiseBeacon) proposalPassesEligibilityThreshold(proposal []byte, ep
 		return false, fmt.Errorf("atxThreshold: %w", err)
 	}
 
-	tb.Log.With().Debug("Checking proposal for ATX threshold",
+	tb.Log.With().Debug("checking proposal for atx threshold",
 		log.String("proposal", proposalInt.String()),
 		log.String("threshold", threshold.String()))
 
diff --git a/turbohare/hare.go b/turbohare/hare.go
index e7d7ace4ad9..8d5bfa276f8 100644
--- a/turbohare/hare.go
+++ b/turbohare/hare.go
@@ -12,8 +12,9 @@ import (
 )
 
 type meshProvider interface {
-	LayerBlockIds(layerID types.LayerID) ([]types.BlockID, error)
-	RecordCoinflip(ctx context.Context, layerID types.LayerID, coinflip bool)
+	LayerBlockIds(types.LayerID) ([]types.BlockID, error)
+	RecordCoinflip(context.Context, types.LayerID, bool)
+	HandleValidatedLayer(context.Context, types.LayerID, []types.BlockID)
 }
 
 // SuperHare is a method to provide fast hare results without consensus based on received blocks from gossip
@@ -45,11 +46,31 @@ func (h *SuperHare) Start(ctx context.Context) error {
 			case layerID := <-h.beginLayer:
 				go func() {
 					logger.With().Info("superhare got layer tick, simulating consensus process run", layerID)
-					time.Sleep(time.Second * time.Duration(h.conf.WakeupDelta+5*h.conf.RoundDuration))
+
+					// don't block here if Close was called
+					select {
+					case <-h.closeChannel:
+						logger.Info("superhare closing lingering goroutine")
+						return
+					case <-time.After(time.Second * time.Duration(h.conf.WakeupDelta+5*h.conf.RoundDuration)):
+					}
+
 					// use lowest-order bit
 					coinflip := layerID.Bytes()[0]&byte(1) == byte(1)
 					h.mesh.RecordCoinflip(ctx, layerID, coinflip)
 					logger.With().Info("superhare recorded coinflip", layerID, log.Bool("coinflip", coinflip))
+
+					// pass all blocks in the layer to the mesh
+					if layerID.GetEpoch().IsGenesis() {
+						logger.With().Info("not sending blocks to mesh for genesis layer")
+						return
+					} else if layerBlocks, err := h.mesh.LayerBlockIds(layerID); err != nil {
+						logger.With().Error("error reading block ids for layer, not sending to mesh",
+							layerID,
+							log.Err(err))
+					} else {
+						h.mesh.HandleValidatedLayer(ctx, layerID, layerBlocks)
+					}
 				}()
 			}
 		}