From db17019448ddbfcabec606354c537726fa86e8ed Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Thu, 12 Nov 2026 18:08:05 -0700 Subject: [PATCH 01/15] use full commit verification in blocksync --- sei-tendermint/internal/blocksync/reactor.go | 5 +- .../reactor_validation_failure_test.go | 275 ++++++++++++++++-- 2 files changed, 259 insertions(+), 21 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor.go b/sei-tendermint/internal/blocksync/reactor.go index 38914624d4..4b980e7f9c 100644 --- a/sei-tendermint/internal/blocksync/reactor.go +++ b/sei-tendermint/internal/blocksync/reactor.go @@ -552,7 +552,10 @@ func (s *syncController) poolRoutine(ctx context.Context, pool *BlockPool, initi firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstParts.Header()} - err = state.Validators.VerifyCommitLight(chainID, firstID, first.Height, second.LastCommit) + // Use the full check, not the light one, because second.LastCommit is + // saved as the seen commit of first. A seen commit with an invalid + // signature must never be saved. + err = state.Validators.VerifyCommit(chainID, firstID, first.Height, second.LastCommit) if err != nil { err = types.DefaultConsensusPolicy().HandleError(fmt.Errorf("%w: %w", types.ErrLastCommitVerify, err)) } diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index 291c224df6..bb4e11ac7c 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -9,19 +9,27 @@ package blocksync import ( "context" "errors" + "fmt" "strings" "testing" "time" - "github.com/stretchr/testify/require" + "github.com/fortytw2/leaktest" "github.com/sei-protocol/sei-chain/sei-tendermint/config" "github.com/sei-protocol/sei-chain/sei-tendermint/internal/p2p" sm "github.com/sei-protocol/sei-chain/sei-tendermint/internal/state" + sf "github.com/sei-protocol/sei-chain/sei-tendermint/internal/state/test/factory" "github.com/sei-protocol/sei-chain/sei-tendermint/internal/test/factory" + "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils" + utilsrequire "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/require" + "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/scope" + tmproto "github.com/sei-protocol/sei-chain/sei-tendermint/proto/tendermint/types" "github.com/sei-protocol/sei-chain/sei-tendermint/types" ) +// makeValidationFailurePair returns a one-validator genesis state, block 1, and a block 2 +// whose commit for block 1 has a signature that does not verify. func makeValidationFailurePair( ctx context.Context, t *testing.T, @@ -30,27 +38,64 @@ func makeValidationFailurePair( t.Helper() cfg, err := config.ResetTestRoot(t.TempDir(), testRootName) - require.NoError(t, err) + utilsrequire.NoError(t, err) valSet, privVals := factory.ValidatorSet(ctx, 1, 30) genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams()) initialState, err := sm.MakeGenesisState(genDoc) - require.NoError(t, err) - - lastCommit := &types.Commit{} - block1, _, _, seenCommit1 := makeNextBlock(ctx, t, initialState, privVals[0], 1, lastCommit) - block2, _, _, _ := makeNextBlock(ctx, t, initialState, privVals[0], 2, seenCommit1) - - badBlock2Proto, err := block2.ToProto() - require.NoError(t, err) - badBlock2Proto.LastCommit.Signatures[0].Signature[0] ^= 0xFF - badCommit, err := types.CommitFromProto(badBlock2Proto.LastCommit) - require.NoError(t, err) - badBlock2Proto.Header.LastCommitHash = badCommit.Hash() - badBlock2, err := types.BlockFromProto(badBlock2Proto) - require.NoError(t, err) - - return initialState, block1, badBlock2 + utilsrequire.NoError(t, err) + + block1 := makeCommittedBlock(ctx, t, initialState, privVals, 1, &types.Commit{}) + block2 := makeCommittedBlock(ctx, t, initialState, privVals, 2, block1.commit) + + return initialState, block1.block, withBadLastSignature(t, block2.block, tmproto.BlockIDFlagCommit) +} + +// committedBlock is a block with its ID, its part set, and a commit for it. +type committedBlock struct { + block *types.Block + id types.BlockID + parts *types.PartSet + commit *types.Commit +} + +// makeCommittedBlock returns the block at height on top of state, with lastCommit as its last +// commit, and a commit for it signed by every validator in privVals. +func makeCommittedBlock( + ctx context.Context, + t *testing.T, + state sm.State, + privVals []types.PrivValidator, + height int64, + lastCommit *types.Commit, +) committedBlock { + t.Helper() + block := sf.MakeBlock(state, height, lastCommit) + parts, err := block.MakePartSet(types.BlockPartSizeBytes) + utilsrequire.NoError(t, err) + id := types.BlockID{Hash: block.Hash(), PartSetHeader: parts.Header()} + voteSet := types.NewVoteSet(state.ChainID, height, 0, tmproto.PrecommitType, state.Validators) + commit, err := factory.MakeCommit(ctx, id, height, 0, voteSet, privVals, time.Now()) + utilsrequire.NoError(t, err) + return committedBlock{block: block, id: id, parts: parts, commit: commit} +} + +// withBadLastSignature returns a copy of block whose last commit has a last signature that +// does not verify, with flag as the block ID flag of that signature. +func withBadLastSignature(t *testing.T, block *types.Block, flag tmproto.BlockIDFlag) *types.Block { + t.Helper() + blockProto, err := block.ToProto() + utilsrequire.NoError(t, err) + sigs := blockProto.LastCommit.Signatures + lastSig := &sigs[len(sigs)-1] + lastSig.Signature[0] ^= 0xFF + lastSig.BlockIdFlag = flag + badCommit, err := types.CommitFromProto(blockProto.LastCommit) + utilsrequire.NoError(t, err) + blockProto.Header.LastCommitHash = badCommit.Hash() + badBlock, err := types.BlockFromProto(blockProto) + utilsrequire.NoError(t, err) + return badBlock } func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { @@ -86,7 +131,7 @@ func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { }() t.Cleanup(func() { err := <-results - require.ErrorIs(t, err, context.Canceled) + utilsrequire.ErrorIs(t, err, context.Canceled) }) introducedGoodPeer := false @@ -142,7 +187,7 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { }() t.Cleanup(func() { err := <-results - require.ErrorIs(t, err, context.Canceled) + utilsrequire.ErrorIs(t, err, context.Canceled) }) introducedGoodPeers := false @@ -177,3 +222,193 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { } } } + +// syncEvent is a block save on the syncing node, or the close of its connection to the bad +// node when saved is empty. +type syncEvent struct { + saved utils.Option[savedBlock] +} + +// savedBlock is a block and the seen commit saved with it. +type savedBlock struct { + block *types.Block + seenCommit *types.Commit +} + +// saveRecordingStore is a block store that reports every saved block on events. +type saveRecordingStore struct { + sm.BlockStore + events chan<- syncEvent +} + +func (s saveRecordingStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) { + s.BlockStore.SaveBlock(block, blockParts, seenCommit) + select { + case s.events <- syncEvent{saved: utils.Some(savedBlock{block: block, seenCommit: seenCommit})}: + default: + panic("events channel full") + } +} + +// syncObserver reads the events of a syncing node in order and checks each one. +type syncObserver struct { + events <-chan syncEvent +} + +// expectSaved receives the next event and returns an error unless it is a save of want with +// wantSeenCommit. +func (o syncObserver) expectSaved(ctx context.Context, want *types.Block, wantSeenCommit *types.Commit) error { + event, err := utils.Recv(ctx, o.events) + if err != nil { + return err + } + saved, ok := event.saved.Get() + if !ok { + return fmt.Errorf("got disconnection of the bad node, want save of block %d", want.Height) + } + if err := utils.TestDiff(want.Hash(), saved.block.Hash()); err != nil { + return fmt.Errorf("saved block %d: %w", want.Height, err) + } + if err := utils.TestDiff(wantSeenCommit.ToProto(), saved.seenCommit.ToProto()); err != nil { + return fmt.Errorf("seen commit of block %d: %w", want.Height, err) + } + return nil +} + +// expectDisconnected receives the next event and returns an error unless it is the close of the +// connection to the bad node. +func (o syncObserver) expectDisconnected(ctx context.Context) error { + event, err := utils.Recv(ctx, o.events) + if err != nil { + return err + } + if saved, ok := event.saved.Get(); ok { + return fmt.Errorf("got save of block %d, want disconnection of the bad node", saved.block.Height) + } + return nil +} + +// waitForDisconnect waits until conn is no longer a connection of node. It returns the +// context error when ctx is done first. +func waitForDisconnect(ctx context.Context, node *p2p.TestNode, conn *p2p.ConnV2) (err error) { + // WaitForDisconnect panics with the context error. + defer func() { + if r := recover(); r != nil { + ctxErr, ok := r.(error) + if !ok { + panic(r) + } + err = ctxErr + } + }() + node.WaitForDisconnect(ctx, conn) + return nil +} + +// TestReactor_RejectsInvalidCommitFromPeer checks that a syncing node saves the blocks a bad +// peer serves up to the first block whose commit fails verification, evicts that peer, and then +// still makes progress by saving that block from a good peer. +func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { + for _, tc := range []struct { + name string + flag tmproto.BlockIDFlag + }{ + {name: "commit vote", flag: tmproto.BlockIDFlagCommit}, + {name: "nil vote", flag: tmproto.BlockIDFlagNil}, + } { + t.Run(tc.name, func(t *testing.T) { + // After every other cleanup, no goroutine of the nodes is left running. + t.Cleanup(leaktest.Check(t)) + ctx := t.Context() + + cfg, err := config.ResetTestRoot(t.TempDir(), "block_sync_invalid_commit") + utilsrequire.NoError(t, err) + valSet, privVals := factory.ValidatorSet(ctx, 4, 30) + genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams()) + network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 2}) + nodeIDs := network.NodeIDs() + badID, syncID := nodeIDs[0], nodeIDs[1] + syncNode := network.Node(syncID) + badReactor := makeReactor(ctx, t, genDoc, network.Node(badID).Router, false, func() {}, config.DefaultSelfRemediationConfig()) + syncReactor := makeReactor(ctx, t, genDoc, syncNode.Router, true, func() {}, config.DefaultSelfRemediationConfig()) + + // Connect the bad node and the syncing node. + network.Start(t) + badConn := syncNode.WaitForConnAndGet(ctx, badID) + + // The good node is not connected to anyone yet. + goodNode := network.MakeNode(t, p2p.TestNodeOptions{}) + goodReactor := makeReactor(ctx, t, genDoc, goodNode.Router, false, func() {}, config.DefaultSelfRemediationConfig()) + + // The good node applies and stores honest blocks 1 to 4. + goodExec := goodReactor.syncer.OrPanic("syncer should be configured in tests").blockExec + state, err := goodReactor.stateStore.Load() + utilsrequire.NoError(t, err) + var honest []committedBlock + lastCommit := &types.Commit{} + for height := int64(1); height <= 4; height++ { + b := makeCommittedBlock(ctx, t, state, privVals, height, lastCommit) + state, err = goodExec.ApplyBlock(ctx, state, b.id, b.block, nil) + utilsrequire.NoError(t, err) + goodReactor.store.SaveBlock(b.block, b.parts, b.commit) + honest = append(honest, b) + lastCommit = b.commit + } + + // The bad node has the state of the good node. It stores blocks 1 to 3, and a block 4 + // whose commit for block 3 is invalid. + utilsrequire.NoError(t, badReactor.stateStore.Save(state)) + for _, b := range honest[:3] { + badReactor.store.SaveBlock(b.block, b.parts, b.commit) + } + badBlock4 := withBadLastSignature(t, honest[3].block, tc.flag) + badParts4, err := badBlock4.MakePartSet(types.BlockPartSizeBytes) + utilsrequire.NoError(t, err) + badReactor.store.SaveBlock(badBlock4, badParts4, honest[3].commit) + + // The syncing node reports every block it saves. The events channel has room for 3 + // saves and 1 disconnection. NewReactor takes a concrete block store, so the recording + // store goes on the sync controller. + events := make(chan syncEvent, 4) + syncer := syncReactor.syncer.OrPanic("syncer should be configured in tests") + syncer.store = saveRecordingStore{BlockStore: syncer.store, events: events} + observer := syncObserver{events: events} + + // Start the reactors. + for _, r := range []*Reactor{goodReactor, badReactor, syncReactor} { + utilsrequire.NoError(t, r.Start(ctx)) + t.Cleanup(r.Wait) + } + + err = scope.Run(ctx, func(ctx context.Context, s scope.Scope) error { + // Report the end of the first connection to the bad node. + s.SpawnBgNamed("wait for disconnection", func() error { + if err := waitForDisconnect(ctx, syncNode, badConn); err != nil { + return utils.IgnoreCancel(err) + } + return utils.IgnoreCancel(utils.Send(ctx, events, syncEvent{})) + }) + + // Block 1 is saved with its honest seen commit. + if err := observer.expectSaved(ctx, honest[0].block, honest[0].commit); err != nil { + return err + } + // Block 2 is saved with its honest seen commit. + if err := observer.expectSaved(ctx, honest[1].block, honest[1].commit); err != nil { + return err + } + // The connection to the bad node closes, and block 3 is not saved. + return observer.expectDisconnected(ctx) + }) + utilsrequire.NoError(t, err) + + // Stop the bad node and remove it from the network. + badReactor.Stop() + network.Remove(t, badID) + + // The good node connects, and block 3 is saved with its honest seen commit. + utilsrequire.NoError(t, goodNode.Connect(ctx, syncNode)) + utilsrequire.NoError(t, observer.expectSaved(ctx, honest[2].block, honest[2].commit)) + }) + } +} From 98c9057a30577021d718461c41e3eee554732a3a Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Fri, 13 Nov 2026 08:44:00 -0700 Subject: [PATCH 02/15] take the block store interface in NewReactor --- sei-tendermint/internal/blocksync/reactor.go | 3 +- .../internal/blocksync/reactor_test.go | 23 ++++++++++---- .../reactor_validation_failure_test.go | 31 ++++++++++--------- 3 files changed, 34 insertions(+), 23 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor.go b/sei-tendermint/internal/blocksync/reactor.go index 4b980e7f9c..68b806965b 100644 --- a/sei-tendermint/internal/blocksync/reactor.go +++ b/sei-tendermint/internal/blocksync/reactor.go @@ -13,7 +13,6 @@ import ( "github.com/sei-protocol/sei-chain/sei-tendermint/internal/eventbus" "github.com/sei-protocol/sei-chain/sei-tendermint/internal/p2p" sm "github.com/sei-protocol/sei-chain/sei-tendermint/internal/state" - "github.com/sei-protocol/sei-chain/sei-tendermint/internal/store" "github.com/sei-protocol/sei-chain/sei-tendermint/libs/service" "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils" "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/scope" @@ -165,7 +164,7 @@ type syncController struct { // NewReactor returns new reactor instance. func NewReactor( stateStore sm.Store, - store *store.BlockStore, + store sm.BlockStore, router *p2p.Router, syncerConfig utils.Option[SyncerConfig], ) (*Reactor, error) { diff --git a/sei-tendermint/internal/blocksync/reactor_test.go b/sei-tendermint/internal/blocksync/reactor_test.go index d8014954dd..6d7f8472d1 100644 --- a/sei-tendermint/internal/blocksync/reactor_test.go +++ b/sei-tendermint/internal/blocksync/reactor_test.go @@ -79,11 +79,18 @@ func setup( return rts } +// newMemBlockStore returns a block store backed by a fresh in-memory database. +func newMemBlockStore() sm.BlockStore { + return store.NewBlockStore(dbm.NewMemDB()) +} + +// makeReactor returns a reactor serving genDoc on router, backed by blockStore. func makeReactor( ctx context.Context, t *testing.T, genDoc *types.GenesisDoc, router *p2p.Router, + blockStore sm.BlockStore, blockSync bool, restartEvent func(), selfRemediationConfig *config.SelfRemediationConfig, @@ -91,10 +98,8 @@ func makeReactor( app := abci.BaseApplication{} - blockDB := dbm.NewMemDB() stateDB := dbm.NewMemDB() stateStore := sm.NewStore(stateDB) - blockStore := store.NewBlockStore(blockDB) proxyApp := proxy.New(app) state, err := sm.MakeGenesisState(genDoc) @@ -148,11 +153,13 @@ func (rts *reactorTestSuite) addNode( remediationConfig := config.DefaultSelfRemediationConfig() remediationConfig.BlocksBehindThreshold = 1000 + blockStore := newMemBlockStore() reactor := makeReactor( ctx, t, genDoc, rts.network.Node(nodeID).Router, + blockStore, true, func() {}, remediationConfig, @@ -168,7 +175,7 @@ func (rts *reactorTestSuite) addNode( state, err = syncer.blockExec.ApplyBlock(ctx, state, blockID, block, nil) require.NoError(t, err) - reactor.store.SaveBlock(block, partSet, seenCommit) + blockStore.SaveBlock(block, partSet, seenCommit) lastCommit = seenCommit } @@ -493,11 +500,13 @@ func TestQueryResponder_ServesBlockRequestsWhenBlockSyncDisabled(t *testing.T) { network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 2}) nodeIDs := network.NodeIDs() + blockStore := newMemBlockStore() server := makeReactor( ctx, t, genDoc, network.Node(nodeIDs[0]).Router, + blockStore, false, func() {}, config.DefaultSelfRemediationConfig(), @@ -509,7 +518,7 @@ func TestQueryResponder_ServesBlockRequestsWhenBlockSyncDisabled(t *testing.T) { block, blockID, partSet, seenCommit := makeNextBlock(ctx, t, state, privVals[0], height, lastCommit) state, err = server.syncer.OrPanic("syncer should be configured in tests").blockExec.ApplyBlock(ctx, state, blockID, block, nil) require.NoError(t, err) - server.store.SaveBlock(block, partSet, seenCommit) + blockStore.SaveBlock(block, partSet, seenCommit) lastCommit = seenCommit } require.NoError(t, server.Start(ctx)) @@ -563,11 +572,13 @@ func TestQueryResponder_ServesStatusRequestsWhenBlockSyncDisabled(t *testing.T) network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 2}) nodeIDs := network.NodeIDs() + blockStore := newMemBlockStore() server := makeReactor( ctx, t, genDoc, network.Node(nodeIDs[0]).Router, + blockStore, false, func() {}, config.DefaultSelfRemediationConfig(), @@ -584,7 +595,7 @@ func TestQueryResponder_ServesStatusRequestsWhenBlockSyncDisabled(t *testing.T) statusResponse, ok := msg.Message.Sum.(*pb.Message_StatusResponse) require.True(t, ok) - require.Equal(t, server.store.Base(), statusResponse.StatusResponse.GetBase()) - require.Equal(t, server.store.Height(), statusResponse.StatusResponse.GetHeight()) + require.Equal(t, blockStore.Base(), statusResponse.StatusResponse.GetBase()) + require.Equal(t, blockStore.Height(), statusResponse.StatusResponse.GetHeight()) require.Equal(t, nodeIDs[0], msg.From) } diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index bb4e11ac7c..e9e7618970 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -289,7 +289,8 @@ func (o syncObserver) expectDisconnected(ctx context.Context) error { } // waitForDisconnect waits until conn is no longer a connection of node. It returns the -// context error when ctx is done first. +// context error when ctx is done first. It watches this one connection rather than any +// connection to the same node, because the router may redial an evicted peer at once. func waitForDisconnect(ctx context.Context, node *p2p.TestNode, conn *p2p.ConnV2) (err error) { // WaitForDisconnect panics with the context error. defer func() { @@ -329,8 +330,16 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { nodeIDs := network.NodeIDs() badID, syncID := nodeIDs[0], nodeIDs[1] syncNode := network.Node(syncID) - badReactor := makeReactor(ctx, t, genDoc, network.Node(badID).Router, false, func() {}, config.DefaultSelfRemediationConfig()) - syncReactor := makeReactor(ctx, t, genDoc, syncNode.Router, true, func() {}, config.DefaultSelfRemediationConfig()) + + // The syncing node reports every block it saves. The events channel has room for 3 + // saves and 1 disconnection. + events := make(chan syncEvent, 4) + observer := syncObserver{events: events} + syncStore := saveRecordingStore{BlockStore: newMemBlockStore(), events: events} + + badStore, goodStore := newMemBlockStore(), newMemBlockStore() + badReactor := makeReactor(ctx, t, genDoc, network.Node(badID).Router, badStore, false, func() {}, config.DefaultSelfRemediationConfig()) + syncReactor := makeReactor(ctx, t, genDoc, syncNode.Router, syncStore, true, func() {}, config.DefaultSelfRemediationConfig()) // Connect the bad node and the syncing node. network.Start(t) @@ -338,7 +347,7 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { // The good node is not connected to anyone yet. goodNode := network.MakeNode(t, p2p.TestNodeOptions{}) - goodReactor := makeReactor(ctx, t, genDoc, goodNode.Router, false, func() {}, config.DefaultSelfRemediationConfig()) + goodReactor := makeReactor(ctx, t, genDoc, goodNode.Router, goodStore, false, func() {}, config.DefaultSelfRemediationConfig()) // The good node applies and stores honest blocks 1 to 4. goodExec := goodReactor.syncer.OrPanic("syncer should be configured in tests").blockExec @@ -350,7 +359,7 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { b := makeCommittedBlock(ctx, t, state, privVals, height, lastCommit) state, err = goodExec.ApplyBlock(ctx, state, b.id, b.block, nil) utilsrequire.NoError(t, err) - goodReactor.store.SaveBlock(b.block, b.parts, b.commit) + goodStore.SaveBlock(b.block, b.parts, b.commit) honest = append(honest, b) lastCommit = b.commit } @@ -359,20 +368,12 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { // whose commit for block 3 is invalid. utilsrequire.NoError(t, badReactor.stateStore.Save(state)) for _, b := range honest[:3] { - badReactor.store.SaveBlock(b.block, b.parts, b.commit) + badStore.SaveBlock(b.block, b.parts, b.commit) } badBlock4 := withBadLastSignature(t, honest[3].block, tc.flag) badParts4, err := badBlock4.MakePartSet(types.BlockPartSizeBytes) utilsrequire.NoError(t, err) - badReactor.store.SaveBlock(badBlock4, badParts4, honest[3].commit) - - // The syncing node reports every block it saves. The events channel has room for 3 - // saves and 1 disconnection. NewReactor takes a concrete block store, so the recording - // store goes on the sync controller. - events := make(chan syncEvent, 4) - syncer := syncReactor.syncer.OrPanic("syncer should be configured in tests") - syncer.store = saveRecordingStore{BlockStore: syncer.store, events: events} - observer := syncObserver{events: events} + badStore.SaveBlock(badBlock4, badParts4, honest[3].commit) // Start the reactors. for _, r := range []*Reactor{goodReactor, badReactor, syncReactor} { From 19094204e7b4412e6de17223598bd48f266bed77 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Fri, 13 Nov 2026 08:44:37 -0700 Subject: [PATCH 03/15] use one block fixture generator in the blocksync tests --- .../internal/blocksync/reactor_test.go | 69 +++++++++---------- .../reactor_validation_failure_test.go | 30 -------- 2 files changed, 33 insertions(+), 66 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_test.go b/sei-tendermint/internal/blocksync/reactor_test.go index 6d7f8472d1..1b64103f53 100644 --- a/sei-tendermint/internal/blocksync/reactor_test.go +++ b/sei-tendermint/internal/blocksync/reactor_test.go @@ -28,6 +28,7 @@ import ( "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils" utilsrequire "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/require" pb "github.com/sei-protocol/sei-chain/sei-tendermint/proto/tendermint/blocksync" + tmproto "github.com/sei-protocol/sei-chain/sei-tendermint/proto/tendermint/types" "github.com/sei-protocol/sei-chain/sei-tendermint/types" ) @@ -169,14 +170,14 @@ func (rts *reactorTestSuite) addNode( state, err := reactor.stateStore.Load() require.NoError(t, err) for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ { - block, blockID, partSet, seenCommit := makeNextBlock(ctx, t, state, privVal, blockHeight, lastCommit) + b := makeCommittedBlock(ctx, t, state, utils.Slice(privVal), blockHeight, lastCommit) syncer := reactor.syncer.OrPanic("syncer should be configured in tests") - state, err = syncer.blockExec.ApplyBlock(ctx, state, blockID, block, nil) + state, err = syncer.blockExec.ApplyBlock(ctx, state, b.id, b.block, nil) require.NoError(t, err) - blockStore.SaveBlock(block, partSet, seenCommit) - lastCommit = seenCommit + blockStore.SaveBlock(b.block, b.parts, b.commit) + lastCommit = b.commit } rts.reactors[nodeID] = reactor @@ -184,37 +185,33 @@ func (rts *reactorTestSuite) addNode( require.True(t, reactor.IsRunning()) } -func makeNextBlock(ctx context.Context, +// committedBlock is a block with its ID, its part set, and a commit for it. +type committedBlock struct { + block *types.Block + id types.BlockID + parts *types.PartSet + commit *types.Commit +} + +// makeCommittedBlock returns the block at height on top of state, with lastCommit as its last +// commit, and a commit for it signed by every validator in privVals. +func makeCommittedBlock( + ctx context.Context, t *testing.T, state sm.State, - signer types.PrivValidator, + privVals []types.PrivValidator, height int64, - lc *types.Commit) (*types.Block, types.BlockID, *types.PartSet, *types.Commit) { - block := sf.MakeBlock(state, height, lc) - partSet, err := block.MakePartSet(types.BlockPartSizeBytes) - require.NoError(t, err) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: partSet.Header()} - - // Simulate a commit for the current height - vote, err := factory.MakeVote( - ctx, - signer, - block.Header.ChainID, - 0, - block.Header.Height, - 0, - 2, - blockID, - time.Now(), - ) - require.NoError(t, err) - seenCommit := &types.Commit{ - Height: vote.Height, - Round: vote.Round, - BlockID: blockID, - Signatures: []types.CommitSig{vote.CommitSig()}, - } - return block, blockID, partSet, seenCommit + lastCommit *types.Commit, +) committedBlock { + t.Helper() + block := sf.MakeBlock(state, height, lastCommit) + parts, err := block.MakePartSet(types.BlockPartSizeBytes) + utilsrequire.NoError(t, err) + id := types.BlockID{Hash: block.Hash(), PartSetHeader: parts.Header()} + voteSet := types.NewVoteSet(state.ChainID, height, 0, tmproto.PrecommitType, state.Validators) + commit, err := factory.MakeCommit(ctx, id, height, 0, voteSet, privVals, time.Now()) + utilsrequire.NoError(t, err) + return committedBlock{block: block, id: id, parts: parts, commit: commit} } func (rts *reactorTestSuite) start(t *testing.T) { @@ -515,11 +512,11 @@ func TestQueryResponder_ServesBlockRequestsWhenBlockSyncDisabled(t *testing.T) { state, err := server.stateStore.Load() require.NoError(t, err) for height := int64(1); height <= 3; height++ { - block, blockID, partSet, seenCommit := makeNextBlock(ctx, t, state, privVals[0], height, lastCommit) - state, err = server.syncer.OrPanic("syncer should be configured in tests").blockExec.ApplyBlock(ctx, state, blockID, block, nil) + b := makeCommittedBlock(ctx, t, state, privVals, height, lastCommit) + state, err = server.syncer.OrPanic("syncer should be configured in tests").blockExec.ApplyBlock(ctx, state, b.id, b.block, nil) require.NoError(t, err) - blockStore.SaveBlock(block, partSet, seenCommit) - lastCommit = seenCommit + blockStore.SaveBlock(b.block, b.parts, b.commit) + lastCommit = b.commit } require.NoError(t, server.Start(ctx)) t.Cleanup(server.Wait) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index e9e7618970..a7e2dac31e 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -19,7 +19,6 @@ import ( "github.com/sei-protocol/sei-chain/sei-tendermint/config" "github.com/sei-protocol/sei-chain/sei-tendermint/internal/p2p" sm "github.com/sei-protocol/sei-chain/sei-tendermint/internal/state" - sf "github.com/sei-protocol/sei-chain/sei-tendermint/internal/state/test/factory" "github.com/sei-protocol/sei-chain/sei-tendermint/internal/test/factory" "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils" utilsrequire "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/require" @@ -51,35 +50,6 @@ func makeValidationFailurePair( return initialState, block1.block, withBadLastSignature(t, block2.block, tmproto.BlockIDFlagCommit) } -// committedBlock is a block with its ID, its part set, and a commit for it. -type committedBlock struct { - block *types.Block - id types.BlockID - parts *types.PartSet - commit *types.Commit -} - -// makeCommittedBlock returns the block at height on top of state, with lastCommit as its last -// commit, and a commit for it signed by every validator in privVals. -func makeCommittedBlock( - ctx context.Context, - t *testing.T, - state sm.State, - privVals []types.PrivValidator, - height int64, - lastCommit *types.Commit, -) committedBlock { - t.Helper() - block := sf.MakeBlock(state, height, lastCommit) - parts, err := block.MakePartSet(types.BlockPartSizeBytes) - utilsrequire.NoError(t, err) - id := types.BlockID{Hash: block.Hash(), PartSetHeader: parts.Header()} - voteSet := types.NewVoteSet(state.ChainID, height, 0, tmproto.PrecommitType, state.Validators) - commit, err := factory.MakeCommit(ctx, id, height, 0, voteSet, privVals, time.Now()) - utilsrequire.NoError(t, err) - return committedBlock{block: block, id: id, parts: parts, commit: commit} -} - // withBadLastSignature returns a copy of block whose last commit has a last signature that // does not verify, with flag as the block ID flag of that signature. func withBadLastSignature(t *testing.T, block *types.Block, flag tmproto.BlockIDFlag) *types.Block { From ee979bb8fe04f076ea39fa6465908d121d71f2c6 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Fri, 13 Nov 2026 09:34:44 -0700 Subject: [PATCH 04/15] rename test peers to invalidCommitPeer and correctPeer in blocksync validation tests --- .../reactor_validation_failure_test.go | 130 +++++++++--------- 1 file changed, 65 insertions(+), 65 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index a7e2dac31e..c83d073b69 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -73,11 +73,11 @@ func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { initialState, block1, badBlock2 := makeValidationFailurePair(ctx, t, "block_sync_validation_failure_does_not_return") - badPeer := types.NodeID(strings.Repeat("a", 40)) - goodPeer := types.NodeID(strings.Repeat("b", 40)) + invalidCommitPeer := types.NodeID(strings.Repeat("a", 40)) + correctPeer := types.NodeID(strings.Repeat("b", 40)) router := makeRouter(testPeers{ - badPeer: {id: badPeer, base: 1, height: 2, inputChan: make(chan inputData, 1)}, - goodPeer: {id: goodPeer, base: 1, height: 2, inputChan: make(chan inputData, 1)}, + invalidCommitPeer: {id: invalidCommitPeer, base: 1, height: 2, inputChan: make(chan inputData, 1)}, + correctPeer: {id: correctPeer, base: 1, height: 2, inputChan: make(chan inputData, 1)}, }) pool := NewBlockPool(1, router) done := make(chan error, 1) @@ -87,7 +87,7 @@ func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { t.Fatalf("pool.run(): %v", err) } }) - pool.SetPeerRange(badPeer, 1, 2) + pool.SetPeerRange(invalidCommitPeer, 1, 2) evictNetwork := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 1}) syncer := &syncController{ @@ -104,13 +104,13 @@ func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { utilsrequire.ErrorIs(t, err, context.Canceled) }) - introducedGoodPeer := false + introducedCorrectPeer := false for { select { case err := <-results: t.Fatalf("poolRoutine returned early after validation failure: %v", err) case request := <-pool.Requests(): - if request.PeerID == goodPeer { + if request.PeerID == correctPeer { return } @@ -119,9 +119,9 @@ func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { _ = pool.AddBlock(request.PeerID, block1, block1.Size()) case 2: _ = pool.AddBlock(request.PeerID, badBlock2, badBlock2.Size()) - if !introducedGoodPeer { - introducedGoodPeer = true - pool.SetPeerRange(goodPeer, 1, 2) + if !introducedCorrectPeer { + introducedCorrectPeer = true + pool.SetPeerRange(correctPeer, 1, 2) } } } @@ -134,17 +134,17 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { initialState, block1, badBlock2 := makeValidationFailurePair(ctx, t, "block_sync_retry_after_validation_failure") network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 1}) - badPeer := types.NodeID(strings.Repeat("a", 40)) - goodPeer1 := types.NodeID(strings.Repeat("b", 40)) - goodPeer2 := types.NodeID(strings.Repeat("c", 40)) + invalidCommitPeer := types.NodeID(strings.Repeat("a", 40)) + correctPeer1 := types.NodeID(strings.Repeat("b", 40)) + correctPeer2 := types.NodeID(strings.Repeat("c", 40)) peers := testPeers{ - badPeer: {id: badPeer, base: 1, height: 2, inputChan: make(chan inputData, 1)}, - goodPeer1: {id: goodPeer1, base: 1, height: 2, inputChan: make(chan inputData, 1)}, - goodPeer2: {id: goodPeer2, base: 1, height: 2, inputChan: make(chan inputData, 1)}, + invalidCommitPeer: {id: invalidCommitPeer, base: 1, height: 2, inputChan: make(chan inputData, 1)}, + correctPeer1: {id: correctPeer1, base: 1, height: 2, inputChan: make(chan inputData, 1)}, + correctPeer2: {id: correctPeer2, base: 1, height: 2, inputChan: make(chan inputData, 1)}, } pool := NewBlockPool(1, makeRouter(peers)) runPoolForTest(t, pool) - pool.SetPeerRange(badPeer, 1, 2) + pool.SetPeerRange(invalidCommitPeer, 1, 2) syncer := &syncController{ router: network.Node(network.NodeIDs()[0]).Router, @@ -160,7 +160,7 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { utilsrequire.ErrorIs(t, err, context.Canceled) }) - introducedGoodPeers := false + introducedCorrectPeers := false height1Requests := map[types.NodeID]int{} for { @@ -170,18 +170,18 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { case request := <-pool.Requests(): if request.Height == 1 { height1Requests[request.PeerID]++ - if request.PeerID != badPeer && height1Requests[request.PeerID] == 1 { + if request.PeerID != invalidCommitPeer && height1Requests[request.PeerID] == 1 { return } } - if request.PeerID == badPeer && request.Height == 2 && !introducedGoodPeers { - introducedGoodPeers = true - pool.SetPeerRange(goodPeer1, 1, 2) - pool.SetPeerRange(goodPeer2, 1, 2) + if request.PeerID == invalidCommitPeer && request.Height == 2 && !introducedCorrectPeers { + introducedCorrectPeers = true + pool.SetPeerRange(correctPeer1, 1, 2) + pool.SetPeerRange(correctPeer2, 1, 2) } - if request.PeerID == badPeer { + if request.PeerID == invalidCommitPeer { switch request.Height { case 1: _ = pool.AddBlock(request.PeerID, block1, block1.Size()) @@ -193,7 +193,7 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { } } -// syncEvent is a block save on the syncing node, or the close of its connection to the bad +// syncEvent is a block save on the syncing node, or the close of its connection to the invalid-commit // node when saved is empty. type syncEvent struct { saved utils.Option[savedBlock] @@ -234,7 +234,7 @@ func (o syncObserver) expectSaved(ctx context.Context, want *types.Block, wantSe } saved, ok := event.saved.Get() if !ok { - return fmt.Errorf("got disconnection of the bad node, want save of block %d", want.Height) + return fmt.Errorf("got disconnection of the invalid-commit node, want save of block %d", want.Height) } if err := utils.TestDiff(want.Hash(), saved.block.Hash()); err != nil { return fmt.Errorf("saved block %d: %w", want.Height, err) @@ -246,14 +246,14 @@ func (o syncObserver) expectSaved(ctx context.Context, want *types.Block, wantSe } // expectDisconnected receives the next event and returns an error unless it is the close of the -// connection to the bad node. +// connection to the invalid-commit node. func (o syncObserver) expectDisconnected(ctx context.Context) error { event, err := utils.Recv(ctx, o.events) if err != nil { return err } if saved, ok := event.saved.Get(); ok { - return fmt.Errorf("got save of block %d, want disconnection of the bad node", saved.block.Height) + return fmt.Errorf("got save of block %d, want disconnection of the invalid-commit node", saved.block.Height) } return nil } @@ -276,9 +276,9 @@ func waitForDisconnect(ctx context.Context, node *p2p.TestNode, conn *p2p.ConnV2 return nil } -// TestReactor_RejectsInvalidCommitFromPeer checks that a syncing node saves the blocks a bad +// TestReactor_RejectsInvalidCommitFromPeer checks that a syncing node saves the blocks an invalid-commit // peer serves up to the first block whose commit fails verification, evicts that peer, and then -// still makes progress by saving that block from a good peer. +// still makes progress by saving that block from a correct peer. func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { for _, tc := range []struct { name string @@ -298,7 +298,7 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams()) network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 2}) nodeIDs := network.NodeIDs() - badID, syncID := nodeIDs[0], nodeIDs[1] + invalidCommitID, syncID := nodeIDs[0], nodeIDs[1] syncNode := network.Node(syncID) // The syncing node reports every block it saves. The events channel has room for 3 @@ -307,79 +307,79 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { observer := syncObserver{events: events} syncStore := saveRecordingStore{BlockStore: newMemBlockStore(), events: events} - badStore, goodStore := newMemBlockStore(), newMemBlockStore() - badReactor := makeReactor(ctx, t, genDoc, network.Node(badID).Router, badStore, false, func() {}, config.DefaultSelfRemediationConfig()) + invalidCommitStore, correctStore := newMemBlockStore(), newMemBlockStore() + invalidCommitReactor := makeReactor(ctx, t, genDoc, network.Node(invalidCommitID).Router, invalidCommitStore, false, func() {}, config.DefaultSelfRemediationConfig()) syncReactor := makeReactor(ctx, t, genDoc, syncNode.Router, syncStore, true, func() {}, config.DefaultSelfRemediationConfig()) - // Connect the bad node and the syncing node. + // Connect the invalid-commit node and the syncing node. network.Start(t) - badConn := syncNode.WaitForConnAndGet(ctx, badID) + invalidCommitConn := syncNode.WaitForConnAndGet(ctx, invalidCommitID) - // The good node is not connected to anyone yet. - goodNode := network.MakeNode(t, p2p.TestNodeOptions{}) - goodReactor := makeReactor(ctx, t, genDoc, goodNode.Router, goodStore, false, func() {}, config.DefaultSelfRemediationConfig()) + // The correct node is not connected to anyone yet. + correctNode := network.MakeNode(t, p2p.TestNodeOptions{}) + correctReactor := makeReactor(ctx, t, genDoc, correctNode.Router, correctStore, false, func() {}, config.DefaultSelfRemediationConfig()) - // The good node applies and stores honest blocks 1 to 4. - goodExec := goodReactor.syncer.OrPanic("syncer should be configured in tests").blockExec - state, err := goodReactor.stateStore.Load() + // The correct node applies and stores correct blocks 1 to 4. + correctExec := correctReactor.syncer.OrPanic("syncer should be configured in tests").blockExec + state, err := correctReactor.stateStore.Load() utilsrequire.NoError(t, err) - var honest []committedBlock + var correct []committedBlock lastCommit := &types.Commit{} for height := int64(1); height <= 4; height++ { b := makeCommittedBlock(ctx, t, state, privVals, height, lastCommit) - state, err = goodExec.ApplyBlock(ctx, state, b.id, b.block, nil) + state, err = correctExec.ApplyBlock(ctx, state, b.id, b.block, nil) utilsrequire.NoError(t, err) - goodStore.SaveBlock(b.block, b.parts, b.commit) - honest = append(honest, b) + correctStore.SaveBlock(b.block, b.parts, b.commit) + correct = append(correct, b) lastCommit = b.commit } - // The bad node has the state of the good node. It stores blocks 1 to 3, and a block 4 + // The invalid-commit node has the state of the correct node. It stores blocks 1 to 3, and a block 4 // whose commit for block 3 is invalid. - utilsrequire.NoError(t, badReactor.stateStore.Save(state)) - for _, b := range honest[:3] { - badStore.SaveBlock(b.block, b.parts, b.commit) + utilsrequire.NoError(t, invalidCommitReactor.stateStore.Save(state)) + for _, b := range correct[:3] { + invalidCommitStore.SaveBlock(b.block, b.parts, b.commit) } - badBlock4 := withBadLastSignature(t, honest[3].block, tc.flag) + badBlock4 := withBadLastSignature(t, correct[3].block, tc.flag) badParts4, err := badBlock4.MakePartSet(types.BlockPartSizeBytes) utilsrequire.NoError(t, err) - badStore.SaveBlock(badBlock4, badParts4, honest[3].commit) + invalidCommitStore.SaveBlock(badBlock4, badParts4, correct[3].commit) // Start the reactors. - for _, r := range []*Reactor{goodReactor, badReactor, syncReactor} { + for _, r := range []*Reactor{correctReactor, invalidCommitReactor, syncReactor} { utilsrequire.NoError(t, r.Start(ctx)) t.Cleanup(r.Wait) } err = scope.Run(ctx, func(ctx context.Context, s scope.Scope) error { - // Report the end of the first connection to the bad node. + // Report the end of the first connection to the invalid-commit node. s.SpawnBgNamed("wait for disconnection", func() error { - if err := waitForDisconnect(ctx, syncNode, badConn); err != nil { + if err := waitForDisconnect(ctx, syncNode, invalidCommitConn); err != nil { return utils.IgnoreCancel(err) } return utils.IgnoreCancel(utils.Send(ctx, events, syncEvent{})) }) - // Block 1 is saved with its honest seen commit. - if err := observer.expectSaved(ctx, honest[0].block, honest[0].commit); err != nil { + // Block 1 is saved with its correct seen commit. + if err := observer.expectSaved(ctx, correct[0].block, correct[0].commit); err != nil { return err } - // Block 2 is saved with its honest seen commit. - if err := observer.expectSaved(ctx, honest[1].block, honest[1].commit); err != nil { + // Block 2 is saved with its correct seen commit. + if err := observer.expectSaved(ctx, correct[1].block, correct[1].commit); err != nil { return err } - // The connection to the bad node closes, and block 3 is not saved. + // The connection to the invalid-commit node closes, and block 3 is not saved. return observer.expectDisconnected(ctx) }) utilsrequire.NoError(t, err) - // Stop the bad node and remove it from the network. - badReactor.Stop() - network.Remove(t, badID) + // Stop the invalid-commit node and remove it from the network. + invalidCommitReactor.Stop() + network.Remove(t, invalidCommitID) - // The good node connects, and block 3 is saved with its honest seen commit. - utilsrequire.NoError(t, goodNode.Connect(ctx, syncNode)) - utilsrequire.NoError(t, observer.expectSaved(ctx, honest[2].block, honest[2].commit)) + // The correct node connects, and block 3 is saved with its correct seen commit. + utilsrequire.NoError(t, correctNode.Connect(ctx, syncNode)) + utilsrequire.NoError(t, observer.expectSaved(ctx, correct[2].block, correct[2].commit)) }) } } From 5c37d91427db478bfeb582342df7a7bb373a0cb6 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 16:13:12 -0700 Subject: [PATCH 05/15] minor formatting fix --- .../internal/blocksync/reactor_validation_failure_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index c83d073b69..cd50c4e8ae 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -276,7 +276,7 @@ func waitForDisconnect(ctx context.Context, node *p2p.TestNode, conn *p2p.ConnV2 return nil } -// TestReactor_RejectsInvalidCommitFromPeer checks that a syncing node saves the blocks an invalid-commit +// TestReactor_RejectsInvalidCommitFromPeer checks that a syncing node saves the blocks an invalid-commit // peer serves up to the first block whose commit fails verification, evicts that peer, and then // still makes progress by saving that block from a correct peer. func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { From 6631445e03e8aeb4bee00fe3c2de2076f50b9bfd Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 16:30:20 -0700 Subject: [PATCH 06/15] save and read fixture blocks through the reactor store in the older blocksync tests --- .../internal/blocksync/reactor_test.go | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_test.go b/sei-tendermint/internal/blocksync/reactor_test.go index 1b64103f53..1690cf2c76 100644 --- a/sei-tendermint/internal/blocksync/reactor_test.go +++ b/sei-tendermint/internal/blocksync/reactor_test.go @@ -154,13 +154,12 @@ func (rts *reactorTestSuite) addNode( remediationConfig := config.DefaultSelfRemediationConfig() remediationConfig.BlocksBehindThreshold = 1000 - blockStore := newMemBlockStore() reactor := makeReactor( ctx, t, genDoc, rts.network.Node(nodeID).Router, - blockStore, + newMemBlockStore(), true, func() {}, remediationConfig, @@ -176,7 +175,7 @@ func (rts *reactorTestSuite) addNode( state, err = syncer.blockExec.ApplyBlock(ctx, state, b.id, b.block, nil) require.NoError(t, err) - blockStore.SaveBlock(b.block, b.parts, b.commit) + reactor.store.SaveBlock(b.block, b.parts, b.commit) lastCommit = b.commit } @@ -497,13 +496,12 @@ func TestQueryResponder_ServesBlockRequestsWhenBlockSyncDisabled(t *testing.T) { network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 2}) nodeIDs := network.NodeIDs() - blockStore := newMemBlockStore() server := makeReactor( ctx, t, genDoc, network.Node(nodeIDs[0]).Router, - blockStore, + newMemBlockStore(), false, func() {}, config.DefaultSelfRemediationConfig(), @@ -515,7 +513,7 @@ func TestQueryResponder_ServesBlockRequestsWhenBlockSyncDisabled(t *testing.T) { b := makeCommittedBlock(ctx, t, state, privVals, height, lastCommit) state, err = server.syncer.OrPanic("syncer should be configured in tests").blockExec.ApplyBlock(ctx, state, b.id, b.block, nil) require.NoError(t, err) - blockStore.SaveBlock(b.block, b.parts, b.commit) + server.store.SaveBlock(b.block, b.parts, b.commit) lastCommit = b.commit } require.NoError(t, server.Start(ctx)) @@ -569,13 +567,12 @@ func TestQueryResponder_ServesStatusRequestsWhenBlockSyncDisabled(t *testing.T) network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 2}) nodeIDs := network.NodeIDs() - blockStore := newMemBlockStore() server := makeReactor( ctx, t, genDoc, network.Node(nodeIDs[0]).Router, - blockStore, + newMemBlockStore(), false, func() {}, config.DefaultSelfRemediationConfig(), @@ -592,7 +589,7 @@ func TestQueryResponder_ServesStatusRequestsWhenBlockSyncDisabled(t *testing.T) statusResponse, ok := msg.Message.Sum.(*pb.Message_StatusResponse) require.True(t, ok) - require.Equal(t, blockStore.Base(), statusResponse.StatusResponse.GetBase()) - require.Equal(t, blockStore.Height(), statusResponse.StatusResponse.GetHeight()) + require.Equal(t, server.store.Base(), statusResponse.StatusResponse.GetBase()) + require.Equal(t, server.store.Height(), statusResponse.StatusResponse.GetHeight()) require.Equal(t, nodeIDs[0], msg.From) } From d5400e9055038d3c830d7fc07d0c252154dd7a93 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 16:32:52 -0700 Subject: [PATCH 07/15] drop the leaktest check from the blocksync validation test --- .../internal/blocksync/reactor_validation_failure_test.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index cd50c4e8ae..e66a382094 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -14,8 +14,6 @@ import ( "testing" "time" - "github.com/fortytw2/leaktest" - "github.com/sei-protocol/sei-chain/sei-tendermint/config" "github.com/sei-protocol/sei-chain/sei-tendermint/internal/p2p" sm "github.com/sei-protocol/sei-chain/sei-tendermint/internal/state" @@ -288,8 +286,6 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { {name: "nil vote", flag: tmproto.BlockIDFlagNil}, } { t.Run(tc.name, func(t *testing.T) { - // After every other cleanup, no goroutine of the nodes is left running. - t.Cleanup(leaktest.Check(t)) ctx := t.Context() cfg, err := config.ResetTestRoot(t.TempDir(), "block_sync_invalid_commit") From 8e02cd996157b0fd496c6d07884f9a6f887f1086 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 16:35:07 -0700 Subject: [PATCH 08/15] let the type assertion panic on a non-error value in waitForDisconnect --- .../internal/blocksync/reactor_validation_failure_test.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index e66a382094..d4bba26636 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -263,11 +263,7 @@ func waitForDisconnect(ctx context.Context, node *p2p.TestNode, conn *p2p.ConnV2 // WaitForDisconnect panics with the context error. defer func() { if r := recover(); r != nil { - ctxErr, ok := r.(error) - if !ok { - panic(r) - } - err = ctxErr + err = r.(error) } }() node.WaitForDisconnect(ctx, conn) From 04d96c3268de27c0c2962e7ef00ce787b16ac61b Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 16:55:29 -0700 Subject: [PATCH 09/15] wait for the peer disconnect in the main task of the blocksync validation test --- .../reactor_validation_failure_test.go | 83 ++++--------------- 1 file changed, 15 insertions(+), 68 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index d4bba26636..1420c4c435 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -20,7 +20,6 @@ import ( "github.com/sei-protocol/sei-chain/sei-tendermint/internal/test/factory" "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils" utilsrequire "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/require" - "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/scope" tmproto "github.com/sei-protocol/sei-chain/sei-tendermint/proto/tendermint/types" "github.com/sei-protocol/sei-chain/sei-tendermint/types" ) @@ -191,12 +190,6 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { } } -// syncEvent is a block save on the syncing node, or the close of its connection to the invalid-commit -// node when saved is empty. -type syncEvent struct { - saved utils.Option[savedBlock] -} - // savedBlock is a block and the seen commit saved with it. type savedBlock struct { block *types.Block @@ -206,34 +199,30 @@ type savedBlock struct { // saveRecordingStore is a block store that reports every saved block on events. type saveRecordingStore struct { sm.BlockStore - events chan<- syncEvent + events chan<- savedBlock } func (s saveRecordingStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) { s.BlockStore.SaveBlock(block, blockParts, seenCommit) select { - case s.events <- syncEvent{saved: utils.Some(savedBlock{block: block, seenCommit: seenCommit})}: + case s.events <- savedBlock{block: block, seenCommit: seenCommit}: default: panic("events channel full") } } -// syncObserver reads the events of a syncing node in order and checks each one. +// syncObserver reads the saves of a syncing node in order and checks each one. type syncObserver struct { - events <-chan syncEvent + events <-chan savedBlock } -// expectSaved receives the next event and returns an error unless it is a save of want with +// expectSaved receives the next save and returns an error unless it is a save of want with // wantSeenCommit. func (o syncObserver) expectSaved(ctx context.Context, want *types.Block, wantSeenCommit *types.Commit) error { - event, err := utils.Recv(ctx, o.events) + saved, err := utils.Recv(ctx, o.events) if err != nil { return err } - saved, ok := event.saved.Get() - if !ok { - return fmt.Errorf("got disconnection of the invalid-commit node, want save of block %d", want.Height) - } if err := utils.TestDiff(want.Hash(), saved.block.Hash()); err != nil { return fmt.Errorf("saved block %d: %w", want.Height, err) } @@ -243,33 +232,6 @@ func (o syncObserver) expectSaved(ctx context.Context, want *types.Block, wantSe return nil } -// expectDisconnected receives the next event and returns an error unless it is the close of the -// connection to the invalid-commit node. -func (o syncObserver) expectDisconnected(ctx context.Context) error { - event, err := utils.Recv(ctx, o.events) - if err != nil { - return err - } - if saved, ok := event.saved.Get(); ok { - return fmt.Errorf("got save of block %d, want disconnection of the invalid-commit node", saved.block.Height) - } - return nil -} - -// waitForDisconnect waits until conn is no longer a connection of node. It returns the -// context error when ctx is done first. It watches this one connection rather than any -// connection to the same node, because the router may redial an evicted peer at once. -func waitForDisconnect(ctx context.Context, node *p2p.TestNode, conn *p2p.ConnV2) (err error) { - // WaitForDisconnect panics with the context error. - defer func() { - if r := recover(); r != nil { - err = r.(error) - } - }() - node.WaitForDisconnect(ctx, conn) - return nil -} - // TestReactor_RejectsInvalidCommitFromPeer checks that a syncing node saves the blocks an invalid-commit // peer serves up to the first block whose commit fails verification, evicts that peer, and then // still makes progress by saving that block from a correct peer. @@ -293,9 +255,9 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { invalidCommitID, syncID := nodeIDs[0], nodeIDs[1] syncNode := network.Node(syncID) - // The syncing node reports every block it saves. The events channel has room for 3 - // saves and 1 disconnection. - events := make(chan syncEvent, 4) + // The syncing node reports every block it saves. The events channel has room for + // blocks 1 to 3, the most the syncing node can save in this test. + events := make(chan savedBlock, 3) observer := syncObserver{events: events} syncStore := saveRecordingStore{BlockStore: newMemBlockStore(), events: events} @@ -343,27 +305,12 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { t.Cleanup(r.Wait) } - err = scope.Run(ctx, func(ctx context.Context, s scope.Scope) error { - // Report the end of the first connection to the invalid-commit node. - s.SpawnBgNamed("wait for disconnection", func() error { - if err := waitForDisconnect(ctx, syncNode, invalidCommitConn); err != nil { - return utils.IgnoreCancel(err) - } - return utils.IgnoreCancel(utils.Send(ctx, events, syncEvent{})) - }) - - // Block 1 is saved with its correct seen commit. - if err := observer.expectSaved(ctx, correct[0].block, correct[0].commit); err != nil { - return err - } - // Block 2 is saved with its correct seen commit. - if err := observer.expectSaved(ctx, correct[1].block, correct[1].commit); err != nil { - return err - } - // The connection to the invalid-commit node closes, and block 3 is not saved. - return observer.expectDisconnected(ctx) - }) - utilsrequire.NoError(t, err) + // The syncing node saves blocks 1 and 2 with their correct seen commits, rejects block 3, + // and closes its connection to the invalid-commit node. + syncNode.WaitForDisconnect(ctx, invalidCommitConn) + utilsrequire.NoError(t, observer.expectSaved(ctx, correct[0].block, correct[0].commit)) + utilsrequire.NoError(t, observer.expectSaved(ctx, correct[1].block, correct[1].commit)) + utilsrequire.Equal(t, 0, len(events)) // Stop the invalid-commit node and remove it from the network. invalidCommitReactor.Stop() From d434138c5c7c7bb9ce5e137b260f098a9681f078 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 17:02:28 -0700 Subject: [PATCH 10/15] assert the store content of the syncing node instead of the order of its saves --- .../reactor_validation_failure_test.go | 70 ++++++------------- 1 file changed, 20 insertions(+), 50 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index 1420c4c435..cd829eb65c 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -9,7 +9,6 @@ package blocksync import ( "context" "errors" - "fmt" "strings" "testing" "time" @@ -190,46 +189,15 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { } } -// savedBlock is a block and the seen commit saved with it. -type savedBlock struct { - block *types.Block - seenCommit *types.Commit -} - -// saveRecordingStore is a block store that reports every saved block on events. -type saveRecordingStore struct { +// heightWatchStore is a block store that publishes the height of every block it saves. +type heightWatchStore struct { sm.BlockStore - events chan<- savedBlock + savedHeight *utils.AtomicSend[int64] } -func (s saveRecordingStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) { +func (s heightWatchStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) { s.BlockStore.SaveBlock(block, blockParts, seenCommit) - select { - case s.events <- savedBlock{block: block, seenCommit: seenCommit}: - default: - panic("events channel full") - } -} - -// syncObserver reads the saves of a syncing node in order and checks each one. -type syncObserver struct { - events <-chan savedBlock -} - -// expectSaved receives the next save and returns an error unless it is a save of want with -// wantSeenCommit. -func (o syncObserver) expectSaved(ctx context.Context, want *types.Block, wantSeenCommit *types.Commit) error { - saved, err := utils.Recv(ctx, o.events) - if err != nil { - return err - } - if err := utils.TestDiff(want.Hash(), saved.block.Hash()); err != nil { - return fmt.Errorf("saved block %d: %w", want.Height, err) - } - if err := utils.TestDiff(wantSeenCommit.ToProto(), saved.seenCommit.ToProto()); err != nil { - return fmt.Errorf("seen commit of block %d: %w", want.Height, err) - } - return nil + s.savedHeight.Store(block.Height) } // TestReactor_RejectsInvalidCommitFromPeer checks that a syncing node saves the blocks an invalid-commit @@ -255,15 +223,13 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { invalidCommitID, syncID := nodeIDs[0], nodeIDs[1] syncNode := network.Node(syncID) - // The syncing node reports every block it saves. The events channel has room for - // blocks 1 to 3, the most the syncing node can save in this test. - events := make(chan savedBlock, 3) - observer := syncObserver{events: events} - syncStore := saveRecordingStore{BlockStore: newMemBlockStore(), events: events} + // The syncing node publishes the height of every block it saves. + savedHeight := utils.NewAtomicSend(int64(0)) invalidCommitStore, correctStore := newMemBlockStore(), newMemBlockStore() invalidCommitReactor := makeReactor(ctx, t, genDoc, network.Node(invalidCommitID).Router, invalidCommitStore, false, func() {}, config.DefaultSelfRemediationConfig()) - syncReactor := makeReactor(ctx, t, genDoc, syncNode.Router, syncStore, true, func() {}, config.DefaultSelfRemediationConfig()) + syncReactor := makeReactor(ctx, t, genDoc, syncNode.Router, + heightWatchStore{BlockStore: newMemBlockStore(), savedHeight: &savedHeight}, true, func() {}, config.DefaultSelfRemediationConfig()) // Connect the invalid-commit node and the syncing node. network.Start(t) @@ -305,20 +271,24 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { t.Cleanup(r.Wait) } - // The syncing node saves blocks 1 and 2 with their correct seen commits, rejects block 3, - // and closes its connection to the invalid-commit node. + // The syncing node saves blocks 1 and 2, rejects block 3, and closes its connection to the + // invalid-commit node. Its store then ends at block 2, with the correct seen commit of block 2. syncNode.WaitForDisconnect(ctx, invalidCommitConn) - utilsrequire.NoError(t, observer.expectSaved(ctx, correct[0].block, correct[0].commit)) - utilsrequire.NoError(t, observer.expectSaved(ctx, correct[1].block, correct[1].commit)) - utilsrequire.Equal(t, 0, len(events)) + utilsrequire.Equal(t, int64(2), syncReactor.store.Height()) + utilsrequire.NoError(t, utils.TestDiff(correct[1].block.Hash(), syncReactor.store.LoadBlock(2).Hash())) + utilsrequire.NoError(t, utils.TestDiff(correct[1].commit.Hash(), syncReactor.store.LoadSeenCommit().Hash())) // Stop the invalid-commit node and remove it from the network. invalidCommitReactor.Stop() network.Remove(t, invalidCommitID) - // The correct node connects, and block 3 is saved with its correct seen commit. + // The correct node connects, and the syncing node saves block 3 with its correct seen commit. utilsrequire.NoError(t, correctNode.Connect(ctx, syncNode)) - utilsrequire.NoError(t, observer.expectSaved(ctx, correct[2].block, correct[2].commit)) + _, err = savedHeight.Wait(ctx, func(h int64) bool { return h >= 3 }) + utilsrequire.NoError(t, err) + utilsrequire.Equal(t, int64(3), syncReactor.store.Height()) + utilsrequire.NoError(t, utils.TestDiff(correct[2].block.Hash(), syncReactor.store.LoadBlock(3).Hash())) + utilsrequire.NoError(t, utils.TestDiff(correct[2].commit.Hash(), syncReactor.store.LoadSeenCommit().Hash())) }) } } From 39eea39381315015288275769c2350011da65de8 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 17:12:26 -0700 Subject: [PATCH 11/15] import utils/require without an alias in the blocksync validation test --- .../reactor_validation_failure_test.go | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index cd829eb65c..46b241b579 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -18,7 +18,7 @@ import ( sm "github.com/sei-protocol/sei-chain/sei-tendermint/internal/state" "github.com/sei-protocol/sei-chain/sei-tendermint/internal/test/factory" "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils" - utilsrequire "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/require" + "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/require" tmproto "github.com/sei-protocol/sei-chain/sei-tendermint/proto/tendermint/types" "github.com/sei-protocol/sei-chain/sei-tendermint/types" ) @@ -33,12 +33,12 @@ func makeValidationFailurePair( t.Helper() cfg, err := config.ResetTestRoot(t.TempDir(), testRootName) - utilsrequire.NoError(t, err) + require.NoError(t, err) valSet, privVals := factory.ValidatorSet(ctx, 1, 30) genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams()) initialState, err := sm.MakeGenesisState(genDoc) - utilsrequire.NoError(t, err) + require.NoError(t, err) block1 := makeCommittedBlock(ctx, t, initialState, privVals, 1, &types.Commit{}) block2 := makeCommittedBlock(ctx, t, initialState, privVals, 2, block1.commit) @@ -51,16 +51,16 @@ func makeValidationFailurePair( func withBadLastSignature(t *testing.T, block *types.Block, flag tmproto.BlockIDFlag) *types.Block { t.Helper() blockProto, err := block.ToProto() - utilsrequire.NoError(t, err) + require.NoError(t, err) sigs := blockProto.LastCommit.Signatures lastSig := &sigs[len(sigs)-1] lastSig.Signature[0] ^= 0xFF lastSig.BlockIdFlag = flag badCommit, err := types.CommitFromProto(blockProto.LastCommit) - utilsrequire.NoError(t, err) + require.NoError(t, err) blockProto.Header.LastCommitHash = badCommit.Hash() badBlock, err := types.BlockFromProto(blockProto) - utilsrequire.NoError(t, err) + require.NoError(t, err) return badBlock } @@ -97,7 +97,7 @@ func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { }() t.Cleanup(func() { err := <-results - utilsrequire.ErrorIs(t, err, context.Canceled) + require.ErrorIs(t, err, context.Canceled) }) introducedCorrectPeer := false @@ -153,7 +153,7 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { }() t.Cleanup(func() { err := <-results - utilsrequire.ErrorIs(t, err, context.Canceled) + require.ErrorIs(t, err, context.Canceled) }) introducedCorrectPeers := false @@ -215,7 +215,7 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { ctx := t.Context() cfg, err := config.ResetTestRoot(t.TempDir(), "block_sync_invalid_commit") - utilsrequire.NoError(t, err) + require.NoError(t, err) valSet, privVals := factory.ValidatorSet(ctx, 4, 30) genDoc := factory.GenesisDoc(cfg, time.Now(), valSet.Validators, factory.ConsensusParams()) network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 2}) @@ -242,13 +242,13 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { // The correct node applies and stores correct blocks 1 to 4. correctExec := correctReactor.syncer.OrPanic("syncer should be configured in tests").blockExec state, err := correctReactor.stateStore.Load() - utilsrequire.NoError(t, err) + require.NoError(t, err) var correct []committedBlock lastCommit := &types.Commit{} for height := int64(1); height <= 4; height++ { b := makeCommittedBlock(ctx, t, state, privVals, height, lastCommit) state, err = correctExec.ApplyBlock(ctx, state, b.id, b.block, nil) - utilsrequire.NoError(t, err) + require.NoError(t, err) correctStore.SaveBlock(b.block, b.parts, b.commit) correct = append(correct, b) lastCommit = b.commit @@ -256,39 +256,39 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { // The invalid-commit node has the state of the correct node. It stores blocks 1 to 3, and a block 4 // whose commit for block 3 is invalid. - utilsrequire.NoError(t, invalidCommitReactor.stateStore.Save(state)) + require.NoError(t, invalidCommitReactor.stateStore.Save(state)) for _, b := range correct[:3] { invalidCommitStore.SaveBlock(b.block, b.parts, b.commit) } badBlock4 := withBadLastSignature(t, correct[3].block, tc.flag) badParts4, err := badBlock4.MakePartSet(types.BlockPartSizeBytes) - utilsrequire.NoError(t, err) + require.NoError(t, err) invalidCommitStore.SaveBlock(badBlock4, badParts4, correct[3].commit) // Start the reactors. for _, r := range []*Reactor{correctReactor, invalidCommitReactor, syncReactor} { - utilsrequire.NoError(t, r.Start(ctx)) + require.NoError(t, r.Start(ctx)) t.Cleanup(r.Wait) } // The syncing node saves blocks 1 and 2, rejects block 3, and closes its connection to the // invalid-commit node. Its store then ends at block 2, with the correct seen commit of block 2. syncNode.WaitForDisconnect(ctx, invalidCommitConn) - utilsrequire.Equal(t, int64(2), syncReactor.store.Height()) - utilsrequire.NoError(t, utils.TestDiff(correct[1].block.Hash(), syncReactor.store.LoadBlock(2).Hash())) - utilsrequire.NoError(t, utils.TestDiff(correct[1].commit.Hash(), syncReactor.store.LoadSeenCommit().Hash())) + require.Equal(t, int64(2), syncReactor.store.Height()) + require.NoError(t, utils.TestDiff(correct[1].block.Hash(), syncReactor.store.LoadBlock(2).Hash())) + require.NoError(t, utils.TestDiff(correct[1].commit.Hash(), syncReactor.store.LoadSeenCommit().Hash())) // Stop the invalid-commit node and remove it from the network. invalidCommitReactor.Stop() network.Remove(t, invalidCommitID) // The correct node connects, and the syncing node saves block 3 with its correct seen commit. - utilsrequire.NoError(t, correctNode.Connect(ctx, syncNode)) + require.NoError(t, correctNode.Connect(ctx, syncNode)) _, err = savedHeight.Wait(ctx, func(h int64) bool { return h >= 3 }) - utilsrequire.NoError(t, err) - utilsrequire.Equal(t, int64(3), syncReactor.store.Height()) - utilsrequire.NoError(t, utils.TestDiff(correct[2].block.Hash(), syncReactor.store.LoadBlock(3).Hash())) - utilsrequire.NoError(t, utils.TestDiff(correct[2].commit.Hash(), syncReactor.store.LoadSeenCommit().Hash())) + require.NoError(t, err) + require.Equal(t, int64(3), syncReactor.store.Height()) + require.NoError(t, utils.TestDiff(correct[2].block.Hash(), syncReactor.store.LoadBlock(3).Hash())) + require.NoError(t, utils.TestDiff(correct[2].commit.Hash(), syncReactor.store.LoadSeenCommit().Hash())) }) } } From e12a80756e4ffdae61e038bc19abc8da794181b7 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 17:14:00 -0700 Subject: [PATCH 12/15] use utils/require for every assertion in the blocksync reactor test --- sei-tendermint/internal/blocksync/reactor_test.go | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_test.go b/sei-tendermint/internal/blocksync/reactor_test.go index 1690cf2c76..6a6f5b5f4f 100644 --- a/sei-tendermint/internal/blocksync/reactor_test.go +++ b/sei-tendermint/internal/blocksync/reactor_test.go @@ -11,9 +11,7 @@ import ( "github.com/sei-protocol/sei-chain/sei-tendermint/internal/mempool" "github.com/fortytw2/leaktest" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" - "github.com/stretchr/testify/require" dbm "github.com/tendermint/tm-db" abci "github.com/sei-protocol/sei-chain/sei-tendermint/abci/types" @@ -26,7 +24,7 @@ import ( "github.com/sei-protocol/sei-chain/sei-tendermint/internal/store" "github.com/sei-protocol/sei-chain/sei-tendermint/internal/test/factory" "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils" - utilsrequire "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/require" + "github.com/sei-protocol/sei-chain/sei-tendermint/libs/utils/require" pb "github.com/sei-protocol/sei-chain/sei-tendermint/proto/tendermint/blocksync" tmproto "github.com/sei-protocol/sei-chain/sei-tendermint/proto/tendermint/types" "github.com/sei-protocol/sei-chain/sei-tendermint/types" @@ -205,11 +203,11 @@ func makeCommittedBlock( t.Helper() block := sf.MakeBlock(state, height, lastCommit) parts, err := block.MakePartSet(types.BlockPartSizeBytes) - utilsrequire.NoError(t, err) + require.NoError(t, err) id := types.BlockID{Hash: block.Hash(), PartSetHeader: parts.Header()} voteSet := types.NewVoteSet(state.ChainID, height, 0, tmproto.PrecommitType, state.Validators) commit, err := factory.MakeCommit(ctx, id, height, 0, voteSet, privVals, time.Now()) - utilsrequire.NoError(t, err) + require.NoError(t, err) return committedBlock{block: block, id: id, parts: parts, commit: commit} } @@ -450,12 +448,12 @@ func TestAutoRestartIfBehind(t *testing.T) { ctx := t.Context() if tt.restartExpected { r.syncer.OrPanic("syncer").autoRestartIfBehind(ctx, blockPool) - assert.True(t, restart.Load(), "Expected restart but did not occur") + require.True(t, restart.Load(), "Expected restart but did not occur") } else { ctx, cancel := context.WithTimeout(t.Context(), 50*time.Millisecond) defer cancel() r.syncer.OrPanic("syncer").autoRestartIfBehind(ctx, blockPool) - assert.False(t, restart.Load(), "Unexpected restart") + require.False(t, restart.Load(), "Unexpected restart") } }) } @@ -481,7 +479,7 @@ func TestAutoRestartStopsAtFreezeBoundary(t *testing.T) { } syncer.autoRestartIfBehind(t.Context(), blockPool) - utilsrequire.False(t, restart.Load()) + require.False(t, restart.Load()) }) } From 14096da951661b100984e89ec3f1fe37d05d48a8 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 17:29:33 -0700 Subject: [PATCH 13/15] remove a double space in the godoc of the blocksync invalid commit test --- .../internal/blocksync/reactor_validation_failure_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index 46b241b579..43397deb2a 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -200,7 +200,7 @@ func (s heightWatchStore) SaveBlock(block *types.Block, blockParts *types.PartSe s.savedHeight.Store(block.Height) } -// TestReactor_RejectsInvalidCommitFromPeer checks that a syncing node saves the blocks an invalid-commit +// TestReactor_RejectsInvalidCommitFromPeer checks that a syncing node saves the blocks an invalid-commit // peer serves up to the first block whose commit fails verification, evicts that peer, and then // still makes progress by saving that block from a correct peer. func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { From d81bc59c55b08e26e4288a97fe95d69c6e8d67c7 Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 17:29:34 -0700 Subject: [PATCH 14/15] name the block with the invalid commit after the invalid-commit peer in the blocksync validation test --- .../reactor_validation_failure_test.go | 28 +++++++++---------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index 43397deb2a..31fac73f97 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -43,12 +43,12 @@ func makeValidationFailurePair( block1 := makeCommittedBlock(ctx, t, initialState, privVals, 1, &types.Commit{}) block2 := makeCommittedBlock(ctx, t, initialState, privVals, 2, block1.commit) - return initialState, block1.block, withBadLastSignature(t, block2.block, tmproto.BlockIDFlagCommit) + return initialState, block1.block, withInvalidLastSignature(t, block2.block, tmproto.BlockIDFlagCommit) } -// withBadLastSignature returns a copy of block whose last commit has a last signature that +// withInvalidLastSignature returns a copy of block whose last commit has a last signature that // does not verify, with flag as the block ID flag of that signature. -func withBadLastSignature(t *testing.T, block *types.Block, flag tmproto.BlockIDFlag) *types.Block { +func withInvalidLastSignature(t *testing.T, block *types.Block, flag tmproto.BlockIDFlag) *types.Block { t.Helper() blockProto, err := block.ToProto() require.NoError(t, err) @@ -56,18 +56,18 @@ func withBadLastSignature(t *testing.T, block *types.Block, flag tmproto.BlockID lastSig := &sigs[len(sigs)-1] lastSig.Signature[0] ^= 0xFF lastSig.BlockIdFlag = flag - badCommit, err := types.CommitFromProto(blockProto.LastCommit) + invalidCommit, err := types.CommitFromProto(blockProto.LastCommit) require.NoError(t, err) - blockProto.Header.LastCommitHash = badCommit.Hash() - badBlock, err := types.BlockFromProto(blockProto) + blockProto.Header.LastCommitHash = invalidCommit.Hash() + invalidCommitBlock, err := types.BlockFromProto(blockProto) require.NoError(t, err) - return badBlock + return invalidCommitBlock } func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { ctx := t.Context() - initialState, block1, badBlock2 := makeValidationFailurePair(ctx, t, "block_sync_validation_failure_does_not_return") + initialState, block1, invalidCommitBlock2 := makeValidationFailurePair(ctx, t, "block_sync_validation_failure_does_not_return") invalidCommitPeer := types.NodeID(strings.Repeat("a", 40)) correctPeer := types.NodeID(strings.Repeat("b", 40)) @@ -114,7 +114,7 @@ func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { case 1: _ = pool.AddBlock(request.PeerID, block1, block1.Size()) case 2: - _ = pool.AddBlock(request.PeerID, badBlock2, badBlock2.Size()) + _ = pool.AddBlock(request.PeerID, invalidCommitBlock2, invalidCommitBlock2.Size()) if !introducedCorrectPeer { introducedCorrectPeer = true pool.SetPeerRange(correctPeer, 1, 2) @@ -127,7 +127,7 @@ func TestPoolRoutine_DoesNotReturnOnValidationFailure(t *testing.T) { func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { ctx := t.Context() - initialState, block1, badBlock2 := makeValidationFailurePair(ctx, t, "block_sync_retry_after_validation_failure") + initialState, block1, invalidCommitBlock2 := makeValidationFailurePair(ctx, t, "block_sync_retry_after_validation_failure") network := p2p.MakeTestNetwork(t, p2p.TestNetworkOptions{NumNodes: 1}) invalidCommitPeer := types.NodeID(strings.Repeat("a", 40)) @@ -182,7 +182,7 @@ func TestPoolRoutine_RetriesAfterValidationFailure(t *testing.T) { case 1: _ = pool.AddBlock(request.PeerID, block1, block1.Size()) case 2: - _ = pool.AddBlock(request.PeerID, badBlock2, badBlock2.Size()) + _ = pool.AddBlock(request.PeerID, invalidCommitBlock2, invalidCommitBlock2.Size()) } } } @@ -260,10 +260,10 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { for _, b := range correct[:3] { invalidCommitStore.SaveBlock(b.block, b.parts, b.commit) } - badBlock4 := withBadLastSignature(t, correct[3].block, tc.flag) - badParts4, err := badBlock4.MakePartSet(types.BlockPartSizeBytes) + invalidCommitBlock4 := withInvalidLastSignature(t, correct[3].block, tc.flag) + invalidCommitParts4, err := invalidCommitBlock4.MakePartSet(types.BlockPartSizeBytes) require.NoError(t, err) - invalidCommitStore.SaveBlock(badBlock4, badParts4, correct[3].commit) + invalidCommitStore.SaveBlock(invalidCommitBlock4, invalidCommitParts4, correct[3].commit) // Start the reactors. for _, r := range []*Reactor{correctReactor, invalidCommitReactor, syncReactor} { From 8d777da416f9c78abd115f3873cacfe10e2ecc5e Mon Sep 17 00:00:00 2001 From: sanaz <35961250+merkroot@users.noreply.github.com> Date: Mon, 16 Nov 2026 17:29:35 -0700 Subject: [PATCH 15/15] name the store wrapper as the actor that publishes the saved height --- .../internal/blocksync/reactor_validation_failure_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go index 31fac73f97..baf0160699 100644 --- a/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go +++ b/sei-tendermint/internal/blocksync/reactor_validation_failure_test.go @@ -223,7 +223,7 @@ func TestReactor_RejectsInvalidCommitFromPeer(t *testing.T) { invalidCommitID, syncID := nodeIDs[0], nodeIDs[1] syncNode := network.Node(syncID) - // The syncing node publishes the height of every block it saves. + // The block store of the syncing node publishes the height of every block it saves. savedHeight := utils.NewAtomicSend(int64(0)) invalidCommitStore, correctStore := newMemBlockStore(), newMemBlockStore()