fix amino overhead computation for Tx (#2792)

* fix amino overhead computation for Tx:

- also count the fieldnum / typ3
- add method to compute overhead per Tx
- slightly clarify comment on MaxAminoOverheadForBlock
- add tests

* fix TestReapMaxBytesMaxGas according to amino overhead

* fix TestMempoolFilters according to amino overhead

* address review comments:

 - add a note about fieldNum = 1
 - add forgotten godoc comment

* fix and use sm.TxPreCheck

* fix test

* remove print statement

state/execution.go

@@ -8,7 +8,6 @@ import (
 	dbm "github.com/tendermint/tendermint/libs/db"
 	"github.com/tendermint/tendermint/libs/fail"
 	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/mempool"
 	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
@@ -180,13 +179,8 @@ func (blockExec *BlockExecutor) Commit(
 	err = blockExec.mempool.Update(
 		block.Height,
 		block.Txs,
-		mempool.PreCheckAminoMaxBytes(
-			types.MaxDataBytesUnknownEvidence(
-				state.ConsensusParams.BlockSize.MaxBytes,
-				state.Validators.Size(),
-			),
-		),
-		mempool.PostCheckMaxGas(state.ConsensusParams.BlockSize.MaxGas),
+		TxPreCheck(state),
+		TxPostCheck(state),
 	)
 
 	return res.Data, err

state/tx_filter.go

@@ -1,15 +1,22 @@
 package state
 
 import (
+	mempl "github.com/tendermint/tendermint/mempool"
 	"github.com/tendermint/tendermint/types"
 )
 
-// TxFilter returns a function to filter transactions. The function limits the
-// size of a transaction to the maximum block's data size.
-func TxFilter(state State) func(tx types.Tx) bool {
+// TxPreCheck returns a function to filter transactions before processing.
+// The function limits the size of a transaction to the block's maximum data size.
+func TxPreCheck(state State) mempl.PreCheckFunc {
 	maxDataBytes := types.MaxDataBytesUnknownEvidence(
 		state.ConsensusParams.BlockSize.MaxBytes,
 		state.Validators.Size(),
 	)
-	return func(tx types.Tx) bool { return int64(len(tx)) <= maxDataBytes }
+	return mempl.PreCheckAminoMaxBytes(maxDataBytes)
+}
+
+// TxPostCheck returns a function to filter transactions after processing.
+// The function limits the gas wanted by a transaction to the block's maximum total gas.
+func TxPostCheck(state State) mempl.PostCheckFunc {
+	return mempl.PostCheckMaxGas(state.ConsensusParams.BlockSize.MaxGas)
 }

state/tx_filter_test.go

@@ -18,12 +18,18 @@ func TestTxFilter(t *testing.T) {
 	genDoc := randomGenesisDoc()
 	genDoc.ConsensusParams.BlockSize.MaxBytes = 3000
 
+	// Max size of Txs is much smaller than size of block,
+	// since we need to account for commits and evidence.
 	testCases := []struct {
-		tx        types.Tx
-		isTxValid bool
+		tx    types.Tx
+		isErr bool
 	}{
-		{types.Tx(cmn.RandBytes(250)), true},
-		{types.Tx(cmn.RandBytes(3001)), false},
+		{types.Tx(cmn.RandBytes(250)), false},
+		{types.Tx(cmn.RandBytes(1809)), false},
+		{types.Tx(cmn.RandBytes(1810)), false},
+		{types.Tx(cmn.RandBytes(1811)), true},
+		{types.Tx(cmn.RandBytes(1812)), true},
+		{types.Tx(cmn.RandBytes(3000)), true},
 	}
 
 	for i, tc := range testCases {
@@ -31,8 +37,12 @@ func TestTxFilter(t *testing.T) {
 		state, err := LoadStateFromDBOrGenesisDoc(stateDB, genDoc)
 		require.NoError(t, err)
 
-		f := TxFilter(state)
-		assert.Equal(t, tc.isTxValid, f(tc.tx), "#%v", i)
+		f := TxPreCheck(state)
+		if tc.isErr {
+			assert.NotNil(t, f(tc.tx), "#%v", i)
+		} else {
+			assert.Nil(t, f(tc.tx), "#%v", i)
+		}
 	}
 }