From 6f3c3543aefd7384066e23393049e833f0dba659 Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Thu, 29 Aug 2024 16:13:43 +0200 Subject: [PATCH 1/9] rename petition types with 'ForX' --- .../signatures_collector_preprocessor.rs | 15 ++++--- src/signing/petition_types/mod.rs | 8 ++-- .../petition_factors_types/mod.rs | 4 +- .../petition_factors_state.rs | 2 +- ...ion_factors.rs => petition_for_factors.rs} | 12 +++--- ...ition_entity.rs => petition_for_entity.rs} | 40 +++++++++---------- ...saction.rs => petition_for_transaction.rs} | 30 +++++++------- src/signing/petition_types/petitions.rs | 10 ++--- 8 files changed, 62 insertions(+), 59 deletions(-) rename src/signing/petition_types/petition_factors_types/{petition_factors.rs => petition_for_factors.rs} (94%) rename src/signing/petition_types/{petition_entity.rs => petition_for_entity.rs} (92%) rename src/signing/petition_types/{petition_of_transaction.rs => petition_for_transaction.rs} (83%) diff --git a/src/signing/collector/signatures_collector_preprocessor.rs b/src/signing/collector/signatures_collector_preprocessor.rs index 321f544f..05367a93 100644 --- a/src/signing/collector/signatures_collector_preprocessor.rs +++ b/src/signing/collector/signatures_collector_preprocessor.rs @@ -35,7 +35,8 @@ impl SignaturesCollectorPreprocessor { all_factor_sources_in_profile: IndexSet, ) -> (Petitions, IndexSet) { let transactions = self.transactions; - let mut petitions_for_all_transactions = IndexMap::::new(); + let mut petitions_for_all_transactions = + IndexMap::::new(); let all_factor_sources_in_profile = all_factor_sources_in_profile .into_iter() @@ -65,7 +66,7 @@ impl SignaturesCollectorPreprocessor { for transaction in transactions.into_iter() { let mut petitions_for_entities = - HashMap::::new(); + HashMap::::new(); for entity in transaction.entities_requiring_auth() { let address = entity.address(); @@ -82,7 +83,7 @@ impl SignaturesCollectorPreprocessor { add(primary_role_matrix.override_factors.clone()); add(primary_role_matrix.threshold_factors.clone()); - let petition = PetitionEntity::new_securified( + let petition = PetitionForEntity::new_securified( transaction.intent_hash.clone(), address.clone(), primary_role_matrix, @@ -93,7 +94,7 @@ impl SignaturesCollectorPreprocessor { let factor_instance = uec; let factor_source_id = factor_instance.factor_source_id; use_factor_in_tx(&factor_source_id, &transaction.intent_hash); - let petition = PetitionEntity::new_unsecurified( + let petition = PetitionForEntity::new_unsecurified( transaction.intent_hash.clone(), address.clone(), factor_instance, @@ -103,8 +104,10 @@ impl SignaturesCollectorPreprocessor { } } - let petition_of_tx = - PetitionTransaction::new(transaction.intent_hash.clone(), petitions_for_entities); + let petition_of_tx = PetitionForTransaction::new( + transaction.intent_hash.clone(), + petitions_for_entities, + ); petitions_for_all_transactions.insert(transaction.intent_hash, petition_of_tx); } diff --git a/src/signing/petition_types/mod.rs b/src/signing/petition_types/mod.rs index 5c7293cd..176e0830 100644 --- a/src/signing/petition_types/mod.rs +++ b/src/signing/petition_types/mod.rs @@ -1,11 +1,11 @@ mod factor_list_kind; -mod petition_entity; mod petition_factors_types; -mod petition_of_transaction; +mod petition_for_entity; +mod petition_for_transaction; mod petitions; pub use factor_list_kind::*; -pub use petition_entity::*; pub use petition_factors_types::*; -pub(crate) use petition_of_transaction::*; +pub use petition_for_entity::*; +pub(crate) use petition_for_transaction::*; pub(crate) use petitions::*; diff --git a/src/signing/petition_types/petition_factors_types/mod.rs b/src/signing/petition_types/petition_factors_types/mod.rs index c5053a06..c870bd1d 100644 --- a/src/signing/petition_types/petition_factors_types/mod.rs +++ b/src/signing/petition_types/petition_factors_types/mod.rs @@ -1,11 +1,11 @@ mod factor_source_referencing; mod neglected_factor_instance; -mod petition_factors; mod petition_factors_input; mod petition_factors_state; mod petition_factors_state_snapshot; mod petition_factors_status; mod petition_factors_sub_state; +mod petition_for_factors; use petition_factors_input::*; use petition_factors_state::*; @@ -14,5 +14,5 @@ use petition_factors_sub_state::*; pub(crate) use factor_source_referencing::*; pub use neglected_factor_instance::*; -pub use petition_factors::*; pub use petition_factors_status::*; +pub use petition_for_factors::*; diff --git a/src/signing/petition_types/petition_factors_types/petition_factors_state.rs b/src/signing/petition_types/petition_factors_types/petition_factors_state.rs index 3dc27a3d..f34d9e4d 100644 --- a/src/signing/petition_types/petition_factors_types/petition_factors_state.rs +++ b/src/signing/petition_types/petition_factors_types/petition_factors_state.rs @@ -3,7 +3,7 @@ use std::cell::Ref; use super::*; use crate::prelude::*; -/// Mutable state of `PetitionFactors`, keeping track of which factors that +/// Mutable state of `PetitionForFactors`, keeping track of which factors that /// have either signed or been neglected. #[derive(Clone, PartialEq, Eq, derive_more::Debug)] #[debug("PetitionFactorsState(signed: {:?}, neglected: {:?})", signed.borrow().clone(), neglected.borrow().clone())] diff --git a/src/signing/petition_types/petition_factors_types/petition_factors.rs b/src/signing/petition_types/petition_factors_types/petition_for_factors.rs similarity index 94% rename from src/signing/petition_types/petition_factors_types/petition_factors.rs rename to src/signing/petition_types/petition_factors_types/petition_for_factors.rs index 49ed9f2d..15721757 100644 --- a/src/signing/petition_types/petition_factors_types/petition_factors.rs +++ b/src/signing/petition_types/petition_factors_types/petition_for_factors.rs @@ -4,7 +4,7 @@ use crate::prelude::*; /// Petition of signatures from a factors list of an entity in a transaction. #[derive(Clone, PartialEq, Eq, derive_more::Debug)] #[debug("{}", self.debug_str())] -pub struct PetitionFactors { +pub struct PetitionForFactors { pub factor_list_kind: FactorListKind, /// Factors to sign with and the required number of them. @@ -12,7 +12,7 @@ pub struct PetitionFactors { state: RefCell, } -impl HasSampleValues for PetitionFactors { +impl HasSampleValues for PetitionForFactors { fn sample() -> Self { Self::new(FactorListKind::Threshold, PetitionFactorsInput::sample()) } @@ -25,7 +25,7 @@ impl HasSampleValues for PetitionFactors { } } -impl PetitionFactors { +impl PetitionForFactors { pub fn new(factor_list_kind: FactorListKind, input: PetitionFactorsInput) -> Self { Self { factor_list_kind, @@ -77,13 +77,13 @@ impl PetitionFactors { let factor_source_id = &neglected.factor_source_id(); if let Some(_x_) = self.reference_to_factor_source_with_id(factor_source_id) { debug!( - "PetitionFactors = kind {:?} neglect factor source with id: {}, reason: {}", + "PetitionForFactors = kind {:?} neglect factor source with id: {}, reason: {}", self.factor_list_kind, factor_source_id, neglected.reason ); self.neglect(neglected) } else { debug!( - "PetitionFactors = kind {:?} did not reference factor source with id: {}", + "PetitionForFactors = kind {:?} did not reference factor source with id: {}", self.factor_list_kind, factor_source_id ); } @@ -189,7 +189,7 @@ impl PetitionFactors { pub fn debug_str(&self) -> String { format!( - "PetitionFactors(input: {:#?}, state_snapshot: {:#?})", + "PetitionForFactors(input: {:#?}, state_snapshot: {:#?})", self.input, self.state_snapshot() ) diff --git a/src/signing/petition_types/petition_entity.rs b/src/signing/petition_types/petition_for_entity.rs similarity index 92% rename from src/signing/petition_types/petition_entity.rs rename to src/signing/petition_types/petition_for_entity.rs index c872b793..8b6f1ad0 100644 --- a/src/signing/petition_types/petition_entity.rs +++ b/src/signing/petition_types/petition_for_entity.rs @@ -2,10 +2,10 @@ use crate::prelude::*; /// Petition of signatures from an entity in a transaction. /// Essentially a wrapper around a tuple -/// `{ threshold: PetitionFactors, override: PetitionFactors }` +/// `{ threshold: PetitionForFactors, override: PetitionForFactors }` #[derive(Clone, PartialEq, Eq, derive_more::Debug)] #[debug("{}", self.debug_str())] -pub struct PetitionEntity { +pub struct PetitionForEntity { /// The owner of these factors pub entity: AddressOfAccountOrPersona, @@ -13,18 +13,18 @@ pub struct PetitionEntity { pub intent_hash: IntentHash, /// Petition with threshold factors - pub threshold_factors: Option>, + pub threshold_factors: Option>, /// Petition with override factors - pub override_factors: Option>, + pub override_factors: Option>, } -impl PetitionEntity { +impl PetitionForEntity { pub fn new( intent_hash: IntentHash, entity: AddressOfAccountOrPersona, - threshold_factors: impl Into>, - override_factors: impl Into>, + threshold_factors: impl Into>, + override_factors: impl Into>, ) -> Self { let threshold_factors = threshold_factors.into(); let override_factors = override_factors.into(); @@ -47,8 +47,8 @@ impl PetitionEntity { Self::new( intent_hash, entity, - PetitionFactors::new_threshold(matrix.threshold_factors, matrix.threshold as i8), - PetitionFactors::new_override(matrix.override_factors), + PetitionForFactors::new_threshold(matrix.threshold_factors, matrix.threshold as i8), + PetitionForFactors::new_override(matrix.override_factors), ) } @@ -60,7 +60,7 @@ impl PetitionEntity { Self::new( intent_hash, entity, - PetitionFactors::new_unsecurified(instance), + PetitionForFactors::new_unsecurified(instance), None, ) } @@ -80,7 +80,7 @@ impl PetitionEntity { fn union_of(&self, map: F) -> IndexSet where T: Eq + std::hash::Hash + Clone, - F: Fn(&PetitionFactors) -> IndexSet, + F: Fn(&PetitionForFactors) -> IndexSet, { self.both( |l| map(l), @@ -115,16 +115,16 @@ impl PetitionEntity { self.union_of(|f| f.all_signatures()) } - fn with_list(list: &Option>, map: F) -> Option + fn with_list(list: &Option>, map: F) -> Option where - F: Fn(&PetitionFactors) -> T, + F: Fn(&PetitionForFactors) -> T, { list.as_ref().map(|refcell| map(&refcell.borrow())) } fn on_list(&self, kind: FactorListKind, r#do: &F) -> Option where - F: Fn(&PetitionFactors) -> R, + F: Fn(&PetitionForFactors) -> R, { match kind { FactorListKind::Threshold => Self::with_list(&self.threshold_factors, r#do), @@ -134,7 +134,7 @@ impl PetitionEntity { fn both(&self, r#do: F, combine: C) -> R where - F: Fn(&PetitionFactors) -> T, + F: Fn(&PetitionForFactors) -> T, C: Fn(Option, Option) -> R, { let t = self.on_list(FactorListKind::Threshold, &r#do); @@ -144,7 +144,7 @@ impl PetitionEntity { fn both_void(&self, r#do: F) where - F: Fn(&PetitionFactors) -> R, + F: Fn(&PetitionForFactors) -> R, { self.both(r#do, |_, _| ()) } @@ -282,7 +282,7 @@ impl PetitionEntity { } } -impl PetitionEntity { +impl PetitionForEntity { fn from_entity(entity: impl Into, intent_hash: IntentHash) -> Self { let entity = entity.into(); match entity.security_state() { @@ -296,7 +296,7 @@ impl PetitionEntity { } } -impl HasSampleValues for PetitionEntity { +impl HasSampleValues for PetitionForEntity { fn sample() -> Self { Self::from_entity(Account::sample_securified(), IntentHash::sample()) } @@ -309,7 +309,7 @@ impl HasSampleValues for PetitionEntity { #[cfg(test)] mod tests { use super::*; - type Sut = PetitionEntity; + type Sut = PetitionForEntity; #[test] fn multiple_device_as_override_skipped_both_is_invalid() { @@ -485,7 +485,7 @@ mod tests { #[test] fn debug() { - pretty_assertions::assert_eq!(format!("{:?}", Sut::sample()), "intent_hash: TXID(\"dedede\"), entity: acco_Grace, \"threshold_factors PetitionFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Device:00, derivation_path: 0/A/tx/6,\\n factor_source_id: Arculus:03, derivation_path: 0/A/tx/6,\\n factor_source_id: Yubikey:05, derivation_path: 0/A/tx/6,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\"\"override_factors PetitionFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Ledger:01, derivation_path: 0/A/tx/6,\\n factor_source_id: Arculus:04, derivation_path: 0/A/tx/6,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\""); + pretty_assertions::assert_eq!(format!("{:?}", Sut::sample()), "intent_hash: TXID(\"dedede\"), entity: acco_Grace, \"threshold_factors PetitionForFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Device:00, derivation_path: 0/A/tx/6,\\n factor_source_id: Arculus:03, derivation_path: 0/A/tx/6,\\n factor_source_id: Yubikey:05, derivation_path: 0/A/tx/6,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\"\"override_factors PetitionForFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Ledger:01, derivation_path: 0/A/tx/6,\\n factor_source_id: Arculus:04, derivation_path: 0/A/tx/6,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\""); } #[test] diff --git a/src/signing/petition_types/petition_of_transaction.rs b/src/signing/petition_types/petition_for_transaction.rs similarity index 83% rename from src/signing/petition_types/petition_of_transaction.rs rename to src/signing/petition_types/petition_for_transaction.rs index 4749f1db..be3ef2a5 100644 --- a/src/signing/petition_types/petition_of_transaction.rs +++ b/src/signing/petition_types/petition_for_transaction.rs @@ -1,20 +1,20 @@ use crate::prelude::*; /// Petition of signatures for a transaction. -/// Essentially a wrapper around `Iterator`. +/// Essentially a wrapper around `Iterator`. #[derive(derive_more::Debug, PartialEq, Eq)] #[debug("{}", self.debug_str())] -pub(crate) struct PetitionTransaction { +pub(crate) struct PetitionForTransaction { /// Hash of transaction to sign pub intent_hash: IntentHash, - pub for_entities: RefCell>, + pub for_entities: RefCell>, } -impl PetitionTransaction { +impl PetitionForTransaction { pub(crate) fn new( intent_hash: IntentHash, - for_entities: HashMap, + for_entities: HashMap, ) -> Self { Self { intent_hash, @@ -164,14 +164,14 @@ impl PetitionTransaction { .for_entities .borrow() .iter() - .map(|p| format!("PetitionEntity({:#?})", p.1)) + .map(|p| format!("PetitionForEntity({:#?})", p.1)) .join(", "); - format!("PetitionTransaction(for_entities: [{}])", entities) + format!("PetitionForTransaction(for_entities: [{}])", entities) } } -impl HasSampleValues for PetitionTransaction { +impl HasSampleValues for PetitionForTransaction { fn sample() -> Self { let intent_hash = IntentHash::sample(); let entity = Account::sample_securified(); @@ -179,11 +179,11 @@ impl HasSampleValues for PetitionTransaction { intent_hash.clone(), HashMap::from_iter([( entity.address(), - PetitionEntity::new( + PetitionForEntity::new( intent_hash.clone(), entity.address(), - PetitionFactors::sample(), - PetitionFactors::sample_other(), + PetitionForFactors::sample(), + PetitionForFactors::sample_other(), ), )]), ) @@ -196,10 +196,10 @@ impl HasSampleValues for PetitionTransaction { intent_hash.clone(), HashMap::from_iter([( entity.address(), - PetitionEntity::new( + PetitionForEntity::new( intent_hash.clone(), entity.address(), - PetitionFactors::sample_other(), + PetitionForFactors::sample_other(), None, ), )]), @@ -212,7 +212,7 @@ mod tests { use super::*; - type Sut = PetitionTransaction; + type Sut = PetitionForTransaction; #[test] fn equality() { @@ -227,6 +227,6 @@ mod tests { #[test] fn debug() { - assert_eq!(format!("{:?}", Sut::sample()), "PetitionTransaction(for_entities: [PetitionEntity(intent_hash: TXID(\"dedede\"), entity: acco_Grace, \"threshold_factors PetitionFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Device:de, derivation_path: 0/A/tx/0,\\n factor_source_id: Ledger:1e, derivation_path: 0/A/tx/1,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\"\"override_factors PetitionFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Ledger:1e, derivation_path: 0/A/tx/1,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\")])"); + assert_eq!(format!("{:?}", Sut::sample()), "PetitionForTransaction(for_entities: [PetitionForEntity(intent_hash: TXID(\"dedede\"), entity: acco_Grace, \"threshold_factors PetitionForFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Device:de, derivation_path: 0/A/tx/0,\\n factor_source_id: Ledger:1e, derivation_path: 0/A/tx/1,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\"\"override_factors PetitionForFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Ledger:1e, derivation_path: 0/A/tx/1,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\")])"); } } diff --git a/src/signing/petition_types/petitions.rs b/src/signing/petition_types/petitions.rs index adb4dc62..c94307a6 100644 --- a/src/signing/petition_types/petitions.rs +++ b/src/signing/petition_types/petitions.rs @@ -20,7 +20,7 @@ pub(crate) struct Petitions { /// Lookup from TXID to signatures builders, sorted according to the order of /// transactions passed to the SignaturesBuilder. - pub txid_to_petition: RefCell>, + pub txid_to_petition: RefCell>, } #[derive(Clone, Copy, PartialEq, Eq, Debug)] @@ -45,7 +45,7 @@ impl PetitionsStatus { impl Petitions { pub(crate) fn new( factor_source_to_intent_hash: HashMap>, - txid_to_petition: IndexMap, + txid_to_petition: IndexMap, ) -> Self { Self { factor_source_to_intent_hash, @@ -249,7 +249,7 @@ impl Petitions { impl HasSampleValues for Petitions { fn sample() -> Self { - let p0 = PetitionTransaction::sample(); + let p0 = PetitionForTransaction::sample(); Self::new( HashMap::from_iter([( FactorSourceIDFromHash::fs0(), @@ -260,7 +260,7 @@ impl HasSampleValues for Petitions { } fn sample_other() -> Self { - let p1 = PetitionTransaction::sample(); + let p1 = PetitionForTransaction::sample(); Self::new( HashMap::from_iter([( FactorSourceIDFromHash::fs1(), @@ -290,6 +290,6 @@ mod tests { #[test] fn debug() { - pretty_assertions::assert_eq!(format!("{:?}", Sut::sample()), "Petitions(TXID(\"dedede\"): PetitionTransaction(for_entities: [PetitionEntity(intent_hash: TXID(\"dedede\"), entity: acco_Grace, \"threshold_factors PetitionFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Device:de, derivation_path: 0/A/tx/0,\\n factor_source_id: Ledger:1e, derivation_path: 0/A/tx/1,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\"\"override_factors PetitionFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Ledger:1e, derivation_path: 0/A/tx/1,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\")]))"); + pretty_assertions::assert_eq!(format!("{:?}", Sut::sample()), "Petitions(TXID(\"dedede\"): PetitionForTransaction(for_entities: [PetitionForEntity(intent_hash: TXID(\"dedede\"), entity: acco_Grace, \"threshold_factors PetitionForFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Device:de, derivation_path: 0/A/tx/0,\\n factor_source_id: Ledger:1e, derivation_path: 0/A/tx/1,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\"\"override_factors PetitionForFactors(input: PetitionFactorsInput(factors: {\\n factor_source_id: Ledger:1e, derivation_path: 0/A/tx/1,\\n}), state_snapshot: signatures: \\\"\\\", neglected: \\\"\\\")\")]))"); } } From 015d85fd5946021e51f277d121ecd39ba3142b86 Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Thu, 29 Aug 2024 16:17:09 +0200 Subject: [PATCH 2/9] make ctor of PetitionForEntity 'private' --- src/signing/petition_types/petition_for_entity.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/signing/petition_types/petition_for_entity.rs b/src/signing/petition_types/petition_for_entity.rs index 8b6f1ad0..fc9da47d 100644 --- a/src/signing/petition_types/petition_for_entity.rs +++ b/src/signing/petition_types/petition_for_entity.rs @@ -20,7 +20,7 @@ pub struct PetitionForEntity { } impl PetitionForEntity { - pub fn new( + pub(super) fn new( intent_hash: IntentHash, entity: AddressOfAccountOrPersona, threshold_factors: impl Into>, From 40f253c6227dea56e29cf2c659067022d820d3c0 Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Thu, 29 Aug 2024 16:23:35 +0200 Subject: [PATCH 3/9] rename map_factor_list --- src/signing/petition_types/petition_for_entity.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/signing/petition_types/petition_for_entity.rs b/src/signing/petition_types/petition_for_entity.rs index fc9da47d..587bbb0f 100644 --- a/src/signing/petition_types/petition_for_entity.rs +++ b/src/signing/petition_types/petition_for_entity.rs @@ -122,7 +122,7 @@ impl PetitionForEntity { list.as_ref().map(|refcell| map(&refcell.borrow())) } - fn on_list(&self, kind: FactorListKind, r#do: &F) -> Option + fn map_factor_list(&self, kind: FactorListKind, r#do: &F) -> Option where F: Fn(&PetitionForFactors) -> R, { @@ -137,8 +137,8 @@ impl PetitionForEntity { F: Fn(&PetitionForFactors) -> T, C: Fn(Option, Option) -> R, { - let t = self.on_list(FactorListKind::Threshold, &r#do); - let o = self.on_list(FactorListKind::Override, &r#do); + let t = self.map_factor_list(FactorListKind::Threshold, &r#do); + let o = self.map_factor_list(FactorListKind::Override, &r#do); combine(t, o) } From 7aa57fa972ed552789609e60845c623d733e0c64 Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Thu, 29 Aug 2024 16:26:30 +0200 Subject: [PATCH 4/9] rename union_of to map_list_then_form_union --- src/signing/petition_types/petition_for_entity.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/signing/petition_types/petition_for_entity.rs b/src/signing/petition_types/petition_for_entity.rs index 587bbb0f..d14f3250 100644 --- a/src/signing/petition_types/petition_for_entity.rs +++ b/src/signing/petition_types/petition_for_entity.rs @@ -77,7 +77,7 @@ impl PetitionForEntity { self.status() == PetitionFactorsStatus::Finished(PetitionFactorsStatusFinished::Fail) } - fn union_of(&self, map: F) -> IndexSet + fn map_list_then_form_union(&self, map: F) -> IndexSet where T: Eq + std::hash::Hash + Clone, F: Fn(&PetitionForFactors) -> IndexSet, @@ -94,14 +94,14 @@ impl PetitionForEntity { } pub fn all_factor_instances(&self) -> IndexSet { - self.union_of(|l| l.factor_instances()) + self.map_list_then_form_union(|l| l.factor_instances()) .into_iter() .map(|f| OwnedFactorInstance::owned_factor_instance(self.entity.clone(), f.clone())) .collect::>() } pub fn all_neglected_factor_instances(&self) -> IndexSet { - self.union_of(|f| f.all_neglected()) + self.map_list_then_form_union(|f| f.all_neglected()) } pub fn all_neglected_factor_sources(&self) -> IndexSet { @@ -112,7 +112,7 @@ impl PetitionForEntity { } pub fn all_signatures(&self) -> IndexSet { - self.union_of(|f| f.all_signatures()) + self.map_list_then_form_union(|f| f.all_signatures()) } fn with_list(list: &Option>, map: F) -> Option From 0a98cf38afc96a00e1f8f81cdd48cad44e9d7e69 Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Thu, 29 Aug 2024 16:35:24 +0200 Subject: [PATCH 5/9] rename arg map -> do --- src/signing/petition_types/petition_for_entity.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/signing/petition_types/petition_for_entity.rs b/src/signing/petition_types/petition_for_entity.rs index d14f3250..52e7bbb1 100644 --- a/src/signing/petition_types/petition_for_entity.rs +++ b/src/signing/petition_types/petition_for_entity.rs @@ -115,11 +115,11 @@ impl PetitionForEntity { self.map_list_then_form_union(|f| f.all_signatures()) } - fn with_list(list: &Option>, map: F) -> Option + fn with_list(list: &Option>, r#do: F) -> Option where F: Fn(&PetitionForFactors) -> T, { - list.as_ref().map(|refcell| map(&refcell.borrow())) + list.as_ref().map(|refcell| r#do(&refcell.borrow())) } fn map_factor_list(&self, kind: FactorListKind, r#do: &F) -> Option From b72ca86a17df3bf1c5e53dbe232a084b62241f3e Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Thu, 29 Aug 2024 16:48:17 +0200 Subject: [PATCH 6/9] invalid_transactions -> invalid_transaction and Option. --- .../petition_types/petition_for_entity.rs | 108 +++++++----------- .../petition_for_transaction.rs | 4 +- 2 files changed, 43 insertions(+), 69 deletions(-) diff --git a/src/signing/petition_types/petition_for_entity.rs b/src/signing/petition_types/petition_for_entity.rs index 52e7bbb1..8ae42abe 100644 --- a/src/signing/petition_types/petition_for_entity.rs +++ b/src/signing/petition_types/petition_for_entity.rs @@ -178,22 +178,23 @@ impl PetitionForEntity { } } - pub fn invalid_transactions_if_neglected_factors( + pub fn invalid_transaction_if_neglected_factors( &self, factor_source_ids: IndexSet, - ) -> IndexSet { + ) -> Option { let status_if_neglected = self.status_if_neglected_factors(factor_source_ids); match status_if_neglected { PetitionFactorsStatus::Finished(finished_reason) => match finished_reason { PetitionFactorsStatusFinished::Fail => { let intent_hash = self.intent_hash.clone(); - let invalid_transaction = - InvalidTransactionIfNeglected::new(intent_hash, vec![self.entity.clone()]); - IndexSet::from_iter([invalid_transaction]) + Some(InvalidTransactionIfNeglected::new( + intent_hash, + vec![self.entity.clone()], + )) } - PetitionFactorsStatusFinished::Success => IndexSet::new(), + PetitionFactorsStatusFinished::Success => None, }, - PetitionFactorsStatus::InProgress => IndexSet::new(), + PetitionFactorsStatus::InProgress => None, } } @@ -328,24 +329,17 @@ mod tests { let entity = AddressOfAccountOrPersona::Account(AccountAddress::sample()); let tx = IntentHash::sample_third(); let sut = Sut::new_securified(tx.clone(), entity.clone(), matrix); - let invalid = sut.invalid_transactions_if_neglected_factors(IndexSet::from_iter([ - d0.factor_source_id(), - d1.factor_source_id(), - ])); + let invalid = sut + .invalid_transaction_if_neglected_factors(IndexSet::from_iter([ + d0.factor_source_id(), + d1.factor_source_id(), + ])) + .unwrap(); + + assert_eq!(invalid.clone().intent_hash, tx); assert_eq!( - invalid - .clone() - .into_iter() - .map(|t| t.intent_hash) - .collect_vec(), - vec![tx] - ); - assert_eq!( - invalid - .into_iter() - .flat_map(|t| t.entities_which_would_fail_auth().into_iter().collect_vec()) - .collect_vec(), - vec![entity] + invalid.entities_which_would_fail_auth(), + IndexSet::<_>::from_iter([entity]) ); } @@ -366,10 +360,9 @@ mod tests { let entity = AddressOfAccountOrPersona::Account(AccountAddress::sample()); let tx = IntentHash::sample_third(); let sut = Sut::new_securified(tx.clone(), entity.clone(), matrix); - let invalid = sut.invalid_transactions_if_neglected_factors(IndexSet::from_iter([ - d0.factor_source_id() - ])); - assert!(invalid.is_empty()); + let invalid = sut + .invalid_transaction_if_neglected_factors(IndexSet::from_iter([d0.factor_source_id()])); + assert!(invalid.is_none()); } #[test] @@ -392,24 +385,16 @@ mod tests { let entity = AddressOfAccountOrPersona::Account(AccountAddress::sample()); let tx = IntentHash::sample_third(); let sut = Sut::new_securified(tx.clone(), entity.clone(), matrix); - let invalid = sut.invalid_transactions_if_neglected_factors(IndexSet::from_iter([ - d0.factor_source_id(), - d1.factor_source_id(), - ])); - assert_eq!( - invalid - .clone() - .into_iter() - .map(|t| t.intent_hash) - .collect_vec(), - vec![tx] - ); + let invalid = sut + .invalid_transaction_if_neglected_factors(IndexSet::from_iter([ + d0.factor_source_id(), + d1.factor_source_id(), + ])) + .unwrap(); + assert_eq!(invalid.clone().intent_hash, tx); assert_eq!( - invalid - .into_iter() - .flat_map(|t| t.entities_which_would_fail_auth().into_iter().collect_vec()) - .collect_vec(), - vec![entity] + invalid.entities_which_would_fail_auth(), + IndexSet::<_>::from_iter([entity]) ); } @@ -434,24 +419,14 @@ mod tests { let tx = IntentHash::sample_third(); let sut = Sut::new_securified(tx.clone(), entity.clone(), matrix); - let invalid = sut.invalid_transactions_if_neglected_factors(IndexSet::from_iter([ - d1.factor_source_id() - ])); + let invalid = sut + .invalid_transaction_if_neglected_factors(IndexSet::from_iter([d1.factor_source_id()])) + .unwrap(); + assert_eq!(invalid.clone().intent_hash, tx); assert_eq!( - invalid - .clone() - .into_iter() - .map(|t| t.intent_hash) - .collect_vec(), - vec![tx] - ); - assert_eq!( - invalid - .into_iter() - .flat_map(|t| t.entities_which_would_fail_auth().into_iter().collect_vec()) - .collect_vec(), - vec![entity] + invalid.entities_which_would_fail_auth(), + IndexSet::<_>::from_iter([entity]) ); } @@ -476,11 +451,10 @@ mod tests { let tx = IntentHash::sample_third(); let sut = Sut::new_securified(tx.clone(), entity.clone(), matrix); - let invalid = sut.invalid_transactions_if_neglected_factors(IndexSet::from_iter([ - d1.factor_source_id() - ])); + let invalid = sut + .invalid_transaction_if_neglected_factors(IndexSet::from_iter([d1.factor_source_id()])); - assert!(invalid.is_empty()); + assert!(invalid.is_none()); } #[test] @@ -567,8 +541,8 @@ mod tests { assert!(sut // Already signed with override factor `FactorSourceIDFromHash::fs1()`. Thus // can skip - .invalid_transactions_if_neglected_factors(IndexSet::from_iter([f])) - .is_empty()) + .invalid_transaction_if_neglected_factors(IndexSet::from_iter([f])) + .is_none()) }; can_skip(FactorSourceIDFromHash::fs0()); can_skip(FactorSourceIDFromHash::fs3()); diff --git a/src/signing/petition_types/petition_for_transaction.rs b/src/signing/petition_types/petition_for_transaction.rs index be3ef2a5..cd4d7c8c 100644 --- a/src/signing/petition_types/petition_for_transaction.rs +++ b/src/signing/petition_types/petition_for_transaction.rs @@ -138,8 +138,8 @@ impl PetitionForTransaction { self.for_entities .borrow() .iter() - .flat_map(|(_, petition)| { - petition.invalid_transactions_if_neglected_factors(factor_source_ids.clone()) + .filter_map(|(_, petition)| { + petition.invalid_transaction_if_neglected_factors(factor_source_ids.clone()) }) .collect() } From 33ba1106863a00eae1a5708afd625ec5a6fbec94 Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Thu, 29 Aug 2024 16:51:51 +0200 Subject: [PATCH 7/9] remove Result and unwrap --- src/signing/petition_types/petition_for_entity.rs | 13 +++++-------- .../petition_types/petition_for_transaction.rs | 2 +- 2 files changed, 6 insertions(+), 9 deletions(-) diff --git a/src/signing/petition_types/petition_for_entity.rs b/src/signing/petition_types/petition_for_entity.rs index 8ae42abe..5a368e03 100644 --- a/src/signing/petition_types/petition_for_entity.rs +++ b/src/signing/petition_types/petition_for_entity.rs @@ -204,12 +204,10 @@ impl PetitionForEntity { ) -> PetitionFactorsStatus { let simulation = self.clone(); for factor_source_id in factor_source_ids.iter() { - simulation - .neglect_if_referenced(NeglectedFactor::new( - NeglectFactorReason::Simulation, - *factor_source_id, - )) - .unwrap(); + simulation.neglect_if_referenced(NeglectedFactor::new( + NeglectFactorReason::Simulation, + *factor_source_id, + )) } simulation.status() } @@ -230,9 +228,8 @@ impl PetitionForEntity { ) } - pub fn neglect_if_referenced(&self, neglected: NeglectedFactor) -> Result<()> { + pub fn neglect_if_referenced(&self, neglected: NeglectedFactor) { self.both_void(|p| p.neglect_if_referenced(neglected.clone())); - Ok(()) } pub fn status(&self) -> PetitionFactorsStatus { diff --git a/src/signing/petition_types/petition_for_transaction.rs b/src/signing/petition_types/petition_for_transaction.rs index cd4d7c8c..01c5aa1d 100644 --- a/src/signing/petition_types/petition_for_transaction.rs +++ b/src/signing/petition_types/petition_for_transaction.rs @@ -109,7 +109,7 @@ impl PetitionForTransaction { pub fn neglect_factor_source(&self, neglected: NeglectedFactor) { let mut for_entities = self.for_entities.borrow_mut(); for petition in for_entities.values_mut() { - petition.neglect_if_referenced(neglected.clone()).unwrap() + petition.neglect_if_referenced(neglected.clone()) } } From 7426b330f058e03094a7e32328c0cc53299d12a7 Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Thu, 29 Aug 2024 16:55:20 +0200 Subject: [PATCH 8/9] use 'both' in 'status'. --- .../petition_types/petition_for_entity.rs | 45 ++++++++++--------- 1 file changed, 25 insertions(+), 20 deletions(-) diff --git a/src/signing/petition_types/petition_for_entity.rs b/src/signing/petition_types/petition_for_entity.rs index 5a368e03..a62c382f 100644 --- a/src/signing/petition_types/petition_for_entity.rs +++ b/src/signing/petition_types/petition_for_entity.rs @@ -236,27 +236,32 @@ impl PetitionForEntity { use PetitionFactorsStatus::*; use PetitionFactorsStatusFinished::*; - let maybe_threshold = self.threshold_factors.as_ref().map(|t| t.borrow().status()); - let maybe_override = self.override_factors.as_ref().map(|o| o.borrow().status()); - if let Some(t) = &maybe_threshold { - trace!("Threshold factor status: {:?}", t); - } - if let Some(o) = &maybe_override { - trace!("Override factor status: {:?}", o); - } - match (maybe_threshold, maybe_override) { - (None, None) => panic!("Programmer error! Should have at least one factors list."), - (Some(threshold), None) => threshold, - (None, Some(r#override)) => r#override, - (Some(threshold), Some(r#override)) => match (threshold, r#override) { - (InProgress, InProgress) => PetitionFactorsStatus::InProgress, - (Finished(Fail), InProgress) => PetitionFactorsStatus::InProgress, - (InProgress, Finished(Fail)) => PetitionFactorsStatus::InProgress, - (Finished(Fail), Finished(Fail)) => PetitionFactorsStatus::Finished(Fail), - (Finished(Success), _) => PetitionFactorsStatus::Finished(Success), - (_, Finished(Success)) => PetitionFactorsStatus::Finished(Success), + self.both( + |p| p.status(), + |maybe_threshold, maybe_override| { + if let Some(t) = &maybe_threshold { + trace!("Threshold factor status: {:?}", t); + } + if let Some(o) = &maybe_override { + trace!("Override factor status: {:?}", o); + } + match (maybe_threshold, maybe_override) { + (None, None) => { + panic!("Programmer error! Should have at least one factors list.") + } + (Some(threshold), None) => threshold, + (None, Some(r#override)) => r#override, + (Some(threshold), Some(r#override)) => match (threshold, r#override) { + (InProgress, InProgress) => PetitionFactorsStatus::InProgress, + (Finished(Fail), InProgress) => PetitionFactorsStatus::InProgress, + (InProgress, Finished(Fail)) => PetitionFactorsStatus::InProgress, + (Finished(Fail), Finished(Fail)) => PetitionFactorsStatus::Finished(Fail), + (Finished(Success), _) => PetitionFactorsStatus::Finished(Success), + (_, Finished(Success)) => PetitionFactorsStatus::Finished(Success), + }, + } }, - } + ) } #[allow(unused)] From bea8ef08d97d5c3a6cc9aef254be5abca45e87d1 Mon Sep 17 00:00:00 2001 From: Alexander Cyon Date: Thu, 29 Aug 2024 17:10:15 +0200 Subject: [PATCH 9/9] 'Parallel' -> 'PolyFactor' and 'Serial' -> 'MonoFactor' --- src/derivation/collector/keys_collector.rs | 12 +-- .../keys_collecting_interactors.rs | 14 +-- src/signing/collector/signatures_collector.rs | 32 +++--- .../interactors/batch_signing_response.rs | 2 +- src/signing/interactors/mod.rs | 22 +++-- ...ctor.rs => mono_factor_sign_interactor.rs} | 8 +- ...request.rs => mono_factor_sign_request.rs} | 10 +- .../mono_factor_sign_request_input.rs | 92 +++++++++++++++++ ...ctor.rs => poly_factor_sign_interactor.rs} | 14 +-- ...request.rs => poly_factor_sign_request.rs} | 14 +-- src/signing/interactors/signing_interactor.rs | 14 +-- ...t.rs => transaction_sign_request_input.rs} | 99 +------------------ .../petition_for_transaction.rs | 4 +- src/signing/petition_types/petitions.rs | 6 +- src/testing/derivation/test_keys_collector.rs | 16 +-- .../test_parallel_interactor.rs | 4 +- .../test_serial_interactor.rs | 4 +- .../test_signature_collecting_interactors.rs | 4 +- 18 files changed, 187 insertions(+), 184 deletions(-) rename src/signing/interactors/{sign_with_factor_serial_interactor.rs => mono_factor_sign_interactor.rs} (69%) rename src/signing/interactors/{serial_batch_signing_request.rs => mono_factor_sign_request.rs} (77%) create mode 100644 src/signing/interactors/mono_factor_sign_request_input.rs rename src/signing/interactors/{sign_with_factor_parallel_interactor.rs => poly_factor_sign_interactor.rs} (66%) rename src/signing/interactors/{parallel_batch_signing_request.rs => poly_factor_sign_request.rs} (83%) rename src/signing/interactors/{batch_tx_batch_key_signing_request.rs => transaction_sign_request_input.rs} (52%) diff --git a/src/derivation/collector/keys_collector.rs b/src/derivation/collector/keys_collector.rs index bce5e6ec..1c96de47 100644 --- a/src/derivation/collector/keys_collector.rs +++ b/src/derivation/collector/keys_collector.rs @@ -66,28 +66,28 @@ impl KeysCollector { .interactor_for(factor_sources_of_kind.kind); let factor_sources = factor_sources_of_kind.factor_sources(); match interactor { - KeyDerivationInteractor::Parallel(interactor) => { + KeyDerivationInteractor::PolyFactor(interactor) => { // Prepare the request for the interactor - debug!("Creating parallel request for interactor"); + debug!("Creating poly request for interactor"); let request = self.request_for_parallel_interactor( factor_sources .into_iter() .map(|f| f.factor_source_id()) .collect(), )?; - debug!("Dispatching parallel request to interactor: {:?}", request); + debug!("Dispatching poly request to interactor: {:?}", request); let response = interactor.derive(request).await?; self.process_batch_response(response)?; } - KeyDerivationInteractor::Serial(interactor) => { + KeyDerivationInteractor::MonoFactor(interactor) => { for factor_source in factor_sources { // Prepare the request for the interactor - debug!("Creating serial request for interactor"); + debug!("Creating mono request for interactor"); let request = self.request_for_serial_interactor(&factor_source.factor_source_id())?; - debug!("Dispatching serial request to interactor: {:?}", request); + debug!("Dispatching mono request to interactor: {:?}", request); // Produce the results from the interactor let response = interactor.derive(request).await?; diff --git a/src/derivation/interactors/keys_collecting_interactors.rs b/src/derivation/interactors/keys_collecting_interactors.rs index ca535ba3..2922e519 100644 --- a/src/derivation/interactors/keys_collecting_interactors.rs +++ b/src/derivation/interactors/keys_collecting_interactors.rs @@ -5,19 +5,19 @@ pub trait KeysCollectingInteractors { fn interactor_for(&self, kind: FactorSourceKind) -> KeyDerivationInteractor; } -/// An interactor which can derive keys - either in parallel or serially. +/// An interactor which can derive keys - either in poly or serially. pub enum KeyDerivationInteractor { - Parallel(Arc), - Serial(Arc), + PolyFactor(Arc), + MonoFactor(Arc), } impl KeyDerivationInteractor { - pub fn parallel(interactor: Arc) -> Self { - Self::Parallel(interactor) + pub fn poly(interactor: Arc) -> Self { + Self::PolyFactor(interactor) } - pub fn serial(interactor: Arc) -> Self { - Self::Serial(interactor) + pub fn mono(interactor: Arc) -> Self { + Self::MonoFactor(interactor) } } diff --git a/src/signing/collector/signatures_collector.rs b/src/signing/collector/signatures_collector.rs index cedee799..959b01ca 100644 --- a/src/signing/collector/signatures_collector.rs +++ b/src/signing/collector/signatures_collector.rs @@ -182,10 +182,10 @@ impl SignaturesCollector { .interactor_for(factor_sources_of_kind.kind); let factor_sources = factor_sources_of_kind.factor_sources(); match interactor { - // Parallel Interactor: Many Factor Sources at once - SigningInteractor::Parallel(interactor) => { + // PolyFactor Interactor: Many Factor Sources at once + SigningInteractor::PolyFactor(interactor) => { // Prepare the request for the interactor - debug!("Creating parallel request for interactor"); + debug!("Creating poly request for interactor"); let request = self.request_for_parallel_interactor(factor_sources_of_kind); if !request.invalid_transactions_if_neglected.is_empty() { info!( @@ -194,20 +194,20 @@ impl SignaturesCollector { request.invalid_transactions_if_neglected ) } - debug!("Dispatching parallel request to interactor: {:?}", request); + debug!("Dispatching poly request to interactor: {:?}", request); let response = interactor.sign(request).await; - debug!("Got response from parallel interactor: {:?}", response); + debug!("Got response from poly interactor: {:?}", response); self.process_batch_response(response); } - // Serial Interactor: One Factor Sources at a time + // MonoFactor Interactor: One Factor Sources at a time // After each factor source we pass the result to the collector // updating its internal state so that we state about being able // to skip the next factor source or not. - SigningInteractor::Serial(interactor) => { + SigningInteractor::MonoFactor(interactor) => { for factor_source in factor_sources { // Prepare the request for the interactor - debug!("Creating serial request for interactor"); + debug!("Creating mono request for interactor"); let request = self.request_for_serial_interactor(&factor_source.factor_source_id()); @@ -219,10 +219,10 @@ impl SignaturesCollector { ) } - debug!("Dispatching serial request to interactor: {:?}", request); + debug!("Dispatching mono request to interactor: {:?}", request); // Produce the results from the interactor let response = interactor.sign(request).await; - debug!("Got response from serial interactor: {:?}", response); + debug!("Got response from mono interactor: {:?}", response); // Report the results back to the collector self.process_batch_response(response); @@ -254,7 +254,7 @@ impl SignaturesCollector { fn input_for_interactor( &self, factor_source_id: &FactorSourceIDFromHash, - ) -> BatchTXBatchKeySigningRequest { + ) -> MonoFactorSignRequestInput { self.state .borrow() .petitions @@ -265,10 +265,10 @@ impl SignaturesCollector { fn request_for_serial_interactor( &self, factor_source_id: &FactorSourceIDFromHash, - ) -> SerialBatchSigningRequest { + ) -> MonoFactorSignRequest { let batch_signing_request = self.input_for_interactor(factor_source_id); - SerialBatchSigningRequest::new( + MonoFactorSignRequest::new( batch_signing_request, self.invalid_transactions_if_neglected_factor_sources(IndexSet::from_iter([ *factor_source_id, @@ -281,7 +281,7 @@ impl SignaturesCollector { fn request_for_parallel_interactor( &self, factor_sources_of_kind: &FactorSourcesOfKind, - ) -> ParallelBatchSigningRequest { + ) -> PolyFactorSignRequest { let factor_source_ids = factor_sources_of_kind .factor_sources() .iter() @@ -291,13 +291,13 @@ impl SignaturesCollector { .clone() .iter() .map(|fid| (*fid, self.input_for_interactor(fid))) - .collect::>(); + .collect::>(); let invalid_transactions_if_neglected = self.invalid_transactions_if_neglected_factor_sources(factor_source_ids); // Prepare the request for the interactor - ParallelBatchSigningRequest::new( + PolyFactorSignRequest::new( factor_sources_of_kind.kind, per_factor_source, invalid_transactions_if_neglected, diff --git a/src/signing/interactors/batch_signing_response.rs b/src/signing/interactors/batch_signing_response.rs index 5e202804..9cb298ca 100644 --- a/src/signing/interactors/batch_signing_response.rs +++ b/src/signing/interactors/batch_signing_response.rs @@ -1,6 +1,6 @@ use crate::prelude::*; -/// The response of a batch signing request, either a Parallel or Serial signing +/// The response of a batch signing request, either a PolyFactor or MonoFactor signing /// request, matters not, because the goal is to have signed all transactions with /// enough keys (derivation paths) needed for it to be valid when submitted to the /// Radix network. diff --git a/src/signing/interactors/mod.rs b/src/signing/interactors/mod.rs index ad3bdc90..96bf1395 100644 --- a/src/signing/interactors/mod.rs +++ b/src/signing/interactors/mod.rs @@ -1,17 +1,19 @@ mod batch_signing_response; -mod batch_tx_batch_key_signing_request; -mod parallel_batch_signing_request; -mod serial_batch_signing_request; -mod sign_with_factor_parallel_interactor; -mod sign_with_factor_serial_interactor; +mod mono_factor_sign_interactor; +mod mono_factor_sign_request; +mod mono_factor_sign_request_input; +mod poly_factor_sign_interactor; +mod poly_factor_sign_request; mod signature_collecting_interactors; mod signing_interactor; +mod transaction_sign_request_input; pub use batch_signing_response::*; -pub use batch_tx_batch_key_signing_request::*; -pub use parallel_batch_signing_request::*; -pub use serial_batch_signing_request::*; -pub use sign_with_factor_parallel_interactor::*; -pub use sign_with_factor_serial_interactor::*; +pub use mono_factor_sign_interactor::*; +pub use mono_factor_sign_request::*; +pub use mono_factor_sign_request_input::*; +pub use poly_factor_sign_interactor::*; +pub use poly_factor_sign_request::*; pub use signature_collecting_interactors::*; pub use signing_interactor::*; +pub use transaction_sign_request_input::*; diff --git a/src/signing/interactors/sign_with_factor_serial_interactor.rs b/src/signing/interactors/mono_factor_sign_interactor.rs similarity index 69% rename from src/signing/interactors/sign_with_factor_serial_interactor.rs rename to src/signing/interactors/mono_factor_sign_interactor.rs index 72052aaa..0b6f9e48 100644 --- a/src/signing/interactors/sign_with_factor_serial_interactor.rs +++ b/src/signing/interactors/mono_factor_sign_interactor.rs @@ -10,11 +10,11 @@ use crate::prelude::*; /// The user might chose to SKIP the current factor source, and move on to the /// next one. /// -/// Example of a Serial Batch Signing Driver is SecurityQuestionsFactorSource, -/// where it does not make any sense to let user in parallel answer multiple +/// Example of a MonoFactor Batch Signing Driver is SecurityQuestionsFactorSource, +/// where it does not make any sense to let user in poly answer multiple /// questions from different security questions factor sources (in fact we /// might not even even allow multiple SecurityQuestionsFactorSources to be used). #[async_trait::async_trait] -pub trait SignWithFactorSerialInteractor { - async fn sign(&self, request: SerialBatchSigningRequest) -> SignWithFactorsOutcome; +pub trait MonoFactorSignInteractor { + async fn sign(&self, request: MonoFactorSignRequest) -> SignWithFactorsOutcome; } diff --git a/src/signing/interactors/serial_batch_signing_request.rs b/src/signing/interactors/mono_factor_sign_request.rs similarity index 77% rename from src/signing/interactors/serial_batch_signing_request.rs rename to src/signing/interactors/mono_factor_sign_request.rs index 60968b86..2bd0e1e9 100644 --- a/src/signing/interactors/serial_batch_signing_request.rs +++ b/src/signing/interactors/mono_factor_sign_request.rs @@ -1,21 +1,21 @@ use crate::prelude::*; -/// A batch signing request used with a SignWithFactorSerialInteractor, containing +/// A batch signing request used with a MonoFactorSignInteractor, containing /// a collection of transactions to sign with multiple keys (derivation paths), /// and a collection of transactions which would be invalid if the user skips /// signing with this factor source, or if we fail to sign. #[derive(derive_more::Debug, Clone)] #[debug("input: {:#?}", input)] -pub struct SerialBatchSigningRequest { - pub input: BatchTXBatchKeySigningRequest, +pub struct MonoFactorSignRequest { + pub input: MonoFactorSignRequestInput, /// A collection of transactions which would be invalid if the user skips /// signing with this factor source, or if we fail to sign pub invalid_transactions_if_neglected: IndexSet, } -impl SerialBatchSigningRequest { +impl MonoFactorSignRequest { pub fn new( - input: BatchTXBatchKeySigningRequest, + input: MonoFactorSignRequestInput, invalid_transactions_if_neglected: IndexSet, ) -> Self { Self { diff --git a/src/signing/interactors/mono_factor_sign_request_input.rs b/src/signing/interactors/mono_factor_sign_request_input.rs new file mode 100644 index 00000000..b75237d5 --- /dev/null +++ b/src/signing/interactors/mono_factor_sign_request_input.rs @@ -0,0 +1,92 @@ +use crate::prelude::*; + +/// A batch of transactions each batching over multiple keys (derivation paths) +/// to sign each transaction with. +#[derive(Clone, Debug, PartialEq, Eq, std::hash::Hash)] +pub struct MonoFactorSignRequestInput { + /// The ID of the factor source used to sign each per_transaction + pub factor_source_id: FactorSourceIDFromHash, + + // The `factor_source_id` of each item must match `self.factor_source_id`. + pub per_transaction: Vec, +} + +impl MonoFactorSignRequestInput { + /// # Panics + /// Panics if `per_transaction` is empty + /// + /// Also panics if `per_transaction` if the factor source id + /// of each request does not match `factor_source_id`. + pub fn new( + factor_source_id: FactorSourceIDFromHash, + per_transaction: IndexSet, + ) -> Self { + assert!( + !per_transaction.is_empty(), + "Invalid input. No transaction to sign, this is a programmer error." + ); + + assert!(per_transaction + .iter() + .all(|f| f.factor_source_id == factor_source_id), "Discprepancy! Input for one of the transactions has a mismatching FactorSourceID, this is a programmer error."); + + Self { + factor_source_id, + per_transaction: per_transaction.into_iter().collect(), + } + } + + pub fn factor_source_kind(&self) -> FactorSourceKind { + self.factor_source_id.kind + } +} + +impl HasSampleValues for MonoFactorSignRequestInput { + fn sample() -> Self { + Self::new( + FactorSourceIDFromHash::sample(), + IndexSet::from_iter([TransactionSignRequestInput::sample()]), + ) + } + + fn sample_other() -> Self { + Self::new( + FactorSourceIDFromHash::sample_other(), + IndexSet::from_iter([TransactionSignRequestInput::sample_other()]), + ) + } +} + +#[cfg(test)] +mod tests { + use super::*; + type Sut = MonoFactorSignRequestInput; + + #[test] + fn equality() { + assert_eq!(Sut::sample(), Sut::sample()); + assert_eq!(Sut::sample_other(), Sut::sample_other()); + } + + #[test] + fn inequality() { + assert_ne!(Sut::sample(), Sut::sample_other()); + } + + #[test] + #[should_panic(expected = "Invalid input. No transaction to sign, this is a programmer error.")] + fn panics_if_per_transaction_is_empty() { + Sut::new(FactorSourceIDFromHash::sample(), IndexSet::new()); + } + + #[test] + #[should_panic( + expected = "Discprepancy! Input for one of the transactions has a mismatching FactorSourceID, this is a programmer error." + )] + fn panics_if_factor_source_mismatch() { + Sut::new( + FactorSourceIDFromHash::sample(), + IndexSet::from_iter([TransactionSignRequestInput::sample_other()]), + ); + } +} diff --git a/src/signing/interactors/sign_with_factor_parallel_interactor.rs b/src/signing/interactors/poly_factor_sign_interactor.rs similarity index 66% rename from src/signing/interactors/sign_with_factor_parallel_interactor.rs rename to src/signing/interactors/poly_factor_sign_interactor.rs index bd82d137..11973262 100644 --- a/src/signing/interactors/sign_with_factor_parallel_interactor.rs +++ b/src/signing/interactors/poly_factor_sign_interactor.rs @@ -1,15 +1,15 @@ use crate::prelude::*; /// A interactor for a factor source kind which supports *Batch* usage of -/// multiple factor sources in parallel. +/// multiple factor sources in poly. /// -/// Most FactorSourceKinds does in fact NOT support parallel usage, +/// Most FactorSourceKinds does in fact NOT support poly usage, /// e.g. signing using multiple factors sources at once, but some do, /// typically the DeviceFactorSource does, i.e. we can load multiple /// mnemonics from secure storage in one go and sign with all of them -/// "in parallel". +/// "in poly". /// -/// This is a bit of a misnomer, as we don't actually use them in parallel, +/// This is a bit of a misnomer, as we don't actually use them in poly, /// but rather we iterate through all mnemonics and derive public keys/ /// or sign a payload with each of them in sequence /// @@ -17,8 +17,8 @@ use crate::prelude::*; /// instead either ALL factor sources are used to sign the transactions /// or none. /// -/// Example of a Parallel Batch Signing Driver is that for DeviceFactorSource. +/// Example of a PolyFactor Batch Signing Driver is that for DeviceFactorSource. #[async_trait::async_trait] -pub trait SignWithFactorParallelInteractor { - async fn sign(&self, request: ParallelBatchSigningRequest) -> SignWithFactorsOutcome; +pub trait PolyFactorSignInteractor { + async fn sign(&self, request: PolyFactorSignRequest) -> SignWithFactorsOutcome; } diff --git a/src/signing/interactors/parallel_batch_signing_request.rs b/src/signing/interactors/poly_factor_sign_request.rs similarity index 83% rename from src/signing/interactors/parallel_batch_signing_request.rs rename to src/signing/interactors/poly_factor_sign_request.rs index 852f0c86..24d3d8b1 100644 --- a/src/signing/interactors/parallel_batch_signing_request.rs +++ b/src/signing/interactors/poly_factor_sign_request.rs @@ -1,29 +1,29 @@ use crate::prelude::*; -/// A collection of factor sources to use to sign, transactions with multiple keys +/// A collection of **many** factor sources to use to sign, transactions with multiple keys /// (derivations paths). #[derive(derive_more::Debug, Clone)] #[debug("per_factor_source: {:#?}", per_factor_source)] -pub struct ParallelBatchSigningRequest { +pub struct PolyFactorSignRequest { factor_source_kind: FactorSourceKind, /// Per factor source, a set of transactions to sign, with /// multiple derivations paths. - pub per_factor_source: IndexMap, + pub per_factor_source: IndexMap, /// A collection of transactions which would be invalid if the user skips /// signing with this factor source. pub invalid_transactions_if_neglected: IndexSet, } -impl ParallelBatchSigningRequest { +impl PolyFactorSignRequest { /// # Panics /// Panics if `per_factor_source` is empty /// /// Panics if not all factor sources are of the same kind pub fn new( factor_source_kind: FactorSourceKind, - per_factor_source: IndexMap, + per_factor_source: IndexMap, invalid_transactions_if_neglected: IndexSet, ) -> Self { assert!( @@ -52,7 +52,7 @@ impl ParallelBatchSigningRequest { #[cfg(test)] mod tests { use super::*; - type Sut = ParallelBatchSigningRequest; + type Sut = PolyFactorSignRequest; #[test] #[should_panic( @@ -71,7 +71,7 @@ mod tests { FactorSourceKind::Arculus, IndexMap::from_iter([( FactorSourceIDFromHash::sample(), - BatchTXBatchKeySigningRequest::sample(), + MonoFactorSignRequestInput::sample(), )]), IndexSet::new(), ); diff --git a/src/signing/interactors/signing_interactor.rs b/src/signing/interactors/signing_interactor.rs index 3089558e..8cc947c7 100644 --- a/src/signing/interactors/signing_interactor.rs +++ b/src/signing/interactors/signing_interactor.rs @@ -1,17 +1,17 @@ use crate::prelude::*; -/// An interactor which can sign transactions - either in parallel or serially. +/// An interactor which can sign transactions - either in poly or mono. pub enum SigningInteractor { - Parallel(Arc), - Serial(Arc), + PolyFactor(Arc), + MonoFactor(Arc), } impl SigningInteractor { - pub fn parallel(interactor: Arc) -> Self { - Self::Parallel(interactor) + pub fn poly(interactor: Arc) -> Self { + Self::PolyFactor(interactor) } - pub fn serial(interactor: Arc) -> Self { - Self::Serial(interactor) + pub fn mono(interactor: Arc) -> Self { + Self::MonoFactor(interactor) } } diff --git a/src/signing/interactors/batch_tx_batch_key_signing_request.rs b/src/signing/interactors/transaction_sign_request_input.rs similarity index 52% rename from src/signing/interactors/batch_tx_batch_key_signing_request.rs rename to src/signing/interactors/transaction_sign_request_input.rs index ca965bef..1a5007a5 100644 --- a/src/signing/interactors/batch_tx_batch_key_signing_request.rs +++ b/src/signing/interactors/transaction_sign_request_input.rs @@ -4,7 +4,7 @@ use crate::prelude::*; /// with id `factor_source_id` to sign a single transaction with, which hash /// is `intent_hash`. #[derive(PartialEq, Eq, Clone, Debug, Hash)] -pub struct BatchKeySigningRequest { +pub struct TransactionSignRequestInput { /// Hash to sign intent_hash: IntentHash, @@ -16,7 +16,7 @@ pub struct BatchKeySigningRequest { owned_factor_instances: Vec, } -impl BatchKeySigningRequest { +impl TransactionSignRequestInput { /// # Panics /// Panics if any of the owned factor instances does not match the `factor_source_id`. /// @@ -49,7 +49,7 @@ impl BatchKeySigningRequest { } } -impl HasSampleValues for BatchKeySigningRequest { +impl HasSampleValues for TransactionSignRequestInput { fn sample() -> Self { Self::new( IntentHash::sample(), @@ -71,7 +71,7 @@ impl HasSampleValues for BatchKeySigningRequest { mod tests_batch_req { use super::*; - type Sut = BatchKeySigningRequest; + type Sut = TransactionSignRequestInput; #[test] fn equality() { @@ -106,94 +106,3 @@ mod tests_batch_req { ); } } - -/// A batch of transactions each batching over multiple keys (derivation paths) -/// to sign each transaction with. -#[derive(Clone, Debug, PartialEq, Eq, std::hash::Hash)] -pub struct BatchTXBatchKeySigningRequest { - /// The ID of the factor source used to sign each per_transaction - pub factor_source_id: FactorSourceIDFromHash, - - // The `factor_source_id` of each item must match `self.factor_source_id`. - pub per_transaction: Vec, -} - -impl BatchTXBatchKeySigningRequest { - /// # Panics - /// Panics if `per_transaction` is empty - /// - /// Also panics if `per_transaction` if the factor source id - /// of each request does not match `factor_source_id`. - pub fn new( - factor_source_id: FactorSourceIDFromHash, - per_transaction: IndexSet, - ) -> Self { - assert!( - !per_transaction.is_empty(), - "Invalid input. No transaction to sign, this is a programmer error." - ); - - assert!(per_transaction - .iter() - .all(|f| f.factor_source_id == factor_source_id), "Discprepancy! Input for one of the transactions has a mismatching FactorSourceID, this is a programmer error."); - - Self { - factor_source_id, - per_transaction: per_transaction.into_iter().collect(), - } - } - - pub fn factor_source_kind(&self) -> FactorSourceKind { - self.factor_source_id.kind - } -} - -impl HasSampleValues for BatchTXBatchKeySigningRequest { - fn sample() -> Self { - Self::new( - FactorSourceIDFromHash::sample(), - IndexSet::from_iter([BatchKeySigningRequest::sample()]), - ) - } - - fn sample_other() -> Self { - Self::new( - FactorSourceIDFromHash::sample_other(), - IndexSet::from_iter([BatchKeySigningRequest::sample_other()]), - ) - } -} - -#[cfg(test)] -mod tests { - use super::*; - type Sut = BatchTXBatchKeySigningRequest; - - #[test] - fn equality() { - assert_eq!(Sut::sample(), Sut::sample()); - assert_eq!(Sut::sample_other(), Sut::sample_other()); - } - - #[test] - fn inequality() { - assert_ne!(Sut::sample(), Sut::sample_other()); - } - - #[test] - #[should_panic(expected = "Invalid input. No transaction to sign, this is a programmer error.")] - fn panics_if_per_transaction_is_empty() { - Sut::new(FactorSourceIDFromHash::sample(), IndexSet::new()); - } - - #[test] - #[should_panic( - expected = "Discprepancy! Input for one of the transactions has a mismatching FactorSourceID, this is a programmer error." - )] - fn panics_if_factor_source_mismatch() { - Sut::new( - FactorSourceIDFromHash::sample(), - IndexSet::from_iter([BatchKeySigningRequest::sample_other()]), - ); - } -} diff --git a/src/signing/petition_types/petition_for_transaction.rs b/src/signing/petition_types/petition_for_transaction.rs index 01c5aa1d..c47ef814 100644 --- a/src/signing/petition_types/petition_for_transaction.rs +++ b/src/signing/petition_types/petition_for_transaction.rs @@ -116,11 +116,11 @@ impl PetitionForTransaction { pub(crate) fn input_for_interactor( &self, factor_source_id: &FactorSourceIDFromHash, - ) -> BatchKeySigningRequest { + ) -> TransactionSignRequestInput { assert!(!self .should_neglect_factors_due_to_irrelevant(IndexSet::from_iter([*factor_source_id]))); assert!(!self.has_tx_failed()); - BatchKeySigningRequest::new( + TransactionSignRequestInput::new( self.intent_hash.clone(), *factor_source_id, self.all_relevant_factor_instances_of_source(factor_source_id), diff --git a/src/signing/petition_types/petitions.rs b/src/signing/petition_types/petitions.rs index c94307a6..98c2a4d5 100644 --- a/src/signing/petition_types/petitions.rs +++ b/src/signing/petition_types/petitions.rs @@ -170,7 +170,7 @@ impl Petitions { pub(crate) fn input_for_interactor( &self, factor_source_id: &FactorSourceIDFromHash, - ) -> BatchTXBatchKeySigningRequest { + ) -> MonoFactorSignRequestInput { let intent_hashes = self .factor_source_to_intent_hash .get(factor_source_id) @@ -187,9 +187,9 @@ impl Petitions { Some(petition.input_for_interactor(factor_source_id)) } }) - .collect::>(); + .collect::>(); - BatchTXBatchKeySigningRequest::new(*factor_source_id, per_transaction) + MonoFactorSignRequestInput::new(*factor_source_id, per_transaction) } fn add_signature(&self, signature: &HDSignature) { diff --git a/src/testing/derivation/test_keys_collector.rs b/src/testing/derivation/test_keys_collector.rs index 9651a417..2fd7e4f8 100644 --- a/src/testing/derivation/test_keys_collector.rs +++ b/src/testing/derivation/test_keys_collector.rs @@ -1,17 +1,17 @@ use crate::prelude::*; pub struct TestDerivationInteractors { - pub parallel: Arc, - pub serial: Arc, + pub poly: Arc, + pub mono: Arc, } impl TestDerivationInteractors { pub fn new( - parallel: impl DeriveKeyWithFactorParallelInteractor + Send + Sync + 'static, - serial: impl DeriveKeyWithFactorSerialInteractor + Send + Sync + 'static, + poly: impl DeriveKeyWithFactorParallelInteractor + Send + Sync + 'static, + mono: impl DeriveKeyWithFactorSerialInteractor + Send + Sync + 'static, ) -> Self { Self { - parallel: Arc::new(parallel), - serial: Arc::new(serial), + poly: Arc::new(poly), + mono: Arc::new(mono), } } } @@ -36,8 +36,8 @@ impl Default for TestDerivationInteractors { impl KeysCollectingInteractors for TestDerivationInteractors { fn interactor_for(&self, kind: FactorSourceKind) -> KeyDerivationInteractor { match kind { - FactorSourceKind::Device => KeyDerivationInteractor::parallel(self.parallel.clone()), - _ => KeyDerivationInteractor::serial(self.serial.clone()), + FactorSourceKind::Device => KeyDerivationInteractor::poly(self.poly.clone()), + _ => KeyDerivationInteractor::mono(self.mono.clone()), } } } diff --git a/src/testing/signing/test_interactors/test_parallel_interactor.rs b/src/testing/signing/test_interactors/test_parallel_interactor.rs index 30654383..0b7da061 100644 --- a/src/testing/signing/test_interactors/test_parallel_interactor.rs +++ b/src/testing/signing/test_interactors/test_parallel_interactor.rs @@ -18,8 +18,8 @@ impl IsTestInteractor for TestSigningParallelInteractor { } #[async_trait::async_trait] -impl SignWithFactorParallelInteractor for TestSigningParallelInteractor { - async fn sign(&self, request: ParallelBatchSigningRequest) -> SignWithFactorsOutcome { +impl PolyFactorSignInteractor for TestSigningParallelInteractor { + async fn sign(&self, request: PolyFactorSignRequest) -> SignWithFactorsOutcome { self.simulated_user.spy_on_request_before_handled( request.clone().factor_source_kind(), request.clone().invalid_transactions_if_neglected, diff --git a/src/testing/signing/test_interactors/test_serial_interactor.rs b/src/testing/signing/test_interactors/test_serial_interactor.rs index ac2c7e85..bded3552 100644 --- a/src/testing/signing/test_interactors/test_serial_interactor.rs +++ b/src/testing/signing/test_interactors/test_serial_interactor.rs @@ -18,8 +18,8 @@ impl IsTestInteractor for TestSigningSerialInteractor { } #[async_trait::async_trait] -impl SignWithFactorSerialInteractor for TestSigningSerialInteractor { - async fn sign(&self, request: SerialBatchSigningRequest) -> SignWithFactorsOutcome { +impl MonoFactorSignInteractor for TestSigningSerialInteractor { + async fn sign(&self, request: MonoFactorSignRequest) -> SignWithFactorsOutcome { self.simulated_user.spy_on_request_before_handled( request.clone().factor_source_kind(), request.clone().invalid_transactions_if_neglected, diff --git a/src/testing/signing/test_signature_collecting_interactors.rs b/src/testing/signing/test_signature_collecting_interactors.rs index 082bce4f..379037d9 100644 --- a/src/testing/signing/test_signature_collecting_interactors.rs +++ b/src/testing/signing/test_signature_collecting_interactors.rs @@ -13,10 +13,10 @@ impl TestSignatureCollectingInteractors { impl SignatureCollectingInteractors for TestSignatureCollectingInteractors { fn interactor_for(&self, kind: FactorSourceKind) -> SigningInteractor { match kind { - FactorSourceKind::Device => SigningInteractor::parallel(Arc::new( + FactorSourceKind::Device => SigningInteractor::poly(Arc::new( TestSigningParallelInteractor::new(self.simulated_user.clone()), )), - _ => SigningInteractor::serial(Arc::new(TestSigningSerialInteractor::new( + _ => SigningInteractor::mono(Arc::new(TestSigningSerialInteractor::new( self.simulated_user.clone(), ))), }