IntoIter and FroIter

src/derivation/collector/key_derivation_outcome.rs

@@ -24,7 +24,7 @@ impl KeyDerivationOutcome {
     }
 
     /// ALL factor instances derived by the KeysCollector
-    pub fn all_factors(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
+    pub fn all_factors(&self) -> FactorInstances {
         self.factors_by_source
             .clone()
             .into_iter()

src/derivation/tests/derivation_tests.rs

@@ -49,7 +49,7 @@ mod key_derivation_tests {
         )
         .unwrap();
         let outcome = collector.collect_keys().await;
-        assert!(outcome.all_factors().is_empty())
+        assert!(outcome.all_factors().factor_instances().is_empty())
     }
 
     mod multi_key {
@@ -378,7 +378,7 @@ mod key_derivation_tests {
                 paths
             );
 
-            assert!(outcome.all_factors().len() > 200);
+            assert!(outcome.all_factors().factor_instances().len() > 200);
 
             assert_eq!(
                 outcome
@@ -413,7 +413,7 @@ mod key_derivation_tests {
                 KeysCollector::with(factor_source, network_id, key_kind, entity_kind, key_space);
 
             let outcome = collector.collect_keys().await;
-            let factors = outcome.all_factors();
+            let factors = outcome.all_factors().factor_instances();
             assert_eq!(factors.len(), 1);
             let factor = factors.first().unwrap();
             assert_eq!(

src/recovery_securify_cache/account_recover_scan/account_recovery_scanning.rs

@@ -8,16 +8,42 @@ async fn _account_recovery_scan(
     DerivationAndAnalysisAccountRecoveryScan::try_from(analysis)
 }
 
-pub async fn account_recovery_scan(
+pub async fn onboarding_account_recovery_scan(
     factor_sources: IndexSet<HDFactorSource>,
     gateway: Arc<dyn Gateway>,
     derivation_interactors: Arc<dyn KeysDerivationInteractors>,
+    is_done_query: Arc<dyn IsDerivationDoneQuery>,
 ) -> Result<AccountRecoveryScanOutcome> {
-    let analysis = _account_recovery_scan(DeriveAndAnalyzeAccountRecoveryScanInput::new(
-        factor_sources,
-        gateway,
-        derivation_interactors,
-    ))
+    let analysis = _account_recovery_scan(
+        DeriveAndAnalyzeAccountRecoveryScanInput::onboarding_account_recovery_scan(
+            factor_sources,
+            gateway,
+            derivation_interactors,
+            is_done_query,
+        ),
+    )
+    .await?;
+    Ok(AccountRecoveryScanOutcome::from(analysis))
+}
+
+pub async fn manual_account_recovery_scan(
+    factor_sources: IndexSet<HDFactorSource>,
+    gateway: Arc<dyn Gateway>,
+    cache: impl Into<Option<PreDerivedKeysCache>>,
+    profile: ProfileAnalyzer,
+    derivation_interactors: Arc<dyn KeysDerivationInteractors>,
+    is_done_query: Arc<dyn IsDerivationDoneQuery>,
+) -> Result<AccountRecoveryScanOutcome> {
+    let analysis = _account_recovery_scan(
+        DeriveAndAnalyzeAccountRecoveryScanInput::manual_account_recovery_scan(
+            factor_sources,
+            gateway,
+            cache,
+            profile,
+            derivation_interactors,
+            is_done_query,
+        ),
+    )
     .await?;
     Ok(AccountRecoveryScanOutcome::from(analysis))
 }

src/recovery_securify_cache/account_recover_scan/derive_and_analyze_account_recovery_scan_input.rs

@@ -1,26 +1,143 @@
 #![allow(unused)]
 #![allow(unused_variables)]
 
-use crate::prelude::*;
+use crate::{gateway, prelude::*};
 
+/// Use by OARS (Onboarding Account Recovery Scan) and MARS
+/// (Manual Account Recovery Scan).
 pub struct DeriveAndAnalyzeAccountRecoveryScanInput {
     factor_sources: IndexSet<HDFactorSource>,
     gateway: Arc<dyn Gateway>,
+
+    /// Empty for OARS, **maybe** not empty for MARS
+    cache: PreDerivedKeysCache,
+    /// Empty for OARS, **guaranteed** not empty for MARS
+    profile: ProfileAnalyzer,
+
     derivation_interactors: Arc<dyn KeysDerivationInteractors>,
+    is_done_query: Arc<dyn IsDerivationDoneQuery>,
 }
 
 impl DeriveAndAnalyzeAccountRecoveryScanInput {
-    pub fn new(
+    fn new(
         factor_sources: IndexSet<HDFactorSource>,
         gateway: Arc<dyn Gateway>,
+        cache: impl Into<Option<PreDerivedKeysCache>>,
+        profile: impl Into<Option<ProfileAnalyzer>>,
         derivation_interactors: Arc<dyn KeysDerivationInteractors>,
+        is_done_query: Arc<dyn IsDerivationDoneQuery>,
     ) -> Self {
         Self {
             factor_sources,
             gateway,
+            cache: cache.into().unwrap_or_default(),
+            profile: profile.into().unwrap_or_default(),
+            derivation_interactors,
+            is_done_query,
+        }
+    }
+
+    /// OARS
+    pub fn onboarding_account_recovery_scan(
+        factor_sources: IndexSet<HDFactorSource>,
+        gateway: Arc<dyn Gateway>,
+        derivation_interactors: Arc<dyn KeysDerivationInteractors>,
+        is_done_query: Arc<dyn IsDerivationDoneQuery>,
+    ) -> Self {
+        Self::new(
+            factor_sources,
+            gateway,
+            None,
+            None,
             derivation_interactors,
+            is_done_query,
+        )
+    }
+
+    /// MARS
+    pub fn manual_account_recovery_scan(
+        factor_sources: IndexSet<HDFactorSource>,
+        gateway: Arc<dyn Gateway>,
+        cache: impl Into<Option<PreDerivedKeysCache>>,
+        profile: ProfileAnalyzer,
+        derivation_interactors: Arc<dyn KeysDerivationInteractors>,
+        is_done_query: Arc<dyn IsDerivationDoneQuery>,
+    ) -> Self {
+        Self::new(
+            factor_sources,
+            gateway,
+            cache,
+            profile,
+            derivation_interactors,
+            is_done_query,
+        )
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct ProfileAnalyzer;
+
+pub struct FactorInstancesProviderImpl {
+    cache: PreDerivedKeysCache,
+    gateway: Option<Arc<dyn Gateway>>,
+    profile: ProfileAnalyzer,
+}
+impl FactorInstancesProviderImpl {
+    /// # Panics
+    /// Panics if all arguments are `None`.
+    fn new(
+        cache: impl Into<Option<PreDerivedKeysCache>>,
+        gateway: impl Into<Option<Arc<dyn Gateway>>>,
+        profile: impl Into<Option<ProfileAnalyzer>>,
+    ) -> Self {
+        let cache = cache.into();
+        let gateway = gateway.into();
+        let profile = profile.into();
+        assert!(
+            !(cache.is_none() && gateway.is_none() && profile.is_none()),
+            "All arguments are None"
+        );
+        Self {
+            cache: cache.unwrap_or_default(),
+            gateway,
+            profile: profile.unwrap_or_default(),
         }
     }
+
+    /// OARS
+    pub fn onboarding_account_recovery_scan(gateway: Arc<dyn Gateway>) -> Self {
+        Self::new(None, gateway, None)
+    }
+
+    /// MARS
+    pub fn manual_account_recovery_scan(
+        cache: impl Into<Option<PreDerivedKeysCache>>,
+        gateway: Arc<dyn Gateway>,
+        profile: ProfileAnalyzer,
+    ) -> Self {
+        Self::new(cache, gateway, profile)
+    }
+}
+
+#[async_trait::async_trait]
+impl IsFactorInstancesProvider for FactorInstancesProviderImpl {
+    async fn provide_instances(
+        &self,
+        derivation_requests: DerivationRequests,
+    ) -> Result<FactorInstances> {
+        let cache_outcome = self.cache.load(&derivation_requests).await?;
+        todo!();
+    }
+}
+
+#[async_trait::async_trait]
+impl IsIntermediaryDerivationAnalyzer for FactorInstancesProviderImpl {
+    async fn analyze(
+        &self,
+        factor_instances: FactorInstances,
+    ) -> Result<IntermediaryDerivationAnalysis> {
+        todo!()
+    }
 }
 
 impl From<DeriveAndAnalyzeAccountRecoveryScanInput> for DeriveAndAnalyzeInput {
@@ -44,12 +161,13 @@ impl From<DeriveAndAnalyzeAccountRecoveryScanInput> for DeriveAndAnalyzeInput {
                     .into_iter()
                     .map(move |u| u.derivation_request_with_factor_source_id(factor_source_id))
             })
-            .collect::<IndexSet<_>>();
+            .collect::<DerivationRequests>();
 
-        let factor_instances_provider: Arc<dyn IsFactorInstancesProvider> = { unreachable!() };
-        let analyze_factor_instances: Arc<dyn IsIntermediaryDerivationAnalyzer> =
-            { unreachable!() };
-        let is_done: Arc<dyn IsDerivationDoneQuery> = { unreachable!() };
+        let analyzing_factor_instance_provider = Arc::new(FactorInstancesProviderImpl::new(
+            value.cache,
+            value.gateway,
+            value.profile,
+        ));
 
         Self::new(
             value.factor_sources.clone(),
@@ -59,9 +177,9 @@ impl From<DeriveAndAnalyzeAccountRecoveryScanInput> for DeriveAndAnalyzeInput {
                 .map(|f| f.factor_source_id())
                 .collect(),
             initial_derivation_requests,
-            factor_instances_provider,
-            analyze_factor_instances,
-            is_done,
+            analyzing_factor_instance_provider.clone(),
+            analyzing_factor_instance_provider.clone(),
+            value.is_done_query,
         )
     }
 }
@@ -76,7 +194,7 @@ pub struct UncachedFactorInstanceProvider {
 impl UncachedFactorInstanceProvider {
     fn derivation_paths_for_requests(
         &self,
-        derivation_requests: IndexSet<DerivationRequest>,
+        derivation_requests: DerivationRequests,
     ) -> IndexMap<FactorSourceIDFromHash, IndexSet<DerivationPath>> {
         todo!()
     }
@@ -86,8 +204,8 @@ impl UncachedFactorInstanceProvider {
 impl IsFactorInstancesProvider for UncachedFactorInstanceProvider {
     async fn provide_instances(
         &self,
-        derivation_requests: IndexSet<DerivationRequest>,
-    ) -> Result<IndexSet<HierarchicalDeterministicFactorInstance>> {
+        derivation_requests: DerivationRequests,
+    ) -> Result<FactorInstances> {
         let derivation_paths = self.derivation_paths_for_requests(derivation_requests);
         let keys_collector = KeysCollector::new(
             self.factor_sources.clone(),

src/recovery_securify_cache/derivation_and_analysis/input.rs

@@ -11,7 +11,7 @@ pub struct DeriveAndAnalyzeInput {
     factor_sources: IndexSet<HDFactorSource>,
     ids_of_new_factor_sources: IndexSet<FactorSourceIDFromHash>,
 
-    next_requests: IndexSet<DerivationRequest>,
+    next_requests: DerivationRequests,
 
     factor_instances_provider: Arc<dyn IsFactorInstancesProvider>,
 
@@ -27,7 +27,7 @@ impl DeriveAndAnalyzeInput {
     pub fn new(
         factor_sources: IndexSet<HDFactorSource>,
         ids_of_new_factor_sources: IndexSet<FactorSourceIDFromHash>,
-        initial_derivation_requests: IndexSet<DerivationRequest>,
+        initial_derivation_requests: DerivationRequests,
         factor_instances_provider: Arc<dyn IsFactorInstancesProvider>,
         analyze_factor_instances: Arc<dyn IsIntermediaryDerivationAnalyzer>,
         is_done: Arc<dyn IsDerivationDoneQuery>,
@@ -54,7 +54,7 @@ impl DeriveAndAnalyzeInput {
 impl IsIntermediaryDerivationAnalyzer for DeriveAndAnalyzeInput {
     async fn analyze(
         &self,
-        factor_instances: IndexSet<HierarchicalDeterministicFactorInstance>,
+        factor_instances: FactorInstances,
     ) -> Result<IntermediaryDerivationAnalysis> {
         self.analyze_factor_instances
             .analyze(factor_instances)
@@ -70,13 +70,11 @@ impl IsDerivationDoneQuery for DeriveAndAnalyzeInput {
 }
 
 impl DeriveAndAnalyzeInput {
-    fn next_requests(&self) -> IndexSet<DerivationRequest> {
+    fn next_requests(&self) -> DerivationRequests {
         self.next_requests.clone()
     }
 
-    pub async fn load_cached_or_derive_new_instances(
-        &self,
-    ) -> Result<IndexSet<HierarchicalDeterministicFactorInstance>> {
+    pub async fn load_cached_or_derive_new_instances(&self) -> Result<FactorInstances> {
         let factor_sources = self.all_factor_sources();
         let requests = self.next_requests();
         let factor_instances = self

src/recovery_securify_cache/derivation_and_analysis/is_factor_instances_provider.rs

@@ -4,6 +4,6 @@ use crate::prelude::*;
 pub trait IsFactorInstancesProvider: Sync + Send {
     async fn provide_instances(
         &self,
-        derivation_requests: IndexSet<DerivationRequest>,
-    ) -> Result<IndexSet<HierarchicalDeterministicFactorInstance>>;
+        derivation_requests: DerivationRequests,
+    ) -> Result<FactorInstances>;
 }

src/recovery_securify_cache/derivation_and_analysis/is_intermediary_derivation_analyzer.rs

@@ -6,6 +6,6 @@ use crate::prelude::*;
 pub trait IsIntermediaryDerivationAnalyzer: Sync + Send {
     async fn analyze(
         &self,
-        factor_instances: IndexSet<HierarchicalDeterministicFactorInstance>,
+        factor_instances: FactorInstances,
     ) -> Result<IntermediaryDerivationAnalysis>;
 }