add Invalid case in distance status

pallets/distance/src/lib.rs

@@ -234,7 +234,8 @@ pub mod pallet {
                 pallet_identity::IdentityIndexOf::<T>::get(&who).ok_or(Error::<T>::NoIdentity)?;
 
             ensure!(
-                IdentityDistanceStatus::<T>::get(idty).is_none(),
+                IdentityDistanceStatus::<T>::get(idty)
+                    != Some((who.clone(), DistanceStatus::Pending)),
                 Error::<T>::AlreadyInEvaluation
             );
 
@@ -479,24 +480,23 @@ pub mod pallet {
                         MedianResult::One(m) => m,
                         MedianResult::Two(m1, m2) => m1 + (m2 - m1) / 2, // Avoid overflow (since max is 1)
                     };
-                    if median >= T::MinAccessibleReferees::get() {
                     IdentityDistanceStatus::<T>::mutate(idty, |entry| {
                         entry.as_mut().map(|(account_id, status)| {
+                            if median >= T::MinAccessibleReferees::get() {
                                 T::Currency::unreserve(
                                     account_id,
                                     <T as Config>::EvaluationPrice::get(),
                                 );
                                 *status = DistanceStatus::Valid;
-                            })
-                        });
-                    } else if let Some((account_id, _status)) =
-                        IdentityDistanceStatus::<T>::take(idty)
-                    {
+                            } else {
                                 <T as Config>::Currency::slash_reserved(
                                     &account_id,
                                     <T as Config>::EvaluationPrice::get(),
                                 );
+                                *status = DistanceStatus::Invalid;
                             }
+                        });
+                    });
                 } else if let Some((account_id, _status)) = IdentityDistanceStatus::<T>::take(idty)
                 {
                     <T as Config>::Currency::unreserve(

pallets/distance/src/types.rs

@@ -28,6 +28,8 @@ pub enum DistanceStatus {
     Pending,
     /// Identity respects the distance
     Valid,
+    /// Identity doesn't respect the distance
+    Invalid,
 }
 
 /// Pool where distance evaluation requests and results are stored

pallets/duniter-wot/src/lib.rs

@@ -109,8 +109,10 @@ pub mod pallet {
     pub enum Error<T, I = ()> {
         /// Insufficient certifications received to claim membership.
         NotEnoughCertsToClaimMembership,
-        /// Distance has not received a positive evaluation.
-        DistanceNotOk,
+        /// Distance is invalid.
+        DistanceIsInvalid,
+        /// Distance is not evaluated.
+        DistanceNotEvaluated,
         /// Identity is not allowed to request membership.
         IdtyNotAllowedToRequestMembership,
         /// Identity not allowed to renew membership.
@@ -296,10 +298,7 @@ impl<T: Config<I>, I: 'static> sp_membership::traits::CheckMembershipCallAllowed
             idty_cert_meta.received_count >= T::MinCertForMembership::get(),
             Error::<T, I>::NotEnoughCertsToClaimMembership
         );
-        ensure!(
-            T::IsDistanceOk::is_distance_ok(idty_index),
-            Error::<T, I>::DistanceNotOk,
-        );
+        T::IsDistanceOk::is_distance_ok(idty_index)?;
         Ok(())
     }
 
@@ -310,10 +309,7 @@ impl<T: Config<I>, I: 'static> sp_membership::traits::CheckMembershipCallAllowed
                 idty_value.status == IdtyStatus::Validated,
                 Error::<T, I>::IdtyNotAllowedToRenewMembership
             );
-            ensure!(
-                T::IsDistanceOk::is_distance_ok(idty_index),
-                Error::<T, I>::DistanceNotOk,
-            );
+            T::IsDistanceOk::is_distance_ok(idty_index)?;
         } else {
             return Err(Error::<T, I>::IdtyNotFound.into());
         }

pallets/duniter-wot/src/traits.rs

@@ -14,14 +14,16 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.
 
+use crate::DispatchError;
+
 pub trait IsDistanceOk<IdtyId> {
-    fn is_distance_ok(idty_id: &IdtyId) -> bool;
+    fn is_distance_ok(idty_id: &IdtyId) -> Result<(), DispatchError>;
 }
 
 pub struct DistanceAlwaysOk;
 
 impl<IdtyId> IsDistanceOk<IdtyId> for DistanceAlwaysOk {
-    fn is_distance_ok(_idty_id: &IdtyId) -> bool {
-        true
+    fn is_distance_ok(_idty_id: &IdtyId) -> Result<(), DispatchError> {
+        Ok(())
     }
 }

runtime/common/src/providers.rs

@@ -17,6 +17,7 @@
 use crate::{entities::IdtyData, AccountId, IdtyIndex};
 use core::marker::PhantomData;
 use pallet_universal_dividend::FirstEligibleUd;
+use sp_runtime::DispatchError;
 use sp_std::boxed::Box;
 use sp_std::vec::Vec;
 
@@ -112,13 +113,16 @@ pub struct MainWotIsDistanceOk<T>(PhantomData<T>);
 impl<T> pallet_duniter_wot::traits::IsDistanceOk<<T as pallet_identity::Config>::IdtyIndex>
     for MainWotIsDistanceOk<T>
 where
-    T: pallet_distance::Config,
+    T: pallet_distance::Config + pallet_duniter_wot::Config<frame_support::instances::Instance1>,
 {
-    fn is_distance_ok(idty_id: &<T as pallet_identity::Config>::IdtyIndex) -> bool {
-        matches!(
-            pallet_distance::Pallet::<T>::identity_distance_status(idty_id),
-            Some((_, pallet_distance::DistanceStatus::Valid))
-        )
+    fn is_distance_ok(
+        idty_id: &<T as pallet_identity::Config>::IdtyIndex,
+    ) -> Result<(), DispatchError> {
+        match pallet_distance::Pallet::<T>::identity_distance_status(idty_id) {
+			Some((_, pallet_distance::DistanceStatus::Valid)) => Ok(()).into(),
+			Some((_, pallet_distance::DistanceStatus::Invalid)) => Err(pallet_duniter_wot::Error::<T, frame_support::instances::Instance1>::DistanceIsInvalid.into()),
+			_ => Err(pallet_duniter_wot::Error::<T, frame_support::instances::Instance1>::DistanceNotEvaluated.into()),
+		}
     }
 }