op-node: Load peer and topic params as a single unit.

Simplify loading code with a switch instead of needing to build a map.

op-e2e/system_test.go

@@ -813,13 +813,10 @@ func TestSystemDenseTopology(t *testing.T) {
 
 	// Set peer scoring for each node, but without banning
 	for _, node := range cfg.Nodes {
-		params, err := p2p.GetPeerScoreParams("light", 2)
+		params, err := p2p.GetScoringParams("light", 2)
 		require.NoError(t, err)
 		node.P2P = &p2p.Config{
-			ScoringParams: &p2p.ScoringParams{
-				PeerScoring:  params,
-				TopicScoring: p2p.DisabledTopicScoreParams(2),
-			},
+			ScoringParams:  params,
 			BanningEnabled: false,
 		}
 	}

op-node/p2p/cli/load_config.go

@@ -91,18 +91,11 @@ func loadScoringParams(conf *p2p.Config, ctx *cli.Context, blockTime uint64) err
 		scoringLevel = ctx.GlobalString(flags.TopicScoring.Name)
 	}
 	if scoringLevel != "" {
-		peerScoreParams, err := p2p.GetPeerScoreParams(scoringLevel, blockTime)
+		params, err := p2p.GetScoringParams(scoringLevel, blockTime)
 		if err != nil {
 			return err
 		}
-		topicScoreParams, err := p2p.GetTopicScoreParams(scoringLevel, blockTime)
-		if err != nil {
-			return err
-		}
-		conf.ScoringParams = &p2p.ScoringParams{
-			PeerScoring:  peerScoreParams,
-			TopicScoring: topicScoreParams,
-		}
+		conf.ScoringParams = params
 	}
 
 	return nil

op-node/p2p/peer_params.go

@@ -51,67 +51,20 @@ var LightPeerScoreParams = func(blockTime uint64) pubsub.PeerScoreParams {
 	}
 }
 
-// DisabledPeerScoreParams is an instantiation of [pubsub.PeerScoreParams] where all scoring is disabled.
-// See [PeerScoreParams] for detailed documentation.
-//
-// [PeerScoreParams]: https://pkg.go.dev/github.com/libp2p/go-libp2p-pubsub@v0.8.1#PeerScoreParams
-var DisabledPeerScoreParams = func(blockTime uint64) pubsub.PeerScoreParams {
-	slot := time.Duration(blockTime) * time.Second
-	if slot == 0 {
-		slot = 2 * time.Second
-	}
-	// We initialize an "epoch" as 6 blocks suggesting 6 blocks,
-	// each taking ~ 2 seconds, is 12 seconds
-	epoch := 6 * slot
-	tenEpochs := 10 * epoch
-	oneHundredEpochs := 100 * epoch
-	return pubsub.PeerScoreParams{
-		Topics: make(map[string]*pubsub.TopicScoreParams),
-		// 0 represent no cap
-		TopicScoreCap: 0,
-		AppSpecificScore: func(p peer.ID) float64 {
-			return 0
-		},
-		AppSpecificWeight: 1,
-		// ignore colocation scoring
-		IPColocationFactorWeight:    0,
-		IPColocationFactorWhitelist: nil,
-		// 0 disables the behaviour penalty
-		BehaviourPenaltyWeight: 0,
-		BehaviourPenaltyDecay:  ScoreDecay(tenEpochs, slot),
-		DecayInterval:          slot,
-		DecayToZero:            DecayToZero,
-		RetainScore:            oneHundredEpochs,
+func GetScoringParams(name string, blockTime uint64) (*ScoringParams, error) {
+	switch name {
+	case "light":
+		return &ScoringParams{
+			PeerScoring:  LightPeerScoreParams(blockTime),
+			TopicScoring: LightTopicScoreParams(blockTime),
+		}, nil
+	case "none":
+		return nil, nil
+	default:
+		return nil, fmt.Errorf("unknown p2p scoring level: %v", name)
 	}
 }
 
-// PeerScoreParamsByName is a map of name to function that returns a [pubsub.PeerScoreParams] based on the provided [rollup.Config].
-var PeerScoreParamsByName = map[string](func(blockTime uint64) pubsub.PeerScoreParams){
-	"light": LightPeerScoreParams,
-	"none":  DisabledPeerScoreParams,
-}
-
-// AvailablePeerScoreParams returns a list of available peer score params.
-// These can be used as an input to [GetPeerScoreParams] which returns the
-// corresponding [pubsub.PeerScoreParams].
-func AvailablePeerScoreParams() []string {
-	var params []string
-	for name := range PeerScoreParamsByName {
-		params = append(params, name)
-	}
-	return params
-}
-
-// GetPeerScoreParams returns the [pubsub.PeerScoreParams] for the given name.
-func GetPeerScoreParams(name string, blockTime uint64) (pubsub.PeerScoreParams, error) {
-	params, ok := PeerScoreParamsByName[name]
-	if !ok {
-		return pubsub.PeerScoreParams{}, fmt.Errorf("invalid params %s", name)
-	}
-
-	return params(blockTime), nil
-}
-
 // NewPeerScoreThresholds returns a default [pubsub.PeerScoreThresholds].
 // See [PeerScoreThresholds] for detailed documentation.
 //

op-node/p2p/peer_params_test.go

@@ -2,7 +2,6 @@ package p2p
 
 import (
 	"math"
-	"sort"
 	"testing"
 	"time"
 
@@ -25,14 +24,6 @@ func (testSuite *PeerParamsTestSuite) TestPeerScoreConstants() {
 	testSuite.Equal(0.01, DecayToZero)
 }
 
-// TestAvailablePeerScoreParams validates the available peer score parameters.
-func (testSuite *PeerParamsTestSuite) TestAvailablePeerScoreParams() {
-	available := AvailablePeerScoreParams()
-	sort.Strings(available)
-	expected := []string{"light", "none"}
-	testSuite.Equal(expected, available)
-}
-
 // TestNewPeerScoreThresholds validates the peer score thresholds.
 //
 // This is tested to ensure that the thresholds are not modified and missed in review.
@@ -50,55 +41,14 @@ func (testSuite *PeerParamsTestSuite) TestNewPeerScoreThresholds() {
 }
 
 // TestGetPeerScoreParams validates the peer score parameters.
-func (testSuite *PeerParamsTestSuite) TestGetPeerScoreParams() {
-	params, err := GetPeerScoreParams("light", 1)
+func (testSuite *PeerParamsTestSuite) TestGetPeerScoreParams_None() {
+	params, err := GetScoringParams("none", 1)
 	testSuite.NoError(err)
-	expected := LightPeerScoreParams(1)
-	testSuite.Equal(expected.DecayInterval, params.DecayInterval)
-	testSuite.Equal(time.Duration(1)*time.Second, params.DecayInterval)
-
-	params, err = GetPeerScoreParams("none", 1)
-	testSuite.NoError(err)
-	expected = DisabledPeerScoreParams(1)
-	testSuite.Equal(expected.DecayInterval, params.DecayInterval)
-	testSuite.Equal(time.Duration(1)*time.Second, params.DecayInterval)
-
-	_, err = GetPeerScoreParams("invalid", 1)
-	testSuite.Error(err)
+	testSuite.Nil(params)
 }
 
 // TestLightPeerScoreParams validates the light peer score params.
-func (testSuite *PeerParamsTestSuite) TestLightPeerScoreParams() {
-	blockTime := uint64(1)
-	slot := time.Duration(blockTime) * time.Second
-	epoch := 6 * slot
-	oneHundredEpochs := 100 * epoch
-
-	// calculate the behavior penalty decay
-	duration := 10 * epoch
-	decay := math.Pow(DecayToZero, 1/float64(duration/slot))
-	testSuite.Equal(0.9261187281287935, decay)
-
-	// Test the params
-	params, err := GetPeerScoreParams("light", blockTime)
-	testSuite.NoError(err)
-	testSuite.Equal(params.Topics, make(map[string]*pubsub.TopicScoreParams))
-	testSuite.Equal(params.TopicScoreCap, float64(34))
-	// testSuite.Equal(params.AppSpecificScore("alice"), float(0))
-	testSuite.Equal(params.AppSpecificWeight, float64(1))
-	testSuite.Equal(params.IPColocationFactorWeight, float64(-35))
-	testSuite.Equal(params.IPColocationFactorThreshold, int(10))
-	testSuite.Nil(params.IPColocationFactorWhitelist)
-	testSuite.Equal(params.BehaviourPenaltyWeight, float64(-16))
-	testSuite.Equal(params.BehaviourPenaltyThreshold, float64(6))
-	testSuite.Equal(params.BehaviourPenaltyDecay, decay)
-	testSuite.Equal(params.DecayInterval, slot)
-	testSuite.Equal(params.DecayToZero, DecayToZero)
-	testSuite.Equal(params.RetainScore, oneHundredEpochs)
-}
-
-// TestDisabledPeerScoreParams validates the disabled peer score params.
-func (testSuite *PeerParamsTestSuite) TestDisabledPeerScoreParams() {
+func (testSuite *PeerParamsTestSuite) TestGetPeerScoreParams_Light() {
 	blockTime := uint64(1)
 	slot := time.Duration(blockTime) * time.Second
 	epoch := 6 * slot
@@ -110,27 +60,27 @@ func (testSuite *PeerParamsTestSuite) TestDisabledPeerScoreParams() {
 	testSuite.Equal(0.9261187281287935, decay)
 
 	// Test the params
-	params, err := GetPeerScoreParams("none", blockTime)
+	scoringParams, err := GetScoringParams("light", blockTime)
+	peerParams := scoringParams.PeerScoring
 	testSuite.NoError(err)
-	testSuite.Equal(params.Topics, make(map[string]*pubsub.TopicScoreParams))
-	testSuite.Equal(params.TopicScoreCap, float64(0))
-	testSuite.Equal(params.AppSpecificWeight, float64(1))
-	testSuite.Equal(params.IPColocationFactorWeight, float64(0))
-	testSuite.Nil(params.IPColocationFactorWhitelist)
-	testSuite.Equal(params.BehaviourPenaltyWeight, float64(0))
-	testSuite.Equal(params.BehaviourPenaltyDecay, decay)
-	testSuite.Equal(params.DecayInterval, slot)
-	testSuite.Equal(params.DecayToZero, DecayToZero)
-	testSuite.Equal(params.RetainScore, oneHundredEpochs)
+	testSuite.Equal(peerParams.Topics, make(map[string]*pubsub.TopicScoreParams))
+	testSuite.Equal(peerParams.TopicScoreCap, float64(34))
+	testSuite.Equal(peerParams.AppSpecificWeight, float64(1))
+	testSuite.Equal(peerParams.IPColocationFactorWeight, float64(-35))
+	testSuite.Equal(peerParams.IPColocationFactorThreshold, 10)
+	testSuite.Nil(peerParams.IPColocationFactorWhitelist)
+	testSuite.Equal(peerParams.BehaviourPenaltyWeight, float64(-16))
+	testSuite.Equal(peerParams.BehaviourPenaltyThreshold, float64(6))
+	testSuite.Equal(peerParams.BehaviourPenaltyDecay, decay)
+	testSuite.Equal(peerParams.DecayInterval, slot)
+	testSuite.Equal(peerParams.DecayToZero, DecayToZero)
+	testSuite.Equal(peerParams.RetainScore, oneHundredEpochs)
 }
 
 // TestParamsZeroBlockTime validates peer score params use default slot for 0 block time.
 func (testSuite *PeerParamsTestSuite) TestParamsZeroBlockTime() {
 	slot := 2 * time.Second
-	params, err := GetPeerScoreParams("none", uint64(0))
-	testSuite.NoError(err)
-	testSuite.Equal(params.DecayInterval, slot)
-	params, err = GetPeerScoreParams("light", uint64(0))
+	params, err := GetScoringParams("light", uint64(0))
 	testSuite.NoError(err)
-	testSuite.Equal(params.DecayInterval, slot)
+	testSuite.Equal(params.PeerScoring.DecayInterval, slot)
 }

op-node/p2p/peer_scores_test.go

@@ -115,7 +115,9 @@ func newGossipSubs(testSuite *PeerScoresTestSuite, ctx context.Context, hosts []
 					DecayInterval:     time.Second,
 					DecayToZero:       0.01,
 				},
-				TopicScoring: DisabledTopicScoreParams(1),
+				TopicScoring: pubsub.TopicScoreParams{
+					TimeInMeshQuantum: time.Second,
+				},
 			},
 		}, scorer, logger)...)
 		ps, err := pubsub.NewGossipSubWithRouter(ctx, h, rt, opts...)

op-node/p2p/topic_params.go

 package p2p
 
 import (
-	"fmt"
 	"time"
 
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
@@ -52,62 +51,3 @@ var LightTopicScoreParams = func(blockTime uint64) pubsub.TopicScoreParams {
 func inMeshCap(slot time.Duration) float64 {
 	return float64((3600 * time.Second) / slot)
 }
-
-// DisabledTopicScoreParams is an instantiation of [pubsub.TopicScoreParams] where all scoring is disabled.
-// See [TopicScoreParams] for detailed documentation.
-//
-// [TopicScoreParams]: https://pkg.go.dev/github.com/libp2p/go-libp2p-pubsub@v0.8.1#TopicScoreParams
-var DisabledTopicScoreParams = func(blockTime uint64) pubsub.TopicScoreParams {
-	slot := time.Duration(blockTime) * time.Second
-	if slot == 0 {
-		slot = 2 * time.Second
-	}
-	epoch := 6 * slot
-	invalidDecayPeriod := 50 * epoch
-	return pubsub.TopicScoreParams{
-		TopicWeight:                     0, // disabled
-		TimeInMeshWeight:                0, // disabled
-		TimeInMeshQuantum:               slot,
-		TimeInMeshCap:                   inMeshCap(slot),
-		FirstMessageDeliveriesWeight:    0, // disabled
-		FirstMessageDeliveriesDecay:     ScoreDecay(20*epoch, slot),
-		FirstMessageDeliveriesCap:       23,
-		MeshMessageDeliveriesWeight:     0, // disabled
-		MeshMessageDeliveriesDecay:      ScoreDecay(DecayEpoch*epoch, slot),
-		MeshMessageDeliveriesCap:        float64(uint64(epoch/slot) * uint64(DecayEpoch)),
-		MeshMessageDeliveriesThreshold:  float64(uint64(epoch/slot) * uint64(DecayEpoch) / 10),
-		MeshMessageDeliveriesWindow:     2 * time.Second,
-		MeshMessageDeliveriesActivation: 4 * epoch,
-		MeshFailurePenaltyWeight:        0, // disabled
-		MeshFailurePenaltyDecay:         ScoreDecay(DecayEpoch*epoch, slot),
-		InvalidMessageDeliveriesWeight:  0, // disabled
-		InvalidMessageDeliveriesDecay:   ScoreDecay(invalidDecayPeriod, slot),
-	}
-}
-
-// TopicScoreParamsByName is a map of name to [pubsub.TopicScoreParams].
-var TopicScoreParamsByName = map[string](func(blockTime uint64) pubsub.TopicScoreParams){
-	"light": LightTopicScoreParams,
-	"none":  DisabledTopicScoreParams,
-}
-
-// AvailableTopicScoreParams returns a list of available topic score params.
-// These can be used as an input to [GetTopicScoreParams] which returns the
-// corresponding [pubsub.TopicScoreParams].
-func AvailableTopicScoreParams() []string {
-	var params []string
-	for name := range TopicScoreParamsByName {
-		params = append(params, name)
-	}
-	return params
-}
-
-// GetTopicScoreParams returns the [pubsub.TopicScoreParams] for the given name.
-func GetTopicScoreParams(name string, blockTime uint64) (pubsub.TopicScoreParams, error) {
-	params, ok := TopicScoreParamsByName[name]
-	if !ok {
-		return pubsub.TopicScoreParams{}, fmt.Errorf("invalid topic params %s", name)
-	}
-
-	return params(blockTime), nil
-}