Merge pull request #185 from maticnetwork/krishna/network-flags

Network flags

.github/workflows/ci.yml

@@ -8,7 +8,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v2.1.3
         with:
-          go-version: 1.15.5
+          go-version: 1.16.7
       - name: "Build binaries"
         run: make all
       - name: "Run tests"

cmd/devp2p/nodesetcmd.go

@@ -235,6 +235,10 @@ func ethFilter(args []string) (nodeFilter, error) {
 		filter = forkid.NewStaticFilter(params.GoerliChainConfig, params.GoerliGenesisHash)
 	case "ropsten":
 		filter = forkid.NewStaticFilter(params.RopstenChainConfig, params.RopstenGenesisHash)
+	case "bor-mumbai":
+		filter = forkid.NewStaticFilter(params.MumbaiChainConfig, params.MumbaiGenesisHash)
+	case "bor-mainnet":
+		filter = forkid.NewStaticFilter(params.BorMainnetChainConfig, params.BorMainnetGenesisHash)
 	default:
 		return nil, fmt.Errorf("unknown network %q", args[0])
 	}

cmd/faucet/faucet.go

@@ -88,6 +88,7 @@ var (
 
 	goerliFlag  = flag.Bool("goerli", false, "Initializes the faucet with Görli network config")
 	rinkebyFlag = flag.Bool("rinkeby", false, "Initializes the faucet with Rinkeby network config")
+	mumbaiFlag  = flag.Bool("bor-mumbai", false, "Initializes the faucet with Bor-Mumbai network config")
 )
 
 var (
@@ -147,7 +148,7 @@ func main() {
 		log.Crit("Failed to render the faucet template", "err", err)
 	}
 	// Load and parse the genesis block requested by the user
-	genesis, err := getGenesis(genesisFlag, *goerliFlag, *rinkebyFlag)
+	genesis, err := getGenesis(genesisFlag, *goerliFlag, *rinkebyFlag, *mumbaiFlag)
 	if err != nil {
 		log.Crit("Failed to parse genesis config", "err", err)
 	}
@@ -886,7 +887,7 @@ func authNoAuth(url string) (string, string, common.Address, error) {
 }
 
 // getGenesis returns a genesis based on input args
-func getGenesis(genesisFlag *string, goerliFlag bool, rinkebyFlag bool) (*core.Genesis, error) {
+func getGenesis(genesisFlag *string, goerliFlag bool, rinkebyFlag bool, mumbaiFlag bool) (*core.Genesis, error) {
 	switch {
 	case genesisFlag != nil:
 		var genesis core.Genesis
@@ -896,6 +897,8 @@ func getGenesis(genesisFlag *string, goerliFlag bool, rinkebyFlag bool) (*core.G
 		return core.DefaultGoerliGenesisBlock(), nil
 	case rinkebyFlag:
 		return core.DefaultRinkebyGenesisBlock(), nil
+	case mumbaiFlag:
+		return core.DefaultMumbaiGenesisBlock(), nil
 	default:
 		return nil, fmt.Errorf("no genesis flag provided")
 	}

cmd/geth/chaincmd.go

@@ -68,6 +68,8 @@ It expects the genesis file as argument.`,
 			utils.RopstenFlag,
 			utils.RinkebyFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 		},
 		Category: "BLOCKCHAIN COMMANDS",
 		Description: `

cmd/geth/config.go

@@ -23,6 +23,7 @@ import (
 	"math/big"
 	"os"
 	"reflect"
+	"time"
 	"unicode"
 
 	"gopkg.in/urfave/cli.v1"
@@ -33,6 +34,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/usbwallet"
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/eth/catalyst"
+	"github.com/ethereum/go-ethereum/eth/downloader"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
 	"github.com/ethereum/go-ethereum/internal/ethapi"
 	"github.com/ethereum/go-ethereum/log"
@@ -133,6 +135,14 @@ func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) {
 		}
 	}
 
+	if ctx.GlobalIsSet(utils.MumbaiFlag.Name) {
+		setDefaultMumbaiGethConfig(ctx, &cfg)
+	}
+
+	if ctx.GlobalIsSet(utils.BorMainnetFlag.Name) {
+		setDefaultBorMainnetGethConfig(ctx, &cfg)
+	}
+
 	// Apply flags.
 	utils.SetNodeConfig(ctx, &cfg.Node)
 	stack, err := node.New(&cfg.Node)
@@ -328,3 +338,49 @@ func setAccountManagerBackends(stack *node.Node) error {
 
 	return nil
 }
+
+func setDefaultMumbaiGethConfig(ctx *cli.Context, config *gethConfig) {
+	config.Node.P2P.ListenAddr = fmt.Sprintf(":%d", 30303)
+	config.Node.HTTPHost = "0.0.0.0"
+	config.Node.HTTPVirtualHosts = []string{"*"}
+	config.Node.HTTPCors = []string{"*"}
+	config.Node.HTTPPort = 8545
+	config.Node.IPCPath = utils.MakeDataDir(ctx) + "/bor.ipc"
+	config.Node.HTTPModules = []string{"eth", "net", "web3", "txpool", "bor"}
+	config.Eth.SyncMode = downloader.SnapSync
+	config.Eth.NetworkId = 80001
+	config.Eth.Miner.GasCeil = 20000000
+	//--miner.gastarget is depreceated, No longed used
+	config.Eth.TxPool.NoLocals = true
+	config.Eth.TxPool.AccountSlots = 16
+	config.Eth.TxPool.GlobalSlots = 131072
+	config.Eth.TxPool.AccountQueue = 64
+	config.Eth.TxPool.GlobalQueue = 131072
+	config.Eth.TxPool.Lifetime = 90 * time.Minute
+	config.Node.P2P.MaxPeers = 200
+	config.Metrics.Enabled = true
+	// --pprof is enabled in 'internal/debug/flags.go'
+}
+
+func setDefaultBorMainnetGethConfig(ctx *cli.Context, config *gethConfig) {
+	config.Node.P2P.ListenAddr = fmt.Sprintf(":%d", 30303)
+	config.Node.HTTPHost = "0.0.0.0"
+	config.Node.HTTPVirtualHosts = []string{"*"}
+	config.Node.HTTPCors = []string{"*"}
+	config.Node.HTTPPort = 8545
+	config.Node.IPCPath = utils.MakeDataDir(ctx) + "/bor.ipc"
+	config.Node.HTTPModules = []string{"eth", "net", "web3", "txpool", "bor"}
+	config.Eth.SyncMode = downloader.SnapSync
+	config.Eth.NetworkId = 137
+	config.Eth.Miner.GasCeil = 20000000
+	//--miner.gastarget is depreceated, No longed used
+	config.Eth.TxPool.NoLocals = true
+	config.Eth.TxPool.AccountSlots = 16
+	config.Eth.TxPool.GlobalSlots = 131072
+	config.Eth.TxPool.AccountQueue = 64
+	config.Eth.TxPool.GlobalQueue = 131072
+	config.Eth.TxPool.Lifetime = 90 * time.Minute
+	config.Node.P2P.MaxPeers = 200
+	config.Metrics.Enabled = true
+	// --pprof is enabled in 'internal/debug/flags.go'
+}

cmd/geth/consolecmd.go

@@ -134,6 +134,9 @@ func remoteConsole(ctx *cli.Context) error {
 				path = filepath.Join(path, "rinkeby")
 			} else if ctx.GlobalBool(utils.GoerliFlag.Name) {
 				path = filepath.Join(path, "goerli")
+			} else if ctx.GlobalBool(utils.MumbaiFlag.Name) || ctx.GlobalBool(utils.BorMainnetFlag.Name) {
+				homeDir, _ := os.UserHomeDir()
+				path = filepath.Join(homeDir, "/.bor/data")
 			}
 		}
 		endpoint = fmt.Sprintf("%s/geth.ipc", path)

cmd/geth/dbcmd.go

@@ -75,6 +75,8 @@ Remove blockchain and state databases`,
 			utils.RopstenFlag,
 			utils.RinkebyFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 		},
 		Usage:       "Inspect the storage size for each type of data in the database",
 		Description: `This commands iterates the entire database. If the optional 'prefix' and 'start' arguments are provided, then the iteration is limited to the given subset of data.`,
@@ -90,6 +92,8 @@ Remove blockchain and state databases`,
 			utils.RopstenFlag,
 			utils.RinkebyFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 		},
 	}
 	dbCompactCmd = cli.Command{
@@ -103,6 +107,8 @@ Remove blockchain and state databases`,
 			utils.RopstenFlag,
 			utils.RinkebyFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 			utils.CacheFlag,
 			utils.CacheDatabaseFlag,
 		},
@@ -122,6 +128,8 @@ corruption if it is aborted during execution'!`,
 			utils.RopstenFlag,
 			utils.RinkebyFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 		},
 		Description: "This command looks up the specified database key from the database.",
 	}
@@ -137,6 +145,8 @@ corruption if it is aborted during execution'!`,
 			utils.RopstenFlag,
 			utils.RinkebyFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 		},
 		Description: `This command deletes the specified database key from the database. 
 WARNING: This is a low-level operation which may cause database corruption!`,
@@ -153,6 +163,8 @@ WARNING: This is a low-level operation which may cause database corruption!`,
 			utils.RopstenFlag,
 			utils.RinkebyFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 		},
 		Description: `This command sets a given database key to the given value. 
 WARNING: This is a low-level operation which may cause database corruption!`,
@@ -169,6 +181,8 @@ WARNING: This is a low-level operation which may cause database corruption!`,
 			utils.RopstenFlag,
 			utils.RinkebyFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 		},
 		Description: "This command looks up the specified database key from the database.",
 	}
@@ -184,6 +198,8 @@ WARNING: This is a low-level operation which may cause database corruption!`,
 			utils.RopstenFlag,
 			utils.RinkebyFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 		},
 		Description: "This command displays information about the freezer index.",
 	}

cmd/geth/main.go

@@ -140,6 +140,8 @@ var (
 		utils.RopstenFlag,
 		utils.RinkebyFlag,
 		utils.GoerliFlag,
+		utils.MumbaiFlag,
+		utils.BorMainnetFlag,
 		utils.VMEnableDebugFlag,
 		utils.NetworkIdFlag,
 		utils.EthStatsURLFlag,
@@ -282,6 +284,12 @@ func prepare(ctx *cli.Context) {
 	case ctx.GlobalIsSet(utils.GoerliFlag.Name):
 		log.Info("Starting Geth on Görli testnet...")
 
+	case ctx.GlobalIsSet(utils.MumbaiFlag.Name):
+		log.Info("Starting Bor on Mumbai testnet...")
+
+	case ctx.GlobalIsSet(utils.BorMainnetFlag.Name):
+		log.Info("Starting Bor on Bor mainnet...")
+
 	case ctx.GlobalIsSet(utils.DeveloperFlag.Name):
 		log.Info("Starting Geth in ephemeral dev mode...")
 
@@ -291,7 +299,7 @@ func prepare(ctx *cli.Context) {
 	// If we're a full node on mainnet without --cache specified, bump default cache allowance
 	if ctx.GlobalString(utils.SyncModeFlag.Name) != "light" && !ctx.GlobalIsSet(utils.CacheFlag.Name) && !ctx.GlobalIsSet(utils.NetworkIdFlag.Name) {
 		// Make sure we're not on any supported preconfigured testnet either
-		if !ctx.GlobalIsSet(utils.RopstenFlag.Name) && !ctx.GlobalIsSet(utils.RinkebyFlag.Name) && !ctx.GlobalIsSet(utils.GoerliFlag.Name) && !ctx.GlobalIsSet(utils.DeveloperFlag.Name) {
+		if !ctx.GlobalIsSet(utils.RopstenFlag.Name) && !ctx.GlobalIsSet(utils.RinkebyFlag.Name) && !ctx.GlobalIsSet(utils.GoerliFlag.Name) && !ctx.GlobalIsSet(utils.MumbaiFlag.Name) && !ctx.GlobalIsSet(utils.DeveloperFlag.Name) {
 			// Nope, we're really on mainnet. Bump that cache up!
 			log.Info("Bumping default cache on mainnet", "provided", ctx.GlobalInt(utils.CacheFlag.Name), "updated", 4096)
 			ctx.GlobalSet(utils.CacheFlag.Name, strconv.Itoa(4096))

cmd/geth/snapshot.go

@@ -63,6 +63,8 @@ var (
 					utils.RopstenFlag,
 					utils.RinkebyFlag,
 					utils.GoerliFlag,
+					utils.MumbaiFlag,
+					utils.BorMainnetFlag,
 					utils.CacheTrieJournalFlag,
 					utils.BloomFilterSizeFlag,
 				},
@@ -93,6 +95,8 @@ the trie clean cache with default directory will be deleted.
 					utils.RopstenFlag,
 					utils.RinkebyFlag,
 					utils.GoerliFlag,
+					utils.MumbaiFlag,
+					utils.BorMainnetFlag,
 				},
 				Description: `
 geth snapshot verify-state <state-root>
@@ -113,6 +117,8 @@ In other words, this command does the snapshot to trie conversion.
 					utils.RopstenFlag,
 					utils.RinkebyFlag,
 					utils.GoerliFlag,
+					utils.MumbaiFlag,
+					utils.BorMainnetFlag,
 				},
 				Description: `
 geth snapshot traverse-state <state-root>
@@ -135,6 +141,8 @@ It's also usable without snapshot enabled.
 					utils.RopstenFlag,
 					utils.RinkebyFlag,
 					utils.GoerliFlag,
+					utils.MumbaiFlag,
+					utils.BorMainnetFlag,
 				},
 				Description: `
 geth snapshot traverse-rawstate <state-root>
@@ -158,6 +166,8 @@ It's also usable without snapshot enabled.
 					utils.RopstenFlag,
 					utils.RinkebyFlag,
 					utils.GoerliFlag,
+					utils.MumbaiFlag,
+					utils.BorMainnetFlag,
 					utils.ExcludeCodeFlag,
 					utils.ExcludeStorageFlag,
 					utils.StartKeyFlag,

cmd/geth/usage.go

@@ -43,6 +43,8 @@ var AppHelpFlagGroups = []flags.FlagGroup{
 			utils.NetworkIdFlag,
 			utils.MainnetFlag,
 			utils.GoerliFlag,
+			utils.MumbaiFlag,
+			utils.BorMainnetFlag,
 			utils.RinkebyFlag,
 			utils.RopstenFlag,
 			utils.SyncModeFlag,

cmd/utils/flags.go

@@ -155,6 +155,14 @@ var (
 		Name:  "ropsten",
 		Usage: "Ropsten network: pre-configured proof-of-work test network",
 	}
+	MumbaiFlag = cli.BoolFlag{
+		Name:  "bor-mumbai",
+		Usage: "Mumbai network: pre-configured proof-of-stake test network",
+	}
+	BorMainnetFlag = cli.BoolFlag{
+		Name:  "bor-mainnet",
+		Usage: "Bor mainnet",
+	}
 	DeveloperFlag = cli.BoolFlag{
 		Name:  "dev",
 		Usage: "Ephemeral proof-of-authority network with a pre-funded developer account, mining enabled",
@@ -797,6 +805,10 @@ func MakeDataDir(ctx *cli.Context) string {
 		if ctx.GlobalBool(GoerliFlag.Name) {
 			return filepath.Join(path, "goerli")
 		}
+		if ctx.GlobalBool(MumbaiFlag.Name) || ctx.GlobalBool(BorMainnetFlag.Name) {
+			homeDir, _ := os.UserHomeDir()
+			return filepath.Join(homeDir, "/.bor/data")
+		}
 		return path
 	}
 	Fatalf("Cannot determine default data directory, please set manually (--datadir)")
@@ -849,6 +861,10 @@ func setBootstrapNodes(ctx *cli.Context, cfg *p2p.Config) {
 		urls = params.RinkebyBootnodes
 	case ctx.GlobalBool(GoerliFlag.Name):
 		urls = params.GoerliBootnodes
+	case ctx.GlobalBool(MumbaiFlag.Name):
+		urls = params.MumbaiBootnodes
+	case ctx.GlobalBool(BorMainnetFlag.Name):
+		urls = params.BorMainnetBootnodes
 	case cfg.BootstrapNodes != nil:
 		return // already set, don't apply defaults.
 	}
@@ -1292,6 +1308,12 @@ func setDataDir(ctx *cli.Context, cfg *node.Config) {
 		cfg.DataDir = filepath.Join(node.DefaultDataDir(), "rinkeby")
 	case ctx.GlobalBool(GoerliFlag.Name) && cfg.DataDir == node.DefaultDataDir():
 		cfg.DataDir = filepath.Join(node.DefaultDataDir(), "goerli")
+	case ctx.GlobalBool(MumbaiFlag.Name) && cfg.DataDir == node.DefaultDataDir():
+		homeDir, _ := os.UserHomeDir()
+		cfg.DataDir = filepath.Join(homeDir, "/.bor/data")
+	case ctx.GlobalBool(BorMainnetFlag.Name) && cfg.DataDir == node.DefaultDataDir():
+		homeDir, _ := os.UserHomeDir()
+		cfg.DataDir = filepath.Join(homeDir, "/.bor/data")
 	}
 }
 
@@ -1477,7 +1499,7 @@ func CheckExclusive(ctx *cli.Context, args ...interface{}) {
 // SetEthConfig applies eth-related command line flags to the config.
 func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 	// Avoid conflicting network flags
-	CheckExclusive(ctx, MainnetFlag, DeveloperFlag, RopstenFlag, RinkebyFlag, GoerliFlag)
+	CheckExclusive(ctx, MainnetFlag, DeveloperFlag, RopstenFlag, RinkebyFlag, GoerliFlag, MumbaiFlag, BorMainnetFlag)
 	CheckExclusive(ctx, LightServeFlag, SyncModeFlag, "light")
 	CheckExclusive(ctx, DeveloperFlag, ExternalSignerFlag) // Can't use both ephemeral unlocked and external signer
 	if ctx.GlobalString(GCModeFlag.Name) == "archive" && ctx.GlobalUint64(TxLookupLimitFlag.Name) != 0 {
@@ -1503,7 +1525,7 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 		cfg.BorLogs = ctx.GlobalBool(BorLogsFlag.Name)
 	}
 
-  // Cap the cache allowance and tune the garbage collector
+	// Cap the cache allowance and tune the garbage collector
 	mem, err := gopsutil.VirtualMemory()
 	if err == nil {
 		if 32<<(^uintptr(0)>>63) == 32 && mem.Total > 2*1024*1024*1024 {
@@ -1634,6 +1656,18 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *ethconfig.Config) {
 		}
 		cfg.Genesis = core.DefaultGoerliGenesisBlock()
 		SetDNSDiscoveryDefaults(cfg, params.GoerliGenesisHash)
+	case ctx.GlobalBool(MumbaiFlag.Name):
+		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
+			cfg.NetworkId = 80001
+		}
+		cfg.Genesis = core.DefaultMumbaiGenesisBlock()
+		SetDNSDiscoveryDefaults(cfg, params.MumbaiGenesisHash)
+	case ctx.GlobalBool(BorMainnetFlag.Name):
+		if !ctx.GlobalIsSet(BorMainnetFlag.Name) {
+			cfg.NetworkId = 137
+		}
+		cfg.Genesis = core.DefaultBorMainnetGenesisBlock()
+		SetDNSDiscoveryDefaults(cfg, params.BorMainnetGenesisHash)
 	case ctx.GlobalBool(DeveloperFlag.Name):
 		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
 			cfg.NetworkId = 1337
@@ -1854,6 +1888,10 @@ func MakeGenesis(ctx *cli.Context) *core.Genesis {
 		genesis = core.DefaultRinkebyGenesisBlock()
 	case ctx.GlobalBool(GoerliFlag.Name):
 		genesis = core.DefaultGoerliGenesisBlock()
+	case ctx.GlobalBool(MumbaiFlag.Name):
+		genesis = core.DefaultMumbaiGenesisBlock()
+	case ctx.GlobalBool(BorMainnetFlag.Name):
+		genesis = core.DefaultBorMainnetGenesisBlock()
 	case ctx.GlobalBool(DeveloperFlag.Name):
 		Fatalf("Developer chains are ephemeral")
 	}

core/genesis.go

@@ -18,6 +18,7 @@ package core
 
 import (
 	"bytes"
+	"embed"
 	"encoding/hex"
 	"encoding/json"
 	"errors"
@@ -42,6 +43,9 @@ import (
 //go:generate gencodec -type Genesis -field-override genesisSpecMarshaling -out gen_genesis.go
 //go:generate gencodec -type GenesisAccount -field-override genesisAccountMarshaling -out gen_genesis_account.go
 
+//go:embed allocs
+var allocs embed.FS
+
 var errGenesisNoConfig = errors.New("genesis has no chain configuration")
 
 // Genesis specifies the header fields, state of a genesis block. It also defines hard
@@ -248,6 +252,10 @@ func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig {
 		return params.RinkebyChainConfig
 	case ghash == params.GoerliGenesisHash:
 		return params.GoerliChainConfig
+	case ghash == params.MumbaiGenesisHash:
+		return params.MumbaiChainConfig
+	case ghash == params.BorMainnetGenesisHash:
+		return params.BorMainnetChainConfig
 	default:
 		return params.AllEthashProtocolChanges
 	}
@@ -397,6 +405,34 @@ func DefaultGoerliGenesisBlock() *Genesis {
 	}
 }
 
+// DefaultMumbaiGenesisBlock returns the Mumbai network genesis block.
+func DefaultMumbaiGenesisBlock() *Genesis {
+	return &Genesis{
+		Config:     params.MumbaiChainConfig,
+		Nonce:      0,
+		Timestamp:  1558348305,
+		GasLimit:   10000000,
+		Difficulty: big.NewInt(1),
+		Mixhash:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
+		Coinbase:   common.HexToAddress("0x0000000000000000000000000000000000000000"),
+		Alloc:      readPrealloc("allocs/mumbai.json"),
+	}
+}
+
+//DefaultBorMainnet returns the Bor Mainnet network gensis block.
+func DefaultBorMainnetGenesisBlock() *Genesis {
+	return &Genesis{
+		Config:     params.BorMainnetChainConfig,
+		Nonce:      0,
+		Timestamp:  1590824836,
+		GasLimit:   10000000,
+		Difficulty: big.NewInt(1),
+		Mixhash:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
+		Coinbase:   common.HexToAddress("0x0000000000000000000000000000000000000000"),
+		Alloc:      readPrealloc("allocs/bor_mainnet.json"),
+	}
+}
+
 // DeveloperGenesisBlock returns the 'geth --dev' genesis block.
 func DeveloperGenesisBlock(period uint64, faucet common.Address) *Genesis {
 	// Override the default period to the user requested one
@@ -439,3 +475,18 @@ func decodePrealloc(data string) GenesisAlloc {
 	}
 	return ga
 }
+
+func readPrealloc(filename string) GenesisAlloc {
+	f, err := allocs.Open(filename)
+	if err != nil {
+		panic(fmt.Sprintf("Could not open genesis preallocation for %s: %v", filename, err))
+	}
+	defer f.Close()
+	decoder := json.NewDecoder(f)
+	ga := make(GenesisAlloc)
+	err = decoder.Decode(&ga)
+	if err != nil {
+		panic(fmt.Sprintf("Could not parse genesis preallocation for %s: %v", filename, err))
+	}
+	return ga
+}

go.mod

@@ -1,6 +1,6 @@
 module github.com/ethereum/go-ethereum
 
-go 1.15
+go 1.16
 
 require (
 	github.com/Azure/azure-pipeline-go v0.2.2 // indirect

go.sum

@@ -33,7 +33,6 @@ github.com/Azure/go-autorest/autorest/date v0.2.0 h1:yW+Zlqf26583pE43KhfnhFcdmSW
 github.com/Azure/go-autorest/autorest/date v0.2.0/go.mod h1:vcORJHLJEh643/Ioh9+vPmf1Ij9AEBM5FuBIXLmIy0g=
 github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
 github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0=
-github.com/Azure/go-autorest/autorest/mocks v0.3.0 h1:qJumjCaCudz+OcqE9/XtEPfvtOjOmKaui4EOpFI6zZc=
 github.com/Azure/go-autorest/autorest/mocks v0.3.0/go.mod h1:a8FDP3DYzQ4RYfVAxAN3SVSiiO77gL2j2ronKKP0syM=
 github.com/Azure/go-autorest/logger v0.1.0 h1:ruG4BSDXONFRrZZJ2GUXDiUyVpayPmb1GnWeHDdaNKY=
 github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc=
@@ -407,7 +406,6 @@ github.com/willf/bitset v1.1.3/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPyS
 github.com/xlab/treeprint v0.0.0-20180616005107-d6fb6747feb6/go.mod h1:ce1O1j6UtZfjr22oyGxGLbauSBp2YVXpARAosm7dHBg=
 github.com/xsleonard/go-merkle v1.1.0 h1:fHe1fuhJjGH22ZzVTAH0jqHLhTGhOq3wQjJN+8P0jQg=
 github.com/xsleonard/go-merkle v1.1.0/go.mod h1:cW4z+UZ/4f2n9IJgIiyDCdYguchoDyDAPmpuOWGxdGg=
-go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=

internal/debug/flags.go

@@ -246,6 +246,9 @@ func Setup(ctx *cli.Context) error {
 		// This context value ("metrics.addr") represents the utils.MetricsHTTPFlag.Name.
 		// It cannot be imported because it will cause a cyclical dependency.
 		StartPProf(address, !ctx.GlobalIsSet("metrics.addr"))
+	} else if ctx.GlobalIsSet("bor-mumbai") || ctx.GlobalIsSet("bor-mainnet") {
+		address := fmt.Sprintf("%s:%d", "0.0.0.0", 7071)
+		StartPProf(address, !ctx.GlobalIsSet("metrics.addr"))
 	}
 	return nil
 }

mobile/geth.go

@@ -179,6 +179,20 @@ func NewNode(datadir string, config *NodeConfig) (stack *Node, _ error) {
 				config.EthereumNetworkID = 5
 			}
 		}
+		// If we have the Bor Mainnet, hard code the chain configs too
+		if config.EthereumGenesis == BorMainnetGenesis() {
+			genesis.Config = params.BorMainnetChainConfig
+			if config.EthereumNetworkID == 1 {
+				config.EthereumNetworkID = 137
+			}
+		}
+		// If we have the Mumbai testnet, hard code the chain configs too
+		if config.EthereumGenesis == MumbaiGenesis() {
+			genesis.Config = params.MumbaiChainConfig
+			if config.EthereumNetworkID == 1 {
+				config.EthereumNetworkID = 80001
+			}
+		}
 	}
 	// Register the Ethereum protocol if requested
 	if config.EthereumEnabled {

mobile/params.go

@@ -59,6 +59,24 @@ func GoerliGenesis() string {
 	return string(enc)
 }
 
+// MumbaiGenesis returns the JSON spec to use for the Mumbai test network
+func MumbaiGenesis() string {
+	enc, err := json.Marshal(core.DefaultMumbaiGenesisBlock())
+	if err != nil {
+		panic(err)
+	}
+	return string(enc)
+}
+
+// BorMainnetGenesis returns the JSON spec to use for the Mumbai test network
+func BorMainnetGenesis() string {
+	enc, err := json.Marshal(core.DefaultBorMainnetGenesisBlock())
+	if err != nil {
+		panic(err)
+	}
+	return string(enc)
+}
+
 // FoundationBootnodes returns the enode URLs of the P2P bootstrap nodes operated
 // by the foundation running the V5 discovery protocol.
 func FoundationBootnodes() *Enodes {

params/bootnodes.go

@@ -67,6 +67,20 @@ var GoerliBootnodes = []string{
 	"enode://a59e33ccd2b3e52d578f1fbd70c6f9babda2650f0760d6ff3b37742fdcdfdb3defba5d56d315b40c46b70198c7621e63ffa3f987389c7118634b0fefbbdfa7fd@51.15.119.157:40303",
 }
 
+// MumbaiBootnodes are the enode URLs of the P2P bootstrap nodes running on the
+// Mumbai test network.
+var MumbaiBootnodes = []string{
+	"enode://320553cda00dfc003f499a3ce9598029f364fbb3ed1222fdc20a94d97dcc4d8ba0cd0bfa996579dcc6d17a534741fb0a5da303a90579431259150de66b597251@54.147.31.250:30303",
+	"enode://f0f48a8781629f95ff02606081e6e43e4aebd503f3d07fc931fad7dd5ca1ba52bd849a6f6c3be0e375cf13c9ae04d859c4a9ae3546dc8ed4f10aa5dbb47d4998@34.226.134.117:30303",
+}
+
+// BorMainnetBootnodes are the enode URLs of the P2P bootstrap nodes running on the
+// main Bor network.
+var BorMainnetBootnodes = []string{
+	"enode://0cb82b395094ee4a2915e9714894627de9ed8498fb881cec6db7c65e8b9a5bd7f2f25cc84e71e89d0947e51c76e85d0847de848c7782b13c0255247a6758178c@44.232.55.71:30303",
+	"enode://88116f4295f5a31538ae409e4d44ad40d22e44ee9342869e7d68bdec55b0f83c1530355ce8b41fbec0928a7d75a5745d528450d30aec92066ab6ba1ee351d710@159.203.9.164:30303",
+}
+
 var V5Bootnodes = []string{
 	// Teku team's bootnode
 	"enr:-KG4QOtcP9X1FbIMOe17QNMKqDxCpm14jcX5tiOE4_TyMrFqbmhPZHK_ZPG2Gxb1GE2xdtodOfx9-cgvNtxnRyHEmC0ghGV0aDKQ9aX9QgAAAAD__________4JpZIJ2NIJpcIQDE8KdiXNlY3AyNTZrMaEDhpehBDbZjM_L9ek699Y7vhUJ-eAdMyQW_Fil522Y0fODdGNwgiMog3VkcIIjKA",
@@ -101,6 +115,10 @@ func KnownDNSNetwork(genesis common.Hash, protocol string) string {
 		net = "rinkeby"
 	case GoerliGenesisHash:
 		net = "goerli"
+	case MumbaiGenesisHash:
+		net = "mumbai"
+	case BorMainnetGenesisHash:
+		net = "bor-mainnet"
 	default:
 		return ""
 	}

params/config.go

@@ -27,10 +27,12 @@ import (
 
 // Genesis hashes to enforce below configs on.
 var (
-	MainnetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")
+	MainnetGenesisHash    = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3")
-	RopstenGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d")
+	RopstenGenesisHash    = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d")
-	RinkebyGenesisHash = common.HexToHash("0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177")
+	RinkebyGenesisHash    = common.HexToHash("0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177")
-	GoerliGenesisHash  = common.HexToHash("0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a")
+	GoerliGenesisHash     = common.HexToHash("0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a")
+	MumbaiGenesisHash     = common.HexToHash("0x7b66506a9ebdbf30d32b43c5f15a3b1216269a1ec3a75aa3182b86176a2b1ca7")
+	BorMainnetGenesisHash = common.HexToHash("0xa9c28ce2141b56c474f1dc504bee9b01eb1bd7d1a507580d5519d4437a97de1b")
 )
 
 // TrustedCheckpoints associates each known checkpoint with the genesis hash of
@@ -220,6 +222,67 @@ var (
 		Threshold: 2,
 	}
 
+	// MumbaiChainConfig contains the chain parameters to run a node on the Mumbai test network.
+	MumbaiChainConfig = &ChainConfig{
+		ChainID:             big.NewInt(80001),
+		HomesteadBlock:      big.NewInt(0),
+		DAOForkBlock:        nil,
+		DAOForkSupport:      true,
+		EIP150Hash:          common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
+		EIP150Block:         big.NewInt(0),
+		EIP155Block:         big.NewInt(0),
+		EIP158Block:         big.NewInt(0),
+		ByzantiumBlock:      big.NewInt(0),
+		ConstantinopleBlock: big.NewInt(0),
+		PetersburgBlock:     big.NewInt(0),
+		IstanbulBlock:       big.NewInt(2722000),
+		MuirGlacierBlock:    big.NewInt(2722000),
+		BerlinBlock:         big.NewInt(13996000),
+		Bor: &BorConfig{
+			Period:                2,
+			ProducerDelay:         6,
+			Sprint:                64,
+			BackupMultiplier:      2,
+			ValidatorContract:     "0x0000000000000000000000000000000000001000",
+			StateReceiverContract: "0x0000000000000000000000000000000000001001",
+		},
+	}
+
+	BorMainnetChainConfig = &ChainConfig{
+		ChainID:             big.NewInt(137),
+		HomesteadBlock:      big.NewInt(0),
+		DAOForkBlock:        nil,
+		DAOForkSupport:      true,
+		EIP150Hash:          common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
+		EIP150Block:         big.NewInt(0),
+		EIP155Block:         big.NewInt(0),
+		EIP158Block:         big.NewInt(0),
+		ByzantiumBlock:      big.NewInt(0),
+		ConstantinopleBlock: big.NewInt(0),
+		PetersburgBlock:     big.NewInt(0),
+		IstanbulBlock:       big.NewInt(3395000),
+		MuirGlacierBlock:    big.NewInt(3395000),
+		BerlinBlock:         big.NewInt(14750000),
+		Bor: &BorConfig{
+			Period:                2,
+			ProducerDelay:         6,
+			Sprint:                64,
+			BackupMultiplier:      2,
+			ValidatorContract:     "0x0000000000000000000000000000000000001000",
+			StateReceiverContract: "0x0000000000000000000000000000000000001001",
+			OverrideStateSyncRecords: map[string]int{
+				"14949120": 8,
+				"14949184": 0,
+				"14953472": 0,
+				"14953536": 5,
+				"14953600": 0,
+				"14953664": 0,
+				"14953728": 0,
+				"14953792": 0,
+				"14953856": 0,
+			},
+		},
+	}
 	// AllEthashProtocolChanges contains every protocol change (EIPs) introduced
 	// and accepted by the Ethereum core developers into the Ethash consensus.
 	//