Preparations for factor instances provider

.vscode/settings.json

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

Cargo.toml

@@ -37,3 +37,4 @@ pretty_env_logger = { git = "https://github.com/seanmonstar/pretty-env-logger/",
 hex = "0.4.3"
 enum-as-inner = "0.6.0"
 futures = "0.3.30"
+enum-iterator = "2.1.0"

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 {
@@ -257,7 +257,7 @@ mod key_derivation_tests {
                     BIP32_SECURIFIED_HALF + 2,
                 ]
                 .into_iter()
-                .map(HDPathComponent::new_from_base_index)
+                .map(HDPathComponent::new_from_index)
                 .map(|p| DerivationPath::new(Mainnet, Account, TransactionSigning, p)),
             );
 
@@ -271,7 +271,7 @@ mod key_derivation_tests {
                     BIP32_SECURIFIED_HALF + 2,
                 ]
                 .into_iter()
-                .map(HDPathComponent::new_from_base_index)
+                .map(HDPathComponent::new_from_index)
                 .map(|p| DerivationPath::new(Stokenet, Account, TransactionSigning, p)),
             );
 
@@ -285,7 +285,7 @@ mod key_derivation_tests {
                     BIP32_SECURIFIED_HALF + 2,
                 ]
                 .into_iter()
-                .map(HDPathComponent::new_from_base_index)
+                .map(HDPathComponent::new_from_index)
                 .map(|p| DerivationPath::new(Mainnet, Identity, TransactionSigning, p)),
             );
 
@@ -299,7 +299,7 @@ mod key_derivation_tests {
                     BIP32_SECURIFIED_HALF + 2,
                 ]
                 .into_iter()
-                .map(HDPathComponent::new_from_base_index)
+                .map(HDPathComponent::new_from_index)
                 .map(|p| DerivationPath::new(Stokenet, Identity, TransactionSigning, p)),
             );
 
@@ -313,7 +313,7 @@ mod key_derivation_tests {
                     BIP32_SECURIFIED_HALF + 2,
                 ]
                 .into_iter()
-                .map(HDPathComponent::new_from_base_index)
+                .map(HDPathComponent::new_from_index)
                 .map(|p| DerivationPath::new(Mainnet, Account, AuthenticationSigning, p)),
             );
 
@@ -327,7 +327,7 @@ mod key_derivation_tests {
                     BIP32_SECURIFIED_HALF + 2,
                 ]
                 .into_iter()
-                .map(HDPathComponent::new_from_base_index)
+                .map(HDPathComponent::new_from_index)
                 .map(|p| DerivationPath::new(Stokenet, Account, AuthenticationSigning, p)),
             );
 
@@ -341,7 +341,7 @@ mod key_derivation_tests {
                     BIP32_SECURIFIED_HALF + 2,
                 ]
                 .into_iter()
-                .map(HDPathComponent::new_from_base_index)
+                .map(HDPathComponent::new_from_index)
                 .map(|p| DerivationPath::new(Mainnet, Identity, AuthenticationSigning, p)),
             );
 
@@ -355,7 +355,7 @@ mod key_derivation_tests {
                     BIP32_SECURIFIED_HALF + 2,
                 ]
                 .into_iter()
-                .map(HDPathComponent::new_from_base_index)
+                .map(HDPathComponent::new_from_index)
                 .map(|p| DerivationPath::new(Stokenet, Identity, AuthenticationSigning, p)),
             );
 
@@ -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!(