abci: implement finalize block (#9468)

Adds the `FinalizeBlock` method which replaces `BeginBlock`, `DeliverTx`, and `EndBlock` in a single call.

cmd/tendermint/commands/reindex_event.go

@@ -143,38 +143,38 @@ func eventReIndex(cmd *cobra.Command, args eventReIndexArgs) error {
 
 	fmt.Println("start re-indexing events:")
 	defer bar.Finish()
-	for i := args.startHeight; i <= args.endHeight; i++ {
+	for height := args.startHeight; height <= args.endHeight; height++ {
 		select {
 		case <-cmd.Context().Done():
-			return fmt.Errorf("event re-index terminated at height %d: %w", i, cmd.Context().Err())
+			return fmt.Errorf("event re-index terminated at height %d: %w", height, cmd.Context().Err())
 		default:
-			b := args.blockStore.LoadBlock(i)
-			if b == nil {
-				return fmt.Errorf("not able to load block at height %d from the blockstore", i)
+			block := args.blockStore.LoadBlock(height)
+			if block == nil {
+				return fmt.Errorf("not able to load block at height %d from the blockstore", height)
 			}
 
-			r, err := args.stateStore.LoadABCIResponses(i)
+			resp, err := args.stateStore.LoadFinalizeBlockResponse(height)
 			if err != nil {
-				return fmt.Errorf("not able to load ABCI Response at height %d from the statestore", i)
+				return fmt.Errorf("not able to load ABCI Response at height %d from the statestore", height)
 			}
 
-			e := types.EventDataNewBlockHeader{
-				Header:           b.Header,
-				NumTxs:           int64(len(b.Txs)),
-				ResultBeginBlock: *r.BeginBlock,
-				ResultEndBlock:   *r.EndBlock,
+			e := types.EventDataNewBlockEvents{
+				Height: height,
+				Events: resp.Events,
 			}
 
+			numTxs := len(resp.TxResults)
+
 			var batch *txindex.Batch
-			if e.NumTxs > 0 {
-				batch = txindex.NewBatch(e.NumTxs)
+			if numTxs > 0 {
+				batch = txindex.NewBatch(int64(numTxs))
 
-				for i := range b.Data.Txs {
+				for idx, txResult := range resp.TxResults {
 					tr := abcitypes.TxResult{
-						Height: b.Height,
-						Index:  uint32(i),
-						Tx:     b.Data.Txs[i],
-						Result: *(r.DeliverTxs[i]),
+						Height: height,
+						Index:  uint32(idx),
+						Tx:     block.Txs[idx],
+						Result: *txResult,
 					}
 
 					if err = batch.Add(&tr); err != nil {
@@ -183,16 +183,16 @@ func eventReIndex(cmd *cobra.Command, args eventReIndexArgs) error {
 				}
 
 				if err := args.txIndexer.AddBatch(batch); err != nil {
-					return fmt.Errorf("tx event re-index at height %d failed: %w", i, err)
+					return fmt.Errorf("tx event re-index at height %d failed: %w", height, err)
 				}
 			}
 
 			if err := args.blockIndexer.Index(e); err != nil {
-				return fmt.Errorf("block event re-index at height %d failed: %w", i, err)
+				return fmt.Errorf("block event re-index at height %d failed: %w", height, err)
 			}
 		}
 
-		bar.Play(i)
+		bar.Play(height)
 	}
 
 	return nil

cmd/tendermint/commands/reindex_event_test.go

@@ -14,7 +14,6 @@ import (
 	abcitypes "github.com/tendermint/tendermint/abci/types"
 	tmcfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/test"
-	prototmstate "github.com/tendermint/tendermint/proto/tendermint/state"
 	blockmocks "github.com/tendermint/tendermint/state/indexer/mocks"
 	"github.com/tendermint/tendermint/state/mocks"
 	txmocks "github.com/tendermint/tendermint/state/txindex/mocks"
@@ -141,25 +140,24 @@ func TestReIndexEvent(t *testing.T) {
 		On("LoadBlock", base).Return(&types.Block{Data: types.Data{Txs: types.Txs{make(types.Tx, 1)}}}).
 		On("LoadBlock", height).Return(&types.Block{Data: types.Data{Txs: types.Txs{make(types.Tx, 1)}}})
 
-	dtx := abcitypes.ResponseDeliverTx{}
-	abciResp := &prototmstate.ABCIResponses{
-		DeliverTxs: []*abcitypes.ResponseDeliverTx{&dtx},
-		EndBlock:   &abcitypes.ResponseEndBlock{},
-		BeginBlock: &abcitypes.ResponseBeginBlock{},
+	abciResp := &abcitypes.ResponseFinalizeBlock{
+		TxResults: []*abcitypes.ExecTxResult{
+			{Code: 1},
+		},
 	}
 
 	mockBlockIndexer.
-		On("Index", mock.AnythingOfType("types.EventDataNewBlockHeader")).Return(errors.New("")).Once().
-		On("Index", mock.AnythingOfType("types.EventDataNewBlockHeader")).Return(nil)
+		On("Index", mock.AnythingOfType("types.EventDataNewBlockEvents")).Return(errors.New("")).Once().
+		On("Index", mock.AnythingOfType("types.EventDataNewBlockEvents")).Return(nil)
 
 	mockTxIndexer.
 		On("AddBatch", mock.AnythingOfType("*txindex.Batch")).Return(errors.New("")).Once().
 		On("AddBatch", mock.AnythingOfType("*txindex.Batch")).Return(nil)
 
 	mockStateStore.
-		On("LoadABCIResponses", base).Return(nil, errors.New("")).Once().
-		On("LoadABCIResponses", base).Return(abciResp, nil).
-		On("LoadABCIResponses", height).Return(abciResp, nil)
+		On("LoadFinalizeBlockResponse", base).Return(nil, errors.New("")).Once().
+		On("LoadFinalizeBlockResponse", base).Return(abciResp, nil).
+		On("LoadFinalizeBlockResponse", height).Return(abciResp, nil)
 
 	testCases := []struct {
 		startHeight int64
@@ -167,7 +165,7 @@ func TestReIndexEvent(t *testing.T) {
 		reIndexErr  bool
 	}{
 		{base, height, true}, // LoadBlock error
-		{base, height, true}, // LoadABCIResponses error
+		{base, height, true}, // LoadFinalizeBlockResponse error
 		{base, height, true}, // index block event error
 		{base, height, true}, // index tx event error
 		{base, base, false},