// Copyright 2014 The go-ethereum Authors // This file is part of the go-ethereum library. // // The go-ethereum library is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // The go-ethereum library 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 Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . package core import ( "bytes" "encoding/hex" "encoding/json" "errors" "fmt" "math/big" "reflect" "regexp" "strings" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/systemcontracts" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" ) //go:generate go run github.com/fjl/gencodec -type Genesis -field-override genesisSpecMarshaling -out gen_genesis.go //go:generate go run github.com/fjl/gencodec -type GenesisAccount -field-override genesisAccountMarshaling -out gen_genesis_account.go var errGenesisNoConfig = errors.New("genesis has no chain configuration") // Genesis specifies the header fields, state of a genesis block. It also defines hard // fork switch-over blocks through the chain configuration. type Genesis struct { Config *params.ChainConfig `json:"config"` Nonce uint64 `json:"nonce"` Timestamp uint64 `json:"timestamp"` ExtraData []byte `json:"extraData"` GasLimit uint64 `json:"gasLimit" gencodec:"required"` Difficulty *big.Int `json:"difficulty" gencodec:"required"` Mixhash common.Hash `json:"mixHash"` Coinbase common.Address `json:"coinbase"` Alloc GenesisAlloc `json:"alloc" gencodec:"required"` // These fields are used for consensus tests. Please don't use them // in actual genesis blocks. Number uint64 `json:"number"` GasUsed uint64 `json:"gasUsed"` ParentHash common.Hash `json:"parentHash"` BaseFee *big.Int `json:"baseFeePerGas"` // EIP-1559 ExcessBlobGas *uint64 `json:"excessBlobGas,omitempty" toml:",omitempty"` // EIP-4844, TODO(Nathan): remove tag `omitempty` after cancun fork BlobGasUsed *uint64 `json:"blobGasUsed,omitempty" toml:",omitempty"` // EIP-4844, TODO(Nathan): remove tag `omitempty` after cancun fork } func ReadGenesis(db ethdb.Database) (*Genesis, error) { var genesis Genesis stored := rawdb.ReadCanonicalHash(db, 0) if (stored == common.Hash{}) { return nil, fmt.Errorf("invalid genesis hash in database: %x", stored) } blob := rawdb.ReadGenesisStateSpec(db, stored) if blob == nil { return nil, errors.New("genesis state missing from db") } if len(blob) != 0 { if err := genesis.Alloc.UnmarshalJSON(blob); err != nil { return nil, fmt.Errorf("could not unmarshal genesis state json: %s", err) } } genesis.Config = rawdb.ReadChainConfig(db, stored) if genesis.Config == nil { return nil, errors.New("genesis config missing from db") } genesisBlock := rawdb.ReadBlock(db, stored, 0) if genesisBlock == nil { return nil, errors.New("genesis block missing from db") } genesisHeader := genesisBlock.Header() genesis.Nonce = genesisHeader.Nonce.Uint64() genesis.Timestamp = genesisHeader.Time genesis.ExtraData = genesisHeader.Extra genesis.GasLimit = genesisHeader.GasLimit genesis.Difficulty = genesisHeader.Difficulty genesis.Mixhash = genesisHeader.MixDigest genesis.Coinbase = genesisHeader.Coinbase genesis.BaseFee = genesisHeader.BaseFee genesis.ExcessBlobGas = genesisHeader.ExcessBlobGas genesis.BlobGasUsed = genesisHeader.BlobGasUsed return &genesis, nil } // GenesisAlloc specifies the initial state that is part of the genesis block. type GenesisAlloc map[common.Address]GenesisAccount func (ga *GenesisAlloc) UnmarshalJSON(data []byte) error { m := make(map[common.UnprefixedAddress]GenesisAccount) if err := json.Unmarshal(data, &m); err != nil { return err } *ga = make(GenesisAlloc) for addr, a := range m { (*ga)[common.Address(addr)] = a } return nil } // deriveHash computes the state root according to the genesis specification. func (ga *GenesisAlloc) deriveHash() (common.Hash, error) { // Create an ephemeral in-memory database for computing hash, // all the derived states will be discarded to not pollute disk. db := state.NewDatabase(rawdb.NewMemoryDatabase()) statedb, err := state.New(types.EmptyRootHash, db, nil) if err != nil { return common.Hash{}, err } for addr, account := range *ga { statedb.AddBalance(addr, account.Balance) statedb.SetCode(addr, account.Code) statedb.SetNonce(addr, account.Nonce) for key, value := range account.Storage { statedb.SetState(addr, key, value) } } statedb.IntermediateRoot(false) root, _, err := statedb.Commit(0, nil) return root, err } // flush is very similar with deriveHash, but the main difference is // all the generated states will be persisted into the given database. // Also, the genesis state specification will be flushed as well. func (ga *GenesisAlloc) flush(db ethdb.Database, triedb *trie.Database, blockhash common.Hash) error { trieConfig := triedb.Config() if trieConfig != nil { trieConfig.NoTries = false } statedb, err := state.New(types.EmptyRootHash, state.NewDatabaseWithNodeDB(db, triedb), nil) if err != nil { return err } for addr, account := range *ga { statedb.AddBalance(addr, account.Balance) statedb.SetCode(addr, account.Code) statedb.SetNonce(addr, account.Nonce) for key, value := range account.Storage { statedb.SetState(addr, key, value) } } statedb.IntermediateRoot(false) root, _, err := statedb.Commit(0, nil) if err != nil { return err } // Commit newly generated states into disk if it's not empty. if root != types.EmptyRootHash { if err := triedb.Commit(root, true); err != nil { return err } } // Marshal the genesis state specification and persist. blob, err := json.Marshal(ga) if err != nil { return err } rawdb.WriteGenesisStateSpec(db, blockhash, blob) return nil } // CommitGenesisState loads the stored genesis state with the given block // hash and commits it into the provided trie database. func CommitGenesisState(db ethdb.Database, triedb *trie.Database, blockhash common.Hash) error { var alloc GenesisAlloc blob := rawdb.ReadGenesisStateSpec(db, blockhash) if len(blob) != 0 { if err := alloc.UnmarshalJSON(blob); err != nil { return err } } else { // Genesis allocation is missing and there are several possibilities: // the node is legacy which doesn't persist the genesis allocation or // the persisted allocation is just lost. // - supported networks(mainnet, testnets), recover with defined allocations // - private network, can't recover var genesis *Genesis switch blockhash { case params.BSCGenesisHash: genesis = DefaultBSCGenesisBlock() } if genesis != nil { alloc = genesis.Alloc } else { return errors.New("not found") } } return alloc.flush(db, triedb, blockhash) } // GenesisAccount is an account in the state of the genesis block. type GenesisAccount struct { Code []byte `json:"code,omitempty"` Storage map[common.Hash]common.Hash `json:"storage,omitempty"` Balance *big.Int `json:"balance" gencodec:"required"` Nonce uint64 `json:"nonce,omitempty"` PrivateKey []byte `json:"secretKey,omitempty"` // for tests } // field type overrides for gencodec type genesisSpecMarshaling struct { Nonce math.HexOrDecimal64 Timestamp math.HexOrDecimal64 ExtraData hexutil.Bytes GasLimit math.HexOrDecimal64 GasUsed math.HexOrDecimal64 Number math.HexOrDecimal64 Difficulty *math.HexOrDecimal256 Alloc map[common.UnprefixedAddress]GenesisAccount BaseFee *math.HexOrDecimal256 ExcessBlobGas *math.HexOrDecimal64 BlobGasUsed *math.HexOrDecimal64 } type genesisAccountMarshaling struct { Code hexutil.Bytes Balance *math.HexOrDecimal256 Nonce math.HexOrDecimal64 Storage map[storageJSON]storageJSON PrivateKey hexutil.Bytes } // storageJSON represents a 256 bit byte array, but allows less than 256 bits when // unmarshaling from hex. type storageJSON common.Hash func (h *storageJSON) UnmarshalText(text []byte) error { text = bytes.TrimPrefix(text, []byte("0x")) if len(text) > 64 { return fmt.Errorf("too many hex characters in storage key/value %q", text) } offset := len(h) - len(text)/2 // pad on the left if _, err := hex.Decode(h[offset:], text); err != nil { return fmt.Errorf("invalid hex storage key/value %q", text) } return nil } func (h storageJSON) MarshalText() ([]byte, error) { return hexutil.Bytes(h[:]).MarshalText() } // GenesisMismatchError is raised when trying to overwrite an existing // genesis block with an incompatible one. type GenesisMismatchError struct { Stored, New common.Hash } func (e *GenesisMismatchError) Error() string { return fmt.Sprintf("database contains incompatible genesis (have %x, new %x)", e.Stored, e.New) } // ChainOverrides contains the changes to chain config. type ChainOverrides struct { OverrideCancun *uint64 OverrideVerkle *uint64 } // SetupGenesisBlock writes or updates the genesis block in db. // The block that will be used is: // // genesis == nil genesis != nil // +------------------------------------------ // db has no genesis | main-net default | genesis // db has genesis | from DB | genesis (if compatible) // // The stored chain configuration will be updated if it is compatible (i.e. does not // specify a fork block below the local head block). In case of a conflict, the // error is a *params.ConfigCompatError and the new, unwritten config is returned. // // The returned chain configuration is never nil. func SetupGenesisBlock(db ethdb.Database, triedb *trie.Database, genesis *Genesis) (*params.ChainConfig, common.Hash, error) { return SetupGenesisBlockWithOverride(db, triedb, genesis, nil) } func SetupGenesisBlockWithOverride(db ethdb.Database, triedb *trie.Database, genesis *Genesis, overrides *ChainOverrides) (*params.ChainConfig, common.Hash, error) { if genesis != nil && genesis.Config == nil { return params.AllEthashProtocolChanges, common.Hash{}, errGenesisNoConfig } applyOverrides := func(config *params.ChainConfig) { if config != nil { if overrides != nil && overrides.OverrideCancun != nil { config.CancunTime = overrides.OverrideCancun } if overrides != nil && overrides.OverrideVerkle != nil { config.VerkleTime = overrides.OverrideVerkle } } } // Just commit the new block if there is no stored genesis block. stored := rawdb.ReadCanonicalHash(db, 0) systemcontracts.GenesisHash = stored if (stored == common.Hash{}) { if genesis == nil { log.Info("Writing default BSC mainnet genesis block") genesis = DefaultBSCGenesisBlock() } else { log.Info("Writing custom genesis block") } block, err := genesis.Commit(db, triedb) if err != nil { return genesis.Config, common.Hash{}, err } applyOverrides(genesis.Config) log.Info("genesis block hash", "hash", block.Hash()) return genesis.Config, block.Hash(), nil } // The genesis block is present(perhaps in ancient database) while the // state database is not initialized yet. It can happen that the node // is initialized with an external ancient store. Commit genesis state // in this case. header := rawdb.ReadHeader(db, stored, 0) if header.Root != types.EmptyRootHash && !triedb.Initialized(header.Root) { if genesis == nil { genesis = DefaultBSCGenesisBlock() } // Ensure the stored genesis matches with the given one. hash := genesis.ToBlock().Hash() if hash != stored { return genesis.Config, hash, &GenesisMismatchError{stored, hash} } block, err := genesis.Commit(db, triedb) if err != nil { return genesis.Config, hash, err } applyOverrides(genesis.Config) return genesis.Config, block.Hash(), nil } // Check whether the genesis block is already written. if genesis != nil { hash := genesis.ToBlock().Hash() if hash != stored { return genesis.Config, hash, &GenesisMismatchError{stored, hash} } } // Get the existing chain configuration. newcfg := genesis.configOrDefault(stored) applyOverrides(newcfg) if err := newcfg.CheckConfigForkOrder(); err != nil { return newcfg, common.Hash{}, err } storedcfg := rawdb.ReadChainConfig(db, stored) if storedcfg == nil { log.Warn("Found genesis block without chain config") rawdb.WriteChainConfig(db, stored, newcfg) return newcfg, stored, nil } storedData, _ := json.Marshal(storedcfg) // Special case: if a private network is being used (no genesis and also no // mainnet hash in the database), we must not apply the `configOrDefault` // chain config as that would be AllProtocolChanges (applying any new fork // on top of an existing private network genesis block). In that case, only // apply the overrides. if genesis == nil && stored != params.MainnetGenesisHash && stored != params.ChapelGenesisHash && stored != params.RialtoGenesisHash && stored != params.BSCGenesisHash { newcfg = storedcfg applyOverrides(newcfg) } // Check config compatibility and write the config. Compatibility errors // are returned to the caller unless we're already at block zero. head := rawdb.ReadHeadHeader(db) if head == nil { return newcfg, stored, errors.New("missing head header") } compatErr := storedcfg.CheckCompatible(newcfg, head.Number.Uint64(), head.Time) if compatErr != nil && ((head.Number.Uint64() != 0 && compatErr.RewindToBlock != 0) || (head.Time != 0 && compatErr.RewindToTime != 0)) { return newcfg, stored, compatErr } // Don't overwrite if the old is identical to the new if newData, _ := json.Marshal(newcfg); !bytes.Equal(storedData, newData) { rawdb.WriteChainConfig(db, stored, newcfg) } return newcfg, stored, nil } // LoadChainConfig loads the stored chain config if it is already present in // database, otherwise, return the config in the provided genesis specification. func LoadChainConfig(db ethdb.Database, genesis *Genesis) (*params.ChainConfig, common.Hash, error) { // Load the stored chain config from the database. It can be nil // in case the database is empty. Notably, we only care about the // chain config corresponds to the canonical chain. stored := rawdb.ReadCanonicalHash(db, 0) if stored != (common.Hash{}) { storedcfg := rawdb.ReadChainConfig(db, stored) if storedcfg != nil { return storedcfg, stored, nil } } // Load the config from the provided genesis specification if genesis != nil { // Reject invalid genesis spec without valid chain config if genesis.Config == nil { return nil, common.Hash{}, errGenesisNoConfig } // If the canonical genesis header is present, but the chain // config is missing(initialize the empty leveldb with an // external ancient chain segment), ensure the provided genesis // is matched. if stored != (common.Hash{}) && genesis.ToBlock().Hash() != stored { return nil, common.Hash{}, &GenesisMismatchError{stored, genesis.ToBlock().Hash()} } return genesis.Config, stored, nil } // There is no stored chain config and no new config provided, // In this case the default chain config(mainnet) will be used return params.BSCChainConfig, params.BSCGenesisHash, nil } // For any block or time in g.Config which is nil but the same field in defaultConfig is not // set the field in genesis config to the field in defaultConfig. // Reflection is used to avoid a long series of if statements with hardcoded block names. func (g *Genesis) setDefaultHardforkValues(defaultConfig *params.ChainConfig) { // Regex to match Block names or Time names hardforkPattern := []string{`.*Block$`, `.*Time$`} for _, pat := range hardforkPattern { hardforkRegex := regexp.MustCompile(pat) // Get reflect values gConfigElem := reflect.ValueOf(g.Config).Elem() defaultConfigElem := reflect.ValueOf(defaultConfig).Elem() // Iterate over fields in config for i := 0; i < gConfigElem.NumField(); i++ { gConfigField := gConfigElem.Field(i) defaultConfigField := defaultConfigElem.Field(i) fieldName := gConfigElem.Type().Field(i).Name // Use the regex to check if the field is a Block or Time field if gConfigField.Kind() == reflect.Ptr && hardforkRegex.MatchString(fieldName) { if gConfigField.IsNil() { gConfigField.Set(defaultConfigField) } } } } } // Hard fork field specified in config.toml has higher priority, but // if it is not specified in config.toml, use the default height in code. func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig { var defaultConfig *params.ChainConfig switch { case ghash == params.MainnetGenesisHash: defaultConfig = params.MainnetChainConfig case ghash == params.BSCGenesisHash: defaultConfig = params.BSCChainConfig case ghash == params.ChapelGenesisHash: defaultConfig = params.ChapelChainConfig case ghash == params.RialtoGenesisHash: defaultConfig = params.RialtoChainConfig default: if g != nil { // it could be a custom config for QA test, just return return g.Config } defaultConfig = params.AllEthashProtocolChanges } if g == nil || g.Config == nil { return defaultConfig } g.setDefaultHardforkValues(defaultConfig) // BSC Parlia set up if g.Config.Parlia == nil { g.Config.Parlia = defaultConfig.Parlia } else { if g.Config.Parlia.Period == 0 { g.Config.Parlia.Period = defaultConfig.Parlia.Period } if g.Config.Parlia.Epoch == 0 { g.Config.Parlia.Epoch = defaultConfig.Parlia.Epoch } } return g.Config } // ToBlock returns the genesis block according to genesis specification. func (g *Genesis) ToBlock() *types.Block { root, err := g.Alloc.deriveHash() if err != nil { panic(err) } head := &types.Header{ Number: new(big.Int).SetUint64(g.Number), Nonce: types.EncodeNonce(g.Nonce), Time: g.Timestamp, ParentHash: g.ParentHash, Extra: g.ExtraData, GasLimit: g.GasLimit, GasUsed: g.GasUsed, BaseFee: g.BaseFee, Difficulty: g.Difficulty, MixDigest: g.Mixhash, Coinbase: g.Coinbase, Root: root, } if g.GasLimit == 0 { head.GasLimit = params.GenesisGasLimit } if g.Difficulty == nil && g.Mixhash == (common.Hash{}) { head.Difficulty = params.GenesisDifficulty } if g.Config != nil && g.Config.IsLondon(common.Big0) { if g.BaseFee != nil { head.BaseFee = g.BaseFee } else { head.BaseFee = new(big.Int).SetUint64(params.InitialBaseFee) } } var withdrawals []*types.Withdrawal if conf := g.Config; conf != nil { num := big.NewInt(int64(g.Number)) if conf.Parlia == nil && conf.IsShanghai(num, g.Timestamp) { head.WithdrawalsHash = &types.EmptyWithdrawalsHash withdrawals = make([]*types.Withdrawal, 0) } if conf.IsCancun(num, g.Timestamp) { head.ExcessBlobGas = g.ExcessBlobGas head.BlobGasUsed = g.BlobGasUsed if head.ExcessBlobGas == nil { head.ExcessBlobGas = new(uint64) } if head.BlobGasUsed == nil { head.BlobGasUsed = new(uint64) } } } return types.NewBlock(head, nil, nil, nil, trie.NewStackTrie(nil)).WithWithdrawals(withdrawals) } // Commit writes the block and state of a genesis specification to the database. // The block is committed as the canonical head block. func (g *Genesis) Commit(db ethdb.Database, triedb *trie.Database) (*types.Block, error) { block := g.ToBlock() if block.Number().Sign() != 0 { return nil, errors.New("can't commit genesis block with number > 0") } config := g.Config if config == nil { config = params.AllEthashProtocolChanges } if err := config.CheckConfigForkOrder(); err != nil { return nil, err } if config.Clique != nil && len(block.Extra()) < 32+crypto.SignatureLength { return nil, errors.New("can't start clique chain without signers") } // All the checks has passed, flush the states derived from the genesis // specification as well as the specification itself into the provided // database. if err := g.Alloc.flush(db, triedb, block.Hash()); err != nil { return nil, err } rawdb.WriteTd(db, block.Hash(), block.NumberU64(), block.Difficulty()) rawdb.WriteBlock(db, block) rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil) rawdb.WriteCanonicalHash(db, block.Hash(), block.NumberU64()) rawdb.WriteHeadBlockHash(db, block.Hash()) rawdb.WriteHeadFastBlockHash(db, block.Hash()) rawdb.WriteHeadHeaderHash(db, block.Hash()) rawdb.WriteChainConfig(db, block.Hash(), config) return block, nil } // MustCommit writes the genesis block and state to db, panicking on error. // The block is committed as the canonical head block. func (g *Genesis) MustCommit(db ethdb.Database, triedb *trie.Database) *types.Block { block, err := g.Commit(db, triedb) if err != nil { panic(err) } return block } // DefaultGenesisBlock returns the Ethereum main net genesis block. func DefaultGenesisBlock() *Genesis { return &Genesis{ Config: params.MainnetChainConfig, Nonce: 66, ExtraData: hexutil.MustDecode("0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa"), GasLimit: 5000, Difficulty: big.NewInt(17179869184), Alloc: decodePrealloc(mainnetAllocData), } } // DefaultBSCGenesisBlock returns the BSC mainnet genesis block. func DefaultBSCGenesisBlock() *Genesis { alloc := decodePrealloc(bscMainnetAllocData) return &Genesis{ Config: params.BSCChainConfig, Nonce: 0, ExtraData: hexutil.MustDecode("0x00000000000000000000000000000000000000000000000000000000000000002a7cdd959bfe8d9487b2a43b33565295a698f7e26488aa4d1955ee33403f8ccb1d4de5fb97c7ade29ef9f4360c606c7ab4db26b016007d3ad0ab86a0ee01c3b1283aa067c58eab4709f85e99d46de5fe685b1ded8013785d6623cc18d214320b6bb6475978f3adfc719c99674c072166708589033e2d9afec2be4ec20253b8642161bc3f444f53679c1f3d472f7be8361c80a4c1e7e9aaf001d0877f1cfde218ce2fd7544e0b2cc94692d4a704debef7bcb61328b8f7166496996a7da21cf1f1b04d9b3e26a3d0772d4c407bbe49438ed859fe965b140dcf1aab71a96bbad7cf34b5fa511d8e963dbba288b1960e75d64430b3230294d12c6ab2aac5c2cd68e80b16b581ea0a6e3c511bbd10f4519ece37dc24887e11b55d7ae2f5b9e386cd1b50a4550696d957cb4900f03a82012708dafc9e1b880fd083b32182b869be8e0922b81f8e175ffde54d797fe11eb03f9e3bf75f1d68bf0b8b6fb4e317a0f9d6f03eaf8ce6675bc60d8c4d90829ce8f72d0163c1d5cf348a862d55063035e7a025f4da968de7e4d7e4004197917f4070f1d6caa02bbebaebb5d7e581e4b66559e635f805ff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), GasLimit: 40000000, Difficulty: big.NewInt(1), Mixhash: common.Hash(hexutil.MustDecode("0x0000000000000000000000000000000000000000000000000000000000000000")), Coinbase: common.HexToAddress("0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE"), Timestamp: 0x5e9da7ce, Alloc: alloc, } } // DeveloperGenesisBlock returns the 'geth --dev' genesis block. func DeveloperGenesisBlock(gasLimit uint64, faucet common.Address) *Genesis { // Override the default period to the user requested one config := *params.AllDevChainProtocolChanges // Assemble and return the genesis with the precompiles and faucet pre-funded return &Genesis{ Config: &config, GasLimit: gasLimit, BaseFee: big.NewInt(params.InitialBaseFee), Difficulty: big.NewInt(0), Alloc: map[common.Address]GenesisAccount{ common.BytesToAddress([]byte{1}): {Balance: big.NewInt(1)}, // ECRecover common.BytesToAddress([]byte{2}): {Balance: big.NewInt(1)}, // SHA256 common.BytesToAddress([]byte{3}): {Balance: big.NewInt(1)}, // RIPEMD common.BytesToAddress([]byte{4}): {Balance: big.NewInt(1)}, // Identity common.BytesToAddress([]byte{5}): {Balance: big.NewInt(1)}, // ModExp common.BytesToAddress([]byte{6}): {Balance: big.NewInt(1)}, // ECAdd common.BytesToAddress([]byte{7}): {Balance: big.NewInt(1)}, // ECScalarMul common.BytesToAddress([]byte{8}): {Balance: big.NewInt(1)}, // ECPairing common.BytesToAddress([]byte{9}): {Balance: big.NewInt(1)}, // BLAKE2b faucet: {Balance: new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), 256), big.NewInt(9))}, }, } } func decodePrealloc(data string) GenesisAlloc { var p []struct { Addr *big.Int Balance *big.Int Misc *struct { Nonce uint64 Code []byte Slots []struct { Key common.Hash Val common.Hash } } `rlp:"optional"` } if err := rlp.NewStream(strings.NewReader(data), 0).Decode(&p); err != nil { panic(err) } ga := make(GenesisAlloc, len(p)) for _, account := range p { acc := GenesisAccount{Balance: account.Balance} if account.Misc != nil { acc.Nonce = account.Misc.Nonce acc.Code = account.Misc.Code acc.Storage = make(map[common.Hash]common.Hash) for _, slot := range account.Misc.Slots { acc.Storage[slot.Key] = slot.Val } } ga[common.BigToAddress(account.Addr)] = acc } return ga }