use crate::traits::{
algorithms::{CRHGadget, MaskedCRHGadget},
curves::{CompressedGroupGadget, GroupGadget},
utilities::{
alloc::AllocGadget,
boolean::Boolean,
uint::unsigned_integer::{UInt, UInt8},
},
};
use snarkvm_algorithms::crh::{PedersenCRH, PedersenCRHParameters, PedersenCompressedCRH, PedersenSize};
use snarkvm_curves::traits::{Group, ProjectiveCurve};
use snarkvm_fields::{Field, PrimeField};
use snarkvm_r1cs::{errors::SynthesisError, ConstraintSystem};
use std::{borrow::Borrow, marker::PhantomData};
#[derive(Clone, PartialEq, Eq)]
pub struct PedersenCRHParametersGadget<G: Group, S: PedersenSize, F: Field, GG: GroupGadget<G, F>> {
pub(crate) parameters: PedersenCRHParameters<G, S>,
_group: PhantomData<GG>,
_engine: PhantomData<F>,
}
impl<G: Group, S: PedersenSize, F: Field, GG: GroupGadget<G, F>> AllocGadget<PedersenCRHParameters<G, S>, F>
for PedersenCRHParametersGadget<G, S, F, GG>
{
fn alloc<
Fn: FnOnce() -> Result<T, SynthesisError>,
T: Borrow<PedersenCRHParameters<G, S>>,
CS: ConstraintSystem<F>,
>(
_cs: CS,
value_gen: Fn,
) -> Result<Self, SynthesisError> {
Ok(PedersenCRHParametersGadget {
parameters: value_gen()?.borrow().clone(),
_group: PhantomData,
_engine: PhantomData,
})
}
fn alloc_input<
Fn: FnOnce() -> Result<T, SynthesisError>,
T: Borrow<PedersenCRHParameters<G, S>>,
CS: ConstraintSystem<F>,
>(
_cs: CS,
value_gen: Fn,
) -> Result<Self, SynthesisError> {
Ok(PedersenCRHParametersGadget {
parameters: value_gen()?.borrow().clone(),
_group: PhantomData,
_engine: PhantomData,
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PedersenCRHGadget<G: Group, F: Field, GG: GroupGadget<G, F>> {
_group: PhantomData<*const G>,
_group_gadget: PhantomData<*const GG>,
_engine: PhantomData<F>,
}
impl<F: Field, G: Group, GG: GroupGadget<G, F>, S: PedersenSize> CRHGadget<PedersenCRH<G, S>, F>
for PedersenCRHGadget<G, F, GG>
{
type OutputGadget = GG;
type ParametersGadget = PedersenCRHParametersGadget<G, S, F, GG>;
fn check_evaluation_gadget<CS: ConstraintSystem<F>>(
cs: CS,
parameters: &Self::ParametersGadget,
input: Vec<UInt8>,
) -> Result<Self::OutputGadget, SynthesisError> {
assert_eq!(parameters.parameters.bases.len(), S::NUM_WINDOWS);
let input_in_bits = pad_input_and_bitify::<S>(input);
Ok(GG::precomputed_base_multiscalar_mul(
cs,
¶meters.parameters.bases,
input_in_bits.chunks(S::WINDOW_SIZE),
)?)
}
}
fn pad_input_and_bitify<S: PedersenSize>(input: Vec<UInt8>) -> Vec<Boolean> {
let mut padded_input = input;
padded_input.resize(S::WINDOW_SIZE * S::NUM_WINDOWS / 8, UInt8::constant(0u8));
assert_eq!(padded_input.len() * 8, S::WINDOW_SIZE * S::NUM_WINDOWS);
padded_input.into_iter().flat_map(|byte| byte.to_bits_le()).collect()
}
impl<F: PrimeField, G: Group, GG: GroupGadget<G, F>, S: PedersenSize> MaskedCRHGadget<PedersenCRH<G, S>, F>
for PedersenCRHGadget<G, F, GG>
{
fn check_evaluation_gadget_masked<CS: ConstraintSystem<F>>(
mut cs: CS,
parameters: &Self::ParametersGadget,
input: Vec<UInt8>,
mask_parameters: &Self::ParametersGadget,
mask: Vec<UInt8>,
) -> Result<Self::OutputGadget, SynthesisError> {
if input.len() != mask.len() * 2 {
return Err(SynthesisError::Unsatisfiable);
}
let mask = <Self as MaskedCRHGadget<PedersenCRH<G, S>, F>>::extend_mask(cs.ns(|| "extend mask"), &mask)?;
let mask_hash = Self::check_evaluation_gadget(cs.ns(|| "evaluate mask"), parameters, mask.clone())?;
let mask_input_in_bits = pad_input_and_bitify::<S>(mask.clone());
let mask_symmetric_hash = GG::precomputed_base_symmetric_multiscalar_mul(
cs.ns(|| "evaluate mask with mask bases"),
&mask_parameters.parameters.bases,
mask_input_in_bits.chunks(S::WINDOW_SIZE),
)?;
assert_eq!(parameters.parameters.bases.len(), S::NUM_WINDOWS);
let input_in_bits = pad_input_and_bitify::<S>(input);
let mask_in_bits = pad_input_and_bitify::<S>(mask);
let masked_output = GG::precomputed_base_multiscalar_mul_masked(
cs.ns(|| "multiscalar multiplication"),
¶meters.parameters.bases,
input_in_bits.chunks(S::WINDOW_SIZE),
&mask_parameters.parameters.bases,
mask_in_bits.chunks(S::WINDOW_SIZE),
)?;
masked_output
.add(cs.ns(|| "remove mask"), &mask_hash)?
.add(cs.ns(|| "remove mask with mask bases"), &mask_symmetric_hash)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct PedersenCompressedCRHGadget<G: Group + ProjectiveCurve, F: Field, GG: CompressedGroupGadget<G, F>> {
_group: PhantomData<fn() -> G>,
_group_gadget: PhantomData<fn() -> GG>,
_engine: PhantomData<F>,
}
impl<F: Field, G: Group + ProjectiveCurve, GG: CompressedGroupGadget<G, F>, S: PedersenSize>
CRHGadget<PedersenCompressedCRH<G, S>, F> for PedersenCompressedCRHGadget<G, F, GG>
{
type OutputGadget = GG::BaseFieldGadget;
type ParametersGadget = PedersenCRHParametersGadget<G, S, F, GG>;
fn check_evaluation_gadget<CS: ConstraintSystem<F>>(
cs: CS,
parameters: &Self::ParametersGadget,
input: Vec<UInt8>,
) -> Result<Self::OutputGadget, SynthesisError> {
let output = PedersenCRHGadget::<G, F, GG>::check_evaluation_gadget(cs, parameters, input)?;
Ok(output.to_x_coordinate())
}
}
impl<F: PrimeField, G: Group + ProjectiveCurve, GG: CompressedGroupGadget<G, F>, S: PedersenSize>
MaskedCRHGadget<PedersenCompressedCRH<G, S>, F> for PedersenCompressedCRHGadget<G, F, GG>
{
fn check_evaluation_gadget_masked<CS: ConstraintSystem<F>>(
cs: CS,
parameters: &Self::ParametersGadget,
input: Vec<UInt8>,
mask_parameters: &Self::ParametersGadget,
mask: Vec<UInt8>,
) -> Result<Self::OutputGadget, SynthesisError> {
let output = PedersenCRHGadget::<G, F, GG>::check_evaluation_gadget_masked(
cs,
parameters,
input,
mask_parameters,
mask,
)?;
Ok(output.to_x_coordinate())
}
}