aboutsummaryrefslogtreecommitdiffstats
path: root/cmd
diff options
context:
space:
mode:
Diffstat (limited to 'cmd')
-rw-r--r--cmd/geth/dao_test.go294
-rw-r--r--cmd/geth/genesis_test.go3
-rw-r--r--cmd/utils/flags.go53
3 files changed, 138 insertions, 212 deletions
diff --git a/cmd/geth/dao_test.go b/cmd/geth/dao_test.go
index fd6831c15..bfa0c2a03 100644
--- a/cmd/geth/dao_test.go
+++ b/cmd/geth/dao_test.go
@@ -29,7 +29,8 @@ import (
"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" : {},
"coinbase" : "0x0000000000000000000000000000000000000000",
"difficulty" : "0x20000",
@@ -38,214 +39,140 @@ var daoNoForkGenesis = `{
"nonce" : "0x0000000000000042",
"mixhash" : "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" : {},
"coinbase" : "0x0000000000000000000000000000000000000000",
"difficulty" : "0x20000",
"extraData" : "",
"gasLimit" : "0x2fefd8",
- "nonce" : "0x0000000000000043",
+ "nonce" : "0x0000000000000042",
"mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
"timestamp" : "0x00",
"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
-// 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)
+// Genesis block for nodes which actively support the DAO fork
+var daoProForkGenesis = `{
+ "alloc" : {},
+ "coinbase" : "0x0000000000000000000000000000000000000000",
+ "difficulty" : "0x20000",
+ "extraData" : "",
+ "gasLimit" : "0x2fefd8",
+ "nonce" : "0x0000000000000042",
+ "mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "timestamp" : "0x00",
+ "config" : {
+ "daoForkBlock" : 314,
+ "daoForkSupport" : true
}
- 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)
- }
-}
+var daoGenesisHash = common.HexToHash("5e1fc79cb4ffa4739177b5408045cd5d51c6cf766133f23f7cd72ee1f8d790e0")
+var daoGenesisForkBlock = big.NewInt(314)
-// Tests that starting up an already existing node with various DAO fork override
-// flags correctly changes the chain configs 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) {
- 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)
+ testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, false}}, params.MainNetDAOForkBlock, false)
}
-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 TestDAOSupportMainnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, "", [][2]bool{{true, false}}, params.MainNetDAOForkBlock, true)
}
-func TestDAOContinueExplicitOpposeMainnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, "", false, false, true, true, nil)
+func TestDAOOpposeMainnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, true}}, params.MainNetDAOForkBlock, false)
}
-func TestDAOContinueImplicitOpposeMainnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, "", false, false, true, false, nil)
+func TestDAOSwitchToSupportMainnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, "", [][2]bool{{false, true}, {true, false}}, params.MainNetDAOForkBlock, true)
}
-func TestDAOSwitchOpposeMainnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, "", true, false, false, true, nil)
+func TestDAOSwitchToOpposeMainnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, "", [][2]bool{{true, false}, {false, true}}, params.MainNetDAOForkBlock, false)
}
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)
+ testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, false}}, params.TestNetDAOForkBlock, false)
}
-func TestDAOStartOpposeTestnet(t *testing.T) {
- testDAOForkBlockOldChain(t, true, "", false, false, false, true, nil)
+func TestDAOSupportTestnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, true, "", [][2]bool{{true, false}}, params.TestNetDAOForkBlock, true)
}
-func TestDAOContinueExplicitOpposeTestnet(t *testing.T) {
- testDAOForkBlockOldChain(t, true, "", false, false, true, true, nil)
+func TestDAOOpposeTestnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, true}}, params.TestNetDAOForkBlock, false)
}
-func TestDAOContinueImplicitOpposeTestnet(t *testing.T) {
- testDAOForkBlockOldChain(t, true, "", false, false, true, false, nil)
+func TestDAOSwitchToSupportTestnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, true, "", [][2]bool{{false, true}, {true, false}}, params.TestNetDAOForkBlock, true)
}
-func TestDAOSwitchOpposeTestnet(t *testing.T) {
- testDAOForkBlockOldChain(t, true, "", true, false, false, true, nil)
+func TestDAOSwitchToOpposeTestnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, true, "", [][2]bool{{true, false}, {false, true}}, params.TestNetDAOForkBlock, false)
}
-func TestDAODefaultPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, false, false, nil)
+func TestDAOInitOldPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{}, nil, false)
}
-func TestDAOStartSupportConPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, true, false, false, params.MainNetDAOForkBlock)
+func TestDAODefaultOldPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, false}}, params.MainNetDAOForkBlock, false)
}
-func TestDAOContinueExplicitSupportConPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoNoForkGenesis, true, true, false, false, params.MainNetDAOForkBlock)
+func TestDAOSupportOldPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{true, false}}, params.MainNetDAOForkBlock, true)
}
-func TestDAOContinueImplicitSupportConPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoNoForkGenesis, true, false, false, false, params.MainNetDAOForkBlock)
+func TestDAOOpposeOldPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, true}}, params.MainNetDAOForkBlock, false)
}
-func TestDAOSwitchSupportConPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, true, true, false, params.MainNetDAOForkBlock)
+func TestDAOSwitchToSupportOldPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{false, true}, {true, false}}, params.MainNetDAOForkBlock, true)
}
-func TestDAOStartOpposeConPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, false, true, nil)
+func TestDAOSwitchToOpposeOldPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoOldGenesis, [][2]bool{{true, false}, {false, true}}, params.MainNetDAOForkBlock, false)
}
-func TestDAOContinueExplicitOpposeConPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, true, true, nil)
+func TestDAOInitNoForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{}, daoGenesisForkBlock, false)
}
-func TestDAOContinueImplicitOpposeConPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoNoForkGenesis, false, false, true, false, nil)
+func TestDAODefaultNoForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, false)
}
-func TestDAOSwitchOpposeConPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoNoForkGenesis, true, false, false, true, nil)
+func TestDAOSupportNoForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true)
}
-func TestDAODefaultProPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, false, false, daoProForkBlock)
+func TestDAOOpposeNoForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false)
}
-func TestDAOStartSupportProPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, true, false, false, daoProForkBlock)
+func TestDAOSwitchToSupportNoForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true)
}
-func TestDAOContinueExplicitSupportProPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoProForkGenesis, true, true, false, false, daoProForkBlock)
+func TestDAOSwitchToOpposeNoForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoNoForkGenesis, [][2]bool{{true, false}, {false, true}}, daoGenesisForkBlock, false)
}
-func TestDAOContinueImplicitSupportProPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoProForkGenesis, true, false, false, false, daoProForkBlock)
+func TestDAOInitProForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{}, daoGenesisForkBlock, true)
}
-func TestDAOSwitchSupportProPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, true, true, false, params.MainNetDAOForkBlock)
+func TestDAODefaultProForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, false}}, daoGenesisForkBlock, true)
}
-func TestDAOStartOpposeProPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, false, true, nil)
+func TestDAOSupportProForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{true, false}}, daoGenesisForkBlock, true)
}
-func TestDAOContinueExplicitOpposeProPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, true, true, nil)
+func TestDAOOpposeProForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, true}}, daoGenesisForkBlock, false)
}
-func TestDAOContinueImplicitOpposeProPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoProForkGenesis, false, false, true, false, nil)
+func TestDAOSwitchToSupportProForkPrivnet(t *testing.T) {
+ testDAOForkBlockNewChain(t, false, daoProForkGenesis, [][2]bool{{false, true}, {true, false}}, daoGenesisForkBlock, true)
}
-func TestDAOSwitchOpposeProPrivnet(t *testing.T) {
- testDAOForkBlockOldChain(t, false, daoProForkGenesis, true, false, false, true, nil)
+func TestDAOSwitchToOpposeProForkPrivnet(t *testing.T) {
+ 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
datadir := tmpdir(t)
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 != "" {
json := filepath.Join(datadir, "genesis.json")
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()
}
- execDAOGeth(t, datadir, testnet, oldSupport, oldOppose)
- execDAOGeth(t, datadir, testnet, newSupport, newOppose)
-
+ for _, vote := range votes {
+ 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
path := filepath.Join(datadir, "chaindata")
- if testnet {
+ if testnet && genesis == "" {
path = filepath.Join(datadir, "testnet", "chaindata")
}
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")
if testnet {
genesisHash = common.HexToHash("0x0cd786a2425d16f152c658316c423e6ce1181e15c3295826d7c9904cba9ce303")
- } else if genesis == daoNoForkGenesis {
- genesisHash = daoNoForkGenesisHash
- } else if genesis == daoProForkGenesis {
- genesisHash = daoProForkGenesisHash
+ }
+ if genesis != "" {
+ genesisHash = daoGenesisHash
}
config, err := core.GetChainConfig(db, genesisHash)
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
if config.DAOForkBlock == nil {
- if expect != nil {
- t.Fatalf("dao hard-fork block mismatch: have nil, want %v", expect)
+ if expectBlock != nil {
+ 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 {
- args = append(args, "--support-dao-fork")
+ } 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 opposeFork {
- args = append(args, "--oppose-dao-fork")
+ if config.DAOForkSupport != expectVote {
+ 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()
}
diff --git a/cmd/geth/genesis_test.go b/cmd/geth/genesis_test.go
index 43d678d89..4f8b1642e 100644
--- a/cmd/geth/genesis_test.go
+++ b/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",
diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go
index b95f5159c..fae1647b3 100644
--- a/cmd/utils/flags.go
+++ b/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 {
- // 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 {
+ switch err {
+ case nil:
+ config = storedConfig
+ case core.ChainConfigNotFoundErr:
+ // No configs found, use empty, will populate below
+ default:
Fatalf("Could not make chain configuration: %v", err)
}
}
- // If the chain is uninitialized nor no configs are present, create one
- var homesteadBlock *big.Int
- if ctx.GlobalBool(TestNetFlag.Name) {
- homesteadBlock = params.TestNetHomesteadBlock
- } else {
- homesteadBlock = params.MainNetHomesteadBlock
+ // Set any missing fields due to them being unset or system upgrade
+ 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)
+ }
}
- 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
- }
- return &core.ChainConfig{
- HomesteadBlock: homesteadBlock,
- DAOForkBlock: daoForkBlock,
+ config.DAOForkSupport = false
}
+ return config
}
// MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails.
generated by cgit (git 2.34.1) at 2024-11-16 00:09:13 +0800