Author a sibling block in case best block's slot is same as current slot

dot/core/mocks_generate.go

@@ -0,0 +1,6 @@
+// Copyright 2022 ChainSafe Systems (ON)
+// SPDX-License-Identifier: LGPL-3.0-only
+
+package core
+
+//go:generate mockgen -destination=mocks.go -package $GOPACKAGE . BlockState,StorageState,TransactionState,Network,EpochState,CodeSubstitutedState,RuntimeInstance

dot/services.go

@@ -175,6 +175,7 @@ func (nb nodeBuilder) createBABEService(cfg *Config, st *state.Service, ks keyst
 	cs *core.Service, telemetryMailer telemetry.Client) (babe.ServiceIFace, error) {
 	return nb.createBABEServiceWithBuilder(cfg, st, ks, cs, telemetryMailer, babe.Builder{})
 }
+
 func (nodeBuilder) createBABEServiceWithBuilder(cfg *Config, st *state.Service, ks keystore.Keystore,
 	cs *core.Service, telemetryMailer telemetry.Client, newBabeService ServiceBuilder) (babe.
 	ServiceIFace, error) {

dot/state/block_notify.go

@@ -68,6 +68,7 @@ func (bs *BlockState) notifyImported(block *types.Block) {
 			}
 		}(ch)
 	}
+
 }
 
 func (bs *BlockState) notifyFinalized(hash common.Hash, round, setID uint64) {

dot/types/authority.go

@@ -16,7 +16,9 @@ import (
 
 // Authority struct to hold authority data
 type Authority struct {
-	Key    crypto.PublicKey
+	Key crypto.PublicKey
+	// Weight exists for potential improvements in the protocol and could
+	// have a use-case in the future. In polkadot all authorities have the weight = 1.
 	Weight uint64
 }
 

lib/babe/babe.go

@@ -467,6 +467,30 @@ func (b *Service) handleSlot(epoch, slotNum uint64,
 		return errNilParentHeader
 	}
 
+	atGenesisBlock := b.blockState.GenesisHash().Equal(parentHeader.Hash())
+	if !atGenesisBlock {
+		bestBlockSlotNum, err := b.blockState.GetSlotForBlock(parentHeader.Hash())
+		if err != nil {
+			return fmt.Errorf("could not get slot for block %s: %w", parentHeader.Hash(), err)
+		}
+
+		if bestBlockSlotNum > slotNum {
+			return errLaggingSlot
+		}
+
+		if bestBlockSlotNum == slotNum {
+			// pick parent of best block instead to handle slot
+			newParentHeader, err := b.blockState.GetHeader(parentHeader.ParentHash)
+			if err != nil {
+				return fmt.Errorf("could not get header for hash %s: %w", parentHeader.ParentHash, err)
+			}
+			if newParentHeader == nil {
+				return errNilParentHeader
+			}
+			parentHeader = newParentHeader
+		}
+	}
+
 	// there is a chance that the best block header may change in the course of building the block,
 	// so let's copy it first.
 	parent, err := parentHeader.DeepCopy()

lib/babe/babe_integration_test.go

@@ -6,7 +6,6 @@
 package babe
 
 import (
-	"path/filepath"
 	"testing"
 	"time"
 
@@ -15,17 +14,17 @@ import (
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/internal/log"
 	"github.com/ChainSafe/gossamer/lib/babe/mocks"
+	"github.com/ChainSafe/gossamer/lib/common"
 	"github.com/ChainSafe/gossamer/lib/crypto/sr25519"
 	"github.com/ChainSafe/gossamer/lib/genesis"
 	"github.com/ChainSafe/gossamer/lib/runtime"
 	rtstorage "github.com/ChainSafe/gossamer/lib/runtime/storage"
 	"github.com/ChainSafe/gossamer/lib/runtime/wasmer"
 	"github.com/ChainSafe/gossamer/lib/trie"
-	"github.com/ChainSafe/gossamer/lib/utils"
 	"github.com/ChainSafe/gossamer/pkg/scale"
 	"github.com/golang/mock/gomock"
 
-	mock "github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
 
@@ -80,37 +79,32 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service {
 
 	cfg.Telemetry = telemetryMock
 
-	if cfg.TransactionState == nil {
-		cfg.TransactionState = state.NewTransactionState(telemetryMock)
-	}
-
 	testDatadirPath := t.TempDir()
 	require.NoError(t, err)
 
 	var dbSrv *state.Service
-	if cfg.BlockState == nil || cfg.StorageState == nil || cfg.EpochState == nil {
-		config := state.Config{
-			Path:      testDatadirPath,
-			LogLevel:  log.Info,
-			Telemetry: telemetryMock,
-		}
-		dbSrv = state.NewService(config)
-		dbSrv.UseMemDB()
+	config := state.Config{
+		Path:      testDatadirPath,
+		LogLevel:  log.Info,
+		Telemetry: telemetryMock,
+	}
+	dbSrv = state.NewService(config)
+	dbSrv.UseMemDB()
 
-		err = dbSrv.Initialise(gen, genHeader, genTrie)
-		require.NoError(t, err)
+	err = dbSrv.Initialise(gen, genHeader, genTrie)
+	require.NoError(t, err)
 
-		err = dbSrv.Start()
-		require.NoError(t, err)
+	err = dbSrv.Start()
+	require.NoError(t, err)
 
-		t.Cleanup(func() {
-			_ = dbSrv.Stop()
-		})
+	t.Cleanup(func() {
+		_ = dbSrv.Stop()
+	})
 
-		cfg.BlockState = dbSrv.Block
-		cfg.StorageState = dbSrv.Storage
-		cfg.EpochState = dbSrv.Epoch
-	}
+	cfg.BlockState = dbSrv.Block
+	cfg.StorageState = dbSrv.Storage
+	cfg.EpochState = dbSrv.Epoch
+	cfg.TransactionState = dbSrv.Transaction
 
 	var rtCfg wasmer.Config
 	rtCfg.Storage = rtstorage.NewTrieState(genTrie)
@@ -120,12 +114,7 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service {
 	require.NoError(t, err)
 
 	nodeStorage := runtime.NodeStorage{}
-	if dbSrv != nil {
-		nodeStorage.BaseDB = dbSrv.Base
-	} else {
-		nodeStorage.BaseDB, err = utils.SetupDatabase(filepath.Join(testDatadirPath, "offline_storage"), false)
-		require.NoError(t, err)
-	}
+	nodeStorage.BaseDB = dbSrv.Base
 
 	rtCfg.NodeStorage = nodeStorage
 	rt, err := wasmer.NewRuntimeFromGenesis(rtCfg)
@@ -136,6 +125,26 @@ func createTestService(t *testing.T, cfg ServiceConfig) *Service {
 	cfg.LogLvl = defaultTestLogLvl
 	babeService, err := NewService(&cfg)
 	require.NoError(t, err)
+
+	if cfg.BlockImportHandler == nil {
+		mockNetwork := core.NewMockNetwork(ctrl)
+		mockNetwork.EXPECT().GossipMessage(gomock.Any()).AnyTimes()
+
+		coreConfig := core.Config{
+			BlockState:           dbSrv.Block,
+			EpochState:           dbSrv.Epoch,
+			StorageState:         storageState,
+			TransactionState:     dbSrv.Transaction,
+			Runtime:              rt,
+			Keystore:             rtCfg.Keystore,
+			Network:              mockNetwork,
+			CodeSubstitutedState: dbSrv.Base,
+			CodeSubstitutes:      make(map[common.Hash]string),
+		}
+
+		babeService.blockImportHandler = core.NewTestService(t, &coreConfig)
+	}
+
 	return babeService
 }
 
@@ -257,17 +266,15 @@ func TestService_GetAuthorityIndex(t *testing.T) {
 }
 
 func TestStartAndStop(t *testing.T) {
-	serviceConfig := ServiceConfig{}
-	bs := createTestService(t, serviceConfig)
+	bs := createTestService(t, ServiceConfig{})
 	err := bs.Start()
 	require.NoError(t, err)
 	err = bs.Stop()
 	require.NoError(t, err)
 }
 
 func TestService_PauseAndResume(t *testing.T) {
-	serviceConfig := ServiceConfig{}
-	bs := createTestService(t, serviceConfig)
+	bs := createTestService(t, ServiceConfig{})
 	err := bs.Start()
 	require.NoError(t, err)
 	time.Sleep(time.Second)
@@ -293,3 +300,160 @@ func TestService_PauseAndResume(t *testing.T) {
 	err = bs.Stop()
 	require.NoError(t, err)
 }
+
+func TestService_HandleSlotWithLaggingSlot(t *testing.T) {
+	cfg := ServiceConfig{
+		Authority: true,
+		Lead:      true,
+	}
+	babeService := createTestService(t, cfg)
+
+	err := babeService.Start()
+	require.NoError(t, err)
+	defer func() {
+		_ = babeService.Stop()
+	}()
+
+	// add a block
+	parentHash := babeService.blockState.GenesisHash()
+	rt, err := babeService.blockState.GetRuntime(nil)
+	require.NoError(t, err)
+
+	epochData, err := babeService.initiateEpoch(testEpochIndex)
+	require.NoError(t, err)
+
+	ext := runtime.NewTestExtrinsic(t, rt, parentHash, parentHash, 0, "System.remark", []byte{0xab, 0xcd})
+	block := createTestBlock(t, babeService, emptyHeader, [][]byte{common.MustHexToBytes(ext)},
+		1, testEpochIndex, epochData)
+
+	babeService.blockState.AddBlock(block)
+	time.Sleep(babeService.constants.slotDuration * 1)
+
+	header, err := babeService.blockState.BestBlockHeader()
+	require.NoError(t, err)
+
+	bestBlockSlotNum, err := babeService.blockState.GetSlotForBlock(header.Hash())
+	require.NoError(t, err)
+
+	slotnum := uint64(1)
+	slot := Slot{
+		start:    time.Now(),
+		duration: 1 * time.Second,
+		number:   slotnum,
+	}
+	testVRFOutputAndProof := &VrfOutputAndProof{}
+	preRuntimeDigest, err := types.NewBabePrimaryPreDigest(
+		0, slot.number,
+		testVRFOutputAndProof.output,
+		testVRFOutputAndProof.proof,
+	).ToPreRuntimeDigest()
+
+	require.NoError(t, err)
+
+	err = babeService.handleSlot(
+		babeService.epochHandler.epochNumber,
+		bestBlockSlotNum-1,
+		babeService.epochHandler.epochData.authorityIndex,
+		preRuntimeDigest)
+
+	require.ErrorIs(t, err, errLaggingSlot)
+}
+
+func TestService_HandleSlotWithSameSlot(t *testing.T) {
+	alice := keyring.Alice().(*sr25519.Keypair)
+	bob := keyring.Bob().(*sr25519.Keypair)
+
+	// Create babe service for alice
+	cfgAlice := ServiceConfig{
+		Authority: true,
+		Lead:      true,
+		Keypair:   alice,
+	}
+	cfgAlice.AuthData = []types.Authority{
+		{
+			Key:    alice.Public().(*sr25519.PublicKey),
+			Weight: 1,
+		},
+		{
+			Key:    bob.Public().(*sr25519.PublicKey),
+			Weight: 1,
+		},
+	}
+
+	// Create babe service for bob
+	cfgBob := ServiceConfig{
+		Authority: true,
+		Lead:      true,
+		Keypair:   bob,
+	}
+	cfgBob.AuthData = []types.Authority{
+		{
+			Key:    alice.Public().(*sr25519.PublicKey),
+			Weight: 1,
+		},
+		{
+			Key:    bob.Public().(*sr25519.PublicKey),
+			Weight: 1,
+		},
+	}
+
+	babeServiceBob := createTestService(t, cfgBob)
+
+	err := babeServiceBob.Start()
+	require.NoError(t, err)
+	defer func() {
+		_ = babeServiceBob.Stop()
+	}()
+
+	// wait till bob creates a block
+	time.Sleep(babeServiceBob.constants.slotDuration * 1)
+	require.NoError(t, err)
+
+	block, err := babeServiceBob.blockState.GetBlockByNumber(1)
+	require.NoError(t, err)
+
+	err = babeServiceBob.Stop()
+	require.NoError(t, err)
+
+	time.Sleep(babeServiceBob.constants.slotDuration * 1)
+
+	babeServiceAlice := createTestService(t, cfgAlice)
+
+	// Add block created by Bob to Alice
+	err = babeServiceAlice.blockState.AddBlock(block)
+	require.NoError(t, err)
+
+	time.Sleep(babeServiceBob.constants.slotDuration * 1)
+
+	bestBlockHeader, err := babeServiceAlice.blockState.BestBlockHeader()
+	require.NoError(t, err)
+	require.Equal(t, block.Header.Hash().String(), bestBlockHeader.Hash().String())
+
+	// If the slot we are claiming is same as slot in best header, test that we don't
+	// through any error and can claim slot.
+	bestBlockSlotNum, err := babeServiceAlice.blockState.GetSlotForBlock(bestBlockHeader.Hash())
+	require.NoError(t, err)
+
+	slot := Slot{
+		start:    time.Now(),
+		duration: 1 * time.Second,
+		number:   bestBlockSlotNum,
+	}
+	testVRFOutputAndProof := &VrfOutputAndProof{}
+	preRuntimeDigest, err := types.NewBabePrimaryPreDigest(
+		0, slot.number,
+		testVRFOutputAndProof.output,
+		testVRFOutputAndProof.proof,
+	).ToPreRuntimeDigest()
+	require.NoError(t, err)
+
+	// slot gets occupied even if it has been occupied by a block
+	// authored by someone else
+	err = babeServiceAlice.handleSlot(
+		testEpochIndex,
+		bestBlockSlotNum,
+		0,
+		preRuntimeDigest)
+	require.NoError(t, err)
+
+}