Refactor padding

src/range_proof.rs

@@ -37,7 +37,7 @@ use crate::{
  traits::{Compressable, Decompressable, FixedBytesRepr, Precomputable},
  transcripts::RangeProofTranscript,
  utils::{
- generic::{nonce, split_at_checked},
+ generic::{compute_generator_padding, nonce, split_at_checked},
  nullrng::NullRng,
  },
 };
@@ -331,15 +331,11 @@ where
  Scalar::random_not_zero(range_proof_transcript.as_mut_rng())
  });
  }
- let padding = 2usize
- .checked_mul(statement.generators.bit_length())
- .ok_or(ProofError::SizeOverflow)?
- .checked_mul(statement.generators.aggregation_factor())
- .ok_or(ProofError::SizeOverflow)?
- .checked_sub(a_li.len())
- .ok_or(ProofError::SizeOverflow)?
- .checked_sub(a_ri.len())
- .ok_or(ProofError::SizeOverflow)?;
+ let padding = compute_generator_padding(
+ statement.generators.bit_length(),
+ statement.commitments.len(),
+ statement.generators.aggregation_factor(),
+ )?;
  let a = statement.generators.precomp().vartime_mixed_multiscalar_mul(
  a_li.iter()
  .interleave(a_ri.iter())
@@ -1035,15 +1031,11 @@ where
  dynamic_points.push(h_base.clone());
 
  // Perform the final check using precomputation
- let padding = 2usize
- .checked_mul(max_statement.generators.bit_length())
- .ok_or(ProofError::SizeOverflow)?
- .checked_mul(max_statement.generators.aggregation_factor())
- .ok_or(ProofError::SizeOverflow)?
- .checked_sub(max_mn)
- .ok_or(ProofError::SizeOverflow)?
- .checked_sub(max_mn)
- .ok_or(ProofError::SizeOverflow)?;
+ let padding = compute_generator_padding(
+ max_statement.generators.bit_length(),
+ max_statement.commitments.len(),
+ max_statement.generators.aggregation_factor(),
+ )?;
  if precomp.vartime_mixed_multiscalar_mul(
  gi_base_scalars
  .iter()

src/utils/generic.rs

@@ -68,6 +68,28 @@ pub fn split_at_checked<T>(vec: &[T], n: usize) -> Result<(&[T], &[T]), ProofErr
  }
 }
 
+/// Compute the padding needed for generator vectors
+pub fn compute_generator_padding(
+ bit_length: usize,
+ aggregation_factor: usize,
+ max_aggregation_factor: usize,
+) -> Result<usize, ProofError> {
+ let padded_capacity = 2usize
+ .checked_mul(bit_length)
+ .ok_or(ProofError::SizeOverflow)?
+ .checked_mul(max_aggregation_factor)
+ .ok_or(ProofError::SizeOverflow)?;
+ let actual_capacity = 2usize
+ .checked_mul(bit_length)
+ .ok_or(ProofError::SizeOverflow)?
+ .checked_mul(aggregation_factor)
+ .ok_or(ProofError::SizeOverflow)?;
+
+ padded_capacity
+ .checked_sub(actual_capacity)
+ .ok_or(ProofError::SizeOverflow)
+}
+
 #[cfg(test)]
 mod tests {
  use alloc::{vec, vec::Vec};
@@ -76,10 +98,20 @@ mod tests {
  use rand_chacha::ChaCha12Rng;
  use rand_core::SeedableRng;
 
- use crate::{
- protocols::scalar_protocol::ScalarProtocol,
- utils::generic::{nonce, split_at_checked, BLAKE2B_PERSONA_LIMIT},
- };
+ use crate::{protocols::scalar_protocol::ScalarProtocol, utils::generic::*};
+
+ #[test]
+ fn test_padding() {
+ // No padding
+ assert_eq!(compute_generator_padding(64, 1, 1).unwrap(), 0);
+
+ // Padding
+ assert_eq!(compute_generator_padding(64, 1, 2).unwrap(), 128);
+
+ // Invalid
+ assert!(compute_generator_padding(64, 2, 1).is_err());
+ assert!(compute_generator_padding(64, usize::MAX - 1, usize::MAX).is_err());
+ }
 
  #[test]
  fn test_split() {