CNS-391 jailing limiting needs to be per geolocation (#449)

* now unresponsiveness takes into account geolocatio

* add tests

---------

Co-authored-by: Yarom Swisa <yarom@lavanet.xyz git config --global user.name Yarom>

x/pairing/keeper/msg_server_relay_payment_test.go

@@ -62,6 +62,10 @@ func (ts *testStruct) addClient(amount int) error {
 }
 
 func (ts *testStruct) addProvider(amount int) error {
+	return ts.addProviderGeolocation(amount, 1)
+}
+
+func (ts *testStruct) addProviderGeolocation(amount int, geolocation uint64) error {
 	for i := 0; i < amount; i++ {
 		sk, address := sigs.GenerateFloatingKey()
 		ts.providers = append(ts.providers, &common.Account{SK: sk, Addr: address})
@@ -70,8 +74,8 @@ func (ts *testStruct) addProvider(amount int) error {
 			return err
 		}
 		endpoints := []epochstoragetypes.Endpoint{}
-		endpoints = append(endpoints, epochstoragetypes.Endpoint{IPPORT: "123", UseType: ts.spec.GetApis()[0].ApiInterfaces[0].Interface, Geolocation: 1})
-		_, err = ts.servers.PairingServer.StakeProvider(ts.ctx, &types.MsgStakeProvider{Creator: address.String(), ChainID: ts.spec.Name, Amount: sdk.NewCoin(epochstoragetypes.TokenDenom, sdk.NewInt(stake)), Geolocation: 1, Endpoints: endpoints})
+		endpoints = append(endpoints, epochstoragetypes.Endpoint{IPPORT: "123", UseType: ts.spec.GetApis()[0].ApiInterfaces[0].Interface, Geolocation: geolocation})
+		_, err = ts.servers.PairingServer.StakeProvider(ts.ctx, &types.MsgStakeProvider{Creator: address.String(), ChainID: ts.spec.Name, Amount: sdk.NewCoin(epochstoragetypes.TokenDenom, sdk.NewInt(stake)), Geolocation: geolocation, Endpoints: endpoints})
 		if err != nil {
 			return err
 		}

x/pairing/keeper/unresponsive_provider.go

@@ -61,12 +61,13 @@ func (k Keeper) UnstakeUnresponsiveProviders(ctx sdk.Context, epochsNumToCheckCU
 	// Go over the staked provider entries (on all chains)
 	for _, providerStakeStorage := range providerStakeStorageList {
 		providerStakeEntriesForChain := providerStakeStorage.GetStakeEntries()
-		existingProviders := uint64(len(providerStakeEntriesForChain))
+		existingProviders := map[uint64]uint64{}
+		// count providers per geolocation
+		for _, providerStakeEntry := range providerStakeEntriesForChain {
+			existingProviders[providerStakeEntry.Geolocation]++
+		}
+
 		for _, providerStakeEntry := range providerStakeEntriesForChain {
-			if existingProviders <= minimumProvidersCount {
-				// not enough providers, skip jailing any more providers
-				break
-			}
 			if minHistoryBlock < providerStakeEntry.StakeAppliedBlock {
 				// this staked provider has too short history (either since staking
 				// or since it was last unfrozen) - do not consider for jailing
@@ -79,9 +80,9 @@ func (k Keeper) UnstakeUnresponsiveProviders(ctx sdk.Context, epochsNumToCheckCU
 			}
 
 			// providerPaymentStorageKeyList is not empty -> provider should be punished
-			if len(providerPaymentStorageKeyList) != 0 {
+			if len(providerPaymentStorageKeyList) != 0 && existingProviders[providerStakeEntry.Geolocation] > minimumProvidersCount {
 				err = k.punishUnresponsiveProvider(ctx, minPaymentBlock, providerPaymentStorageKeyList, providerStakeEntry.GetAddress(), providerStakeEntry.GetChain())
-				existingProviders--
+				existingProviders[providerStakeEntry.Geolocation]--
 				if err != nil {
 					return utils.LavaError(ctx, k.Logger(ctx), "punish_unresponsive_provider", map[string]string{"err": err.Error()}, "couldn't punish unresponsive provider")
 				}

x/pairing/keeper/unresponsive_provider_test.go

@@ -344,6 +344,8 @@ func TestNotUnstakingProviderForUnresponsivenessWithMinProviders(t *testing.T) {
 	testClientAmount := 1
 	testProviderAmount := 2
 	ts := setupClientsAndProvidersForUnresponsiveness(t, testClientAmount, testProviderAmount)
+	err := ts.addProviderGeolocation(2, 2)
+	require.Nil(t, err)
 
 	// get recommendedEpochNumToCollectPayment
 	recommendedEpochNumToCollectPayment := ts.keepers.Pairing.RecommendedEpochNumToCollectPayment(sdk.UnwrapSDKContext(ts.ctx))