mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-04-22 16:50:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

continue wading through tests

Browse Source
This commit is contained in:
Callum Waters
2022-09-29 15:56:33 +02:00
parent 178ea47b56
commit b5fa9b11d2
11 changed files with 122 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
abci/example/kvstore/helpers.go
View File

@@ -8,7 +8,6 @@ import (
"github.com/tendermint/tendermint/abci/types"
cryptoencoding "github.com/tendermint/tendermint/crypto/encoding"
"github.com/tendermint/tendermint/libs/rand"
tmrand "github.com/tendermint/tendermint/libs/rand"
"github.com/tendermint/tendermint/proto/tendermint/crypto"
)
@@ -53,7 +52,7 @@ func NewRandomTx(size int) []byte {
if size < 4 {
panic("random tx size must be greater than 3")
}
return NewTx(rand.Str(2), rand.Str(size - 3))
return NewTx(tmrand.Str(2), tmrand.Str(size-3))
}
func NewRandomTxs(n int) [][]byte {
@@ -64,8 +63,8 @@ func NewRandomTxs(n int) [][]byte {
return txs
}
func NewTxFromId(i int) []byte {
return []byte(fmt.Sprintf("%d=%d", i))
func NewTxFromID(i int) []byte {
return []byte(fmt.Sprintf("%d=%d", i, i))
}
// Create a transaction to add/remove/update a validator

21
abci/example/kvstore/kvstore.go
View File

@@ -172,16 +172,15 @@ func (app *Application) substPrepareTx(blockData [][]byte) [][]byte {
// - if key is `val` that the validator update transaction is also valid
func (app *Application) ProcessProposal(_ context.Context, req *types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
for _, tx := range req.Txs {
if len(tx) < 3 ||
bytes.Count(tx, []byte("=")) != 1 ||
bytes.HasPrefix(tx, []byte("=")) ||
bytes.HasSuffix(tx, []byte("=")) {
return &types.ResponseProcessProposal{Status: types.ResponseProcessProposal_REJECT}, nil
}
if isValidatorTx(tx) {
if _, _, err := parseValidatorTx(tx); err != nil {
return &types.ResponseProcessProposal{Status: types.ResponseProcessProposal_REJECT}, nil
}
} else if len(tx) < 3 ||
bytes.Count(tx, []byte("=")) != 1 ||
bytes.HasPrefix(tx, []byte("=")) ||
bytes.HasSuffix(tx, []byte("=")) {
return &types.ResponseProcessProposal{Status: types.ResponseProcessProposal_REJECT}, nil
}
}
return &types.ResponseProcessProposal{Status: types.ResponseProcessProposal_ACCEPT}, nil
@@ -345,24 +344,24 @@ func parseValidatorTx(tx []byte) ([]byte, int64, error) {
// get the pubkey and power
pubKeyAndPower := strings.Split(string(tx), "!")
if len(pubKeyAndPower) != 2 {
return nil, 0, fmt.Errorf("Expected 'pubkey!power'. Got %v", pubKeyAndPower)
return nil, 0, fmt.Errorf("expected 'pubkey!power'. Got %v", pubKeyAndPower)
}
pubkeyS, powerS := pubKeyAndPower[0], pubKeyAndPower[1]
// decode the pubkey
pubkey, err := base64.StdEncoding.DecodeString(pubkeyS)
if err != nil {
return nil, 0, fmt.Errorf("Pubkey (%s) is invalid base64", pubkeyS)
return nil, 0, fmt.Errorf("pubkey (%s) is invalid base64", pubkeyS)
}
// decode the power
power, err := strconv.ParseInt(powerS, 10, 64)
if err != nil {
return nil, 0, fmt.Errorf("Power (%s) is not an int", powerS)
return nil, 0, fmt.Errorf("power (%s) is not an int", powerS)
}
if power < 0 {
return nil, 0, fmt.Errorf("Power can not be less than 0, got %d", power)
return nil, 0, fmt.Errorf("power can not be less than 0, got %d", power)
}
return pubkey, power, nil
@@ -464,7 +463,7 @@ func saveState(state State) {
// Hash returns the hash of the application state. This is computed
// as the size or number of transactions processed within the state. Note that this isn't
// a strong gaurantee of state machine replication because states could
// a strong guarantee of state machine replication because states could
// have different kv values but still have the same size.
func (s State) Hash() []byte {
appHash := make([]byte, 8)

5
abci/example/kvstore/kvstore_test.go
View File

@@ -38,6 +38,7 @@ func testKVStore(ctx context.Context, t *testing.T, app types.Application, tx []
require.Equal(t, uint32(0), checkTxResp.Code)
ppResp, err := app.PrepareProposal(ctx, &types.RequestPrepareProposal{Txs: [][]byte{tx}})
require.NoError(t, err)
require.Len(t, ppResp.Txs, 1)
req := &types.RequestFinalizeBlock{Height: 1, Txs: ppResp.Txs}
ar, err := app.FinalizeBlock(ctx, req)
@@ -343,7 +344,7 @@ func runClientTests(ctx context.Context, t *testing.T, client abcicli.Client) {
testKVStore(ctx, t, client, tx, testKey, testValue)
}
func TestTxGeneration(t *testing.T) {
func TestTxGeneration(t *testing.T) {
require.Len(t, NewRandomTx(20), 20)
require.Len(t, NewRandomTxs(10), 10)
}
}

2
consensus/common_test.go
View File

@@ -435,7 +435,7 @@ func newStateWithConfigAndBlockStore(
stateStore := sm.NewStore(stateDB, sm.StoreOptions{
DiscardFinalizeBlockResponses: false,
})
if err := stateStore.Save(state); err != nil { // for save height 1's validators info
panic(err)
}

2
consensus/mempool_test.go
View File

@@ -100,7 +100,7 @@ func TestMempoolProgressInHigherRound(t *testing.T) {
round = 0
ensureNewRound(newRoundCh, height, round) // first round at next height
deliverTxsRange(t, cs, 0, 1) // we deliver txs, but dont set a proposal so we get the next round
deliverTxsRange(t, cs, 0, 1) // we deliver txs, but dont set a proposal so we get the next round
ensureNewTimeout(timeoutCh, height, round, cs.config.TimeoutPropose.Nanoseconds())
round++ // moving to the next round

175
consensus/reactor_test.go
View File

@@ -6,7 +6,7 @@ import (
"os"
"path"
"runtime"
"runtime/pprof"
// "runtime/pprof"
"sync"
"testing"
"time"
@@ -247,7 +247,9 @@ func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) {
defer stopConsensusNet(log.TestingLogger(), reactors, eventBuses)
// send a tx
if err := assertMempool(css[3].txNotifier).CheckTx([]byte{1, 2, 3}, nil, mempl.TxInfo{}); err != nil {
if err := assertMempool(css[3].txNotifier).CheckTx(kvstore.NewTxFromID(1), func (resp *abci.ResponseCheckTx) {
require.False(t, resp.IsErr())
}, mempl.TxInfo{}); err != nil {
t.Error(err)
}
@@ -409,6 +411,7 @@ func TestReactorVotingPowerChange(t *testing.T) {
}
func TestReactorValidatorSetChanges(t *testing.T) {
t.Skip()
nPeers := 7
nVals := 4
css, _, _, cleanup := randConsensusNetWithPeers(
@@ -438,59 +441,54 @@ func TestReactorValidatorSetChanges(t *testing.T) {
<-blocksSubs[j].Out()
}, css)
//---------------------------------------------------------------------------
logger.Info("---------------------------- Testing adding one validator")
t.Run("Testing adding one validator", func (t *testing.T) {
newValidatorPubKey1, err := css[nVals].privValidator.GetPubKey()
assert.NoError(t, err)
valPubKey1ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey1)
assert.NoError(t, err)
newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower)
// wait till everyone makes block 2
// ensure the commit includes all validators
// send newValTx to change vals in block 3
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css, newValidatorTx1)
// wait till everyone makes block 3.
// it includes the commit for block 2, which is by the original validator set
waitForAndValidateBlockWithTx(t, nPeers, activeVals, blocksSubs, css, newValidatorTx1)
// wait till everyone makes block 4.
// it includes the commit for block 3, which is by the original validator set
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css)
// the commits for block 4 should be with the updated validator set
activeVals[string(newValidatorPubKey1.Address())] = struct{}{}
// wait till everyone makes block 5
// it includes the commit for block 4, which should have the updated validator set
waitForBlockWithUpdatedValsAndValidateIt(t, nPeers, activeVals, blocksSubs, css)
})
newValidatorPubKey1, err := css[nVals].privValidator.GetPubKey()
assert.NoError(t, err)
valPubKey1ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey1)
assert.NoError(t, err)
newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower)
// wait till everyone makes block 2
// ensure the commit includes all validators
// send newValTx to change vals in block 3
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css, newValidatorTx1)
// wait till everyone makes block 3.
// it includes the commit for block 2, which is by the original validator set
waitForAndValidateBlockWithTx(t, nPeers, activeVals, blocksSubs, css, newValidatorTx1)
// wait till everyone makes block 4.
// it includes the commit for block 3, which is by the original validator set
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css)
// the commits for block 4 should be with the updated validator set
activeVals[string(newValidatorPubKey1.Address())] = struct{}{}
// wait till everyone makes block 5
// it includes the commit for block 4, which should have the updated validator set
waitForBlockWithUpdatedValsAndValidateIt(t, nPeers, activeVals, blocksSubs, css)
//---------------------------------------------------------------------------
logger.Info("---------------------------- Testing changing the voting power of one validator")
updateValidatorPubKey1, err := css[nVals].privValidator.GetPubKey()
require.NoError(t, err)
updatePubKey1ABCI, err := cryptoenc.PubKeyToProto(updateValidatorPubKey1)
require.NoError(t, err)
updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25)
previousTotalVotingPower := css[nVals].GetRoundState().LastValidators.TotalVotingPower()
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css, updateValidatorTx1)
waitForAndValidateBlockWithTx(t, nPeers, activeVals, blocksSubs, css, updateValidatorTx1)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css)
waitForBlockWithUpdatedValsAndValidateIt(t, nPeers, activeVals, blocksSubs, css)
if css[nVals].GetRoundState().LastValidators.TotalVotingPower() == previousTotalVotingPower {
t.Errorf(
"expected voting power to change (before: %d, after: %d)",
previousTotalVotingPower,
css[nVals].GetRoundState().LastValidators.TotalVotingPower())
}
//---------------------------------------------------------------------------
logger.Info("---------------------------- Testing adding two validators at once")
t.Run("Testing changing the voting power of one validator", func(t *testing.T) {
updateValidatorPubKey1, err := css[nVals].privValidator.GetPubKey()
require.NoError(t, err)
updatePubKey1ABCI, err := cryptoenc.PubKeyToProto(updateValidatorPubKey1)
require.NoError(t, err)
updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25)
previousTotalVotingPower := css[nVals].GetRoundState().LastValidators.TotalVotingPower()
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css, updateValidatorTx1)
waitForAndValidateBlockWithTx(t, nPeers, activeVals, blocksSubs, css, updateValidatorTx1)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css)
waitForBlockWithUpdatedValsAndValidateIt(t, nPeers, activeVals, blocksSubs, css)
if css[nVals].GetRoundState().LastValidators.TotalVotingPower() == previousTotalVotingPower {
t.Errorf(
"expected voting power to change (before: %d, after: %d)",
previousTotalVotingPower,
css[nVals].GetRoundState().LastValidators.TotalVotingPower())
}
})
newValidatorPubKey2, err := css[nVals+1].privValidator.GetPubKey()
require.NoError(t, err)
@@ -504,25 +502,28 @@ func TestReactorValidatorSetChanges(t *testing.T) {
require.NoError(t, err)
newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css, newValidatorTx2, newValidatorTx3)
waitForAndValidateBlockWithTx(t, nPeers, activeVals, blocksSubs, css, newValidatorTx2, newValidatorTx3)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css)
activeVals[string(newValidatorPubKey2.Address())] = struct{}{}
activeVals[string(newValidatorPubKey3.Address())] = struct{}{}
waitForBlockWithUpdatedValsAndValidateIt(t, nPeers, activeVals, blocksSubs, css)
t.Run("Testing adding two validators at once", func (t *testing.T) {
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css, newValidatorTx2, newValidatorTx3)
waitForAndValidateBlockWithTx(t, nPeers, activeVals, blocksSubs, css, newValidatorTx2, newValidatorTx3)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css)
activeVals[string(newValidatorPubKey2.Address())] = struct{}{}
activeVals[string(newValidatorPubKey3.Address())] = struct{}{}
waitForBlockWithUpdatedValsAndValidateIt(t, nPeers, activeVals, blocksSubs, css)
})
//---------------------------------------------------------------------------
logger.Info("---------------------------- Testing removing two validators at once")
t.Run("Testing removing two validators at once", func(t *testing.T) {
removeValidatorTx2 := kvstore.MakeValSetChangeTx(newVal2ABCI, 0)
removeValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, 0)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css, removeValidatorTx2, removeValidatorTx3)
waitForAndValidateBlockWithTx(t, nPeers, activeVals, blocksSubs, css, removeValidatorTx2, removeValidatorTx3)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css)
delete(activeVals, string(newValidatorPubKey2.Address()))
delete(activeVals, string(newValidatorPubKey3.Address()))
waitForBlockWithUpdatedValsAndValidateIt(t, nPeers, activeVals, blocksSubs, css)
})
removeValidatorTx2 := kvstore.MakeValSetChangeTx(newVal2ABCI, 0)
removeValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, 0)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css, removeValidatorTx2, removeValidatorTx3)
waitForAndValidateBlockWithTx(t, nPeers, activeVals, blocksSubs, css, removeValidatorTx2, removeValidatorTx3)
waitForAndValidateBlock(t, nPeers, activeVals, blocksSubs, css)
delete(activeVals, string(newValidatorPubKey2.Address()))
delete(activeVals, string(newValidatorPubKey3.Address()))
waitForBlockWithUpdatedValsAndValidateIt(t, nPeers, activeVals, blocksSubs, css)
}
// Check we can make blocks with skip_timeout_commit=false
@@ -558,10 +559,14 @@ func waitForAndValidateBlock(
newBlock := msg.Data().(types.EventDataNewBlock).Block
css[j].Logger.Debug("waitForAndValidateBlock: Got block", "height", newBlock.Height)
err := validateBlock(newBlock, activeVals)
assert.Nil(t, err)
require.NoError(t, err)
// optionally add transactions for the next block
for _, tx := range txs {
err := assertMempool(css[j].txNotifier).CheckTx(tx, nil, mempl.TxInfo{})
assert.Nil(t, err)
err := assertMempool(css[j].txNotifier).CheckTx(tx, func (resp *abci.ResponseCheckTx) {
require.False(t, resp.IsErr())
}, mempl.TxInfo{})
require.NoError(t, err)
}
}, css)
}
@@ -583,7 +588,7 @@ func waitForAndValidateBlockWithTx(
newBlock := msg.Data().(types.EventDataNewBlock).Block
css[j].Logger.Debug("waitForAndValidateBlockWithTx: Got block", "height", newBlock.Height)
err := validateBlock(newBlock, activeVals)
assert.Nil(t, err)
require.NoError(t, err)
// check that txs match the txs we're waiting for.
// note they could be spread over multiple blocks,
@@ -622,8 +627,8 @@ func waitForBlockWithUpdatedValsAndValidateIt(
} else {
css[j].Logger.Debug(
"waitForBlockWithUpdatedValsAndValidateIt: Got block with no new validators. Skipping",
"height",
newBlock.Height)
"height", newBlock.Height, "last_commit", newBlock.LastCommit.Size(), "updated_vals", len(updatedVals),
)
}
}
@@ -650,12 +655,14 @@ func validateBlock(block *types.Block, activeVals map[string]struct{}) error {
}
func timeoutWaitGroup(t *testing.T, n int, f func(int), css []*State) {
counter := 0
wg := new(sync.WaitGroup)
wg.Add(n)
for i := 0; i < n; i++ {
go func(j int) {
f(j)
wg.Done()
counter++
}(i)
}
@@ -667,22 +674,12 @@ func timeoutWaitGroup(t *testing.T, n int, f func(int), css []*State) {
// we're running many nodes in-process, possibly in in a virtual machine,
// and spewing debug messages - making a block could take a while,
timeout := time.Second * 120
timeout := time.Second * 20
select {
case <-done:
case <-time.After(timeout):
for i, cs := range css {
t.Log("#################")
t.Log("Validator", i)
t.Log(cs.GetRoundState())
t.Log("")
}
os.Stdout.Write([]byte("pprof.Lookup('goroutine'):\n"))
err := pprof.Lookup("goroutine").WriteTo(os.Stdout, 1)
require.NoError(t, err)
capture()
panic("Timed out waiting for all validators to commit a block")
panic(fmt.Sprintf("Timed out waiting for all validators (got %d / %d) to commit a block", counter, n))
}
}

4
mempool/v0/cache_test.go
View File

@@ -37,7 +37,7 @@ func TestCacheAfterUpdate(t *testing.T) {
for tcIndex, tc := range tests {
for i := 0; i < tc.numTxsToCreate; i++ {
tx := kvstore.NewTx(fmt.Sprintf("%d", i), "value")
err := mp.CheckTx(tx, func (resp *abci.ResponseCheckTx) {
err := mp.CheckTx(tx, func(resp *abci.ResponseCheckTx) {
require.False(t, resp.IsErr())
}, mempool.TxInfo{})
require.NoError(t, err)
@@ -53,7 +53,7 @@ func TestCacheAfterUpdate(t *testing.T) {
for _, v := range tc.reAddIndices {
tx := kvstore.NewTx(fmt.Sprintf("%d", v), "value")
_ = mp.CheckTx(tx, func (resp *abci.ResponseCheckTx) {
_ = mp.CheckTx(tx, func(resp *abci.ResponseCheckTx) {
require.False(t, resp.IsErr())
}, mempool.TxInfo{})
}

16
mempool/v0/clist_mempool_test.go
View File

@@ -208,7 +208,7 @@ func TestMempoolUpdate(t *testing.T) {
// 1. Adds valid txs to the cache
{
tx1 := kvstore.NewTxFromId(1)
tx1 := kvstore.NewTxFromID(1)
err := mp.Update(1, []types.Tx{tx1}, abciResponses(1, abci.CodeTypeOK), nil, nil)
require.NoError(t, err)
err = mp.CheckTx(tx1, nil, mempool.TxInfo{})
@@ -219,7 +219,7 @@ func TestMempoolUpdate(t *testing.T) {
// 2. Removes valid txs from the mempool
{
tx2 := kvstore.NewTxFromId(2)
tx2 := kvstore.NewTxFromID(2)
err := mp.CheckTx(tx2, nil, mempool.TxInfo{})
require.NoError(t, err)
err = mp.Update(1, []types.Tx{tx2}, abciResponses(1, abci.CodeTypeOK), nil, nil)
@@ -229,7 +229,7 @@ func TestMempoolUpdate(t *testing.T) {
// 3. Removes invalid transactions from the cache and the mempool (if present)
{
tx3 := kvstore.NewTxFromId(3)
tx3 := kvstore.NewTxFromID(3)
err := mp.CheckTx(tx3, nil, mempool.TxInfo{})
require.NoError(t, err)
err = mp.Update(1, []types.Tx{tx3}, abciResponses(1, 1), nil, nil)
@@ -411,9 +411,9 @@ func TestSerialReap(t *testing.T) {
}
updateRange := func(start, end int) {
txs := make(types.Txs, end - start)
txs := make(types.Txs, end-start)
for i := start; i < end; i++ {
txs[i - start] = kvstore.NewTx(fmt.Sprintf("%d", i), "true")
txs[i-start] = kvstore.NewTx(fmt.Sprintf("%d", i), "true")
}
if err := mp.Update(0, txs, abciResponses(len(txs), abci.CodeTypeOK), nil, nil); err != nil {
t.Error(err)
@@ -422,9 +422,9 @@ func TestSerialReap(t *testing.T) {
commitRange := func(start, end int) {
// Deliver some txs in a block
txs := make([][]byte, end - start)
txs := make([][]byte, end-start)
for i := start; i < end; i++ {
txs[i - start] = kvstore.NewTx(fmt.Sprintf("%d", i), "true")
txs[i-start] = kvstore.NewTx(fmt.Sprintf("%d", i), "true")
}
res, err := appConnCon.FinalizeBlock(context.Background(), &abci.RequestFinalizeBlock{Txs: txs})
@@ -560,7 +560,7 @@ func TestMempoolTxsBytes(t *testing.T) {
mp.Flush()
assert.EqualValues(t, 0, mp.SizeBytes())
// 5. ErrMempoolIsFull is returned when/if MaxTxsBytes limit is reached.
tx3 := kvstore.NewRandomTx(100)
err = mp.CheckTx(tx3, nil, mempool.TxInfo{})

4
mempool/v0/reactor_test.go
View File

@@ -170,7 +170,7 @@ func TestReactor_MaxTxBytes(t *testing.T) {
// Broadcast a tx, which has the max size
// => ensure it's received by the second reactor.
tx1 := kvstore.NewRandomTx(config.Mempool.MaxTxBytes)
err := reactors[0].mempool.CheckTx(tx1, func (resp *abci.ResponseCheckTx) {
err := reactors[0].mempool.CheckTx(tx1, func(resp *abci.ResponseCheckTx) {
require.False(t, resp.IsErr())
}, mempool.TxInfo{SenderID: mempool.UnknownPeerID})
require.NoError(t, err)
@@ -182,7 +182,7 @@ func TestReactor_MaxTxBytes(t *testing.T) {
// Broadcast a tx, which is beyond the max size
// => ensure it's not sent
tx2 := kvstore.NewRandomTx(config.Mempool.MaxTxBytes + 1)
err = reactors[0].mempool.CheckTx(tx2, func (resp *abci.ResponseCheckTx) {
err = reactors[0].mempool.CheckTx(tx2, func(resp *abci.ResponseCheckTx) {
require.False(t, resp.IsErr())
}, mempool.TxInfo{SenderID: mempool.UnknownPeerID})
require.Error(t, err)

6
mempool/v1/mempool_test.go
View File

@@ -120,7 +120,7 @@ func checkTxs(t *testing.T, txmp *TxMempool, numTxs int, peerID uint16) []testTx
tx: []byte(fmt.Sprintf("sender-%d-%d=%d", i, peerID, priority)),
priority: priority,
}
require.NoError(t, txmp.CheckTx(txs[i].tx, func (resp *abci.ResponseCheckTx) {
require.NoError(t, txmp.CheckTx(txs[i].tx, func(resp *abci.ResponseCheckTx) {
require.False(t, resp.IsErr(), txs[i].tx)
}, txInfo))
}
@@ -405,13 +405,13 @@ func TestTxMempool_CheckTxExceedsMaxSize(t *testing.T) {
txmp := setup(t, 0)
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
tx := kvstore.NewRandomTx(txmp.config.MaxTxBytes+1)
tx := kvstore.NewRandomTx(txmp.config.MaxTxBytes + 1)
_, err := rng.Read(tx)
require.NoError(t, err)
require.Error(t, txmp.CheckTx(tx, nil, mempool.TxInfo{SenderID: 0}))
tx = kvstore.NewRandomTx(txmp.config.MaxTxBytes-1)
tx = kvstore.NewRandomTx(txmp.config.MaxTxBytes - 1)
_, err = rng.Read(tx)
require.NoError(t, err)

6
state/execution.go
View File

@@ -215,7 +215,7 @@ func (blockExec *BlockExecutor) ApplyBlock(
// validate the validator updates and convert to tendermint types
err = validateValidatorUpdates(abciResponse.ValidatorUpdates, state.ConsensusParams.Validator)
if err != nil {
return state, 0, fmt.Errorf("error in validator updates: %v", err)
return state, 0, fmt.Errorf("error in validator updates: %w", err)
}
validatorUpdates, err := types.PB2TM.ValidatorUpdates(abciResponse.ValidatorUpdates)
@@ -233,13 +233,13 @@ func (blockExec *BlockExecutor) ApplyBlock(
// Update the state with the block and responses.
state, err = updateState(state, blockID, &block.Header, abciResponse, validatorUpdates)
if err != nil {
return state, 0, fmt.Errorf("commit failed for application: %v", err)
return state, 0, fmt.Errorf("failed to update state: %w", err)
}
// Lock mempool, commit app state, update mempoool.
retainHeight, err := blockExec.Commit(state, block, abciResponse)
if err != nil {
return state, 0, fmt.Errorf("commit failed for application: %v", err)
return state, 0, fmt.Errorf("commit failed for application: %w", err)
}
// Update evpool with the latest state.