Merge branch 'main' into PRT-fix-arbitrum

proto/lavanet/lava/pairing/params.proto

@@ -17,4 +17,12 @@ message Params {
       (gogoproto.nullable)   = false
       ];
   uint64 recommendedEpochNumToCollectPayment = 14 [(gogoproto.moretags) = "yaml:\"recommended_epoch_num_to_collect_payment\""];
+  int64 reputation_variance_stabilization_period = 15 [(gogoproto.moretags) = "yaml:\"reputation_variance_stabilization_period\""];
+  string reputation_latency_over_sync_factor = 16 [
+    (gogoproto.moretags) = "yaml:\"reputation_latency_over_sync_factor\"",
+    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
+    (gogoproto.nullable)   = false
+  ];
+  int64 reputation_half_life_factor = 17 [(gogoproto.moretags) = "yaml:\"reputation_half_life_factor\""];
+  uint64 reputation_relay_failure_cost = 18 [(gogoproto.moretags) = "yaml:\"reputation_relay_failure_cost\""];
 }

protocol/chainlib/chain_router.go

@@ -15,6 +15,8 @@ import (
 	"google.golang.org/grpc/metadata"
 )
 
+var IgnoreWsEnforcementForTestCommands = false
+
 type chainRouterEntry struct {
 	ChainProxy
 	addonsSupported map[string]struct{}
@@ -313,14 +315,13 @@ func newChainRouter(ctx context.Context, nConns uint, rpcProviderEndpoint lavase
 			break
 		}
 	}
-	if hasSubscriptionInSpec && apiCollection.Enabled && !webSocketSupported {
+	if !IgnoreWsEnforcementForTestCommands && hasSubscriptionInSpec && apiCollection.Enabled && !webSocketSupported {
 		return nil, utils.LavaFormatError("subscriptions are applicable for this chain, but websocket is not provided in 'supported' map. By not setting ws/wss your provider wont be able to accept ws subscriptions, therefore might receive less rewards and lower QOS score.", nil,
 			utils.LogAttr("apiInterface", apiCollection.CollectionData.ApiInterface),
 			utils.LogAttr("supportedMap", supportedMap),
 			utils.LogAttr("required", WebSocketExtension),
 		)
 	}
-
 	utils.LavaFormatDebug("router keys", utils.LogAttr("chainProxyRouter", chainProxyRouter))
 
 	// make sure all chainProxyRouter entries have one without a method routing

protocol/monitoring/health.go

@@ -349,6 +349,7 @@ func CheckConsumersAndReferences(ctx context.Context,
 		healthResults.updateLatestBlock(specId, providerBlock)
 	}
 	errCh := make(chan error, 1)
+	chainlib.IgnoreWsEnforcementForTestCommands = true // ignore ws panic for tests
 	queryEndpoint := func(endpoint *HealthRPCEndpoint, isReference bool) error {
 		chainParser, err := chainlib.NewChainParser(endpoint.ApiInterface)
 		if err != nil {

protocol/rpcconsumer/testing.go

@@ -31,6 +31,7 @@ func startTesting(ctx context.Context, clientCtx client.Context, rpcEndpoints []
 		signal.Stop(signalChan)
 		cancel()
 	}()
+	chainlib.IgnoreWsEnforcementForTestCommands = true // ignore ws panic for tests
 	stateQuery := updaters.NewConsumerStateQuery(ctx, clientCtx)
 	for _, rpcProviderEndpoint := range rpcEndpoints {
 		go func(rpcProviderEndpoint *lavasession.RPCProviderEndpoint) error {

x/pairing/README.md

@@ -322,6 +322,22 @@ EpochBlocksOverlap is the number of blocks a consumer waits before interacting w
 
 RecommendedEpochNumToCollectPayment is the recommended max number of epochs for providers to claim payments. It's also used for determining unresponsiveness.
 
+### ReputationVarianceStabilizationPeriod
+
+ReputationVarianceStabilizationPeriod is the period in which reputation reports are not truncated due to variance.
+
+### ReputationLatencyOverSyncFactor
+
+ReputationLatencyOverSyncFactor is the factor that decreases the reputation's sync report influence when calculating the reputation score.
+
+### ReputationHalfLifeFactor
+
+ReputationHalfLifeFactor is the half life factor that determines the degradation in old reputation samples (when the reputation is updated).
+
+### ReputationRelayFailureCost
+
+ReputationRelayFailureCost is the cost (in seconds) for a failed relay sent from the consumer to the provider. This is part of the reputation report calculation.
+
 ## Queries
 
 The pairing module supports the following queries:

x/pairing/keeper/migrations.go

@@ -5,9 +5,11 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	types1 "github.com/cosmos/cosmos-sdk/x/staking/types"
+	"github.com/lavanet/lava/v4/utils"
 	"github.com/lavanet/lava/v4/utils/lavaslices"
 	epochstoragetypes "github.com/lavanet/lava/v4/x/epochstorage/types"
 	v2 "github.com/lavanet/lava/v4/x/pairing/migrations/v2"
+	"github.com/lavanet/lava/v4/x/pairing/types"
 )
 
 type Migrator struct {
@@ -107,3 +109,19 @@ func (m Migrator) MigrateVersion4To5(ctx sdk.Context) error {
 
 	return nil
 }
+
+// MigrateVersion5To6 sets new parameters:
+// ReputationVarianceStabilizationPeriod, ReputationLatencyOverSyncFactor,
+// ReputationHalfLifeFactor, ReputationRelayFailureCost
+func (m Migrator) MigrateVersion5To6(ctx sdk.Context) error {
+	utils.LavaFormatInfo("migrate: pairing to set new parameters")
+
+	params := m.keeper.GetParams(ctx)
+	params.ReputationVarianceStabilizationPeriod = types.DefaultReputationVarianceStabilizationPeriod
+	params.ReputationLatencyOverSyncFactor = types.DefaultReputationLatencyOverSyncFactor
+	params.ReputationHalfLifeFactor = types.DefaultReputationHalfLifeFactor
+	params.ReputationRelayFailureCost = types.DefaultReputationRelayFailureCost
+
+	m.keeper.SetParams(ctx, params)
+	return nil
+}

x/pairing/keeper/params.go

@@ -3,6 +3,7 @@ package keeper
 import (
 	"strconv"
 
+	"cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/lavanet/lava/v4/utils"
 	"github.com/lavanet/lava/v4/x/pairing/types"
@@ -14,6 +15,10 @@ func (k Keeper) GetParams(ctx sdk.Context) types.Params {
 		k.EpochBlocksOverlap(ctx),
 		k.QoSWeight(ctx),
 		k.RecommendedEpochNumToCollectPayment(ctx),
+		k.ReputationVarianceStabilizationPeriod(ctx),
+		k.ReputationLatencyOverSyncFactor(ctx),
+		k.ReputationHalfLifeFactor(ctx),
+		k.ReputationRelayFailureCost(ctx),
 	)
 }
 
@@ -53,6 +58,26 @@ func (k Keeper) RecommendedEpochNumToCollectPayment(ctx sdk.Context) (res uint64
 	return
 }
 
-func (k Keeper) SetRecommendedEpochNumToCollectPayment(ctx sdk.Context, val uint64) {
-	k.paramstore.Set(ctx, types.KeyRecommendedEpochNumToCollectPayment, val)
+// ReputationVarianceStabilizationPeriod returns the ReputationVarianceStabilizationPeriod param
+func (k Keeper) ReputationVarianceStabilizationPeriod(ctx sdk.Context) (res int64) {
+	k.paramstore.Get(ctx, types.KeyReputationVarianceStabilizationPeriod, &res)
+	return
+}
+
+// ReputationLatencyOverSyncFactor returns the ReputationLatencyOverSyncFactor param
+func (k Keeper) ReputationLatencyOverSyncFactor(ctx sdk.Context) (res math.LegacyDec) {
+	k.paramstore.Get(ctx, types.KeyReputationLatencyOverSyncFactor, &res)
+	return
+}
+
+// ReputationHalfLifeFactor returns the ReputationHalfLifeFactor param
+func (k Keeper) ReputationHalfLifeFactor(ctx sdk.Context) (res int64) {
+	k.paramstore.Get(ctx, types.KeyReputationHalfLifeFactor, &res)
+	return
+}
+
+// ReputationRelayFailureCost returns the ReputationRelayFailureCost param
+func (k Keeper) ReputationRelayFailureCost(ctx sdk.Context) (res uint64) {
+	k.paramstore.Get(ctx, types.KeyReputationRelayFailureCost, &res)
+	return
 }

x/pairing/keeper/params_test.go

@@ -17,4 +17,8 @@ func TestGetParams(t *testing.T) {
 	require.EqualValues(t, params, k.GetParams(ctx))
 	require.EqualValues(t, params.EpochBlocksOverlap, k.EpochBlocksOverlap(ctx))
 	require.EqualValues(t, params.RecommendedEpochNumToCollectPayment, k.RecommendedEpochNumToCollectPayment(ctx))
+	require.EqualValues(t, params.ReputationVarianceStabilizationPeriod, k.ReputationVarianceStabilizationPeriod(ctx))
+	require.EqualValues(t, params.ReputationLatencyOverSyncFactor, k.ReputationLatencyOverSyncFactor(ctx))
+	require.EqualValues(t, params.ReputationHalfLifeFactor, k.ReputationHalfLifeFactor(ctx))
+	require.EqualValues(t, params.ReputationRelayFailureCost, k.ReputationRelayFailureCost(ctx))
 }

x/pairing/module.go

@@ -141,6 +141,10 @@ func (am AppModule) RegisterServices(cfg module.Configurator) {
 	if err := cfg.RegisterMigration(types.ModuleName, 4, migrator.MigrateVersion4To5); err != nil {
 		panic(fmt.Errorf("%s: failed to register migration to v5: %w", types.ModuleName, err))
 	}
+	// register v5 -> v6 migration
+	if err := cfg.RegisterMigration(types.ModuleName, 5, migrator.MigrateVersion5To6); err != nil {
+		panic(fmt.Errorf("%s: failed to register migration to v6: %w", types.ModuleName, err))
+	}
 }
 
 // RegisterInvariants registers the capability module's invariants.

x/pairing/types/params.go

@@ -3,6 +3,7 @@ package types
 import (
 	"fmt"
 
+	"cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	"gopkg.in/yaml.v2"
@@ -26,6 +27,26 @@ var (
 	DefaultRecommendedEpochNumToCollectPayment uint64 = 3
 )
 
+var (
+	KeyReputationVarianceStabilizationPeriod           = []byte("ReputationVarianceStabilizationPeriod")
+	DefaultReputationVarianceStabilizationPeriod int64 = 7 * 24 * 60 * 60 // week
+)
+
+var (
+	KeyReputationLatencyOverSyncFactor                    = []byte("ReputationLatencyOverSyncFactor")
+	DefaultReputationLatencyOverSyncFactor math.LegacyDec = sdk.NewDecWithPrec(3, 1) // 0.3
+)
+
+var (
+	KeyReputationHalfLifeFactor           = []byte("ReputationHalfLifeFactor")
+	DefaultReputationHalfLifeFactor int64 = 12 * 30 * 24 * 60 * 60 // year in seconds
+)
+
+var (
+	KeyReputationRelayFailureCost            = []byte("ReputationRelayFailureCost")
+	DefaultReputationRelayFailureCost uint64 = 3 // seconds
+)
+
 // ParamKeyTable the param key table for launch module
 func ParamKeyTable() paramtypes.KeyTable {
 	return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
@@ -36,11 +57,19 @@ func NewParams(
 	epochBlocksOverlap uint64,
 	qoSWeight sdk.Dec,
 	recommendedEpochNumToCollectPayment uint64,
+	reputationVarianceStabilizationPeriod int64,
+	reputationLatencyOverSyncFactor math.LegacyDec,
+	reputationHalfLifeFactor int64,
+	reputationRelayFailureCost uint64,
 ) Params {
 	return Params{
-		EpochBlocksOverlap:                  epochBlocksOverlap,
-		QoSWeight:                           qoSWeight,
-		RecommendedEpochNumToCollectPayment: recommendedEpochNumToCollectPayment,
+		EpochBlocksOverlap:                    epochBlocksOverlap,
+		QoSWeight:                             qoSWeight,
+		RecommendedEpochNumToCollectPayment:   recommendedEpochNumToCollectPayment,
+		ReputationVarianceStabilizationPeriod: reputationVarianceStabilizationPeriod,
+		ReputationLatencyOverSyncFactor:       reputationLatencyOverSyncFactor,
+		ReputationHalfLifeFactor:              reputationHalfLifeFactor,
+		ReputationRelayFailureCost:            reputationRelayFailureCost,
 	}
 }
 
@@ -50,6 +79,10 @@ func DefaultParams() Params {
 		DefaultEpochBlocksOverlap,
 		DefaultQoSWeight,
 		DefaultRecommendedEpochNumToCollectPayment,
+		DefaultReputationVarianceStabilizationPeriod,
+		DefaultReputationLatencyOverSyncFactor,
+		DefaultReputationHalfLifeFactor,
+		DefaultReputationRelayFailureCost,
 	)
 }
 
@@ -59,6 +92,10 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
 		paramtypes.NewParamSetPair(KeyEpochBlocksOverlap, &p.EpochBlocksOverlap, validateEpochBlocksOverlap),
 		paramtypes.NewParamSetPair(KeyQoSWeight, &p.QoSWeight, validateQoSWeight),
 		paramtypes.NewParamSetPair(KeyRecommendedEpochNumToCollectPayment, &p.RecommendedEpochNumToCollectPayment, validateRecommendedEpochNumToCollectPayment),
+		paramtypes.NewParamSetPair(KeyReputationVarianceStabilizationPeriod, &p.ReputationVarianceStabilizationPeriod, validateReputationVarianceStabilizationPeriod),
+		paramtypes.NewParamSetPair(KeyReputationLatencyOverSyncFactor, &p.ReputationLatencyOverSyncFactor, validateReputationLatencyOverSyncFactor),
+		paramtypes.NewParamSetPair(KeyReputationHalfLifeFactor, &p.ReputationHalfLifeFactor, validateReputationHalfLifeFactor),
+		paramtypes.NewParamSetPair(KeyReputationRelayFailureCost, &p.ReputationRelayFailureCost, validateReputationRelayFailureCost),
 	}
 }
 
@@ -68,9 +105,29 @@ func (p Params) Validate() error {
 		return err
 	}
 
+	if err := validateQoSWeight(p.QoSWeight); err != nil {
+		return err
+	}
+
 	if err := validateRecommendedEpochNumToCollectPayment(p.RecommendedEpochNumToCollectPayment); err != nil {
 		return err
 	}
+
+	if err := validateReputationVarianceStabilizationPeriod(p.ReputationVarianceStabilizationPeriod); err != nil {
+		return err
+	}
+
+	if err := validateReputationLatencyOverSyncFactor(p.ReputationLatencyOverSyncFactor); err != nil {
+		return err
+	}
+
+	if err := validateReputationHalfLifeFactor(p.ReputationHalfLifeFactor); err != nil {
+		return err
+	}
+
+	if err := validateReputationRelayFailureCost(p.ReputationRelayFailureCost); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -119,3 +176,55 @@ func validateRecommendedEpochNumToCollectPayment(v interface{}) error {
 
 	return nil
 }
+
+// validateReputationVarianceStabilizationPeriod validates the ReputationVarianceStabilizationPeriod param
+func validateReputationVarianceStabilizationPeriod(v interface{}) error {
+	reputationVarianceStabilizationPeriod, ok := v.(int64)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", v)
+	}
+
+	// TODO implement validation
+	_ = reputationVarianceStabilizationPeriod
+
+	return nil
+}
+
+// validateReputationLatencyOverSyncFactor validates the ReputationLatencyOverSyncFactor param
+func validateReputationLatencyOverSyncFactor(v interface{}) error {
+	reputationLatencyOverSyncFactor, ok := v.(math.LegacyDec)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", v)
+	}
+
+	// TODO implement validation
+	_ = reputationLatencyOverSyncFactor
+
+	return nil
+}
+
+// validateReputationHalfLifeFactor validates the ReputationHalfLifeFactor param
+func validateReputationHalfLifeFactor(v interface{}) error {
+	reputationHalfLifeFactor, ok := v.(int64)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", v)
+	}
+
+	// TODO implement validation
+	_ = reputationHalfLifeFactor
+
+	return nil
+}
+
+// validateReputationRelayFailureCost validates the ReputationRelayFailureCost param
+func validateReputationRelayFailureCost(v interface{}) error {
+	reputationRelayFailureCost, ok := v.(uint64)
+	if !ok {
+		return fmt.Errorf("invalid parameter type: %T", v)
+	}
+
+	// TODO implement validation
+	_ = reputationRelayFailureCost
+
+	return nil
+}