diff --git a/internal/blocksync/reactor.go b/internal/blocksync/reactor.go index ee745fb92..361be537e 100644 --- a/internal/blocksync/reactor.go +++ b/internal/blocksync/reactor.go @@ -513,8 +513,15 @@ FOR_LOOP: didProcessCh <- struct{}{} } + firstParts, err := first.MakePartSet(types.BlockPartSizeBytes) + if err != nil { + r.logger.Error("failed to make ", + "height", first.Height, + "err", err.Error()) + break FOR_LOOP + } + var ( - firstParts = first.MakePartSet(types.BlockPartSizeBytes) firstPartSetHeader = firstParts.Header() firstID = types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader} ) @@ -524,8 +531,7 @@ FOR_LOOP: // NOTE: We can probably make this more efficient, but note that calling // first.Hash() doesn't verify the tx contents, so MakePartSet() is // currently necessary. - err := state.Validators.VerifyCommitLight(chainID, firstID, first.Height, second.LastCommit) - if err != nil { + if err = state.Validators.VerifyCommitLight(chainID, firstID, first.Height, second.LastCommit); err != nil { err = fmt.Errorf("invalid last commit: %w", err) r.logger.Error( err.Error(), diff --git a/internal/blocksync/reactor_test.go b/internal/blocksync/reactor_test.go index d9d959ddc..557478091 100644 --- a/internal/blocksync/reactor_test.go +++ b/internal/blocksync/reactor_test.go @@ -152,8 +152,10 @@ func (rts *reactorTestSuite) addNode( ) } - thisBlock := sf.MakeBlock(state, blockHeight, lastCommit) - thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes) + thisBlock, err := sf.MakeBlock(state, blockHeight, lastCommit) + require.NoError(t, err) + thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes) + require.NoError(t, err) blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()} state, err = blockExec.ApplyBlock(ctx, state, blockID, thisBlock) diff --git a/internal/consensus/byzantine_test.go b/internal/consensus/byzantine_test.go index d9a8e02d3..8b900120e 100644 --- a/internal/consensus/byzantine_test.go +++ b/internal/consensus/byzantine_test.go @@ -201,9 +201,10 @@ func TestByzantinePrevoteEquivocation(t *testing.T) { } proposerAddr := lazyNodeState.privValidatorPubKey.Address() - block, blockParts := lazyNodeState.blockExec.CreateProposalBlock( + block, blockParts, err := lazyNodeState.blockExec.CreateProposalBlock( lazyNodeState.Height, lazyNodeState.state, commit, proposerAddr, ) + require.NoError(t, err) // Flush the WAL. Otherwise, we may not recompute the same proposal to sign, // and the privValidator will refuse to sign anything. diff --git a/internal/consensus/common_test.go b/internal/consensus/common_test.go index e693cdd01..7415dd979 100644 --- a/internal/consensus/common_test.go +++ b/internal/consensus/common_test.go @@ -231,13 +231,15 @@ func startTestRound(ctx context.Context, cs *State, height int64, round int32) { // Create proposal block from cs1 but sign it with vs. func decideProposal( ctx context.Context, + t *testing.T, cs1 *State, vs *validatorStub, height int64, round int32, ) (proposal *types.Proposal, block *types.Block) { cs1.mtx.Lock() - block, blockParts := cs1.createProposalBlock() + block, blockParts, err := cs1.createProposalBlock() + require.NoError(t, err) validRound := cs1.ValidRound chainID := cs1.state.ChainID cs1.mtx.Unlock() diff --git a/internal/consensus/replay_test.go b/internal/consensus/replay_test.go index bd5b7f505..a2b5a9798 100644 --- a/internal/consensus/replay_test.go +++ b/internal/consensus/replay_test.go @@ -381,8 +381,10 @@ func setupSimulator(ctx context.Context, t *testing.T) *simulatorTestSuite { newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower) err = assertMempool(css[0].txNotifier).CheckTx(ctx, newValidatorTx1, nil, mempool.TxInfo{}) assert.Nil(t, err) - propBlock, _ := css[0].createProposalBlock() // changeProposer(t, cs1, vs2) - propBlockParts := propBlock.MakePartSet(partSize) + propBlock, _, err := css[0].createProposalBlock() // changeProposer(t, cs1, vs2) + require.NoError(t, err) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()} proposal := types.NewProposal(vss[1].Height, round, -1, blockID) @@ -413,8 +415,10 @@ func setupSimulator(ctx context.Context, t *testing.T) *simulatorTestSuite { updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25) err = assertMempool(css[0].txNotifier).CheckTx(ctx, updateValidatorTx1, nil, mempool.TxInfo{}) assert.Nil(t, err) - propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2) - propBlockParts = propBlock.MakePartSet(partSize) + propBlock, _, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2) + require.NoError(t, err) + propBlockParts, err = propBlock.MakePartSet(partSize) + require.NoError(t, err) blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()} proposal = types.NewProposal(vss[2].Height, round, -1, blockID) @@ -452,8 +456,10 @@ func setupSimulator(ctx context.Context, t *testing.T) *simulatorTestSuite { newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower) err = assertMempool(css[0].txNotifier).CheckTx(ctx, newValidatorTx3, nil, mempool.TxInfo{}) assert.Nil(t, err) - propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2) - propBlockParts = propBlock.MakePartSet(partSize) + propBlock, _, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2) + require.NoError(t, err) + propBlockParts, err = propBlock.MakePartSet(partSize) + require.NoError(t, err) blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()} newVss := make([]*validatorStub, nVals+1) copy(newVss, vss[:nVals+1]) @@ -531,8 +537,10 @@ func setupSimulator(ctx context.Context, t *testing.T) *simulatorTestSuite { removeValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, 0) err = assertMempool(css[0].txNotifier).CheckTx(ctx, removeValidatorTx3, nil, mempool.TxInfo{}) assert.Nil(t, err) - propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2) - propBlockParts = propBlock.MakePartSet(partSize) + propBlock, _, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2) + require.NoError(t, err) + propBlockParts, err = propBlock.MakePartSet(partSize) + require.NoError(t, err) blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()} newVss = make([]*validatorStub, nVals+3) copy(newVss, vss[:nVals+3]) @@ -740,7 +748,7 @@ func testHandshakeReplay( cfg = sim.Config chain = append([]*types.Block{}, sim.Chain...) // copy chain commits = sim.Commits - store = newMockBlockStore(cfg, genesisState.ConsensusParams) + store = newMockBlockStore(t, cfg, genesisState.ConsensusParams) } else { // test single node testConfig, err := ResetConfig(fmt.Sprintf("%s_%v_s", t.Name(), mode)) require.NoError(t, err) @@ -762,7 +770,7 @@ func testHandshakeReplay( require.NoError(t, err) pubKey, err := privVal.GetPubKey(ctx) require.NoError(t, err) - stateDB, genesisState, store = stateAndStore(cfg, pubKey, kvstore.ProtocolVersion) + stateDB, genesisState, store = stateAndStore(t, cfg, pubKey, kvstore.ProtocolVersion) } stateStore := sm.NewStore(stateDB) @@ -773,6 +781,7 @@ func testHandshakeReplay( // run the chain through state.ApplyBlock to build up the tendermint state state = buildTMStateFromChain( ctx, + t, cfg, logger, sim.Mempool, @@ -800,7 +809,7 @@ func testHandshakeReplay( stateStore := sm.NewStore(stateDB1) err := stateStore.Save(genesisState) require.NoError(t, err) - buildAppStateFromChain(ctx, proxyApp, stateStore, sim.Mempool, sim.Evpool, genesisState, chain, nBlocks, mode, store) + buildAppStateFromChain(ctx, t, proxyApp, stateStore, sim.Mempool, sim.Evpool, genesisState, chain, nBlocks, mode, store) } // Prune block store if requested @@ -858,6 +867,7 @@ func testHandshakeReplay( func applyBlock( ctx context.Context, + t *testing.T, stateStore sm.Store, mempool mempool.Mempool, evpool sm.EvidencePool, @@ -869,16 +879,17 @@ func applyBlock( testPartSize := types.BlockPartSizeBytes blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool, blockStore) - blkID := types.BlockID{Hash: blk.Hash(), PartSetHeader: blk.MakePartSet(testPartSize).Header()} + bps, err := blk.MakePartSet(testPartSize) + require.NoError(t, err) + blkID := types.BlockID{Hash: blk.Hash(), PartSetHeader: bps.Header()} newState, err := blockExec.ApplyBlock(ctx, st, blkID, blk) - if err != nil { - panic(err) - } + require.NoError(t, err) return newState } func buildAppStateFromChain( ctx context.Context, + t *testing.T, proxyApp proxy.AppConns, stateStore sm.Store, mempool mempool.Mempool, @@ -908,18 +919,18 @@ func buildAppStateFromChain( case 0: for i := 0; i < nBlocks; i++ { block := chain[i] - state = applyBlock(ctx, stateStore, mempool, evpool, state, block, proxyApp, blockStore) + state = applyBlock(ctx, t, stateStore, mempool, evpool, state, block, proxyApp, blockStore) } case 1, 2, 3: for i := 0; i < nBlocks-1; i++ { block := chain[i] - state = applyBlock(ctx, stateStore, mempool, evpool, state, block, proxyApp, blockStore) + state = applyBlock(ctx, t, stateStore, mempool, evpool, state, block, proxyApp, blockStore) } if mode == 2 || mode == 3 { // update the kvstore height and apphash // as if we ran commit but not - state = applyBlock(ctx, stateStore, mempool, evpool, state, chain[nBlocks-1], proxyApp, blockStore) + state = applyBlock(ctx, t, stateStore, mempool, evpool, state, chain[nBlocks-1], proxyApp, blockStore) } default: panic(fmt.Sprintf("unknown mode %v", mode)) @@ -929,6 +940,7 @@ func buildAppStateFromChain( func buildTMStateFromChain( ctx context.Context, + t *testing.T, cfg *config.Config, logger log.Logger, mempool mempool.Mempool, @@ -965,19 +977,19 @@ func buildTMStateFromChain( case 0: // sync right up for _, block := range chain { - state = applyBlock(ctx, stateStore, mempool, evpool, state, block, proxyApp, blockStore) + state = applyBlock(ctx, t, stateStore, mempool, evpool, state, block, proxyApp, blockStore) } case 1, 2, 3: // sync up to the penultimate as if we stored the block. // whether we commit or not depends on the appHash for _, block := range chain[:len(chain)-1] { - state = applyBlock(ctx, stateStore, mempool, evpool, state, block, proxyApp, blockStore) + state = applyBlock(ctx, t, stateStore, mempool, evpool, state, block, proxyApp, blockStore) } // apply the final block to a state copy so we can // get the right next appHash but keep the state back - applyBlock(ctx, stateStore, mempool, evpool, state, chain[len(chain)-1], proxyApp, blockStore) + applyBlock(ctx, t, stateStore, mempool, evpool, state, chain[len(chain)-1], proxyApp, blockStore) default: panic(fmt.Sprintf("unknown mode %v", mode)) } @@ -1002,12 +1014,14 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) { const appVersion = 0x0 pubKey, err := privVal.GetPubKey(ctx) require.NoError(t, err) - stateDB, state, store := stateAndStore(cfg, pubKey, appVersion) + stateDB, state, store := stateAndStore(t, cfg, pubKey, appVersion) stateStore := sm.NewStore(stateDB) genDoc, _ := sm.MakeGenesisDocFromFile(cfg.GenesisFile()) state.LastValidators = state.Validators.Copy() // mode = 0 for committing all the blocks - blocks := sf.MakeBlocks(3, &state, privVal) + blocks, err := sf.MakeBlocks(3, &state, privVal) + require.NoError(t, err) + store.chain = blocks logger := log.TestingLogger() @@ -1204,17 +1218,19 @@ func readPieceFromWAL(msg *TimedWALMessage) interface{} { // fresh state and mock store func stateAndStore( + t *testing.T, cfg *config.Config, pubKey crypto.PubKey, - appVersion uint64) (dbm.DB, sm.State, *mockBlockStore) { + appVersion uint64, +) (dbm.DB, sm.State, *mockBlockStore) { stateDB := dbm.NewMemDB() stateStore := sm.NewStore(stateDB) - state, _ := sm.MakeGenesisStateFromFile(cfg.GenesisFile()) + state, err := sm.MakeGenesisStateFromFile(cfg.GenesisFile()) + require.NoError(t, err) state.Version.Consensus.App = appVersion - store := newMockBlockStore(cfg, state.ConsensusParams) - if err := stateStore.Save(state); err != nil { - panic(err) - } + store := newMockBlockStore(t, cfg, state.ConsensusParams) + require.NoError(t, stateStore.Save(state)) + return stateDB, state, store } @@ -1227,11 +1243,16 @@ type mockBlockStore struct { chain []*types.Block commits []*types.Commit base int64 + t *testing.T } // TODO: NewBlockStore(db.NewMemDB) ... -func newMockBlockStore(cfg *config.Config, params types.ConsensusParams) *mockBlockStore { - return &mockBlockStore{cfg, params, nil, nil, 0} +func newMockBlockStore(t *testing.T, cfg *config.Config, params types.ConsensusParams) *mockBlockStore { + return &mockBlockStore{ + cfg: cfg, + params: params, + t: t, + } } func (bs *mockBlockStore) Height() int64 { return int64(len(bs.chain)) } @@ -1245,8 +1266,10 @@ func (bs *mockBlockStore) LoadBlockByHash(hash []byte) *types.Block { func (bs *mockBlockStore) LoadBlockMetaByHash(hash []byte) *types.BlockMeta { return nil } func (bs *mockBlockStore) LoadBlockMeta(height int64) *types.BlockMeta { block := bs.chain[height-1] + bps, err := block.MakePartSet(types.BlockPartSizeBytes) + require.NoError(bs.t, err) return &types.BlockMeta{ - BlockID: types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()}, + BlockID: types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()}, Header: block.Header, } } @@ -1291,7 +1314,7 @@ func TestHandshakeUpdatesValidators(t *testing.T) { require.NoError(t, err) pubKey, err := privVal.GetPubKey(ctx) require.NoError(t, err) - stateDB, state, store := stateAndStore(cfg, pubKey, 0x0) + stateDB, state, store := stateAndStore(t, cfg, pubKey, 0x0) stateStore := sm.NewStore(stateDB) oldValAddr := state.Validators.Validators[0].Address diff --git a/internal/consensus/state.go b/internal/consensus/state.go index 10d0bb975..b7967b829 100644 --- a/internal/consensus/state.go +++ b/internal/consensus/state.go @@ -1230,8 +1230,9 @@ func (cs *State) defaultDecideProposal(ctx context.Context, height int64, round block, blockParts = cs.ValidBlock, cs.ValidBlockParts } else { // Create a new proposal block from state/txs from the mempool. - block, blockParts = cs.createProposalBlock() - if block == nil { + var err error + block, blockParts, err = cs.createProposalBlock() + if block == nil || err != nil { return } } @@ -1290,9 +1291,9 @@ func (cs *State) isProposalComplete() bool { // // NOTE: keep it side-effect free for clarity. // CONTRACT: cs.privValidator is not nil. -func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.PartSet) { +func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.PartSet, err error) { if cs.privValidator == nil { - panic("entered createProposalBlock with privValidator being nil") + return nil, nil, errors.New("entered createProposalBlock with privValidator being nil") } var commit *types.Commit diff --git a/internal/consensus/state_test.go b/internal/consensus/state_test.go index fd79c19a6..93f5eca19 100644 --- a/internal/consensus/state_test.go +++ b/internal/consensus/state_test.go @@ -227,7 +227,8 @@ func TestStateBadProposal(t *testing.T) { proposalCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryCompleteProposal) voteCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryVote) - propBlock, _ := cs1.createProposalBlock() // changeProposer(t, cs1, vs2) + propBlock, _, err := cs1.createProposalBlock() // changeProposer(t, cs1, vs2) + require.NoError(t, err) // make the second validator the proposer by incrementing round round++ @@ -240,7 +241,8 @@ func TestStateBadProposal(t *testing.T) { } stateHash[0] = (stateHash[0] + 1) % 255 propBlock.AppHash = stateHash - propBlockParts := propBlock.MakePartSet(partSize) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()} proposal := types.NewProposal(vs2.Height, round, -1, blockID) p := proposal.ToProto() @@ -266,13 +268,19 @@ func TestStateBadProposal(t *testing.T) { validatePrevote(ctx, t, cs1, round, vss[0], nil) // add bad prevote from vs2 and wait for it - signAddVotes(ctx, config, cs1, tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2) + bps, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) + + signAddVotes(ctx, config, cs1, tmproto.PrevoteType, propBlock.Hash(), bps.Header(), vs2) ensurePrevote(voteCh, height, round) // wait for precommit ensurePrecommit(voteCh, height, round) validatePrecommit(ctx, t, cs1, round, -1, vss[0], nil, nil) - signAddVotes(ctx, config, cs1, tmproto.PrecommitType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2) + + bps2, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) + signAddVotes(ctx, config, cs1, tmproto.PrecommitType, propBlock.Hash(), bps2.Header(), vs2) } func TestStateOversizedBlock(t *testing.T) { @@ -291,7 +299,8 @@ func TestStateOversizedBlock(t *testing.T) { timeoutProposeCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryTimeoutPropose) voteCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryVote) - propBlock, _ := cs1.createProposalBlock() + propBlock, _, err := cs1.createProposalBlock() + require.NoError(t, err) propBlock.Data.Txs = []types.Tx{tmrand.Bytes(2001)} propBlock.Header.DataHash = propBlock.Data.Hash() @@ -299,7 +308,8 @@ func TestStateOversizedBlock(t *testing.T) { round++ incrementRound(vss[1:]...) - propBlockParts := propBlock.MakePartSet(partSize) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()} proposal := types.NewProposal(height, round, -1, blockID) p := proposal.ToProto() @@ -331,11 +341,18 @@ func TestStateOversizedBlock(t *testing.T) { // precommit on it ensurePrevote(voteCh, height, round) validatePrevote(ctx, t, cs1, round, vss[0], nil) - signAddVotes(ctx, config, cs1, tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2) + + bps, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) + + signAddVotes(ctx, config, cs1, tmproto.PrevoteType, propBlock.Hash(), bps.Header(), vs2) ensurePrevote(voteCh, height, round) ensurePrecommit(voteCh, height, round) validatePrecommit(ctx, t, cs1, round, -1, vss[0], nil, nil) - signAddVotes(ctx, config, cs1, tmproto.PrecommitType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2) + + bps2, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) + signAddVotes(ctx, config, cs1, tmproto.PrecommitType, propBlock.Hash(), bps2.Header(), vs2) } //---------------------------------------------------------------------------------------------------- @@ -528,9 +545,7 @@ func TestStateLockNoPOL(t *testing.T) { rs := cs1.GetRoundState() - if rs.ProposalBlock != nil { - panic("Expected proposal block to be nil") - } + require.Nil(t, rs.ProposalBlock, "Expected proposal block to be nil") // wait to finish prevote ensurePrevote(voteCh, height, round) @@ -538,7 +553,10 @@ func TestStateLockNoPOL(t *testing.T) { validatePrevote(ctx, t, cs1, round, vss[0], rs.LockedBlock.Hash()) // add a conflicting prevote from the other validator - signAddVotes(ctx, config, cs1, tmproto.PrevoteType, hash, rs.LockedBlock.MakePartSet(partSize).Header(), vs2) + bps, err := rs.LockedBlock.MakePartSet(partSize) + require.NoError(t, err) + + signAddVotes(ctx, config, cs1, tmproto.PrevoteType, hash, bps.Header(), vs2) ensurePrevote(voteCh, height, round) // now we're going to enter prevote again, but with invalid args @@ -551,7 +569,9 @@ func TestStateLockNoPOL(t *testing.T) { validatePrecommit(ctx, t, cs1, round, 0, vss[0], nil, theBlockHash) // add conflicting precommit from vs2 - signAddVotes(ctx, config, cs1, tmproto.PrecommitType, hash, rs.LockedBlock.MakePartSet(partSize).Header(), vs2) + bps2, err := rs.LockedBlock.MakePartSet(partSize) + require.NoError(t, err) + signAddVotes(ctx, config, cs1, tmproto.PrecommitType, hash, bps2.Header(), vs2) ensurePrecommit(voteCh, height, round) // (note we're entering precommit for a second time this round, but with invalid args @@ -581,7 +601,9 @@ func TestStateLockNoPOL(t *testing.T) { ensurePrevote(voteCh, height, round) // prevote validatePrevote(ctx, t, cs1, round, vss[0], rs.LockedBlock.Hash()) - signAddVotes(ctx, config, cs1, tmproto.PrevoteType, hash, rs.ProposalBlock.MakePartSet(partSize).Header(), vs2) + bps0, err := rs.ProposalBlock.MakePartSet(partSize) + require.NoError(t, err) + signAddVotes(ctx, config, cs1, tmproto.PrevoteType, hash, bps0.Header(), vs2) ensurePrevote(voteCh, height, round) ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds()) @@ -589,13 +611,15 @@ func TestStateLockNoPOL(t *testing.T) { validatePrecommit(ctx, t, cs1, round, 0, vss[0], nil, theBlockHash) // precommit nil but be locked on proposal + bps1, err := rs.ProposalBlock.MakePartSet(partSize) + require.NoError(t, err) signAddVotes( ctx, config, cs1, tmproto.PrecommitType, hash, - rs.ProposalBlock.MakePartSet(partSize).Header(), + bps1.Header(), vs2) // NOTE: conflicting precommits at same height ensurePrecommit(voteCh, height, round) @@ -605,7 +629,7 @@ func TestStateLockNoPOL(t *testing.T) { cs2, _, err := randState(ctx, config, log.TestingLogger(), 2) require.NoError(t, err) // before we time out into new round, set next proposal block - prop, propBlock := decideProposal(ctx, cs2, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(ctx, t, cs2, vs2, vs2.Height, vs2.Round+1) if prop == nil || propBlock == nil { t.Fatal("Failed to create proposal block with vs2") } @@ -621,7 +645,9 @@ func TestStateLockNoPOL(t *testing.T) { // now we're on a new round and not the proposer // so set the proposal block - if err := cs1.SetProposalAndBlock(ctx, prop, propBlock, propBlock.MakePartSet(partSize), ""); err != nil { + bps3, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) + if err := cs1.SetProposalAndBlock(ctx, prop, propBlock, bps3, ""); err != nil { t.Fatal(err) } @@ -631,20 +657,25 @@ func TestStateLockNoPOL(t *testing.T) { validatePrevote(ctx, t, cs1, 3, vss[0], cs1.LockedBlock.Hash()) // prevote for proposed block - signAddVotes(ctx, config, cs1, tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2) + bps4, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) + + signAddVotes(ctx, config, cs1, tmproto.PrevoteType, propBlock.Hash(), bps4.Header(), vs2) ensurePrevote(voteCh, height, round) ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds()) ensurePrecommit(voteCh, height, round) validatePrecommit(ctx, t, cs1, round, 0, vss[0], nil, theBlockHash) // precommit nil but locked on proposal + bps5, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) signAddVotes( ctx, config, cs1, tmproto.PrecommitType, propBlock.Hash(), - propBlock.MakePartSet(partSize).Header(), + bps5.Header(), vs2) // NOTE: conflicting precommits at same height ensurePrecommit(voteCh, height, round) } @@ -708,11 +739,13 @@ func TestStateLockPOLRelock(t *testing.T) { cs2, err := newState(ctx, logger, cs1.state, vs2, kvstore.NewApplication()) require.NoError(t, err) - prop, propBlock := decideProposal(ctx, cs2, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(ctx, t, cs2, vs2, vs2.Height, vs2.Round+1) if prop == nil || propBlock == nil { t.Fatal("Failed to create proposal block with vs2") } - propBlockParts := propBlock.MakePartSet(partSize) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) + propBlockHash := propBlock.Hash() require.NotEqual(t, propBlockHash, theBlockHash) @@ -810,8 +843,9 @@ func TestStateLockPOLUnlock(t *testing.T) { signAddVotes(ctx, config, cs1, tmproto.PrecommitType, theBlockHash, theBlockParts, vs3) // before we time out into new round, set next proposal block - prop, propBlock := decideProposal(ctx, cs1, vs2, vs2.Height, vs2.Round+1) - propBlockParts := propBlock.MakePartSet(partSize) + prop, propBlock := decideProposal(ctx, t, cs1, vs2, vs2.Height, vs2.Round+1) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) // timeout to new round ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds()) @@ -905,11 +939,13 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) { // before we timeout to the new round set the new proposal cs2, err := newState(ctx, logger, cs1.state, vs2, kvstore.NewApplication()) require.NoError(t, err) - prop, propBlock := decideProposal(ctx, cs2, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(ctx, t, cs2, vs2, vs2.Height, vs2.Round+1) if prop == nil || propBlock == nil { t.Fatal("Failed to create proposal block with vs2") } - secondBlockParts := propBlock.MakePartSet(partSize) + secondBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) + secondBlockHash := propBlock.Hash() require.NotEqual(t, secondBlockHash, firstBlockHash) @@ -950,11 +986,12 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) { // before we timeout to the new round set the new proposal cs3, err := newState(ctx, logger, cs1.state, vs3, kvstore.NewApplication()) require.NoError(t, err) - prop, propBlock = decideProposal(ctx, cs3, vs3, vs3.Height, vs3.Round+1) + prop, propBlock = decideProposal(ctx, t, cs3, vs3, vs3.Height, vs3.Round+1) if prop == nil || propBlock == nil { t.Fatal("Failed to create proposal block with vs2") } - thirdPropBlockParts := propBlock.MakePartSet(partSize) + thirdPropBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) thirdPropBlockHash := propBlock.Hash() require.NotEqual(t, secondBlockHash, thirdPropBlockHash) @@ -1023,8 +1060,11 @@ func TestStateLockPOLSafety1(t *testing.T) { validatePrevote(ctx, t, cs1, round, vss[0], propBlock.Hash()) // the others sign a polka but we don't see it + bps, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) + prevotes := signVotes(ctx, config, tmproto.PrevoteType, - propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), + propBlock.Hash(), bps.Header(), vs2, vs3, vs4) t.Logf("old prop hash %v", fmt.Sprintf("%X", propBlock.Hash())) @@ -1038,9 +1078,10 @@ func TestStateLockPOLSafety1(t *testing.T) { t.Log("### ONTO ROUND 1") - prop, propBlock := decideProposal(ctx, cs1, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(ctx, t, cs1, vs2, vs2.Height, vs2.Round+1) propBlockHash := propBlock.Hash() - propBlockParts := propBlock.MakePartSet(partSize) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) incrementRound(vs2, vs3, vs4) @@ -1139,18 +1180,20 @@ func TestStateLockPOLSafety2(t *testing.T) { // the block for R0: gets polkad but we miss it // (even though we signed it, shhh) - _, propBlock0 := decideProposal(ctx, cs1, vss[0], height, round) + _, propBlock0 := decideProposal(ctx, t, cs1, vss[0], height, round) propBlockHash0 := propBlock0.Hash() - propBlockParts0 := propBlock0.MakePartSet(partSize) + propBlockParts0, err := propBlock0.MakePartSet(partSize) + require.NoError(t, err) propBlockID0 := types.BlockID{Hash: propBlockHash0, PartSetHeader: propBlockParts0.Header()} // the others sign a polka but we don't see it prevotes := signVotes(ctx, config, tmproto.PrevoteType, propBlockHash0, propBlockParts0.Header(), vs2, vs3, vs4) // the block for round 1 - prop1, propBlock1 := decideProposal(ctx, cs1, vs2, vs2.Height, vs2.Round+1) + prop1, propBlock1 := decideProposal(ctx, t, cs1, vs2, vs2.Height, vs2.Round+1) propBlockHash1 := propBlock1.Hash() - propBlockParts1 := propBlock1.MakePartSet(partSize) + propBlockParts1, err := propBlock1.MakePartSet(partSize) + require.NoError(t, err) incrementRound(vs2, vs3, vs4) @@ -1253,8 +1296,10 @@ func TestProposeValidBlock(t *testing.T) { validatePrevote(ctx, t, cs1, round, vss[0], propBlockHash) // the others sign a polka + bps, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) signAddVotes(ctx, config, cs1, tmproto.PrevoteType, - propBlockHash, propBlock.MakePartSet(partSize).Header(), vs2, + propBlockHash, bps.Header(), vs2, vs3, vs4) ensurePrecommit(voteCh, height, round) @@ -1344,7 +1389,8 @@ func TestSetValidBlockOnDelayedPrevote(t *testing.T) { rs := cs1.GetRoundState() propBlock := rs.ProposalBlock propBlockHash := propBlock.Hash() - propBlockParts := propBlock.MakePartSet(partSize) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) ensurePrevote(voteCh, height, round) validatePrevote(ctx, t, cs1, round, vss[0], propBlockHash) @@ -1415,9 +1461,10 @@ func TestSetValidBlockOnDelayedProposal(t *testing.T) { ensurePrevote(voteCh, height, round) validatePrevote(ctx, t, cs1, round, vss[0], nil) - prop, propBlock := decideProposal(ctx, cs1, vs2, vs2.Height, vs2.Round+1) + prop, propBlock := decideProposal(ctx, t, cs1, vs2, vs2.Height, vs2.Round+1) propBlockHash := propBlock.Hash() - propBlockParts := propBlock.MakePartSet(partSize) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) // vs2, vs3 and vs4 send prevote for propBlock signAddVotes(ctx, config, cs1, tmproto.PrevoteType, propBlockHash, propBlockParts.Header(), vs2, vs3, vs4) @@ -1601,9 +1648,10 @@ func TestEmitNewValidBlockEventOnCommitWithoutBlock(t *testing.T) { newRoundCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryNewRound) validBlockCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryValidBlock) - _, propBlock := decideProposal(ctx, cs1, vs2, vs2.Height, vs2.Round) + _, propBlock := decideProposal(ctx, t, cs1, vs2, vs2.Height, vs2.Round) propBlockHash := propBlock.Hash() - propBlockParts := propBlock.MakePartSet(partSize) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) // start round in which PO is not proposer startTestRound(ctx, cs1, height, round) @@ -1639,9 +1687,10 @@ func TestCommitFromPreviousRound(t *testing.T) { validBlockCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryValidBlock) proposalCh := subscribe(ctx, t, cs1.eventBus, types.EventQueryCompleteProposal) - prop, propBlock := decideProposal(ctx, cs1, vs2, vs2.Height, vs2.Round) + prop, propBlock := decideProposal(ctx, t, cs1, vs2, vs2.Height, vs2.Round) propBlockHash := propBlock.Hash() - propBlockParts := propBlock.MakePartSet(partSize) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) // start round in which PO is not proposer startTestRound(ctx, cs1, height, round) @@ -1794,8 +1843,9 @@ func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) { ensureNewBlockHeader(newBlockHeader, height, theBlockHash) - prop, propBlock := decideProposal(ctx, cs1, vs2, height+1, 0) - propBlockParts := propBlock.MakePartSet(partSize) + prop, propBlock := decideProposal(ctx, t, cs1, vs2, height+1, 0) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) if err := cs1.SetProposalAndBlock(ctx, prop, propBlock, propBlockParts, "some peer"); err != nil { t.Fatal(err) @@ -1921,7 +1971,8 @@ func TestStateHalt1(t *testing.T) { ensureNewProposal(proposalCh, height, round) rs := cs1.GetRoundState() propBlock := rs.ProposalBlock - propBlockParts := propBlock.MakePartSet(partSize) + propBlockParts, err := propBlock.MakePartSet(partSize) + require.NoError(t, err) ensurePrevote(voteCh, height, round) diff --git a/internal/eventbus/event_bus_test.go b/internal/eventbus/event_bus_test.go index 66581b6cc..852fe903f 100644 --- a/internal/eventbus/event_bus_test.go +++ b/internal/eventbus/event_bus_test.go @@ -80,7 +80,9 @@ func TestEventBusPublishEventNewBlock(t *testing.T) { require.NoError(t, err) block := types.MakeBlock(0, []types.Tx{}, nil, []types.Evidence{}) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()} + bps, err := block.MakePartSet(types.BlockPartSizeBytes) + require.NoError(t, err) + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} resultBeginBlock := abci.ResponseBeginBlock{ Events: []abci.Event{ {Type: "testType", Attributes: []abci.EventAttribute{{Key: "baz", Value: "1"}}}, diff --git a/internal/evidence/pool_test.go b/internal/evidence/pool_test.go index f38c09e02..5069acab0 100644 --- a/internal/evidence/pool_test.go +++ b/internal/evidence/pool_test.go @@ -335,7 +335,8 @@ func TestRecoverPendingEvidence(t *testing.T) { state, err := stateStore.Load() require.NoError(t, err) - blockStore := initializeBlockStore(dbm.NewMemDB(), state, valAddress) + blockStore, err := initializeBlockStore(dbm.NewMemDB(), state, valAddress) + require.NoError(t, err) // create previous pool and populate it pool, err := evidence.NewPool(log.TestingLogger(), evidenceDB, stateStore, blockStore) @@ -434,22 +435,29 @@ func initializeValidatorState(t *testing.T, privVal types.PrivValidator, height // initializeBlockStore creates a block storage and populates it w/ a dummy // block at +height+. -func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) *store.BlockStore { +func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) (*store.BlockStore, error) { blockStore := store.NewBlockStore(db) for i := int64(1); i <= state.LastBlockHeight; i++ { lastCommit := makeCommit(i-1, valAddr) - block := sf.MakeBlock(state, i, lastCommit) + block, err := sf.MakeBlock(state, i, lastCommit) + if err != nil { + return nil, err + } + block.Header.Time = defaultEvidenceTime.Add(time.Duration(i) * time.Minute) block.Header.Version = version.Consensus{Block: version.BlockProtocol, App: 1} const parts = 1 - partSet := block.MakePartSet(parts) + partSet, err := block.MakePartSet(parts) + if err != nil { + return nil, err + } seenCommit := makeCommit(i, valAddr) blockStore.SaveBlock(block, partSet, seenCommit) } - return blockStore + return blockStore, nil } func makeCommit(height int64, valAddr []byte) *types.Commit { @@ -464,12 +472,14 @@ func makeCommit(height int64, valAddr []byte) *types.Commit { } func defaultTestPool(t *testing.T, height int64) (*evidence.Pool, types.MockPV) { + t.Helper() val := types.NewMockPV() valAddress := val.PrivKey.PubKey().Address() evidenceDB := dbm.NewMemDB() stateStore := initializeValidatorState(t, val, height) state, _ := stateStore.Load() - blockStore := initializeBlockStore(dbm.NewMemDB(), state, valAddress) + blockStore, err := initializeBlockStore(dbm.NewMemDB(), state, valAddress) + require.NoError(t, err) pool, err := evidence.NewPool(log.TestingLogger(), evidenceDB, stateStore, blockStore) require.NoError(t, err, "test evidence pool could not be created") diff --git a/internal/state/execution.go b/internal/state/execution.go index e50b3e97f..afb30d8a7 100644 --- a/internal/state/execution.go +++ b/internal/state/execution.go @@ -104,7 +104,7 @@ func (blockExec *BlockExecutor) CreateProposalBlock( height int64, state State, commit *types.Commit, proposerAddr []byte, -) (*types.Block, *types.PartSet) { +) (*types.Block, *types.PartSet, error) { maxBytes := state.ConsensusParams.Block.MaxBytes maxGas := state.ConsensusParams.Block.MaxGas @@ -603,7 +603,12 @@ func ExecCommitBlock( return nil, err } - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()} + bps, err := block.MakePartSet(types.BlockPartSizeBytes) + if err != nil { + return nil, err + } + + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} fireEvents(ctx, be.logger, be.eventBus, block, blockID, abciResponses, validatorUpdates) } diff --git a/internal/state/execution_test.go b/internal/state/execution_test.go index 32b26b425..66b72f21c 100644 --- a/internal/state/execution_test.go +++ b/internal/state/execution_test.go @@ -53,8 +53,11 @@ func TestApplyBlock(t *testing.T) { blockExec := sm.NewBlockExecutor(stateStore, logger, proxyApp.Consensus(), mmock.Mempool{}, sm.EmptyEvidencePool{}, blockStore) - block := sf.MakeBlock(state, 1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := sf.MakeBlock(state, 1, new(types.Commit)) + require.NoError(t, err) + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} state, err = blockExec.ApplyBlock(ctx, state, blockID, block) require.Nil(t, err) @@ -109,7 +112,8 @@ func TestBeginBlockValidators(t *testing.T) { lastCommit := types.NewCommit(1, 0, prevBlockID, tc.lastCommitSigs) // block for height 2 - block := sf.MakeBlock(state, 2, lastCommit) + block, err := sf.MakeBlock(state, 2, lastCommit) + require.NoError(t, err) _, err = sm.ExecCommitBlock(ctx, nil, proxyApp.Consensus(), block, log.TestingLogger(), stateStore, 1, state) require.Nil(t, err, tc.desc) @@ -214,10 +218,14 @@ func TestBeginBlockByzantineValidators(t *testing.T) { blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(), mmock.Mempool{}, evpool, blockStore) - block := sf.MakeBlock(state, 1, new(types.Commit)) + block, err := sf.MakeBlock(state, 1, new(types.Commit)) + require.NoError(t, err) block.Evidence = types.EvidenceData{Evidence: ev} block.Header.EvidenceHash = block.Evidence.Hash() - blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + + blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} _, err = blockExec.ApplyBlock(ctx, state, blockID, block) require.Nil(t, err) @@ -394,8 +402,11 @@ func TestEndBlockValidatorUpdates(t *testing.T) { }) require.NoError(t, err) - block := sf.MakeBlock(state, 1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := sf.MakeBlock(state, 1, new(types.Commit)) + require.NoError(t, err) + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} pubkey := ed25519.GenPrivKey().PubKey() pk, err := encoding.PubKeyToProto(pubkey) @@ -452,8 +463,11 @@ func TestEndBlockValidatorUpdatesResultingInEmptySet(t *testing.T) { blockStore, ) - block := sf.MakeBlock(state, 1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := sf.MakeBlock(state, 1, new(types.Commit)) + require.NoError(t, err) + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} vp, err := encoding.PubKeyToProto(state.Validators.Validators[0].PubKey) require.NoError(t, err) diff --git a/internal/state/helpers_test.go b/internal/state/helpers_test.go index 20d931f62..2af2ea441 100644 --- a/internal/state/helpers_test.go +++ b/internal/state/helpers_test.go @@ -4,8 +4,10 @@ import ( "bytes" "context" "fmt" + "testing" "time" + "github.com/stretchr/testify/require" dbm "github.com/tendermint/tm-db" abciclient "github.com/tendermint/tendermint/abci/client" @@ -69,13 +71,17 @@ func makeAndApplyGoodBlock( blockExec *sm.BlockExecutor, evidence []types.Evidence, ) (sm.State, types.BlockID, error) { - block, _ := state.MakeBlock(height, factory.MakeTenTxs(height), lastCommit, evidence, proposerAddr) + block, _, err := state.MakeBlock(height, factory.MakeTenTxs(height), lastCommit, evidence, proposerAddr) + if err != nil { + return state, types.BlockID{}, err + } + if err := blockExec.ValidateBlock(state, block); err != nil { return state, types.BlockID{}, err } blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: types.PartSetHeader{Total: 3, Hash: tmrand.Bytes(32)}} - state, err := blockExec.ApplyBlock(ctx, state, blockID, block) + state, err = blockExec.ApplyBlock(ctx, state, blockID, block) if err != nil { return state, types.BlockID{}, err } @@ -147,11 +153,13 @@ func genValSet(size int) *types.ValidatorSet { } func makeHeaderPartsResponsesValPubKeyChange( + t *testing.T, state sm.State, pubkey crypto.PubKey, ) (types.Header, types.BlockID, *tmstate.ABCIResponses) { - block := sf.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + block, err := sf.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) abciResponses := &tmstate.ABCIResponses{ BeginBlock: &abci.ResponseBeginBlock{}, EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: nil}, @@ -160,13 +168,10 @@ func makeHeaderPartsResponsesValPubKeyChange( _, val := state.NextValidators.GetByIndex(0) if !bytes.Equal(pubkey.Bytes(), val.PubKey.Bytes()) { vPbPk, err := encoding.PubKeyToProto(val.PubKey) - if err != nil { - panic(err) - } + require.NoError(t, err) pbPk, err := encoding.PubKeyToProto(pubkey) - if err != nil { - panic(err) - } + require.NoError(t, err) + abciResponses.EndBlock = &abci.ResponseEndBlock{ ValidatorUpdates: []abci.ValidatorUpdate{ {PubKey: vPbPk, Power: 0}, @@ -179,11 +184,14 @@ func makeHeaderPartsResponsesValPubKeyChange( } func makeHeaderPartsResponsesValPowerChange( + t *testing.T, state sm.State, power int64, ) (types.Header, types.BlockID, *tmstate.ABCIResponses) { - block := sf.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + block, err := sf.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + abciResponses := &tmstate.ABCIResponses{ BeginBlock: &abci.ResponseBeginBlock{}, EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: nil}, @@ -207,11 +215,13 @@ func makeHeaderPartsResponsesValPowerChange( } func makeHeaderPartsResponsesParams( + t *testing.T, state sm.State, params *types.ConsensusParams, ) (types.Header, types.BlockID, *tmstate.ABCIResponses) { - block := sf.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + block, err := sf.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) pbParams := params.ToProto() abciResponses := &tmstate.ABCIResponses{ BeginBlock: &abci.ResponseBeginBlock{}, diff --git a/internal/state/state.go b/internal/state/state.go index 6fd632ff9..277143cee 100644 --- a/internal/state/state.go +++ b/internal/state/state.go @@ -258,7 +258,7 @@ func (state State) MakeBlock( commit *types.Commit, evidence []types.Evidence, proposerAddress []byte, -) (*types.Block, *types.PartSet) { +) (*types.Block, *types.PartSet, error) { // Build base block with block data. block := types.MakeBlock(height, txs, commit, evidence) @@ -280,7 +280,12 @@ func (state State) MakeBlock( proposerAddress, ) - return block, block.MakePartSet(types.BlockPartSizeBytes) + bps, err := block.MakePartSet(types.BlockPartSizeBytes) + if err != nil { + return nil, nil, err + } + + return block, bps, nil } // MedianTime computes a median time for a given Commit (based on Timestamp field of votes messages) and the diff --git a/internal/state/state_test.go b/internal/state/state_test.go index 3f989536a..10b0c356e 100644 --- a/internal/state/state_test.go +++ b/internal/state/state_test.go @@ -107,7 +107,8 @@ func TestABCIResponsesSaveLoad1(t *testing.T) { state.LastBlockHeight++ // Build mock responses. - block := statefactory.MakeBlock(state, 2, new(types.Commit)) + block, err := statefactory.MakeBlock(state, 2, new(types.Commit)) + require.NoError(t, err) abciResponses := new(tmstate.ABCIResponses) dtxs := make([]*abci.ResponseDeliverTx, 2) @@ -275,7 +276,7 @@ func TestOneValidatorChangesSaveLoad(t *testing.T) { changeIndex++ power++ } - header, blockID, responses := makeHeaderPartsResponsesValPowerChange(state, power) + header, blockID, responses := makeHeaderPartsResponsesValPowerChange(t, state, power) validatorUpdates, err = types.PB2TM.ValidatorUpdates(responses.EndBlock.ValidatorUpdates) require.NoError(t, err) state, err = sm.UpdateState(state, blockID, &header, responses, validatorUpdates) @@ -451,8 +452,11 @@ func TestProposerPriorityDoesNotGetResetToZero(t *testing.T) { // NewValidatorSet calls IncrementProposerPriority but uses on a copy of val1 assert.EqualValues(t, 0, val1.ProposerPriority) - block := statefactory.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := statefactory.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} abciResponses := &tmstate.ABCIResponses{ BeginBlock: &abci.ResponseBeginBlock{}, EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: nil}, @@ -565,8 +569,11 @@ func TestProposerPriorityProposerAlternates(t *testing.T) { // we only have one validator: assert.Equal(t, val1PubKey.Address(), state.Validators.Proposer.Address) - block := statefactory.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := statefactory.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} // no updates: abciResponses := &tmstate.ABCIResponses{ BeginBlock: &abci.ResponseBeginBlock{}, @@ -752,8 +759,11 @@ func TestLargeGenesisValidator(t *testing.T) { validatorUpdates, err := types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) - block := statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} updatedState, err := sm.UpdateState(oldState, blockID, &block.Header, abciResponses, validatorUpdates) require.NoError(t, err) @@ -781,8 +791,13 @@ func TestLargeGenesisValidator(t *testing.T) { BeginBlock: &abci.ResponseBeginBlock{}, EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{firstAddedVal}}, } - block := statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} updatedState, err := sm.UpdateState(oldState, blockID, &block.Header, abciResponses, validatorUpdates) require.NoError(t, err) @@ -796,8 +811,13 @@ func TestLargeGenesisValidator(t *testing.T) { validatorUpdates, err := types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) - block := statefactory.MakeBlock(lastState, lastState.LastBlockHeight+1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := statefactory.MakeBlock(lastState, lastState.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + + bps, err = block.MakePartSet(testPartSize) + require.NoError(t, err) + + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} updatedStateInner, err := sm.UpdateState(lastState, blockID, &block.Header, abciResponses, validatorUpdates) require.NoError(t, err) @@ -829,8 +849,12 @@ func TestLargeGenesisValidator(t *testing.T) { BeginBlock: &abci.ResponseBeginBlock{}, EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{addedVal}}, } - block := statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} state, err = sm.UpdateState(state, blockID, &block.Header, abciResponses, validatorUpdates) require.NoError(t, err) } @@ -844,8 +868,14 @@ func TestLargeGenesisValidator(t *testing.T) { BeginBlock: &abci.ResponseBeginBlock{}, EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{removeGenesisVal}}, } - block = statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) - blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + + block, err = statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + + bps, err = block.MakePartSet(testPartSize) + require.NoError(t, err) + + blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} validatorUpdates, err = types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) updatedState, err = sm.UpdateState(state, blockID, &block.Header, abciResponses, validatorUpdates) @@ -865,8 +895,13 @@ func TestLargeGenesisValidator(t *testing.T) { } validatorUpdates, err = types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) - block = statefactory.MakeBlock(curState, curState.LastBlockHeight+1, new(types.Commit)) - blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err = statefactory.MakeBlock(curState, curState.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + + blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} curState, err = sm.UpdateState(curState, blockID, &block.Header, abciResponses, validatorUpdates) require.NoError(t, err) if !bytes.Equal(curState.Validators.Proposer.Address, curState.NextValidators.Proposer.Address) { @@ -890,8 +925,13 @@ func TestLargeGenesisValidator(t *testing.T) { validatorUpdates, err := types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) - block := statefactory.MakeBlock(updatedState, updatedState.LastBlockHeight+1, new(types.Commit)) - blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} + block, err := statefactory.MakeBlock(updatedState, updatedState.LastBlockHeight+1, new(types.Commit)) + require.NoError(t, err) + + bps, err := block.MakePartSet(testPartSize) + require.NoError(t, err) + + blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()} updatedState, err = sm.UpdateState(updatedState, blockID, &block.Header, abciResponses, validatorUpdates) require.NoError(t, err) @@ -946,7 +986,7 @@ func TestManyValidatorChangesSaveLoad(t *testing.T) { pubkey := ed25519.GenPrivKey().PubKey() // Swap the first validator with a new one (validator set size stays the same). - header, blockID, responses := makeHeaderPartsResponsesValPubKeyChange(state, pubkey) + header, blockID, responses := makeHeaderPartsResponsesValPubKeyChange(t, state, pubkey) // Save state etc. var validatorUpdates []*types.Validator @@ -985,7 +1025,8 @@ func TestStateMakeBlock(t *testing.T) { proposerAddress := state.Validators.GetProposer().Address stateVersion := state.Version.Consensus - block := statefactory.MakeBlock(state, 2, new(types.Commit)) + block, err := statefactory.MakeBlock(state, 2, new(types.Commit)) + require.NoError(t, err) // test we set some fields assert.Equal(t, stateVersion, block.Version) @@ -1026,7 +1067,7 @@ func TestConsensusParamsChangesSaveLoad(t *testing.T) { changeIndex++ cp = params[changeIndex] } - header, blockID, responses := makeHeaderPartsResponsesParams(state, &cp) + header, blockID, responses := makeHeaderPartsResponsesParams(t, state, &cp) validatorUpdates, err = types.PB2TM.ValidatorUpdates(responses.EndBlock.ValidatorUpdates) require.NoError(t, err) state, err = sm.UpdateState(state, blockID, &header, responses, validatorUpdates) diff --git a/internal/state/test/factory/block.go b/internal/state/test/factory/block.go index dfcf5ebd9..e43ec7533 100644 --- a/internal/state/test/factory/block.go +++ b/internal/state/test/factory/block.go @@ -8,8 +8,8 @@ import ( "github.com/tendermint/tendermint/types" ) -func MakeBlocks(n int, state *sm.State, privVal types.PrivValidator) []*types.Block { - blocks := make([]*types.Block, 0) +func MakeBlocks(n int, state *sm.State, privVal types.PrivValidator) ([]*types.Block, error) { + blocks := make([]*types.Block, n) var ( prevBlock *types.Block @@ -20,8 +20,12 @@ func MakeBlocks(n int, state *sm.State, privVal types.PrivValidator) []*types.Bl for i := 0; i < n; i++ { height := int64(i + 1) - block, parts := makeBlockAndPartSet(*state, prevBlock, prevBlockMeta, privVal, height) - blocks = append(blocks, block) + block, parts, err := makeBlockAndPartSet(*state, prevBlock, prevBlockMeta, privVal, height) + if err != nil { + return nil, err + } + + blocks[i] = block prevBlock = block prevBlockMeta = types.NewBlockMeta(block, parts) @@ -32,23 +36,31 @@ func MakeBlocks(n int, state *sm.State, privVal types.PrivValidator) []*types.Bl state.LastBlockHeight = height } - return blocks + return blocks, nil } -func MakeBlock(state sm.State, height int64, c *types.Commit) *types.Block { - block, _ := state.MakeBlock( +func MakeBlock(state sm.State, height int64, c *types.Commit) (*types.Block, error) { + block, _, err := state.MakeBlock( height, factory.MakeTenTxs(state.LastBlockHeight), c, nil, state.Validators.GetProposer().Address, ) - return block -} + if err != nil { + return nil, err + } -func makeBlockAndPartSet(state sm.State, lastBlock *types.Block, lastBlockMeta *types.BlockMeta, - privVal types.PrivValidator, height int64) (*types.Block, *types.PartSet) { + return block, nil +} +func makeBlockAndPartSet( + state sm.State, + lastBlock *types.Block, + lastBlockMeta *types.BlockMeta, + privVal types.PrivValidator, + height int64, +) (*types.Block, *types.PartSet, error) { lastCommit := types.NewCommit(height-1, 0, types.BlockID{}, nil) if height > 1 { vote, _ := factory.MakeVote( diff --git a/internal/state/validation_test.go b/internal/state/validation_test.go index 19b830709..2bb35a6e7 100644 --- a/internal/state/validation_test.go +++ b/internal/state/validation_test.go @@ -92,9 +92,10 @@ func TestValidateBlockHeader(t *testing.T) { Invalid blocks don't pass */ for _, tc := range testCases { - block := statefactory.MakeBlock(state, height, lastCommit) + block, err := statefactory.MakeBlock(state, height, lastCommit) + require.NoError(t, err) tc.malleateBlock(block) - err := blockExec.ValidateBlock(state, block) + err = blockExec.ValidateBlock(state, block) t.Logf("%s: %v", tc.name, err) require.Error(t, err, tc.name) } @@ -109,9 +110,10 @@ func TestValidateBlockHeader(t *testing.T) { } nextHeight := validationTestsStopHeight - block := statefactory.MakeBlock(state, nextHeight, lastCommit) + block, err := statefactory.MakeBlock(state, nextHeight, lastCommit) + require.NoError(t, err) state.InitialHeight = nextHeight + 1 - err := blockExec.ValidateBlock(state, block) + err = blockExec.ValidateBlock(state, block) require.Error(t, err, "expected an error when state is ahead of block") assert.Contains(t, err.Error(), "lower than initial height") } @@ -162,7 +164,8 @@ func TestValidateBlockCommit(t *testing.T) { state.LastBlockID, []types.CommitSig{wrongHeightVote.CommitSig()}, ) - block := statefactory.MakeBlock(state, height, wrongHeightCommit) + block, err := statefactory.MakeBlock(state, height, wrongHeightCommit) + require.NoError(t, err) err = blockExec.ValidateBlock(state, block) _, isErrInvalidCommitHeight := err.(types.ErrInvalidCommitHeight) require.True(t, isErrInvalidCommitHeight, "expected ErrInvalidCommitHeight at height %d but got: %v", height, err) @@ -170,7 +173,8 @@ func TestValidateBlockCommit(t *testing.T) { /* #2589: test len(block.LastCommit.Signatures) == state.LastValidators.Size() */ - block = statefactory.MakeBlock(state, height, wrongSigsCommit) + block, err = statefactory.MakeBlock(state, height, wrongSigsCommit) + require.NoError(t, err) err = blockExec.ValidateBlock(state, block) _, isErrInvalidCommitSignatures := err.(types.ErrInvalidCommitSignatures) require.True(t, isErrInvalidCommitSignatures, @@ -285,8 +289,10 @@ func TestValidateBlockEvidence(t *testing.T) { evidence = append(evidence, newEv) currentBytes += int64(len(newEv.Bytes())) } - block, _ := state.MakeBlock(height, testfactory.MakeTenTxs(height), lastCommit, evidence, proposerAddr) - err := blockExec.ValidateBlock(state, block) + block, _, err := state.MakeBlock(height, testfactory.MakeTenTxs(height), lastCommit, evidence, proposerAddr) + require.NoError(t, err) + + err = blockExec.ValidateBlock(state, block) if assert.Error(t, err) { _, ok := err.(*types.ErrEvidenceOverflow) require.True(t, ok, "expected error to be of type ErrEvidenceOverflow at height %d but got %v", height, err) diff --git a/internal/store/store_test.go b/internal/store/store_test.go index 14163f488..db71bb4b0 100644 --- a/internal/store/store_test.go +++ b/internal/store/store_test.go @@ -2,6 +2,7 @@ package store import ( "fmt" + stdlog "log" "os" "runtime/debug" "strings" @@ -75,9 +76,17 @@ var ( func TestMain(m *testing.M) { var cleanup cleanupFunc + var err error state, _, cleanup = makeStateAndBlockStore(log.NewNopLogger()) - block = factory.MakeBlock(state, 1, new(types.Commit)) - partSet = block.MakePartSet(2) + block, err = factory.MakeBlock(state, 1, new(types.Commit)) + + if err != nil { + stdlog.Fatal(err) + } + partSet, err = block.MakePartSet(2) + if err != nil { + stdlog.Fatal(err) + } part1 = partSet.GetPart(0) part2 = partSet.GetPart(1) seenCommit1 = makeTestCommit(10, tmtime.Now()) @@ -102,8 +111,10 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) { } // save a block - block := factory.MakeBlock(state, bs.Height()+1, new(types.Commit)) - validPartSet := block.MakePartSet(2) + block, err := factory.MakeBlock(state, bs.Height()+1, new(types.Commit)) + require.NoError(t, err) + validPartSet, err := block.MakePartSet(2) + require.NoError(t, err) seenCommit := makeTestCommit(10, tmtime.Now()) bs.SaveBlock(block, partSet, seenCommit) require.EqualValues(t, 1, bs.Base(), "expecting the new height to be changed") @@ -111,7 +122,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) { incompletePartSet := types.NewPartSetFromHeader(types.PartSetHeader{Total: 2}) uncontiguousPartSet := types.NewPartSetFromHeader(types.PartSetHeader{Total: 0}) - _, err := uncontiguousPartSet.AddPart(part2) + _, err = uncontiguousPartSet.AddPart(part2) require.Error(t, err) header1 := types.Header{ @@ -305,8 +316,10 @@ func TestLoadBaseMeta(t *testing.T) { bs := NewBlockStore(dbm.NewMemDB()) for h := int64(1); h <= 10; h++ { - block := factory.MakeBlock(state, h, new(types.Commit)) - partSet := block.MakePartSet(2) + block, err := factory.MakeBlock(state, h, new(types.Commit)) + require.NoError(t, err) + partSet, err := block.MakePartSet(2) + require.NoError(t, err) seenCommit := makeTestCommit(h, tmtime.Now()) bs.SaveBlock(block, partSet, seenCommit) } @@ -371,8 +384,10 @@ func TestPruneBlocks(t *testing.T) { // make more than 1000 blocks, to test batch deletions for h := int64(1); h <= 1500; h++ { - block := factory.MakeBlock(state, h, new(types.Commit)) - partSet := block.MakePartSet(2) + block, err := factory.MakeBlock(state, h, new(types.Commit)) + require.NoError(t, err) + partSet, err := block.MakePartSet(2) + require.NoError(t, err) seenCommit := makeTestCommit(h, tmtime.Now()) bs.SaveBlock(block, partSet, seenCommit) } @@ -476,9 +491,11 @@ func TestBlockFetchAtHeight(t *testing.T) { state, bs, cleanup := makeStateAndBlockStore(log.NewNopLogger()) defer cleanup() require.Equal(t, bs.Height(), int64(0), "initially the height should be zero") - block := factory.MakeBlock(state, bs.Height()+1, new(types.Commit)) + block, err := factory.MakeBlock(state, bs.Height()+1, new(types.Commit)) + require.NoError(t, err) - partSet := block.MakePartSet(2) + partSet, err := block.MakePartSet(2) + require.NoError(t, err) seenCommit := makeTestCommit(10, tmtime.Now()) bs.SaveBlock(block, partSet, seenCommit) require.Equal(t, bs.Height(), block.Header.Height, "expecting the new height to be changed") @@ -517,8 +534,10 @@ func TestSeenAndCanonicalCommit(t *testing.T) { // are persisted. for h := int64(3); h <= 5; h++ { blockCommit := makeTestCommit(h-1, tmtime.Now()) - block := factory.MakeBlock(state, h, blockCommit) - partSet := block.MakePartSet(2) + block, err := factory.MakeBlock(state, h, blockCommit) + require.NoError(t, err) + partSet, err := block.MakePartSet(2) + require.NoError(t, err) seenCommit := makeTestCommit(h, tmtime.Now()) bs.SaveBlock(block, partSet, seenCommit) c3 := bs.LoadSeenCommit() diff --git a/node/node_test.go b/node/node_test.go index ad3980df6..7e4bd8119 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -316,14 +316,16 @@ func TestCreateProposalBlock(t *testing.T) { ) commit := types.NewCommit(height-1, 0, types.BlockID{}, nil) - block, _ := blockExec.CreateProposalBlock( + block, _, err := blockExec.CreateProposalBlock( height, state, commit, proposerAddr, ) + require.NoError(t, err) // check that the part set does not exceed the maximum block size - partSet := block.MakePartSet(partSize) + partSet, err := block.MakePartSet(partSize) + require.NoError(t, err) assert.Less(t, partSet.ByteSize(), int64(maxBytes)) partSetFromHeader := types.NewPartSetFromHeader(partSet.Header()) @@ -387,18 +389,20 @@ func TestMaxTxsProposalBlockSize(t *testing.T) { ) commit := types.NewCommit(height-1, 0, types.BlockID{}, nil) - block, _ := blockExec.CreateProposalBlock( + block, _, err := blockExec.CreateProposalBlock( height, state, commit, proposerAddr, ) + require.NoError(t, err) pb, err := block.ToProto() require.NoError(t, err) assert.Less(t, int64(pb.Size()), maxBytes) // check that the part set does not exceed the maximum block size - partSet := block.MakePartSet(partSize) + partSet, err := block.MakePartSet(partSize) + require.NoError(t, err) assert.EqualValues(t, partSet.ByteSize(), int64(pb.Size())) } @@ -494,11 +498,12 @@ func TestMaxProposalBlockSize(t *testing.T) { commit.Signatures = append(commit.Signatures, cs) } - block, partSet := blockExec.CreateProposalBlock( + block, partSet, err := blockExec.CreateProposalBlock( math.MaxInt64, state, commit, proposerAddr, ) + require.NoError(t, err) // this ensures that the header is at max size block.Header.Time = timestamp diff --git a/types/block.go b/types/block.go index 89054e100..a2e34d5e5 100644 --- a/types/block.go +++ b/types/block.go @@ -126,22 +126,22 @@ func (b *Block) Hash() tmbytes.HexBytes { // MakePartSet returns a PartSet containing parts of a serialized block. // This is the form in which the block is gossipped to peers. // CONTRACT: partSize is greater than zero. -func (b *Block) MakePartSet(partSize uint32) *PartSet { +func (b *Block) MakePartSet(partSize uint32) (*PartSet, error) { if b == nil { - return nil + return nil, errors.New("nil block") } b.mtx.Lock() defer b.mtx.Unlock() pbb, err := b.ToProto() if err != nil { - panic(err) + return nil, err } bz, err := proto.Marshal(pbb) if err != nil { - panic(err) + return nil, err } - return NewPartSetFromData(bz, partSize) + return NewPartSetFromData(bz, partSize), nil } // HashesTo is a convenience function that checks if a block hashes to the given argument. diff --git a/types/block_test.go b/types/block_test.go index e0c1ab3be..64d98131f 100644 --- a/types/block_test.go +++ b/types/block_test.go @@ -123,15 +123,20 @@ func TestBlockHash(t *testing.T) { } func TestBlockMakePartSet(t *testing.T) { - assert.Nil(t, (*Block)(nil).MakePartSet(2)) + bps, err := (*Block)(nil).MakePartSet(2) + assert.Error(t, err) + assert.Nil(t, bps) - partSet := MakeBlock(int64(3), []Tx{Tx("Hello World")}, nil, nil).MakePartSet(1024) + partSet, err := MakeBlock(int64(3), []Tx{Tx("Hello World")}, nil, nil).MakePartSet(1024) + require.NoError(t, err) assert.NotNil(t, partSet) assert.EqualValues(t, 1, partSet.Total()) } func TestBlockMakePartSetWithEvidence(t *testing.T) { - assert.Nil(t, (*Block)(nil).MakePartSet(2)) + bps, err := (*Block)(nil).MakePartSet(2) + assert.Error(t, err) + assert.Nil(t, bps) lastID := makeBlockIDRandom() h := int64(3) @@ -143,7 +148,9 @@ func TestBlockMakePartSetWithEvidence(t *testing.T) { ev := NewMockDuplicateVoteEvidenceWithValidator(h, time.Now(), vals[0], "block-test-chain") evList := []Evidence{ev} - partSet := MakeBlock(h, []Tx{Tx("Hello World")}, commit, evList).MakePartSet(512) + partSet, err := MakeBlock(h, []Tx{Tx("Hello World")}, commit, evList).MakePartSet(512) + require.NoError(t, err) + assert.NotNil(t, partSet) assert.EqualValues(t, 4, partSet.Total()) } diff --git a/types/evidence_test.go b/types/evidence_test.go index 06c118d61..51a91a75a 100644 --- a/types/evidence_test.go +++ b/types/evidence_test.go @@ -249,9 +249,8 @@ func makeVote( vpb := v.ToProto() err = val.SignVote(context.Background(), chainID, vpb) - if err != nil { - panic(err) - } + require.NoError(t, err) + v.Signature = vpb.Signature return v }