diff --git a/node/src/chain_spec/gdev.rs b/node/src/chain_spec/gdev.rs
index c7b13c41a515f38ed716257f5eaa43b175c14ea9..70ff7bc0af7d1694466cac781ac01f77235c1a59 100644
--- a/node/src/chain_spec/gdev.rs
+++ b/node/src/chain_spec/gdev.rs
@@ -371,12 +371,7 @@ fn gen_genesis_conf(
         },
         smiths_collective: Default::default(),
         ud_accounts_storage: UdAccountsStorageConfig {
-            ud_accounts: initial_identities
-                .values()
-                .cloned()
-                .enumerate()
-                .map(|(i, account)| (account, (i + 1) as u32))
-                .collect(),
+            ud_accounts: initial_identities.values().cloned().collect(),
         },
         universal_dividend: UniversalDividendConfig {
             first_reeval: 100,
diff --git a/node/src/chain_spec/gen_genesis_data.rs b/node/src/chain_spec/gen_genesis_data.rs
index bc8d197541d520cd6b7a8c4403a10ea584c51baa..cafbeff1fbc0bcf0b46de04b56a7fe2031e28592 100644
--- a/node/src/chain_spec/gen_genesis_data.rs
+++ b/node/src/chain_spec/gen_genesis_data.rs
@@ -17,7 +17,7 @@
 use common_runtime::*;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use sp_core::{blake2_256, Decode, Encode, H256};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 
 type MembershipData = sp_membership::MembershipData<u32>;
 
@@ -38,7 +38,7 @@ pub struct GenesisData<Parameters: DeserializeOwned, SessionKeys: Decode> {
     pub smiths_certs_by_issuer: BTreeMap<u32, BTreeMap<u32, u32>>,
     pub smiths_memberships: BTreeMap<u32, MembershipData>,
     pub sudo_key: Option<AccountId>,
-    pub ud_accounts: BTreeMap<AccountId, u32>,
+    pub ud_accounts: BTreeSet<AccountId>,
 }
 
 #[derive(Default)]
@@ -150,7 +150,7 @@ where
     let mut initial_monetary_mass = 0;
     let mut memberships = BTreeMap::new();
     //let mut total_dust = 0;
-    let mut ud_accounts = BTreeMap::new();
+    let mut ud_accounts = BTreeSet::new();
 
     // SIMPLE WALLETS //
 
@@ -193,7 +193,7 @@ where
         // We must count the money under the existential deposit because what we count is
         // the monetary mass created (for the revaluation of the DU)
         initial_monetary_mass += identity.balance;
-        ud_accounts.insert(identity.pubkey.clone(), idty_index);
+        ud_accounts.insert(identity.pubkey.clone());
 
         // Wot
         identities_.push((idty_name.clone(), identity.pubkey.clone()));
diff --git a/pallets/ud-accounts-storage/src/lib.rs b/pallets/ud-accounts-storage/src/lib.rs
index b77bfa161164545305980e406f7b325daf90fd70..d73c89fed2e50db5a6d8d60d5085e132fe3ade01 100644
--- a/pallets/ud-accounts-storage/src/lib.rs
+++ b/pallets/ud-accounts-storage/src/lib.rs
@@ -54,20 +54,14 @@ pub mod pallet {
 
     #[pallet::storage]
     #[pallet::getter(fn ud_accounts)]
-    pub type UdAccounts<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, u32, ValueQuery>;
-
-    #[pallet::storage]
-    #[pallet::getter(fn ud_accounts_count)]
-    pub(super) type UdAccountsCounter<T: Config> = StorageValue<_, u64, ValueQuery>;
-
-    #[pallet::storage]
-    pub(super) type ToBeRemoved<T: Config> = StorageValue<_, Vec<u32>, ValueQuery>;
+    pub type UdAccounts<T: Config> =
+        CountedStorageMap<_, Blake2_128Concat, T::AccountId, (), ValueQuery>;
 
     // GENESIS //
 
     #[pallet::genesis_config]
     pub struct GenesisConfig<T: Config> {
-        pub ud_accounts: sp_std::collections::btree_map::BTreeMap<T::AccountId, u32>,
+        pub ud_accounts: sp_std::collections::btree_set::BTreeSet<T::AccountId>,
     }
 
     #[cfg(feature = "std")]
@@ -82,9 +76,8 @@ pub mod pallet {
     #[pallet::genesis_build]
     impl<T: Config> GenesisBuild<T> for GenesisConfig<T> {
         fn build(&self) {
-            <UdAccountsCounter<T>>::put(self.ud_accounts.len() as u64);
-            for (account, index) in &self.ud_accounts {
-                <UdAccounts<T>>::insert(account, index);
+            for account in &self.ud_accounts {
+                <UdAccounts<T>>::insert(account, ());
             }
         }
     }
@@ -92,56 +85,36 @@ pub mod pallet {
     // PUBLIC FUNCTIONS //
 
     impl<T: Config> Pallet<T> {
-        pub fn account_list() -> Vec<T::AccountId> {
-            let mut to_be_removed = ToBeRemoved::<T>::take();
-            to_be_removed.sort_unstable();
-
-            let mut accounts_to_pass = Vec::new();
-            let mut accounts_to_remove = Vec::new();
-            <UdAccounts<T>>::iter().for_each(|(k, v)| {
-                if to_be_removed.binary_search(&v).is_ok() {
-                    accounts_to_remove.push(k);
-                } else {
-                    accounts_to_pass.push(k);
-                }
-            });
-            for account in accounts_to_remove {
-                UdAccounts::<T>::remove(account);
-            }
-
-            accounts_to_pass
+        pub fn accounts_len() -> u32 {
+            <UdAccounts<T>>::count()
+        }
+        pub fn accounts_list() -> Vec<T::AccountId> {
+            <UdAccounts<T>>::iter_keys().collect()
         }
         pub fn replace_account(
             old_account_opt: Option<T::AccountId>,
             new_account_opt: Option<T::AccountId>,
-            index: u32,
         ) -> Weight {
             if let Some(old_account) = old_account_opt {
                 if let Some(new_account) = new_account_opt {
-                    Self::replace_account_inner(old_account, new_account, index)
+                    Self::replace_account_inner(old_account, new_account)
                 } else {
                     Self::del_account(old_account)
                 }
             } else if let Some(new_account) = new_account_opt {
-                Self::add_account(new_account, index)
+                Self::add_account(new_account)
             } else {
                 0
             }
         }
-        pub fn remove_account(account_index: u32) -> Weight {
-            ToBeRemoved::<T>::append(account_index);
-            UdAccountsCounter::<T>::mutate(|counter| counter.saturating_sub(1));
-            0
+        pub fn remove_account(account_id: T::AccountId) -> Weight {
+            Self::del_account(account_id)
         }
-        fn replace_account_inner(
-            old_account: T::AccountId,
-            new_account: T::AccountId,
-            index: u32,
-        ) -> Weight {
+        fn replace_account_inner(old_account: T::AccountId, new_account: T::AccountId) -> Weight {
             if <UdAccounts<T>>::contains_key(&old_account) {
                 if !<UdAccounts<T>>::contains_key(&new_account) {
                     <UdAccounts<T>>::remove(&old_account);
-                    <UdAccounts<T>>::insert(&new_account, index);
+                    <UdAccounts<T>>::insert(&new_account, ());
                 } else {
                     frame_support::runtime_print!(
                         "ERROR: replace_account(): new_account {:?} already added",
@@ -156,10 +129,9 @@ pub mod pallet {
             }
             0
         }
-        fn add_account(account: T::AccountId, index: u32) -> Weight {
+        fn add_account(account: T::AccountId) -> Weight {
             if !<UdAccounts<T>>::contains_key(&account) {
-                <UdAccounts<T>>::insert(&account, index);
-                UdAccountsCounter::<T>::mutate(|counter| counter.saturating_add(1));
+                <UdAccounts<T>>::insert(&account, ());
             } else {
                 frame_support::runtime_print!(
                     "ERROR: add_account(): account {:?} already added",
@@ -171,8 +143,6 @@ pub mod pallet {
         fn del_account(account: T::AccountId) -> Weight {
             if <UdAccounts<T>>::contains_key(&account) {
                 <UdAccounts<T>>::remove(&account);
-
-                UdAccountsCounter::<T>::mutate(|counter| counter.saturating_sub(1));
             } else {
                 frame_support::runtime_print!(
                     "ERROR: del_account(): account {:?} already deleted",
diff --git a/resources/metadata.scale b/resources/metadata.scale
index 9979acdb707305a49c4e2f8f5c915e82ef4909be..c25033d3bdc88f3b6ce6aa68aaeaec2ca87e2536 100644
Binary files a/resources/metadata.scale and b/resources/metadata.scale differ
diff --git a/runtime/common/src/handlers.rs b/runtime/common/src/handlers.rs
index 5e35e81701e6d0b4ad0dd71dc2f2f9900022f03d..b9731cd6b40651da8f21282c19ed32c029803a2b 100644
--- a/runtime/common/src/handlers.rs
+++ b/runtime/common/src/handlers.rs
@@ -20,7 +20,7 @@ use frame_support::dispatch::UnfilteredDispatchable;
 use frame_support::instances::{Instance1, Instance2};
 use frame_support::pallet_prelude::Weight;
 use frame_support::Parameter;
-use sp_runtime::traits::IsMember;
+use sp_runtime::traits::{Convert, IsMember};
 
 pub struct OnNewSessionHandler<Runtime>(core::marker::PhantomData<Runtime>);
 impl<Runtime> pallet_authority_members::traits::OnNewSession for OnNewSessionHandler<Runtime>
@@ -48,15 +48,20 @@ impl<
 {
     fn on_event(membership_event: &sp_membership::Event<IdtyIndex, MembershipMetaData>) -> Weight {
         (match membership_event {
-            sp_membership::Event::MembershipAcquired(idty_index, owner_key) => {
+            sp_membership::Event::MembershipAcquired(_idty_index, owner_key) => {
                 pallet_ud_accounts_storage::Pallet::<Runtime>::replace_account(
                     None,
                     Some(owner_key.0.clone()),
-                    *idty_index,
                 )
             }
             sp_membership::Event::MembershipRevoked(idty_index) => {
-                pallet_ud_accounts_storage::Pallet::<Runtime>::remove_account(*idty_index)
+                if let Some(account_id) =
+                    crate::providers::IdentityAccountIdProvider::<Runtime>::convert(*idty_index)
+                {
+                    pallet_ud_accounts_storage::Pallet::<Runtime>::remove_account(account_id)
+                } else {
+                    0
+                }
             }
             _ => 0,
         }) + Inner::on_event(membership_event)
diff --git a/runtime/common/src/providers.rs b/runtime/common/src/providers.rs
index 1f49810e9455fefa28402692790c9259812d7f49..5c87d977327cb23e13645c6335694fe646c23dfd 100644
--- a/runtime/common/src/providers.rs
+++ b/runtime/common/src/providers.rs
@@ -14,20 +14,33 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with Substrate-Libre-Currency. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::AccountId;
+use crate::{AccountId, IdtyIndex};
 use frame_support::traits::Get;
 use sp_std::vec::Vec;
 
+pub struct IdentityAccountIdProvider<Runtime>(core::marker::PhantomData<Runtime>);
+
+impl<
+        Runtime: frame_system::Config<AccountId = AccountId>
+            + pallet_identity::Config<IdtyIndex = IdtyIndex>,
+    > sp_runtime::traits::Convert<IdtyIndex, Option<AccountId>>
+    for IdentityAccountIdProvider<Runtime>
+{
+    fn convert(idty_index: IdtyIndex) -> Option<AccountId> {
+        pallet_identity::Pallet::<Runtime>::identity(idty_index).map(|idty| idty.owner_key)
+    }
+}
+
 pub struct UdAccountsProvider<Runtime>(core::marker::PhantomData<Runtime>);
 impl<Runtime: pallet_ud_accounts_storage::Config> Get<u64> for UdAccountsProvider<Runtime> {
     fn get() -> u64 {
-        <pallet_ud_accounts_storage::Pallet<Runtime>>::ud_accounts_count()
+        <pallet_ud_accounts_storage::Pallet<Runtime>>::accounts_len() as u64
     }
 }
 impl<Runtime: frame_system::Config<AccountId = AccountId> + pallet_ud_accounts_storage::Config>
     Get<Vec<AccountId>> for UdAccountsProvider<Runtime>
 {
     fn get() -> Vec<AccountId> {
-        <pallet_ud_accounts_storage::Pallet<Runtime>>::account_list()
+        <pallet_ud_accounts_storage::Pallet<Runtime>>::accounts_list()
     }
 }
diff --git a/runtime/gdev/tests/common/mod.rs b/runtime/gdev/tests/common/mod.rs
index 9bf3075898aa4b77cc64b37425d197d374715747..f17c23b4c1d7b37e6b61379ea9df133da4cd817a 100644
--- a/runtime/gdev/tests/common/mod.rs
+++ b/runtime/gdev/tests/common/mod.rs
@@ -267,12 +267,7 @@ impl ExtBuilder {
         .unwrap();
 
         pallet_ud_accounts_storage::GenesisConfig::<Runtime> {
-            ud_accounts: initial_identities
-                .values()
-                .cloned()
-                .enumerate()
-                .map(|(i, account)| (account, (i + 1) as u32))
-                .collect(),
+            ud_accounts: initial_identities.values().cloned().collect(),
         }
         .assimilate_storage(&mut t)
         .unwrap();