perf(pallet-cert): remove useless double map CertsByIssuer (!88)

* ref(runtime): rework pallet certification

end2end-tests/cucumber-features/certification.feature

@@ -3,5 +3,6 @@
 Feature: Certification
 
     Scenario: Dave certifies Alice
+        When 2 blocks later
         When dave certifies alice
         Then alice should be certified by dave

end2end-tests/cucumber-genesis/wot.json

@@ -4,12 +4,12 @@
   "identities": {
     "Alice": {
       "balance": 1000,
-      "certs": ["Bob", "Charlie", "Dave"],
+      "certs": ["Bob", "Charlie"],
       "pubkey": "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY"
     },
     "Bob": {
       "balance": 1000,
-      "certs": ["Alice", "Charlie", "Dave"],
+      "certs": ["Alice", "Charlie"],
       "pubkey": "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty"
     },
     "Charlie": {
@@ -19,13 +19,13 @@
     },
     "Dave": {
       "balance": 1000,
-      "certs": [],
+      "certs": ["Alice", "Bob"],
       "pubkey": "5DAAnrj7VHTznn2AWBemMuyBwZWs6FNFjdyVXUeYum3PTXFy"
     }
   },
   "parameters": {
     "babe_epoch_duration": 30,
-    "cert_period": 15,
+    "cert_period": 2,
     "cert_max_by_issuer": 10,
     "cert_min_received_cert_to_issue_cert": 2,
     "cert_validity_period": 1000,

end2end-tests/tests/cucumber_tests.rs

@@ -278,15 +278,23 @@ async fn should_be_certified_by(
         .await?
         .unwrap();
 
-    let _certification = world
+    let issuers = world
         .api()
         .storage()
         .cert()
-        .storage_certs_by_issuer(issuer_index, receiver_index, None)
-        .await?
-        .ok_or_else(|| anyhow::anyhow!("no certification found from {} to {}", issuer, receiver))?;
+        .certs_by_receiver(receiver_index, None)
+        .await?;
 
-    Ok(())
+    match issuers.binary_search_by(|(issuer_, _)| issuer_index.cmp(issuer_)) {
+        Ok(_) => Ok(()),
+        Err(_) => Err(anyhow::anyhow!(
+            "no certification found from {} to {}: {:?}",
+            issuer,
+            receiver,
+            issuers
+        )
+        .into()),
+    }
 }
 
 // ============================================================

node/src/chain_spec/gdev.rs

@@ -380,7 +380,7 @@ fn gen_genesis_for_local_chain(
         },
         cert: CertConfig {
             apply_cert_period_at_genesis: false,
-            certs_by_issuer: clique_wot(initial_identities.len(), cert_validity_period),
+            certs_by_receiver: clique_wot(initial_identities.len(), cert_validity_period),
         },
         smiths_membership: SmithsMembershipConfig {
             memberships: (1..=initial_smiths_len)
@@ -389,7 +389,7 @@ fn gen_genesis_for_local_chain(
         },
         smiths_cert: SmithsCertConfig {
             apply_cert_period_at_genesis: false,
-            certs_by_issuer: clique_wot(initial_smiths_len, smith_cert_validity_period),
+            certs_by_receiver: clique_wot(initial_smiths_len, smith_cert_validity_period),
         },
         smiths_collective: Default::default(),
         universal_dividend: UniversalDividendConfig {
@@ -427,7 +427,7 @@ fn genesis_data_to_gdev_genesis_conf(
 ) -> gdev_runtime::GenesisConfig {
     let super::gen_genesis_data::GenesisData {
         accounts,
-        certs_by_issuer,
+        certs_by_receiver,
         first_ud,
         first_ud_reeval,
         identities,
@@ -436,7 +436,7 @@ fn genesis_data_to_gdev_genesis_conf(
         memberships,
         parameters,
         session_keys_map,
-        smiths_certs_by_issuer,
+        smiths_certs_by_receiver,
         smiths_memberships,
         sudo_key,
     } = genesis_data;
@@ -486,12 +486,12 @@ fn genesis_data_to_gdev_genesis_conf(
         },
         cert: CertConfig {
             apply_cert_period_at_genesis: true,
-            certs_by_issuer,
+            certs_by_receiver,
         },
         membership: MembershipConfig { memberships },
         smiths_cert: SmithsCertConfig {
             apply_cert_period_at_genesis: true,
-            certs_by_issuer: smiths_certs_by_issuer,
+            certs_by_receiver: smiths_certs_by_receiver,
         },
         smiths_membership: SmithsMembershipConfig {
             memberships: smiths_memberships,

node/src/chain_spec/gen_genesis_data.rs

@@ -26,7 +26,7 @@ const EXISTENTIAL_DEPOSIT: u64 = 100;
 #[derive(Clone)]
 pub struct GenesisData<Parameters: DeserializeOwned, SessionKeys: Decode> {
     pub accounts: BTreeMap<AccountId, GenesisAccountData<u64>>,
-    pub certs_by_issuer: BTreeMap<u32, BTreeMap<u32, u32>>,
+    pub certs_by_receiver: BTreeMap<u32, BTreeMap<u32, u32>>,
     pub first_ud: u64,
     pub first_ud_reeval: u32,
     pub identities: Vec<(String, AccountId)>,
@@ -35,7 +35,7 @@ pub struct GenesisData<Parameters: DeserializeOwned, SessionKeys: Decode> {
     pub memberships: BTreeMap<u32, MembershipData>,
     pub parameters: Parameters,
     pub session_keys_map: BTreeMap<AccountId, SessionKeys>,
-    pub smiths_certs_by_issuer: BTreeMap<u32, BTreeMap<u32, u32>>,
+    pub smiths_certs_by_receiver: BTreeMap<u32, BTreeMap<u32, u32>>,
     pub smiths_memberships: BTreeMap<u32, MembershipData>,
     pub sudo_key: Option<AccountId>,
 }
@@ -209,19 +209,19 @@ where
 
     // CERTIFICATIONS //
 
-    let mut certs_by_issuer = BTreeMap::new();
+    let mut certs_by_receiver = BTreeMap::new();
     for (idty_name, identity) in &identities {
         let issuer_index = idty_index_of
             .get(&idty_name)
             .ok_or(format!("Identity '{}' not exist", &idty_name))?;
-        let mut issuer_certs = BTreeMap::new();
-        for receiver in &identity.certs {
-            let receiver_index = idty_index_of
-                .get(receiver)
-                .ok_or(format!("Identity '{}' not exist", receiver))?;
-            issuer_certs.insert(*receiver_index, genesis_certs_expire_on);
+        let mut receiver_certs = BTreeMap::new();
+        for issuer in &identity.certs {
+            let issuer_index = idty_index_of
+                .get(issuer)
+                .ok_or(format!("Identity '{}' not exist", issuer))?;
+            receiver_certs.insert(*issuer_index, genesis_certs_expire_on);
         }
-        certs_by_issuer.insert(*issuer_index, issuer_certs);
+        certs_by_receiver.insert(*issuer_index, receiver_certs);
     }
 
     // SMITHS SUB-WOT //
@@ -230,7 +230,7 @@ where
     let mut online_authorities_counter = 0;
     let mut session_keys_map = BTreeMap::new();
     let mut smiths_memberships = BTreeMap::new();
-    let mut smiths_certs_by_issuer = BTreeMap::new();
+    let mut smiths_certs_by_receiver = BTreeMap::new();
     for (idty_name, smith_data) in smith_identities {
         let idty_index = idty_index_of
             .get(&idty_name)
@@ -284,14 +284,14 @@ where
         );
 
         // Certifications
-        let mut issuer_certs = BTreeMap::new();
+        let mut receiver_certs = BTreeMap::new();
         for receiver in &smith_data.certs {
-            let receiver_index = idty_index_of
+            let issuer_index = idty_index_of
                 .get(receiver)
                 .ok_or(format!("Identity '{}' not exist", receiver))?;
-            issuer_certs.insert(*receiver_index, genesis_smith_certs_expire_on);
+            receiver_certs.insert(*issuer_index, genesis_smith_certs_expire_on);
         }
-        smiths_certs_by_issuer.insert(*idty_index, issuer_certs);
+        smiths_certs_by_receiver.insert(*idty_index, receiver_certs);
 
         // Memberships
         smiths_memberships.insert(
@@ -308,7 +308,7 @@ where
 
     let genesis_data = GenesisData {
         accounts,
-        certs_by_issuer,
+        certs_by_receiver,
         first_ud,
         first_ud_reeval,
         identities: identities_,
@@ -317,7 +317,7 @@ where
         memberships,
         parameters,
         session_keys_map,
-        smiths_certs_by_issuer,
+        smiths_certs_by_receiver,
         smiths_memberships,
         sudo_key,
     };

pallets/certification/src/lib.rs

@@ -92,7 +92,7 @@ pub mod pallet {
     #[pallet::genesis_config]
     pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
         pub apply_cert_period_at_genesis: bool,
-        pub certs_by_issuer: BTreeMap<T::IdtyIndex, BTreeMap<T::IdtyIndex, T::BlockNumber>>,
+        pub certs_by_receiver: BTreeMap<T::IdtyIndex, BTreeMap<T::IdtyIndex, T::BlockNumber>>,
     }
 
     #[cfg(feature = "std")]
@@ -100,7 +100,7 @@ pub mod pallet {
         fn default() -> Self {
             Self {
                 apply_cert_period_at_genesis: false,
-                certs_by_issuer: Default::default(),
+                certs_by_receiver: Default::default(),
             }
         }
     }
@@ -110,47 +110,36 @@ pub mod pallet {
         fn build(&self) {
             let mut cert_meta_by_issuer =
                 BTreeMap::<T::IdtyIndex, IdtyCertMeta<T::BlockNumber>>::new();
-            let mut certs_by_receiver = BTreeMap::<T::IdtyIndex, Vec<T::IdtyIndex>>::new();
-            for (issuer, receivers) in &self.certs_by_issuer {
+            let mut certs_removable_on =
+                BTreeMap::<T::BlockNumber, Vec<(T::IdtyIndex, T::IdtyIndex)>>::new();
+            for (receiver, issuers) in &self.certs_by_receiver {
+                // Forbid self-cert
                 assert!(
-                    !receivers.contains_key(issuer),
+                    !issuers.contains_key(receiver),
                     "Identity cannot certify it-self."
                 );
-                assert!(
-                    !receivers.len() >= T::MaxByIssuer::get() as usize,
-                    "Identity n°{:?} exceed MaxByIssuer.",
-                    issuer
-                );
 
-                cert_meta_by_issuer.insert(
-                    *issuer,
-                    IdtyCertMeta {
-                        issued_count: receivers.len() as u32,
+                // We should insert cert_meta for receivers that have not issued any cert.
+                cert_meta_by_issuer
+                    .entry(*receiver)
+                    .or_insert(IdtyCertMeta {
+                        issued_count: 0,
                         next_issuable_on: sp_runtime::traits::Zero::zero(),
-                        received_count: 0,
-                    },
-                );
-                for receiver in receivers.keys() {
-                    certs_by_receiver
-                        .entry(*receiver)
-                        .or_default()
-                        .push(*issuer);
-                }
-            }
+                        received_count: issuers.len() as u32,
+                    });
 
-            // Write StorageCertsByReceiver
-            for (receiver, mut issuers) in certs_by_receiver {
-                cert_meta_by_issuer
-                    .entry(receiver)
-                    .and_modify(|cert_meta| cert_meta.received_count = issuers.len() as u32);
-                issuers.sort();
-                <StorageCertsByReceiver<T, I>>::insert(receiver, issuers);
-            }
-            // Write StorageCertsByIssuer
-            let mut certs_removable_on =
-                BTreeMap::<T::BlockNumber, Vec<(T::IdtyIndex, T::IdtyIndex)>>::new();
-            for (issuer, receivers) in &self.certs_by_issuer {
-                for (receiver, removable_on) in receivers {
+                for (issuer, removable_on) in issuers {
+                    // Count issued certs
+                    cert_meta_by_issuer
+                        .entry(*issuer)
+                        .or_insert(IdtyCertMeta {
+                            issued_count: 0,
+                            next_issuable_on: sp_runtime::traits::Zero::zero(),
+                            received_count: issuers.len() as u32,
+                        })
+                        .issued_count += 1;
+
+                    // Prepare CertsRemovableOn
                     certs_removable_on
                         .entry(*removable_on)
                         .or_default()
@@ -166,23 +155,31 @@ pub mod pallet {
                             }
                         }
                     }
-
-                    <StorageCertsByIssuer<T, I>>::insert(
-                        issuer,
-                        receiver,
-                        CertValue {
-                            removable_on: *removable_on,
-                        },
-                    );
                 }
+
+                // Write CertsByReceiver
+                let mut issuers: Vec<_> = issuers.iter().collect();
+                issuers.sort();
+                CertsByReceiver::<T, I>::insert(receiver, issuers);
             }
+
             // Write StorageIdtyCertMeta
             for (issuer, cert_meta) in cert_meta_by_issuer {
-                <StorageIdtyCertMeta<T, I>>::insert(issuer, cert_meta);
+                assert!(
+                    !cert_meta.issued_count >= T::MaxByIssuer::get(),
+                    "Identity n°{:?} exceed MaxByIssuer.",
+                    issuer
+                );
+                assert!(
+                    !cert_meta.received_count >= T::MinReceivedCertToBeAbleToIssueCert::get(),
+                    "Identity n°{:?} not respect MinReceivedCertToBeAbleToIssueCert.",
+                    issuer
+                );
+                StorageIdtyCertMeta::<T, I>::insert(issuer, cert_meta);
             }
             // Write storage StorageCertsRemovableOn
             for (removable_on, certs) in certs_removable_on {
-                <StorageCertsRemovableOn<T, I>>::insert(removable_on, certs);
+                StorageCertsRemovableOn::<T, I>::insert(removable_on, certs);
             }
         }
     }
@@ -195,27 +192,11 @@ pub mod pallet {
     pub type StorageIdtyCertMeta<T: Config<I>, I: 'static = ()> =
         StorageMap<_, Twox64Concat, T::IdtyIndex, IdtyCertMeta<T::BlockNumber>, ValueQuery>;
 
-    /// Certifications by issuer
-    #[pallet::storage]
-    #[pallet::getter(fn cert)]
-    /// Certifications by issuer
-    pub(super) type StorageCertsByIssuer<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
-        _,
-        Twox64Concat,
-        T::IdtyIndex,
-        Twox64Concat,
-        T::IdtyIndex,
-        CertValue<T::BlockNumber>,
-        OptionQuery,
-        GetDefault,
-        ConstU32<4_000_000_000>,
-    >;
-
     /// Certifications by receiver
     #[pallet::storage]
     #[pallet::getter(fn certs_by_receiver)]
-    pub type StorageCertsByReceiver<T: Config<I>, I: 'static = ()> =
-        StorageMap<_, Twox64Concat, T::IdtyIndex, Vec<T::IdtyIndex>, ValueQuery>;
+    pub type CertsByReceiver<T: Config<I>, I: 'static = ()> =
+        StorageMap<_, Twox64Concat, T::IdtyIndex, Vec<(T::IdtyIndex, T::BlockNumber)>, ValueQuery>;
 
     /// Certifications removable on
     #[pallet::storage]
@@ -310,8 +291,7 @@ pub mod pallet {
                 }
             };
 
-            let create = !StorageCertsByIssuer::<T, I>::contains_key(issuer, receiver);
-            Self::do_add_cert(block_number, create, issuer, receiver)
+            Self::do_add_cert(block_number, issuer, receiver)
         }
         /// Add a new certification or renew an existing one
         ///
@@ -348,8 +328,7 @@ pub mod pallet {
                 return Err(Error::<T, I>::IssuedTooManyCert.into());
             }
 
-            let create = !StorageCertsByIssuer::<T, I>::contains_key(issuer, receiver);
-            Self::do_add_cert(block_number, create, issuer, receiver)
+            Self::do_add_cert(block_number, issuer, receiver)
         }
 
         #[pallet::weight(1_000_000_000)]
@@ -369,10 +348,8 @@ pub mod pallet {
             idty_index: T::IdtyIndex,
         ) -> DispatchResultWithPostInfo {
             ensure_root(origin)?;
-            if let Ok(issuers) = <StorageCertsByReceiver<T, I>>::try_get(idty_index) {
-                for issuer in issuers {
-                    Self::remove_cert_inner(issuer, idty_index, None);
-                }
+            for (issuer, _) in CertsByReceiver::<T, I>::get(idty_index) {
+                Self::remove_cert_inner(issuer, idty_index, None);
             }
             Ok(().into())
         }
@@ -383,42 +360,42 @@ pub mod pallet {
     impl<T: Config<I>, I: 'static> Pallet<T, I> {
         fn do_add_cert(
             block_number: T::BlockNumber,
-            create: bool,
             issuer: T::IdtyIndex,
             receiver: T::IdtyIndex,
         ) -> DispatchResultWithPostInfo {
-            // Write StorageIdtyCertMeta for issuer
-            let issuer_issued_count =
-                StorageIdtyCertMeta::<T, I>::mutate(issuer, |issuer_idty_cert_meta| {
-                    issuer_idty_cert_meta.issued_count =
-                        issuer_idty_cert_meta.issued_count.saturating_add(1);
-                    issuer_idty_cert_meta.next_issuable_on = block_number + T::CertPeriod::get();
-                    issuer_idty_cert_meta.issued_count
-                });
+            // Write StorageCertsRemovableOn
+            let removable_on = block_number + T::ValidityPeriod::get();
+            <StorageCertsRemovableOn<T, I>>::append(removable_on, (issuer, receiver));
+
+            // Write CertsByReceiver
+            let mut created = false;
+            CertsByReceiver::<T, I>::mutate_exists(receiver, |maybe_issuers| {
+                let issuers = maybe_issuers.get_or_insert(Vec::with_capacity(0));
+                if let Err(index) = issuers.binary_search_by(|(issuer_, _)| issuer.cmp(issuer_)) {
+                    issuers.insert(index, (issuer, removable_on));
+                    created = true;
+                }
+            });
 
-            // Write StorageIdtyCertMeta for receiver
-            let receiver_received_count =
-                <StorageIdtyCertMeta<T, I>>::mutate_exists(receiver, |cert_meta_opt| {
-                    let cert_meta = cert_meta_opt.get_or_insert(IdtyCertMeta::default());
-                    cert_meta.received_count = cert_meta.received_count.saturating_add(1);
-                    cert_meta.received_count
-                });
+            if created {
+                // Write StorageIdtyCertMeta for issuer
+                let issuer_issued_count =
+                    StorageIdtyCertMeta::<T, I>::mutate(issuer, |issuer_idty_cert_meta| {
+                        issuer_idty_cert_meta.issued_count =
+                            issuer_idty_cert_meta.issued_count.saturating_add(1);
+                        issuer_idty_cert_meta.next_issuable_on =
+                            block_number + T::CertPeriod::get();
+                        issuer_idty_cert_meta.issued_count
+                    });
+
+                // Write StorageIdtyCertMeta for receiver
+                let receiver_received_count =
+                    <StorageIdtyCertMeta<T, I>>::mutate_exists(receiver, |cert_meta_opt| {
+                        let cert_meta = cert_meta_opt.get_or_insert(IdtyCertMeta::default());
+                        cert_meta.received_count = cert_meta.received_count.saturating_add(1);
+                        cert_meta.received_count
+                    });
 
-            // Write StorageCertsRemovableOn and StorageCertsByIssuer
-            let cert_value = CertValue {
-                removable_on: block_number + T::ValidityPeriod::get(),
-            };
-            <StorageCertsRemovableOn<T, I>>::append(cert_value.removable_on, (issuer, receiver));
-            <StorageCertsByIssuer<T, I>>::insert(issuer, receiver, cert_value);
-
-            if create {
-                // Write StorageCertsByReceiver
-                <StorageCertsByReceiver<T, I>>::mutate_exists(receiver, |issuers_opt| {
-                    let issuers = issuers_opt.get_or_insert(Vec::with_capacity(0));
-                    if let Err(index) = issuers.binary_search(&issuer) {
-                        issuers.insert(index, issuer);
-                    }
-                });
                 Self::deposit_event(Event::NewCert {
                     issuer,
                     issuer_issued_count,
@@ -455,24 +432,23 @@ pub mod pallet {
         ) -> Weight {
             let mut total_weight: Weight = 0;
             let mut removed = false;
-            <StorageCertsByIssuer<T, I>>::mutate_exists(issuer, receiver, |cert_val_opt| {
-                if let Some(cert_val) = cert_val_opt {
-                    if Some(cert_val.removable_on) == block_number_opt || block_number_opt.is_none()
-                    {
+            CertsByReceiver::<T, I>::mutate_exists(receiver, |issuers_opt| {
+                let issuers = issuers_opt.get_or_insert(Vec::with_capacity(0));
+                if let Ok(index) = issuers.binary_search_by(|(issuer_, _)| issuer.cmp(issuer_)) {
+                    if let Some(block_number) = block_number_opt {
+                        if let Some((_, removable_on)) = issuers.get(index) {
+                            if *removable_on == block_number {
+                                issuers.remove(index);
+                                removed = true;
+                            }
+                        }
+                    } else {
+                        issuers.remove(index);
                         removed = true;
                     }
                 }
-                if removed {
-                    cert_val_opt.take();
-                }
             });
             if removed {
-                <StorageCertsByReceiver<T, I>>::mutate_exists(receiver, |issuers_opt| {
-                    let issuers = issuers_opt.get_or_insert(Vec::with_capacity(0));
-                    if let Ok(index) = issuers.binary_search(&issuer) {
-                        issuers.remove(index);
-                    }
-                });
                 let issuer_issued_count =
                     <StorageIdtyCertMeta<T, I>>::mutate_exists(issuer, |cert_meta_opt| {
                         let cert_meta = cert_meta_opt.get_or_insert(IdtyCertMeta::default());

pallets/certification/src/mock.rs

@@ -92,7 +92,7 @@ impl frame_support::traits::EnsureOrigin<(Origin, IdtyIndex, IdtyIndex)> for Ens
 }
 
 parameter_types! {
-    pub const MaxByIssuer: u32 = 3;
+    pub const MaxByIssuer: u32 = 4;
     pub const MinReceivedCertToBeAbleToIssueCert: u32 = 2;
     pub const CertPeriod: u64 = 2;
     pub const ValidityPeriod: u64 = 10;

pallets/certification/src/tests.rs

@@ -26,7 +26,7 @@ use sp_std::collections::btree_map::BTreeMap;
 fn test_must_receive_cert_before_can_issue() {
     new_test_ext(DefaultCertificationConfig {
         apply_cert_period_at_genesis: true,
-        certs_by_issuer: BTreeMap::new(),
+        certs_by_receiver: BTreeMap::new(),
     })
     .execute_with(|| {
         assert_eq!(
@@ -40,15 +40,10 @@ fn test_must_receive_cert_before_can_issue() {
 fn test_cannot_certify_self() {
     new_test_ext(DefaultCertificationConfig {
         apply_cert_period_at_genesis: true,
-        certs_by_issuer: btreemap![
-            1 => btreemap![
-                0 => 5,
-            ],
-            2 => btreemap![
-                0 => 5,
-            ],
-            3 => btreemap![
-                0 => 5,
+        certs_by_receiver: btreemap![
+            0 => btreemap![
+                1 => 5,
+                2 => 5,
             ],
         ],
     })
@@ -66,18 +61,18 @@ fn test_cannot_certify_self() {
 fn test_genesis_build() {
     new_test_ext(DefaultCertificationConfig {
         apply_cert_period_at_genesis: true,
-        certs_by_issuer: btreemap![
+        certs_by_receiver: btreemap![
             0 => btreemap![
-                1 => 10,
-                2 => 5,
+                1 => 7,
+                2 => 9,
             ],
             1 => btreemap![
-                0 => 7,
-                2 => 4,
+                0 => 10,
+                2 => 3,
             ],
             2 => btreemap![
-                0 => 9,
-                1 => 3,
+                0 => 5,
+                1 => 4,
             ],
         ],
     })
@@ -135,25 +130,42 @@ fn test_genesis_build() {
 fn test_cert_period() {
     new_test_ext(DefaultCertificationConfig {
         apply_cert_period_at_genesis: true,
-        certs_by_issuer: btreemap![
-            0 => btreemap![1 => 10],
-            2 => btreemap![0 => 10],
-            3 => btreemap![0 => 10],
+        certs_by_receiver: btreemap![
+            0 => btreemap![
+                1 => 10,
+                2 => 10,
+            ],
+            1 => btreemap![
+                0 => 10,
+                2 => 10,
+            ],
+            2 => btreemap![
+                0 => 10,
+                1 => 10,
+            ],
         ],
     })
     .execute_with(|| {
         assert_eq!(
-            DefaultCertification::add_cert(Origin::signed(0), 2),
+            DefaultCertification::idty_cert_meta(0),
+            crate::IdtyCertMeta {
+                issued_count: 2,
+                next_issuable_on: 2,
+                received_count: 2,
+            }
+        );
+        assert_eq!(
+            DefaultCertification::add_cert(Origin::signed(0), 3),
             Err(Error::<Test, _>::NotRespectCertPeriod.into())
         );
         run_to_block(CertPeriod::get());
-        assert_ok!(DefaultCertification::add_cert(Origin::signed(0), 2));
+        assert_ok!(DefaultCertification::add_cert(Origin::signed(0), 3));
         run_to_block(CertPeriod::get() + 1);
         assert_eq!(
-            DefaultCertification::add_cert(Origin::signed(0), 3),
+            DefaultCertification::add_cert(Origin::signed(0), 4),
             Err(Error::<Test, _>::NotRespectCertPeriod.into())
         );
         run_to_block((2 * CertPeriod::get()) + 1);
-        assert_ok!(DefaultCertification::add_cert(Origin::signed(0), 3));
+        assert_ok!(DefaultCertification::add_cert(Origin::signed(0), 4));
     });
 }

pallets/certification/src/types.rs

@@ -20,11 +20,6 @@ use codec::{Decode, Encode};
 use frame_support::pallet_prelude::*;
 use scale_info::TypeInfo;
 
-#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, TypeInfo)]
-pub struct CertValue<BlockNumber> {
-    pub removable_on: BlockNumber,
-}
-
 #[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, TypeInfo)]
 pub struct IdtyCertMeta<BlockNumber: Default> {
     pub issued_count: u32,

pallets/duniter-wot/src/mock.rs

@@ -270,8 +270,8 @@ pub fn new_test_ext(
     .unwrap();
 
     pallet_certification::GenesisConfig::<Test, Instance1> {
-        certs_by_issuer: clique_wot(initial_identities_len, ValidityPeriod::get()),
         apply_cert_period_at_genesis: true,
+        certs_by_receiver: clique_wot(initial_identities_len, ValidityPeriod::get()),
     }
     .assimilate_storage(&mut t)
     .unwrap();
@@ -292,8 +292,8 @@ pub fn new_test_ext(
     .unwrap();
 
     pallet_certification::GenesisConfig::<Test, Instance2> {
-        certs_by_issuer: clique_wot(initial_smiths_len, SmithsValidityPeriod::get()),
         apply_cert_period_at_genesis: true,
+        certs_by_receiver: clique_wot(initial_smiths_len, SmithsValidityPeriod::get()),
     }
     .assimilate_storage(&mut t)
     .unwrap();

runtime/gdev/tests/common/mod.rs

@@ -231,8 +231,11 @@ impl ExtBuilder {
         .unwrap();
 
         pallet_certification::GenesisConfig::<Runtime, Instance1> {
+            certs_by_receiver: clique_wot(
+                initial_identities.len(),
+                parameters.cert_validity_period,
+            ),
             apply_cert_period_at_genesis: false,
-            certs_by_issuer: clique_wot(initial_identities.len(), parameters.cert_validity_period),
         }
         .assimilate_storage(&mut t)
         .unwrap();
@@ -254,7 +257,7 @@ impl ExtBuilder {
 
         pallet_certification::GenesisConfig::<Runtime, Instance2> {
             apply_cert_period_at_genesis: false,
-            certs_by_issuer: clique_wot(
+            certs_by_receiver: clique_wot(
                 initial_smiths.len(),
                 parameters.smith_cert_validity_period,
             ),