adding VirtualEntityCreatingInstances

src/recovery_securify_cache/derivation_and_analysis/input.rs

@@ -16,41 +16,20 @@ pub struct IntermediaryDerivationAnalysis {
 }
 impl IntermediaryDerivationAnalysis {
     /// # Panics
-    /// Panics if the union all instances from:
-    /// `probably_free_instances`, `recovered_unsecurified_entities`, `recovered_securified_entities`, `unrecovered_securified_entities` are not equal to `all_factor_instances`
-    /// Also panics if any factor_instance in:
-    /// `recovered_unsecurified_entities`, `recovered_securified_entities`, `unrecovered_securified_entities` is found in probably_free_instances
+    /// Panics if the collections of factor instances are not disjoint
     pub fn new(
         all_factor_instances: IndexSet<HierarchicalDeterministicFactorInstance>,
         probably_free_instances: ProbablyFreeFactorInstances,
         recovered_unsecurified_entities: RecoveredUnsecurifiedEntities,
         recovered_securified_entities: RecoveredSecurifiedEntities,
         unrecovered_securified_entities: UnrecoveredSecurifiedEntities,
     ) -> Self {
-        let mut merge = IndexSet::new();
-        merge.extend(recovered_unsecurified_entities.instances());
-        merge.extend(recovered_securified_entities.instances());
-        merge.extend(unrecovered_securified_entities.instances());
-
-        assert!(
-            merge.clone().into_iter().collect::<HashSet<_>>()
-            .intersection(
-                &probably_free_instances.instances().into_iter().collect::<HashSet<_>>()
-            )
-            .collect_vec()
-            .is_empty(),
-            "Discrepancy! Some factor instances in probably_free_instances are found in other collections of non free instances!");
-
-        // Only extend with `probably_free_instances` once we have verified it does not contain any of the instances in the other collections
-        merge.extend(probably_free_instances.instances());
-
-        assert_eq!(
-            merge.into_iter().collect::<HashSet<_>>(),
-            all_factor_instances
-                .clone()
-                .into_iter()
-                .collect::<HashSet<_>>()
-        );
+        assert_are_factor_instance_collections_disjoint(vec![
+            &probably_free_instances,
+            &recovered_unsecurified_entities,
+            &recovered_securified_entities,
+            &unrecovered_securified_entities,
+        ]);
 
         Self {
             all_factor_instances: all_factor_instances.into_iter().collect(),

src/recovery_securify_cache/derivation_and_analysis/output/derivation_and_analysis.rs

@@ -33,7 +33,7 @@ pub struct DerivationAndAnalysis {
     /// Securified entities that were not recovered
     pub unrecovered_securified_entities: UnrecoveredSecurifiedEntities,
 
-    virtual_entity_creating_instances: Vec<HierarchicalDeterministicFactorInstance>,
+    pub virtual_entity_creating_instances: VirtualEntityCreatingInstances,
 
     /// Used FactorSources which are not new - might be empty
     old_factor_sources: Vec<HDFactorSource>,
@@ -45,12 +45,14 @@ pub struct DerivationAndAnalysis {
 impl DerivationAndAnalysis {
     /// # Panics
     /// Panics if `old_factor_sources` intersects with `new_factor_sources`
+    ///
+    /// Panics if the collections of factor instances are not disjoint
     pub fn new(
         probably_free_instances: ProbablyFreeFactorInstances,
         recovered_unsecurified_entities: RecoveredUnsecurifiedEntities,
         recovered_securified_entities: RecoveredSecurifiedEntities,
         unrecovered_securified_entities: UnrecoveredSecurifiedEntities,
-        virtual_entity_creating_instances: IndexSet<HierarchicalDeterministicFactorInstance>,
+        virtual_entity_creating_instances: VirtualEntityCreatingInstances,
         old_factor_sources: IndexSet<HDFactorSource>,
         new_factor_sources: IndexSet<HDFactorSource>,
     ) -> Self {
@@ -61,28 +63,24 @@ impl DerivationAndAnalysis {
                 .is_empty(),
             "Discrepancy! FactorSource found in old an new, this is a programmer error!"
         );
+        assert_are_factor_instance_collections_disjoint(vec![
+            &probably_free_instances,
+            &recovered_unsecurified_entities,
+            &recovered_securified_entities,
+            &unrecovered_securified_entities,
+            &virtual_entity_creating_instances,
+        ]);
         Self {
             probably_free_instances,
             recovered_unsecurified_entities,
             recovered_securified_entities,
             unrecovered_securified_entities,
-            virtual_entity_creating_instances: virtual_entity_creating_instances
-                .into_iter()
-                .collect(),
+            virtual_entity_creating_instances,
             old_factor_sources: old_factor_sources.into_iter().collect(),
             new_factor_sources: new_factor_sources.into_iter().collect(),
         }
     }
 
-    pub fn virtual_entity_creating_instances(
-        &self,
-    ) -> IndexSet<HierarchicalDeterministicFactorInstance> {
-        self.virtual_entity_creating_instances
-            .clone()
-            .into_iter()
-            .collect()
-    }
-
     pub fn new_factor_sources(&self) -> IndexSet<HDFactorSource> {
         self.new_factor_sources.clone().into_iter().collect()
     }
@@ -105,10 +103,7 @@ impl HasSampleValues for DerivationAndAnalysis {
             RecoveredUnsecurifiedEntities::sample(),
             RecoveredSecurifiedEntities::sample(),
             UnrecoveredSecurifiedEntities::sample(),
-            IndexSet::from_iter([
-                HierarchicalDeterministicFactorInstance::sample(),
-                HierarchicalDeterministicFactorInstance::sample_other(),
-            ]),
+            VirtualEntityCreatingInstances::sample(),
             IndexSet::just(HDFactorSource::sample()),
             IndexSet::just(HDFactorSource::sample_other()),
         )
@@ -120,7 +115,7 @@ impl HasSampleValues for DerivationAndAnalysis {
             RecoveredUnsecurifiedEntities::sample_other(),
             RecoveredSecurifiedEntities::sample_other(),
             UnrecoveredSecurifiedEntities::sample_other(),
-            IndexSet::just(HierarchicalDeterministicFactorInstance::sample_other()),
+            VirtualEntityCreatingInstances::sample(),
             IndexSet::just(HDFactorSource::sample_other()),
             IndexSet::just(HDFactorSource::sample()),
         )

src/recovery_securify_cache/derivation_and_analysis/output/mod.rs

@@ -6,6 +6,7 @@ mod securified_entity;
 mod unrecovered_securified_entities;
 mod unrecovered_securified_entity;
 mod unsecurified_entity;
+mod virtual_entity_creating_instances;
 
 pub use derivation_and_analysis::*;
 pub use probably_free_factor_instances::*;
@@ -15,3 +16,4 @@ pub use securified_entity::*;
 pub use unrecovered_securified_entities::*;
 pub use unrecovered_securified_entity::*;
 pub use unsecurified_entity::*;
+pub use virtual_entity_creating_instances::*;

src/recovery_securify_cache/derivation_and_analysis/output/probably_free_factor_instances.rs

@@ -1,5 +1,46 @@
 use crate::prelude::*;
 
+pub trait IsFactorInstanceCollectionBase {
+    fn factor_instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance>;
+}
+pub trait IsFactorInstanceCollection:
+    IsFactorInstanceCollectionBase + HasSampleValues + Sized
+{
+    fn new(instances: IndexSet<HierarchicalDeterministicFactorInstance>) -> Self;
+
+    fn merge<T: IsFactorInstanceCollection>(&self, other: T) -> Self {
+        Self::new(
+            self.factor_instances()
+                .union(&other.factor_instances())
+                .cloned()
+                .collect(),
+        )
+    }
+}
+
+pub fn are_factor_instance_collections_disjoint(
+    collections: Vec<&dyn IsFactorInstanceCollectionBase>,
+) -> bool {
+    let mut all_instances = IndexSet::new();
+    for collection in collections {
+        let instances = collection.factor_instances();
+        if !instances.is_disjoint(&all_instances) {
+            return false;
+        }
+        all_instances.extend(instances);
+    }
+    true
+}
+
+pub fn assert_are_factor_instance_collections_disjoint(
+    collections: Vec<&dyn IsFactorInstanceCollectionBase>,
+) {
+    assert!(
+        are_factor_instance_collections_disjoint(collections),
+        "Discrepancy! FactorInstance found in multiple collections, this is a programmer error!"
+    );
+}
+
 /// "Probably" since we might not have all the information to be sure, since
 /// Gateway might not keep track of past FactorInstances, some of the FactorInstances
 /// in KeySpace::Securified might in fact have been used in the past for some entity.
@@ -8,23 +49,17 @@ pub struct ProbablyFreeFactorInstances {
     factor_instances: Vec<HierarchicalDeterministicFactorInstance>,
 }
 
-impl ProbablyFreeFactorInstances {
-    pub fn new(instances: IndexSet<HierarchicalDeterministicFactorInstance>) -> Self {
+impl IsFactorInstanceCollectionBase for ProbablyFreeFactorInstances {
+    fn factor_instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
+        self.factor_instances.iter().cloned().collect()
+    }
+}
+impl IsFactorInstanceCollection for ProbablyFreeFactorInstances {
+    fn new(instances: IndexSet<HierarchicalDeterministicFactorInstance>) -> Self {
         Self {
             factor_instances: instances.into_iter().collect(),
         }
     }
-    pub fn merge(&self, other: &Self) -> Self {
-        Self::new(
-            self.instances()
-                .union(&other.instances())
-                .cloned()
-                .collect(),
-        )
-    }
-    pub fn instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
-        self.factor_instances.iter().cloned().collect()
-    }
 }
 
 impl HasSampleValues for ProbablyFreeFactorInstances {

src/recovery_securify_cache/derivation_and_analysis/output/recovered_securified_entities.rs

@@ -24,8 +24,10 @@ impl RecoveredSecurifiedEntities {
             .map(AccountOrPersona::from)
             .collect()
     }
+}
 
-    pub fn instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
+impl IsFactorInstanceCollectionBase for RecoveredSecurifiedEntities {
+    fn factor_instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
         self.securified_entities()
             .into_iter()
             .flat_map(|x| x.securified_entity_control().all_factor_instances())

src/recovery_securify_cache/derivation_and_analysis/output/recovered_unsecurified_entities.rs

@@ -24,11 +24,13 @@ impl RecoveredUnsecurifiedEntities {
             .map(AccountOrPersona::from)
             .collect()
     }
+}
 
-    pub fn instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
+impl IsFactorInstanceCollectionBase for RecoveredUnsecurifiedEntities {
+    fn factor_instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
         self.unsecurified_entities()
             .into_iter()
-            .map(|x| x.veci())
+            .map(|x| x.factor_instance())
             .collect()
     }
 }

src/recovery_securify_cache/derivation_and_analysis/output/unrecovered_securified_entities.rs

@@ -20,8 +20,10 @@ impl UnrecoveredSecurifiedEntities {
     pub fn entities(&self) -> IndexSet<UnrecoveredSecurifiedEntity> {
         self.entities.clone().into_iter().collect()
     }
+}
 
-    pub fn instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
+impl IsFactorInstanceCollectionBase for UnrecoveredSecurifiedEntities {
+    fn factor_instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
         self.entities()
             .into_iter()
             .flat_map(|x| x.matched_factor_instances())

src/recovery_securify_cache/derivation_and_analysis/output/unsecurified_entity.rs

@@ -1,14 +1,12 @@
+use std::vec;
+
 use crate::prelude::*;
 
 /// The HDFactorInstance, address and possibly third party deposit state of some
 /// unsecurified entity.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct UnsecurifiedEntity {
-    /// The address which is verified to match the `veci`
-    address: AddressOfAccountOrPersona,
-
-    /// Virtual Entity Creating (Factor)Instance
-    veci: HierarchicalDeterministicFactorInstance,
+    veci: VirtualEntityCreatingInstance,
 
     /// If we found this UnsecurifiedEntity while scanning OnChain using
     /// Gateway, we might have been able to read out the third party deposit
@@ -17,50 +15,36 @@ pub struct UnsecurifiedEntity {
 }
 
 impl UnsecurifiedEntity {
-    /// # Panics
-    /// Panics if address does not match `veci`
-    pub fn new(
-        address: AddressOfAccountOrPersona,
-        veci: HierarchicalDeterministicFactorInstance,
+    pub fn with_veci(
+        veci: VirtualEntityCreatingInstance,
         third_party_deposit: impl Into<Option<ThirdPartyDepositPreference>>,
     ) -> Self {
-        assert!(
-            address.derived_from_factor_instance(&veci),
-            "Discrepancy, mismatching public keys, this is a programmer error!"
-        );
         Self {
-            address,
             veci,
             third_party_deposit: third_party_deposit.into(),
         }
     }
 
-    fn with_veci_on_network(
-        veci: HierarchicalDeterministicFactorInstance,
-        entity_kind: CAP26EntityKind,
-        network_id: NetworkID,
+    /// # Panics
+    /// Panics if address does not match `factor_instance`
+    pub fn new(
+        address: AddressOfAccountOrPersona,
+        factor_instance: HierarchicalDeterministicFactorInstance,
+        third_party_deposit: impl Into<Option<ThirdPartyDepositPreference>>,
     ) -> Self {
-        let public_key_hash = veci.public_key_hash();
-        let address = match entity_kind {
-            CAP26EntityKind::Account => {
-                AddressOfAccountOrPersona::from(AccountAddress::new(network_id, public_key_hash))
-            }
-            CAP26EntityKind::Identity => {
-                AddressOfAccountOrPersona::from(IdentityAddress::new(network_id, public_key_hash))
-            }
-        };
-        Self {
-            address,
-            veci,
-            third_party_deposit: None,
-        }
+        let veci = VirtualEntityCreatingInstance::new(factor_instance, address);
+        Self::with_veci(veci, third_party_deposit)
     }
 
     pub fn address(&self) -> AddressOfAccountOrPersona {
-        self.address.clone()
+        self.veci.clone().address()
+    }
+
+    pub fn factor_instance(&self) -> HierarchicalDeterministicFactorInstance {
+        self.veci.factor_instance()
     }
 
-    pub fn veci(&self) -> HierarchicalDeterministicFactorInstance {
+    pub fn veci(&self) -> VirtualEntityCreatingInstance {
         self.veci.clone()
     }
 
@@ -73,7 +57,7 @@ impl From<UnsecurifiedEntity> for AccountOrPersona {
     fn from(value: UnsecurifiedEntity) -> Self {
         let address = value.address();
         let name = "Recovered";
-        let security_state = EntitySecurityState::Unsecured(value.veci());
+        let security_state = EntitySecurityState::Unsecured(value.factor_instance());
 
         if let Ok(account_address) = address.clone().into_account() {
             Account::new(name, account_address, security_state).into()
@@ -87,17 +71,15 @@ impl From<UnsecurifiedEntity> for AccountOrPersona {
 
 impl HasSampleValues for UnsecurifiedEntity {
     fn sample() -> Self {
-        Self::with_veci_on_network(
-            HierarchicalDeterministicFactorInstance::sample(),
-            CAP26EntityKind::Account,
-            NetworkID::Mainnet,
+        Self::with_veci(
+            VirtualEntityCreatingInstance::sample(),
+            ThirdPartyDepositPreference::sample(),
         )
     }
     fn sample_other() -> Self {
-        Self::with_veci_on_network(
-            HierarchicalDeterministicFactorInstance::sample_other(),
-            CAP26EntityKind::Identity,
-            NetworkID::Stokenet,
+        Self::with_veci(
+            VirtualEntityCreatingInstance::sample_other(),
+            ThirdPartyDepositPreference::sample_other(),
         )
     }
 }