arc

src/recovery_securify_cache/account_recover_scan/derivation_and_analysis_account_recovery_scan.rs

@@ -43,8 +43,9 @@ impl TryFrom<DerivationAndAnalysis> for DerivationAndAnalysisAccountRecoveryScan
     fn try_from(value: DerivationAndAnalysis) -> Result<Self> {
         let factor_sources = value.all_factor_sources();
         let recovered_entities = value
+            .known_taken_instances
             .recovered_unsecurified_entities
-            .merge_with_securified(value.recovered_securified_entities);
+            .merge_with_securified(value.known_taken_instances.recovered_securified_entities);
 
         let recovered_accounts = recovered_entities
             .into_iter()
@@ -54,7 +55,7 @@ impl TryFrom<DerivationAndAnalysis> for DerivationAndAnalysisAccountRecoveryScan
         Ok(Self::new(
             factor_sources,
             recovered_accounts,
-            value.unrecovered_securified_entities,
+            value.known_taken_instances.unrecovered_securified_entities,
             value.probably_free_instances,
         ))
     }

src/recovery_securify_cache/account_recover_scan/derive_and_analyze_account_recovery_scan_input.rs

@@ -23,31 +23,32 @@ impl DeriveAndAnalyzeAccountRecoveryScanInput {
 }
 impl From<DeriveAndAnalyzeAccountRecoveryScanInput> for DeriveAndAnalyzeInput {
     fn from(value: DeriveAndAnalyzeAccountRecoveryScanInput) -> Self {
-        let next_derivation_entity_index_assigner = NextDerivationEntityIndexAssigner::ars();
+        // let next_derivation_entity_index_assigner = NextDerivationEntityIndexAssigner::ars();
 
-        let analyze_factor_instances = IntermediaryDerivationAnalyzer::ars(value.gateway);
+        // let analyze_factor_instances = IntermediaryDerivationAnalyzer::ars(value.gateway);
 
-        Self::new(
-            value.factor_sources.clone(),
-            value
-                .factor_sources
-                .into_iter()
-                .map(|f| f.factor_source_id())
-                .collect(),
-            next_derivation_entity_index_assigner,
-            analyze_factor_instances,
-        )
-    }
-}
-
-impl NextDerivationEntityIndexAssigner {
-    pub fn ars() -> Self {
+        // Self::new(
+        //     value.factor_sources.clone(),
+        //     value
+        //         .factor_sources
+        //         .into_iter()
+        //         .map(|f| f.factor_source_id())
+        //         .collect(),
+        //     next_derivation_entity_index_assigner,
+        //     analyze_factor_instances,
+        // )
         todo!()
     }
 }
 
-impl IntermediaryDerivationAnalyzer {
-    pub fn ars(gateway: Arc<dyn Gateway>) -> Self {
-        todo!()
-    }
-}
+// impl NextDerivationEntityIndexAssigner {
+//     pub fn ars() -> Self {
+//         todo!()
+//     }
+// }
+
+// impl IntermediaryDerivationAnalyzer {
+//     pub fn ars(gateway: Arc<dyn Gateway>) -> Self {
+//         todo!()
+//     }
+// }

src/recovery_securify_cache/derivation_and_analysis/input.rs

@@ -8,35 +8,25 @@ pub struct ProfileNextIndexAnalyzer {}
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct IntermediaryDerivationAnalysis {
-    all_factor_instances: Vec<HierarchicalDeterministicFactorInstance>,
     pub probably_free_instances: ProbablyFreeFactorInstances,
-    pub recovered_unsecurified_entities: RecoveredUnsecurifiedEntities,
-    pub recovered_securified_entities: RecoveredSecurifiedEntities,
-    pub unrecovered_securified_entities: UnrecoveredSecurifiedEntities,
+    pub known_taken: KnownTakenInstances,
 }
+
 impl IntermediaryDerivationAnalysis {
     /// # Panics
     /// 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,
+        known_taken: KnownTakenInstances,
     ) -> Self {
         assert_are_factor_instance_collections_disjoint(vec![
             &probably_free_instances,
-            &recovered_unsecurified_entities,
-            &recovered_securified_entities,
-            &unrecovered_securified_entities,
+            &known_taken,
         ]);
 
         Self {
-            all_factor_instances: all_factor_instances.into_iter().collect(),
             probably_free_instances,
-            recovered_unsecurified_entities,
-            recovered_securified_entities,
-            unrecovered_securified_entities,
+            known_taken,
         }
     }
 }
@@ -60,28 +50,31 @@ pub struct DerivationRequest {
 /// But for VECID - Virtual Entity Creating (Factor)Instance Derivation request:
 /// `DerivationRequest { entity_kind: Account, key_space: Unsecurified, key_kind: TransactionSigning, ... }`
 /// we would use "next free" based on cache or profile analysis.
-pub struct NextDerivationEntityIndexAssigner {
-    start_index: Arc<dyn Fn(DerivationRequest) -> HDPathComponent>,
+#[async_trait::async_trait]
+pub trait IsNextDerivationEntityIndexAssigner {
+    async fn start_index(&self, derivation_request: DerivationRequest) -> Result<HDPathComponent>;
 }
 
 /// Check if there is any known entity associated with a given factor instance,
 /// if so, some base info, if not, it is counted as "probably free".
-pub struct IntermediaryDerivationAnalyzer {
-    analuze: Arc<
-        dyn Fn(IndexSet<HierarchicalDeterministicFactorInstance>) -> IntermediaryDerivationAnalysis,
-    >,
+#[async_trait::async_trait]
+pub trait IsIntermediaryDerivationAnalyzer {
+    async fn analyze(
+        &self,
+        factor_instances: IndexSet<HierarchicalDeterministicFactorInstance>,
+    ) -> Result<IntermediaryDerivationAnalysis>;
 }
 
 pub struct DeriveAndAnalyzeInput {
     factor_sources: IndexSet<HDFactorSource>,
     ids_of_new_factor_sources: IndexSet<FactorSourceIDFromHash>,
 
     /// Which index to start at for the range of indices to derive
-    next_derivation_entity_index_assigner: NextDerivationEntityIndexAssigner,
+    next_derivation_entity_index_assigner: Arc<dyn IsNextDerivationEntityIndexAssigner>,
 
     /// Check if there is any known entity associated with a given factor instance,
     /// if so, some base info, if not, it is counted as "probably free".
-    analyze_factor_instances: IntermediaryDerivationAnalyzer,
+    pub analyze_factor_instances: Arc<dyn IsIntermediaryDerivationAnalyzer>,
 }
 
 impl DeriveAndAnalyzeInput {
@@ -115,8 +108,8 @@ impl DeriveAndAnalyzeInput {
     pub fn new(
         factor_sources: IndexSet<HDFactorSource>,
         ids_of_new_factor_sources: IndexSet<FactorSourceIDFromHash>,
-        next_derivation_entity_index_assigner: NextDerivationEntityIndexAssigner,
-        analyze_factor_instances: IntermediaryDerivationAnalyzer,
+        next_derivation_entity_index_assigner: Arc<dyn IsNextDerivationEntityIndexAssigner>,
+        analyze_factor_instances: Arc<dyn IsIntermediaryDerivationAnalyzer>,
     ) -> Self {
         assert!(
             ids_of_new_factor_sources

src/recovery_securify_cache/derivation_and_analysis/output/derivation_and_analysis.rs

@@ -1,5 +1,79 @@
 use crate::prelude::*;
 
+/// A collection of collections of FactorInstances, all collections are disjoint,
+/// i.e. no FactorInstance is present in more than one collection.
+///
+/// All FactorInstances are known to be not free, i.e. they are taken, meaning
+/// they are already used by some Securified or Unsecurified entity, which we
+/// know by having matched them against Profile or Gateway or both.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct KnownTakenInstances {
+    /// Unsecurified entities that were recovered
+    pub recovered_unsecurified_entities: RecoveredUnsecurifiedEntities,
+
+    /// Securified entities that were recovered
+    pub recovered_securified_entities: RecoveredSecurifiedEntities,
+
+    /// Securified entities that were not recovered
+    pub unrecovered_securified_entities: UnrecoveredSecurifiedEntities,
+
+    pub virtual_entity_creating_instances: VirtualEntityCreatingInstances,
+}
+
+impl IsFactorInstanceCollectionBase for KnownTakenInstances {
+    fn factor_instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
+        let mut set = self.recovered_unsecurified_entities.factor_instances();
+        set.extend(self.recovered_securified_entities.factor_instances());
+        set.extend(self.unrecovered_securified_entities.factor_instances());
+        set.extend(self.virtual_entity_creating_instances.factor_instances());
+        set
+    }
+}
+
+impl HasSampleValues for KnownTakenInstances {
+    fn sample() -> Self {
+        Self::new(
+            RecoveredUnsecurifiedEntities::sample(),
+            RecoveredSecurifiedEntities::sample(),
+            UnrecoveredSecurifiedEntities::sample(),
+            VirtualEntityCreatingInstances::sample(),
+        )
+    }
+
+    fn sample_other() -> Self {
+        Self::new(
+            RecoveredUnsecurifiedEntities::sample_other(),
+            RecoveredSecurifiedEntities::sample_other(),
+            UnrecoveredSecurifiedEntities::sample_other(),
+            VirtualEntityCreatingInstances::sample(),
+        )
+    }
+}
+
+impl KnownTakenInstances {
+    /// # Panics
+    /// Panics if the collections of factor instances are not disjoint
+    pub fn new(
+        recovered_unsecurified_entities: RecoveredUnsecurifiedEntities,
+        recovered_securified_entities: RecoveredSecurifiedEntities,
+        unrecovered_securified_entities: UnrecoveredSecurifiedEntities,
+        virtual_entity_creating_instances: VirtualEntityCreatingInstances,
+    ) -> Self {
+        assert_are_factor_instance_collections_disjoint(vec![
+            &recovered_unsecurified_entities,
+            &recovered_securified_entities,
+            &unrecovered_securified_entities,
+            &virtual_entity_creating_instances,
+        ]);
+        Self {
+            recovered_unsecurified_entities,
+            recovered_securified_entities,
+            unrecovered_securified_entities,
+            virtual_entity_creating_instances,
+        }
+    }
+}
+
 /// The outcome of `derive_and_analyze` method. Contains:
 /// * set of "probably free" FactorInstances
 /// * set of recovered entities in spaces
@@ -24,16 +98,7 @@ pub struct DerivationAndAnalysis {
     /// To be fed into a PreDerivedKeysCache
     pub probably_free_instances: ProbablyFreeFactorInstances,
 
-    /// Unsecurified entities that were recovered
-    pub recovered_unsecurified_entities: RecoveredUnsecurifiedEntities,
-
-    /// Securified entities that were recovered
-    pub recovered_securified_entities: RecoveredSecurifiedEntities,
-
-    /// Securified entities that were not recovered
-    pub unrecovered_securified_entities: UnrecoveredSecurifiedEntities,
-
-    pub virtual_entity_creating_instances: VirtualEntityCreatingInstances,
+    pub known_taken_instances: KnownTakenInstances,
 
     /// Used FactorSources which are not new - might be empty
     old_factor_sources: Vec<HDFactorSource>,
@@ -49,10 +114,7 @@ impl DerivationAndAnalysis {
     /// 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: VirtualEntityCreatingInstances,
+        known_taken_instances: KnownTakenInstances,
         old_factor_sources: IndexSet<HDFactorSource>,
         new_factor_sources: IndexSet<HDFactorSource>,
     ) -> Self {
@@ -65,17 +127,11 @@ impl DerivationAndAnalysis {
         );
         assert_are_factor_instance_collections_disjoint(vec![
             &probably_free_instances,
-            &recovered_unsecurified_entities,
-            &recovered_securified_entities,
-            &unrecovered_securified_entities,
-            &virtual_entity_creating_instances,
+            &known_taken_instances,
         ]);
         Self {
             probably_free_instances,
-            recovered_unsecurified_entities,
-            recovered_securified_entities,
-            unrecovered_securified_entities,
-            virtual_entity_creating_instances,
+            known_taken_instances,
             old_factor_sources: old_factor_sources.into_iter().collect(),
             new_factor_sources: new_factor_sources.into_iter().collect(),
         }
@@ -100,10 +156,7 @@ impl HasSampleValues for DerivationAndAnalysis {
     fn sample() -> Self {
         Self::new(
             ProbablyFreeFactorInstances::sample(),
-            RecoveredUnsecurifiedEntities::sample(),
-            RecoveredSecurifiedEntities::sample(),
-            UnrecoveredSecurifiedEntities::sample(),
-            VirtualEntityCreatingInstances::sample(),
+            KnownTakenInstances::sample(),
             IndexSet::just(HDFactorSource::sample()),
             IndexSet::just(HDFactorSource::sample_other()),
         )
@@ -112,10 +165,7 @@ impl HasSampleValues for DerivationAndAnalysis {
     fn sample_other() -> Self {
         Self::new(
             ProbablyFreeFactorInstances::sample_other(),
-            RecoveredUnsecurifiedEntities::sample_other(),
-            RecoveredSecurifiedEntities::sample_other(),
-            UnrecoveredSecurifiedEntities::sample_other(),
-            VirtualEntityCreatingInstances::sample(),
+            KnownTakenInstances::sample_other(),
             IndexSet::just(HDFactorSource::sample_other()),
             IndexSet::just(HDFactorSource::sample()),
         )

src/recovery_securify_cache/derive_and_analyze.rs

@@ -98,27 +98,13 @@ pub async fn derive_and_analyze(input: DeriveAndAnalyzeInput) -> Result<Derivati
 
     let mut derived_instances = IndexSet::<HierarchicalDeterministicFactorInstance>::new();
 
+    // input.analyze_factor_instances.
+
     // To be fed into cache, NOT done by this function.
     // Might be empty
     let probably_free_instances = ProbablyFreeFactorInstances::sample();
 
-    // Unsecurified entities that were recovered
-    // Might be empty
-    let recovered_unsecurified_entities = RecoveredUnsecurifiedEntities::sample();
-
-    // Securified entities that were recovered
-    // Might be empty
-    let recovered_securified_entities = RecoveredSecurifiedEntities::sample();
-
-    // Securified entities that were not recovered
-    // Might be empty
-    let unrecovered_securified_entities = UnrecoveredSecurifiedEntities::sample();
-
-    // Instances which are not in `recovered_unsecurified_entities`, but which
-    // have been matched against a securified entity in Profile, as their
-    // creating instance.
-    // Might be empty
-    let virtual_entity_creating_instances = VirtualEntityCreatingInstances::sample();
+    let known_taken = KnownTakenInstances::sample();
 
     // Used FactorSources which are not new - might be empty
     let old_factor_sources = input.old_factor_sources();
@@ -128,10 +114,7 @@ pub async fn derive_and_analyze(input: DeriveAndAnalyzeInput) -> Result<Derivati
 
     Ok(DerivationAndAnalysis::new(
         probably_free_instances,
-        recovered_unsecurified_entities,
-        recovered_securified_entities,
-        unrecovered_securified_entities,
-        virtual_entity_creating_instances,
+        known_taken,
         old_factor_sources,
         new_factor_sources,
     ))