CNS-359: add geolocation scoring

common/types/utils.go

@@ -5,28 +5,53 @@ import (
 	"golang.org/x/exp/constraints"
 )
 
-func FindMin[T constraints.Ordered](s []T) (m T) {
-	if len(s) > 0 {
-		m = s[0]
-		for _, v := range s[1:] {
-			if m > v {
-				m = v
-			}
+func FindMin[T constraints.Ordered](s []T) T {
+	ind := FindIndexOfMin(s)
+	if ind == -1 {
+		var zero T
+		return zero
+	}
+
+	return s[ind]
+}
+
+func FindIndexOfMin[T constraints.Ordered](s []T) int {
+	if len(s) == 0 {
+		return -1
+	}
+	m := s[0]
+	mInd := 0
+	for i := range s {
+		if m > s[i] {
+			mInd = i
 		}
 	}
-	return m
+	return mInd
 }
 
-func FindMax[T constraints.Ordered](s []T) (m T) {
-	if len(s) > 0 {
-		m = s[0]
-		for _, v := range s[1:] {
-			if m < v {
-				m = v
-			}
+func FindMax[T constraints.Ordered](s []T) T {
+	ind := FindIndexOfMax(s)
+	if ind == -1 {
+		var zero T
+		return zero
+	}
+
+	return s[ind]
+}
+
+func FindIndexOfMax[T constraints.Ordered](s []T) int {
+	if len(s) == 0 {
+		return -1
+	}
+	m := s[0]
+	mInd := 0
+	for i := range s {
+		if m < s[i] {
+			m = s[i]
+			mInd = i
 		}
 	}
-	return m
+	return mInd
 }
 
 func Intersection[T comparable](arrays ...[]T) []T {

cookbook/plans/adventurer.json → cookbook/plans/basic.json

@@ -1,11 +1,11 @@
 {
     "proposal": {
-        "title": "Add plan proposal: advneturer",
-        "description": "A proposal for a new plan for a mid-range user",
+        "title": "Add plan proposal: Basic",
+        "description": "A proposal for a new plan for a basic user",
         "plans": [
             {
-                "index": "adventurer",
-                "description": "Plan for the Lava adventurer",
+                "index": "basic",
+                "description": "Plan for the basic Lava user",
                 "type": "rpc",
                 "price": {
                     "denom": "ulava",
@@ -15,10 +15,10 @@
                 "allow_overuse": false,
                 "overuse_rate": "0",
                 "plan_policy": {
-                    "geolocation_profile": "18446744073709551615",
+                    "geolocation_profile": "0",
                     "total_cu_limit": "1000000000",
                     "epoch_cu_limit": "5000000",
-                    "max_providers_to_pair": "5"
+                    "max_providers_to_pair": "14"
                 }
             }
         ]

cookbook/plans/enterprise.json

@@ -0,0 +1,27 @@
+{
+    "proposal": {
+        "title": "Add plan proposal: Enterprise",
+        "description": "A proposal for a new plan for a enterprise user",
+        "plans": [
+            {
+                "index": "enterprise",
+                "description": "Plan for the enterprise Lava user",
+                "type": "rpc",
+                "price": {
+                    "denom": "ulava",
+                    "amount": "600000000000"
+                },
+                "annual_discount_percentage": "0",
+                "allow_overuse": false,
+                "overuse_rate": "0",
+                "plan_policy": {
+                    "geolocation_profile": "65535",
+                    "total_cu_limit": "9223372036854775807",
+                    "epoch_cu_limit": "9223372036854775807",
+                    "max_providers_to_pair": "28"
+                }
+            }
+        ]
+    },
+    "deposit": "10000000ulava"
+}

cookbook/plans/explorer.json → cookbook/plans/free.json

@@ -1,11 +1,11 @@
 {
     "proposal": {
-        "title": "Add plan proposal: explorer",
-        "description": "A proposal for a new plan for a beginner user",
+        "title": "Add plan proposal: free",
+        "description": "A proposal for a new plan for a free user",
         "plans": [
             {
-                "index": "explorer",
-                "description": "Plan for the Lava explorer",
+                "index": "free",
+                "description": "Plan for the free Lava user",
                 "type": "rpc",
                 "price": {
                     "denom": "ulava",
@@ -15,7 +15,7 @@
                 "allow_overuse": false,
                 "overuse_rate": "0",
                 "plan_policy": {
-                    "geolocation_profile": "18446744073709551615",
+                    "geolocation_profile": "4",
                     "total_cu_limit": "10000000",
                     "epoch_cu_limit": "100000",
                     "max_providers_to_pair": "5"

cookbook/plans/whale.json → cookbook/plans/premium.json

@@ -1,24 +1,24 @@
 {
     "proposal": {
-        "title": "Add plan proposal: whale",
-        "description": "A proposal for a new plan for an advanced user",
+        "title": "Add plan proposal: Premium",
+        "description": "A proposal for a new plan for a premium user",
         "plans": [
             {
-                "index": "whale",
-                "description": "Plan for the Lava whale",
+                "index": "premium",
+                "description": "Plan for the premium Lava user",
                 "type": "rpc",
                 "price": {
                     "denom": "ulava",
-                    "amount": "100000000000000"
+                    "amount": "600000000000"
                 },
                 "annual_discount_percentage": "0",
                 "allow_overuse": false,
                 "overuse_rate": "0",
                 "plan_policy": {
-                    "geolocation_profile": "18446744073709551615",
+                    "geolocation_profile": "65535",
                     "total_cu_limit": "9223372036854775807",
                     "epoch_cu_limit": "9223372036854775807",
-                    "max_providers_to_pair": "5"
+                    "max_providers_to_pair": "14"
                 }
             }
         ]

x/pairing/client/cli/tx_stake_provider.go

@@ -207,7 +207,7 @@ func HandleEndpointsAndGeolocationArgs(endpArg []string, geoArg string) (endp []
 
 		if geoloc == int32(planstypes.Geolocation_GL) {
 			// if global ("GL"), append the endpoint in all possible geolocations
-			for _, geoloc := range types.GetGeolocations() {
+			for _, geoloc := range types.GetAllGeolocations() {
 				endpoint := epochstoragetypes.Endpoint{
 					IPPORT:      split[0],
 					Geolocation: uint64(geoloc),

x/pairing/keeper/filters/geolocation_filter.go

@@ -6,18 +6,21 @@ import (
 	planstypes "github.com/lavanet/lava/x/plans/types"
 )
 
-// TODO: This is a temp filter until the geolocation mechanism changes (this is not optimal)
+// TODO: This filter is disabled (InitFilter always returns false)
+// will be used in the future to exclude geolocations (thus keeping this code)
 
 type GeolocationFilter struct {
 	geolocation uint64
 }
 
 func (f *GeolocationFilter) InitFilter(strictestPolicy planstypes.Policy) bool {
-	if strictestPolicy.SelectedProvidersMode == planstypes.SELECTED_PROVIDERS_MODE_DISABLED ||
-		strictestPolicy.SelectedProvidersMode == planstypes.SELECTED_PROVIDERS_MODE_ALLOWED {
-		f.geolocation = strictestPolicy.GeolocationProfile
-		return true
-	}
+	/*
+		if strictestPolicy.SelectedProvidersMode == planstypes.SELECTED_PROVIDERS_MODE_DISABLED ||
+			strictestPolicy.SelectedProvidersMode == planstypes.SELECTED_PROVIDERS_MODE_ALLOWED {
+			f.geolocation = strictestPolicy.GeolocationProfile
+			return true
+		}
+	*/
 	return false
 }
 

x/pairing/keeper/grpc_query_user_entry.go

@@ -35,6 +35,11 @@ func (k Keeper) UserEntry(goCtx context.Context, req *types.QueryUserEntryReques
 		return nil, err
 	}
 
+	sub, found := k.subscriptionKeeper.GetSubscription(ctx, project.GetSubscription())
+	if !found {
+		return nil, fmt.Errorf("could not find subscription with address %s", project.GetSubscription())
+	}
+
 	plan, err := k.subscriptionKeeper.GetPlanFromSubscription(ctx, project.GetSubscription())
 	if err != nil {
 		return nil, err
@@ -43,11 +48,9 @@ func (k Keeper) UserEntry(goCtx context.Context, req *types.QueryUserEntryReques
 	planPolicy := plan.GetPlanPolicy()
 	policies := []*planstypes.Policy{&planPolicy, project.AdminPolicy, project.SubscriptionPolicy}
 	// geolocation is a bitmap. common denominator can be calculated with logical AND
-	geolocation := k.CalculateEffectiveGeolocationFromPolicies(policies)
-
-	sub, found := k.subscriptionKeeper.GetSubscription(ctx, project.GetSubscription())
-	if !found {
-		return nil, fmt.Errorf("could not find subscription with address %s", project.GetSubscription())
+	geolocation, err := k.CalculateEffectiveGeolocationFromPolicies(policies)
+	if err != nil {
+		return nil, err
 	}
 	allowedCU, _ := k.CalculateEffectiveAllowedCuPerEpochFromPolicies(policies, project.GetUsedCu(), sub.GetMonthCuLeft())
 

x/pairing/keeper/pairing.go

@@ -165,7 +165,6 @@ func (k Keeper) getPairingForClient(ctx sdk.Context, chainID string, clientAddre
 	// calculate score (always on the diff in score components of consecutive groups) and pick providers
 	prevGroupSlot := pairingscores.NewPairingSlot() // init dummy slot to compare to
 	prevGroupSlot.Reqs = map[string]pairingscores.ScoreReq{}
-
 	for idx, group := range slotGroups {
 		hashData := pairingscores.PrepareHashData(project.Index, chainID, epochHash, idx)
 		diffSlot := group.Subtract(prevGroupSlot)
@@ -175,7 +174,6 @@ func (k Keeper) getPairingForClient(ctx sdk.Context, chainID string, clientAddre
 		}
 		pickedProviders := pairingscores.PickProviders(ctx, providerScores, group.Count, hashData)
 		providers = append(providers, pickedProviders...)
-
 		prevGroupSlot = group
 	}
 
@@ -201,7 +199,10 @@ func (k Keeper) GetProjectStrictestPolicy(ctx sdk.Context, project projectstypes
 		return planstypes.Policy{}, fmt.Errorf("chain ID not allowed in all policies, or collections specified and have no intersection %#v", policies)
 	}
 
-	geolocation := k.CalculateEffectiveGeolocationFromPolicies(policies)
+	geolocation, err := k.CalculateEffectiveGeolocationFromPolicies(policies)
+	if err != nil {
+		return planstypes.Policy{}, err
+	}
 
 	providersToPair, err := k.CalculateEffectiveProvidersToPairFromPolicies(policies)
 	if err != nil {
@@ -247,17 +248,25 @@ func (k Keeper) CalculateEffectiveSelectedProviders(policies []*planstypes.Polic
 	return effectiveMode, effectiveSelectedProviders
 }
 
-func (k Keeper) CalculateEffectiveGeolocationFromPolicies(policies []*planstypes.Policy) uint64 {
+func (k Keeper) CalculateEffectiveGeolocationFromPolicies(policies []*planstypes.Policy) (uint64, error) {
 	geolocation := uint64(math.MaxUint64)
 
 	// geolocation is a bitmap. common denominator can be calculated with logical AND
 	for _, policy := range policies {
 		if policy != nil {
-			geolocation &= policy.GetGeolocationProfile()
+			geo := policy.GetGeolocationProfile()
+			if geo == uint64(planstypes.Geolocation_value["GLS"]) {
+				return uint64(planstypes.Geolocation_value["GL"]), nil
+			}
+			geolocation &= geo
 		}
 	}
 
-	return geolocation
+	if geolocation == 0 {
+		return 0, utils.LavaFormatWarning("invalid strictest geolocation", fmt.Errorf("strictest geo = 0"))
+	}
+
+	return geolocation, nil
 }
 
 func (k Keeper) CalculateEffectiveProvidersToPairFromPolicies(policies []*planstypes.Policy) (uint64, error) {

x/pairing/keeper/pairing_subscription_test.go

@@ -195,7 +195,7 @@ func TestStrictestPolicyGeolocation(t *testing.T) {
 	ts.plan.PlanPolicy.GeolocationProfile = 7
 	ts.AddPlan("mock", ts.plan)
 
-	ts.setupForPayments(1, 1, 0) // 1 provider, 0 client, default providers-to-pair
+	ts.setupForPayments(1, 1, 0) // 1 provider, 1 client, default providers-to-pair
 
 	_, client1Addr := ts.GetAccount(common.CONSUMER, 0)
 
@@ -209,13 +209,14 @@ func TestStrictestPolicyGeolocation(t *testing.T) {
 		name                   string
 		geolocationAdminPolicy uint64
 		geolocationSubPolicy   uint64
-		success                bool
+		expectedProviderPaired int
+		validPairing           bool
 	}{
-		{"effective geo = 1", uint64(1), uint64(1), true},
-		{"effective geo = 3 (includes geo=1)", uint64(3), uint64(3), true},
-		{"effective geo = 2", uint64(3), uint64(2), false},
-		{"effective geo = 0 (planPolicy & subPolicy = 1)", uint64(2), uint64(1), false},
-		{"effective geo = 0 (planPolicy & adminPolicy = 1)", uint64(1), uint64(2), false},
+		{"effective geo = 1", uint64(1), uint64(1), len(ts.Accounts(common.PROVIDER)), true},
+		{"effective geo = 3 (includes geo=1)", uint64(3), uint64(3), len(ts.Accounts(common.PROVIDER)), true},
+		{"effective geo = 2", uint64(3), uint64(2), len(ts.Accounts(common.PROVIDER)), true},
+		{"effective geo = 0 (planPolicy & subPolicy = 1)", uint64(2), uint64(1), 0, false},
+		{"effective geo = 0 (planPolicy & adminPolicy = 1)", uint64(1), uint64(2), 0, false},
 	}
 
 	for _, tt := range geolocationTestTemplates {
@@ -242,12 +243,13 @@ func TestStrictestPolicyGeolocation(t *testing.T) {
 			// the only provider is set with geolocation=1. So only geolocation that ANDs
 			// with 1 and output non-zero result, will output a provider for pairing
 			res, err := ts.QueryPairingGetPairing(ts.spec.Index, client1Addr)
-			require.Nil(t, err)
-			if tt.success {
-				require.NotEqual(t, 0, len(res.Providers))
+			if tt.validPairing {
+				require.Nil(t, err)
 			} else {
-				require.Equal(t, 0, len(res.Providers))
+				require.NotNil(t, err)
+				return
 			}
+			require.Equal(t, tt.expectedProviderPaired, len(res.Providers))
 		})
 	}
 }