derive and analyze input

src/recovery_securify_cache/account_recover_scan/account_recovery_scanning.rs

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

src/recovery_securify_cache/account_recover_scan/derive_and_analyze_input_account_recovery_scan.rs

@@ -0,0 +1,30 @@
+use crate::prelude::*;
+
+pub struct DeriveAndAnalyzeInputAccountRecoveryScan {
+    factor_sources: IndexSet<HDFactorSource>,
+    gateway: Arc<dyn Gateway>,
+}
+impl DeriveAndAnalyzeInputAccountRecoveryScan {
+    pub fn new(factor_sources: IndexSet<HDFactorSource>, gateway: Arc<dyn Gateway>) -> Self {
+        Self {
+            factor_sources,
+            gateway,
+        }
+    }
+}
+impl From<DeriveAndAnalyzeInputAccountRecoveryScan> for DeriveAndAnalyzeInput {
+    fn from(value: DeriveAndAnalyzeInputAccountRecoveryScan) -> Self {
+        Self::new(
+            value.factor_sources.clone(),
+            value
+                .factor_sources
+                .into_iter()
+                .map(|f| f.factor_source_id())
+                .collect(),
+            None,
+            value.gateway,
+            true,
+            None,
+        )
+    }
+}

src/recovery_securify_cache/account_recover_scan/mod.rs

@@ -1,5 +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;
 
 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::*;

src/recovery_securify_cache/derivation_and_analysis/input.rs

@@ -0,0 +1,46 @@
+#![allow(unused)]
+
+use crate::prelude::*;
+
+pub struct ProfileNextIndexAnalyzer {}
+
+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,
+
+    profile_next_index_analyzer: Option<ProfileNextIndexAnalyzer>,
+}
+
+impl DeriveAndAnalyzeInput {
+    /// # Panics
+    /// Panics if some IDs of `ids_of_new_factor_sources` are not found in `factor_sources`
+    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>,
+    ) -> Self {
+        assert!(
+            ids_of_new_factor_sources
+                .iter()
+                .all(|id| factor_sources.iter().any(|f| f.factor_source_id() == *id)),
+            "Discrepancy! Some IDs of new factor sources are not found in factor sources!"
+        );
+
+        Self {
+            factor_sources,
+            ids_of_new_factor_sources,
+            cache,
+            gateway,
+            is_onchain_analysis_required,
+            profile_next_index_analyzer,
+        }
+    }
+}

src/recovery_securify_cache/derivation_and_analysis/mod.rs

@@ -0,0 +1,5 @@
+mod input;
+mod output;
+
+pub use input::*;
+pub use output::*;

src/recovery_securify_cache/derivation_and_analysis/output/mod.rs

@@ -0,0 +1,17 @@
+mod derivation_and_analysis;
+mod probably_free_factor_instances;
+mod recovered_securified_entities;
+mod recovered_unsecurified_entities;
+mod securified_entity;
+mod unrecovered_securified_entities;
+mod unrecovered_securified_entity;
+mod unsecurified_entity;
+
+pub use derivation_and_analysis::*;
+pub use probably_free_factor_instances::*;
+pub use recovered_securified_entities::*;
+pub use recovered_unsecurified_entities::*;
+pub use securified_entity::*;
+pub use unrecovered_securified_entities::*;
+pub use unrecovered_securified_entity::*;
+pub use unsecurified_entity::*;

src/recovery_securify_cache/playground.rs → src/recovery_securify_cache/derive_and_analyze.rs

@@ -65,16 +65,6 @@ use crate::prelude::*;
 ///     - `VECI` Addition: NO
 ///     - Gateway Required: NO (but beneficial to use it if host is online to
 ///         analyze if FactorInstance are free.)
-async fn derive_and_analyze() -> Result<DerivationAndAnalysis> {
+pub async fn derive_and_analyze(input: DeriveAndAnalyzeInput) -> Result<DerivationAndAnalysis> {
     todo!()
 }
-
-async fn _account_recovery_scan() -> Result<DerivationAndAnalysisAccountRecoveryScan> {
-    let analysis = derive_and_analyze().await?;
-    DerivationAndAnalysisAccountRecoveryScan::try_from(analysis)
-}
-
-pub async fn account_recovery_scan() -> Result<AccountRecoveryScanOutcome> {
-    let analysis = _account_recovery_scan().await?;
-    Ok(AccountRecoveryScanOutcome::from(analysis))
-}

src/recovery_securify_cache/mod.rs

@@ -1,22 +1,9 @@
 mod account_recover_scan;
 mod derivation_and_analysis;
-mod playground;
+mod derive_and_analyze;
 mod pre_derived_keys_cache;
-mod probably_free_factor_instances;
-mod recovered_securified_entities;
-mod recovered_unsecurified_entities;
-mod securified_entity;
-mod unrecovered_securified_entities;
-mod unrecovered_securified_entity;
-mod unsecurified_entity;
 
 pub use account_recover_scan::*;
 pub use derivation_and_analysis::*;
+pub use derive_and_analyze::*;
 pub use pre_derived_keys_cache::*;
-pub use probably_free_factor_instances::*;
-pub use recovered_securified_entities::*;
-pub use recovered_unsecurified_entities::*;
-pub use securified_entity::*;
-pub use unrecovered_securified_entities::*;
-pub use unrecovered_securified_entity::*;
-pub use unsecurified_entity::*;

src/recovery_securify_cache/pre_derived_keys_cache.rs

@@ -1,7 +1,5 @@
 use crate::prelude::*;
 
-use super::probably_free_factor_instances;
-
 #[derive(Debug)]
 pub struct PreDerivedKeysCache;