From 56150eb63dcb2547bd8f2f34b3dacfd28afc362c Mon Sep 17 00:00:00 2001 From: Dam Date: Thu, 2 Oct 2025 17:42:03 +0200 Subject: [PATCH 1/3] Added new functions to try replace the select k indices one. --- .../src/aggregate_signature/basic_verifier.rs | 112 ++++++++++++++++++ 1 file changed, 112 insertions(+) diff --git a/mithril-stm/src/aggregate_signature/basic_verifier.rs b/mithril-stm/src/aggregate_signature/basic_verifier.rs index ab59658650f..76a5a18753c 100644 --- a/mithril-stm/src/aggregate_signature/basic_verifier.rs +++ b/mithril-stm/src/aggregate_signature/basic_verifier.rs @@ -172,6 +172,118 @@ impl BasicVerifier { Err(AggregationError::NotEnoughSignatures(count, params.k)) } + + // Modification of the function select_valid_signatures_for_k_indices + // to try to improve readability + // Still not outputing the same results, more tests need to be done + pub fn modified_select_valid_signatures_for_k_indices( + total_stake: &Stake, + params: &Parameters, + msg: &[u8], + sigs: &[SingleSignatureWithRegisteredParty], + ) -> Result, AggregationError> { + + let (idx_by_mtidx, btm) = Self::get_k_indices( + total_stake, + params, + msg, + sigs, + ); + + let vec_single_sig = Self::valid_signatures_from_k_indices( + ¶ms, + idx_by_mtidx, + btm, + ); + vec_single_sig + } + + + // Get a set of k unique indices connected to indices in the MT + // Also creates a more explicit link between MT index and signature to reuse later + pub fn get_k_indices<'a>( + total_stake: &Stake, + params: &Parameters, + msg: &[u8], + sigs: &'a [SingleSignatureWithRegisteredParty], + ) -> (HashMap, BTreeMap) { + let mut sig_by_mt_index: BTreeMap = + BTreeMap::new(); + let mut indices_by_mt_idx: HashMap = HashMap::new(); + + for sig_reg in sigs.iter() { + if sig_reg + .sig + .basic_verify( + params, + &sig_reg.reg_party.0, + &sig_reg.reg_party.1, + msg, + total_stake, + ) + .is_err() + { + continue; + } + for index in sig_reg.sig.indexes.iter() { + if let Some(mt_idx) = indices_by_mt_idx.get(index) { + if let Some(prev_sig) = sig_by_mt_index.get(mt_idx) { + if prev_sig.sig.sigma < sig_reg.sig.sigma { + continue + } else { + indices_by_mt_idx.insert(*index, sig_reg.sig.signer_index); + sig_by_mt_index.insert(sig_reg.sig.signer_index, &sig_reg); + } + } + } else { + if (indices_by_mt_idx.len() as u64) < params.k { + indices_by_mt_idx.insert(*index, sig_reg.sig.signer_index); + sig_by_mt_index.insert(sig_reg.sig.signer_index, &sig_reg); + } + } + } + } + (indices_by_mt_idx, sig_by_mt_index) + } + + // From a set of k unique indices together with Merkle Tree indices + // Creates a vector of signatures with correct indices + pub fn valid_signatures_from_k_indices( + params: &Parameters, + list_k_valid_indices: HashMap, + sig_by_mt_index: BTreeMap, + ) -> Result, AggregationError> { + + let mut valid_idx_for_mt_idx: HashMap> = HashMap::new(); + + for (&valid_idx, &mt_id) in list_k_valid_indices.iter() { + if let Some(val) = valid_idx_for_mt_idx.get_mut(&mt_id) { + val.push(valid_idx); + } else { + valid_idx_for_mt_idx.insert(mt_id, vec![valid_idx]); + } + } + let mut uniques_sig: Vec = Vec::new(); + let mut count_idx = 0; + for (mt_idx, indices) in valid_idx_for_mt_idx.into_iter() { + let mut single_sig = if let Some(sig) = sig_by_mt_index.get(&mt_idx) { + (*sig).clone() + } else { + // Change the error + return Err(AggregationError::NotEnoughSignatures(0, params.k)); + }; + count_idx += indices.len() as u64; + single_sig.sig.indexes = indices; + uniques_sig.push(single_sig); + + } + + if count_idx >= params.k { + return Ok(uniques_sig); + } + Err(AggregationError::NotEnoughSignatures(count_idx, params.k)) + } + /// Given a slice of `sig_reg_list`, this function returns a new list of `sig_reg_list` with only valid indices. /// In case of conflict (having several signatures for the same index) /// it selects the smallest signature (i.e. takes the signature with the smallest scalar). From 815428b6122d4dc478c2e3a86b66d608c634b5e6 Mon Sep 17 00:00:00 2001 From: Dam Date: Thu, 2 Oct 2025 18:12:06 +0200 Subject: [PATCH 2/3] Corrected format in new functions. --- .../src/aggregate_signature/basic_verifier.rs | 37 ++++++------------- 1 file changed, 12 insertions(+), 25 deletions(-) diff --git a/mithril-stm/src/aggregate_signature/basic_verifier.rs b/mithril-stm/src/aggregate_signature/basic_verifier.rs index 76a5a18753c..e74ba21ac48 100644 --- a/mithril-stm/src/aggregate_signature/basic_verifier.rs +++ b/mithril-stm/src/aggregate_signature/basic_verifier.rs @@ -172,7 +172,6 @@ impl BasicVerifier { Err(AggregationError::NotEnoughSignatures(count, params.k)) } - // Modification of the function select_valid_signatures_for_k_indices // to try to improve readability // Still not outputing the same results, more tests need to be done @@ -182,23 +181,11 @@ impl BasicVerifier { msg: &[u8], sigs: &[SingleSignatureWithRegisteredParty], ) -> Result, AggregationError> { + let (idx_by_mtidx, btm) = Self::get_k_indices(total_stake, params, msg, sigs); - let (idx_by_mtidx, btm) = Self::get_k_indices( - total_stake, - params, - msg, - sigs, - ); - - let vec_single_sig = Self::valid_signatures_from_k_indices( - ¶ms, - idx_by_mtidx, - btm, - ); - vec_single_sig + Self::valid_signatures_from_k_indices(¶ms, idx_by_mtidx, btm) } - // Get a set of k unique indices connected to indices in the MT // Also creates a more explicit link between MT index and signature to reuse later pub fn get_k_indices<'a>( @@ -206,7 +193,10 @@ impl BasicVerifier { params: &Parameters, msg: &[u8], sigs: &'a [SingleSignatureWithRegisteredParty], - ) -> (HashMap, BTreeMap) { + ) -> ( + HashMap, + BTreeMap, + ) { let mut sig_by_mt_index: BTreeMap = BTreeMap::new(); let mut indices_by_mt_idx: HashMap = HashMap::new(); @@ -229,17 +219,16 @@ impl BasicVerifier { if let Some(mt_idx) = indices_by_mt_idx.get(index) { if let Some(prev_sig) = sig_by_mt_index.get(mt_idx) { if prev_sig.sig.sigma < sig_reg.sig.sigma { - continue + continue; } else { indices_by_mt_idx.insert(*index, sig_reg.sig.signer_index); sig_by_mt_index.insert(sig_reg.sig.signer_index, &sig_reg); } } - } else { - if (indices_by_mt_idx.len() as u64) < params.k { - indices_by_mt_idx.insert(*index, sig_reg.sig.signer_index); - sig_by_mt_index.insert(sig_reg.sig.signer_index, &sig_reg); - } + } else if (indices_by_mt_idx.len() as u64) < params.k { + // Should we test for k indices here? + indices_by_mt_idx.insert(*index, sig_reg.sig.signer_index); + sig_by_mt_index.insert(sig_reg.sig.signer_index, &sig_reg); } } } @@ -253,7 +242,6 @@ impl BasicVerifier { list_k_valid_indices: HashMap, sig_by_mt_index: BTreeMap, ) -> Result, AggregationError> { - let mut valid_idx_for_mt_idx: HashMap> = HashMap::new(); for (&valid_idx, &mt_id) in list_k_valid_indices.iter() { @@ -275,8 +263,7 @@ impl BasicVerifier { count_idx += indices.len() as u64; single_sig.sig.indexes = indices; uniques_sig.push(single_sig); - - } + } if count_idx >= params.k { return Ok(uniques_sig); From 55c8b6c2b1ba3da5edafeb54cbbd9250a0db9fef Mon Sep 17 00:00:00 2001 From: Dam Date: Thu, 2 Oct 2025 18:46:04 +0200 Subject: [PATCH 3/3] Fixed double references. --- mithril-stm/src/aggregate_signature/basic_verifier.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mithril-stm/src/aggregate_signature/basic_verifier.rs b/mithril-stm/src/aggregate_signature/basic_verifier.rs index e74ba21ac48..f68707475c4 100644 --- a/mithril-stm/src/aggregate_signature/basic_verifier.rs +++ b/mithril-stm/src/aggregate_signature/basic_verifier.rs @@ -183,7 +183,7 @@ impl BasicVerifier { ) -> Result, AggregationError> { let (idx_by_mtidx, btm) = Self::get_k_indices(total_stake, params, msg, sigs); - Self::valid_signatures_from_k_indices(¶ms, idx_by_mtidx, btm) + Self::valid_signatures_from_k_indices(params, idx_by_mtidx, btm) } // Get a set of k unique indices connected to indices in the MT @@ -222,13 +222,13 @@ impl BasicVerifier { continue; } else { indices_by_mt_idx.insert(*index, sig_reg.sig.signer_index); - sig_by_mt_index.insert(sig_reg.sig.signer_index, &sig_reg); + sig_by_mt_index.insert(sig_reg.sig.signer_index, sig_reg); } } } else if (indices_by_mt_idx.len() as u64) < params.k { // Should we test for k indices here? indices_by_mt_idx.insert(*index, sig_reg.sig.signer_index); - sig_by_mt_index.insert(sig_reg.sig.signer_index, &sig_reg); + sig_by_mt_index.insert(sig_reg.sig.signer_index, sig_reg); } } }