Merge pull request #270 from getamis/feature/update_istanbul

consensus, core, eth, miner, params: update istanbul engine

Author: patrickmn

consensus/consensus.go

@@ -99,7 +99,7 @@ type Engine interface {
 // Handler should be implemented is the consensus needs to handle and send peer's message
 type Handler interface {
 	// NewChainHead handles a new head block comes
-	NewChainHead(block *types.Block) error
+	NewChainHead() error
 
 	// HandleMsg handles a message from peer
 	HandleMsg(address common.Address, data p2p.Msg) (bool, error)
@@ -121,7 +121,7 @@ type Istanbul interface {
 	Engine
 
 	// Start starts the engine
-	Start(chain ChainReader, inserter func(types.Blocks) (int, error)) error
+	Start(chain ChainReader, currentBlock func() *types.Block, hasBadBlock func(hash common.Hash) bool) error
 
 	// Stop stops the engine
 	Stop() error

consensus/istanbul/backend.go

@@ -17,6 +17,7 @@
 package istanbul
 
 import (
+	"math/big"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -57,4 +58,16 @@ type Backend interface {
 
 	// LastProposal retrieves latest committed proposal and the address of proposer
 	LastProposal() (Proposal, common.Address)
+
+	// HasPropsal checks if the combination of the given hash and height matches any existing blocks
+	HasPropsal(hash common.Hash, number *big.Int) bool
+
+	// GetProposer returns the proposer of the given block height
+	GetProposer(number uint64) common.Address
+
+	// ParentValidators returns the validator set of the given proposal's parent block
+	ParentValidators(proposal Proposal) ValidatorSet
+
+	// HasBadBlock returns whether the block with the hash is a bad block
+	HasBadProposal(hash common.Hash) bool
 }

consensus/istanbul/backend/backend.go

@@ -18,6 +18,7 @@ package backend
 
 import (
 	"crypto/ecdsa"
+	"math/big"
 	"sync"
 	"time"
 
@@ -35,6 +36,11 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 )
 
+const (
+	// fetcherID is the ID indicates the block is from Istanbul engine
+	fetcherID = "istanbul"
+)
+
 // New creates an Ethereum backend for Istanbul core engine.
 func New(config *istanbul.Config, privateKey *ecdsa.PrivateKey, db ethdb.Database) consensus.Istanbul {
 	// Allocate the snapshot caches and create the engine
@@ -70,14 +76,15 @@ type backend struct {
 	logger           log.Logger
 	db               ethdb.Database
 	chain            consensus.ChainReader
-	inserter         func(types.Blocks) (int, error)
+	currentBlock     func() *types.Block
+	hasBadBlock      func(hash common.Hash) bool
 
 	// the channels for istanbul engine notifications
 	commitCh          chan *types.Block
 	proposedBlockHash common.Hash
 	sealMu            sync.Mutex
 	coreStarted       bool
-	coreMu            sync.Mutex
+	coreMu            sync.RWMutex
 
 	// Current list of candidates we are pushing
 	candidates map[common.Address]bool
@@ -180,16 +187,11 @@ func (sb *backend) Commit(proposal istanbul.Proposal, seals [][]byte) error {
 	if sb.proposedBlockHash == block.Hash() {
 		// feed block hash to Seal() and wait the Seal() result
 		sb.commitCh <- block
-		// TODO: how do we check the block is inserted correctly?
 		return nil
 	}
-	// if I'm not a proposer, insert the block directly and broadcast NewCommittedEvent
-	if _, err := sb.inserter(types.Blocks{block}); err != nil && err != core.ErrKnownBlock {
-		return err
-	}
 
 	if sb.broadcaster != nil {
-		go sb.broadcaster.BroadcastBlock(block, false)
+		sb.broadcaster.Enqueue(fetcherID, block)
 	}
 	return nil
 }
@@ -208,6 +210,22 @@ func (sb *backend) Verify(proposal istanbul.Proposal) (time.Duration, error) {
 		sb.logger.Error("Invalid proposal, %v", proposal)
 		return 0, errInvalidProposal
 	}
+
+	// check bad block
+	if sb.HasBadProposal(block.Hash()) {
+		return 0, core.ErrBlacklistedHash
+	}
+
+	// check block body
+	txnHash := types.DeriveSha(block.Transactions())
+	uncleHash := types.CalcUncleHash(block.Uncles())
+	if txnHash != block.Header().TxHash {
+		return 0, errMismatchTxhashes
+	}
+	if uncleHash != nilUncleHash {
+		return 0, errInvalidUncleHash
+	}
+
 	// verify the header of proposed block
 	err := sb.VerifyHeader(sb.chain, block.Header(), false)
 	// ignore errEmptyCommittedSeals error because we don't have the committed seals yet
@@ -239,6 +257,11 @@ func (sb *backend) CheckSignature(data []byte, address common.Address, sig []byt
 	return nil
 }
 
+// HasPropsal implements istanbul.Backend.HashBlock
+func (sb *backend) HasPropsal(hash common.Hash, number *big.Int) bool {
+	return sb.chain.GetHeader(hash, number.Uint64()) != nil
+}
+
 // GetProposer implements istanbul.Backend.GetProposer
 func (sb *backend) GetProposer(number uint64) common.Address {
 	if h := sb.chain.GetHeaderByNumber(number); h != nil {
@@ -248,6 +271,14 @@ func (sb *backend) GetProposer(number uint64) common.Address {
 	return common.Address{}
 }
 
+// ParentValidators implements istanbul.Backend.GetParentValidators
+func (sb *backend) ParentValidators(proposal istanbul.Proposal) istanbul.ValidatorSet {
+	if block, ok := proposal.(*types.Block); ok {
+		return sb.getValidators(block.Number().Uint64()-1, block.ParentHash())
+	}
+	return validator.NewSet(nil, sb.config.ProposerPolicy)
+}
+
 func (sb *backend) getValidators(number uint64, hash common.Hash) istanbul.ValidatorSet {
 	snap, err := sb.snapshot(sb.chain, number, hash, nil)
 	if err != nil {
@@ -257,23 +288,25 @@ func (sb *backend) getValidators(number uint64, hash common.Hash) istanbul.Valid
 }
 
 func (sb *backend) LastProposal() (istanbul.Proposal, common.Address) {
-	if sb.chain == nil {
-		sb.logger.Error("Failed to access blockchain")
-		return nil, common.Address{}
-	}
-
-	h := sb.chain.CurrentHeader()
+	block := sb.currentBlock()
 
 	var proposer common.Address
-	if h.Number.Cmp(common.Big0) > 0 {
+	if block.Number().Cmp(common.Big0) > 0 {
 		var err error
-		proposer, err = sb.Author(h)
+		proposer, err = sb.Author(block.Header())
 		if err != nil {
 			sb.logger.Error("Failed to get block proposer", "err", err)
 			return nil, common.Address{}
 		}
 	}
 
 	// Return header only block here since we don't need block body
-	return types.NewBlockWithHeader(h), proposer
+	return block, proposer
+}
+
+func (sb *backend) HasBadProposal(hash common.Hash) bool {
+	if sb.hasBadBlock == nil {
+		return false
+	}
+	return sb.hasBadBlock(hash)
 }

consensus/istanbul/backend/backend_test.go

@@ -29,11 +29,10 @@ import (
 	"github.com/ethereum/go-ethereum/consensus/istanbul/validator"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/log"
 )
 
 func TestSign(t *testing.T) {
-	b, _, _ := newBackend()
+	b := newBackend()
 	data := []byte("Here is a string....")
 	sig, err := b.Sign(data)
 	if err != nil {
@@ -54,7 +53,7 @@ func TestCheckSignature(t *testing.T) {
 	data := []byte("Here is a string....")
 	hashData := crypto.Keccak256([]byte(data))
 	sig, _ := crypto.Sign(hashData, key)
-	b, _, _ := newBackend()
+	b := newBackend()
 	a := getAddress()
 	err := b.CheckSignature(data, a, sig)
 	if err != nil {
@@ -68,7 +67,7 @@ func TestCheckSignature(t *testing.T) {
 }
 
 func TestCheckValidatorSignature(t *testing.T) {
-	_, keys, vset := newBackend()
+	vset, keys := newTestValidatorSet(5)
 
 	// 1. Positive test: sign with validator's key should succeed
 	data := []byte("dummy data")
@@ -113,7 +112,7 @@ func TestCheckValidatorSignature(t *testing.T) {
 }
 
 func TestCommit(t *testing.T) {
-	backend, _, _ := newBackend()
+	backend := newBackend()
 
 	commitCh := make(chan *types.Block)
 	// Case: it's a proposer, so the backend.commit will receive channel result from backend.Commit function
@@ -235,13 +234,9 @@ func (slice Keys) Swap(i, j int) {
 	slice[i], slice[j] = slice[j], slice[i]
 }
 
-func newBackend() (b *backend, validatorKeys Keys, validatorSet istanbul.ValidatorSet) {
+func newBackend() (b *backend) {
+	_, b = newBlockChain(4)
 	key, _ := generatePrivateKey()
-	validatorSet, validatorKeys = newTestValidatorSet(5)
-	b = &backend{
-		privateKey: key,
-		logger:     log.New("backend", "simple"),
-		commitCh:   make(chan *types.Block, 1),
-	}
+	b.privateKey = key
 	return
 }

consensus/istanbul/backend/engine.go

@@ -80,6 +80,8 @@ var (
 	errInvalidCommittedSeals = errors.New("invalid committed seals")
 	// errEmptyCommittedSeals is returned if the field of committed seals is zero.
 	errEmptyCommittedSeals = errors.New("zero committed seals")
+	// errMismatchTxhashes is returned if the TxHash in header is mismatch.
+	errMismatchTxhashes = errors.New("mismatch transcations hashes")
 )
 var (
 	defaultDifficulty = big.NewInt(1)
@@ -477,7 +479,7 @@ func (sb *backend) APIs(chain consensus.ChainReader) []rpc.API {
 }
 
 // Start implements consensus.Istanbul.Start
-func (sb *backend) Start(chain consensus.ChainReader, inserter func(types.Blocks) (int, error)) error {
+func (sb *backend) Start(chain consensus.ChainReader, currentBlock func() *types.Block, hasBadBlock func(hash common.Hash) bool) error {
 	sb.coreMu.Lock()
 	defer sb.coreMu.Unlock()
 	if sb.coreStarted {
@@ -492,23 +494,10 @@ func (sb *backend) Start(chain consensus.ChainReader, inserter func(types.Blocks
 	sb.commitCh = make(chan *types.Block, 1)
 
 	sb.chain = chain
-	sb.inserter = inserter
-
-	curHeader := chain.CurrentHeader()
-	lastSequence := new(big.Int).Set(curHeader.Number)
-	lastProposer := common.Address{}
-	// should get proposer if the block is not genesis
-	if lastSequence.Cmp(common.Big0) > 0 {
-		p, err := sb.Author(curHeader)
-		if err != nil {
-			return err
-		}
-		lastProposer = p
-	}
-	// We don't need block body so we create a header only block.
-	// The proposal is only for validator set calculation.
-	lastProposal := types.NewBlockWithHeader(curHeader)
-	if err := sb.core.Start(lastSequence, lastProposer, lastProposal); err != nil {
+	sb.currentBlock = currentBlock
+	sb.hasBadBlock = hasBadBlock
+
+	if err := sb.core.Start(); err != nil {
 		return err
 	}
 

consensus/istanbul/backend/engine_test.go

@@ -51,7 +51,7 @@ func newBlockChain(n int) (*core.BlockChain, *backend) {
 	if err != nil {
 		panic(err)
 	}
-	b.Start(blockchain, blockchain.InsertChain)
+	b.Start(blockchain, blockchain.CurrentBlock, blockchain.HasBadBlock)
 	snap, err := b.snapshot(blockchain, 0, common.Hash{}, nil)
 	if err != nil {
 		panic(err)
@@ -138,7 +138,7 @@ func makeBlock(chain *core.BlockChain, engine *backend, parent *types.Block) *ty
 func makeBlockWithoutSeal(chain *core.BlockChain, engine *backend, parent *types.Block) *types.Block {
 	header := makeHeader(parent, engine.config)
 	engine.Prepare(chain, header)
-	state, _, _ := chain.StateAt(parent.Root())
+	state, _,_ := chain.StateAt(parent.Root())
 	block, _ := engine.Finalize(chain, header, state, nil, nil, nil)
 	return block
 }

consensus/istanbul/backend/handler.go

@@ -22,7 +22,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/istanbul"
-	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/p2p"
 	lru "github.com/hashicorp/golang-lru"
 )
@@ -93,20 +92,12 @@ func (sb *backend) SetBroadcaster(broadcaster consensus.Broadcaster) {
 	sb.broadcaster = broadcaster
 }
 
-func (sb *backend) NewChainHead(block *types.Block) error {
-	sb.coreMu.Lock()
-	defer sb.coreMu.Unlock()
+func (sb *backend) NewChainHead() error {
+	sb.coreMu.RLock()
+	defer sb.coreMu.RUnlock()
 	if !sb.coreStarted {
 		return istanbul.ErrStoppedEngine
 	}
-	p, err := sb.Author(block.Header())
-	if err != nil {
-		sb.logger.Error("Failed to get block proposer", "err", err)
-		return err
-	}
-	go sb.istanbulEventMux.Post(istanbul.FinalCommittedEvent{
-		Proposal: block,
-		Proposer: p,
-	})
+	go sb.istanbulEventMux.Post(istanbul.FinalCommittedEvent{})
 	return nil
 }