Method verify

smc_range_proof/src/ccs_range_proof/kv_arbitrary_range.rs:214–270

Verify the proof for `min <= value < max` where `commitment` is a Pedersen commitment to `value`

(
        &self,
        commitment: &G,
        challenge: &G::ScalarField,
        min: u64,
        max: u64,
        comm_key: &MemberCommitmentKey<G>,
        params: &SetMembershipCheckParamsKV<

impl<G: AffineRepr> CCSArbitraryRangeWithKVProof<G> {
    /// Verify the proof for `min <= value < max` where `commitment` is a Pedersen commitment to `value`
    pub fn verify(
        &self,
        commitment: &G,
        challenge: &G::ScalarField,
        min: u64,
        max: u64,
        comm_key: &MemberCommitmentKey<G>,
        params: &SetMembershipCheckParamsKV<G>,
        secret_key: &SecretKey<G::ScalarField>,
    ) -> Result<(), SmcRangeProofError> {
        params.validate_base(self.base)?;
        let l = find_l_for_arbitrary_range(max, min, self.base) as usize;
        expect_equality!(
            self.pok_sigs_min.len(),
            l,
            SmcRangeProofError::ProofShorterThanExpected
        );
        expect_equality!(
            self.pok_sigs_max.len(),
            l,
            SmcRangeProofError::ProofShorterThanExpected
        );

        let resp_d_min = cfg_iter!(self.pok_sigs_min)
            .map(|p| *p.get_resp_for_message().unwrap())
            .collect::<Vec<_>>();
        let resp_d_max = cfg_iter!(self.pok_sigs_max)
            .map(|p| *p.get_resp_for_message().unwrap())
            .collect::<Vec<_>>();
        check_commitment_for_arbitrary_range::<G>(
            self.base,
            &resp_d_min,
            &resp_d_max,
            &self.resp_r_min,
            &self.resp_r_max,
            &self.D_min,
            &self.D_max,
            min,
            max,
            commitment,
            challenge,
            comm_key,
        )?;
        let results = cfg_iter!(self.pok_sigs_min)
            .chain(cfg_iter!(self.pok_sigs_max))
            .map(|p| {
                if let Err(e) = p.verify(challenge, secret_key, &params.bb_sig_params) {
                    return Err(SmcRangeProofError::ShortGroupSig(e));
                }
                Ok(())
            })
            .collect::<Vec<_>>();
        for r in results {
            r?;
        }
        Ok(())
    }