diff --git a/cmd/geth/main.go b/cmd/geth/main.go
index c4309f44b6efbe1890b750a153f014e06bd2b2eb..bc5cf06e8b43aef1ec5c9f969f5a0983883dd6b4 100644
--- a/cmd/geth/main.go
+++ b/cmd/geth/main.go
@@ -161,12 +161,6 @@ func init() {
// Start system runtime metrics collection
go metrics.CollectProcessMetrics(3 * time.Second)
- // This should be the only place where reporting is enabled
- // because it is not intended to run while testing.
- // In addition to this check, bad block reports are sent only
- // for chains with the main network genesis block and network id 1.
- eth.EnableBadBlockReporting = true
-
utils.SetupNetwork(ctx)
return nil
}
diff --git a/consensus/errors.go b/consensus/errors.go
new file mode 100644
index 0000000000000000000000000000000000000000..f94bcb329c25d982c255369d37c6adf03ebad778
--- /dev/null
+++ b/consensus/errors.go
@@ -0,0 +1,41 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package consensus
+
+import "errors"
+
+var (
+ // ErrUnknownAncestor is returned when validating a block requires an ancestor
+ // that is unknown.
+ ErrUnknownAncestor = errors.New("unknown ancestor")
+
+ // ErrLargeBlockTime is returned if the value of the timestamp is beyond
+ // any reasonable value.
+ ErrLargeBlockTime = errors.New("timestamp too big")
+
+ // ErrZeroBlockTime is returned if the block's timestamp is the same as the one
+ // its parent has.
+ ErrZeroBlockTime = errors.New("timestamp equals parent's")
+
+ // ErrFutureBlock is returned when a block's timestamp is in the future according
+ // to the current node.
+ ErrFutureBlock = errors.New("block in the future")
+
+ // ErrInvalidNumber is returned if a block's number doesn't equal it's parent's
+ // plus one.
+ ErrInvalidNumber = errors.New("invalid block number")
+)
diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go
index 603be3e53128c43e4f96c193df8f32a9f0cd3421..4a3a74a930af4410af2888f7593c6be7681c80a2 100644
--- a/consensus/ethash/consensus.go
+++ b/consensus/ethash/consensus.go
@@ -42,20 +42,15 @@ var (
)
var (
- ErrInvalidChain = errors.New("invalid header chain")
- ErrParentUnknown = errors.New("parent not known locally")
- ErrFutureBlock = errors.New("block in the future")
- ErrLargeBlockTimestamp = errors.New("timestamp too big")
- ErrZeroBlockTime = errors.New("timestamp equals parent's")
- ErrInvalidNumber = errors.New("invalid block number")
- ErrTooManyUncles = errors.New("too many uncles")
- ErrDuplicateUncle = errors.New("duplicate uncle")
- ErrUncleIsAncestor = errors.New("uncle is ancestor")
- ErrDanglingUncle = errors.New("uncle's parent is not ancestor")
- ErrNonceOutOfRange = errors.New("nonce out of range")
- ErrInvalidDifficulty = errors.New("non-positive difficulty")
- ErrInvalidMixDigest = errors.New("invalid mix digest")
- ErrInvalidPoW = errors.New("invalid proof-of-work")
+ ErrInvalidChain = errors.New("invalid header chain")
+ ErrTooManyUncles = errors.New("too many uncles")
+ ErrDuplicateUncle = errors.New("duplicate uncle")
+ ErrUncleIsAncestor = errors.New("uncle is ancestor")
+ ErrDanglingUncle = errors.New("uncle's parent is not ancestor")
+ ErrNonceOutOfRange = errors.New("nonce out of range")
+ ErrInvalidDifficulty = errors.New("non-positive difficulty")
+ ErrInvalidMixDigest = errors.New("invalid mix digest")
+ ErrInvalidPoW = errors.New("invalid proof-of-work")
)
// VerifyHeader checks whether a header conforms to the consensus rules of the
@@ -72,7 +67,7 @@ func (ethash *Ethash) VerifyHeader(chain consensus.ChainReader, header *types.He
}
parent := chain.GetHeader(header.ParentHash, number-1)
if parent == nil {
- return ErrParentUnknown
+ return consensus.ErrUnknownAncestor
}
// Sanity checks passed, do a proper verification
return ethash.verifyHeader(chain, header, parent, false, seal)
@@ -125,7 +120,7 @@ func (ethash *Ethash) VerifyHeaders(chain consensus.ChainReader, headers []*type
case chain.GetHeader(headers[index].Hash(), headers[index].Number.Uint64()-1) != nil:
outputs <- result{index: index, err: nil}
case parent == nil:
- failure = ErrParentUnknown
+ failure = consensus.ErrUnknownAncestor
outputs <- result{index: index, err: failure}
default:
failure = ethash.verifyHeader(chain, headers[index], parent, false, seals[index])
@@ -254,15 +249,15 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *
// Verify the header's timestamp
if uncle {
if header.Time.Cmp(math.MaxBig256) > 0 {
- return ErrLargeBlockTimestamp
+ return consensus.ErrLargeBlockTime
}
} else {
if header.Time.Cmp(big.NewInt(time.Now().Unix())) > 0 {
- return ErrFutureBlock
+ return consensus.ErrFutureBlock
}
}
if header.Time.Cmp(parent.Time) <= 0 {
- return ErrZeroBlockTime
+ return consensus.ErrZeroBlockTime
}
// Verify the block's difficulty based in it's timestamp and parent's difficulty
expected := CalcDifficulty(chain.Config(), header.Time.Uint64(), parent.Time.Uint64(), parent.Number, parent.Difficulty)
@@ -282,7 +277,7 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *
}
// Verify that the block number is parent's +1
if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 {
- return ErrInvalidNumber
+ return consensus.ErrInvalidNumber
}
// Verify the engine specific seal securing the block
if seal {
@@ -449,7 +444,7 @@ func (ethash *Ethash) VerifySeal(chain consensus.ChainReader, header *types.Head
func (ethash *Ethash) Prepare(chain consensus.ChainReader, header *types.Header) error {
parent := chain.GetHeader(header.ParentHash, header.Number.Uint64()-1)
if parent == nil {
- return ErrParentUnknown
+ return consensus.ErrUnknownAncestor
}
header.Difficulty = CalcDifficulty(chain.Config(), header.Time.Uint64(),
parent.Time.Uint64(), parent.Number, parent.Difficulty)
diff --git a/core/block_validator.go b/core/block_validator.go
index 00457dd7ab84c1c2232841eee311a02f2124cad3..4f85df0070b388b8174dd05fcbec8ccd9991bcb5 100644
--- a/core/block_validator.go
+++ b/core/block_validator.go
@@ -54,15 +54,15 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
// Check whether the block's known, and if not, that it's linkable
if v.bc.HasBlock(block.Hash()) {
if _, err := state.New(block.Root(), v.bc.chainDb); err == nil {
- return &KnownBlockError{block.Number(), block.Hash()}
+ return ErrKnownBlock
}
}
parent := v.bc.GetBlock(block.ParentHash(), block.NumberU64()-1)
if parent == nil {
- return ParentError(block.ParentHash())
+ return consensus.ErrUnknownAncestor
}
if _, err := state.New(parent.Root(), v.bc.chainDb); err != nil {
- return ParentError(block.ParentHash())
+ return consensus.ErrUnknownAncestor
}
// Header validity is known at this point, check the uncles and transactions
header := block.Header()
@@ -82,10 +82,10 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
// transition, such as amount of used gas, the receipt roots and the state root
// itself. ValidateState returns a database batch if the validation was a success
// otherwise nil and an error is returned.
-func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas *big.Int) (err error) {
+func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas *big.Int) error {
header := block.Header()
if block.GasUsed().Cmp(usedGas) != 0 {
- return ValidationError(fmt.Sprintf("invalid gas used (remote: %v local: %v)", block.GasUsed(), usedGas))
+ return fmt.Errorf("invalid gas used (remote: %v local: %v)", block.GasUsed(), usedGas)
}
// Validate the received block's bloom with the one derived from the generated receipts.
// For valid blocks this should always validate to true.
diff --git a/core/blockchain.go b/core/blockchain.go
index 4793431d8e791d86787d145565eaeb6f39130772..b601c462cea0ae0e5143c94e04204d3e19aaaaa2 100644
--- a/core/blockchain.go
+++ b/core/blockchain.go
@@ -831,7 +831,7 @@ func (self *BlockChain) WriteBlock(block *types.Block) (status WriteStatus, err
// Calculate the total difficulty of the block
ptd := self.GetTd(block.ParentHash(), block.NumberU64()-1)
if ptd == nil {
- return NonStatTy, ParentError(block.ParentHash())
+ return NonStatTy, consensus.ErrUnknownAncestor
}
// Make sure no inconsistent state is leaked during insertion
self.mu.Lock()
@@ -918,9 +918,8 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
}
// If the header is a banned one, straight out abort
if BadHashes[block.Hash()] {
- err := BadHashError(block.Hash())
- self.reportBlock(block, nil, err)
- return i, err
+ self.reportBlock(block, nil, ErrBlacklistedHash)
+ return i, ErrBlacklistedHash
}
// Wait for the block's verification to complete
bstart := time.Now()
@@ -930,25 +929,25 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) {
err = self.Validator().ValidateBody(block)
}
if err != nil {
- if IsKnownBlockErr(err) {
+ if err == ErrKnownBlock {
stats.ignored++
continue
}
- if err == BlockFutureErr {
+ if err == consensus.ErrFutureBlock {
// Allow up to MaxFuture second in the future blocks. If this limit
// is exceeded the chain is discarded and processed at a later time
// if given.
max := big.NewInt(time.Now().Unix() + maxTimeFutureBlocks)
- if block.Time().Cmp(max) == 1 {
- return i, fmt.Errorf("%v: BlockFutureErr, %v > %v", BlockFutureErr, block.Time(), max)
+ if block.Time().Cmp(max) > 0 {
+ return i, fmt.Errorf("future block: %v > %v", block.Time(), max)
}
self.futureBlocks.Add(block.Hash(), block)
stats.queued++
continue
}
- if IsParentErr(err) && self.futureBlocks.Contains(block.ParentHash()) {
+ if err == consensus.ErrUnknownAncestor && self.futureBlocks.Contains(block.ParentHash()) {
self.futureBlocks.Add(block.Hash(), block)
stats.queued++
continue
diff --git a/core/blockchain_test.go b/core/blockchain_test.go
index b2fb226dbbba9a433b31684d41ec5455ae0e4b0d..d65571cdeba4db940dfe0bb79abc286486d6608f 100644
--- a/core/blockchain_test.go
+++ b/core/blockchain_test.go
@@ -126,7 +126,7 @@ func testBlockChainImport(chain types.Blocks, blockchain *BlockChain) error {
err = blockchain.validator.ValidateBody(block)
}
if err != nil {
- if IsKnownBlockErr(err) {
+ if err == ErrKnownBlock {
continue
}
return err
@@ -441,8 +441,8 @@ func testBadHashes(t *testing.T, full bool) {
BadHashes[headers[2].Hash()] = true
_, err = bc.InsertHeaderChain(headers, 1)
}
- if !IsBadHashError(err) {
- t.Errorf("error mismatch: want: BadHashError, have: %v", err)
+ if err != ErrBlacklistedHash {
+ t.Errorf("error mismatch: have: %v, want: %v", err, ErrBlacklistedHash)
}
}
diff --git a/core/dao.go b/core/dao.go
index c43899e31580540b0da1ca8bc6c300166a9417a6..ff42a0e9d392d65f23ce799e97159aa477fc8555 100644
--- a/core/dao.go
+++ b/core/dao.go
@@ -18,6 +18,7 @@ package core
import (
"bytes"
+ "fmt"
"math/big"
"github.com/ethereum/go-ethereum/core/state"
@@ -46,11 +47,11 @@ func ValidateDAOHeaderExtraData(config *params.ChainConfig, header *types.Header
// Depending whether we support or oppose the fork, validate the extra-data contents
if config.DAOForkSupport {
if !bytes.Equal(header.Extra, params.DAOForkBlockExtra) {
- return ValidationError("DAO pro-fork bad block extra-data: 0x%x", header.Extra)
+ return fmt.Errorf("DAO pro-fork bad block extra-data: 0x%x", header.Extra)
}
} else {
if bytes.Equal(header.Extra, params.DAOForkBlockExtra) {
- return ValidationError("DAO no-fork bad block extra-data: 0x%x", header.Extra)
+ return fmt.Errorf("DAO no-fork bad block extra-data: 0x%x", header.Extra)
}
}
// All ok, header has the same extra-data we expect
diff --git a/core/error.go b/core/error.go
index 0ba506f468116fbed536b6f25ea3c2afa391c1a9..9ac4fff514312cc7710121a14a7714bcd1776867 100644
--- a/core/error.go
+++ b/core/error.go
@@ -16,188 +16,16 @@
package core
-import (
- "errors"
- "fmt"
- "math/big"
-
- "github.com/ethereum/go-ethereum/common"
-)
+import "errors"
var (
- BlockNumberErr = errors.New("block number invalid")
- BlockFutureErr = errors.New("block time is in the future")
- BlockTSTooBigErr = errors.New("block time too big")
- BlockEqualTSErr = errors.New("block time stamp equal to previous")
-)
-
-// Parent error. In case a parent is unknown this error will be thrown
-// by the block manager
-type ParentErr struct {
- Message string
-}
-
-func (err *ParentErr) Error() string {
- return err.Message
-}
-
-func ParentError(hash common.Hash) error {
- return &ParentErr{Message: fmt.Sprintf("Block's parent unknown %x", hash)}
-}
-
-func IsParentErr(err error) bool {
- _, ok := err.(*ParentErr)
- return ok
-}
-
-type UncleErr struct {
- Message string
-}
-
-func (err *UncleErr) Error() string {
- return err.Message
-}
-
-func UncleError(format string, v ...interface{}) error {
- return &UncleErr{Message: fmt.Sprintf(format, v...)}
-}
-
-func IsUncleErr(err error) bool {
- _, ok := err.(*UncleErr)
- return ok
-}
-
-// Block validation error. If any validation fails, this error will be thrown
-type ValidationErr struct {
- Message string
-}
-
-func (err *ValidationErr) Error() string {
- return err.Message
-}
-
-func ValidationError(format string, v ...interface{}) *ValidationErr {
- return &ValidationErr{Message: fmt.Sprintf(format, v...)}
-}
-
-func IsValidationErr(err error) bool {
- _, ok := err.(*ValidationErr)
- return ok
-}
-
-type NonceErr struct {
- Message string
- Is, Exp uint64
-}
-
-func (err *NonceErr) Error() string {
- return err.Message
-}
-
-func NonceError(is, exp uint64) *NonceErr {
- return &NonceErr{Message: fmt.Sprintf("Transaction w/ invalid nonce. tx=%d state=%d)", is, exp), Is: is, Exp: exp}
-}
-
-func IsNonceErr(err error) bool {
- _, ok := err.(*NonceErr)
- return ok
-}
+ // ErrKnownBlock is returned when a block to import is already known locally.
+ ErrKnownBlock = errors.New("block already known")
-// BlockNonceErr indicates that a block's nonce is invalid.
-type BlockNonceErr struct {
- Number *big.Int
- Hash common.Hash
- Nonce uint64
-}
+ // ErrGasLimitReached is returned by the gas pool if the amount of gas required
+ // by a transaction is higher than what's left in the block.
+ ErrGasLimitReached = errors.New("gas limit reached")
-func (err *BlockNonceErr) Error() string {
- return fmt.Sprintf("nonce for #%d [%x…] is invalid (got %d)", err.Number, err.Hash, err.Nonce)
-}
-
-// IsBlockNonceErr returns true for invalid block nonce errors.
-func IsBlockNonceErr(err error) bool {
- _, ok := err.(*BlockNonceErr)
- return ok
-}
-
-type InvalidTxErr struct {
- Message string
-}
-
-func (err *InvalidTxErr) Error() string {
- return err.Message
-}
-
-func InvalidTxError(err error) *InvalidTxErr {
- return &InvalidTxErr{fmt.Sprintf("%v", err)}
-}
-
-func IsInvalidTxErr(err error) bool {
- _, ok := err.(*InvalidTxErr)
- return ok
-}
-
-type TDError struct {
- a, b *big.Int
-}
-
-func (self *TDError) Error() string {
- return fmt.Sprintf("incoming chain has a lower or equal TD (%v <= %v)", self.a, self.b)
-}
-func IsTDError(e error) bool {
- _, ok := e.(*TDError)
- return ok
-}
-
-type KnownBlockError struct {
- number *big.Int
- hash common.Hash
-}
-
-func (self *KnownBlockError) Error() string {
- return fmt.Sprintf("block %v already known (%x)", self.number, self.hash[0:4])
-}
-func IsKnownBlockErr(e error) bool {
- _, ok := e.(*KnownBlockError)
- return ok
-}
-
-type ValueTransferError struct {
- message string
-}
-
-func ValueTransferErr(str string, v ...interface{}) *ValueTransferError {
- return &ValueTransferError{fmt.Sprintf(str, v...)}
-}
-
-func (self *ValueTransferError) Error() string {
- return self.message
-}
-func IsValueTransferErr(e error) bool {
- _, ok := e.(*ValueTransferError)
- return ok
-}
-
-type BadHashError common.Hash
-
-func (h BadHashError) Error() string {
- return fmt.Sprintf("Found known bad hash in chain %x", h[:])
-}
-
-func IsBadHashError(err error) bool {
- _, ok := err.(BadHashError)
- return ok
-}
-
-type GasLimitErr struct {
- Have, Want *big.Int
-}
-
-func IsGasLimitErr(err error) bool {
- _, ok := err.(*GasLimitErr)
- return ok
-}
-
-func (err *GasLimitErr) Error() string {
- return fmt.Sprintf("GasLimit reached. Have %d gas, transaction requires %d", err.Have, err.Want)
-}
+ // ErrBlacklistedHash is returned if a block to import is on the blacklist.
+ ErrBlacklistedHash = errors.New("blacklisted hash")
+)
diff --git a/core/gaspool.go b/core/gaspool.go
index f1c64c97aaf03b54fcdc39c6354e16e75e5ffbfe..ef99908cfe4479d4ac86f75658c45e1d0eae2238 100644
--- a/core/gaspool.go
+++ b/core/gaspool.go
@@ -35,7 +35,7 @@ func (gp *GasPool) AddGas(amount *big.Int) *GasPool {
func (gp *GasPool) SubGas(amount *big.Int) error {
i := (*big.Int)(gp)
if i.Cmp(amount) < 0 {
- return &GasLimitErr{Have: new(big.Int).Set(i), Want: amount}
+ return ErrGasLimitReached
}
i.Sub(i, amount)
return nil
diff --git a/core/headerchain.go b/core/headerchain.go
index e2d0ff5b171107447a945b31a02d77679c99eafa..f58afc6ca24dae71664d2b1a4936af89f0c7bb64 100644
--- a/core/headerchain.go
+++ b/core/headerchain.go
@@ -137,7 +137,7 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er
// Calculate the total difficulty of the header
ptd := hc.GetTd(header.ParentHash, number-1)
if ptd == nil {
- return NonStatTy, ParentError(header.ParentHash)
+ return NonStatTy, consensus.ErrUnknownAncestor
}
localTd := hc.GetTd(hc.currentHeaderHash, hc.currentHeader.Number.Uint64())
externTd := new(big.Int).Add(header.Difficulty, ptd)
@@ -246,7 +246,7 @@ func (hc *HeaderChain) ValidateHeaderChain(chain []*types.Header, checkFreq int)
}
// If the header is a banned one, straight out abort
if BadHashes[header.Hash()] {
- return i, BadHashError(header.Hash())
+ return i, ErrBlacklistedHash
}
// Otherwise wait for headers checks and ensure they pass
if err := <-results; err != nil {
diff --git a/core/state_transition.go b/core/state_transition.go
index fb75186470bccc6b99ea3b887ea8f407012ae2fa..9e11144c6c8a934855f66c88a8adb850e373db95 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -18,6 +18,7 @@ package core
import (
"errors"
+ "fmt"
"math/big"
"github.com/ethereum/go-ethereum/common"
@@ -195,26 +196,17 @@ func (self *StateTransition) buyGas() error {
return nil
}
-func (self *StateTransition) preCheck() (err error) {
+func (self *StateTransition) preCheck() error {
msg := self.msg
sender := self.from()
// Make sure this transaction's nonce is correct
if msg.CheckNonce() {
if n := self.state.GetNonce(sender.Address()); n != msg.Nonce() {
- return NonceError(msg.Nonce(), n)
+ return fmt.Errorf("invalid nonce: have %d, expected %d", msg.Nonce(), n)
}
}
-
- // Pre-pay gas
- if err = self.buyGas(); err != nil {
- if IsGasLimitErr(err) {
- return err
- }
- return InvalidTxError(err)
- }
-
- return nil
+ return self.buyGas()
}
// TransitionDb will transition the state by applying the current message and returning the result
@@ -233,11 +225,10 @@ func (self *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *b
// TODO convert to uint64
intrinsicGas := IntrinsicGas(self.data, contractCreation, homestead)
if intrinsicGas.BitLen() > 64 {
- return nil, nil, nil, InvalidTxError(vm.ErrOutOfGas)
+ return nil, nil, nil, vm.ErrOutOfGas
}
-
if err = self.useGas(intrinsicGas.Uint64()); err != nil {
- return nil, nil, nil, InvalidTxError(err)
+ return nil, nil, nil, err
}
var (
@@ -260,10 +251,9 @@ func (self *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *b
// sufficient balance to make the transfer happen. The first
// balance transfer may never fail.
if vmerr == vm.ErrInsufficientBalance {
- return nil, nil, nil, InvalidTxError(vmerr)
+ return nil, nil, nil, vmerr
}
}
-
requiredGas = new(big.Int).Set(self.gasUsed())
self.refundGas()
diff --git a/eth/bad_block.go b/eth/bad_block.go
deleted file mode 100644
index dd1ced8048e885b83f6ae45f5a097eebff03f7a3..0000000000000000000000000000000000000000
--- a/eth/bad_block.go
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package eth
-
-import (
- "bytes"
- "encoding/json"
- "fmt"
- "net/http"
- "time"
-
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/log"
- "github.com/ethereum/go-ethereum/rlp"
-)
-
-const (
- // The Ethereum main network genesis block.
- defaultGenesisHash = "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3"
- badBlocksURL = "https://badblocks.ethdev.com"
-)
-
-var EnableBadBlockReporting = false
-
-func sendBadBlockReport(block *types.Block, err error) {
- if !EnableBadBlockReporting {
- return
- }
-
- var (
- blockRLP, _ = rlp.EncodeToBytes(block)
- params = map[string]interface{}{
- "block": common.Bytes2Hex(blockRLP),
- "blockHash": block.Hash().Hex(),
- "errortype": err.Error(),
- "client": "go",
- }
- )
- if !block.ReceivedAt.IsZero() {
- params["receivedAt"] = block.ReceivedAt.UTC().String()
- }
- if p, ok := block.ReceivedFrom.(*peer); ok {
- params["receivedFrom"] = map[string]interface{}{
- "enode": fmt.Sprintf("enode://%x@%v", p.ID(), p.RemoteAddr()),
- "name": p.Name(),
- "protocolVersion": p.version,
- }
- }
- jsonStr, _ := json.Marshal(map[string]interface{}{"method": "eth_badBlock", "id": "1", "jsonrpc": "2.0", "params": []interface{}{params}})
- client := http.Client{Timeout: 8 * time.Second}
- resp, err := client.Post(badBlocksURL, "application/json", bytes.NewReader(jsonStr))
- if err != nil {
- log.Debug("Failed to report bad block", "err", err)
- return
- }
- log.Debug("Bad block report posted", "status", resp.StatusCode)
- resp.Body.Close()
-}
diff --git a/eth/fetcher/fetcher.go b/eth/fetcher/fetcher.go
index 64a9910696f00458fd2230944c5f959be77ea515..98cc1a76b639fe9ae53fb391f4f9dda586cd10b1 100644
--- a/eth/fetcher/fetcher.go
+++ b/eth/fetcher/fetcher.go
@@ -23,7 +23,7 @@ import (
"time"
"github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/log"
"gopkg.in/karalabe/cookiejar.v2/collections/prque"
@@ -654,7 +654,7 @@ func (f *Fetcher) insert(peer string, block *types.Block) {
propBroadcastOutTimer.UpdateSince(block.ReceivedAt)
go f.broadcastBlock(block, true)
- case core.BlockFutureErr:
+ case consensus.ErrFutureBlock:
// Weird future block, don't fail, but neither propagate
default:
diff --git a/eth/handler.go b/eth/handler.go
index 44527206031fd02140651cf7c6139e0a85c7e8f1..ef62a3d6516db29a8df2e0b37426aeda7eeae1fc 100644
--- a/eth/handler.go
+++ b/eth/handler.go
@@ -92,8 +92,6 @@ type ProtocolManager struct {
// wait group is used for graceful shutdowns during downloading
// and processing
wg sync.WaitGroup
-
- badBlockReportingEnabled bool
}
// NewProtocolManager returns a new ethereum sub protocol manager. The Ethereum sub protocol manages peers capable
@@ -163,7 +161,7 @@ func NewProtocolManager(config *params.ChainConfig, fastSync bool, networkId int
// Construct the different synchronisation mechanisms
manager.downloader = downloader.New(downloader.FullSync, chaindb, manager.eventMux, blockchain.HasHeader, blockchain.HasBlockAndState, blockchain.GetHeaderByHash,
blockchain.GetBlockByHash, blockchain.CurrentHeader, blockchain.CurrentBlock, blockchain.CurrentFastBlock, blockchain.FastSyncCommitHead,
- blockchain.GetTdByHash, blockchain.InsertHeaderChain, manager.insertChain, blockchain.InsertReceiptChain, blockchain.Rollback,
+ blockchain.GetTdByHash, blockchain.InsertHeaderChain, manager.blockchain.InsertChain, blockchain.InsertReceiptChain, blockchain.Rollback,
manager.removePeer)
validator := func(header *types.Header) error {
@@ -174,26 +172,13 @@ func NewProtocolManager(config *params.ChainConfig, fastSync bool, networkId int
}
inserter := func(blocks types.Blocks) (int, error) {
atomic.StoreUint32(&manager.synced, 1) // Mark initial sync done on any fetcher import
- return manager.insertChain(blocks)
+ return manager.blockchain.InsertChain(blocks)
}
manager.fetcher = fetcher.New(blockchain.GetBlockByHash, validator, manager.BroadcastBlock, heighter, inserter, manager.removePeer)
- if blockchain.Genesis().Hash().Hex() == defaultGenesisHash && networkId == 1 {
- log.Debug("Bad block reporting is enabled")
- manager.badBlockReportingEnabled = true
- }
-
return manager, nil
}
-func (pm *ProtocolManager) insertChain(blocks types.Blocks) (i int, err error) {
- i, err = pm.blockchain.InsertChain(blocks)
- if pm.badBlockReportingEnabled && core.IsValidationErr(err) && i < len(blocks) {
- go sendBadBlockReport(blocks[i], err)
- }
- return i, err
-}
-
func (pm *ProtocolManager) removePeer(id string) {
// Short circuit if the peer was already removed
peer := pm.peers.Peer(id)
diff --git a/les/fetcher.go b/les/fetcher.go
index 353e919323444dcea199cfdcfcbd4abf5f1155c2..a294d00d52926580fd132830e5b218c7c8c34057 100644
--- a/les/fetcher.go
+++ b/les/fetcher.go
@@ -24,6 +24,7 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/mclock"
+ "github.com/ethereum/go-ethereum/consensus"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/light"
@@ -498,7 +499,7 @@ func (f *lightFetcher) processResponse(req fetchRequest, resp fetchResponse) boo
headers[int(req.amount)-1-i] = header
}
if _, err := f.chain.InsertHeaderChain(headers, 1); err != nil {
- if err == core.BlockFutureErr {
+ if err == consensus.ErrFutureBlock {
return true
}
log.Debug("Failed to insert header chain", "err", err)
diff --git a/light/lightchain_test.go b/light/lightchain_test.go
index 41010cf577d15ade4e7eef293408f3b94a0bf187..21b6210462e5848cf85bbc18f5a4386e8f72fc6d 100644
--- a/light/lightchain_test.go
+++ b/light/lightchain_test.go
@@ -327,9 +327,8 @@ func TestBadHeaderHashes(t *testing.T) {
var err error
headers := makeHeaderChainWithDiff(bc.genesisBlock, []int{1, 2, 4}, 10)
core.BadHashes[headers[2].Hash()] = true
- _, err = bc.InsertHeaderChain(headers, 1)
- if !core.IsBadHashError(err) {
- t.Errorf("error mismatch: want: BadHashError, have: %v", err)
+ if _, err = bc.InsertHeaderChain(headers, 1); err != core.ErrBlacklistedHash {
+ t.Errorf("error mismatch: have: %v, want %v", err, core.ErrBlacklistedHash)
}
}
diff --git a/miner/worker.go b/miner/worker.go
index 347de4e08a04095883acaa4caa448201909efab7..8a67b12a6a90698bdd232e6afb0f73a09860dcec 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -279,21 +279,11 @@ func (self *worker) wait() {
go self.mux.Post(core.NewMinedBlockEvent{Block: block})
} else {
work.state.Commit(self.config.IsEIP158(block.Number()))
- parent := self.chain.GetBlock(block.ParentHash(), block.NumberU64()-1)
- if parent == nil {
- log.Error("Invalid block found during mining")
- continue
- }
- if err := self.engine.VerifyHeader(self.chain, block.Header(), false); err != nil {
- log.Error("Invalid header on mined block", "err", err)
- continue
- }
stat, err := self.chain.WriteBlock(block)
if err != nil {
log.Error("Failed writing block to chain", "err", err)
continue
}
-
// update block hash since it is now available and not when the receipt/log of individual transactions were created
for _, r := range work.receipts {
for _, l := range r.Logs {
@@ -513,13 +503,13 @@ func (self *worker) commitNewWork() {
func (self *worker) commitUncle(work *Work, uncle *types.Header) error {
hash := uncle.Hash()
if work.uncles.Has(hash) {
- return core.UncleError("uncle not unique")
+ return fmt.Errorf("uncle not unique")
}
if !work.ancestors.Has(uncle.ParentHash) {
- return core.UncleError(fmt.Sprintf("uncle's parent unknown (%x)", uncle.ParentHash[0:4]))
+ return fmt.Errorf("uncle's parent unknown (%x)", uncle.ParentHash[0:4])
}
if work.family.Has(hash) {
- return core.UncleError(fmt.Sprintf("uncle already in family (%x)", hash))
+ return fmt.Errorf("uncle already in family (%x)", hash)
}
work.uncles.Add(uncle.Hash())
return nil
@@ -564,23 +554,23 @@ func (env *Work) commitTransactions(mux *event.TypeMux, txs *types.TransactionsB
env.state.StartRecord(tx.Hash(), common.Hash{}, env.tcount)
err, logs := env.commitTransaction(tx, bc, gp)
- switch {
- case core.IsGasLimitErr(err):
+ switch err {
+ case core.ErrGasLimitReached:
// Pop the current out-of-gas transaction without shifting in the next from the account
log.Trace("Gas limit exceeded for current block", "sender", from)
txs.Pop()
- case err != nil:
- // Pop the current failed transaction without shifting in the next from the account
- log.Trace("Transaction failed, will be removed", "hash", tx.Hash(), "err", err)
- env.failedTxs = append(env.failedTxs, tx)
- txs.Pop()
-
- default:
+ case nil:
// Everything ok, collect the logs and shift in the next transaction from the same account
coalescedLogs = append(coalescedLogs, logs...)
env.tcount++
txs.Shift()
+
+ default:
+ // Pop the current failed transaction without shifting in the next from the account
+ log.Trace("Transaction failed, will be removed", "hash", tx.Hash(), "err", err)
+ env.failedTxs = append(env.failedTxs, tx)
+ txs.Pop()
}
}
diff --git a/tests/state_test_util.go b/tests/state_test_util.go
index 81f49efa5b79a9f43a720fcf12beb4961effa5ab..c1892cdccf1a8c2af5b690abaf44e1b1ee2ff495 100644
--- a/tests/state_test_util.go
+++ b/tests/state_test_util.go
@@ -214,7 +214,7 @@ func RunState(chainConfig *params.ChainConfig, statedb *state.StateDB, env, tx m
snapshot := statedb.Snapshot()
ret, gasUsed, err := core.ApplyMessage(environment, msg, gaspool)
- if core.IsNonceErr(err) || core.IsInvalidTxErr(err) || core.IsGasLimitErr(err) {
+ if err != nil {
statedb.RevertToSnapshot(snapshot)
}
statedb.Commit(chainConfig.IsEIP158(environment.Context.BlockNumber))