smith-members

Closes #168 (closed).

Présentation

Nouvelle palette visant à remplacer l'implémentation actuelle de la WoT Smith.

Avancement :

• events
• replace duniter-wot<Instance2> by smith-members
• integration tests
• benchmarks (écriture + lancement local)
• benchmarks (sur machine de référence)
• remove duniter-wot + certifications + membership instance parameters
• clean // TODOs

Impacts si adoptée :

1. la palette duniter-wot n'est plus instanciée (ni membership ni certification ) : réalisé dans cette MR
2. la palette membership , exploitée seulement pour la WoT principale, pourrait disparaître (voir explication ici) : non réalisé dans cette MR

Architecture

La palette s'intercale entre la palette membership et authority-members.

Son rôle est de définir qui est Smith, c'est-à-dire qui fait partie du groupe de personnes capables d'interagir avec la palette authority-members et plus spécifiquement la méthode go_online().

La palette :

• en aval :
  • implémente IsMember de authority-members pour avoir un contrôle sur go_online()
  • fournit un trait OnSmithDelete qui notifie authority-members qu'un Smith a perdu son statut et donc qu'une autorité, éventuellement online, doit être exclue (via OutgoingAuthorities)
• en amont :
  • définit un trait IsWoTMember implémenté par la palette membership qui fournit qui est membre de la WoT (car seuls les membres peuvent devenir Smith)
  • implémente OnIdtyChange de la palette identity afin de retirer le statut Smith à qui perd le statut membre de la WoT

Fonctionnement

Je suis parti de l'idée que nous souhaitions conserver une toile Smith à peu près sur les mêmes règles que l'actuelle, à savoir :

• il faut être Membre (de la WoT) pour devenir Smith
• devenir Smith se fait par certification

J'ai toutefois changé quelques éléments :

• les certifications n'expirent plus, mais sont perdues par leur bénéficiaire s'il perd le statut de Smith
• les certifications (et invitations) ne sont possibles que pour les Smith online (c-à-d au statut d'Autorité au sens de la palette authority-members)
• il n'y a plus de concept d'adhésion, remplacé par l'acception d'une invitation et le maintien du statut grâce à go_online()

Processus d'inscription

Pour devenir Smith un membre de la WoT doit :

1. Être invité par un Smith existant
2. Accepter l'invitation
3. Recevoir suffisamment de certifications

Et c'est tout. A partir du moment où l'étape 3 est atteinte, le Smith peut :

• devenir autorité : il lui faut simplement faire un go_online()
• inviter et certifier d'autres smiths

Limites

Un Smith ne peut pas rester éternellement Smith et offline. Le but d'être Smith est de mettre en place un nœud validateur.

De ce fait, un Smith expire au bout de SmithInactivityMaxDuration sessions. Dans ce cas, le Smith arbore un statut Excluded et perd toutes ses certifications.

Toutefois, les certifications valides (c-à-d celles dont le bénéficiaire est Smith) restent comptabilisées au cas où le smith exclu redevenait Smith par la suite : il ne faudrait pas qu'il puisse artificiellement gonfler son stock par entrée/sortie du cercle des smiths.

Redevenir Smith

Un Smith exclu peut redevenir Smith. Mais il doit recommencer tout le processus et recevoir des certifications en repartant de zéro.

Stock de certifications

Chaque Smith dispose d'un stock de MaxByIssuer certifications valides qu'il peut émettre.

Les certifications n'ont plus de date d'expiration : celles-ci sont données "à vie de Smith non exclu". L'idée est de récompenser le comportement de Smith actif, c'est-à-dire qui est online de façon stable (ou devient offline pendant de courtes durées).

Un Smith exclu peut redevenir Smith. Ce processus d'entrée/sortie n'influe pas sur le stock d'émission MaxByIssuer qui reste le même peu importe le nombre d'entrée/sortie de la toile Smith effectuées. Ce qui augmente ou diminue son stock de certification est uniquement lié à l'émission des certifications réalisées, ou à la perte de statut Smith des autres membres forgerons.

pallets/smith-members/src/lib.rs

@@ -225,30 +225,28 @@ pub mod pallet {
 
     #[pallet::error]
     pub enum Error<T> {
-        /// Certification issuer has no known identity ID
-        UnknownIssuer,
+        /// Issuer of anything (invitation, acceptance, certification) must have an identity ID
+        OriginMustHaveAnIdentity,
         /// Issuer must be known as a potential smith
-        IssuerHasNoSmithStatus,
+        OriginHasNeverBeenInvited,
         /// Invitation is reseverd to smiths
-        CannotInvite,
-        /// Must have receive invitation to accept it
-        NotInvited,
+        InvitationIsASmithPrivilege,
         /// Invitation must not have been accepted yet
-        AlreadyAcceptedInvitation,
-        /// Recevier must not be known among smiths
-        OnlyExcludedCanComeBack,
-        /// Recevier must have accepted to eventually become a smith
-        ReceveirMustAcceptInvitation,
+        InvitationAlreadyAccepted,
+        /// Invitation of an already known smith is forbidden except if it has been excluded
+        InvitationOfNonExcluded,
+        /// Certification cannot be made on someone who has not accepted an invitation
+        CertificationMustBeAgreed,
+        /// Certification cannot be made on excluded
+        CertificationOnExcludedIsForbidden,
         /// Issuer must be a smith
-        IssuerIsNotASmith,
+        CertificationIsASmithPrivilege,
         /// Smith cannot certify itself
-        CannotCertifySelf,
+        CertificationOfSelfIsForbidden,
         /// Receiver must be invited by another smith
-        ReceiverHasNotBeenInvited,
-        /// Smith must be a member of the main WoT
-        NotAMember,
+        CertificationReceiverMustHaveBeenInvited,
         /// A smith has a limited stock of certifications
-        TooMuchCertificationsIssued,
+        CertificationStockFullyConsumed,
     }
 
     #[pallet::call]
@@ -260,7 +258,8 @@ pub mod pallet {
             receiver: T::IdtyIndex,
         ) -> DispatchResultWithPostInfo {
             let who = ensure_signed(origin.clone())?;
-            let issuer = T::IdtyIdOf::convert(who.clone()).ok_or(Error::<T>::UnknownIssuer)?;
+            let issuer =
+                T::IdtyIdOf::convert(who.clone()).ok_or(Error::<T>::OriginMustHaveAnIdentity)?;
             Self::check_invite_smith(issuer, receiver)?;
             Self::do_invite_smith(issuer, receiver);
             Ok(().into())
@@ -270,7 +269,8 @@ pub mod pallet {
         #[pallet::weight(1_000_000_000)]
         pub fn accept_invitation(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
             let who = ensure_signed(origin.clone())?;
-            let receiver = T::IdtyIdOf::convert(who.clone()).ok_or(Error::<T>::UnknownIssuer)?;
+            let receiver =
+                T::IdtyIdOf::convert(who.clone()).ok_or(Error::<T>::OriginMustHaveAnIdentity)?;
             Self::check_accept_invitation(receiver)?;
             Self::do_accept_invitation(receiver)?;
             Ok(().into())
@@ -283,7 +283,8 @@ pub mod pallet {
             receiver: T::IdtyIndex,
         ) -> DispatchResultWithPostInfo {
             let who = ensure_signed(origin)?;
-            let issuer = T::IdtyIdOf::convert(who.clone()).ok_or(Error::<T>::UnknownIssuer)?;
+            let issuer =
+                T::IdtyIdOf::convert(who.clone()).ok_or(Error::<T>::OriginMustHaveAnIdentity)?;
             Self::check_certify_smith(issuer, receiver)?;
             Self::do_certify_smith(receiver, issuer);
             Ok(().into())
@@ -297,16 +298,16 @@ impl<T: Config> Pallet<T> {
         receiver: T::IdtyIndex,
     ) -> DispatchResultWithPostInfo {
         let issuer_status = Smiths::<T>::get(issuer)
-            .ok_or(Error::<T>::IssuerHasNoSmithStatus)?
+            .ok_or(Error::<T>::OriginHasNeverBeenInvited)?
             .status;
         ensure!(
             issuer_status == SmithStatus::Smith,
-            Error::<T>::CannotInvite
+            Error::<T>::InvitationIsASmithPrivilege
         );
         if let Some(receiver_meta) = Smiths::<T>::get(receiver) {
             ensure!(
                 receiver_meta.status == SmithStatus::Excluded,
-                Error::<T>::OnlyExcludedCanComeBack
+                Error::<T>::InvitationOfNonExcluded
             );
         }
 
@@ -343,11 +344,11 @@ impl<T: Config> Pallet<T> {
 
     fn check_accept_invitation(receiver: T::IdtyIndex) -> DispatchResultWithPostInfo {
         let pretender_status = Smiths::<T>::get(receiver)
-            .ok_or(Error::<T>::NotInvited)?
+            .ok_or(Error::<T>::OriginHasNeverBeenInvited)?
             .status;
         ensure!(
             pretender_status == SmithStatus::Invited,
-            Error::<T>::AlreadyAcceptedInvitation
+            Error::<T>::InvitationAlreadyAccepted
         );
         Ok(().into())
     }
@@ -367,23 +368,30 @@ impl<T: Config> Pallet<T> {
         issuer: T::IdtyIndex,
         receiver: T::IdtyIndex,
     ) -> DispatchResultWithPostInfo {
-        ensure!(issuer != receiver, Error::<T>::CannotCertifySelf);
-        let issuer = Smiths::<T>::get(issuer).ok_or(Error::<T>::IssuerHasNoSmithStatus)?;
+        ensure!(
+            issuer != receiver,
+            Error::<T>::CertificationOfSelfIsForbidden
+        );
+        let issuer = Smiths::<T>::get(issuer).ok_or(Error::<T>::OriginHasNeverBeenInvited)?;
         ensure!(
             issuer.status == SmithStatus::Smith,
-            Error::<T>::IssuerIsNotASmith
+            Error::<T>::CertificationIsASmithPrivilege
         );
         let issued_certs = issuer.issued_certs.len() as u32;
         ensure!(
             issued_certs < T::MaxByIssuer::get(),
-            Error::<T>::TooMuchCertificationsIssued
+            Error::<T>::CertificationStockFullyConsumed
         );
         let receiver_status = Smiths::<T>::get(receiver)
-            .ok_or(Error::<T>::ReceiverHasNotBeenInvited)?
+            .ok_or(Error::<T>::CertificationReceiverMustHaveBeenInvited)?
             .status;
         ensure!(
             receiver_status != SmithStatus::Invited,
-            Error::<T>::ReceveirMustAcceptInvitation
+            Error::<T>::CertificationMustBeAgreed
+        );
+        ensure!(
+            receiver_status != SmithStatus::Excluded,
+            Error::<T>::CertificationOnExcludedIsForbidden
         );
 
         Ok(().into())