Method new

bulletproofs_plus_plus/src/weighted_norm_linear_argument.rs:26–188

Create new argument

(
        mut l: Vec<G::ScalarField>,
        mut n: Vec<G::ScalarField>,
        mut c: Vec<G::ScalarField>,
        mut rho: G::ScalarField,
        setup_params: SetupParams<G>,
        transcript:

impl<G: AffineRepr> WeightedNormLinearArgument<G> {
    /// Create new argument
    pub fn new(
        mut l: Vec<G::ScalarField>,
        mut n: Vec<G::ScalarField>,
        mut c: Vec<G::ScalarField>,
        mut rho: G::ScalarField,
        setup_params: SetupParams<G>,
        transcript: &mut impl Transcript,
    ) -> Result<Self, BulletproofsPlusPlusError> {
        let SetupParams {
            G: g,
            G_vec: mut g_vec,
            H_vec: mut h_vec,
        } = setup_params;
        if l.len() != c.len() {
            return Err(BulletproofsPlusPlusError::UnexpectedLengthOfVectors(
                format!(
                    "length of l={} not equal to length of c={}",
                    l.len(),
                    c.len()
                ),
            ));
        }
        if c.len() != h_vec.len() {
            return Err(BulletproofsPlusPlusError::UnexpectedLengthOfVectors(
                format!(
                    "length of c={} not equal to length of H_vec={}",
                    c.len(),
                    h_vec.len()
                ),
            ));
        }
        if n.len() != g_vec.len() {
            return Err(BulletproofsPlusPlusError::UnexpectedLengthOfVectors(
                format!(
                    "length of n={} not equal to length of G_vec={}",
                    n.len(),
                    g_vec.len()
                ),
            ));
        }
        if !l.len().is_power_of_two() {
            return Err(BulletproofsPlusPlusError::UnexpectedLengthOfVectors(
                format!("length of l={} must be power of 2", l.len()),
            ));
        }
        if !n.len().is_power_of_two() {
            return Err(BulletproofsPlusPlusError::UnexpectedLengthOfVectors(
                format!("length of n={} must be power of 2", n.len()),
            ));
        }

        let mut mu = rho.square();
        let mut X = Vec::new();
        let mut R = Vec::new();

        while l.len() > 1 || n.len() > 1 {
            let (l_0, l_1) = Self::split_vec(&l);
            let (n_0, n_1) = Self::split_vec(&n);