remove g1 uncheck

eigmax · Sep 21, 2025 · Sep 21, 2025 · Sep 21, 2025 · Sep 21, 2025 · Sep 22, 2025
commit 7075c783a5a9fc32c8623fd7801c627438a057dd
diff --git a/bitvm/src/bn254/g1.rs b/bitvm/src/bn254/g1.rs
@@ -139,10 +139,6 @@ impl G1Affine {
         }
     }
 
-    pub fn one_in_script() -> ark_bn254::G1Affine {
-        ark_bn254::G1Affine::new_unchecked(ark_bn254::Fq::ONE, ark_bn254::Fq::ONE)
-    }
-
     pub fn zero_in_script() -> ark_bn254::G1Affine {
         ark_bn254::G1Affine::new_unchecked(ark_bn254::Fq::ZERO, ark_bn254::Fq::ZERO)
     }
@@ -464,19 +460,20 @@ impl G1Affine {
 }
 
 /// input of func (params):
-///      p.x, p.y
+///      px, py
 /// Input Hints On Stack
-///      tmul hints, p.y_inverse
+///      tmul hints, py_inverse
 /// output on stack:
-///      x' = -p.x / p.y
+///      x' = -px / py
 pub fn hinted_x_from_eval_point(
-    p: ark_bn254::G1Affine,
+    px: ark_bn254::Fq,
+    py: ark_bn254::Fq,
     py_inv: ark_bn254::Fq,
 ) -> (Script, Vec<Hint>) {
     let mut hints = Vec::new();
 
-    let (hinted_script1, hint1) = Fq::hinted_mul(1, p.y, 0, py_inv);
-    let (hinted_script2, hint2) = Fq::hinted_mul(1, py_inv, 0, -p.x);
+    let (hinted_script1, hint1) = Fq::hinted_mul(1, py, 0, py_inv);
+    let (hinted_script2, hint2) = Fq::hinted_mul(1, py_inv, 0, -px);
     let script = script! {   // Stack: [hints, pyd, px, py]
         {Fq::copy(2)}                        // Stack: [hints, pyd, px, py, pyd]
         {hinted_script1}
@@ -517,13 +514,13 @@ pub fn hinted_y_from_eval_point(py: ark_bn254::Fq, py_inv: ark_bn254::Fq) -> (Sc
 /// output on stack:
 ///      x' = -p.x / p.y
 ///      y' = 1 / p.y
-pub fn hinted_from_eval_point(p: ark_bn254::G1Affine) -> (Script, Vec<Hint>) {
+pub fn hinted_from_eval_point(px: ark_bn254::Fq, py: ark_bn254::Fq) -> (Script, Vec<Hint>) {
     let mut hints = Vec::new();
 
-    let py_inv = p.y().unwrap().inverse().unwrap();
+    let py_inv = py.inverse().unwrap();
 
-    let (hinted_script1, hint1) = hinted_y_from_eval_point(p.y, py_inv);
-    let (hinted_script2, hint2) = hinted_x_from_eval_point(p, py_inv);
+    let (hinted_script1, hint1) = hinted_y_from_eval_point(py, py_inv);
+    let (hinted_script2, hint2) = hinted_x_from_eval_point(px, py, py_inv);
     let script = script! {
 
         // [hints, yinv, x, y]
@@ -544,13 +541,19 @@ pub fn hinted_from_eval_point(p: ark_bn254::G1Affine) -> (Script, Vec<Hint>) {
     (script, hints)
 }
 
-pub fn hinted_from_eval_points(p: ark_bn254::G1Affine) -> (Script, Vec<Hint>) {
+pub fn hinted_from_eval_points(px: ark_bn254::Fq, py: ark_bn254::Fq) -> (Script, Vec<Hint>, bool) {
     let mut hints = Vec::new();
 
-    let py_inv = p.y().unwrap().inverse().unwrap();
+    let p = ark_bn254::G1Affine::new_unchecked(px, py);
+    if p.is_zero() {
+        return (G1Affine::push_zero(), hints, true);
+    }
+    let valid_point = p.is_on_curve();
+
+    let py_inv = py.inverse().unwrap();
 
-    let (hinted_script1, hint1) = hinted_y_from_eval_point(p.y, py_inv);
-    let (hinted_script2, hint2) = hinted_x_from_eval_point(p, py_inv);
+    let (hinted_script1, hint1) = hinted_y_from_eval_point(py, py_inv);
+    let (hinted_script2, hint2) = hinted_x_from_eval_point(px, py, py_inv);
 
     let script = script! {
         // [yinv, hints,.., x, y]
@@ -574,7 +577,7 @@ pub fn hinted_from_eval_points(p: ark_bn254::G1Affine) -> (Script, Vec<Hint>) {
     hints.extend(hint1);
     hints.extend(hint2);
 
-    (script, hints)
+    (script, hints, valid_point)
 }
 
 #[cfg(test)]
@@ -912,7 +915,7 @@ mod test {
     fn test_hinted_from_eval_point() {
         let mut prng = ChaCha20Rng::seed_from_u64(1);
         let p = ark_bn254::G1Affine::rand(&mut prng);
-        let (eval_scr, hints) = hinted_from_eval_point(p);
+        let (eval_scr, hints) = hinted_from_eval_point(p.x, p.y);
         let pyinv = p.y.inverse().unwrap();
 
         let script = script! {
@@ -938,7 +941,7 @@ mod test {
         let mut prng = ChaCha20Rng::seed_from_u64(0);
         let p = ark_bn254::G1Affine::rand(&mut prng);
         let (ell_by_constant_affine_script, hints) =
-            hinted_x_from_eval_point(p, p.y.inverse().unwrap());
+            hinted_x_from_eval_point(p.x, p.y, p.y.inverse().unwrap());
         let script = script! {
             for tmp in hints {
                 { tmp.push() }

diff --git a/bitvm/src/bn254/g2.rs b/bitvm/src/bn254/g2.rs
@@ -110,10 +110,6 @@ impl G2Affine {
         (scr, hints)
     }
 
-    pub fn one_in_script() -> ark_bn254::G2Affine {
-        ark_bn254::G2Affine::new_unchecked(ark_bn254::Fq2::ONE, ark_bn254::Fq2::ONE)
-    }
-
     pub fn zero_in_script() -> ark_bn254::G2Affine {
         ark_bn254::G2Affine::new_unchecked(ark_bn254::Fq2::ZERO, ark_bn254::Fq2::ZERO)
     }
@@ -914,7 +910,7 @@ mod test {
 
         // affine mode
         let coeffs = G2Prepared::from_affine(b);
-        let (from_eval_point_script, hints_eval) = hinted_from_eval_point(p);
+        let (from_eval_point_script, hints_eval) = hinted_from_eval_point(p.x, p.y);
         let (ell_by_constant_affine_script, hints) = hinted_ell_by_constant_affine_and_sparse_mul(
             f,
             -p.x / p.y,

diff --git a/bitvm/src/bn254/pairing.rs b/bitvm/src/bn254/pairing.rs
@@ -769,11 +769,11 @@ mod test {
 
         let mut hints = Vec::new();
 
-        let (from_eval_p1, hints1) = hinted_from_eval_point(p1);
-        let (from_eval_p2, hints2) = hinted_from_eval_point(p2);
+        let (from_eval_p1, hints1) = hinted_from_eval_point(p1.x, p1.y);
+        let (from_eval_p2, hints2) = hinted_from_eval_point(p2.x, p2.y);
 
-        let (from_eval_p3, hints3) = hinted_from_eval_point(p3);
-        let (from_eval_p4, hints4) = hinted_from_eval_point(p4);
+        let (from_eval_p3, hints3) = hinted_from_eval_point(p3.x, p3.y);
+        let (from_eval_p4, hints4) = hinted_from_eval_point(p4.x, p4.y);
 
         let (quad_miller_loop_affine_script, hints5) = Pairing::hinted_quad_miller_loop_with_c_wi(
             [q1_prepared, q2_prepared, q3_prepared, q4_prepared].to_vec(),

diff --git a/bitvm/src/chunk/elements.rs b/bitvm/src/chunk/elements.rs
@@ -7,8 +7,9 @@ use crate::{
         wrap_hasher::BLAKE3_HASH_LENGTH,
     },
 };
-use ark_ff::{AdditiveGroup, Field};
+use ark_ff::{AdditiveGroup, Field, UniformRand};
 use num_bigint::{BigInt, BigUint};
+use rand::Rng;
 use std::fmt::Debug;
 
 use super::helpers::{extern_hash_fps, extern_nibbles_to_limbs};
@@ -61,6 +62,11 @@ impl FqPair {
         let p: ark_bn254::G1Affine = (*self).into();
         Self::new(p.x, p.y)
     }
+
+    pub fn rand<R: Rng + ?Sized>(rng: &mut R) -> Self {
+        let p = ark_bn254::G1Affine::rand(rng);
+        Self::new(p.x, p.y)
+    }
 }
 
 impl From<ark_bn254::G1Affine> for FqPair {

diff --git a/bitvm/src/chunk/taps_ext_miller.rs b/bitvm/src/chunk/taps_ext_miller.rs
@@ -39,24 +39,23 @@ pub(crate) fn chunk_precompute_p(
         hints.extend_from_slice(&on_curve_hint);
     }
 
-    let p = ark_bn254::G1Affine::new_unchecked(px, py);
-    let (eval_xy, eval_hints) = hinted_from_eval_points(p);
+    let (eval_xy, eval_hints, valid_point) = hinted_from_eval_points(px, py);
 
-    let valid_point = are_valid_field_elems && py != ark_bn254::Fq::ZERO && p.is_on_curve();
-    let mock_pd = G1Affine::one_in_script();
+    let valid_point = are_valid_field_elems && valid_point;
 
     let pd = if valid_point {
         hints.extend_from_slice(&eval_hints);
-        FqPair::new(p.x, p.y)
+        FqPair::new(px, py)
     } else {
-        mock_pd.into()
+        FqPair::new(ark_bn254::Fq::ONE, ark_bn254::Fq::ONE)
     };
 
     let drop_and_return_scr = script! {
         // [px, py] [pdhash]
         {G1Affine::drop()}
         // [] [pdhash]
-        {G1Affine::push(mock_pd)} // mock values for pd,these values won't be useful as we add {0} <- skip output hash check for invalid input
+        {Fq::push(ark_bn254::Fq::ONE)} // mock values for pd,these values won't be useful as we add {0} <- skip output hash check for invalid input
+        {Fq::push(ark_bn254::Fq::ONE)}
         // [pd] [pdhash]
         {0} // skip output hash check because input was invalid
     };
@@ -131,22 +130,21 @@ pub(crate) fn chunk_precompute_p_from_hash(
         hints.extend_from_slice(&on_curve_hint);
     }
 
-    let p = ark_bn254::G1Affine::new_unchecked(px, py);
-    let (eval_xy, eval_hints) = hinted_from_eval_points(p);
+    let (eval_xy, eval_hints, valid_point) = hinted_from_eval_points(px, py);
 
-    let valid_point = py_is_not_zero && p.is_on_curve();
-    let mock_pd = G1Affine::one_in_script();
+    let valid_point = py_is_not_zero && valid_point;
 
     let pd = if valid_point {
         hints.extend_from_slice(&eval_hints);
-        FqPair::new(p.x, p.y)
+        FqPair::new(px, py)
     } else {
-        mock_pd.into()
+        FqPair::new(ark_bn254::Fq::ONE, ark_bn254::Fq::ONE)
     };
 
     let drop_and_return_scr = script! {
         // [px, py] [pdhash, phash]
-        {G1Affine::push(mock_pd)} // mock values for pd,these values won't be useful as we add {0} <- skip output hash check for invalid input
+        {Fq::push(ark_bn254::Fq::ONE)} // mock values for pd,these values won't be useful as we add {0} <- skip output hash check for invalid input
+        {Fq::push(ark_bn254::Fq::ONE)}
         // [p, pd] [pdhash, phash]
         {0} // skip output hash check because input was invalid
     };

diff --git a/bitvm/src/chunk/taps_point_ops.rs b/bitvm/src/chunk/taps_point_ops.rs
@@ -816,7 +816,7 @@ pub(crate) fn point_ops_and_multiply_line_evals_step_2(
 pub(crate) fn chunk_init_t4(ts: [ark_ff::BigInt<4>; 4]) -> (ElemG2Eval, bool, Script, Vec<Hint>) {
     let mut hints = vec![];
 
-    let mock_t = G2Affine::one_in_script();
+    let mock_t = ark_bn254::G2Affine::new_unchecked(ark_bn254::Fq2::ONE, ark_bn254::Fq2::ONE);
     let are_valid_fps = ts.iter().filter(|f| **f < ark_bn254::Fq::MODULUS).count() == ts.len();
 
     let mut t4: ElemG2Eval = ElemG2Eval {
@@ -1281,15 +1281,15 @@ mod test {
 
         let t4 = ark_bn254::G2Affine::rand(&mut prng);
         let q4 = ark_bn254::G2Affine::rand(&mut prng);
-        let p4 = ark_bn254::G1Affine::rand(&mut prng);
+        let p4 = FqPair::rand(&mut prng);
 
         let t3 = t4; // ark_bn254::G2Affine::rand(&mut prng);
         let q3 = q4; //ark_bn254::G2Affine::rand(&mut prng);
-        let p3 = ark_bn254::G1Affine::new_unchecked(p4.x, -p4.y); //ark_bn254::G1Affine::rand(&mut prng);
+        let p3 = FqPair::new(p4.x(), -p4.y()); //ark_bn254::G1Affine::rand(&mut prng);
 
         let t2 = ark_bn254::G2Affine::rand(&mut prng);
         let q2 = ark_bn254::G2Affine::rand(&mut prng);
-        let p2 = ark_bn254::G1Affine::rand(&mut prng);
+        let p2 = FqPair::rand(&mut prng);
 
         let is_dbl = false;
         let is_frob: Option<bool> = Some(false);
@@ -1304,15 +1304,12 @@ mod test {
                 is_frob,
                 ate_bit,
                 t4,
-                //p4,
-                FqPair::new(p4.x, p4.y),
+                p4,
                 Some(q4),
-                //p3,
-                FqPair::new(p3.x, p3.y),
+                p3,
                 t3,
                 Some(q3),
-                //p2,
-                FqPair::new(p2.x, p2.y),
+                p2,
                 t2,
                 Some(q2),
             );
@@ -1335,9 +1332,9 @@ mod test {
             ]);
         }
 
-        preimage_hints.extend_from_slice(&[Hint::Fq(p4.x), Hint::Fq(p4.y)]);
-        preimage_hints.extend_from_slice(&[Hint::Fq(p3.x), Hint::Fq(p3.y)]);
-        preimage_hints.extend_from_slice(&[Hint::Fq(p2.x), Hint::Fq(p2.y)]);
+        preimage_hints.extend_from_slice(&[Hint::Fq(p4.x()), Hint::Fq(p4.y())]);
+        preimage_hints.extend_from_slice(&[Hint::Fq(p3.x()), Hint::Fq(p3.y())]);
+        preimage_hints.extend_from_slice(&[Hint::Fq(p2.x()), Hint::Fq(p2.y())]);
 
         let tap_len = ops_scr.len();
         // [hints, t4, (q2), p4, p3, p2]
@@ -1365,11 +1362,14 @@ mod test {
             {Fq2::equalverify()}
             {Fq2::push(hint_out.t.x)}
             {Fq2::equalverify()}
-            {G1Affine::push(p2)}
+            {Fq::push(p2.x())}
+            {Fq::push(p2.y())}
             {Fq2::equalverify()}
-            {G1Affine::push(p3)}
+            {Fq::push(p3.x())}
+            {Fq::push(p3.y())}
             {Fq2::equalverify()}
-            {G1Affine::push(p4)}
+            {Fq::push(p4.x())}
+            {Fq::push(p4.y())}
             {Fq2::equalverify()}
             {Fq2::push(t4.y)}
             {Fq2::equalverify()}
@@ -1400,14 +1400,14 @@ mod test {
 
         let t4 = ark_bn254::G2Affine::rand(&mut prng);
         let q4 = ark_bn254::G2Affine::rand(&mut prng);
-        let p4 = ark_bn254::G1Affine::rand(&mut prng);
+        let p4 = FqPair::rand(&mut prng);
         let t3 = ark_bn254::G2Affine::rand(&mut prng);
         let q3 = ark_bn254::G2Affine::rand(&mut prng);
-        let p3 = ark_bn254::G1Affine::rand(&mut prng);
+        let p3 = FqPair::rand(&mut prng);
 
         let t2 = ark_bn254::G2Affine::rand(&mut prng);
         let q2 = ark_bn254::G2Affine::rand(&mut prng);
-        let p2 = ark_bn254::G1Affine::rand(&mut prng);
+        let p2 = FqPair::rand(&mut prng);
 
         let t4 = ElemG2Eval {
             t: t4,
@@ -1420,15 +1420,12 @@ mod test {
             None,
             None,
             t4,
-            //p4,
-            FqPair::new(p4.x, p4.y),
+            p4,
             Some(q4),
-            //p3,
-            FqPair::new(p3.x, p3.y),
+            p3,
             t3,
             Some(q3),
-            //p2,
-            FqPair::new(p2.x, p2.y),
+            p2,
             t2,
             Some(q2),
         );
@@ -1515,14 +1512,14 @@ mod test {
 
         let t4 = ark_bn254::G2Affine::rand(&mut prng);
         let q4 = ark_bn254::G2Affine::rand(&mut prng);
-        let p4 = ark_bn254::G1Affine::rand(&mut prng);
+        let p4 = FqPair::rand(&mut prng);
         let t3 = ark_bn254::G2Affine::rand(&mut prng);
         let q3 = ark_bn254::G2Affine::rand(&mut prng);
-        let p3 = ark_bn254::G1Affine::rand(&mut prng);
+        let p3 = FqPair::rand(&mut prng);
 
         let t2 = ark_bn254::G2Affine::rand(&mut prng);
         let q2 = ark_bn254::G2Affine::rand(&mut prng);
-        let p2 = ark_bn254::G1Affine::rand(&mut prng);
+        let p2 = FqPair::rand(&mut prng);
 
         let t4 = ElemG2Eval {
             t: t4,
@@ -1536,14 +1533,14 @@ mod test {
             None,
             t4,
             //p4,
-            FqPair::new(p4.x, p4.y),
+            FqPair::new(p4.x(), p4.y()),
             Some(q4),
             //p3,
-            FqPair::new(p3.x, p3.y),
+            FqPair::new(p3.x(), p3.y()),
             t3,
             Some(q3),
             //p2,
-            FqPair::new(p2.x, p2.y),
+            FqPair::new(p2.x(), p2.y()),
             t2,
             Some(q2),
         );

diff --git a/bitvm/src/groth16/verifier.rs b/bitvm/src/groth16/verifier.rs
@@ -73,9 +73,9 @@ impl Verifier {
 
         let (hinted_script1, hint1) = Fq::hinted_inv(p1.y);
         let (hinted_script2, hint2) = Fq::hinted_mul(1, p1.y.inverse().unwrap(), 0, p1.x.neg());
-        let (hinted_script3, hint3) = hinted_from_eval_point(p2);
-        let (hinted_script4, hint4) = hinted_from_eval_point(p3);
-        let (hinted_script5, hint5) = hinted_from_eval_point(p4);
+        let (hinted_script3, hint3) = hinted_from_eval_point(p2.x, p2.y);
+        let (hinted_script4, hint4) = hinted_from_eval_point(p3.x, p3.y);
+        let (hinted_script5, hint5) = hinted_from_eval_point(p4.x, p4.y);
         let (hinted_script6, hint6) = Pairing::hinted_quad_miller_loop_with_c_wi(
             q_prepared.to_vec(),
             c,