1use crate::{
8 gadgets::ecc::{MultiScalarMultiplicationCircuit, PointVariable},
9 BoolVar, Circuit, CircuitError, PlonkCircuit, Variable,
10};
11use ark_ec::{
12 twisted_edwards::{Projective, TECurveConfig},
13 CurveGroup,
14};
15use ark_ff::{PrimeField, Zero};
16use jf_utils::field_switching;
17use num_bigint::{BigInt, BigUint};
18
19use super::TEPoint;
20
21const COEFF_B: [u8; 32] = [
25 180, 16, 37, 23, 77, 1, 15, 238, 214, 244, 154, 13, 119, 18, 167, 46, 136, 26, 81, 99, 58, 13,
26 240, 97, 165, 38, 132, 130, 139, 242, 201, 82,
27];
28
29const COEFF_C: [u8; 32] = [
30 61, 11, 101, 223, 108, 128, 92, 81, 233, 244, 54, 255, 207, 171, 86, 132, 7, 209, 23, 108, 253,
31 110, 124, 169, 195, 87, 84, 134, 207, 36, 198, 108,
32];
33const LAMBDA: [u8; 32] = [
35 5, 223, 131, 135, 64, 33, 61, 209, 110, 5, 165, 112, 185, 157, 196, 207, 43, 199, 56, 43, 86,
36 73, 248, 237, 147, 164, 57, 74, 220, 243, 180, 19,
37];
38const LAMBDA_1: [u8; 32] = [
40 5, 223, 131, 135, 64, 33, 61, 209, 110, 5, 165, 112, 185, 157, 196, 207, 0, 0, 0, 0, 0, 0, 0,
41 0, 0, 0, 0, 0, 0, 0, 0, 0,
42];
43const LAMBDA_2: [u8; 32] = [
46 43, 199, 56, 43, 86, 73, 248, 237, 147, 164, 57, 74, 220, 243, 180, 19, 0, 0, 0, 0, 0, 0, 0, 0,
47 0, 0, 0, 0, 0, 0, 0, 0,
48];
49const R1: [u8; 32] = [
52 225, 231, 118, 40, 181, 6, 253, 116, 113, 4, 25, 116, 0, 135, 143, 255, 0, 0, 0, 0, 0, 0, 0, 0,
53 0, 0, 0, 0, 0, 0, 0, 0,
54];
55const R2: [u8; 32] = [
58 0, 118, 104, 2, 2, 118, 206, 12, 82, 95, 103, 202, 212, 105, 251, 28, 0, 0, 0, 0, 0, 0, 0, 0,
59 0, 0, 0, 0, 0, 0, 0, 0,
60];
61
62const COEFF_N11: [u8; 32] = [
63 31, 24, 137, 151, 74, 249, 2, 75, 142, 146, 230, 75, 0, 226, 95, 85, 0, 0, 0, 0, 0, 0, 0, 0, 0,
64 0, 0, 0, 0, 0, 0, 0,
65];
66
67const COEFF_N12: [u8; 32] = [
68 68, 31, 214, 35, 26, 89, 226, 248, 93, 143, 94, 229, 238, 179, 20, 8, 0, 0, 0, 0, 0, 0, 0, 0,
69 0, 0, 0, 0, 0, 0, 0, 0,
70];
71
72const COEFF_N21: [u8; 32] = [
73 136, 62, 172, 71, 52, 178, 196, 241, 187, 30, 189, 202, 221, 103, 41, 16, 0, 0, 0, 0, 0, 0, 0,
74 0, 0, 0, 0, 0, 0, 0, 0, 0,
75];
76const COEFF_N22: [u8; 32] = [
77 194, 207, 237, 144, 106, 13, 250, 41, 227, 113, 50, 40, 0, 165, 47, 170, 0, 118, 104, 2, 2,
78 118, 206, 12, 82, 95, 103, 202, 212, 105, 251, 28,
79];
80
81impl<F> PlonkCircuit<F>
83where
84 F: PrimeField,
85{
86 pub fn glv_mul<P: TECurveConfig<BaseField = F>>(
89 &mut self,
90 scalar: Variable,
91 base: &PointVariable,
92 ) -> Result<PointVariable, CircuitError> {
93 self.check_var_bound(scalar)?;
94 self.check_point_var_bound(base)?;
95
96 let (s1_var, s2_var, s2_sign_var) =
97 scalar_decomposition_gate::<P::BaseField, P::ScalarField>(self, &scalar)?;
98
99 let endo_base_var = endomorphism_circuit::<_, P>(self, base)?;
100 multi_scalar_mul_circuit::<_, P>(self, base, s1_var, &endo_base_var, s2_var, s2_sign_var)
101 }
102}
103
104fn multi_scalar_mul_circuit<F, P>(
106 circuit: &mut PlonkCircuit<F>,
107 base: &PointVariable,
108 scalar_1: Variable,
109 endo_base: &PointVariable,
110 scalar_2: Variable,
111 scalar_2_sign_var: BoolVar,
112) -> Result<PointVariable, CircuitError>
113where
114 F: PrimeField,
115 P: TECurveConfig<BaseField = F>,
116{
117 let endo_base_neg = circuit.inverse_point(endo_base)?;
118 let endo_base =
119 circuit.binary_point_vars_select(scalar_2_sign_var, endo_base, &endo_base_neg)?;
120
121 MultiScalarMultiplicationCircuit::<F, P>::msm_with_var_scalar_length(
122 circuit,
123 &[*base, endo_base],
124 &[scalar_1, scalar_2],
125 128,
126 )
127}
128
129fn endomorphism<F, P>(base: &TEPoint<F>) -> TEPoint<F>
131where
132 F: PrimeField,
133 P: TECurveConfig<BaseField = F>,
134{
135 let x = base.get_x();
136 let y = base.get_y();
137 let b = F::from_le_bytes_mod_order(COEFF_B.as_ref());
138 let c = F::from_le_bytes_mod_order(COEFF_C.as_ref());
139
140 let xy = x * y;
141 let y_square = y * y;
142 let f_y = c * (F::one() - y_square);
143 let g_y = b * (y_square + b);
144 let h_y = y_square - b;
145
146 Projective::<P>::new(f_y * h_y, g_y * xy, F::one(), h_y * xy)
147 .into_affine()
148 .into()
149}
150
151fn endomorphism_circuit<F, P>(
153 circuit: &mut PlonkCircuit<F>,
154 point_var: &PointVariable,
155) -> Result<PointVariable, CircuitError>
156where
157 F: PrimeField,
158 P: TECurveConfig<BaseField = F>,
159{
160 let base = circuit.point_witness(point_var)?;
161 let endo_point = endomorphism::<_, P>(&base);
162 let endo_point_var = circuit.create_point_variable(endo_point)?;
163
164 let b = F::from_le_bytes_mod_order(COEFF_B.as_ref());
165 let c = F::from_le_bytes_mod_order(COEFF_C.as_ref());
166 let b_square = b * b;
167
168 let x_var = point_var.get_x();
169 let y_var = point_var.get_y();
170
171 let xy_var = circuit.mul(x_var, y_var)?;
173
174 let wire = [y_var, y_var, circuit.zero(), circuit.zero()];
176 let coeff = [F::zero(), F::zero(), F::zero(), F::zero()];
177 let q_mul = [-c, F::zero()];
178 let q_c = c;
179 let f_y_var = circuit.gen_quad_poly(&wire, &coeff, &q_mul, q_c)?;
180
181 let wire = [y_var, y_var, circuit.zero(), circuit.zero()];
183 let coeff = [F::zero(), F::zero(), F::zero(), F::zero()];
184 let q_mul = [b, F::zero()];
185 let q_c = b_square;
186 let g_y_var = circuit.gen_quad_poly(&wire, &coeff, &q_mul, q_c)?;
187
188 let wire = [y_var, y_var, circuit.zero(), circuit.zero()];
190 let coeff = [F::zero(), F::zero(), F::zero(), F::zero()];
191 let q_mul = [F::one(), F::zero()];
192 let q_c = -b;
193 let h_y_var = circuit.gen_quad_poly(&wire, &coeff, &q_mul, q_c)?;
194
195 circuit.mul_gate(endo_point_var.get_x(), xy_var, f_y_var)?;
197 circuit.mul_gate(endo_point_var.get_y(), h_y_var, g_y_var)?;
199
200 Ok(endo_point_var)
201}
202
203fn scalar_decomposition<F: PrimeField>(scalar: &F) -> (F, F, bool) {
208 let scalar_z: BigUint = (*scalar).into();
209
210 let tmp = F::from_le_bytes_mod_order(COEFF_N11.as_ref());
211 let n11: BigUint = tmp.into();
212
213 let tmp = F::from_le_bytes_mod_order(COEFF_N12.as_ref());
214 let n12: BigUint = tmp.into();
215
216 let tmp = F::from_le_bytes_mod_order(COEFF_N21.as_ref());
217 let n21: BigUint = tmp.into();
218
219 let tmp = F::from_le_bytes_mod_order(COEFF_N22.as_ref());
220 let n22: BigUint = tmp.into();
221
222 let r: BigUint = F::MODULUS.into();
223 let r_over_2 = &r / BigUint::from(2u8);
224
225 let beta_1 = &scalar_z * &n11;
227 let beta_2 = &scalar_z * &n12;
228
229 let beta_1 = &beta_1 / &r;
230 let beta_2 = &beta_2 / &r;
231
232 let b1: BigUint = &beta_1 * &n11 + &beta_2 * &n21;
234 let b2: BigUint = (&beta_1 * &n12 + &beta_2 * &n22) % r;
235
236 let k1 = F::from(scalar_z - b1);
237 let is_k2_pos = b2 < r_over_2;
238
239 let k2 = if is_k2_pos { F::from(b2) } else { -F::from(b2) };
240
241 (k1, k2, is_k2_pos)
242}
243
244macro_rules! fq_to_big_int {
245 ($fq: expr) => {
246 <BigInt as From<BigUint>>::from($fq.into_bigint().into())
247 };
248}
249
250macro_rules! int_to_fq {
251 ($in: expr) => {
252 F::from_le_bytes_mod_order(&$in.to_bytes_le().1)
253 };
254}
255
256#[allow(clippy::type_complexity)]
267fn scalar_decomposition_gate<F, S>(
268 circuit: &mut PlonkCircuit<F>,
269 s_var: &Variable,
270) -> Result<(Variable, Variable, BoolVar), CircuitError>
271where
272 F: PrimeField,
273 S: PrimeField,
274{
275 let two_to_128 = BigInt::from(2u64).pow(128);
337
338 let s = circuit.witness(*s_var)?;
340 let s_int = fq_to_big_int!(s);
341 let s_fr = field_switching::<_, S>(&s);
342
343 let lambda = F::from_le_bytes_mod_order(LAMBDA.as_ref());
345 let lambda_1 = F::from_le_bytes_mod_order(LAMBDA_1.as_ref());
346
347 let lambda_int = fq_to_big_int!(lambda);
348 let lambda_1_int = fq_to_big_int!(lambda_1);
349 let lambda_2 = F::from_le_bytes_mod_order(LAMBDA_2.as_ref());
350
351 let (k1, k2, is_k2_positive) = scalar_decomposition(&s_fr);
353 let k1_int = fq_to_big_int!(k1);
354 let k2_int = fq_to_big_int!(k2);
355 let k2_sign = if is_k2_positive {
356 BigInt::from(1)
357 } else {
358 BigInt::from(-1)
359 };
360 let k2_with_sign = &k2_int * &k2_sign;
361
362 let fr_order_uint: BigUint = S::MODULUS.into();
364 let fr_order_int: BigInt = fr_order_uint.into();
365 let r1 = F::from_le_bytes_mod_order(R1.as_ref());
366 let r1_int = fq_to_big_int!(r1);
367 let r2 = F::from_le_bytes_mod_order(R2.as_ref());
368
369 let mut t_int = (&lambda_int * &k2_with_sign + &s_int - &k1_int) / &fr_order_int;
371 let t_int_sign = if t_int < BigInt::zero() {
372 t_int = -t_int;
373 BigInt::from(-1)
374 } else {
375 BigInt::from(1)
376 };
377 let t_int_with_sign = &t_int * &t_int_sign;
378
379 let tmp_int = &lambda_1_int * &k2_with_sign + &s_int - &t_int_with_sign * &r1_int - &k1_int;
382 let tmp2_int = &tmp_int / &two_to_128;
383
384 #[cfg(test)]
385 {
386 use ark_ff::BigInteger;
387
388 let fq_uint: BigUint = F::MODULUS.into();
389 let fq_int: BigInt = fq_uint.into();
390
391 let tmp1_int = &tmp_int % &two_to_128;
392
393 let lambda_2_int = fq_to_big_int!(lambda_2);
394 let r2_int = fq_to_big_int!(r2);
395 assert_eq!(
399 &s_int + &lambda_int * &k2_with_sign,
400 &k1_int + &t_int_with_sign * &fr_order_int
401 );
402
403 assert_eq!(
408 &lambda_1_int * &k2_with_sign + &s_int - &t_int_with_sign * &r1_int - &k1_int
409 + &two_to_128 * (&lambda_2_int * &k2_with_sign - &t_int_with_sign * &r2_int),
410 BigInt::zero()
411 );
412
413 let k1_bits = get_bits(&k1.into_bigint().to_bits_le());
416 let k2_bits = get_bits(&k1.into_bigint().to_bits_le());
417
418 assert!(k1_bits < 128, "k1 bits {}", k1_bits);
419 assert!(k2_bits < 128, "k2 bits {}", k1_bits);
420
421 assert!(tmp1_int == BigInt::from(0));
425 let tmp2_fq = F::from_le_bytes_mod_order(&tmp2_int.to_bytes_le().1);
426 let tmp2_bits = get_bits(&tmp2_fq.into_bigint().to_bits_le());
427 assert!(tmp1_int == BigInt::from(0));
428 assert!(tmp2_bits < 128, "tmp2 bits {}", tmp2_bits);
429
430 assert_eq!(
433 &tmp1_int + &two_to_128 * &tmp2_int,
434 &lambda_1_int * &k2_with_sign + &s_int - &t_int_with_sign * &r1_int - &k1_int
435 );
436 assert!(&tmp_int + &t_int_with_sign * &r1_int + &k1_int < fq_int);
437
438 assert!(&lambda_1_int * &k2_int + &s_int < fq_int);
439
440 assert_eq!(
442 &tmp2_int + &lambda_2_int * &k2_with_sign,
443 &t_int_with_sign * &r2_int
444 );
445
446 assert!(k1_int >= BigInt::zero());
448 assert!(k2_int >= BigInt::zero());
449 assert!(t_int >= BigInt::zero());
450 assert!(tmp_int >= BigInt::zero());
451 assert!(tmp2_int >= BigInt::zero());
452
453 assert_eq!(t_int_sign, k2_sign);
455 }
456
457 let two_to_128 = F::from(BigUint::from(2u64).pow(128));
461
462 let k1_var = circuit.create_variable(int_to_fq!(k1_int))?;
463 let k2_var = circuit.create_variable(int_to_fq!(k2_int))?;
464 let k2_sign_var = circuit.create_boolean_variable(is_k2_positive)?;
465
466 let t_var = circuit.create_variable(int_to_fq!(t_int))?;
467
468 let tmp_var = circuit.create_variable(int_to_fq!(tmp_int))?;
469
470 let tmp2_var = circuit.create_variable(int_to_fq!(tmp2_int))?;
471
472 circuit.enforce_in_range(k1_var, 128)?;
478 circuit.enforce_in_range(k2_var, 128)?;
479
480 circuit.mul_constant_gate(tmp2_var, two_to_128, tmp_var)?;
484 circuit.enforce_in_range(tmp2_var, 128)?;
485
486 let k2_is_pos_sat = {
492 let left_wire = [tmp_var, t_var, k1_var, circuit.zero()];
495 let left_coeff = [F::one(), r1, F::one(), F::zero()];
496 let left_var = circuit.lc(&left_wire, &left_coeff)?;
497
498 let right_wire = [k2_var, *s_var, circuit.zero(), circuit.zero()];
499 let right_coeff = [lambda_1, F::one(), F::zero(), F::zero()];
500 let right_var = circuit.lc(&right_wire, &right_coeff)?;
501
502 circuit.is_equal(left_var, right_var)?
503 };
504
505 let k2_is_neg_sat = {
506 let left_wire = [k2_var, tmp_var, k1_var, circuit.zero()];
509 let left_coeff = [lambda_1, F::one(), F::one(), F::zero()];
510 let left_var = circuit.lc(&left_wire, &left_coeff)?;
511
512 let right_wire = [*s_var, t_var, circuit.zero(), circuit.zero()];
513 let right_coeff = [F::one(), r1, F::zero(), F::zero()];
514 let right_var = circuit.lc(&right_wire, &right_coeff)?;
515 circuit.is_equal(left_var, right_var)?
516 };
517
518 let sat =
520 circuit.conditional_select(k2_sign_var, k2_is_neg_sat.into(), k2_is_pos_sat.into())?;
521 circuit.enforce_true(sat)?;
522
523 let k2_is_pos_sat = {
526 let left_wire = [tmp2_var, k2_var, circuit.zero(), circuit.zero()];
529 let left_coeff = [F::one(), lambda_2, F::zero(), F::zero()];
530 let left_var = circuit.lc(&left_wire, &left_coeff)?;
531
532 let right_var = circuit.mul_constant(t_var, &r2)?;
533
534 circuit.is_equal(left_var, right_var)?
535 };
536
537 let k2_is_neg_sat = {
538 let left_wire = [tmp2_var, t_var, circuit.zero(), circuit.zero()];
541 let left_coeff = [F::one(), r2, F::zero(), F::zero()];
542 let left_var = circuit.lc(&left_wire, &left_coeff)?;
543
544 let right_var = circuit.mul_constant(k2_var, &lambda_2)?;
545
546 circuit.is_equal(left_var, right_var)?
547 };
548
549 let sat =
551 circuit.conditional_select(k2_sign_var, k2_is_neg_sat.into(), k2_is_pos_sat.into())?;
552 circuit.enforce_true(sat)?;
553
554 Ok((k1_var, k2_var, k2_sign_var))
556}
557
558#[cfg(test)]
559fn get_bits(a: &[bool]) -> u16 {
561 let mut res = 256;
562 for e in a.iter().rev() {
563 if !e {
564 res -= 1;
565 } else {
566 return res;
567 }
568 }
569 res
570}
571
572#[cfg(test)]
573mod tests {
574 use super::*;
575 use ark_ec::{
576 twisted_edwards::{Affine, TECurveConfig as Config},
577 CurveConfig,
578 };
579 use ark_ed_on_bls12_381_bandersnatch::{EdwardsAffine, EdwardsConfig, Fq, Fr};
580 use ark_ff::{BigInteger, MontFp, One, UniformRand};
581 use jf_utils::{fr_to_fq, test_rng};
582
583 #[test]
584 fn test_glv() -> Result<(), CircuitError> {
585 test_glv_helper::<Fq, EdwardsConfig>()
586 }
587
588 fn test_glv_helper<F, P>() -> Result<(), CircuitError>
589 where
590 F: PrimeField,
591 P: Config<BaseField = F>,
592 {
593 let mut rng = jf_utils::test_rng();
594
595 for _ in 0..100 {
596 {
597 let mut base = Affine::<P>::rand(&mut rng);
598 let s = P::ScalarField::rand(&mut rng);
599 let mut circuit: PlonkCircuit<F> = PlonkCircuit::new_turbo_plonk();
600
601 let s_var = circuit.create_variable(fr_to_fq::<F, P>(&s))?;
602 let base_var = circuit.create_point_variable(TEPoint::from(base))?;
603 base = (base * s).into();
604 let result = circuit.variable_base_scalar_mul::<P>(s_var, &base_var)?;
605 assert_eq!(TEPoint::from(base), circuit.point_witness(&result)?);
606
607 assert!(circuit.check_circuit_satisfiability(&[]).is_ok());
610 }
611 {
612 let mut base = Affine::<P>::rand(&mut rng);
613 let s = P::ScalarField::rand(&mut rng);
614 let mut circuit: PlonkCircuit<F> = PlonkCircuit::new_ultra_plonk(16);
615
616 let s_var = circuit.create_variable(fr_to_fq::<F, P>(&s))?;
617 let base_var = circuit.create_point_variable(TEPoint::from(base))?;
618 base = (base * s).into();
619 let result = circuit.variable_base_scalar_mul::<P>(s_var, &base_var)?;
620 assert_eq!(TEPoint::from(base), circuit.point_witness(&result)?);
621
622 assert!(circuit.check_circuit_satisfiability(&[]).is_ok());
625 }
626
627 {
628 let mut base = Affine::<P>::rand(&mut rng);
629 let s = P::ScalarField::rand(&mut rng);
630 let mut circuit: PlonkCircuit<F> = PlonkCircuit::new_turbo_plonk();
631
632 let s_var = circuit.create_variable(fr_to_fq::<F, P>(&s))?;
633 let base_var = circuit.create_point_variable(TEPoint::from(base))?;
634 base = (base * s).into();
635 let result = circuit.glv_mul::<P>(s_var, &base_var)?;
636 assert_eq!(TEPoint::from(base), circuit.point_witness(&result)?);
637
638 assert!(circuit.check_circuit_satisfiability(&[]).is_ok());
641 }
642
643 {
644 let mut base = Affine::<P>::rand(&mut rng);
645 let s = P::ScalarField::rand(&mut rng);
646 let mut circuit: PlonkCircuit<F> = PlonkCircuit::new_ultra_plonk(16);
647
648 let s_var = circuit.create_variable(fr_to_fq::<F, P>(&s))?;
649 let base_var = circuit.create_point_variable(TEPoint::from(base))?;
650 base = (base * s).into();
651 let result = circuit.glv_mul::<P>(s_var, &base_var)?;
652 assert_eq!(TEPoint::from(base), circuit.point_witness(&result)?);
653
654 assert!(circuit.check_circuit_satisfiability(&[]).is_ok());
657 }
658 }
659 Ok(())
660 }
661
662 #[test]
663 fn test_endomorphism() {
664 let base_point = EdwardsAffine::new_unchecked(
665 MontFp!(
666 "29627151942733444043031429156003786749302466371339015363120350521834195802525"
667 ),
668 MontFp!(
669 "27488387519748396681411951718153463804682561779047093991696427532072116857978"
670 ),
671 );
672 let endo_point = EdwardsAffine::new_unchecked(
673 MontFp!("3995099504672814451457646880854530097687530507181962222512229786736061793535"),
674 MontFp!(
675 "33370049900732270411777328808452912493896532385897059012214433666611661340894"
676 ),
677 );
678 let base_point: TEPoint<Fq> = base_point.into();
679 let endo_point: TEPoint<Fq> = endo_point.into();
680
681 let t = endomorphism::<_, EdwardsConfig>(&base_point);
682 assert_eq!(t, endo_point);
683
684 let mut circuit: PlonkCircuit<Fq> = PlonkCircuit::new_turbo_plonk();
685 let point_var = circuit.create_point_variable(base_point).unwrap();
686 let endo_var = endomorphism_circuit::<_, EdwardsConfig>(&mut circuit, &point_var).unwrap();
687 let endo_point_rec = circuit.point_witness(&endo_var).unwrap();
688 assert_eq!(endo_point_rec, endo_point);
689 }
690
691 #[test]
692 fn test_decomposition() {
693 let mut rng = test_rng();
694 let lambda: Fr = Fr::from_le_bytes_mod_order(LAMBDA.as_ref());
695
696 for _ in 0..100 {
697 let scalar = Fr::rand(&mut rng);
698 let (k1, k2, is_k2_pos) = scalar_decomposition(&scalar);
699 assert!(get_bits(&k1.into_bigint().to_bits_le()) <= 128);
700 assert!(get_bits(&k2.into_bigint().to_bits_le()) <= 128);
701 let k2 = if is_k2_pos { k2 } else { -k2 };
702
703 assert_eq!(k1 - k2 * lambda, scalar,);
704
705 let mut circuit: PlonkCircuit<Fq> = PlonkCircuit::new_ultra_plonk(16);
706 let scalar_var = circuit.create_variable(field_switching(&scalar)).unwrap();
707 let (k1_var, k2_var, k2_sign_var) = scalar_decomposition_gate::<
708 <EdwardsConfig as CurveConfig>::BaseField,
709 <EdwardsConfig as CurveConfig>::ScalarField,
710 >(&mut circuit, &scalar_var)
711 .unwrap();
712
713 let k1_rec = circuit.witness(k1_var).unwrap();
714 assert_eq!(field_switching::<_, Fq>(&k1), k1_rec);
715
716 let k2_rec = circuit.witness(k2_var).unwrap();
717 let k2_sign = circuit.witness(k2_sign_var.into()).unwrap();
718 let k2_with_sign_rec = if k2_sign == Fq::one() {
719 field_switching::<_, Fr>(&k2_rec)
720 } else {
721 -field_switching::<_, Fr>(&k2_rec)
722 };
723
724 assert_eq!(k2, k2_with_sign_rec);
725 }
726 }
727}