You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
178 lines
4.9 KiB
178 lines
4.9 KiB
package state
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
|
|
. "github.com/tendermint/go-common"
|
|
"github.com/tendermint/tendermint/proxy"
|
|
"github.com/tendermint/tendermint/types"
|
|
tmsp "github.com/tendermint/tmsp/types"
|
|
)
|
|
|
|
// Execute the block to mutate State.
|
|
// Also, execute txs on the proxyAppCtx and validate apphash
|
|
// Rolls back before executing transactions.
|
|
// Rolls back if invalid, but never commits.
|
|
func (s *State) ExecBlock(proxyAppCtx proxy.AppContext, block *types.Block, blockPartsHeader types.PartSetHeader) error {
|
|
|
|
// Validate the block.
|
|
err := s.validateBlock(block)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Update the validator set
|
|
valSet := s.Validators.Copy()
|
|
// Update valSet with signatures from block.
|
|
updateValidatorsWithBlock(s.LastValidators, valSet, block)
|
|
// TODO: Update the validator set (e.g. block.Data.ValidatorUpdates?)
|
|
nextValSet := valSet.Copy()
|
|
|
|
// First, rollback.
|
|
proxyAppCtx.RollbackSync()
|
|
|
|
// Execute, or rollback. (Does not commit)
|
|
err = s.execBlockOnProxyApp(proxyAppCtx, block)
|
|
if err != nil {
|
|
proxyAppCtx.RollbackSync()
|
|
return err
|
|
}
|
|
|
|
// All good!
|
|
nextValSet.IncrementAccum(1)
|
|
s.Validators = nextValSet
|
|
s.LastValidators = valSet
|
|
s.LastAppHash = block.AppHash
|
|
s.LastBlockHeight = block.Height
|
|
s.LastBlockHash = block.Hash()
|
|
s.LastBlockParts = blockPartsHeader
|
|
s.LastBlockTime = block.Time
|
|
|
|
return nil
|
|
}
|
|
|
|
// Commits block on proxyAppCtx.
|
|
func (s *State) Commit(proxyAppCtx proxy.AppContext) error {
|
|
err := proxyAppCtx.CommitSync()
|
|
return err
|
|
}
|
|
|
|
// Executes transactions on proxyAppCtx.
|
|
func (s *State) execBlockOnProxyApp(proxyAppCtx proxy.AppContext, block *types.Block) error {
|
|
// Execute transactions and get hash
|
|
var invalidTxErr error
|
|
proxyCb := func(req tmsp.Request, res tmsp.Response) {
|
|
switch res := res.(type) {
|
|
case tmsp.ResponseAppendTx:
|
|
reqAppendTx := req.(tmsp.RequestAppendTx)
|
|
if res.RetCode != tmsp.RetCodeOK {
|
|
if invalidTxErr == nil {
|
|
invalidTxErr = InvalidTxError{reqAppendTx.TxBytes, res.RetCode}
|
|
}
|
|
}
|
|
case tmsp.ResponseEvent:
|
|
s.evc.FireEvent(types.EventStringApp(), types.EventDataApp{res.Key, res.Data})
|
|
}
|
|
}
|
|
proxyAppCtx.SetResponseCallback(proxyCb)
|
|
for _, tx := range block.Data.Txs {
|
|
proxyAppCtx.AppendTxAsync(tx)
|
|
if err := proxyAppCtx.Error(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
hash, err := proxyAppCtx.GetHashSync()
|
|
if err != nil {
|
|
log.Warn("Error computing proxyAppCtx hash", "error", err)
|
|
return err
|
|
}
|
|
if invalidTxErr != nil {
|
|
log.Warn("Invalid transaction in block")
|
|
return invalidTxErr
|
|
}
|
|
|
|
// Check that appHash matches
|
|
if !bytes.Equal(block.AppHash, hash) {
|
|
log.Warn(Fmt("App hash in proposal was %X, computed %X instead", block.AppHash, hash))
|
|
return InvalidAppHashError{block.AppHash, hash}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *State) validateBlock(block *types.Block) error {
|
|
// Basic block validation.
|
|
err := block.ValidateBasic(s.ChainID, s.LastBlockHeight, s.LastBlockHash, s.LastBlockParts, s.LastBlockTime)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Validate block LastValidation.
|
|
if block.Height == 1 {
|
|
if len(block.LastValidation.Precommits) != 0 {
|
|
return errors.New("Block at height 1 (first block) should have no LastValidation precommits")
|
|
}
|
|
} else {
|
|
if len(block.LastValidation.Precommits) != s.LastValidators.Size() {
|
|
return fmt.Errorf("Invalid block validation size. Expected %v, got %v",
|
|
s.LastValidators.Size(), len(block.LastValidation.Precommits))
|
|
}
|
|
err := s.LastValidators.VerifyValidation(
|
|
s.ChainID, s.LastBlockHash, s.LastBlockParts, block.Height-1, block.LastValidation)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Updates the LastCommitHeight of the validators in valSet, in place.
|
|
// Assumes that lastValSet matches the valset of block.LastValidators
|
|
// CONTRACT: lastValSet is not mutated.
|
|
func updateValidatorsWithBlock(lastValSet *types.ValidatorSet, valSet *types.ValidatorSet, block *types.Block) {
|
|
|
|
for i, precommit := range block.LastValidation.Precommits {
|
|
if precommit == nil {
|
|
continue
|
|
}
|
|
_, val := lastValSet.GetByIndex(i)
|
|
if val == nil {
|
|
PanicCrisis(Fmt("Failed to fetch validator at index %v", i))
|
|
}
|
|
if _, val_ := valSet.GetByAddress(val.Address); val_ != nil {
|
|
val_.LastCommitHeight = block.Height - 1
|
|
updated := valSet.Update(val_)
|
|
if !updated {
|
|
PanicCrisis("Failed to update validator LastCommitHeight")
|
|
}
|
|
} else {
|
|
// XXX This is not an error if validator was removed.
|
|
// But, we don't mutate validators yet so go ahead and panic.
|
|
PanicCrisis("Could not find validator")
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
type InvalidTxError struct {
|
|
Tx types.Tx
|
|
tmsp.RetCode
|
|
}
|
|
|
|
func (txErr InvalidTxError) Error() string {
|
|
return Fmt("Invalid tx: [%v] code: [%v]", txErr.Tx, txErr.RetCode)
|
|
}
|
|
|
|
type InvalidAppHashError struct {
|
|
Expected []byte
|
|
Got []byte
|
|
}
|
|
|
|
func (hashErr InvalidAppHashError) Error() string {
|
|
return Fmt("Invalid hash: [%X] got: [%X]", hashErr.Expected, hashErr.Got)
|
|
}
|