op-node: Define application score parameters.

op-node/p2p/app_params.go

+package p2p
+
+import (
+	"time"
+
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+)
+
+type ApplicationScoreParams struct {
+	ValidResponseCap    float64
+	ValidResponseWeight float64
+	ValidResponseDecay  float64
+
+	ErrorResponseCap    float64
+	ErrorResponseWeight float64
+	ErrorResponseDecay  float64
+
+	RejectedPayloadCap    float64
+	RejectedPayloadWeight float64
+	RejectedPayloadDecay  float64
+
+	DecayToZero   float64
+	DecayInterval time.Duration
+}
+
+func LightApplicationScoreParams(cfg *rollup.Config) ApplicationScoreParams {
+	slot := time.Duration(cfg.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
+	return ApplicationScoreParams{
+		ValidResponseCap:      10,
+		ValidResponseWeight:   1,
+		ValidResponseDecay:    ScoreDecay(tenEpochs, slot),
+		ErrorResponseCap:      10,
+		ErrorResponseWeight:   -16,
+		ErrorResponseDecay:    ScoreDecay(tenEpochs, slot),
+		RejectedPayloadCap:    10,
+		RejectedPayloadWeight: -50,
+		RejectedPayloadDecay:  ScoreDecay(tenEpochs, slot),
+		DecayToZero:           DecayToZero,
+		DecayInterval:         slot,
+	}
+}

op-node/p2p/config.go

@@ -54,6 +54,7 @@ type SetupP2P interface {
 // ScoringParams defines the various types of peer scoring parameters.
 type ScoringParams struct {
 	PeerScoring        pubsub.PeerScoreParams
+	ApplicationScoring ApplicationScoreParams
 }
 
 // Config sets up a p2p host and discv5 service from configuration.

op-node/p2p/peer_params.go

@@ -32,7 +32,7 @@ func ScoreDecay(duration time.Duration, slot time.Duration) float64 {
 // See [PeerScoreParams] for detailed documentation.
 //
 // [PeerScoreParams]: https://pkg.go.dev/github.com/libp2p/go-libp2p-pubsub@v0.8.1#PeerScoreParams
-var LightPeerScoreParams = func(cfg *rollup.Config) pubsub.PeerScoreParams {
+func LightPeerScoreParams(cfg *rollup.Config) pubsub.PeerScoreParams {
 	slot := time.Duration(cfg.BlockTime) * time.Second
 	if slot == 0 {
 		slot = 2 * time.Second
@@ -92,6 +92,7 @@ func GetScoringParams(name string, cfg *rollup.Config) (*ScoringParams, error) {
 	case "light":
 		return &ScoringParams{
 			PeerScoring:        LightPeerScoreParams(cfg),
+			ApplicationScoring: LightApplicationScoreParams(cfg),
 		}, nil
 	case "none":
 		return nil, nil

op-node/p2p/peer_params_test.go

@@ -81,6 +81,19 @@ func (testSuite *PeerParamsTestSuite) TestGetPeerScoreParams_Light() {
 	testSuite.Equal(peerParams.DecayInterval, slot)
 	testSuite.Equal(peerParams.DecayToZero, DecayToZero)
 	testSuite.Equal(peerParams.RetainScore, oneHundredEpochs)
+
+	appParams := scoringParams.ApplicationScoring
+	testSuite.Positive(appParams.ValidResponseCap)
+	testSuite.Positive(appParams.ValidResponseWeight)
+	testSuite.Positive(appParams.ValidResponseDecay)
+	testSuite.Positive(appParams.ErrorResponseCap)
+	testSuite.Negative(appParams.ErrorResponseWeight)
+	testSuite.Positive(appParams.ErrorResponseDecay)
+	testSuite.Positive(appParams.RejectedPayloadCap)
+	testSuite.Negative(appParams.RejectedPayloadWeight)
+	testSuite.Positive(appParams.RejectedPayloadDecay)
+	testSuite.Equal(DecayToZero, appParams.DecayToZero)
+	testSuite.Equal(slot, appParams.DecayInterval)
 }
 
 // TestParamsZeroBlockTime validates peer score params use default slot for 0 block time.
@@ -91,4 +104,5 @@ func (testSuite *PeerParamsTestSuite) TestParamsZeroBlockTime() {
 	params, err := GetScoringParams("light", &cfg)
 	testSuite.NoError(err)
 	testSuite.Equal(params.PeerScoring.DecayInterval, slot)
+	testSuite.Equal(params.ApplicationScoring.DecayInterval, slot)
 }