[WIP] Epic/aura consensus

accounts/accounts.go

@@ -39,6 +39,7 @@ const (
 	MimetypeDataWithValidator = "data/validator"
 	MimetypeTypedData         = "data/typed"
 	MimetypeClique            = "application/x-clique-header"
+	MimetypeAura              = "application/x-aura-header"
 	MimetypeTextPlain         = "text/plain"
 )
 

cmd/geth/chaincmd.go

@@ -163,6 +163,7 @@ The export-preimages command export hash preimages to an RLP encoded stream`,
 			utils.RinkebyFlag,
 			utils.TxLookupLimitFlag,
 			utils.GoerliFlag,
+			utils.LuksoFlag,
 			utils.YoloV1Flag,
 			utils.LegacyTestnetFlag,
 		},

cmd/geth/consolecmd.go

@@ -138,6 +138,8 @@ func remoteConsole(ctx *cli.Context) error {
 				path = filepath.Join(path, "goerli")
 			} else if ctx.GlobalBool(utils.YoloV1Flag.Name) {
 				path = filepath.Join(path, "yolo-v1")
+			} else if ctx.GlobalBool(utils.LuksoFlag.Name) {
+				path = filepath.Join(path, "lukso")
 			}
 		}
 		endpoint = fmt.Sprintf("%s/geth.ipc", path)

cmd/geth/genesis_test.go

@@ -68,6 +68,61 @@ var customGenesisTests = []struct {
 	},
 }
 
+var customAuraGenesisTests = []struct {
+	genesis string
+	query   string
+	result  string
+}{
+	// Aura Genesis file with specific chain configurations to test
+	{
+		genesis: `
+		{
+		  "name": "AuthorityRound",
+		  "engine": {
+			"authorityRound": {
+			  "params": {
+				"stepDuration": "5",
+				"validators" : {
+				  "list": [
+					"0x70ad1a5fba52e27173d23ad87ad97c9bbe249abf",
+					"0xafe443af9d1504de4c2d486356c421c160fdd7b1"
+				  ]
+				}
+			  }
+			}
+		  },
+		  "params": {
+			"gasLimitBoundDivisor": "0x400",
+			"maximumExtraDataSize": "0x20",
+			"minGasLimit": "0x1388",
+			"networkID" : "0x2323"
+		  },
+		  "genesis": {
+			"seal": {
+			  "authorityRound": {
+				"step": "0x0",
+				"signature": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+			  }
+			},
+			"difficulty": "0x20000",
+			"author": "0x0000000000000000000000000000000000000000",
+			"timestamp": "0x00",
+			"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+			"extraData": "0x",
+			"gasLimit": "0x222222"
+		  },
+		  "accounts": {
+			"0x0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
+			"0x0000000000000000000000000000000000000002": { "balance": "1", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
+			"0x0000000000000000000000000000000000000003": { "balance": "1", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
+			"0x0000000000000000000000000000000000000004": { "balance": "1", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } }
+		  }
+		}`,
+		query:  "eth.getBlock(0).hash",
+		result: "0x2778716827366f0a5479d7a907800d183c57382fa7142b84fbb71db143cf788c",
+	},
+}
+
 // Tests that initializing Geth with a custom genesis block and chain definitions
 // work properly.
 func TestCustomGenesis(t *testing.T) {
@@ -92,3 +147,27 @@ func TestCustomGenesis(t *testing.T) {
 		geth.ExpectExit()
 	}
 }
+
+// Tests that initializing Geth with a custom aura genesis block and chain definitions
+// work properly.
+func TestAuraGenesisBlock(t *testing.T) {
+	for i, tt := range customAuraGenesisTests {
+		// Create a temporary data directory to use and inspect later
+		datadir := tmpdir(t)
+		defer os.RemoveAll(datadir)
+
+		// Initialize the data directory with the custom genesis block
+		json := filepath.Join(datadir, "genesis.json")
+		if err := ioutil.WriteFile(json, []byte(tt.genesis), 0600); err != nil {
+			t.Fatalf("test %d: failed to write aura genesis file: %v", i, err)
+		}
+		runGeth(t, "--nousb", "--datadir", datadir, "init", json).WaitExit()
+		// Query the custom genesis block
+		geth := runGeth(t, "--nousb",
+			"--datadir", datadir, "--maxpeers", "0", "--port", "0",
+			"--nodiscover", "--nat", "none", "--ipcdisable",
+			"--exec", tt.query, "console")
+		geth.ExpectRegexp(tt.result)
+		geth.ExpectExit()
+	}
+}

cmd/geth/main.go

@@ -144,6 +144,7 @@ var (
 		utils.RopstenFlag,
 		utils.RinkebyFlag,
 		utils.GoerliFlag,
+		utils.LuksoFlag,
 		utils.YoloV1Flag,
 		utils.VMEnableDebugFlag,
 		utils.NetworkIdFlag,
@@ -295,6 +296,9 @@ func prepare(ctx *cli.Context) {
 	case ctx.GlobalIsSet(utils.GoerliFlag.Name):
 		log.Info("Starting Geth on Görli testnet...")
 
+	case ctx.GlobalIsSet(utils.LuksoFlag.Name):
+		log.Info("Starting Geth on Lukso testnet...")
+
 	case ctx.GlobalIsSet(utils.DeveloperFlag.Name):
 		log.Info("Starting Geth in ephemeral dev mode...")
 
@@ -304,7 +308,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.LegacyTestnetFlag.Name) && !ctx.GlobalIsSet(utils.RopstenFlag.Name) && !ctx.GlobalIsSet(utils.RinkebyFlag.Name) && !ctx.GlobalIsSet(utils.GoerliFlag.Name) && !ctx.GlobalIsSet(utils.DeveloperFlag.Name) {
+		if !ctx.GlobalIsSet(utils.LegacyTestnetFlag.Name) && !ctx.GlobalIsSet(utils.RopstenFlag.Name) && !ctx.GlobalIsSet(utils.RinkebyFlag.Name) && !ctx.GlobalIsSet(utils.GoerliFlag.Name) && !ctx.GlobalIsSet(utils.LuksoFlag.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/usage.go

@@ -41,6 +41,7 @@ var AppHelpFlagGroups = []flags.FlagGroup{
 			utils.SmartCardDaemonPathFlag,
 			utils.NetworkIdFlag,
 			utils.GoerliFlag,
+			utils.LuksoFlag,
 			utils.RinkebyFlag,
 			utils.YoloV1Flag,
 			utils.RopstenFlag,

cmd/puppeth/module_node.go

@@ -32,7 +32,7 @@ import (
 
 // nodeDockerfile is the Dockerfile required to run an Ethereum node.
 var nodeDockerfile = `
-FROM ethereum/client-go:latest
+FROM {{.DockerImage}}
 
 ADD genesis.json /genesis.json
 {{if .Unlock}}
@@ -82,7 +82,14 @@ services:
 // deployNode deploys a new Ethereum node container to a remote machine via SSH,
 // docker and docker-compose. If an instance with the specified network name
 // already exists there, it will be overwritten!
-func deployNode(client *sshClient, network string, bootnodes []string, config *nodeInfos, nocache bool) ([]byte, error) {
+func deployNode(
+	client *sshClient,
+	network string,
+	bootnodes []string,
+	config *nodeInfos,
+	nocache bool,
+	dockerImage string,
+) ([]byte, error) {
 	kind := "sealnode"
 	if config.keyJSON == "" && config.etherbase == "" {
 		kind = "bootnode"
@@ -98,18 +105,19 @@ func deployNode(client *sshClient, network string, bootnodes []string, config *n
 	}
 	dockerfile := new(bytes.Buffer)
 	template.Must(template.New("").Parse(nodeDockerfile)).Execute(dockerfile, map[string]interface{}{
-		"NetworkID": config.network,
-		"Port":      config.port,
-		"IP":        client.address,
-		"Peers":     config.peersTotal,
-		"LightFlag": lightFlag,
-		"Bootnodes": strings.Join(bootnodes, ","),
-		"Ethstats":  config.ethstats,
-		"Etherbase": config.etherbase,
-		"GasTarget": uint64(1000000 * config.gasTarget),
-		"GasLimit":  uint64(1000000 * config.gasLimit),
-		"GasPrice":  uint64(1000000000 * config.gasPrice),
-		"Unlock":    config.keyJSON != "",
+		"DockerImage": dockerImage,
+		"NetworkID":   config.network,
+		"Port":        config.port,
+		"IP":          client.address,
+		"Peers":       config.peersTotal,
+		"LightFlag":   lightFlag,
+		"Bootnodes":   strings.Join(bootnodes, ","),
+		"Ethstats":    config.ethstats,
+		"Etherbase":   config.etherbase,
+		"GasTarget":   uint64(1000000 * config.gasTarget),
+		"GasLimit":    uint64(1000000 * config.gasLimit),
+		"GasPrice":    uint64(1000000000 * config.gasPrice),
+		"Unlock":      config.keyJSON != "",
 	})
 	files[filepath.Join(workdir, "Dockerfile")] = dockerfile.Bytes()
 

cmd/puppeth/wizard_genesis.go

@@ -59,6 +59,21 @@ func (w *wizard) makeGenesis() {
 	fmt.Println("Which consensus engine to use? (default = clique)")
 	fmt.Println(" 1. Ethash - proof-of-work")
 	fmt.Println(" 2. Clique - proof-of-authority")
+	fmt.Println(" 3. Aura   - proof-of-authority")
+
+	readSigners := func() (signers []common.Address) {
+		for {
+			if address := w.readAddress(); address != nil {
+				signers = append(signers, *address)
+				continue
+			}
+			if len(signers) > 0 {
+				break
+			}
+		}
+
+		return
+	}
 
 	choice := w.read()
 	switch {
@@ -83,15 +98,8 @@ func (w *wizard) makeGenesis() {
 		fmt.Println("Which accounts are allowed to seal? (mandatory at least one)")
 
 		var signers []common.Address
-		for {
-			if address := w.readAddress(); address != nil {
-				signers = append(signers, *address)
-				continue
-			}
-			if len(signers) > 0 {
-				break
-			}
-		}
+		signers = readSigners()
+
 		// Sort the signers and embed into the extra-data section
 		for i := 0; i < len(signers); i++ {
 			for j := i + 1; j < len(signers); j++ {
@@ -104,7 +112,27 @@ func (w *wizard) makeGenesis() {
 		for i, signer := range signers {
 			copy(genesis.ExtraData[32+i*common.AddressLength:], signer[:])
 		}
+	case "3" == choice:
+		genesis.Difficulty = big.NewInt(1)
+		genesis.Config.Aura = &params.AuraConfig{
+			Period: 5,
+			Epoch:  30000,
+		}
+		fmt.Println()
+		fmt.Println("How many seconds should round take? (default = 5)")
+		genesis.Config.Aura.Period = uint64(w.readDefaultInt(5))
+
+		// We also need the initial list of signers
+		fmt.Println()
+		fmt.Println("Which accounts are allowed to seal? (mandatory at least one)")
+
+		signers := readSigners()
+		auraConfig := genesis.Config.Aura
+		auraConfig.Authorities = make([]common.Address, len(signers))
 
+		for i, signer := range signers {
+			genesis.Config.Aura.Authorities[i] = signer
+		}
 	default:
 		log.Crit("Invalid consensus engine choice", "choice", choice)
 	}

cmd/puppeth/wizard_node.go

@@ -118,7 +118,8 @@ func (w *wizard) deployNode(boot bool) {
 				fmt.Printf("What address should the miner use? (default = %s)\n", infos.etherbase)
 				infos.etherbase = w.readDefaultAddress(common.HexToAddress(infos.etherbase)).Hex()
 			}
-		} else if w.conf.Genesis.Config.Clique != nil {
+		}
+		if w.conf.Genesis.Config.Clique != nil || w.conf.Genesis.Config.Aura != nil {
 			// If a previous signer was already set, offer to reuse it
 			if infos.keyJSON != "" {
 				if key, err := keystore.DecryptKey([]byte(infos.keyJSON), infos.keyPass); err != nil {
@@ -167,7 +168,13 @@ func (w *wizard) deployNode(boot bool) {
 		fmt.Printf("Should the node be built from scratch (y/n)? (default = no)\n")
 		nocache = w.readDefaultYesNo(false)
 	}
-	if out, err := deployNode(client, w.network, w.conf.bootnodes, infos, nocache); err != nil {
+
+	dockerImage := "ethereum/client-go:latest"
+	fmt.Println()
+	fmt.Printf("Please provide geth docker image you would like to use (y/n)? (default = %s)\n", dockerImage)
+	dockerImage = w.readDefaultString(dockerImage)
+
+	if out, err := deployNode(client, w.network, w.conf.bootnodes, infos, nocache, dockerImage); err != nil {
 		log.Error("Failed to deploy Ethereum node container", "err", err)
 		if len(out) > 0 {
 			fmt.Printf("%s\n", out)

cmd/utils/flags.go

@@ -20,6 +20,7 @@ package utils
 import (
 	"crypto/ecdsa"
 	"fmt"
+	"github.com/ethereum/go-ethereum/consensus/aura"
 	"io"
 	"io/ioutil"
 	"math/big"
@@ -135,6 +136,10 @@ var (
 		Name:  "goerli",
 		Usage: "Görli network: pre-configured proof-of-authority test network",
 	}
+	LuksoFlag = cli.BoolFlag{
+		Name: "luksoAura",
+		Usage: "Lukso aura network: pre-configured proof-of-authority(Aura) test network",
+	}
 	YoloV1Flag = cli.BoolFlag{
 		Name:  "yolov1",
 		Usage: "YOLOv1 network: pre-configured proof-of-authority shortlived test network.",
@@ -744,6 +749,9 @@ func MakeDataDir(ctx *cli.Context) string {
 		if ctx.GlobalBool(GoerliFlag.Name) {
 			return filepath.Join(path, "goerli")
 		}
+		if ctx.GlobalBool(LuksoFlag.Name) {
+			return filepath.Join(path, "lukso")
+		}
 		if ctx.GlobalBool(YoloV1Flag.Name) {
 			return filepath.Join(path, "yolo-v1")
 		}
@@ -803,6 +811,8 @@ func setBootstrapNodes(ctx *cli.Context, cfg *p2p.Config) {
 		urls = params.RinkebyBootnodes
 	case ctx.GlobalBool(GoerliFlag.Name):
 		urls = params.GoerliBootnodes
+	case ctx.GlobalBool(LuksoFlag.Name):
+		urls = params.LuksoBootnodes
 	case ctx.GlobalBool(YoloV1Flag.Name):
 		urls = params.YoloV1Bootnodes
 	case cfg.BootstrapNodes != nil:
@@ -839,6 +849,8 @@ func setBootstrapNodesV5(ctx *cli.Context, cfg *p2p.Config) {
 		urls = params.RinkebyBootnodes
 	case ctx.GlobalBool(GoerliFlag.Name):
 		urls = params.GoerliBootnodes
+	case ctx.GlobalBool(LuksoFlag.Name):
+		urls = params.LuksoBootnodes
 	case ctx.GlobalBool(YoloV1Flag.Name):
 		urls = params.YoloV1Bootnodes
 	case cfg.BootstrapNodesV5 != nil:
@@ -1270,6 +1282,8 @@ 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(LuksoFlag.Name) && cfg.DataDir == node.DefaultDataDir():
+		cfg.DataDir = filepath.Join(node.DefaultDataDir(), "lukso")
 	case ctx.GlobalBool(YoloV1Flag.Name) && cfg.DataDir == node.DefaultDataDir():
 		cfg.DataDir = filepath.Join(node.DefaultDataDir(), "yolo-v1")
 	}
@@ -1484,7 +1498,7 @@ func SetShhConfig(ctx *cli.Context, stack *node.Node) {
 // SetEthConfig applies eth-related command line flags to the config.
 func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
 	// Avoid conflicting network flags
-	CheckExclusive(ctx, DeveloperFlag, LegacyTestnetFlag, RopstenFlag, RinkebyFlag, GoerliFlag, YoloV1Flag)
+	CheckExclusive(ctx, DeveloperFlag, LegacyTestnetFlag, RopstenFlag, RinkebyFlag, GoerliFlag, LuksoFlag, YoloV1Flag)
 	CheckExclusive(ctx, LegacyLightServFlag, LightServeFlag, SyncModeFlag, "light")
 	CheckExclusive(ctx, DeveloperFlag, ExternalSignerFlag) // Can't use both ephemeral unlocked and external signer
 	CheckExclusive(ctx, GCModeFlag, "archive", TxLookupLimitFlag)
@@ -1604,6 +1618,12 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) {
 		}
 		cfg.Genesis = core.DefaultGoerliGenesisBlock()
 		setDNSDiscoveryDefaults(cfg, params.GoerliGenesisHash)
+	case ctx.GlobalBool(LuksoFlag.Name):
+		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
+			cfg.NetworkId = 5
+		}
+		cfg.Genesis = core.DefaultLuksoGenesisBlock()
+		setDNSDiscoveryDefaults(cfg, params.LuksoGenesisHash)
 	case ctx.GlobalBool(YoloV1Flag.Name):
 		if !ctx.GlobalIsSet(NetworkIdFlag.Name) {
 			cfg.NetworkId = 133519467574833 // "yolov1"
@@ -1792,6 +1812,8 @@ func MakeGenesis(ctx *cli.Context) *core.Genesis {
 		genesis = core.DefaultRinkebyGenesisBlock()
 	case ctx.GlobalBool(GoerliFlag.Name):
 		genesis = core.DefaultGoerliGenesisBlock()
+	case ctx.GlobalBool(LuksoFlag.Name):
+		genesis = core.DefaultLuksoGenesisBlock()
 	case ctx.GlobalBool(YoloV1Flag.Name):
 		genesis = core.DefaultYoloV1GenesisBlock()
 	case ctx.GlobalBool(DeveloperFlag.Name):
@@ -1811,6 +1833,8 @@ func MakeChain(ctx *cli.Context, stack *node.Node, readOnly bool) (chain *core.B
 	var engine consensus.Engine
 	if config.Clique != nil {
 		engine = clique.New(config.Clique, chainDb)
+	} else if config.Aura != nil {
+		engine = aura.New(config.Aura, chainDb)
 	} else {
 		engine = ethash.NewFaker()
 		if !ctx.GlobalBool(FakePoWFlag.Name) {