1// Copyright 2014 The go-ethereum Authors 2// This file is part of the go-ethereum library. 3// 4// The go-ethereum library is free software: you can redistribute it and/or modify 5// it under the terms of the GNU Lesser General Public License as published by 6// the Free Software Foundation, either version 3 of the License, or 7// (at your option) any later version. 8// 9// The go-ethereum library is distributed in the hope that it will be useful, 10// but WITHOUT ANY WARRANTY; without even the implied warranty of 11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12// GNU Lesser General Public License for more details. 13// 14// You should have received a copy of the GNU Lesser General Public License 15// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17package core 18 19import ( 20 "bytes" 21 "encoding/hex" 22 "encoding/json" 23 "errors" 24 "fmt" 25 "math/big" 26 "strings" 27 28 "github.com/ethereum/go-ethereum/common" 29 "github.com/ethereum/go-ethereum/common/hexutil" 30 "github.com/ethereum/go-ethereum/common/math" 31 "github.com/ethereum/go-ethereum/core/rawdb" 32 "github.com/ethereum/go-ethereum/core/state" 33 "github.com/ethereum/go-ethereum/core/types" 34 "github.com/ethereum/go-ethereum/crypto" 35 "github.com/ethereum/go-ethereum/ethdb" 36 "github.com/ethereum/go-ethereum/log" 37 "github.com/ethereum/go-ethereum/params" 38 "github.com/ethereum/go-ethereum/rlp" 39 "github.com/ethereum/go-ethereum/trie" 40) 41 42//go:generate gencodec -type Genesis -field-override genesisSpecMarshaling -out gen_genesis.go 43//go:generate gencodec -type GenesisAccount -field-override genesisAccountMarshaling -out gen_genesis_account.go 44 45var errGenesisNoConfig = errors.New("genesis has no chain configuration") 46 47// Genesis specifies the header fields, state of a genesis block. It also defines hard 48// fork switch-over blocks through the chain configuration. 49type Genesis struct { 50 Config *params.ChainConfig `json:"config"` 51 Nonce uint64 `json:"nonce"` 52 Timestamp uint64 `json:"timestamp"` 53 ExtraData []byte `json:"extraData"` 54 GasLimit uint64 `json:"gasLimit" gencodec:"required"` 55 Difficulty *big.Int `json:"difficulty" gencodec:"required"` 56 Mixhash common.Hash `json:"mixHash"` 57 Coinbase common.Address `json:"coinbase"` 58 Alloc GenesisAlloc `json:"alloc" gencodec:"required"` 59 60 // These fields are used for consensus tests. Please don't use them 61 // in actual genesis blocks. 62 Number uint64 `json:"number"` 63 GasUsed uint64 `json:"gasUsed"` 64 ParentHash common.Hash `json:"parentHash"` 65 BaseFee *big.Int `json:"baseFeePerGas"` 66} 67 68// GenesisAlloc specifies the initial state that is part of the genesis block. 69type GenesisAlloc map[common.Address]GenesisAccount 70 71func (ga *GenesisAlloc) UnmarshalJSON(data []byte) error { 72 m := make(map[common.UnprefixedAddress]GenesisAccount) 73 if err := json.Unmarshal(data, &m); err != nil { 74 return err 75 } 76 *ga = make(GenesisAlloc) 77 for addr, a := range m { 78 (*ga)[common.Address(addr)] = a 79 } 80 return nil 81} 82 83// GenesisAccount is an account in the state of the genesis block. 84type GenesisAccount struct { 85 Code []byte `json:"code,omitempty"` 86 Storage map[common.Hash]common.Hash `json:"storage,omitempty"` 87 Balance *big.Int `json:"balance" gencodec:"required"` 88 Nonce uint64 `json:"nonce,omitempty"` 89 PrivateKey []byte `json:"secretKey,omitempty"` // for tests 90} 91 92// field type overrides for gencodec 93type genesisSpecMarshaling struct { 94 Nonce math.HexOrDecimal64 95 Timestamp math.HexOrDecimal64 96 ExtraData hexutil.Bytes 97 GasLimit math.HexOrDecimal64 98 GasUsed math.HexOrDecimal64 99 Number math.HexOrDecimal64 100 Difficulty *math.HexOrDecimal256 101 BaseFee *math.HexOrDecimal256 102 Alloc map[common.UnprefixedAddress]GenesisAccount 103} 104 105type genesisAccountMarshaling struct { 106 Code hexutil.Bytes 107 Balance *math.HexOrDecimal256 108 Nonce math.HexOrDecimal64 109 Storage map[storageJSON]storageJSON 110 PrivateKey hexutil.Bytes 111} 112 113// storageJSON represents a 256 bit byte array, but allows less than 256 bits when 114// unmarshaling from hex. 115type storageJSON common.Hash 116 117func (h *storageJSON) UnmarshalText(text []byte) error { 118 text = bytes.TrimPrefix(text, []byte("0x")) 119 if len(text) > 64 { 120 return fmt.Errorf("too many hex characters in storage key/value %q", text) 121 } 122 offset := len(h) - len(text)/2 // pad on the left 123 if _, err := hex.Decode(h[offset:], text); err != nil { 124 fmt.Println(err) 125 return fmt.Errorf("invalid hex storage key/value %q", text) 126 } 127 return nil 128} 129 130func (h storageJSON) MarshalText() ([]byte, error) { 131 return hexutil.Bytes(h[:]).MarshalText() 132} 133 134// GenesisMismatchError is raised when trying to overwrite an existing 135// genesis block with an incompatible one. 136type GenesisMismatchError struct { 137 Stored, New common.Hash 138} 139 140func (e *GenesisMismatchError) Error() string { 141 return fmt.Sprintf("database contains incompatible genesis (have %x, new %x)", e.Stored, e.New) 142} 143 144// SetupGenesisBlock writes or updates the genesis block in db. 145// The block that will be used is: 146// 147// genesis == nil genesis != nil 148// +------------------------------------------ 149// db has no genesis | main-net default | genesis 150// db has genesis | from DB | genesis (if compatible) 151// 152// The stored chain configuration will be updated if it is compatible (i.e. does not 153// specify a fork block below the local head block). In case of a conflict, the 154// error is a *params.ConfigCompatError and the new, unwritten config is returned. 155// 156// The returned chain configuration is never nil. 157func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig, common.Hash, error) { 158 return SetupGenesisBlockWithOverride(db, genesis, nil, nil) 159} 160 161func SetupGenesisBlockWithOverride(db ethdb.Database, genesis *Genesis, overrideArrowGlacier, overrideTerminalTotalDifficulty *big.Int) (*params.ChainConfig, common.Hash, error) { 162 if genesis != nil && genesis.Config == nil { 163 return params.AllEthashProtocolChanges, common.Hash{}, errGenesisNoConfig 164 } 165 // Just commit the new block if there is no stored genesis block. 166 stored := rawdb.ReadCanonicalHash(db, 0) 167 if (stored == common.Hash{}) { 168 if genesis == nil { 169 log.Info("Writing default main-net genesis block") 170 genesis = DefaultGenesisBlock() 171 } else { 172 log.Info("Writing custom genesis block") 173 } 174 block, err := genesis.Commit(db) 175 if err != nil { 176 return genesis.Config, common.Hash{}, err 177 } 178 return genesis.Config, block.Hash(), nil 179 } 180 // We have the genesis block in database(perhaps in ancient database) 181 // but the corresponding state is missing. 182 header := rawdb.ReadHeader(db, stored, 0) 183 if _, err := state.New(header.Root, state.NewDatabaseWithConfig(db, nil), nil); err != nil { 184 if genesis == nil { 185 genesis = DefaultGenesisBlock() 186 } 187 // Ensure the stored genesis matches with the given one. 188 hash := genesis.ToBlock(nil).Hash() 189 if hash != stored { 190 return genesis.Config, hash, &GenesisMismatchError{stored, hash} 191 } 192 block, err := genesis.Commit(db) 193 if err != nil { 194 return genesis.Config, hash, err 195 } 196 return genesis.Config, block.Hash(), nil 197 } 198 // Check whether the genesis block is already written. 199 if genesis != nil { 200 hash := genesis.ToBlock(nil).Hash() 201 if hash != stored { 202 return genesis.Config, hash, &GenesisMismatchError{stored, hash} 203 } 204 } 205 // Get the existing chain configuration. 206 newcfg := genesis.configOrDefault(stored) 207 if overrideArrowGlacier != nil { 208 newcfg.ArrowGlacierBlock = overrideArrowGlacier 209 } 210 if overrideTerminalTotalDifficulty != nil { 211 newcfg.TerminalTotalDifficulty = overrideTerminalTotalDifficulty 212 } 213 if err := newcfg.CheckConfigForkOrder(); err != nil { 214 return newcfg, common.Hash{}, err 215 } 216 storedcfg := rawdb.ReadChainConfig(db, stored) 217 if storedcfg == nil { 218 log.Warn("Found genesis block without chain config") 219 rawdb.WriteChainConfig(db, stored, newcfg) 220 return newcfg, stored, nil 221 } 222 // Special case: don't change the existing config of a non-mainnet chain if no new 223 // config is supplied. These chains would get AllProtocolChanges (and a compat error) 224 // if we just continued here. 225 if genesis == nil && stored != params.MainnetGenesisHash { 226 return storedcfg, stored, nil 227 } 228 // Check config compatibility and write the config. Compatibility errors 229 // are returned to the caller unless we're already at block zero. 230 height := rawdb.ReadHeaderNumber(db, rawdb.ReadHeadHeaderHash(db)) 231 if height == nil { 232 return newcfg, stored, fmt.Errorf("missing block number for head header hash") 233 } 234 compatErr := storedcfg.CheckCompatible(newcfg, *height) 235 if compatErr != nil && *height != 0 && compatErr.RewindTo != 0 { 236 return newcfg, stored, compatErr 237 } 238 rawdb.WriteChainConfig(db, stored, newcfg) 239 return newcfg, stored, nil 240} 241 242func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig { 243 switch { 244 case g != nil: 245 return g.Config 246 case ghash == params.MainnetGenesisHash: 247 return params.MainnetChainConfig 248 case ghash == params.RopstenGenesisHash: 249 return params.RopstenChainConfig 250 case ghash == params.SepoliaGenesisHash: 251 return params.SepoliaChainConfig 252 case ghash == params.RinkebyGenesisHash: 253 return params.RinkebyChainConfig 254 case ghash == params.GoerliGenesisHash: 255 return params.GoerliChainConfig 256 default: 257 return params.AllEthashProtocolChanges 258 } 259} 260 261// ToBlock creates the genesis block and writes state of a genesis specification 262// to the given database (or discards it if nil). 263func (g *Genesis) ToBlock(db ethdb.Database) *types.Block { 264 if db == nil { 265 db = rawdb.NewMemoryDatabase() 266 } 267 statedb, err := state.New(common.Hash{}, state.NewDatabase(db), nil) 268 if err != nil { 269 panic(err) 270 } 271 for addr, account := range g.Alloc { 272 statedb.AddBalance(addr, account.Balance) 273 statedb.SetCode(addr, account.Code) 274 statedb.SetNonce(addr, account.Nonce) 275 for key, value := range account.Storage { 276 statedb.SetState(addr, key, value) 277 } 278 } 279 root := statedb.IntermediateRoot(false) 280 head := &types.Header{ 281 Number: new(big.Int).SetUint64(g.Number), 282 Nonce: types.EncodeNonce(g.Nonce), 283 Time: g.Timestamp, 284 ParentHash: g.ParentHash, 285 Extra: g.ExtraData, 286 GasLimit: g.GasLimit, 287 GasUsed: g.GasUsed, 288 BaseFee: g.BaseFee, 289 Difficulty: g.Difficulty, 290 MixDigest: g.Mixhash, 291 Coinbase: g.Coinbase, 292 Root: root, 293 } 294 if g.GasLimit == 0 { 295 head.GasLimit = params.GenesisGasLimit 296 } 297 if g.Difficulty == nil { 298 head.Difficulty = params.GenesisDifficulty 299 } 300 if g.Config != nil && g.Config.IsLondon(common.Big0) { 301 if g.BaseFee != nil { 302 head.BaseFee = g.BaseFee 303 } else { 304 head.BaseFee = new(big.Int).SetUint64(params.InitialBaseFee) 305 } 306 } 307 statedb.Commit(false) 308 statedb.Database().TrieDB().Commit(root, true, nil) 309 310 return types.NewBlock(head, nil, nil, nil, trie.NewStackTrie(nil)) 311} 312 313// Commit writes the block and state of a genesis specification to the database. 314// The block is committed as the canonical head block. 315func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error) { 316 block := g.ToBlock(db) 317 if block.Number().Sign() != 0 { 318 return nil, errors.New("can't commit genesis block with number > 0") 319 } 320 config := g.Config 321 if config == nil { 322 config = params.AllEthashProtocolChanges 323 } 324 if err := config.CheckConfigForkOrder(); err != nil { 325 return nil, err 326 } 327 if config.Clique != nil && len(block.Extra()) == 0 { 328 return nil, errors.New("can't start clique chain without signers") 329 } 330 rawdb.WriteTd(db, block.Hash(), block.NumberU64(), block.Difficulty()) 331 rawdb.WriteBlock(db, block) 332 rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil) 333 rawdb.WriteCanonicalHash(db, block.Hash(), block.NumberU64()) 334 rawdb.WriteHeadBlockHash(db, block.Hash()) 335 rawdb.WriteHeadFastBlockHash(db, block.Hash()) 336 rawdb.WriteHeadHeaderHash(db, block.Hash()) 337 rawdb.WriteChainConfig(db, block.Hash(), config) 338 return block, nil 339} 340 341// MustCommit writes the genesis block and state to db, panicking on error. 342// The block is committed as the canonical head block. 343func (g *Genesis) MustCommit(db ethdb.Database) *types.Block { 344 block, err := g.Commit(db) 345 if err != nil { 346 panic(err) 347 } 348 return block 349} 350 351// GenesisBlockForTesting creates and writes a block in which addr has the given wei balance. 352func GenesisBlockForTesting(db ethdb.Database, addr common.Address, balance *big.Int) *types.Block { 353 g := Genesis{ 354 Alloc: GenesisAlloc{addr: {Balance: balance}}, 355 BaseFee: big.NewInt(params.InitialBaseFee), 356 } 357 return g.MustCommit(db) 358} 359 360// DefaultGenesisBlock returns the Ethereum main net genesis block. 361func DefaultGenesisBlock() *Genesis { 362 return &Genesis{ 363 Config: params.MainnetChainConfig, 364 Nonce: 66, 365 ExtraData: hexutil.MustDecode("0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa"), 366 GasLimit: 5000, 367 Difficulty: big.NewInt(17179869184), 368 Alloc: decodePrealloc(mainnetAllocData), 369 } 370} 371 372// DefaultRopstenGenesisBlock returns the Ropsten network genesis block. 373func DefaultRopstenGenesisBlock() *Genesis { 374 return &Genesis{ 375 Config: params.RopstenChainConfig, 376 Nonce: 66, 377 ExtraData: hexutil.MustDecode("0x3535353535353535353535353535353535353535353535353535353535353535"), 378 GasLimit: 16777216, 379 Difficulty: big.NewInt(1048576), 380 Alloc: decodePrealloc(ropstenAllocData), 381 } 382} 383 384// DefaultRinkebyGenesisBlock returns the Rinkeby network genesis block. 385func DefaultRinkebyGenesisBlock() *Genesis { 386 return &Genesis{ 387 Config: params.RinkebyChainConfig, 388 Timestamp: 1492009146, 389 ExtraData: hexutil.MustDecode("0x52657370656374206d7920617574686f7269746168207e452e436172746d616e42eb768f2244c8811c63729a21a3569731535f067ffc57839b00206d1ad20c69a1981b489f772031b279182d99e65703f0076e4812653aab85fca0f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), 390 GasLimit: 4700000, 391 Difficulty: big.NewInt(1), 392 Alloc: decodePrealloc(rinkebyAllocData), 393 } 394} 395 396// DefaultGoerliGenesisBlock returns the Görli network genesis block. 397func DefaultGoerliGenesisBlock() *Genesis { 398 return &Genesis{ 399 Config: params.GoerliChainConfig, 400 Timestamp: 1548854791, 401 ExtraData: hexutil.MustDecode("0x22466c6578692069732061207468696e6722202d204166726900000000000000e0a2bd4258d2768837baa26a28fe71dc079f84c70000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), 402 GasLimit: 10485760, 403 Difficulty: big.NewInt(1), 404 Alloc: decodePrealloc(goerliAllocData), 405 } 406} 407 408// DefaultSepoliaGenesisBlock returns the Sepolia network genesis block. 409func DefaultSepoliaGenesisBlock() *Genesis { 410 return &Genesis{ 411 Config: params.SepoliaChainConfig, 412 Nonce: 0, 413 ExtraData: []byte("Sepolia, Athens, Attica, Greece!"), 414 GasLimit: 0x1c9c380, 415 Difficulty: big.NewInt(0x20000), 416 Timestamp: 1633267481, 417 Alloc: decodePrealloc(sepoliaAllocData), 418 } 419} 420 421// DeveloperGenesisBlock returns the 'geth --dev' genesis block. 422func DeveloperGenesisBlock(period uint64, gasLimit uint64, faucet common.Address) *Genesis { 423 // Override the default period to the user requested one 424 config := *params.AllCliqueProtocolChanges 425 config.Clique = ¶ms.CliqueConfig{ 426 Period: period, 427 Epoch: config.Clique.Epoch, 428 } 429 430 // Assemble and return the genesis with the precompiles and faucet pre-funded 431 return &Genesis{ 432 Config: &config, 433 ExtraData: append(append(make([]byte, 32), faucet[:]...), make([]byte, crypto.SignatureLength)...), 434 GasLimit: gasLimit, 435 BaseFee: big.NewInt(params.InitialBaseFee), 436 Difficulty: big.NewInt(1), 437 Alloc: map[common.Address]GenesisAccount{ 438 common.BytesToAddress([]byte{1}): {Balance: big.NewInt(1)}, // ECRecover 439 common.BytesToAddress([]byte{2}): {Balance: big.NewInt(1)}, // SHA256 440 common.BytesToAddress([]byte{3}): {Balance: big.NewInt(1)}, // RIPEMD 441 common.BytesToAddress([]byte{4}): {Balance: big.NewInt(1)}, // Identity 442 common.BytesToAddress([]byte{5}): {Balance: big.NewInt(1)}, // ModExp 443 common.BytesToAddress([]byte{6}): {Balance: big.NewInt(1)}, // ECAdd 444 common.BytesToAddress([]byte{7}): {Balance: big.NewInt(1)}, // ECScalarMul 445 common.BytesToAddress([]byte{8}): {Balance: big.NewInt(1)}, // ECPairing 446 common.BytesToAddress([]byte{9}): {Balance: big.NewInt(1)}, // BLAKE2b 447 faucet: {Balance: new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(9))}, 448 }, 449 } 450} 451 452func decodePrealloc(data string) GenesisAlloc { 453 var p []struct{ Addr, Balance *big.Int } 454 if err := rlp.NewStream(strings.NewReader(data), 0).Decode(&p); err != nil { 455 panic(err) 456 } 457 ga := make(GenesisAlloc, len(p)) 458 for _, account := range p { 459 ga[common.BigToAddress(account.Addr)] = GenesisAccount{Balance: account.Balance} 460 } 461 return ga 462} 463