github.com/snowblossomcoin/go-ethereum@v1.9.25/core/genesis.go (about) 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 17 package core 18 19 import ( 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 45 var 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. 49 type 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 } 66 67 // GenesisAlloc specifies the initial state that is part of the genesis block. 68 type GenesisAlloc map[common.Address]GenesisAccount 69 70 func (ga *GenesisAlloc) UnmarshalJSON(data []byte) error { 71 m := make(map[common.UnprefixedAddress]GenesisAccount) 72 if err := json.Unmarshal(data, &m); err != nil { 73 return err 74 } 75 *ga = make(GenesisAlloc) 76 for addr, a := range m { 77 (*ga)[common.Address(addr)] = a 78 } 79 return nil 80 } 81 82 // GenesisAccount is an account in the state of the genesis block. 83 type GenesisAccount struct { 84 Code []byte `json:"code,omitempty"` 85 Storage map[common.Hash]common.Hash `json:"storage,omitempty"` 86 Balance *big.Int `json:"balance" gencodec:"required"` 87 Nonce uint64 `json:"nonce,omitempty"` 88 PrivateKey []byte `json:"secretKey,omitempty"` // for tests 89 } 90 91 // field type overrides for gencodec 92 type genesisSpecMarshaling struct { 93 Nonce math.HexOrDecimal64 94 Timestamp math.HexOrDecimal64 95 ExtraData hexutil.Bytes 96 GasLimit math.HexOrDecimal64 97 GasUsed math.HexOrDecimal64 98 Number math.HexOrDecimal64 99 Difficulty *math.HexOrDecimal256 100 Alloc map[common.UnprefixedAddress]GenesisAccount 101 } 102 103 type genesisAccountMarshaling struct { 104 Code hexutil.Bytes 105 Balance *math.HexOrDecimal256 106 Nonce math.HexOrDecimal64 107 Storage map[storageJSON]storageJSON 108 PrivateKey hexutil.Bytes 109 } 110 111 // storageJSON represents a 256 bit byte array, but allows less than 256 bits when 112 // unmarshaling from hex. 113 type storageJSON common.Hash 114 115 func (h *storageJSON) UnmarshalText(text []byte) error { 116 text = bytes.TrimPrefix(text, []byte("0x")) 117 if len(text) > 64 { 118 return fmt.Errorf("too many hex characters in storage key/value %q", text) 119 } 120 offset := len(h) - len(text)/2 // pad on the left 121 if _, err := hex.Decode(h[offset:], text); err != nil { 122 fmt.Println(err) 123 return fmt.Errorf("invalid hex storage key/value %q", text) 124 } 125 return nil 126 } 127 128 func (h storageJSON) MarshalText() ([]byte, error) { 129 return hexutil.Bytes(h[:]).MarshalText() 130 } 131 132 // GenesisMismatchError is raised when trying to overwrite an existing 133 // genesis block with an incompatible one. 134 type GenesisMismatchError struct { 135 Stored, New common.Hash 136 } 137 138 func (e *GenesisMismatchError) Error() string { 139 return fmt.Sprintf("database contains incompatible genesis (have %x, new %x)", e.Stored, e.New) 140 } 141 142 // SetupGenesisBlock writes or updates the genesis block in db. 143 // The block that will be used is: 144 // 145 // genesis == nil genesis != nil 146 // +------------------------------------------ 147 // db has no genesis | main-net default | genesis 148 // db has genesis | from DB | genesis (if compatible) 149 // 150 // The stored chain configuration will be updated if it is compatible (i.e. does not 151 // specify a fork block below the local head block). In case of a conflict, the 152 // error is a *params.ConfigCompatError and the new, unwritten config is returned. 153 // 154 // The returned chain configuration is never nil. 155 func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig, common.Hash, error) { 156 if genesis != nil && genesis.Config == nil { 157 return params.AllEthashProtocolChanges, common.Hash{}, errGenesisNoConfig 158 } 159 // Just commit the new block if there is no stored genesis block. 160 stored := rawdb.ReadCanonicalHash(db, 0) 161 if (stored == common.Hash{}) { 162 if genesis == nil { 163 log.Info("Writing default main-net genesis block") 164 genesis = DefaultGenesisBlock() 165 } else { 166 log.Info("Writing custom genesis block") 167 } 168 block, err := genesis.Commit(db) 169 if err != nil { 170 return genesis.Config, common.Hash{}, err 171 } 172 return genesis.Config, block.Hash(), nil 173 } 174 175 // We have the genesis block in database(perhaps in ancient database) 176 // but the corresponding state is missing. 177 header := rawdb.ReadHeader(db, stored, 0) 178 if _, err := state.New(header.Root, state.NewDatabaseWithCache(db, 0, ""), nil); err != nil { 179 if genesis == nil { 180 genesis = DefaultGenesisBlock() 181 } 182 // Ensure the stored genesis matches with the given one. 183 hash := genesis.ToBlock(nil).Hash() 184 if hash != stored { 185 return genesis.Config, hash, &GenesisMismatchError{stored, hash} 186 } 187 block, err := genesis.Commit(db) 188 if err != nil { 189 return genesis.Config, hash, err 190 } 191 return genesis.Config, block.Hash(), nil 192 } 193 194 // Check whether the genesis block is already written. 195 if genesis != nil { 196 hash := genesis.ToBlock(nil).Hash() 197 if hash != stored { 198 return genesis.Config, hash, &GenesisMismatchError{stored, hash} 199 } 200 } 201 202 // Get the existing chain configuration. 203 newcfg := genesis.configOrDefault(stored) 204 if err := newcfg.CheckConfigForkOrder(); err != nil { 205 return newcfg, common.Hash{}, err 206 } 207 storedcfg := rawdb.ReadChainConfig(db, stored) 208 if storedcfg == nil { 209 log.Warn("Found genesis block without chain config") 210 rawdb.WriteChainConfig(db, stored, newcfg) 211 return newcfg, stored, nil 212 } 213 // Special case: don't change the existing config of a non-mainnet chain if no new 214 // config is supplied. These chains would get AllProtocolChanges (and a compat error) 215 // if we just continued here. 216 if genesis == nil && stored != params.MainnetGenesisHash { 217 return storedcfg, stored, nil 218 } 219 220 // Check config compatibility and write the config. Compatibility errors 221 // are returned to the caller unless we're already at block zero. 222 height := rawdb.ReadHeaderNumber(db, rawdb.ReadHeadHeaderHash(db)) 223 if height == nil { 224 return newcfg, stored, fmt.Errorf("missing block number for head header hash") 225 } 226 compatErr := storedcfg.CheckCompatible(newcfg, *height) 227 if compatErr != nil && *height != 0 && compatErr.RewindTo != 0 { 228 return newcfg, stored, compatErr 229 } 230 rawdb.WriteChainConfig(db, stored, newcfg) 231 return newcfg, stored, nil 232 } 233 234 func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig { 235 switch { 236 case g != nil: 237 return g.Config 238 case ghash == params.MainnetGenesisHash: 239 return params.MainnetChainConfig 240 case ghash == params.RopstenGenesisHash: 241 return params.RopstenChainConfig 242 case ghash == params.RinkebyGenesisHash: 243 return params.RinkebyChainConfig 244 case ghash == params.GoerliGenesisHash: 245 return params.GoerliChainConfig 246 case ghash == params.YoloV2GenesisHash: 247 return params.YoloV2ChainConfig 248 default: 249 return params.AllEthashProtocolChanges 250 } 251 } 252 253 // ToBlock creates the genesis block and writes state of a genesis specification 254 // to the given database (or discards it if nil). 255 func (g *Genesis) ToBlock(db ethdb.Database) *types.Block { 256 if db == nil { 257 db = rawdb.NewMemoryDatabase() 258 } 259 statedb, _ := state.New(common.Hash{}, state.NewDatabase(db), nil) 260 for addr, account := range g.Alloc { 261 statedb.AddBalance(addr, account.Balance) 262 statedb.SetCode(addr, account.Code) 263 statedb.SetNonce(addr, account.Nonce) 264 for key, value := range account.Storage { 265 statedb.SetState(addr, key, value) 266 } 267 } 268 root := statedb.IntermediateRoot(false) 269 head := &types.Header{ 270 Number: new(big.Int).SetUint64(g.Number), 271 Nonce: types.EncodeNonce(g.Nonce), 272 Time: g.Timestamp, 273 ParentHash: g.ParentHash, 274 Extra: g.ExtraData, 275 GasLimit: g.GasLimit, 276 GasUsed: g.GasUsed, 277 Difficulty: g.Difficulty, 278 MixDigest: g.Mixhash, 279 Coinbase: g.Coinbase, 280 Root: root, 281 } 282 if g.GasLimit == 0 { 283 head.GasLimit = params.GenesisGasLimit 284 } 285 if g.Difficulty == nil { 286 head.Difficulty = params.GenesisDifficulty 287 } 288 statedb.Commit(false) 289 statedb.Database().TrieDB().Commit(root, true, nil) 290 291 return types.NewBlock(head, nil, nil, nil, new(trie.Trie)) 292 } 293 294 // Commit writes the block and state of a genesis specification to the database. 295 // The block is committed as the canonical head block. 296 func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error) { 297 block := g.ToBlock(db) 298 if block.Number().Sign() != 0 { 299 return nil, fmt.Errorf("can't commit genesis block with number > 0") 300 } 301 config := g.Config 302 if config == nil { 303 config = params.AllEthashProtocolChanges 304 } 305 if err := config.CheckConfigForkOrder(); err != nil { 306 return nil, err 307 } 308 rawdb.WriteTd(db, block.Hash(), block.NumberU64(), g.Difficulty) 309 rawdb.WriteBlock(db, block) 310 rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil) 311 rawdb.WriteCanonicalHash(db, block.Hash(), block.NumberU64()) 312 rawdb.WriteHeadBlockHash(db, block.Hash()) 313 rawdb.WriteHeadFastBlockHash(db, block.Hash()) 314 rawdb.WriteHeadHeaderHash(db, block.Hash()) 315 rawdb.WriteChainConfig(db, block.Hash(), config) 316 return block, nil 317 } 318 319 // MustCommit writes the genesis block and state to db, panicking on error. 320 // The block is committed as the canonical head block. 321 func (g *Genesis) MustCommit(db ethdb.Database) *types.Block { 322 block, err := g.Commit(db) 323 if err != nil { 324 panic(err) 325 } 326 return block 327 } 328 329 // GenesisBlockForTesting creates and writes a block in which addr has the given wei balance. 330 func GenesisBlockForTesting(db ethdb.Database, addr common.Address, balance *big.Int) *types.Block { 331 g := Genesis{Alloc: GenesisAlloc{addr: {Balance: balance}}} 332 return g.MustCommit(db) 333 } 334 335 // DefaultGenesisBlock returns the Ethereum main net genesis block. 336 func DefaultGenesisBlock() *Genesis { 337 return &Genesis{ 338 Config: params.MainnetChainConfig, 339 Nonce: 66, 340 ExtraData: hexutil.MustDecode("0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa"), 341 GasLimit: 5000, 342 Difficulty: big.NewInt(17179869184), 343 Alloc: decodePrealloc(mainnetAllocData), 344 } 345 } 346 347 // DefaultRopstenGenesisBlock returns the Ropsten network genesis block. 348 func DefaultRopstenGenesisBlock() *Genesis { 349 return &Genesis{ 350 Config: params.RopstenChainConfig, 351 Nonce: 66, 352 ExtraData: hexutil.MustDecode("0x3535353535353535353535353535353535353535353535353535353535353535"), 353 GasLimit: 16777216, 354 Difficulty: big.NewInt(1048576), 355 Alloc: decodePrealloc(ropstenAllocData), 356 } 357 } 358 359 // DefaultRinkebyGenesisBlock returns the Rinkeby network genesis block. 360 func DefaultRinkebyGenesisBlock() *Genesis { 361 return &Genesis{ 362 Config: params.RinkebyChainConfig, 363 Timestamp: 1492009146, 364 ExtraData: hexutil.MustDecode("0x52657370656374206d7920617574686f7269746168207e452e436172746d616e42eb768f2244c8811c63729a21a3569731535f067ffc57839b00206d1ad20c69a1981b489f772031b279182d99e65703f0076e4812653aab85fca0f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), 365 GasLimit: 4700000, 366 Difficulty: big.NewInt(1), 367 Alloc: decodePrealloc(rinkebyAllocData), 368 } 369 } 370 371 // DefaultGoerliGenesisBlock returns the Görli network genesis block. 372 func DefaultGoerliGenesisBlock() *Genesis { 373 return &Genesis{ 374 Config: params.GoerliChainConfig, 375 Timestamp: 1548854791, 376 ExtraData: hexutil.MustDecode("0x22466c6578692069732061207468696e6722202d204166726900000000000000e0a2bd4258d2768837baa26a28fe71dc079f84c70000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), 377 GasLimit: 10485760, 378 Difficulty: big.NewInt(1), 379 Alloc: decodePrealloc(goerliAllocData), 380 } 381 } 382 383 func DefaultYoloV2GenesisBlock() *Genesis { 384 // TODO: Update with yolov2 values + regenerate alloc data 385 return &Genesis{ 386 Config: params.YoloV2ChainConfig, 387 Timestamp: 0x5f91b932, 388 ExtraData: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000000000000000000008a37866fd3627c9205a37c8685666f32ec07bb1b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), 389 GasLimit: 0x47b760, 390 Difficulty: big.NewInt(1), 391 Alloc: decodePrealloc(yoloV1AllocData), 392 } 393 } 394 395 // DeveloperGenesisBlock returns the 'geth --dev' genesis block. 396 func DeveloperGenesisBlock(period uint64, faucet common.Address) *Genesis { 397 // Override the default period to the user requested one 398 config := *params.AllCliqueProtocolChanges 399 config.Clique.Period = period 400 401 // Assemble and return the genesis with the precompiles and faucet pre-funded 402 return &Genesis{ 403 Config: &config, 404 ExtraData: append(append(make([]byte, 32), faucet[:]...), make([]byte, crypto.SignatureLength)...), 405 GasLimit: 11500000, 406 Difficulty: big.NewInt(1), 407 Alloc: map[common.Address]GenesisAccount{ 408 common.BytesToAddress([]byte{1}): {Balance: big.NewInt(1)}, // ECRecover 409 common.BytesToAddress([]byte{2}): {Balance: big.NewInt(1)}, // SHA256 410 common.BytesToAddress([]byte{3}): {Balance: big.NewInt(1)}, // RIPEMD 411 common.BytesToAddress([]byte{4}): {Balance: big.NewInt(1)}, // Identity 412 common.BytesToAddress([]byte{5}): {Balance: big.NewInt(1)}, // ModExp 413 common.BytesToAddress([]byte{6}): {Balance: big.NewInt(1)}, // ECAdd 414 common.BytesToAddress([]byte{7}): {Balance: big.NewInt(1)}, // ECScalarMul 415 common.BytesToAddress([]byte{8}): {Balance: big.NewInt(1)}, // ECPairing 416 common.BytesToAddress([]byte{9}): {Balance: big.NewInt(1)}, // BLAKE2b 417 faucet: {Balance: new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(9))}, 418 }, 419 } 420 } 421 422 func decodePrealloc(data string) GenesisAlloc { 423 var p []struct{ Addr, Balance *big.Int } 424 if err := rlp.NewStream(strings.NewReader(data), 0).Decode(&p); err != nil { 425 panic(err) 426 } 427 ga := make(GenesisAlloc, len(p)) 428 for _, account := range p { 429 ga[common.BigToAddress(account.Addr)] = GenesisAccount{Balance: account.Balance} 430 } 431 return ga 432 }