Deterministic Proposer Root Boosting in Forkchoice (#10427)

* begin refactor

* fix doubly linked tree tests

* pass

* fix up

* gaz

* buidl

* buidl more

* comment

* args check

Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>

beacon-chain/blockchain/BUILD.bazel

@@ -51,6 +51,7 @@ go_library(
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/protoarray:go_default_library",
+        "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",

beacon-chain/blockchain/process_block.go

@@ -12,6 +12,7 @@ import (
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
 	coreTime "github.com/prysmaticlabs/prysm/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/beacon-chain/core/transition"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/config/features"
 	"github.com/prysmaticlabs/prysm/config/params"
@@ -121,9 +122,13 @@ func (s *Service) onBlock(ctx context.Context, signed block.SignedBeaconBlock, b
 
 	// We add a proposer score boost to fork choice for the block root if applicable, right after
 	// running a successful state transition for the block.
-	if err := s.cfg.ForkChoiceStore.BoostProposerRoot(
-		ctx, signed.Block().Slot(), blockRoot, s.genesisTime,
-	); err != nil {
+	secondsIntoSlot := uint64(time.Since(s.genesisTime).Seconds()) % params.BeaconConfig().SecondsPerSlot
+	if err := s.cfg.ForkChoiceStore.BoostProposerRoot(ctx, &forkchoicetypes.ProposerBoostRootArgs{
+		BlockRoot:       blockRoot,
+		BlockSlot:       signed.Block().Slot(),
+		CurrentSlot:     slots.SinceGenesis(s.genesisTime),
+		SecondsIntoSlot: secondsIntoSlot,
+	}); err != nil {
 		return err
 	}
 

beacon-chain/blockchain/process_block_test.go

@@ -18,6 +18,7 @@ import (
 	testDB "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/protoarray"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/beacon-chain/state/stategen"
 	v1 "github.com/prysmaticlabs/prysm/beacon-chain/state/v1"
@@ -253,7 +254,13 @@ func TestStore_OnBlock_ProposerBoostEarly(t *testing.T) {
 
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.BoostProposerRoot(ctx, 0, [32]byte{'A'}, time.Now()))
+	args := &forkchoicetypes.ProposerBoostRootArgs{
+		BlockRoot:       [32]byte{'A'},
+		BlockSlot:       types.Slot(0),
+		CurrentSlot:     0,
+		SecondsIntoSlot: 0,
+	}
+	require.NoError(t, service.cfg.ForkChoiceStore.BoostProposerRoot(ctx, args))
 	_, err = service.cfg.ForkChoiceStore.Head(ctx, 0,
 		params.BeaconConfig().ZeroHash, []uint64{}, 0)
 	require.ErrorContains(t, "could not apply proposer boost score: invalid proposer boost root", err)

beacon-chain/forkchoice/BUILD.bazel

@@ -12,6 +12,7 @@ go_library(
         "//testing/spectest:__subpackages__",
     ],
     deps = [
+        "//beacon-chain/forkchoice/types:go_default_library",
         "//config/fieldparams:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_prysmaticlabs_eth2_types//:go_default_library",

beacon-chain/forkchoice/doubly-linked-tree/BUILD.bazel

@@ -19,10 +19,10 @@ go_library(
         "//testing/spectest:__subpackages__",
     ],
     deps = [
+        "//beacon-chain/forkchoice/types:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
@@ -45,6 +45,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//beacon-chain/forkchoice/types:go_default_library",
         "//config/params:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/forkchoice/doubly-linked-tree/proposer_boost.go

@@ -2,12 +2,10 @@ package doublylinkedtree
 
 import (
 	"context"
-	"time"
 
 	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
 // BoostProposerRoot sets the block root which should be boosted during
@@ -19,17 +17,18 @@ import (
 //  is_before_attesting_interval = time_into_slot < SECONDS_PER_SLOT // INTERVALS_PER_SLOT
 //  if get_current_slot(store) == block.slot and is_before_attesting_interval:
 //      store.proposer_boost_root = hash_tree_root(block)
-func (f *ForkChoice) BoostProposerRoot(_ context.Context, blockSlot types.Slot, blockRoot [32]byte, genesisTime time.Time) error {
+func (f *ForkChoice) BoostProposerRoot(_ context.Context, args *forkchoicetypes.ProposerBoostRootArgs) error {
+	if args == nil {
+		return errors.New("nil function args provided to BoostProposerRoot")
+	}
 	secondsPerSlot := params.BeaconConfig().SecondsPerSlot
-	timeIntoSlot := uint64(time.Since(genesisTime).Seconds()) % secondsPerSlot
-	isBeforeAttestingInterval := timeIntoSlot < secondsPerSlot/params.BeaconConfig().IntervalsPerSlot
-	currentSlot := slots.SinceGenesis(genesisTime)
+	isBeforeAttestingInterval := args.SecondsIntoSlot < secondsPerSlot/params.BeaconConfig().IntervalsPerSlot
 
 	// Only update the boosted proposer root to the incoming block root
 	// if the block is for the current, clock-based slot and the block was timely.
-	if currentSlot == blockSlot && isBeforeAttestingInterval {
+	if args.CurrentSlot == args.BlockSlot && isBeforeAttestingInterval {
 		f.store.proposerBoostLock.Lock()
-		f.store.proposerBoostRoot = blockRoot
+		f.store.proposerBoostRoot = args.BlockRoot
 		f.store.proposerBoostLock.Unlock()
 	}
 	return nil

beacon-chain/forkchoice/doubly-linked-tree/proposer_boost_test.go

@@ -2,11 +2,11 @@ package doublylinkedtree
 
 import (
 	"context"
-	"fmt"
 	"testing"
 	"time"
 
 	types "github.com/prysmaticlabs/eth2-types"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -26,6 +26,11 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		balances[i] = 10
 	}
 	jEpoch, fEpoch := types.Epoch(0), types.Epoch(0)
+	t.Run("nil args check", func(t *testing.T) {
+		f := setup(jEpoch, fEpoch)
+		err := f.BoostProposerRoot(ctx, nil)
+		require.ErrorContains(t, "nil function args", err)
+	})
 	t.Run("back-propagates boost score to ancestors after proposer boosting", func(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
@@ -128,9 +133,14 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 			),
 		)
 		f.ProcessAttestation(ctx, []uint64{3}, newRoot, fEpoch)
-		threeSlots := 3 * params.BeaconConfig().SecondsPerSlot
-		genesisTime := time.Now().Add(-time.Second * time.Duration(threeSlots))
-		require.NoError(t, f.BoostProposerRoot(ctx, slot, newRoot, genesisTime))
+		clockSlot := types.Slot(3)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       newRoot,
+			BlockSlot:       slot,
+			CurrentSlot:     clockSlot,
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 		headRoot, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
@@ -221,9 +231,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       honestBlock,
+			BlockSlot:       honestBlockSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// The maliciously withheld block has one vote.
 		votes := []uint64{1}
@@ -289,9 +303,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       honestBlock,
+			BlockSlot:       honestBlockSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// An attestation is received for B that has more voting power than C with the proposer boost,
 		// allowing B to then become the head if their attestation has enough adversarial votes.
@@ -345,9 +363,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost C.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, cSlot /* slot */, c, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       c,
+			BlockSlot:       cSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		bSlot := types.Slot(1)
 		b := indexToHash(1)
@@ -393,8 +415,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Expected C to remain the head")
 
 		// Block D receives the boost.
-		genesis = time.Now().Add(-3 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, dSlot /* slot */, d, genesis))
+		args = &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       d,
+			BlockSlot:       dSlot,
+			CurrentSlot:     types.Slot(3),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// Ensure D becomes the head thanks to boosting.
 		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
@@ -415,12 +442,15 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		f := &ForkChoice{
 			store: &Store{},
 		}
-		// Genesis set to 1 slot ago.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
 		blockRoot := [32]byte{'A'}
-
 		// Trying to boost a block from slot 0 should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(0), blockRoot, genesis)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(0),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: 0,
+		}
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
 	})
@@ -429,14 +459,18 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 			store: &Store{},
 		}
 		// Genesis set to 1 slot ago + X where X > attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		attestingInterval := time.Duration(cfg.SecondsPerSlot / cfg.IntervalsPerSlot)
-		greaterThanAttestingInterval := attestingInterval + 100*time.Millisecond
-		genesis = genesis.Add(-greaterThanAttestingInterval * time.Second)
-		blockRoot := [32]byte{'A'}
+		attestingInterval := time.Duration(cfg.SecondsPerSlot/cfg.IntervalsPerSlot) * time.Second
+		greaterThanAttestingInterval := attestingInterval + time.Second
 
 		// Trying to boost a block from slot 1 that is untimely should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		blockRoot := [32]byte{'A'}
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     1,
+			SecondsIntoSlot: uint64(greaterThanAttestingInterval.Seconds()),
+		}
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
 	})
@@ -445,11 +479,15 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 			store: &Store{},
 		}
 		// Genesis set to 1 slot ago + 0 seconds into the attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		fmt.Println(genesis)
 		blockRoot := [32]byte{'A'}
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: 0,
+		}
 
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
 	})
@@ -457,13 +495,16 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		f := &ForkChoice{
 			store: &Store{},
 		}
-		// Genesis set to 1 slot ago + (attesting interval / 2).
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
 		blockRoot := [32]byte{'A'}
 		halfAttestingInterval := time.Second
-		genesis = genesis.Add(-halfAttestingInterval)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: uint64(halfAttestingInterval.Seconds()),
+		}
 
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
 	})

beacon-chain/forkchoice/interfaces.go

@@ -2,9 +2,9 @@ package forkchoice
 
 import (
 	"context"
-	"time"
 
 	types "github.com/prysmaticlabs/eth2-types"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	fieldparams "github.com/prysmaticlabs/prysm/config/fieldparams"
 	pbrpc "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
 )
@@ -51,7 +51,7 @@ type Pruner interface {
 
 // ProposerBooster is able to boost the proposer's root score during fork choice.
 type ProposerBooster interface {
-	BoostProposerRoot(ctx context.Context, blockSlot types.Slot, blockRoot [32]byte, genesisTime time.Time) error
+	BoostProposerRoot(ctx context.Context, args *forkchoicetypes.ProposerBoostRootArgs) error
 	ResetBoostedProposerRoot(ctx context.Context) error
 }
 

beacon-chain/forkchoice/protoarray/BUILD.bazel

@@ -19,11 +19,11 @@ go_library(
         "//testing/spectest:__subpackages__",
     ],
     deps = [
+        "//beacon-chain/forkchoice/types:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
@@ -46,6 +46,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//beacon-chain/forkchoice/types:go_default_library",
         "//config/params:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/forkchoice/protoarray/proposer_boost.go

@@ -2,12 +2,10 @@ package protoarray
 
 import (
 	"context"
-	"time"
 
 	"github.com/pkg/errors"
-	types "github.com/prysmaticlabs/eth2-types"
+	"github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
-	"github.com/prysmaticlabs/prysm/time/slots"
 )
 
 // BoostProposerRoot sets the block root which should be boosted during
@@ -19,17 +17,18 @@ import (
 //  is_before_attesting_interval = time_into_slot < SECONDS_PER_SLOT // INTERVALS_PER_SLOT
 //  if get_current_slot(store) == block.slot and is_before_attesting_interval:
 //      store.proposer_boost_root = hash_tree_root(block)
-func (f *ForkChoice) BoostProposerRoot(_ context.Context, blockSlot types.Slot, blockRoot [32]byte, genesisTime time.Time) error {
+func (f *ForkChoice) BoostProposerRoot(_ context.Context, args *types.ProposerBoostRootArgs) error {
+	if args == nil {
+		return errors.New("nil function args provided to BoostProposerRoot")
+	}
 	secondsPerSlot := params.BeaconConfig().SecondsPerSlot
-	timeIntoSlot := uint64(time.Since(genesisTime).Seconds()) % secondsPerSlot
-	isBeforeAttestingInterval := timeIntoSlot < secondsPerSlot/params.BeaconConfig().IntervalsPerSlot
-	currentSlot := slots.SinceGenesis(genesisTime)
+	isBeforeAttestingInterval := args.SecondsIntoSlot < secondsPerSlot/params.BeaconConfig().IntervalsPerSlot
 
 	// Only update the boosted proposer root to the incoming block root
 	// if the block is for the current, clock-based slot and the block was timely.
-	if currentSlot == blockSlot && isBeforeAttestingInterval {
+	if args.CurrentSlot == args.BlockSlot && isBeforeAttestingInterval {
 		f.store.proposerBoostLock.Lock()
-		f.store.proposerBoostRoot = blockRoot
+		f.store.proposerBoostRoot = args.BlockRoot
 		f.store.proposerBoostLock.Unlock()
 	}
 	return nil

beacon-chain/forkchoice/protoarray/proposer_boost_test.go

@@ -2,11 +2,11 @@ package protoarray
 
 import (
 	"context"
-	"fmt"
 	"testing"
 	"time"
 
 	types "github.com/prysmaticlabs/eth2-types"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/testing/assert"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -20,12 +20,17 @@ import (
 // If the honest proposal is boosted at slot n+2, it will win against this attacker.
 func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 	ctx := context.Background()
+	jEpoch, fEpoch := types.Epoch(0), types.Epoch(0)
 	zeroHash := params.BeaconConfig().ZeroHash
 	balances := make([]uint64, 64) // 64 active validators.
 	for i := 0; i < len(balances); i++ {
 		balances[i] = 10
 	}
-	jEpoch, fEpoch := types.Epoch(0), types.Epoch(0)
+	t.Run("nil args check", func(t *testing.T) {
+		f := setup(jEpoch, fEpoch)
+		err := f.BoostProposerRoot(ctx, nil)
+		require.ErrorContains(t, "nil function args", err)
+	})
 	t.Run("back-propagates boost score to ancestors after proposer boosting", func(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
 
@@ -88,8 +93,8 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		//         2
 		//         |
 		//         3 <- HEAD
-		slot = types.Slot(2)
-		newRoot = indexToHash(2)
+		slot = types.Slot(3)
+		newRoot = indexToHash(3)
 		require.NoError(t,
 			f.InsertOptimisticBlock(
 				ctx,
@@ -128,15 +133,20 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 			),
 		)
 		f.ProcessAttestation(ctx, []uint64{3}, newRoot, fEpoch)
-		threeSlots := 3 * params.BeaconConfig().SecondsPerSlot
-		genesisTime := time.Now().Add(-time.Second * time.Duration(threeSlots))
-		require.NoError(t, f.BoostProposerRoot(ctx, slot, newRoot, genesisTime))
+		clockSlot := types.Slot(3)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       newRoot,
+			BlockSlot:       slot,
+			CurrentSlot:     clockSlot,
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 		headRoot, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
 
 		// Check the ancestor scores from the store.
-		require.Equal(t, 4, len(f.store.nodes))
+		require.Equal(t, 5, len(f.store.nodes))
 
 		// Expect nodes to have a boosted, back-propagated score.
 		// Ancestors have the added weights of their children. Genesis is a special exception at 0 weight,
@@ -163,7 +173,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// middle instead of the normal progression of (44 -> 34 -> 24).
 		require.Equal(t, f.store.nodes[1].weight, uint64(54))
 		require.Equal(t, f.store.nodes[2].weight, uint64(44))
-		require.Equal(t, f.store.nodes[3].weight, uint64(24))
+		require.Equal(t, f.store.nodes[3].weight, uint64(34))
 	})
 	t.Run("vanilla ex ante attack", func(t *testing.T) {
 		f := setup(jEpoch, fEpoch)
@@ -189,7 +199,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				honestBlockSlot,
 				honestBlock,
 				zeroHash,
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -206,7 +216,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				maliciouslyWithheldBlockSlot,
 				maliciouslyWithheldBlock,
 				zeroHash,
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -218,9 +228,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       honestBlock,
+			BlockSlot:       honestBlockSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// The maliciously withheld block has one vote.
 		votes := []uint64{1}
@@ -255,7 +269,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				honestBlockSlot,
 				honestBlock,
 				zeroHash,
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -274,7 +288,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				maliciouslyWithheldBlockSlot,
 				maliciouslyWithheldBlock,
 				zeroHash,
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -286,9 +300,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, honestBlock, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost the honest proposal at slot 2.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, honestBlockSlot, honestBlock, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       honestBlock,
+			BlockSlot:       honestBlockSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// An attestation is received for B that has more voting power than C with the proposer boost,
 		// allowing B to then become the head if their attestation has enough adversarial votes.
@@ -330,7 +348,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				cSlot,
 				c,
 				a, // parent
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -342,9 +360,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Incorrect head for justified epoch at slot 2")
 
 		// We boost C.
-		secondsPerSlot := time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot)
-		genesis := time.Now().Add(-2 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, cSlot /* slot */, c, genesis))
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       c,
+			BlockSlot:       cSlot,
+			CurrentSlot:     types.Slot(2),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		bSlot := types.Slot(1)
 		b := indexToHash(1)
@@ -354,7 +376,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				bSlot,
 				b,
 				a, // parent
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -378,7 +400,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 				dSlot,
 				d,
 				b, // parent
-				params.BeaconConfig().ZeroHash,
+				zeroHash,
 				jEpoch,
 				fEpoch,
 			),
@@ -390,8 +412,13 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		assert.Equal(t, c, r, "Expected C to remain the head")
 
 		// Block D receives the boost.
-		genesis = time.Now().Add(-3 * secondsPerSlot)
-		require.NoError(t, f.BoostProposerRoot(ctx, dSlot /* slot */, d, genesis))
+		args = &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       d,
+			BlockSlot:       dSlot,
+			CurrentSlot:     types.Slot(3),
+			SecondsIntoSlot: 0,
+		}
+		require.NoError(t, f.BoostProposerRoot(ctx, args))
 
 		// Ensure D becomes the head thanks to boosting.
 		r, err = f.Head(ctx, jEpoch, zeroHash, balances, fEpoch)
@@ -412,12 +439,15 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		f := &ForkChoice{
 			store: &Store{},
 		}
-		// Genesis set to 1 slot ago.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
 		blockRoot := [32]byte{'A'}
-
 		// Trying to boost a block from slot 0 should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(0), blockRoot, genesis)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(0),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: 0,
+		}
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
 	})
@@ -426,14 +456,18 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 			store: &Store{},
 		}
 		// Genesis set to 1 slot ago + X where X > attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		attestingInterval := time.Duration(cfg.SecondsPerSlot / cfg.IntervalsPerSlot)
-		greaterThanAttestingInterval := attestingInterval + 100*time.Millisecond
-		genesis = genesis.Add(-greaterThanAttestingInterval * time.Second)
-		blockRoot := [32]byte{'A'}
+		attestingInterval := time.Duration(cfg.SecondsPerSlot/cfg.IntervalsPerSlot) * time.Second
+		greaterThanAttestingInterval := attestingInterval + time.Second
 
 		// Trying to boost a block from slot 1 that is untimely should not work.
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		blockRoot := [32]byte{'A'}
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     1,
+			SecondsIntoSlot: uint64(greaterThanAttestingInterval.Seconds()),
+		}
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
 	})
@@ -442,11 +476,15 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 			store: &Store{},
 		}
 		// Genesis set to 1 slot ago + 0 seconds into the attesting interval.
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
-		fmt.Println(genesis)
 		blockRoot := [32]byte{'A'}
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: 0,
+		}
 
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
 	})
@@ -454,13 +492,16 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		f := &ForkChoice{
 			store: &Store{},
 		}
-		// Genesis set to 1 slot ago + (attesting interval / 2).
-		genesis := time.Now().Add(-time.Duration(cfg.SecondsPerSlot) * time.Second)
 		blockRoot := [32]byte{'A'}
 		halfAttestingInterval := time.Second
-		genesis = genesis.Add(-halfAttestingInterval)
+		args := &forkchoicetypes.ProposerBoostRootArgs{
+			BlockRoot:       blockRoot,
+			BlockSlot:       types.Slot(1),
+			CurrentSlot:     types.Slot(1),
+			SecondsIntoSlot: uint64(halfAttestingInterval.Seconds()),
+		}
 
-		err := f.BoostProposerRoot(ctx, types.Slot(1), blockRoot, genesis)
+		err := f.BoostProposerRoot(ctx, args)
 		require.NoError(t, err)
 		require.DeepEqual(t, [32]byte{'A'}, f.store.proposerBoostRoot)
 	})

beacon-chain/forkchoice/types/BUILD.bazel

@@ -0,0 +1,9 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["types.go"],
+    importpath = "github.com/prysmaticlabs/prysm/beacon-chain/forkchoice/types",
+    visibility = ["//visibility:public"],
+    deps = ["@com_github_prysmaticlabs_eth2_types//:go_default_library"],
+)

beacon-chain/forkchoice/types/types.go

@@ -0,0 +1,13 @@
+package types
+
+import (
+	types "github.com/prysmaticlabs/eth2-types"
+)
+
+// ProposerBoostRootArgs to call the BoostProposerRoot function.
+type ProposerBoostRootArgs struct {
+	BlockRoot       [32]byte
+	BlockSlot       types.Slot
+	CurrentSlot     types.Slot
+	SecondsIntoSlot uint64
+}