sketch of god method

src/recovery_securify_cache/account_recover_scan/account_recovery_scanning.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 async fn _account_recovery_scan(
-    input: DeriveAndAnalyzeInputAccountRecoveryScan,
+    input: DeriveAndAnalyzeAccountRecoveryScanInput,
 ) -> Result<DerivationAndAnalysisAccountRecoveryScan> {
     let input = DeriveAndAnalyzeInput::from(input);
     let analysis = derive_and_analyze(input).await?;
@@ -11,10 +11,12 @@ async fn _account_recovery_scan(
 pub async fn account_recovery_scan(
     factor_sources: IndexSet<HDFactorSource>,
     gateway: Arc<dyn Gateway>,
+    derivation_interactors: Arc<dyn KeysDerivationInteractors>,
 ) -> Result<AccountRecoveryScanOutcome> {
-    let analysis = _account_recovery_scan(DeriveAndAnalyzeInputAccountRecoveryScan::new(
+    let analysis = _account_recovery_scan(DeriveAndAnalyzeAccountRecoveryScanInput::new(
         factor_sources,
         gateway,
+        derivation_interactors,
     ))
     .await?;
     Ok(AccountRecoveryScanOutcome::from(analysis))

src/recovery_securify_cache/account_recover_scan/derive_and_analyze_account_recovery_scan_input.rs

@@ -0,0 +1,53 @@
+#![allow(unused)]
+#![allow(unused_variables)]
+
+use crate::prelude::*;
+
+pub struct DeriveAndAnalyzeAccountRecoveryScanInput {
+    factor_sources: IndexSet<HDFactorSource>,
+    gateway: Arc<dyn Gateway>,
+    derivation_interactors: Arc<dyn KeysDerivationInteractors>,
+}
+impl DeriveAndAnalyzeAccountRecoveryScanInput {
+    pub fn new(
+        factor_sources: IndexSet<HDFactorSource>,
+        gateway: Arc<dyn Gateway>,
+        derivation_interactors: Arc<dyn KeysDerivationInteractors>,
+    ) -> Self {
+        Self {
+            factor_sources,
+            gateway,
+            derivation_interactors,
+        }
+    }
+}
+impl From<DeriveAndAnalyzeAccountRecoveryScanInput> for DeriveAndAnalyzeInput {
+    fn from(value: DeriveAndAnalyzeAccountRecoveryScanInput) -> Self {
+        let next_derivation_entity_index_assigner = NextDerivationEntityIndexAssigner::ars();
+
+        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 {
+        todo!()
+    }
+}
+
+impl IntermediaryDerivationAnalyzer {
+    pub fn ars(gateway: Arc<dyn Gateway>) -> Self {
+        todo!()
+    }
+}

src/recovery_securify_cache/account_recover_scan/mod.rs

@@ -1,9 +1,9 @@
 mod account_recovery_scan_outcome;
 mod account_recovery_scanning;
 mod derivation_and_analysis_account_recovery_scan;
-mod derive_and_analyze_input_account_recovery_scan;
+mod derive_and_analyze_account_recovery_scan_input;
 
 pub use account_recovery_scan_outcome::*;
 pub use account_recovery_scanning::*;
 pub use derivation_and_analysis_account_recovery_scan::*;
-pub use derive_and_analyze_input_account_recovery_scan::*;
+pub use derive_and_analyze_account_recovery_scan_input::*;

src/recovery_securify_cache/derivation_and_analysis/input.rs

@@ -1,19 +1,108 @@
 #![allow(unused)]
 
+use std::ops::Index;
+
 use crate::prelude::*;
 
 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,
+}
+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
+    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<_>>()
+        );
+
+        Self {
+            all_factor_instances: all_factor_instances.into_iter().collect(),
+            probably_free_instances,
+            recovered_unsecurified_entities,
+            recovered_securified_entities,
+            unrecovered_securified_entities,
+        }
+    }
+}
+
+pub struct DerivationRequest {
+    pub factor_source_id: FactorSourceIDFromHash,
+    pub network_id: NetworkID,
+    pub entity_kind: CAP26EntityKind,
+    pub key_space: KeySpace,
+    pub key_kind: CAP26KeyKind,
+}
+
+/// Lookup which Entity Range Start Value to use for the Range of Derivation Indices
+/// to uses per request.
+///
+/// E.g. when doing recovery scan of unsecurified accounts we would return:
+/// `HDPathComponent::unsecurified_hardening_base_index(0)` as start value of a range of lets say
+/// 30 indices, for `DeviceFactorSource`s, given a request:
+/// `DerivationRequest { entity_kind: Account, key_space: Unsecurified, key_kind: TransactionSigning, ... }`
+///
+/// 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>,
+}
+
+/// 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,
+    >,
+}
+
 pub struct DeriveAndAnalyzeInput {
     factor_sources: IndexSet<HDFactorSource>,
     ids_of_new_factor_sources: IndexSet<FactorSourceIDFromHash>,
-    cache: Option<PreDerivedKeysCache>,
-    gateway: Arc<dyn Gateway>,
 
-    /// "Gateway required"
-    is_onchain_analysis_required: bool,
+    /// Which index to start at for the range of indices to derive
+    next_derivation_entity_index_assigner: NextDerivationEntityIndexAssigner,
 
-    profile_next_index_analyzer: Option<ProfileNextIndexAnalyzer>,
+    /// 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,
 }
 
 impl DeriveAndAnalyzeInput {
@@ -47,10 +136,8 @@ impl DeriveAndAnalyzeInput {
     pub fn new(
         factor_sources: IndexSet<HDFactorSource>,
         ids_of_new_factor_sources: IndexSet<FactorSourceIDFromHash>,
-        cache: Option<PreDerivedKeysCache>,
-        gateway: Arc<dyn Gateway>,
-        is_onchain_analysis_required: bool,
-        profile_next_index_analyzer: Option<ProfileNextIndexAnalyzer>,
+        next_derivation_entity_index_assigner: NextDerivationEntityIndexAssigner,
+        analyze_factor_instances: IntermediaryDerivationAnalyzer,
     ) -> Self {
         assert!(
             ids_of_new_factor_sources
@@ -62,10 +149,8 @@ impl DeriveAndAnalyzeInput {
         Self {
             factor_sources,
             ids_of_new_factor_sources,
-            cache,
-            gateway,
-            is_onchain_analysis_required,
-            profile_next_index_analyzer,
+            next_derivation_entity_index_assigner,
+            analyze_factor_instances,
         }
     }
 }

src/recovery_securify_cache/derivation_and_analysis/output/probably_free_factor_instances.rs

@@ -14,6 +14,17 @@ impl ProbablyFreeFactorInstances {
             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,6 +24,13 @@ impl RecoveredSecurifiedEntities {
             .map(AccountOrPersona::from)
             .collect()
     }
+
+    pub fn instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
+        self.securified_entities()
+            .into_iter()
+            .flat_map(|x| x.securified_entity_control().all_factor_instances())
+            .collect()
+    }
 }
 
 impl HasSampleValues for RecoveredSecurifiedEntities {

src/recovery_securify_cache/derivation_and_analysis/output/recovered_unsecurified_entities.rs

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

src/recovery_securify_cache/derivation_and_analysis/output/unrecovered_securified_entities.rs

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

src/recovery_securify_cache/derive_and_analyze.rs

@@ -67,6 +67,7 @@ use crate::prelude::*;
 ///         analyze if FactorInstance are free.)
 pub async fn derive_and_analyze(input: DeriveAndAnalyzeInput) -> Result<DerivationAndAnalysis> {
     error!("Using SAMPLE data in 'derive_and_analyze'!!!");
+    let mut derived_instances = IndexSet::<HierarchicalDeterministicFactorInstance>::new();
 
     // To be fed into cache, NOT done by this function.
     let probably_free_instances = ProbablyFreeFactorInstances::sample();

src/types/sargon_types.rs

@@ -991,6 +991,9 @@ pub struct SecurifiedEntityControl {
     pub access_controller: AccessController,
 }
 impl SecurifiedEntityControl {
+    pub fn all_factor_instances(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
+        self.matrix.all_factors()
+    }
     pub fn new(matrix: MatrixOfFactorInstances, access_controller: AccessController) -> Self {
         Self {
             matrix,