Add TotalTx to block header, issue #952

Update state to keep track of this info.
Change function args as needed.
Make NumTx also an int64 for consistency.

blockchain/reactor_test.go

@@ -106,7 +106,9 @@ func makeBlock(height int64, state *sm.State) *types.Block {
 	valHash := state.Validators.Hash()
 	prevBlockID := types.BlockID{prevHash, prevParts}
 	block, _ := types.MakeBlock(height, "test_chain", makeTxs(height),
-		new(types.Commit), prevBlockID, valHash, state.AppHash, state.Params.BlockGossipParams.BlockPartSizeBytes)
+		state.LastBlockTotalTx, new(types.Commit),
+		prevBlockID, valHash, state.AppHash,
+		state.Params.BlockGossipParams.BlockPartSizeBytes)
 	return block
 }
 

consensus/mempool_test.go

@@ -108,7 +108,8 @@ func TestTxConcurrentWithCommit(t *testing.T) {
 	for nTxs := 0; nTxs < NTxs; {
 		select {
 		case b := <-newBlockCh:
-			nTxs += b.(types.TMEventData).Unwrap().(types.EventDataNewBlock).Block.Header.NumTxs
+			evt := b.(types.TMEventData).Unwrap().(types.EventDataNewBlock)
+			nTxs += int(evt.Block.Header.NumTxs)
 		case <-ticker.C:
 			panic("Timed out waiting to commit blocks with transactions")
 		}

consensus/state.go

@@ -863,7 +863,8 @@ func (cs *ConsensusState) createProposalBlock() (block *types.Block, blockParts
 
 	// Mempool validated transactions
 	txs := cs.mempool.Reap(cs.config.MaxBlockSizeTxs)
-	return types.MakeBlock(cs.Height, cs.state.ChainID, txs, commit,
+	return types.MakeBlock(cs.Height, cs.state.ChainID, txs,
+		cs.state.LastBlockTotalTx, commit,
 		cs.state.LastBlockID, cs.state.Validators.Hash(),
 		cs.state.AppHash, cs.state.Params.BlockPartSizeBytes)
 }
@@ -1200,7 +1201,7 @@ func (cs *ConsensusState) finalizeCommit(height int64) {
 	// Create a copy of the state for staging
 	// and an event cache for txs
 	stateCopy := cs.state.Copy()
-	txEventBuffer := types.NewTxEventBuffer(cs.eventBus, block.NumTxs)
+	txEventBuffer := types.NewTxEventBuffer(cs.eventBus, int(block.NumTxs))
 
 	// Execute and commit the block, update and save the state, and update the mempool.
 	// All calls to the proxyAppConn come here.

lite/helpers.go

@@ -112,10 +112,11 @@ func genHeader(chainID string, height int64, txs types.Txs,
 	vals *types.ValidatorSet, appHash []byte) *types.Header {
 
 	return &types.Header{
-		ChainID: chainID,
+		ChainID:  chainID,
-		Height:  height,
+		Height:   height,
-		Time:    time.Now(),
+		Time:     time.Now(),
-		NumTxs:  len(txs),
+		NumTxs:   int64(len(txs)),
+		TotalTxs: int64(len(txs)),
 		// LastBlockID
 		// LastCommitHash
 		ValidatorsHash: vals.Hash(),

state/execution.go

@@ -178,7 +178,8 @@ func (s *State) ValidateBlock(block *types.Block) error {
 
 func (s *State) validateBlock(block *types.Block) error {
 	// Basic block validation.
-	err := block.ValidateBasic(s.ChainID, s.LastBlockHeight, s.LastBlockID, s.LastBlockTime, s.AppHash)
+	err := block.ValidateBasic(s.ChainID, s.LastBlockHeight,
+		s.LastBlockTotalTx, s.LastBlockID, s.LastBlockTime, s.AppHash)
 	if err != nil {
 		return err
 	}

state/execution_test.go

@@ -66,7 +66,9 @@ func makeBlock(height int64, state *State) *types.Block {
 	prevParts := types.PartSetHeader{}
 	valHash := state.Validators.Hash()
 	prevBlockID := types.BlockID{prevHash, prevParts}
-	block, _ := types.MakeBlock(height, chainID, makeTxs(height), new(types.Commit),
+	block, _ := types.MakeBlock(height, chainID,
-		prevBlockID, valHash, state.AppHash, testPartSize)
+		makeTxs(height), state.LastBlockTotalTx,
+		new(types.Commit), prevBlockID, valHash,
+		state.AppHash, testPartSize)
 	return block
 }

state/state.go

@@ -45,11 +45,12 @@ type State struct {
 	// These fields are updated by SetBlockAndValidators.
 	// LastBlockHeight=0 at genesis (ie. block(H=0) does not exist)
 	// LastValidators is used to validate block.LastCommit.
-	LastBlockHeight int64
+	LastBlockHeight  int64
-	LastBlockID     types.BlockID
+	LastBlockTotalTx int64
-	LastBlockTime   time.Time
+	LastBlockID      types.BlockID
-	Validators      *types.ValidatorSet
+	LastBlockTime    time.Time
-	LastValidators  *types.ValidatorSet
+	Validators       *types.ValidatorSet
+	LastValidators   *types.ValidatorSet
 	// When a block returns a validator set change via EndBlock,
 	// the change only applies to the next block.
 	// So, if s.LastBlockHeight causes a valset change,
@@ -113,6 +114,7 @@ func (s *State) Copy() *State {
 	return &State{
 		db:                          s.db,
 		LastBlockHeight:             s.LastBlockHeight,
+		LastBlockTotalTx:            s.LastBlockTotalTx,
 		LastBlockID:                 s.LastBlockID,
 		LastBlockTime:               s.LastBlockTime,
 		Validators:                  s.Validators.Copy(),
@@ -250,16 +252,19 @@ func (s *State) SetBlockAndValidators(header *types.Header, blockPartsHeader typ
 	nextValSet.IncrementAccum(1)
 
 	s.setBlockAndValidators(header.Height,
+		header.NumTxs,
 		types.BlockID{header.Hash(), blockPartsHeader},
 		header.Time,
 		prevValSet, nextValSet)
 
 }
 
-func (s *State) setBlockAndValidators(height int64, blockID types.BlockID, blockTime time.Time,
+func (s *State) setBlockAndValidators(height int64,
+	newTxs int64, blockID types.BlockID, blockTime time.Time,
 	prevValSet, nextValSet *types.ValidatorSet) {
 
 	s.LastBlockHeight = height
+	s.LastBlockTotalTx += newTxs
 	s.LastBlockID = blockID
 	s.LastBlockTime = blockTime
 	s.Validators = nextValSet

types/block.go

@@ -23,14 +23,19 @@ type Block struct {
 
 // MakeBlock returns a new block and corresponding partset from the given information.
 // TODO: Add version information to the Block struct.
-func MakeBlock(height int64, chainID string, txs []Tx, commit *Commit,
+func MakeBlock(height int64, chainID string, txs []Tx,
-	prevBlockID BlockID, valHash, appHash []byte, partSize int) (*Block, *PartSet) {
+	totalTxs int64, commit *Commit,
+	prevBlockID BlockID, valHash, appHash []byte,
+	partSize int) (*Block, *PartSet) {
+
+	newTxs := int64(len(txs))
 	block := &Block{
 		Header: &Header{
 			ChainID:        chainID,
 			Height:         height,
 			Time:           time.Now(),
-			NumTxs:         len(txs),
+			NumTxs:         newTxs,
+			TotalTxs:       totalTxs + newTxs,
 			LastBlockID:    prevBlockID,
 			ValidatorsHash: valHash,
 			AppHash:        appHash, // state merkle root of txs from the previous block.
@@ -45,8 +50,10 @@ func MakeBlock(height int64, chainID string, txs []Tx, commit *Commit,
 }
 
 // ValidateBasic performs basic validation that doesn't involve state data.
-func (b *Block) ValidateBasic(chainID string, lastBlockHeight int64, lastBlockID BlockID,
+func (b *Block) ValidateBasic(chainID string, lastBlockHeight int64,
+	lastBlockTotalTx int64, lastBlockID BlockID,
 	lastBlockTime time.Time, appHash []byte) error {
+
 	if b.ChainID != chainID {
 		return errors.New(cmn.Fmt("Wrong Block.Header.ChainID. Expected %v, got %v", chainID, b.ChainID))
 	}
@@ -60,8 +67,12 @@ func (b *Block) ValidateBasic(chainID string, lastBlockHeight int64, lastBlockID
 			return errors.New("Invalid Block.Header.Time")
 		}
 	*/
-	if b.NumTxs != len(b.Data.Txs) {
+	newTxs := int64(len(b.Data.Txs))
-		return errors.New(cmn.Fmt("Wrong Block.Header.NumTxs. Expected %v, got %v", len(b.Data.Txs), b.NumTxs))
+	if b.NumTxs != newTxs {
+		return errors.New(cmn.Fmt("Wrong Block.Header.NumTxs. Expected %v, got %v", newTxs, b.NumTxs))
+	}
+	if b.TotalTxs != lastBlockTotalTx+newTxs {
+		return errors.New(cmn.Fmt("Wrong Block.Header.TotalTxs. Expected %v, got %v", lastBlockTotalTx+newTxs, b.TotalTxs))
 	}
 	if !b.LastBlockID.Equals(lastBlockID) {
 		return errors.New(cmn.Fmt("Wrong Block.Header.LastBlockID.  Expected %v, got %v", lastBlockID, b.LastBlockID))
@@ -160,7 +171,8 @@ type Header struct {
 	ChainID        string     `json:"chain_id"`
 	Height         int64      `json:"height"`
 	Time           time.Time  `json:"time"`
-	NumTxs         int        `json:"num_txs"` // XXX: Can we get rid of this?
+	NumTxs         int64      `json:"num_txs"` // XXX: Can we get rid of this?
+	TotalTxs       int64      `json:"total_txs"`
 	LastBlockID    BlockID    `json:"last_block_id"`
 	LastCommitHash data.Bytes `json:"last_commit_hash"` // commit from validators from the last block
 	DataHash       data.Bytes `json:"data_hash"`        // transactions
@@ -179,6 +191,7 @@ func (h *Header) Hash() data.Bytes {
 		"Height":      h.Height,
 		"Time":        h.Time,
 		"NumTxs":      h.NumTxs,
+		"TotalTxs":    h.TotalTxs,
 		"LastBlockID": h.LastBlockID,
 		"LastCommit":  h.LastCommitHash,
 		"Data":        h.DataHash,
@@ -197,6 +210,7 @@ func (h *Header) StringIndented(indent string) string {
 %s  Height:         %v
 %s  Time:           %v
 %s  NumTxs:         %v
+%s  TotalTxs:       %v
 %s  LastBlockID:    %v
 %s  LastCommit:     %v
 %s  Data:           %v
@@ -207,6 +221,7 @@ func (h *Header) StringIndented(indent string) string {
 		indent, h.Height,
 		indent, h.Time,
 		indent, h.NumTxs,
+		indent, h.TotalTxs,
 		indent, h.LastBlockID,
 		indent, h.LastCommitHash,
 		indent, h.DataHash,