Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

cmd/geth, miner, params: special extradata for DAO fork start #2791

Closed
wants to merge 3 commits into from
Closed

cmd/geth, miner, params: special extradata for DAO fork start #2791

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
84aab38
cmd, core, eth, params: implement flags to control dao fork blocks
karalabe Jul 7, 2016
b191124
core: gracefully handle missing homestead block config
karalabe Jul 8, 2016
4b7dbbc
cmd/geth, miner, params: special extradata for DAO fork start
karalabe Jul 8, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
306 changes: 306 additions & 0 deletions cmd/geth/dao_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,306 @@
// Copyright 2016 The go-ethereum Authors
// This file is part of go-ethereum.
//
// go-ethereum is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// go-ethereum 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.

package main

import (
"io/ioutil"
"math/big"
"os"
"path/filepath"
"testing"

"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/params"
)

var daoNoForkGenesis = `{
"alloc" : {},
"coinbase" : "0x0000000000000000000000000000000000000000",
"difficulty" : "0x20000",
"extraData" : "",
"gasLimit" : "0x2fefd8",
"nonce" : "0x0000000000000042",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00"
}`
var daoNoForkGenesisHash = common.HexToHash("5e1fc79cb4ffa4739177b5408045cd5d51c6cf766133f23f7cd72ee1f8d790e0")

var daoProForkGenesis = `{
"alloc" : {},
"coinbase" : "0x0000000000000000000000000000000000000000",
"difficulty" : "0x20000",
"extraData" : "",
"gasLimit" : "0x2fefd8",
"nonce" : "0x0000000000000043",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00",
"config" : {
"daoForkBlock": 314
}
}`
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
// set the genesis block but with DAO support explicitly set or unset in the chain
// config in the database.
func TestDAOSupportMainnet(t *testing.T) {
testDAOForkBlockNewChain(t, false, "", true, params.MainNetDAOForkBlock)
}
func TestDAOSupportTestnet(t *testing.T) {
testDAOForkBlockNewChain(t, true, "", true, params.TestNetDAOForkBlock)
}
func TestDAOSupportPrivnet(t *testing.T) {
testDAOForkBlockNewChain(t, false, daoProForkGenesis, false, daoProForkBlock)
}
func TestDAONoSupportMainnet(t *testing.T) {
testDAOForkBlockNewChain(t, false, "", false, nil)
}
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")
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 {
args = append(args, "--support-dao-fork")
}
if opposeFork {
args = append(args, "--oppose-dao-fork")
}
geth := runGeth(t, append(args, []string{"--exec", "2+2", "console"}...)...)
geth.cmd.Wait()
}
Loading