Factor instances provider

.vscode/settings.json

@@ -1,21 +1,26 @@
 {
 	"cSpell.words": [
+		"analyser",
 		"Banksy",
 		"Fulfillable",
 		"interactor",
 		"Interactors",
 		"Keyrings",
 		"preprocess",
+		"rola",
 		"scrypto",
 		"securifies",
 		"securify",
 		"securifying",
 		"substate",
 		"txid",
 		"txids",
+		"unfactored",
+		"Unindex",
+		"Unindexed",
 		"unrecovered",
 		"unsecurified",
 		"VECI",
 		"Yubikey"
 	]
-}
+}

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/collector/key_ring.rs

@@ -2,26 +2,33 @@ use crate::prelude::*;
 
 /// A collection of `HierarchicalDeterministicFactorInstance` derived from a
 /// factor source.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub(crate) struct Keyring {
     pub(crate) factor_source_id: FactorSourceIDFromHash,
     pub(crate) paths: IndexSet<DerivationPath>,
-    derived: RefCell<IndexSet<HierarchicalDeterministicFactorInstance>>,
+    derived: RwLock<IndexSet<HierarchicalDeterministicFactorInstance>>,
 }
 
 impl Keyring {
+    pub fn clone_snapshot(&self) -> Self {
+        Self {
+            factor_source_id: self.factor_source_id,
+            paths: self.paths.clone(),
+            derived: RwLock::new(self.derived.try_read().unwrap().clone()),
+        }
+    }
     pub(crate) fn new(
         factor_source_id: FactorSourceIDFromHash,
         paths: IndexSet<DerivationPath>,
     ) -> Self {
         Self {
             factor_source_id,
             paths,
-            derived: RefCell::new(IndexSet::new()),
+            derived: RwLock::new(IndexSet::new()),
         }
     }
     pub(crate) fn factors(&self) -> IndexSet<HierarchicalDeterministicFactorInstance> {
-        self.derived.borrow().clone()
+        self.derived.try_read().unwrap().clone()
     }
 
     pub(crate) fn process_response(
@@ -33,10 +40,11 @@ impl Keyring {
             .all(|f| f.factor_source_id == self.factor_source_id
                 && !self
                     .derived
-                    .borrow()
+                    .try_read()
+                    .unwrap()
                     .iter()
                     .any(|x| x.public_key == f.public_key)));
 
-        self.derived.borrow_mut().extend(response)
+        self.derived.try_write().unwrap().extend(response)
     }
 }

src/derivation/collector/keys_collector.rs

@@ -15,15 +15,16 @@ pub struct KeysCollector {
 
     /// Mutable internal state of the collector which builds up the list
     /// of public keys from each used factor source.
-    state: RefCell<KeysCollectorState>,
+    state: RwLock<KeysCollectorState>,
 }
 
 impl KeysCollector {
     pub fn new(
         all_factor_sources_in_profile: impl IntoIterator<Item = HDFactorSource>,
-        derivation_paths: IndexMap<FactorSourceIDFromHash, IndexSet<DerivationPath>>,
+        derivation_paths: impl Into<IndexMap<FactorSourceIDFromHash, IndexSet<DerivationPath>>>,
         interactors: Arc<dyn KeysDerivationInteractors>,
     ) -> Result<Self> {
+        let derivation_paths = derivation_paths.into();
         let preprocessor = KeysCollectorPreprocessor::new(derivation_paths);
         Self::with_preprocessor(
             all_factor_sources_in_profile
@@ -47,7 +48,7 @@ impl KeysCollector {
 
         Ok(Self {
             dependencies,
-            state: RefCell::new(state),
+            state: RwLock::new(state),
         })
     }
 }
@@ -60,7 +61,7 @@ impl KeysCollector {
             .derive_with_factors() // in decreasing "friction order"
             .await
             .inspect_err(|e| error!("Failed to use factor sources: {:#?}", e));
-        self.state.into_inner().outcome()
+        self.state.into_inner().unwrap().outcome()
     }
 }
 
@@ -123,7 +124,11 @@ impl KeysCollector {
         &self,
         factor_source_id: &FactorSourceIDFromHash,
     ) -> Result<MonoFactorKeyDerivationRequest> {
-        let keyring = self.state.borrow().keyring_for(factor_source_id)?;
+        let keyring = self
+            .state
+            .try_read()
+            .unwrap()
+            .keyring_for(factor_source_id)?;
         assert_eq!(keyring.factors().len(), 0);
         let paths = keyring.paths.clone();
         Ok(MonoFactorKeyDerivationRequest::new(
@@ -156,6 +161,9 @@ impl KeysCollector {
     }
 
     fn process_batch_response(&self, response: KeyDerivationResponse) -> Result<()> {
-        self.state.borrow_mut().process_batch_response(response)
+        self.state
+            .try_write()
+            .unwrap()
+            .process_batch_response(response)
     }
 }

src/derivation/collector/keys_collector_state.rs

@@ -5,7 +5,7 @@ use crate::prelude::*;
 ///
 /// Holds a collection of keyrings derived from various factor sources.
 pub(crate) struct KeysCollectorState {
-    pub(super) keyrings: RefCell<IndexMap<FactorSourceIDFromHash, Keyring>>,
+    pub(super) keyrings: RwLock<IndexMap<FactorSourceIDFromHash, Keyring>>,
 }
 
 impl KeysCollectorState {
@@ -22,12 +22,12 @@ impl KeysCollectorState {
             })
             .collect::<IndexMap<FactorSourceIDFromHash, Keyring>>();
         Self {
-            keyrings: RefCell::new(keyrings),
+            keyrings: RwLock::new(keyrings),
         }
     }
 
     pub(crate) fn outcome(self) -> KeyDerivationOutcome {
-        let key_rings = self.keyrings.into_inner();
+        let key_rings = self.keyrings.into_inner().unwrap();
         KeyDerivationOutcome::new(
             key_rings
                 .into_iter()
@@ -38,16 +38,17 @@ impl KeysCollectorState {
 
     pub(crate) fn keyring_for(&self, factor_source_id: &FactorSourceIDFromHash) -> Result<Keyring> {
         self.keyrings
-            .borrow()
+            .try_read()
+            .unwrap()
             .get(factor_source_id)
-            .cloned()
+            .map(|x| x.clone_snapshot())
             .inspect(|k| assert_eq!(k.factor_source_id, *factor_source_id))
             .ok_or(CommonError::UnknownFactorSource)
     }
 
     pub(crate) fn process_batch_response(&self, response: KeyDerivationResponse) -> Result<()> {
         for (factor_source_id, factors) in response.per_factor_source.into_iter() {
-            let mut rings = self.keyrings.borrow_mut();
+            let mut rings = self.keyrings.try_write().unwrap();
             let keyring = rings
                 .get_mut(&factor_source_id)
                 .ok_or(CommonError::UnknownFactorSource)?;

src/derivation/host_interaction/interactors/mono_factor_key_derivation_interactor.rs

@@ -8,7 +8,7 @@ use crate::prelude::*;
 /// which it will use to update it internal state and continue with the next
 /// factor source, or in case of failure the whole process will be aborted.
 #[async_trait::async_trait]
-pub trait MonoFactorKeyDerivationInteractor {
+pub trait MonoFactorKeyDerivationInteractor: Send + Sync {
     async fn derive(
         &self,
         request: MonoFactorKeyDerivationRequest,

src/derivation/host_interaction/interactors/poly_factor_key_derivation_interactor.rs

@@ -8,7 +8,7 @@ use crate::prelude::*;
 /// which it will use to update it internal state and continue with the next
 /// factor source, or in case of failure the whole process will be aborted.
 #[async_trait::async_trait]
-pub trait PolyFactorKeyDerivationInteractor {
+pub trait PolyFactorKeyDerivationInteractor: Send + Sync {
     async fn derive(
         &self,
         request: PolyFactorKeyDerivationRequest,

src/derivation/host_interaction/keys_derivation_interactors.rs

@@ -1,6 +1,6 @@
 use crate::prelude::*;
 
 /// A collection of "interactors" which can derive keys.
-pub trait KeysDerivationInteractors {
+pub trait KeysDerivationInteractors: Sync + Send {
     fn interactor_for(&self, kind: FactorSourceKind) -> KeyDerivationInteractor;
 }

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/factor_instances_provider/derive_more.rs

@@ -0,0 +1,44 @@
+use crate::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum DeriveMore {
+    WithKnownStartIndex {
+        with_start_index: DerivationRequestWithRange,
+        number_of_instances_needed_to_fully_satisfy_request: Option<usize>,
+    },
+    WithoutKnownLastIndex {
+        request: QuantifiedUnindexDerivationRequest,
+        number_of_instances_needed_to_fully_satisfy_request: usize,
+    },
+}
+
+impl DeriveMore {
+    pub fn number_of_instances_to_use_directly(
+        &self,
+        original_purpose: FactorInstancesRequestPurpose,
+    ) -> usize {
+        match original_purpose {
+            FactorInstancesRequestPurpose::MARS { .. } => {
+                DerivationRequestQuantitySelector::FILL_CACHE_QUANTITY
+            }
+            FactorInstancesRequestPurpose::OARS { .. } => {
+                DerivationRequestQuantitySelector::FILL_CACHE_QUANTITY
+            }
+            FactorInstancesRequestPurpose::UpdateOrSetSecurityShieldForAccounts {
+                accounts,
+                ..
+            } => accounts.len(),
+            FactorInstancesRequestPurpose::PreDeriveInstancesForNewFactorSource { .. } => 0,
+            FactorInstancesRequestPurpose::NewVirtualUnsecurifiedAccount { .. } => 1,
+        }
+    }
+
+    pub fn unquantified(&self) -> UnquantifiedUnindexDerivationRequest {
+        match self {
+            Self::WithKnownStartIndex {
+                with_start_index, ..
+            } => with_start_index.clone().into(),
+            Self::WithoutKnownLastIndex { request, .. } => request.clone().into(),
+        }
+    }
+}