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

cmd/geth/dao_test.go

@@ -29,6 +29,21 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 )
 
+// Genesis block for nodes which don't care about the DAO fork (i.e. not configured)
+var daoOldGenesis = `{
+	"alloc"      : {},
+	"coinbase"   : "0x0000000000000000000000000000000000000000",
+	"difficulty" : "0x20000",
+	"extraData"  : "",
+	"gasLimit"   : "0x2fefd8",
+	"nonce"      : "0x0000000000000042",
+	"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
+	"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+	"timestamp"  : "0x00",
+	"config"     : {}
+}`
+
+// Genesis block for nodes which actively oppose the DAO fork
 var daoNoForkGenesis = `{
 	"alloc"      : {},
 	"coinbase"   : "0x0000000000000000000000000000000000000000",
@@ -38,50 +53,121 @@ var daoNoForkGenesis = `{
 	"nonce"      : "0x0000000000000042",
 	"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
 	"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
-	"timestamp"  : "0x00"
+	"timestamp"  : "0x00",
+	"config"     : {
+		"daoForkBlock"   : 314,
+		"daoForkSupport" : false
+	}
 }`
-var daoNoForkGenesisHash = common.HexToHash("5e1fc79cb4ffa4739177b5408045cd5d51c6cf766133f23f7cd72ee1f8d790e0")
 
+// Genesis block for nodes which actively support the DAO fork
 var daoProForkGenesis = `{
 	"alloc"      : {},
 	"coinbase"   : "0x0000000000000000000000000000000000000000",
 	"difficulty" : "0x20000",
 	"extraData"  : "",
 	"gasLimit"   : "0x2fefd8",
-	"nonce"      : "0x0000000000000043",
+	"nonce"      : "0x0000000000000042",
 	"mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
 	"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
 	"timestamp"  : "0x00",
 	"config"     : {
-		"daoForkBlock": 314
+		"daoForkBlock"   : 314,
+		"daoForkSupport" : true
 	}
 }`
-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
+var daoGenesisHash = common.HexToHash("5e1fc79cb4ffa4739177b5408045cd5d51c6cf766133f23f7cd72ee1f8d790e0")
-// set the genesis block but with DAO support explicitly set or unset in the chain
+var daoGenesisForkBlock = big.NewInt(314)
-// config in the database.
+
+// Tests that the DAO hard-fork number and the nodes support/opposition is correctly
+// set in the database after various initialization procedures and invocations.
+func TestDAODefaultMainnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, false}}, params.MainNetDAOForkBlock, false)
+}
 func TestDAOSupportMainnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, "", true, params.MainNetDAOForkBlock)
+	testDAOForkBlockNewChain(t, false, "", [][2]bool{{true, false}}, params.MainNetDAOForkBlock, true)
+}
+func TestDAOOpposeMainnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, true}}, params.MainNetDAOForkBlock, false)
+}
+func TestDAOSwitchToSupportMainnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, true}, {true, false}}, params.MainNetDAOForkBlock, true)
+}
+func TestDAOSwitchToOpposeMainnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, "", [][2]bool{{true, false}, {false, true}}, params.MainNetDAOForkBlock, false)
+}
+func TestDAODefaultTestnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, false}}, params.TestNetDAOForkBlock, false)
 }
 func TestDAOSupportTestnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, true, "", true, params.TestNetDAOForkBlock)
+	testDAOForkBlockNewChain(t, true, "", [][2]bool{{true, false}}, params.TestNetDAOForkBlock, true)
 }
-func TestDAOSupportPrivnet(t *testing.T) {
+func TestDAOOpposeTestnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoProForkGenesis, false, daoProForkBlock)
+	testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, true}}, params.TestNetDAOForkBlock, false)
 }
-func TestDAONoSupportMainnet(t *testing.T) {
+func TestDAOSwitchToSupportTestnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, "", false, nil)
+	testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, true}, {true, false}}, params.TestNetDAOForkBlock, true)
 }
-func TestDAONoSupportTestnet(t *testing.T) {
+func TestDAOSwitchToOpposeTestnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, true, "", false, nil)
+	testDAOForkBlockNewChain(t, true, "", [][2]bool{{true, false}, {false, true}}, params.TestNetDAOForkBlock, false)
 }
-func TestDAONoSupportPrivnet(t *testing.T) {
+func TestDAOInitOldPrivnet(t *testing.T) {
-	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, false, nil)
+	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{}, nil, false)
+}
+func TestDAODefaultOldPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, false}}, params.MainNetDAOForkBlock, false)
+}
+func TestDAOSupportOldPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{true, false}}, params.MainNetDAOForkBlock, true)
+}
+func TestDAOOpposeOldPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, true}}, params.MainNetDAOForkBlock, false)
+}
+func TestDAOSwitchToSupportOldPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, true}, {true, false}}, params.MainNetDAOForkBlock, true)
+}
+func TestDAOSwitchToOpposeOldPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{true, false}, {false, true}}, params.MainNetDAOForkBlock, false)
+}
+func TestDAOInitNoForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{}, daoGenesisForkBlock, false)
+}
+func TestDAODefaultNoForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, false)
+}
+func TestDAOSupportNoForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true)
+}
+func TestDAOOpposeNoForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false)
+}
+func TestDAOSwitchToSupportNoForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true)
+}
+func TestDAOSwitchToOpposeNoForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{true, false}, {false, true}}, daoGenesisForkBlock, false)
+}
+func TestDAOInitProForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{}, daoGenesisForkBlock, true)
+}
+func TestDAODefaultProForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, true)
+}
+func TestDAOSupportProForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true)
+}
+func TestDAOOpposeProForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false)
+}
+func TestDAOSwitchToSupportProForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true)
+}
+func TestDAOSwitchToOpposeProForkPrivnet(t *testing.T) {
+	testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{true, false}, {false, true}}, daoGenesisForkBlock, false)
 }
 
-func testDAOForkBlockNewChain(t *testing.T, testnet bool, genesis string, fork 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
 	datadir := tmpdir(t)
 	defer os.RemoveAll(datadir)
@@ -94,213 +180,53 @@ func testDAOForkBlockNewChain(t *testing.T, testnet bool, genesis string, fork b
 		}
 		runGeth(t, "--datadir", datadir, "init", json).cmd.Wait()
 	}
-	execDAOGeth(t, datadir, testnet, fork, false)
+	for _, vote := range votes {
-
-	// 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")
-	if testnet {
-		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
-// flags correctly changes the chain configs in the database.
-func TestDAODefaultMainnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, "", false, false, false, false, nil)
-}
-func TestDAOStartSupportMainnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, "", false, true, false, false, params.MainNetDAOForkBlock)
-}
-func TestDAOContinueExplicitSupportMainnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, "", true, true, false, false, params.MainNetDAOForkBlock)
-}
-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) {
-	testDAOForkBlockOldChain(t, false, "", false, false, true, true, nil)
-}
-func TestDAOContinueImplicitOpposeMainnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, "", false, false, true, false, nil)
-}
-func TestDAOSwitchOpposeMainnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, "", true, false, false, true, nil)
-}
-func TestDAODefaultTestnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, true, "", false, false, false, false, nil)
-}
-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) {
-	testDAOForkBlockOldChain(t, true, "", true, false, false, false, params.TestNetDAOForkBlock)
-}
-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) {
-	testDAOForkBlockOldChain(t, true, "", false, false, true, true, nil)
-}
-func TestDAOContinueImplicitOpposeTestnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, true, "", false, false, true, false, nil)
-}
-func TestDAOSwitchOpposeTestnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, true, "", true, false, false, true, nil)
-}
-func TestDAODefaultPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, false, false, nil)
-}
-func TestDAOStartSupportConPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, true, false, false, params.MainNetDAOForkBlock)
-}
-func TestDAOContinueExplicitSupportConPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoNoForkGenesis, true, true, false, false, params.MainNetDAOForkBlock)
-}
-func TestDAOContinueImplicitSupportConPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoNoForkGenesis, true, false, false, false, params.MainNetDAOForkBlock)
-}
-func TestDAOSwitchSupportConPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, true, true, false, params.MainNetDAOForkBlock)
-}
-func TestDAOStartOpposeConPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, false, true, nil)
-}
-func TestDAOContinueExplicitOpposeConPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, true, true, nil)
-}
-func TestDAOContinueImplicitOpposeConPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, true, false, nil)
-}
-func TestDAOSwitchOpposeConPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoNoForkGenesis, true, false, false, true, nil)
-}
-func TestDAODefaultProPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, false, false, daoProForkBlock)
-}
-func TestDAOStartSupportProPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, true, false, false, daoProForkBlock)
-}
-func TestDAOContinueExplicitSupportProPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoProForkGenesis, true, true, false, false, daoProForkBlock)
-}
-func TestDAOContinueImplicitSupportProPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoProForkGenesis, true, false, false, false, daoProForkBlock)
-}
-func TestDAOSwitchSupportProPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, true, true, false, params.MainNetDAOForkBlock)
-}
-func TestDAOStartOpposeProPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, false, true, nil)
-}
-func TestDAOContinueExplicitOpposeProPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, true, true, nil)
-}
-func TestDAOContinueImplicitOpposeProPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, true, false, nil)
-}
-func TestDAOSwitchOpposeProPrivnet(t *testing.T) {
-	testDAOForkBlockOldChain(t, false, daoProForkGenesis, true, false, false, true, nil)
-}
-
-func testDAOForkBlockOldChain(t *testing.T, testnet bool, genesis string, oldSupport, newSupport, oldOppose, newOppose bool, expect *big.Int) {
-	// Create a temporary data directory to use and inspect later
-	datadir := tmpdir(t)
-	defer os.RemoveAll(datadir)
-
-	// Cycle two Geth instances, possibly changing fork support in between
-	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, oldSupport, oldOppose)
-	execDAOGeth(t, datadir, testnet, newSupport, newOppose)
-
-	// 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")
-	if testnet {
-		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)
-	}
-}
-
-// 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 {
+		if vote[0] {
 			args = append(args, "--support-dao-fork")
 		}
-	if opposeFork {
+		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
+	path := filepath.Join(datadir, "chaindata")
+	if testnet && genesis == "" {
+		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")
+	if testnet {
+		genesisHash = common.HexToHash("0x0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303")
+	}
+	if genesis != "" {
+		genesisHash = daoGenesisHash
+	}
+	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 expectBlock != nil {
+			t.Errorf("dao hard-fork block mismatch: have nil, want %v", expectBlock)
+		}
+	} else if expectBlock == nil {
+		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 config.DAOForkSupport != expectVote {
+		t.Errorf("dao hard-fork support mismatch: have %v, want %v", config.DAOForkSupport, expectVote)
+	}
+}

cmd/geth/genesis_test.go

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

cmd/utils/flags.go

@@ -798,43 +798,42 @@ func MustMakeChainConfig(ctx *cli.Context) *core.ChainConfig {
 // MustMakeChainConfigFromDb reads the chain configuration from the given database.
 func MustMakeChainConfigFromDb(ctx *cli.Context, db ethdb.Database) *core.ChainConfig {
 	// 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 {
 		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)
 		}
 	}
-	// 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) {
-		homesteadBlock = params.TestNetHomesteadBlock
+			config.HomesteadBlock = new(big.Int).Set(params.TestNetHomesteadBlock)
 		} else {
-		homesteadBlock = params.MainNetHomesteadBlock
+			config.HomesteadBlock = new(big.Int).Set(params.MainNetHomesteadBlock)
 		}
-	var daoForkBlock *big.Int
+	}
+	if config.DAOForkBlock == nil {
+		if ctx.GlobalBool(TestNetFlag.Name) {
+			config.DAOForkBlock = new(big.Int).Set(params.TestNetDAOForkBlock)
+		} else {
+			config.DAOForkBlock = new(big.Int).Set(params.MainNetDAOForkBlock)
+		}
+	}
+	// Force override any existing configs if explicitly requested
 	switch {
-	case ctx.GlobalBool(SupportDAOFork.Name) && ctx.GlobalBool(TestNetFlag.Name):
-		daoForkBlock = params.TestNetDAOForkBlock
 	case ctx.GlobalBool(SupportDAOFork.Name):
-		daoForkBlock = params.MainNetDAOForkBlock
+		config.DAOForkSupport = true
 	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.

core/block_validator.go

@@ -17,6 +17,7 @@
 package core
 
 import (
+	"bytes"
 	"fmt"
 	"math/big"
 	"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()}
 		}
 	}
+	// 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
 }
 

core/block_validator_test.go

@@ -27,6 +27,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/event"
+	"github.com/ethereum/go-ethereum/params"
 	"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.")
 	}
 }
+
+// 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)
+	}
+}

core/config.go

@@ -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
 // set of configuration options.
 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:"-"`
 }

miner/worker.go

@@ -17,6 +17,7 @@
 package miner
 
 import (
+	"bytes"
 	"fmt"
 	"math/big"
 	"sync"
@@ -469,12 +470,17 @@ func (self *worker) commitNewWork() {
 		Extra:      self.extra,
 		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 {
 		// 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, override differently
+			if self.config.DAOForkSupport {
 				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