fix(lib/babe): add --babe-lead flag, update epoch handling logic

chain/dev/config.toml

@@ -24,6 +24,7 @@ unlock = ""
 roles = 4
 babe-authority = true
 grandpa-authority = true
+babe-lead = true
 
 [network]
 port = 7001

chain/gssmr/config.toml

@@ -30,6 +30,7 @@ port = 7001
 nobootstrap = false
 nomdns = false
 discovery-interval = 10
+min-peers = 1
 
 [rpc]
 enabled = false

chain/gssmr/defaults.go

@@ -81,6 +81,8 @@ var (
 	DefaultNoBootstrap = false
 	// DefaultNoMDNS disables mDNS discovery
 	DefaultNoMDNS = false
+	// DefaultMinPeers is the default minimum desired peer count
+	DefaultMinPeers = 1
 
 	// DefaultDiscoveryInterval is the default interval for searching for DHT peers
 	DefaultDiscoveryInterval = time.Second * 10

cmd/gossamer/config.go

@@ -555,6 +555,7 @@ func setDotCoreConfig(ctx *cli.Context, tomlCfg ctoml.CoreConfig, cfg *dot.CoreC
 	cfg.Roles = tomlCfg.Roles
 	cfg.BabeAuthority = tomlCfg.Roles == types.AuthorityRole
 	cfg.GrandpaAuthority = tomlCfg.Roles == types.AuthorityRole
+	cfg.BABELead = ctx.GlobalBool(BABELeadFlag.Name)
 
 	// check --roles flag and update node configuration
 	if roles := ctx.GlobalString(RolesFlag.Name); roles != "" {

cmd/gossamer/flags.go

@@ -316,6 +316,14 @@ var (
 	}
 )
 
+// BABE flags
+var (
+	BABELeadFlag = cli.BoolFlag{
+		Name:  "babe-lead",
+		Usage: `specify whether node should build block 1 of the network. only used when starting a new network`,
+	}
+)
+
 // flag sets that are shared by multiple commands
 var (
 	// GlobalFlags are flags that are valid for use with the root command and all subcommands
@@ -366,6 +374,9 @@ var (
 
 		// telemetry flags
 		NoTelemetryFlag,
+
+		// BABE flags
+		BABELeadFlag,
 	}
 )
 

dot/config.go

@@ -98,6 +98,7 @@ type NetworkConfig struct {
 type CoreConfig struct {
 	Roles            byte
 	BabeAuthority    bool
+	BABELead         bool
 	GrandpaAuthority bool
 	WasmInterpreter  string
 }
@@ -183,6 +184,7 @@ func GssmrConfig() *Config {
 			NoBootstrap:       gssmr.DefaultNoBootstrap,
 			NoMDNS:            gssmr.DefaultNoMDNS,
 			DiscoveryInterval: gssmr.DefaultDiscoveryInterval,
+			MinPeers:          gssmr.DefaultMinPeers,
 		},
 		RPC: RPCConfig{
 			Port:    gssmr.DefaultRPCHTTPPort,

dot/config/toml/config.go

@@ -82,6 +82,7 @@ type CoreConfig struct {
 	SlotDuration     uint64 `toml:"slot-duration,omitempty"`
 	EpochLength      uint64 `toml:"epoch-length,omitempty"`
 	WasmInterpreter  string `toml:"wasm-interpreter,omitempty"`
+	BabeLead         bool   `toml:"babe-lead,omitempty"`
 }
 
 // RPCConfig is to marshal/unmarshal toml RPC config vars

dot/core/service.go

@@ -248,12 +248,6 @@ func (s *Service) handleBlock(block *types.Block, state *rtstorage.TrieState) er
 		return err
 	}
 
-	// check if block production epoch transitioned
-	if err := s.handleCurrentSlot(&block.Header); err != nil {
-		logger.Warn("failed to handle epoch for block", "block", block.Header.Hash(), "error", err)
-		return err
-	}
-
 	go func() {
 		s.Lock()
 		defer s.Unlock()
@@ -313,29 +307,6 @@ func (s *Service) handleCodeSubstitution(hash common.Hash, state *rtstorage.Trie
 	return nil
 }
 
-func (s *Service) handleCurrentSlot(header *types.Header) error {
-	head := s.blockState.BestBlockHash()
-	if header.Hash() != head {
-		return nil
-	}
-
-	epoch, err := s.epochState.GetEpochForBlock(header)
-	if err != nil {
-		return err
-	}
-
-	currEpoch, err := s.epochState.GetCurrentEpoch()
-	if err != nil {
-		return err
-	}
-
-	if currEpoch == epoch {
-		return nil
-	}
-
-	return s.epochState.SetCurrentEpoch(epoch)
-}
-
 // handleBlocksAsync handles a block asynchronously; the handling performed by this function
 // does not need to be completed before the next block can be imported.
 func (s *Service) handleBlocksAsync() {

dot/services.go

@@ -199,6 +199,7 @@ func createBABEService(cfg *Config, st *state.Service, ks keystore.Keystore, cs
 		BlockImportHandler: cs,
 		Authority:          cfg.Core.BabeAuthority,
 		IsDev:              cfg.Global.ID == "dev",
+		Lead:               cfg.Core.BABELead,
 	}
 
 	if cfg.Core.BabeAuthority {

lib/babe/babe.go

@@ -28,13 +28,14 @@ import (
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/crypto/sr25519"
 	"github.com/ChainSafe/gossamer/lib/runtime"
+
 	log "github.com/ChainSafe/log15"
 	ethmetrics "github.com/ethereum/go-ethereum/metrics"
 )
 
 var (
-	logger          log.Logger
-	initialWaitTime time.Duration
+	logger            log.Logger
+	firstBlockTimeout = time.Minute
 )
 
 // Service contains the VRF keys for the validator, as well as BABE configuation data
@@ -43,6 +44,10 @@ type Service struct {
 	cancel    context.CancelFunc
 	authority bool
 	dev       bool
+	// lead is used when setting up a new network from genesis.
+	// the "lead" node is the node that is designated to build block 1, after which the rest of the nodes
+	// will sync it and determine the first slot of the network based on that block
+	lead bool
 
 	// Storage interfaces
 	blockState       BlockState
@@ -79,6 +84,7 @@ type ServiceConfig struct {
 	AuthData           []types.Authority
 	IsDev              bool
 	Authority          bool
+	Lead               bool
 }
 
 // NewService returns a new Babe Service using the provided VRF keys and runtime
@@ -119,20 +125,18 @@ func NewService(cfg *ServiceConfig) (*Service, error) {
 		authority:          cfg.Authority,
 		dev:                cfg.IsDev,
 		blockImportHandler: cfg.BlockImportHandler,
+		lead:               cfg.Lead,
 	}
 
 	epoch, err := cfg.EpochState.GetCurrentEpoch()
 	if err != nil {
 		return nil, err
 	}
 
-	err = babeService.setupParameters(cfg)
-	if err != nil {
+	if err = babeService.setupParameters(cfg); err != nil {
 		return nil, err
 	}
 
-	initialWaitTime = babeService.slotDuration * 5
-
 	logger.Debug("created service",
 		"epoch", epoch,
 		"block producer", cfg.Authority,
@@ -143,6 +147,11 @@ func NewService(cfg *ServiceConfig) (*Service, error) {
 		"threshold", babeService.epochData.threshold,
 		"randomness", babeService.epochData.randomness,
 	)
+
+	if cfg.Lead {
+		logger.Debug("node designated to build block 1")
+	}
+
 	return babeService, nil
 }
 
@@ -191,13 +200,41 @@ func (b *Service) Start() error {
 		return nil
 	}
 
-	// wait a bit to check if we need to sync before initiating
-	<-time.NewTimer(initialWaitTime).C
+	go func() {
+		// if we aren't leading node, wait for first block
+		if !b.lead {
+			if err := b.waitForFirstBlock(); err != nil {
+				logger.Crit("failed to start BABE", "error", err)
+			}
+		}
+
+		b.initiate()
+	}()
 
-	go b.initiate()
 	return nil
 }
 
+func (b *Service) waitForFirstBlock() error {
+	ch := b.blockState.GetImportedBlockNotifierChannel()
+	defer b.blockState.FreeImportedBlockNotifierChannel(ch)
+
+	timeout := time.After(firstBlockTimeout)
+
+	// loop until block 1
+	for {
+		select {
+		case block := <-ch:
+			if block != nil && block.Header.Number.Int64() > 0 {
+				return nil
+			}
+		case <-timeout:
+			return errFirstBlockTimeout
+		case <-b.ctx.Done():
+			return nil
+		}
+	}
+}
+
 // SlotDuration returns the current service slot duration in milliseconds
 func (b *Service) SlotDuration() uint64 {
 	return uint64(b.slotDuration.Milliseconds())
@@ -327,6 +364,12 @@ func (b *Service) invokeBlockAuthoring() error {
 			return err
 		}
 
+		logger.Debug("initiated epoch",
+			"threshold", b.epochData.threshold,
+			"randomness", b.epochData.randomness,
+			"authorities", b.epochData.authorities,
+		)
+
 		epochStartSlot, err := b.waitForEpochStart(epoch)
 		if err != nil {
 			logger.Error("failed to wait for epoch start", "epoch", epoch, "error", err)
@@ -355,12 +398,25 @@ func (b *Service) invokeBlockAuthoring() error {
 
 		logger.Info("current epoch", "epoch", epoch, "slots into epoch", intoEpoch)
 
+		// get start slot for current epoch
+		nextEpochStart, err := b.epochState.GetStartSlotForEpoch(epoch + 1)
+		if err != nil {
+			logger.Error("failed to get start slot for next epoch", "epoch", epoch, "error", err)
+			return err
+		}
+
+		nextEpochStartTime := getSlotStartTime(nextEpochStart, b.slotDuration)
+		epochDoneCtx, cancel := context.WithDeadline(context.Background(), nextEpochStartTime)
+		defer cancel()
+
 		slotDone := make([]<-chan time.Time, b.epochLength-intoEpoch)
 		for i := 0; i < int(b.epochLength-intoEpoch); i++ {
 			slotDone[i] = time.After(b.getSlotDuration() * time.Duration(i))
 		}
 
 		for i := 0; i < int(b.epochLength-intoEpoch); i++ {
+			done := false
+
 			select {
 			case <-b.ctx.Done():
 				return nil
@@ -380,6 +436,12 @@ func (b *Service) invokeBlockAuthoring() error {
 					logger.Warn("failed to handle slot", "slot", slotNum, "error", err)
 					continue
 				}
+			case <-epochDoneCtx.Done():
+				done = true
+			}
+
+			if done {
+				break
 			}
 		}
 
@@ -489,7 +551,7 @@ func (b *Service) handleSlot(epoch, slotNum uint64) error {
 		"epoch", epoch,
 		"slot", slotNum,
 	)
-	logger.Debug("built block",
+	logger.Trace("built block",
 		"header", block.Header,
 		"body", block.Body,
 		"parent", parent.Hash(),

lib/babe/babe_test.go

@@ -323,6 +323,7 @@ func TestService_SlotDuration(t *testing.T) {
 
 func TestService_ProducesBlocks(t *testing.T) {
 	babeService := createTestService(t, nil)
+	babeService.lead = true
 
 	babeService.epochData.authorityIndex = 0
 	babeService.epochData.authorities = []types.Authority{

lib/babe/epoch.go

@@ -83,7 +83,7 @@ func (b *Service) initiateEpoch(epoch uint64) error {
 				randomness:     data.Randomness,
 				authorities:    data.Authorities,
 				authorityIndex: idx,
-				threshold:      b.epochData.threshold,
+				threshold:      b.epochData.threshold, // TODO: threshold might change if authority count changes
 			}
 		}
 

lib/babe/errors.go

@@ -59,6 +59,7 @@ var (
 	errNilEpochState         = errors.New("cannot have nil EpochState")
 	errInvalidResult         = errors.New("invalid error value")
 	errNoEpochData           = errors.New("no epoch data found for upcoming epoch")
+	errFirstBlockTimeout     = errors.New("timed out waiting for first block")
 
 	other         Other
 	invalidCustom InvalidCustom

lib/babe/state.go

@@ -48,6 +48,8 @@ type BlockState interface {
 	NumberIsFinalised(num *big.Int) (bool, error)
 	GetRuntime(*common.Hash) (runtime.Instance, error)
 	StoreRuntime(common.Hash, runtime.Instance)
+	GetImportedBlockNotifierChannel() chan *types.Block
+	FreeImportedBlockNotifierChannel(ch chan *types.Block)
 }
 
 // StorageState interface for storage state methods

tests/rpc/rpc_03-chain_test.go

@@ -75,7 +75,7 @@ func TestChainRPC(t *testing.T) {
 	nodes, err := utils.InitializeAndStartNodes(t, 1, utils.GenesisDev, utils.ConfigDefault)
 	require.Nil(t, err)
 
-	time.Sleep(time.Second) // give server a second to start
+	time.Sleep(time.Second * 5) // give server a second to start
 
 	chainBlockHeaderHash := ""
 	for _, test := range testCases {

tests/utils/gossamer_utils.go

@@ -91,6 +91,7 @@ type Node struct {
 	basePath string
 	config   string
 	WSPort   string
+	BabeLead bool
 }
 
 // InitGossamer initialises given node number and returns node reference
@@ -132,6 +133,10 @@ func StartGossamer(t *testing.T, node *Node, websocket bool) error {
 		"--rpc",
 		"--log", "info"}
 
+	if node.BabeLead {
+		params = append(params, "--babe-lead")
+	}
+
 	if node.Idx >= len(KeyList) {
 		params = append(params, "--roles", "1")
 	} else {
@@ -222,6 +227,10 @@ func RunGossamer(t *testing.T, idx int, basepath, genesis, config string, websoc
 		os.Exit(1)
 	}
 
+	if idx == 0 {
+		node.BabeLead = true
+	}
+
 	err = StartGossamer(t, node, websocket)
 	if err != nil {
 		logger.Crit("could not start gossamer", "error", err)
@@ -501,6 +510,7 @@ func CreateConfigNoBabe() {
 func generateConfigNoGrandpa() *ctoml.Config {
 	cfg := generateDefaultConfig()
 	cfg.Core.GrandpaAuthority = false
+	cfg.Core.BabeLead = true
 	return cfg
 }