headrush
/
go-ethereum
forked from mirror/go-ethereum
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cmd, core, miner: add extradata validation to consensus rules

Browse Source
release/1.5
Péter Szilágyi 8 years ago
parent 1e24c2e4f4
commit a87089fd2d
7 changed files with 275 additions and 216 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 294
      cmd/geth/dao_test.go
  2. 3
      cmd/geth/genesis_test.go
  3. 49
      cmd/utils/flags.go
  4. 21
      core/block_validator.go
  5. 105
      core/block_validator_test.go
  6. 5
      core/config.go
  7. 8
      miner/worker.go

294
cmd/geth/dao_test.go
Unescape View File

@ -29,7 +29,8 @@ import (
"github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/params"
) )
var daoNoForkGenesis = `{ // Genesis block for nodes which don't care about the DAO fork (i.e. not configured)
var daoOldGenesis = `{
"alloc" : {}, "alloc" : {},
"coinbase" : "0x0000000000000000000000000000000000000000", "coinbase" : "0x0000000000000000000000000000000000000000",
"difficulty" : "0x20000", "difficulty" : "0x20000",
@ -38,214 +39,140 @@ var daoNoForkGenesis = `{
"nonce" : "0x0000000000000042", "nonce" : "0x0000000000000042",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000", "mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000", "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00" "timestamp" : "0x00",
"config" : {}
}` }`
var daoNoForkGenesisHash = common.HexToHash("5e1fc79cb4ffa4739177b5408045cd5d51c6cf766133f23f7cd72ee1f8d790e0")
var daoProForkGenesis = `{ // Genesis block for nodes which actively oppose the DAO fork
var daoNoForkGenesis = `{
"alloc" : {}, "alloc" : {},
"coinbase" : "0x0000000000000000000000000000000000000000", "coinbase" : "0x0000000000000000000000000000000000000000",
"difficulty" : "0x20000", "difficulty" : "0x20000",
"extraData" : "", "extraData" : "",
"gasLimit" : "0x2fefd8", "gasLimit" : "0x2fefd8",
"nonce" : "0x0000000000000043", "nonce" : "0x0000000000000042",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000", "mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000", "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00", "timestamp" : "0x00",
"config" : { "config" : {
"daoForkBlock": 314 "daoForkBlock" : 314,
"daoForkSupport" : false
} }
}` }`
var daoProForkGenesisHash = common.HexToHash("c80f3c1c3d81ae6d8ea59edf35d3e4b723e4c8684ec71fdb6d4715e3f8add237")
var daoProForkBlock = big.NewInt(314)
// Tests that creating a new node to with or without the DAO fork flag will correctly // Genesis block for nodes which actively support the DAO fork
// set the genesis block but with DAO support explicitly set or unset in the chain var daoProForkGenesis = `{
// config in the database. "alloc" : {},
func TestDAOSupportMainnet(t *testing.T) { "coinbase" : "0x0000000000000000000000000000000000000000",
testDAOForkBlockNewChain(t, false, "", true, params.MainNetDAOForkBlock) "difficulty" : "0x20000",
} "extraData" : "",
func TestDAOSupportTestnet(t *testing.T) { "gasLimit" : "0x2fefd8",
testDAOForkBlockNewChain(t, true, "", true, params.TestNetDAOForkBlock) "nonce" : "0x0000000000000042",
} "mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
func TestDAOSupportPrivnet(t *testing.T) { "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
testDAOForkBlockNewChain(t, false, daoProForkGenesis, false, daoProForkBlock) "timestamp" : "0x00",
} "config" : {
func TestDAONoSupportMainnet(t *testing.T) { "daoForkBlock" : 314,
testDAOForkBlockNewChain(t, false, "", false, nil) "daoForkSupport" : true
}
func TestDAONoSupportTestnet(t *testing.T) {
testDAOForkBlockNewChain(t, true, "", false, nil)
}
func TestDAONoSupportPrivnet(t *testing.T) {
testDAOForkBlockNewChain(t, false, daoNoForkGenesis, false, nil)
}
func testDAOForkBlockNewChain(t *testing.T, testnet bool, genesis string, fork bool, expect *big.Int) {
// Create a temporary data directory to use and inspect later
datadir := tmpdir(t)
defer os.RemoveAll(datadir)
// Start a Geth instance with the requested flags set and immediately terminate
if genesis != "" {
json := filepath.Join(datadir, "genesis.json")
if err := ioutil.WriteFile(json, []byte(genesis), 0600); err != nil {
t.Fatalf("failed to write genesis file: %v", err)
}
runGeth(t, "--datadir", datadir, "init", json).cmd.Wait()
}
execDAOGeth(t, datadir, testnet, fork, false)
// Retrieve the DAO config flag from the database
path := filepath.Join(datadir, "chaindata")
if testnet {
path = filepath.Join(datadir, "testnet", "chaindata")
}
db, err := ethdb.NewLDBDatabase(path, 0, 0)
if err != nil {
t.Fatalf("failed to open test database: %v", err)
} }
defer db.Close() }`
genesisHash := common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3") var daoGenesisHash = common.HexToHash("5e1fc79cb4ffa4739177b5408045cd5d51c6cf766133f23f7cd72ee1f8d790e0")
if testnet { var daoGenesisForkBlock = big.NewInt(314)
genesisHash = common.HexToHash("0x0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303")
} else if genesis == daoNoForkGenesis {
genesisHash = daoNoForkGenesisHash
} else if genesis == daoProForkGenesis {
genesisHash = daoProForkGenesisHash
}
config, err := core.GetChainConfig(db, genesisHash)
if err != nil {
t.Fatalf("failed to retrieve chain config: %v", err)
}
// Validate the DAO hard-fork block number against the expected value
if config.DAOForkBlock == nil {
if expect != nil {
t.Fatalf("dao hard-fork block mismatch: have nil, want %v", expect)
}
} else if config.DAOForkBlock.Cmp(expect) != 0 {
t.Fatalf("dao hard-fork block mismatch: have %v, want %v", config.DAOForkBlock, expect)
}
}
// Tests that starting up an already existing node with various DAO fork override // Tests that the DAO hard-fork number and the nodes support/opposition is correctly
// flags correctly changes the chain configs in the database. // set in the database after various initialization procedures and invocations.
func TestDAODefaultMainnet(t *testing.T) { func TestDAODefaultMainnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, "", false, false, false, false, nil) testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, false}}, params.MainNetDAOForkBlock, false)
}
func TestDAOStartSupportMainnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, "", false, true, false, false, params.MainNetDAOForkBlock)
} }
func TestDAOContinueExplicitSupportMainnet(t *testing.T) { func TestDAOSupportMainnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, "", true, true, false, false, params.MainNetDAOForkBlock) testDAOForkBlockNewChain(t, false, "", [][2]bool{{true, false}}, params.MainNetDAOForkBlock, true)
}
func TestDAOContinueImplicitSupportMainnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, "", true, false, false, false, params.MainNetDAOForkBlock)
}
func TestDAOSwitchSupportMainnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, "", false, true, true, false, params.MainNetDAOForkBlock)
}
func TestDAOStartOpposeMainnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, "", false, false, false, true, nil)
} }
func TestDAOContinueExplicitOpposeMainnet(t *testing.T) { func TestDAOOpposeMainnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, "", false, false, true, true, nil) testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, true}}, params.MainNetDAOForkBlock, false)
} }
func TestDAOContinueImplicitOpposeMainnet(t *testing.T) { func TestDAOSwitchToSupportMainnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, "", false, false, true, false, nil) testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, true}, {true, false}}, params.MainNetDAOForkBlock, true)
} }
func TestDAOSwitchOpposeMainnet(t *testing.T) { func TestDAOSwitchToOpposeMainnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, "", true, false, false, true, nil) testDAOForkBlockNewChain(t, false, "", [][2]bool{{true, false}, {false, true}}, params.MainNetDAOForkBlock, false)
} }
func TestDAODefaultTestnet(t *testing.T) { func TestDAODefaultTestnet(t *testing.T) {
testDAOForkBlockOldChain(t, true, "", false, false, false, false, nil) testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, false}}, params.TestNetDAOForkBlock, false)
}
func TestDAOStartSupportTestnet(t *testing.T) {
testDAOForkBlockOldChain(t, true, "", false, true, false, false, params.TestNetDAOForkBlock)
}
func TestDAOContinueExplicitSupportTestnet(t *testing.T) {
testDAOForkBlockOldChain(t, true, "", true, true, false, false, params.TestNetDAOForkBlock)
} }
func TestDAOContinueImplicitSupportTestnet(t *testing.T) { func TestDAOSupportTestnet(t *testing.T) {
testDAOForkBlockOldChain(t, true, "", true, false, false, false, params.TestNetDAOForkBlock) testDAOForkBlockNewChain(t, true, "", [][2]bool{{true, false}}, params.TestNetDAOForkBlock, true)
}
func TestDAOSwitchSupportTestnet(t *testing.T) {
testDAOForkBlockOldChain(t, true, "", false, true, true, false, params.TestNetDAOForkBlock)
}
func TestDAOStartOpposeTestnet(t *testing.T) {
testDAOForkBlockOldChain(t, true, "", false, false, false, true, nil)
} }
func TestDAOContinueExplicitOpposeTestnet(t *testing.T) { func TestDAOOpposeTestnet(t *testing.T) {
testDAOForkBlockOldChain(t, true, "", false, false, true, true, nil) testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, true}}, params.TestNetDAOForkBlock, false)
} }
func TestDAOContinueImplicitOpposeTestnet(t *testing.T) { func TestDAOSwitchToSupportTestnet(t *testing.T) {
testDAOForkBlockOldChain(t, true, "", false, false, true, false, nil) testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, true}, {true, false}}, params.TestNetDAOForkBlock, true)
} }
func TestDAOSwitchOpposeTestnet(t *testing.T) { func TestDAOSwitchToOpposeTestnet(t *testing.T) {
testDAOForkBlockOldChain(t, true, "", true, false, false, true, nil) testDAOForkBlockNewChain(t, true, "", [][2]bool{{true, false}, {false, true}}, params.TestNetDAOForkBlock, false)
} }
func TestDAODefaultPrivnet(t *testing.T) { func TestDAOInitOldPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, false, false, nil) testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{}, nil, false)
} }
func TestDAOStartSupportConPrivnet(t *testing.T) { func TestDAODefaultOldPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, true, false, false, params.MainNetDAOForkBlock) testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, false}}, params.MainNetDAOForkBlock, false)
} }
func TestDAOContinueExplicitSupportConPrivnet(t *testing.T) { func TestDAOSupportOldPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoNoForkGenesis, true, true, false, false, params.MainNetDAOForkBlock) testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{true, false}}, params.MainNetDAOForkBlock, true)
} }
func TestDAOContinueImplicitSupportConPrivnet(t *testing.T) { func TestDAOOpposeOldPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoNoForkGenesis, true, false, false, false, params.MainNetDAOForkBlock) testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, true}}, params.MainNetDAOForkBlock, false)
} }
func TestDAOSwitchSupportConPrivnet(t *testing.T) { func TestDAOSwitchToSupportOldPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, true, true, false, params.MainNetDAOForkBlock) testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, true}, {true, false}}, params.MainNetDAOForkBlock, true)
} }
func TestDAOStartOpposeConPrivnet(t *testing.T) { func TestDAOSwitchToOpposeOldPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, false, true, nil) testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{true, false}, {false, true}}, params.MainNetDAOForkBlock, false)
} }
func TestDAOContinueExplicitOpposeConPrivnet(t *testing.T) { func TestDAOInitNoForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, true, true, nil) testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{}, daoGenesisForkBlock, false)
} }
func TestDAOContinueImplicitOpposeConPrivnet(t *testing.T) { func TestDAODefaultNoForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, true, false, nil) testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, false)
} }
func TestDAOSwitchOpposeConPrivnet(t *testing.T) { func TestDAOSupportNoForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoNoForkGenesis, true, false, false, true, nil) testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true)
} }
func TestDAODefaultProPrivnet(t *testing.T) { func TestDAOOpposeNoForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, false, false, daoProForkBlock) testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false)
} }
func TestDAOStartSupportProPrivnet(t *testing.T) { func TestDAOSwitchToSupportNoForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, true, false, false, daoProForkBlock) testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true)
} }
func TestDAOContinueExplicitSupportProPrivnet(t *testing.T) { func TestDAOSwitchToOpposeNoForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoProForkGenesis, true, true, false, false, daoProForkBlock) testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{true, false}, {false, true}}, daoGenesisForkBlock, false)
} }
func TestDAOContinueImplicitSupportProPrivnet(t *testing.T) { func TestDAOInitProForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoProForkGenesis, true, false, false, false, daoProForkBlock) testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{}, daoGenesisForkBlock, true)
} }
func TestDAOSwitchSupportProPrivnet(t *testing.T) { func TestDAODefaultProForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, true, true, false, params.MainNetDAOForkBlock) testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, true)
} }
func TestDAOStartOpposeProPrivnet(t *testing.T) { func TestDAOSupportProForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, false, true, nil) testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true)
} }
func TestDAOContinueExplicitOpposeProPrivnet(t *testing.T) { func TestDAOOpposeProForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, true, true, nil) testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false)
} }
func TestDAOContinueImplicitOpposeProPrivnet(t *testing.T) { func TestDAOSwitchToSupportProForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, true, false, nil) testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true)
} }
func TestDAOSwitchOpposeProPrivnet(t *testing.T) { func TestDAOSwitchToOpposeProForkPrivnet(t *testing.T) {
testDAOForkBlockOldChain(t, false, daoProForkGenesis, true, false, false, true, nil) testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{true, false}, {false, true}}, daoGenesisForkBlock, false)
} }
func testDAOForkBlockOldChain(t *testing.T, testnet bool, genesis string, oldSupport, newSupport, oldOppose, newOppose bool, expect *big.Int) { func testDAOForkBlockNewChain(t *testing.T, testnet bool, genesis string, votes [][2]bool, expectBlock *big.Int, expectVote bool) {
// Create a temporary data directory to use and inspect later // Create a temporary data directory to use and inspect later
datadir := tmpdir(t) datadir := tmpdir(t)
defer os.RemoveAll(datadir) defer os.RemoveAll(datadir)
// Cycle two Geth instances, possibly changing fork support in between // Start a Geth instance with the requested flags set and immediately terminate
if genesis != "" { if genesis != "" {
json := filepath.Join(datadir, "genesis.json") json := filepath.Join(datadir, "genesis.json")
if err := ioutil.WriteFile(json, []byte(genesis), 0600); err != nil { if err := ioutil.WriteFile(json, []byte(genesis), 0600); err != nil {
@ -253,12 +180,23 @@ func testDAOForkBlockOldChain(t *testing.T, testnet bool, genesis string, oldSup
} }
runGeth(t, "--datadir", datadir, "init", json).cmd.Wait() runGeth(t, "--datadir", datadir, "init", json).cmd.Wait()
} }
execDAOGeth(t, datadir, testnet, oldSupport, oldOppose) for _, vote := range votes {
execDAOGeth(t, datadir, testnet, newSupport, newOppose) args := []string{"--port", "0", "--maxpeers", "0", "--nodiscover", "--nat", "none", "--ipcdisable", "--datadir", datadir}
if testnet {
args = append(args, "--testnet")
}
if vote[0] {
args = append(args, "--support-dao-fork")
}
if vote[1] {
args = append(args, "--oppose-dao-fork")
}
geth := runGeth(t, append(args, []string{"--exec", "2+2", "console"}...)...)
geth.cmd.Wait()
}
// Retrieve the DAO config flag from the database // Retrieve the DAO config flag from the database
path := filepath.Join(datadir, "chaindata") path := filepath.Join(datadir, "chaindata")
if testnet { if testnet && genesis == "" {
path = filepath.Join(datadir, "testnet", "chaindata") path = filepath.Join(datadir, "testnet", "chaindata")
} }
db, err := ethdb.NewLDBDatabase(path, 0, 0) db, err := ethdb.NewLDBDatabase(path, 0, 0)
@ -270,10 +208,9 @@ func testDAOForkBlockOldChain(t *testing.T, testnet bool, genesis string, oldSup
genesisHash := common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3") genesisHash := common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")
if testnet { if testnet {
genesisHash = common.HexToHash("0x0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303") genesisHash = common.HexToHash("0x0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303")
} else if genesis == daoNoForkGenesis { }
genesisHash = daoNoForkGenesisHash if genesis != "" {
} else if genesis == daoProForkGenesis { genesisHash = daoGenesisHash
genesisHash = daoProForkGenesisHash
} }
config, err := core.GetChainConfig(db, genesisHash) config, err := core.GetChainConfig(db, genesisHash)
if err != nil { if err != nil {
@ -281,26 +218,15 @@ func testDAOForkBlockOldChain(t *testing.T, testnet bool, genesis string, oldSup
} }
// Validate the DAO hard-fork block number against the expected value // Validate the DAO hard-fork block number against the expected value
if config.DAOForkBlock == nil { if config.DAOForkBlock == nil {
if expect != nil { if expectBlock != nil {
t.Fatalf("dao hard-fork block mismatch: have nil, want %v", expect) t.Errorf("dao hard-fork block mismatch: have nil, want %v", expectBlock)
}
} else if config.DAOForkBlock.Cmp(expect) != 0 {
t.Fatalf("dao hard-fork block mismatch: have %v, want %v", config.DAOForkBlock, expect)
}
}
// execDAOGeth starts a Geth instance with some DAO forks set and terminates.
func execDAOGeth(t *testing.T, datadir string, testnet bool, supportFork bool, opposeFork bool) {
args := []string{"--port", "0", "--maxpeers", "0", "--nodiscover", "--nat", "none", "--ipcdisable", "--datadir", datadir}
if testnet {
args = append(args, "--testnet")
} }
if supportFork { } else if expectBlock == nil {
args = append(args, "--support-dao-fork") t.Errorf("dao hard-fork block mismatch: have %v, want nil", config.DAOForkBlock)
} else if config.DAOForkBlock.Cmp(expectBlock) != 0 {
t.Errorf("dao hard-fork block mismatch: have %v, want %v", config.DAOForkBlock, expectBlock)
} }
if opposeFork { if config.DAOForkSupport != expectVote {
args = append(args, "--oppose-dao-fork") t.Errorf("dao hard-fork support mismatch: have %v, want %v", config.DAOForkSupport, expectVote)
} }
geth := runGeth(t, append(args, []string{"--exec", "2+2", "console"}...)...)
geth.cmd.Wait()
} }

3
cmd/geth/genesis_test.go
Unescape View File

@ -75,7 +75,8 @@ var customGenesisTests = []struct {
"timestamp" : "0x00", "timestamp" : "0x00",
"config" : { "config" : {
"homesteadBlock" : 314, "homesteadBlock" : 314,
"daoForkBlock" : 141 "daoForkBlock" : 141,
"daoForkSupport" : true
}, },
}`, }`,
query: "eth.getBlock(0).nonce", query: "eth.getBlock(0).nonce",

49
cmd/utils/flags.go
Unescape View File

@ -798,43 +798,42 @@ func MustMakeChainConfig(ctx *cli.Context) *core.ChainConfig {
// MustMakeChainConfigFromDb reads the chain configuration from the given database. // MustMakeChainConfigFromDb reads the chain configuration from the given database.
func MustMakeChainConfigFromDb(ctx *cli.Context, db ethdb.Database) *core.ChainConfig { func MustMakeChainConfigFromDb(ctx *cli.Context, db ethdb.Database) *core.ChainConfig {
// If the chain is already initialized, use any existing chain configs // If the chain is already initialized, use any existing chain configs
config := new(core.ChainConfig)
if genesis := core.GetBlock(db, core.GetCanonicalHash(db, 0), 0); genesis != nil { if genesis := core.GetBlock(db, core.GetCanonicalHash(db, 0), 0); genesis != nil {
storedConfig, err := core.GetChainConfig(db, genesis.Hash()) storedConfig, err := core.GetChainConfig(db, genesis.Hash())
if err == nil { switch err {
// Force override any existing configs if explicitly requested case nil:
switch { config = storedConfig
case storedConfig.DAOForkBlock == nil && ctx.GlobalBool(SupportDAOFork.Name) && ctx.GlobalBool(TestNetFlag.Name): case core.ChainConfigNotFoundErr:
storedConfig.DAOForkBlock = params.TestNetDAOForkBlock // No configs found, use empty, will populate below
case storedConfig.DAOForkBlock == nil && ctx.GlobalBool(SupportDAOFork.Name): default:
storedConfig.DAOForkBlock = params.MainNetDAOForkBlock
case ctx.GlobalBool(OpposeDAOFork.Name):
storedConfig.DAOForkBlock = nil
}
return storedConfig
} else if err != core.ChainConfigNotFoundErr {
Fatalf("Could not make chain configuration: %v", err) Fatalf("Could not make chain configuration: %v", err)
} }
} }
// If the chain is uninitialized nor no configs are present, create one // Set any missing fields due to them being unset or system upgrade
var homesteadBlock *big.Int if config.HomesteadBlock == nil {
if ctx.GlobalBool(TestNetFlag.Name) {
config.HomesteadBlock = new(big.Int).Set(params.TestNetHomesteadBlock)
} else {
config.HomesteadBlock = new(big.Int).Set(params.MainNetHomesteadBlock)
}
}
if config.DAOForkBlock == nil {
if ctx.GlobalBool(TestNetFlag.Name) { if ctx.GlobalBool(TestNetFlag.Name) {
homesteadBlock = params.TestNetHomesteadBlock config.DAOForkBlock = new(big.Int).Set(params.TestNetDAOForkBlock)
} else { } else {
homesteadBlock = params.MainNetHomesteadBlock config.DAOForkBlock = new(big.Int).Set(params.MainNetDAOForkBlock)
} }
var daoForkBlock *big.Int }
// Force override any existing configs if explicitly requested
switch { switch {
case ctx.GlobalBool(SupportDAOFork.Name) && ctx.GlobalBool(TestNetFlag.Name):
daoForkBlock = params.TestNetDAOForkBlock
case ctx.GlobalBool(SupportDAOFork.Name): case ctx.GlobalBool(SupportDAOFork.Name):
daoForkBlock = params.MainNetDAOForkBlock config.DAOForkSupport = true
case ctx.GlobalBool(OpposeDAOFork.Name): case ctx.GlobalBool(OpposeDAOFork.Name):
daoForkBlock = nil config.DAOForkSupport = false
}
return &core.ChainConfig{
HomesteadBlock: homesteadBlock,
DAOForkBlock: daoForkBlock,
} }
return config
} }
// MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails. // MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.

21
core/block_validator.go
Unescape View File

@ -17,6 +17,7 @@
package core package core
import ( import (
"bytes"
"fmt" "fmt"
"math/big" "math/big"
"time" "time"
@ -247,6 +248,26 @@ func ValidateHeader(config *ChainConfig, pow pow.PoW, header *types.Header, pare
return &BlockNonceErr{header.Number, header.Hash(), header.Nonce.Uint64()} return &BlockNonceErr{header.Number, header.Hash(), header.Nonce.Uint64()}
} }
} }
// DAO hard-fork extension to the header validity: a) if the node is no-fork,
// do not accept blocks in the [fork, fork+10) range with the fork specific
// extra-data set; b) if the node is pro-fork, require blocks in the specific
// range to have the unique extra-data set.
if daoBlock := config.DAOForkBlock; daoBlock != nil {
// Check whether the block is among the fork extra-override range
limit := new(big.Int).Add(daoBlock, params.DAOForkExtraRange)
if daoBlock.Cmp(header.Number) <= 0 && header.Number.Cmp(limit) < 0 {
// Depending whether we support or oppose the fork, verrift the extra-data contents
if config.DAOForkSupport {
if bytes.Compare(header.Extra, params.DAOForkBlockExtra) != 0 {
return ValidationError("DAO pro-fork bad block extra-data: 0x%x", header.Extra)
}
} else {
if bytes.Compare(header.Extra, params.DAOForkBlockExtra) == 0 {
return ValidationError("DAO no-fork bad block extra-data: 0x%x", header.Extra)
}
}
}
}
return nil return nil
} }

105
core/block_validator_test.go
Unescape View File

@ -27,6 +27,7 @@ import (
"github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/pow/ezp" "github.com/ethereum/go-ethereum/pow/ezp"
) )
@ -92,3 +93,107 @@ func TestPutReceipt(t *testing.T) {
t.Error("expected to get 1 receipt, got none.") t.Error("expected to get 1 receipt, got none.")
} }
} }
// Tests that DAO-fork enabled clients can properly filter out fork-commencing
// blocks based on their extradata fields.
func TestDAOForkRangeExtradata(t *testing.T) {
forkBlock := big.NewInt(32)
// Generate a common prefix for both pro-forkers and non-forkers
db, _ := ethdb.NewMemDatabase()
genesis := WriteGenesisBlockForTesting(db)
prefix, _ := GenerateChain(genesis, db, int(forkBlock.Int64()-1), func(i int, gen *BlockGen) {})
// Create the concurrent, conflicting two nodes
proDb, _ := ethdb.NewMemDatabase()
WriteGenesisBlockForTesting(proDb)
proBc, _ := NewBlockChain(proDb, &ChainConfig{HomesteadBlock: big.NewInt(0), DAOForkBlock: forkBlock, DAOForkSupport: true}, new(FakePow), new(event.TypeMux))
conDb, _ := ethdb.NewMemDatabase()
WriteGenesisBlockForTesting(conDb)
conBc, _ := NewBlockChain(conDb, &ChainConfig{HomesteadBlock: big.NewInt(0), DAOForkBlock: forkBlock, DAOForkSupport: false}, new(FakePow), new(event.TypeMux))
if _, err := proBc.InsertChain(prefix); err != nil {
t.Fatalf("pro-fork: failed to import chain prefix: %v", err)
}
if _, err := conBc.InsertChain(prefix); err != nil {
t.Fatalf("con-fork: failed to import chain prefix: %v", err)
}
// Try to expand both pro-fork and non-fork chains iteratively with other camp's blocks
for i := int64(0); i < params.DAOForkExtraRange.Int64(); i++ {
// Create a pro-fork block, and try to feed into the no-fork chain
db, _ = ethdb.NewMemDatabase()
WriteGenesisBlockForTesting(db)
bc, _ := NewBlockChain(db, &ChainConfig{HomesteadBlock: big.NewInt(0)}, new(FakePow), new(event.TypeMux))
blocks := conBc.GetBlocksFromHash(conBc.CurrentBlock().Hash(), int(conBc.CurrentBlock().NumberU64()+1))
for j := 0; j < len(blocks)/2; j++ {
blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j]
}
if _, err := bc.InsertChain(blocks); err != nil {
t.Fatalf("failed to import contra-fork chain for expansion: %v", err)
}
blocks, _ = GenerateChain(conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) { gen.SetExtra(params.DAOForkBlockExtra) })
if _, err := conBc.InsertChain(blocks); err == nil {
t.Fatalf("contra-fork chain accepted pro-fork block: %v", blocks[0])
}
// Create a proper no-fork block for the contra-forker
blocks, _ = GenerateChain(conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
if _, err := conBc.InsertChain(blocks); err != nil {
t.Fatalf("contra-fork chain didn't accepted no-fork block: %v", err)
}
// Create a no-fork block, and try to feed into the pro-fork chain
db, _ = ethdb.NewMemDatabase()
WriteGenesisBlockForTesting(db)
bc, _ = NewBlockChain(db, &ChainConfig{HomesteadBlock: big.NewInt(0)}, new(FakePow), new(event.TypeMux))
blocks = proBc.GetBlocksFromHash(proBc.CurrentBlock().Hash(), int(proBc.CurrentBlock().NumberU64()+1))
for j := 0; j < len(blocks)/2; j++ {
blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j]
}
if _, err := bc.InsertChain(blocks); err != nil {
t.Fatalf("failed to import pro-fork chain for expansion: %v", err)
}
blocks, _ = GenerateChain(proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
if _, err := proBc.InsertChain(blocks); err == nil {
t.Fatalf("pro-fork chain accepted contra-fork block: %v", blocks[0])
}
// Create a proper pro-fork block for the pro-forker
blocks, _ = GenerateChain(proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) { gen.SetExtra(params.DAOForkBlockExtra) })
if _, err := proBc.InsertChain(blocks); err != nil {
t.Fatalf("pro-fork chain didn't accepted pro-fork block: %v", err)
}
}
// Verify that contra-forkers accept pro-fork extra-datas after forking finishes
db, _ = ethdb.NewMemDatabase()
WriteGenesisBlockForTesting(db)
bc, _ := NewBlockChain(db, &ChainConfig{HomesteadBlock: big.NewInt(0)}, new(FakePow), new(event.TypeMux))
blocks := conBc.GetBlocksFromHash(conBc.CurrentBlock().Hash(), int(conBc.CurrentBlock().NumberU64()+1))
for j := 0; j < len(blocks)/2; j++ {
blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j]
}
if _, err := bc.InsertChain(blocks); err != nil {
t.Fatalf("failed to import contra-fork chain for expansion: %v", err)
}
blocks, _ = GenerateChain(conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) { gen.SetExtra(params.DAOForkBlockExtra) })
if _, err := conBc.InsertChain(blocks); err != nil {
t.Fatalf("contra-fork chain didn't accept pro-fork block post-fork: %v", err)
}
// Verify that pro-forkers accept contra-fork extra-datas after forking finishes
db, _ = ethdb.NewMemDatabase()
WriteGenesisBlockForTesting(db)
bc, _ = NewBlockChain(db, &ChainConfig{HomesteadBlock: big.NewInt(0)}, new(FakePow), new(event.TypeMux))
blocks = proBc.GetBlocksFromHash(proBc.CurrentBlock().Hash(), int(proBc.CurrentBlock().NumberU64()+1))
for j := 0; j < len(blocks)/2; j++ {
blocks[j], blocks[len(blocks)-1-j] = blocks[len(blocks)-1-j], blocks[j]
}
if _, err := bc.InsertChain(blocks); err != nil {
t.Fatalf("failed to import pro-fork chain for expansion: %v", err)
}
blocks, _ = GenerateChain(proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {})
if _, err := proBc.InsertChain(blocks); err != nil {
t.Fatalf("pro-fork chain didn't accept contra-fork block post-fork: %v", err)
}
}

5
core/config.go
Unescape View File

@ -31,8 +31,9 @@ var ChainConfigNotFoundErr = errors.New("ChainConfig not found") // general conf
// that any network, identified by its genesis block, can have its own // that any network, identified by its genesis block, can have its own
// set of configuration options. // set of configuration options.
type ChainConfig struct { type ChainConfig struct {
HomesteadBlock *big.Int `json:"homesteadBlock"` // homestead switch block (0 = already homestead) HomesteadBlock *big.Int `json:"homesteadBlock"` // Homestead switch block (nil = no fork, 0 = already homestead)
DAOForkBlock *big.Int `json:"daoForkBlock"` // TheDAO hard-fork block (nil = no fork) DAOForkBlock *big.Int `json:"daoForkBlock"` // TheDAO hard-fork switch block (nil = no fork)
DAOForkSupport bool `json:"daoForkSupport"` // Whether the nodes supports or opposes the DAO hard-fork
VmConfig vm.Config `json:"-"` VmConfig vm.Config `json:"-"`
} }

8
miner/worker.go
Unescape View File

@ -17,6 +17,7 @@
package miner package miner
import ( import (
"bytes"
"fmt" "fmt"
"math/big" "math/big"
"sync" "sync"
@ -469,12 +470,17 @@ func (self *worker) commitNewWork() {
Extra: self.extra, Extra: self.extra,
Time: big.NewInt(tstamp), Time: big.NewInt(tstamp),
} }
// If we are doing a DAO hard-fork check whether to override the extra-data or not // If we are care about TheDAO hard-fork check whether to override the extra-data or not
if daoBlock := self.config.DAOForkBlock; daoBlock != nil { if daoBlock := self.config.DAOForkBlock; daoBlock != nil {
// Check whether the block is among the fork extra-override range // Check whether the block is among the fork extra-override range
limit := new(big.Int).Add(daoBlock, params.DAOForkExtraRange) limit := new(big.Int).Add(daoBlock, params.DAOForkExtraRange)
if daoBlock.Cmp(header.Number) <= 0 && header.Number.Cmp(limit) < 0 { if daoBlock.Cmp(header.Number) <= 0 && header.Number.Cmp(limit) < 0 {
// Depending whether we support or oppose the fork, override differently
if self.config.DAOForkSupport {
header.Extra = common.CopyBytes(params.DAOForkBlockExtra) header.Extra = common.CopyBytes(params.DAOForkBlockExtra)
} else if bytes.Compare(header.Extra, params.DAOForkBlockExtra) == 0 {
header.Extra = []byte{} // If miner opposes, don't let it use the reserved extra-data
}
} }
} }
previous := self.current previous := self.current

Write Preview
Loading…
Cancel
Save