poanetwork
/
quorum
mirror of https://github.com/poanetwork/quorum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

cmd, core, eth, params: implement flags to control dao fork blocks

This commit is contained in:
Péter Szilágyi 2016-07-07 16:04:34 +03:00
parent aa1e052cb4
commit 6060e098c9
7 changed files with 354 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

306
cmd/geth/dao_test.go Normal file
View File

@ -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()
}

9
cmd/geth/main.go
View File

@ -150,7 +150,6 @@ participating.
utils.IdentityFlag,
utils.UnlockedAccountFlag,
utils.PasswordFileFlag,
utils.GenesisFileFlag,
utils.BootnodesFlag,
utils.DataDirFlag,
utils.KeyStoreDirFlag,
@ -165,6 +164,8 @@ participating.
utils.MaxPendingPeersFlag,
utils.EtherbaseFlag,
utils.GasPriceFlag,
utils.SupportDAOFork,
utils.OpposeDAOFork,
utils.MinerThreadsFlag,
utils.MiningEnabledFlag,
utils.MiningGPUFlag,
@ -225,12 +226,6 @@ participating.
eth.EnableBadBlockReporting = true
utils.SetupNetwork(ctx)
// Deprecation warning.
if ctx.GlobalIsSet(utils.GenesisFileFlag.Name) {
common.PrintDepricationWarning("--genesis is deprecated. Switch to use 'geth init /path/to/file'")
}
return nil
}

1
cmd/geth/usage.go
View File

@ -68,7 +68,6 @@ var AppHelpFlagGroups = []flagGroup{
utils.OlympicFlag,
utils.TestNetFlag,
utils.DevModeFlag,
utils.GenesisFileFlag,
utils.IdentityFlag,
utils.FastSyncFlag,
utils.LightKDFFlag,

76
cmd/utils/flags.go
View File

@ -126,10 +126,6 @@ var (
Name: "dev",
Usage: "Developer mode: pre-configured private network with several debugging flags",
}
GenesisFileFlag = cli.StringFlag{
Name: "genesis",
Usage: "Insert/overwrite the genesis block (JSON format)",
}
IdentityFlag = cli.StringFlag{
Name: "identity",
Usage: "Custom node name",
@ -161,6 +157,15 @@ var (
Name: "lightkdf",
Usage: "Reduce key-derivation RAM & CPU usage at some expense of KDF strength",
}
// Fork settings
SupportDAOFork = cli.BoolFlag{
Name: "support-dao-fork",
Usage: "Updates the chain rules to support the DAO hard-fork",
}
OpposeDAOFork = cli.BoolFlag{
Name: "oppose-dao-fork",
Usage: "Updates the chain rules to oppose the DAO hard-fork",
}
// Miner settings
// TODO: refactor CPU vs GPU mining flags
MiningEnabledFlag = cli.BoolFlag{
@ -534,20 +539,6 @@ func MakeWSRpcHost(ctx *cli.Context) string {
return ctx.GlobalString(WSListenAddrFlag.Name)
}
// MakeGenesisBlock loads up a genesis block from an input file specified in the
// command line, or returns the empty string if none set.
func MakeGenesisBlock(ctx *cli.Context) string {
genesis := ctx.GlobalString(GenesisFileFlag.Name)
if genesis == "" {
return ""
}
data, err := ioutil.ReadFile(genesis)
if err != nil {
Fatalf("Failed to load custom genesis file: %v", err)
}
return string(data)
}
// MakeDatabaseHandles raises out the number of allowed file handles per process
// for Geth and returns half of the allowance to assign to the database.
func MakeDatabaseHandles() int {
@ -689,7 +680,6 @@ func MakeSystemNode(name, version string, relconf release.Config, extra []byte,
ethConf := &eth.Config{
ChainConfig: MustMakeChainConfig(ctx),
Genesis: MakeGenesisBlock(ctx),
FastSync: ctx.GlobalBool(FastSyncFlag.Name),
BlockChainVersion: ctx.GlobalInt(BlockchainVersionFlag.Name),
DatabaseCache: ctx.GlobalInt(CacheFlag.Name),
@ -722,17 +712,13 @@ func MakeSystemNode(name, version string, relconf release.Config, extra []byte,
if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
ethConf.NetworkId = 1
}
if !ctx.GlobalIsSet(GenesisFileFlag.Name) {
ethConf.Genesis = core.OlympicGenesisBlock()
}
ethConf.Genesis = core.OlympicGenesisBlock()
case ctx.GlobalBool(TestNetFlag.Name):
if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
ethConf.NetworkId = 2
}
if !ctx.GlobalIsSet(GenesisFileFlag.Name) {
ethConf.Genesis = core.TestNetGenesisBlock()
}
ethConf.Genesis = core.TestNetGenesisBlock()
state.StartingNonce = 1048576 // (2**20)
case ctx.GlobalBool(DevModeFlag.Name):
@ -747,9 +733,7 @@ func MakeSystemNode(name, version string, relconf release.Config, extra []byte,
stackConf.ListenAddr = ":0"
}
// Override the Ethereum protocol configs
if !ctx.GlobalIsSet(GenesisFileFlag.Name) {
ethConf.Genesis = core.OlympicGenesisBlock()
}
ethConf.Genesis = core.OlympicGenesisBlock()
if !ctx.GlobalIsSet(GasPriceFlag.Name) {
ethConf.GasPrice = new(big.Int)
}
@ -813,24 +797,44 @@ 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 {
genesis := core.GetBlock(db, core.GetCanonicalHash(db, 0), 0)
if genesis != nil {
// Existing genesis block, use stored config if available.
// If the chain is already initialized, use any existing chain configs
if genesis := core.GetBlock(db, core.GetCanonicalHash(db, 0), 0); genesis != nil {
storedConfig, err := core.GetChainConfig(db, genesis.Hash())
if err == nil {
// Force override any existing configs if explicitly requested
switch {
case storedConfig.DAOForkBlock == nil && ctx.GlobalBool(SupportDAOFork.Name) && ctx.GlobalBool(TestNetFlag.Name):
storedConfig.DAOForkBlock = params.TestNetDAOForkBlock
case storedConfig.DAOForkBlock == nil && ctx.GlobalBool(SupportDAOFork.Name):
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)
}
}
var homesteadBlockNo *big.Int
// If the chain is uninitialized nor no configs are present, create one
var homesteadBlock *big.Int
if ctx.GlobalBool(TestNetFlag.Name) {
homesteadBlockNo = params.TestNetHomesteadBlock
homesteadBlock = params.TestNetHomesteadBlock
} else {
homesteadBlockNo = params.MainNetHomesteadBlock
homesteadBlock = params.MainNetHomesteadBlock
}
var daoForkBlock *big.Int
switch {
case ctx.GlobalBool(SupportDAOFork.Name) && ctx.GlobalBool(TestNetFlag.Name):
daoForkBlock = params.TestNetDAOForkBlock
case ctx.GlobalBool(SupportDAOFork.Name):
daoForkBlock = params.MainNetDAOForkBlock
case ctx.GlobalBool(OpposeDAOFork.Name):
daoForkBlock = nil
}
return &core.ChainConfig{
HomesteadBlock: homesteadBlock,
DAOForkBlock: daoForkBlock,
}
return &core.ChainConfig{HomesteadBlock: homesteadBlockNo}
}
// MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.

4
core/config.go
View File

@ -31,7 +31,8 @@ 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 // homestead switch block
HomesteadBlock *big.Int `json:"homesteadBlock"` // homestead switch block (0 = already homestead)
DAOForkBlock *big.Int `json:"daoForkBlock"` // TheDAO hard-fork block (nil = no fork)
VmConfig vm.Config `json:"-"`
}
@ -41,6 +42,5 @@ func (c *ChainConfig) IsHomestead(num *big.Int) bool {
if num == nil {
return false
}
return num.Cmp(c.HomesteadBlock) >= 0
}

2
eth/backend.go
View File

@ -205,6 +205,8 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
if config.ChainConfig == nil {
return nil, errors.New("missing chain config")
}
core.WriteChainConfig(chainDb, genesis.Hash(), config.ChainConfig)
eth.chainConfig = config.ChainConfig
eth.chainConfig.VmConfig = vm.Config{
EnableJit: config.EnableJit,

2
params/util.go
View File

@ -21,4 +21,6 @@ import "math/big"
var (
TestNetHomesteadBlock = big.NewInt(494000) // testnet homestead block
MainNetHomesteadBlock = big.NewInt(1150000) // mainnet homestead block
TestNetDAOForkBlock = big.NewInt(8888888) // testnet dao hard-fork block
MainNetDAOForkBlock = big.NewInt(9999999) // mainnet dao hard-fork block
)