1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
use crate::algorithms::crh::pedersen::PedersenCRHParametersGadget;
use snarkos_algorithms::crh::{
BoweHopwoodPedersenCRH,
BoweHopwoodPedersenCompressedCRH,
PedersenSize,
BOWE_HOPWOOD_CHUNK_SIZE,
};
use snarkos_errors::gadgets::SynthesisError;
use snarkos_models::{
curves::{Field, Group, ProjectiveCurve},
gadgets::{
algorithms::CRHGadget,
curves::{CompressedGroupGadget, GroupGadget},
r1cs::ConstraintSystem,
utilities::{
boolean::Boolean,
uint::unsigned_integer::{UInt, UInt8},
},
},
};
use std::marker::PhantomData;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BoweHopwoodPedersenCRHGadget<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<BoweHopwoodPedersenCRH<G, S>, F>
for BoweHopwoodPedersenCRHGadget<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: &[UInt8],
) -> Result<Self::OutputGadget, SynthesisError> {
let mut padded_input_bytes = input.to_vec();
padded_input_bytes.resize(S::WINDOW_SIZE * S::NUM_WINDOWS / 8, UInt8::constant(0u8));
assert_eq!(padded_input_bytes.len() * 8, S::WINDOW_SIZE * S::NUM_WINDOWS);
let mut input_in_bits: Vec<_> = padded_input_bytes
.to_vec()
.into_iter()
.flat_map(|byte| byte.to_bits_le())
.collect();
if (input_in_bits.len()) % BOWE_HOPWOOD_CHUNK_SIZE != 0 {
let current_length = input_in_bits.len();
for _ in 0..(BOWE_HOPWOOD_CHUNK_SIZE - current_length % BOWE_HOPWOOD_CHUNK_SIZE) {
input_in_bits.push(Boolean::constant(false));
}
}
assert!(input_in_bits.len() % BOWE_HOPWOOD_CHUNK_SIZE == 0);
assert_eq!(parameters.parameters.bases.len(), S::NUM_WINDOWS);
for generators in parameters.parameters.bases.iter() {
assert_eq!(generators.len(), S::WINDOW_SIZE);
}
let input_in_bits = input_in_bits
.chunks(S::WINDOW_SIZE * BOWE_HOPWOOD_CHUNK_SIZE)
.map(|x| x.chunks(BOWE_HOPWOOD_CHUNK_SIZE).collect::<Vec<_>>())
.collect::<Vec<_>>();
let result =
GG::precomputed_base_3_bit_signed_digit_scalar_mul(cs, ¶meters.parameters.bases, &input_in_bits)?;
Ok(result)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct BoweHopwoodPedersenCompressedCRHGadget<G: Group + ProjectiveCurve, F: Field, GG: CompressedGroupGadget<G, F>>
{
_group: PhantomData<*const G>,
_group_gadget: PhantomData<*const GG>,
_engine: PhantomData<F>,
}
impl<F: Field, G: Group + ProjectiveCurve, GG: CompressedGroupGadget<G, F>, S: PedersenSize>
CRHGadget<BoweHopwoodPedersenCompressedCRH<G, S>, F> for BoweHopwoodPedersenCompressedCRHGadget<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: &[UInt8],
) -> Result<Self::OutputGadget, SynthesisError> {
let output = BoweHopwoodPedersenCRHGadget::<G, F, GG>::check_evaluation_gadget(cs, parameters, input)?;
Ok(output.to_x_coordinate())
}
}