refac: upstream latest plonky2

Cargo.toml

@@ -13,7 +13,7 @@ ark-std = "0.4.0"
 num-bigint = "0.4.3"
 num-traits = "0.2"
 rand = "0.8.5"
-plonky2_ecdsa = { git = "https://github.com/Lagrange-Labs/plonky2-ecdsa", features = [
+plonky2_ecdsa = { git = "https://github.com/Lagrange-Labs/plonky2-ecdsa", rev = "5dd47af", features = [
     "parallel",
 ] }
 plonky2_crypto = { git = "https://github.com/Lagrange-Labs/plonky2-crypto" }

src/fields/fq_target.rs

@@ -107,27 +107,64 @@ impl<F: RichField + Extendable<D>, const D: usize> FqTarget<F, D> {
     pub fn is_equal(&self, builder: &mut CircuitBuilder<F, D>, rhs: &Self) -> BoolTarget {
         let a_limbs = self.target.value.limbs.iter().map(|x| x.0).collect_vec();
         let b_limbs = rhs.target.value.limbs.iter().map(|x| x.0).collect_vec();
-        assert_eq!(a_limbs.len(), b_limbs.len());
 
-        let terms = a_limbs
+        if a_limbs.len() == b_limbs.len() {
+            self.compare_same_length(builder, &a_limbs, &b_limbs)
+        } else {
+            self.compare_different_length(builder, &a_limbs, &b_limbs)
+        }
+    }
+
+    fn compare_same_length(
+        &self,
+        builder: &mut CircuitBuilder<F, D>,
+        lhs: &Vec<Target>,
+        rhs: &Vec<Target>,
+    ) -> BoolTarget {
+        let terms = lhs
             .iter()
-            .zip(b_limbs)
-            .map(|(&a, b)| builder.is_equal(a, b).target)
+            .zip(rhs)
+            .map(|(&a, b)| builder.is_equal(a, *b).target)
             .collect_vec();
         let is_equal = builder.mul_many(terms);
 
         // is_equal is ensured to be 0 or 1, so we can safely convert it to bool.
         BoolTarget::new_unsafe(is_equal)
     }
 
-    pub fn is_zero(&self, builder: &mut CircuitBuilder<F, D>) -> BoolTarget {
+    fn compare_different_length(
+        &self,
+        builder: &mut CircuitBuilder<F, D>,
+        lhs: &Vec<Target>,
+        rhs: &Vec<Target>,
+    ) -> BoolTarget {
+        let (shorter, longer) = if lhs.len() < rhs.len() {
+            (&lhs, &rhs)
+        } else {
+            (&rhs, &lhs)
+        };
+        let mut terms = Vec::with_capacity(longer.len());
+
+        // Compare common limbs
+        for (a, b) in shorter.iter().zip(longer.iter()) {
+            terms.push(builder.is_equal(*a, *b).target);
+        }
+
         let zero = builder.zero();
-        let mut t = builder._true();
-        for l in self.target.value.limbs.iter() {
-            let eq = builder.is_equal(zero, l.0);
-            t = builder.and(eq, t);
+        // Check if the remaining limbs in the longer one are all zeros
+        for &limb in longer.iter().skip(shorter.len()) {
+            terms.push(builder.is_equal(limb, zero).target);
         }
-        t
+
+        let is_equal = builder.mul_many(terms);
+
+        // is_equal is ensured to be 0 or 1, so we can safely convert it to bool.
+        BoolTarget::new_unsafe(is_equal)
+    }
+
+    pub fn is_zero(&self, builder: &mut CircuitBuilder<F, D>) -> BoolTarget {
+        let zero = Self::zero(builder);
+        self.is_equal(builder, &zero)
     }
 
     pub fn constant(builder: &mut CircuitBuilder<F, D>, c: Fq) -> Self {