1use crate::{
10 gadgets::{from_emulated_field, EmulatedVariable, EmulationConfig, SerializableEmulatedStruct},
11 BoolVar, Circuit, CircuitError, PlonkCircuit,
12};
13use ark_ec::short_weierstrass::{Affine, SWCurveConfig};
14use ark_ff::PrimeField;
15use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
16use ark_std::{vec, vec::Vec};
17
18#[derive(Debug, Eq, PartialEq, Copy, Clone, CanonicalSerialize, CanonicalDeserialize)]
20pub struct SWPoint<F: PrimeField>(pub F, pub F, pub bool);
21
22impl<F: PrimeField> Default for SWPoint<F> {
23 fn default() -> Self {
24 Self(F::zero(), F::zero(), true)
25 }
26}
27
28impl<F, P> From<Affine<P>> for SWPoint<F>
29where
30 F: PrimeField,
31 P: SWCurveConfig<BaseField = F>,
32{
33 fn from(p: Affine<P>) -> Self {
34 SWPoint(p.x, p.y, p.infinity)
35 }
36}
37
38impl<E, F> SerializableEmulatedStruct<F> for SWPoint<E>
39where
40 E: EmulationConfig<F>,
41 F: PrimeField,
42{
43 fn serialize_to_native_elements(&self) -> Vec<F> {
44 let mut result = from_emulated_field(self.0);
45 result.extend(from_emulated_field(self.1));
46 result.push(if self.2 { F::one() } else { F::zero() });
47 result
48 }
49}
50
51#[derive(Debug, Clone)]
53pub struct EmulatedSWPointVariable<E: PrimeField>(
54 pub EmulatedVariable<E>,
55 pub EmulatedVariable<E>,
56 pub BoolVar,
57);
58
59impl<F: PrimeField> PlonkCircuit<F> {
60 pub fn emulated_sw_point_witness<E: EmulationConfig<F>>(
62 &self,
63 point_var: &EmulatedSWPointVariable<E>,
64 ) -> Result<SWPoint<E>, CircuitError> {
65 let x = self.emulated_witness(&point_var.0)?;
66 let y = self.emulated_witness(&point_var.1)?;
67 let infinity = self.witness(point_var.2 .0)? == F::one();
68 Ok(SWPoint(x, y, infinity))
69 }
70
71 pub fn create_emulated_sw_point_variable<E: EmulationConfig<F>>(
73 &mut self,
74 point: SWPoint<E>,
75 ) -> Result<EmulatedSWPointVariable<E>, CircuitError> {
76 let x = self.create_emulated_variable(point.0)?;
77 let y = self.create_emulated_variable(point.1)?;
78 let infinity = self.create_boolean_variable(point.2)?;
79 Ok(EmulatedSWPointVariable(x, y, infinity))
80 }
81
82 pub fn create_constant_emulated_sw_point_variable<E: EmulationConfig<F>>(
84 &mut self,
85 point: SWPoint<E>,
86 ) -> Result<EmulatedSWPointVariable<E>, CircuitError> {
87 let x = self.create_constant_emulated_variable(point.0)?;
88 let y = self.create_constant_emulated_variable(point.1)?;
89 let infinity = BoolVar(if point.2 { self.one() } else { self.zero() });
90 Ok(EmulatedSWPointVariable(x, y, infinity))
91 }
92
93 pub fn create_public_emulated_sw_point_variable<E: EmulationConfig<F>>(
95 &mut self,
96 point: SWPoint<E>,
97 ) -> Result<EmulatedSWPointVariable<E>, CircuitError> {
98 let x = self.create_public_emulated_variable(point.0)?;
99 let y = self.create_public_emulated_variable(point.1)?;
100 let infinity = self.create_public_boolean_variable(point.2)?;
101 Ok(EmulatedSWPointVariable(x, y, infinity))
102 }
103
104 pub fn binary_emulated_sw_point_vars_select<E: EmulationConfig<F>>(
109 &mut self,
110 b: BoolVar,
111 p0: &EmulatedSWPointVariable<E>,
112 p1: &EmulatedSWPointVariable<E>,
113 ) -> Result<EmulatedSWPointVariable<E>, CircuitError> {
114 let select_x = self.conditional_select_emulated(b, &p0.0, &p1.0)?;
115 let select_y = self.conditional_select_emulated(b, &p0.1, &p1.1)?;
116 let select_infinity = BoolVar(self.conditional_select(b, p0.2 .0, p1.2 .0)?);
117
118 Ok(EmulatedSWPointVariable::<E>(
119 select_x,
120 select_y,
121 select_infinity,
122 ))
123 }
124
125 pub fn enforce_emulated_sw_point_equal<E: EmulationConfig<F>>(
128 &mut self,
129 p0: &EmulatedSWPointVariable<E>,
130 p1: &EmulatedSWPointVariable<E>,
131 ) -> Result<(), CircuitError> {
132 self.enforce_emulated_var_equal(&p0.0, &p1.0)?;
133 self.enforce_emulated_var_equal(&p0.1, &p1.1)?;
134 self.enforce_equal(p0.2 .0, p1.2 .0)?;
135 Ok(())
136 }
137
138 pub fn is_emulated_sw_point_equal<E: EmulationConfig<F>>(
141 &mut self,
142 p0: &EmulatedSWPointVariable<E>,
143 p1: &EmulatedSWPointVariable<E>,
144 ) -> Result<BoolVar, CircuitError> {
145 let mut r0 = self.is_emulated_var_equal(&p0.0, &p1.0)?;
146 let r1 = self.is_emulated_var_equal(&p0.1, &p1.1)?;
147 let r2 = self.is_equal(p0.2 .0, p1.2 .0)?;
148 r0.0 = self.mul(r0.0, r1.0)?;
149 r0.0 = self.mul(r0.0, r2.0)?;
150 Ok(r0)
151 }
152
153 pub fn emulated_sw_ecc_add_gate<E: EmulationConfig<F>>(
197 &mut self,
198 p0: &EmulatedSWPointVariable<E>,
199 p1: &EmulatedSWPointVariable<E>,
200 p2: &EmulatedSWPointVariable<E>,
201 a: E,
202 ) -> Result<(), CircuitError> {
203 let eq_p1_p2 = self.is_emulated_sw_point_equal(p1, p2)?;
204 let eq_p0_p2 = self.is_emulated_sw_point_equal(p0, p2)?;
205 self.enforce_equal(p0.2 .0, eq_p1_p2.0)?;
207 self.enforce_equal(p1.2 .0, eq_p0_p2.0)?;
208
209 let infinity_mark = self.logic_or(p0.2, p1.2)?;
211 let non_infinity_mark = self.logic_neg(infinity_mark)?;
213
214 let non_inf_p2 = self.logic_neg(p2.2)?;
218 let eq_x0_x1 = self.is_emulated_var_equal(&p0.0, &p1.0)?;
219 let neq_x0_x1 = self.logic_neg(eq_x0_x1)?;
220 let eq_y0_y1 = self.is_emulated_var_equal(&p0.1, &p1.1)?;
221 let is_y0_zero = self.is_emulated_var_zero(&p0.1)?;
222 let not_y0_zero = self.logic_neg(is_y0_zero)?;
223 let t = self.logic_and(eq_y0_y1, not_y0_zero)?;
224 let t = self.logic_or(neq_x0_x1, t)?;
225 let t = self.logic_or(non_inf_p2, t)?;
226 self.logic_or_gate(infinity_mark, t)?;
227
228 let doubling_mark = self.mul(eq_x0_x1.0, eq_y0_y1.0)?;
231 let doubling_coef = self.mul(doubling_mark, non_infinity_mark.0)?;
232 let doubling_coef = self.mul(doubling_coef, not_y0_zero.0)?;
233 let mut v = vec![self.zero(); E::NUM_LIMBS];
236 v[0] = doubling_coef;
237 let doubling_coef = EmulatedVariable::<E>(v, core::marker::PhantomData);
238
239 let y0_times_2 = self.emulated_add(&p0.1, &p0.1)?;
241 let x0_plus_x1 = self.emulated_add(&p0.0, &p1.0)?;
242 let x0_plus_x1_plus_x2 = self.emulated_add(&p2.0, &x0_plus_x1)?;
243 let lhs = self.emulated_mul(&x0_plus_x1_plus_x2, &y0_times_2)?;
244 let lhs = self.emulated_mul(&lhs, &y0_times_2)?;
245 let s = self.emulated_mul(&p0.0, &p0.0)?;
247 let s = self.emulated_mul_constant(&s, E::from(3u64))?;
248 let s = self.emulated_add_constant(&s, a)?;
249 let rhs = self.emulated_mul(&s, &s)?;
250
251 let lhs = self.emulated_mul(&lhs, &doubling_coef)?;
252 let rhs = self.emulated_mul(&rhs, &doubling_coef)?;
253 self.enforce_emulated_var_equal(&lhs, &rhs)?;
254
255 let y2_plus_y0 = self.emulated_add(&p2.1, &p0.1)?;
257 let lhs = self.emulated_mul(&y2_plus_y0, &y0_times_2)?;
258 let x0_minus_x2 = self.emulated_sub(&p0.0, &p2.0)?;
259 let rhs = self.emulated_mul(&s, &x0_minus_x2)?;
260
261 let lhs = self.emulated_mul(&lhs, &doubling_coef)?;
262 let rhs = self.emulated_mul(&rhs, &doubling_coef)?;
263 self.enforce_emulated_var_equal(&lhs, &rhs)?;
264
265 let coef = self.mul(non_infinity_mark.0, neq_x0_x1.0)?;
267 let mut v = vec![self.zero(); E::NUM_LIMBS];
270 v[0] = coef;
271 let add_coef = EmulatedVariable::<E>(v, core::marker::PhantomData);
272
273 let x0_minus_x1 = self.emulated_sub(&p0.0, &p1.0)?;
275 let lhs = self.emulated_mul(&x0_minus_x1, &x0_minus_x1)?;
276 let lhs = self.emulated_mul(&lhs, &x0_plus_x1_plus_x2)?;
277 let y0_minus_y1 = self.emulated_sub(&p0.1, &p1.1)?;
278 let rhs = self.emulated_mul(&y0_minus_y1, &y0_minus_y1)?;
279
280 let lhs = self.emulated_mul(&lhs, &add_coef)?;
281 let rhs = self.emulated_mul(&rhs, &add_coef)?;
282 self.enforce_emulated_var_equal(&lhs, &rhs)?;
283
284 let lhs = self.emulated_mul(&x0_minus_x2, &y0_minus_y1)?;
286 let y0_plus_y2 = self.emulated_add(&p0.1, &p2.1)?;
287 let rhs = self.emulated_mul(&y0_plus_y2, &x0_minus_x1)?;
288
289 let lhs = self.emulated_mul(&lhs, &add_coef)?;
290 let rhs = self.emulated_mul(&rhs, &add_coef)?;
291 self.enforce_emulated_var_equal(&lhs, &rhs)?;
292
293 Ok(())
294 }
295
296 pub fn emulated_sw_ecc_add<E: EmulationConfig<F>>(
298 &mut self,
299 p0: &EmulatedSWPointVariable<E>,
300 p1: &EmulatedSWPointVariable<E>,
301 a: E,
302 ) -> Result<EmulatedSWPointVariable<E>, CircuitError> {
303 let x0 = self.emulated_witness(&p0.0)?;
304 let y0 = self.emulated_witness(&p0.1)?;
305 let infinity0 = self.witness(p0.2 .0)? == F::one();
306 let x1 = self.emulated_witness(&p1.0)?;
307 let y1 = self.emulated_witness(&p1.1)?;
308 let infinity1 = self.witness(p1.2 .0)? == F::one();
309 let p2 = if infinity0 {
310 SWPoint(x1, y1, infinity1)
311 } else if infinity1 {
312 SWPoint(x0, y0, infinity0)
313 } else if x0 == x1 && y0 == y1 {
314 if y0.is_zero() {
316 SWPoint(E::zero(), E::zero(), true)
317 } else {
318 let s = (x0 * x0 * E::from(3u64) + a) / (y0 + y0);
319 let x2 = s * s - x0 - x1;
320 let y2 = s * (x0 - x2) - y0;
321 SWPoint(x2, y2, false)
322 }
323 } else {
324 if x0 == x1 {
326 SWPoint(E::zero(), E::zero(), true)
327 } else {
328 let s = (y0 - y1) / (x0 - x1);
329 let x2 = s * s - x0 - x1;
330 let y2 = s * (x0 - x2) - y0;
331 SWPoint(x2, y2, false)
332 }
333 };
334 let p2 = self.create_emulated_sw_point_variable(p2)?;
335 self.emulated_sw_ecc_add_gate(p0, p1, &p2, a)?;
336 Ok(p2)
337 }
338}
339
340#[cfg(test)]
341mod tests {
342 use crate::{
343 gadgets::{ecc::conversion::*, EmulationConfig, SerializableEmulatedStruct},
344 Circuit, CircuitError, PlonkCircuit,
345 };
346 use ark_bls12_377::{g1::Config as Param377, Fq as Fq377};
347 use ark_bn254::{g1::Config as Param254, Fq as Fq254, Fr as Fr254};
348 use ark_ec::{
349 short_weierstrass::{Projective, SWCurveConfig},
350 CurveGroup, PrimeGroup,
351 };
352 use ark_ff::{MontFp, PrimeField};
353 use ark_std::{UniformRand, Zero};
354
355 use super::{EmulatedSWPointVariable, SWPoint};
356
357 #[test]
358 fn test_emulated_sw_point_addition() {
359 let a: Fq377 = MontFp!("0");
360 test_emulated_sw_point_addition_helper::<Fq377, Fr254, Param377>(a);
361 let a: Fq254 = MontFp!("0");
362 test_emulated_sw_point_addition_helper::<Fq254, Fr254, Param254>(a);
363 }
364
365 fn ecc_add_and_check<E, F>(
366 circuit: &mut PlonkCircuit<F>,
367 p0: &EmulatedSWPointVariable<E>,
368 p1: &EmulatedSWPointVariable<E>,
369 a: E,
370 expected: &SWPoint<E>,
371 ) -> Result<EmulatedSWPointVariable<E>, CircuitError>
372 where
373 E: EmulationConfig<F> + SWToTEConParam,
374 F: PrimeField,
375 {
376 let result = circuit.emulated_sw_ecc_add(p0, p1, a)?;
377 assert_eq!(circuit.emulated_sw_point_witness(&result)?, *expected);
378 Ok(result)
379 }
380
381 fn test_emulated_sw_point_addition_helper<E, F, P>(a: E)
382 where
383 E: EmulationConfig<F> + SWToTEConParam,
384 F: PrimeField,
385 P: SWCurveConfig<BaseField = E>,
386 {
387 let mut rng = jf_utils::test_rng();
388 let neutral = Projective::<P>::zero().into_affine();
389 let p1 = Projective::<P>::rand(&mut rng).into_affine();
390 let p2 = Projective::<P>::rand(&mut rng).into_affine();
391 let expected = (p1 + p2).into_affine().into();
392 let wrong_result = (p1 + p2 + Projective::<P>::generator())
393 .into_affine()
394 .into();
395
396 let mut circuit = PlonkCircuit::<F>::new_ultra_plonk(20);
397
398 let var_p1 = circuit
399 .create_public_emulated_sw_point_variable(p1.into())
400 .unwrap();
401 let var_p2 = circuit
402 .create_emulated_sw_point_variable(p2.into())
403 .unwrap();
404 let var_neutral = circuit
405 .create_emulated_sw_point_variable(neutral.into())
406 .unwrap();
407 ecc_add_and_check::<E, F>(&mut circuit, &var_p1, &var_p2, a, &expected).unwrap();
408 ecc_add_and_check::<E, F>(&mut circuit, &var_p1, &var_neutral, a, &p1.into()).unwrap();
409 ecc_add_and_check::<E, F>(&mut circuit, &var_neutral, &var_p2, a, &p2.into()).unwrap();
410
411 let double_p1 = (p1 + p1).into_affine().into();
413 ecc_add_and_check::<E, F>(&mut circuit, &var_p1, &var_p1, a, &double_p1).unwrap();
414 ecc_add_and_check::<E, F>(&mut circuit, &var_neutral, &var_neutral, a, &neutral.into())
415 .unwrap();
416
417 let public_inputs: SWPoint<E> = p1.into();
418 let public_inputs = public_inputs.serialize_to_native_elements();
419 let wrong_inputs: SWPoint<E> = neutral.into();
420 let wrong_inputs = wrong_inputs.serialize_to_native_elements();
421 assert!(circuit.check_circuit_satisfiability(&public_inputs).is_ok());
422 assert!(circuit.check_circuit_satisfiability(&wrong_inputs).is_err());
423
424 let var_wrong_result = circuit
426 .create_emulated_sw_point_variable(wrong_result)
427 .unwrap();
428 circuit
429 .emulated_sw_ecc_add_gate(&var_p1, &var_p2, &var_wrong_result, a)
430 .unwrap();
431 assert!(circuit
432 .check_circuit_satisfiability(&public_inputs)
433 .is_err());
434 }
435}