chore!: remove is_infinite from EmbeddedCurvePoint

Author: asterite

acvm-repo/acir/codegen/acir.cpp

@@ -177,11 +177,13 @@ pub enum BlackBoxFuncCall<F> {
     /// Coordinates of each point must be all witnesses or all constants.
     /// Similarly, both halves (lo, hi) of each scalar must be all witnesses or
     /// all constants. This is a backend requirement from Barretenberg.
+    ///
+    /// The point at infinity is represented as `(0, 0)`.
     MultiScalarMul {
         points: Vec<FunctionInput<F>>,
         scalars: Vec<FunctionInput<F>>,
         predicate: FunctionInput<F>,
-        outputs: (Witness, Witness, Witness),
+        outputs: (Witness, Witness),
     },
     /// Addition over the embedded curve on which the witness is defined.
     /// The opcode makes the following assumptions but does not enforce them because
@@ -193,13 +195,15 @@ pub enum BlackBoxFuncCall<F> {
     /// If not, it assumes that the points' x-coordinates are not equal.
     /// It also assumes neither point is the infinity point.
     ///
+    /// The point at infinity is represented as `(0, 0)`.
+    ///
     /// Coordinates of each point must be all witnesses or all constants.
     /// This is a backend requirement from Barretenberg.
     EmbeddedCurveAdd {
-        input1: Box<[FunctionInput<F>; 3]>,
-        input2: Box<[FunctionInput<F>; 3]>,
+        input1: Box<[FunctionInput<F>; 2]>,
+        input2: Box<[FunctionInput<F>; 2]>,
         predicate: FunctionInput<F>,
-        outputs: (Witness, Witness, Witness),
+        outputs: (Witness, Witness),
     },
     /// Keccak Permutation function of width 1600
     /// - inputs: An array of 25 64-bit Keccak lanes that represent a keccak sponge of 1600 bits
@@ -331,7 +335,7 @@ impl<F> BlackBoxFuncCall<F> {
             | BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
             BlackBoxFuncCall::MultiScalarMul { outputs, .. }
             | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => {
-                vec![outputs.0, outputs.1, outputs.2]
+                vec![outputs.0, outputs.1]
             }
             BlackBoxFuncCall::RANGE { .. } | BlackBoxFuncCall::RecursiveAggregation { .. } => {
                 vec![]
@@ -364,7 +368,7 @@ impl<F: Copy + AcirField> BlackBoxFuncCall<F> {
                 [points.as_slice(), scalars.as_slice(), &[*predicate]].concat()
             }
             BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, predicate, outputs: _ } => {
-                vec![input1[0], input1[1], input1[2], input2[0], input2[1], input2[2], *predicate]
+                vec![input1[0], input1[1], input2[0], input2[1], *predicate]
             }
             BlackBoxFuncCall::EcdsaSecp256k1 {
                 public_key_x,
@@ -494,17 +498,17 @@ impl<F: std::fmt::Display + Copy> std::fmt::Display for BlackBoxFuncCall<F> {
                 let scalars = slice_to_string(scalars);
                 write!(
                     f,
-                    "points: {points}, scalars: {scalars}, predicate: {predicate}, outputs: [{}, {}, {}]",
-                    outputs.0, outputs.1, outputs.2
+                    "points: {points}, scalars: {scalars}, predicate: {predicate}, outputs: [{}, {}]",
+                    outputs.0, outputs.1
                 )?;
             }
             BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, predicate, outputs } => {
                 let input1 = slice_to_string(&input1.to_vec());
                 let input2 = slice_to_string(&input2.to_vec());
                 write!(
                     f,
-                    "input1: {input1}, input2: {input2}, predicate: {predicate}, outputs: [{}, {}, {}]",
-                    outputs.0, outputs.1, outputs.2
+                    "input1: {input1}, input2: {input2}, predicate: {predicate}, outputs: [{}, {}]",
+                    outputs.0, outputs.1
                 )?;
             }
             BlackBoxFuncCall::Keccakf1600 { inputs, outputs } => {
@@ -627,6 +631,7 @@ mod arb {
         fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
             let input = any::<FunctionInput<F>>();
             let input_vec = any::<Vec<FunctionInput<F>>>();
+            let input_arr_2 = any::<Box<[FunctionInput<F>; 2]>>();
             let input_arr_3 = any::<Box<[FunctionInput<F>; 3]>>();
             let input_arr_8 = any::<Box<[FunctionInput<F>; 8]>>();
             let input_arr_16 = any::<Box<[FunctionInput<F>; 16]>>();
@@ -660,7 +665,7 @@ mod arb {
                 },
             );
 
-            let case_xor = (input_arr_3.clone(), input_arr_8.clone(), witness.clone()).prop_map(
+            let case_xor = (input_arr_3, input_arr_8.clone(), witness.clone()).prop_map(
                 |(lhs, rhs, output)| BlackBoxFuncCall::XOR {
                     lhs: lhs[0],
                     rhs: rhs[1],
@@ -732,33 +737,26 @@ mod arb {
                 input.clone(),
                 witness.clone(),
                 witness.clone(),
-                witness.clone(),
             )
-                .prop_map(|(points, scalars, predicate, w1, w2, w3)| {
+                .prop_map(|(points, scalars, predicate, w1, w2)| {
                     BlackBoxFuncCall::MultiScalarMul {
                         points,
                         scalars,
                         predicate,
-                        outputs: (w1, w2, w3),
+                        outputs: (w1, w2),
                     }
                 });
 
-            let case_embedded_curve_add = (
-                input_arr_3.clone(),
-                input_arr_3,
-                input.clone(),
-                witness.clone(),
-                witness.clone(),
-                witness,
-            )
-                .prop_map(|(input1, input2, predicate, w1, w2, w3)| {
-                    BlackBoxFuncCall::EmbeddedCurveAdd {
-                        input1,
-                        input2,
-                        predicate,
-                        outputs: (w1, w2, w3),
-                    }
-                });
+            let case_embedded_curve_add =
+                (input_arr_2.clone(), input_arr_2, input.clone(), witness.clone(), witness)
+                    .prop_map(|(input1, input2, predicate, w1, w2)| {
+                        BlackBoxFuncCall::EmbeddedCurveAdd {
+                            input1,
+                            input2,
+                            predicate,
+                            outputs: (w1, w2),
+                        }
+                    });
 
             let case_keccakf1600 = (input_arr_25, witness_arr_25)
                 .prop_map(|(inputs, outputs)| BlackBoxFuncCall::Keccakf1600 { inputs, outputs });

acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs

@@ -501,8 +501,8 @@ impl<'a> Parser<'a> {
                 let predicate = self.parse_blackbox_input(Keyword::Predicate)?;
                 self.eat_comma_or_error()?;
 
-                let outputs = self.parse_blackbox_outputs_array::<3>()?;
-                let outputs = (outputs[0], outputs[1], outputs[2]);
+                let outputs = self.parse_blackbox_outputs_array::<2>()?;
+                let outputs = (outputs[0], outputs[1]);
 
                 BlackBoxFuncCall::MultiScalarMul { points, scalars, predicate, outputs }
             }
@@ -542,17 +542,17 @@ impl<'a> Parser<'a> {
                 }
             }
             BlackBoxFunc::EmbeddedCurveAdd => {
-                let input1 = self.parse_blackbox_inputs_array::<3>(Keyword::Input1)?;
+                let input1 = self.parse_blackbox_inputs_array::<2>(Keyword::Input1)?;
                 self.eat_comma_or_error()?;
 
-                let input2 = self.parse_blackbox_inputs_array::<3>(Keyword::Input2)?;
+                let input2 = self.parse_blackbox_inputs_array::<2>(Keyword::Input2)?;
                 self.eat_comma_or_error()?;
 
                 let predicate = self.parse_blackbox_input(Keyword::Predicate)?;
                 self.eat_comma_or_error()?;
 
-                let outputs = self.parse_blackbox_outputs_array::<3>()?;
-                let outputs = (outputs[0], outputs[1], outputs[2]);
+                let outputs = self.parse_blackbox_outputs_array::<2>()?;
+                let outputs = (outputs[0], outputs[1]);
 
                 BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, predicate, outputs }
             }

acvm-repo/acir/src/parser/mod.rs

@@ -370,7 +370,7 @@ fn embedded_curve_add() {
     private parameters: []
     public parameters: []
     return values: []
-    BLACKBOX::EMBEDDED_CURVE_ADD input1: [w0, w1, w2], input2: [w3, w4, w5], predicate: w6, outputs: [w7, w8, w9]
+    BLACKBOX::EMBEDDED_CURVE_ADD input1: [w0, w1], input2: [w2, w3], predicate: w4, outputs: [w5, w6]
     ";
     assert_circuit_roundtrip(src);
 }
@@ -382,7 +382,7 @@ fn embedded_curve_add_wrong_output_count() {
         private parameters: []
         public parameters: []
         return values: []
-        BLACKBOX::EMBEDDED_CURVE_ADD input1: [w0, w1, w2], input2: [w3, w4, w5], predicate: w6, outputs: [w7, w8]
+        BLACKBOX::EMBEDDED_CURVE_ADD input1: [w0, w1], input2: [w2, w3], predicate: w4, outputs: [w5]
     ";
     let _ = Circuit::from_str(src).unwrap();
 }
@@ -449,7 +449,7 @@ fn multi_scalar_mul() {
     private parameters: []
     public parameters: []
     return values: []
-    BLACKBOX::MULTI_SCALAR_MUL points: [w0, w1], scalars: [w2, w3], predicate: 1, outputs: [w4, w5, w6]
+    BLACKBOX::MULTI_SCALAR_MUL points: [w0, w1], scalars: [w2, w3], predicate: 1, outputs: [w4, w5]
     ";
     assert_circuit_roundtrip(src);
 }

acvm-repo/acir/src/parser/tests.rs

@@ -54,21 +54,21 @@ fn addition_circuit() {
 #[test]
 fn multi_scalar_mul_circuit() {
     let src = "
-    private parameters: [w1, w2, w3, w4, w5, w6]
+    private parameters: [w1, w2, w3, w4, w5]
     public parameters: []
-    return values: [w7, w8, w9]
-    BLACKBOX::MULTI_SCALAR_MUL points: [w1, w2, w3], scalars: [w4, w5], predicate: w6, outputs: [w7, w8, w9]
+    return values: [w6, w7]
+    BLACKBOX::MULTI_SCALAR_MUL points: [w1, w2], scalars: [w3, w4], predicate: w5, outputs: [w6, w7]
     ";
     let circuit = Circuit::from_str(src).unwrap();
 
     let program = Program { functions: vec![circuit], unconstrained_functions: vec![] };
 
     let bytes_msgpack =
         Program::serialize_program_with_format(&program, SerializationFormat::Msgpack);
-    insta::assert_compact_debug_snapshot!(bytes_msgpack, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 144, 189, 138, 66, 49, 16, 133, 241, 250, 179, 187, 175, 229, 194, 118, 91, 109, 177, 101, 24, 115, 71, 9, 198, 36, 204, 76, 196, 246, 138, 88, 95, 21, 172, 173, 188, 88, 248, 219, 248, 122, 6, 193, 96, 247, 49, 103, 206, 97, 206, 20, 243, 195, 48, 58, 45, 198, 59, 94, 45, 143, 47, 86, 14, 38, 184, 107, 124, 208, 190, 68, 94, 85, 151, 190, 5, 61, 238, 251, 217, 79, 90, 248, 6, 107, 171, 211, 111, 180, 98, 254, 52, 88, 160, 132, 139, 125, 240, 198, 9, 111, 170, 230, 223, 136, 67, 230, 86, 166, 34, 83, 187, 225, 167, 129, 215, 121, 212, 201, 212, 61, 4, 194, 210, 104, 16, 204, 179, 94, 227, 163, 132, 152, 114, 63, 62, 191, 110, 129, 204, 52, 169, 42, 0, 165, 243, 4, 137, 183, 173, 162, 221, 233, 246, 174, 33, 14, 172, 209, 111, 66, 125, 36, 148, 72, 78, 77, 193, 70, 124, 218, 207, 192, 140, 36, 106, 146, 114, 97, 132, 92, 223, 83, 151, 84, 91, 8, 140, 195, 82, 229, 63, 212, 15, 176, 100, 253, 143, 21, 1, 0, 0]");
+    insta::assert_compact_debug_snapshot!(bytes_msgpack, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 77, 143, 189, 10, 2, 49, 16, 132, 241, 252, 123, 47, 5, 59, 43, 11, 203, 176, 230, 86, 9, 198, 36, 236, 110, 196, 246, 68, 172, 79, 193, 222, 202, 195, 194, 223, 198, 215, 51, 10, 30, 118, 31, 59, 179, 195, 76, 182, 62, 79, 163, 211, 98, 188, 227, 221, 246, 242, 99, 229, 96, 129, 199, 202, 7, 237, 115, 228, 93, 113, 239, 89, 208, 243, 158, 95, 13, 146, 161, 15, 214, 22, 215, 97, 180, 98, 70, 26, 44, 80, 194, 205, 41, 120, 227, 132, 247, 69, 53, 54, 226, 144, 185, 81, 83, 86, 241, 215, 246, 39, 54, 107, 106, 157, 3, 97, 110, 52, 8, 214, 183, 118, 229, 163, 132, 152, 210, 58, 221, 103, 32, 179, 76, 162, 10, 64, 169, 147, 32, 241, 161, 145, 53, 91, 237, 71, 136, 19, 107, 244, 223, 189, 188, 16, 74, 36, 167, 150, 96, 35, 126, 158, 111, 192, 140, 36, 106, 145, 66, 97, 134, 92, 190, 82, 253, 180, 84, 8, 140, 195, 92, 213, 211, 203, 55, 238, 115, 64, 226, 8, 1, 0, 0]");
 
     let bytes_default = Program::serialize_program(&program);
-    insta::assert_compact_debug_snapshot!(bytes_default, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 61, 198, 187, 10, 128, 32, 20, 0, 80, 202, 158, 191, 101, 208, 214, 212, 208, 44, 210, 32, 93, 12, 82, 161, 213, 63, 240, 17, 206, 109, 109, 209, 39, 86, 203, 221, 14, 9, 62, 157, 222, 62, 20, 24, 95, 232, 186, 247, 70, 242, 142, 1, 216, 123, 48, 160, 197, 200, 25, 176, 237, 227, 17, 237, 53, 9, 45, 103, 165, 50, 84, 142, 34, 1, 89, 160, 74, 84, 21, 235, 166, 77, 89, 78, 138, 178, 114, 191, 157, 123, 1, 110, 20, 217, 141, 121, 0, 0, 0]");
+    insta::assert_compact_debug_snapshot!(bytes_default, @"[31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 69, 200, 187, 10, 128, 32, 20, 0, 80, 242, 81, 255, 101, 208, 214, 212, 208, 124, 145, 6, 233, 98, 144, 10, 173, 254, 129, 74, 53, 183, 181, 69, 159, 152, 147, 109, 135, 67, 83, 60, 175, 232, 95, 129, 32, 103, 177, 108, 157, 211, 178, 5, 68, 255, 244, 14, 173, 26, 36, 32, 172, 153, 123, 242, 247, 168, 172, 158, 140, 169, 138, 200, 159, 180, 136, 21, 241, 84, 55, 71, 69, 40, 227, 33, 43, 132, 15, 97, 220, 166, 97, 108, 0, 0, 0]");
 
     assert_deserialization(&program, [bytes_msgpack, bytes_default]);
 }

acvm-repo/acir/tests/test_program_serialization.rs

@@ -427,19 +427,17 @@ where
                 self.fold_inputs(points.as_slice());
                 self.fold_inputs(scalars.as_slice());
                 self.fold_input(predicate);
-                let (x, y, i) = outputs;
+                let (x, y) = outputs;
                 self.fold(*x);
                 self.fold(*y);
-                self.fold(*i);
             }
             BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, predicate, outputs } => {
                 self.fold_inputs(input1.as_slice());
                 self.fold_inputs(input2.as_slice());
                 self.fold_input(predicate);
-                let (x, y, i) = outputs;
+                let (x, y) = outputs;
                 self.fold(*x);
                 self.fold(*y);
-                self.fold(*i);
             }
             BlackBoxFuncCall::Keccakf1600 { inputs, outputs } => {
                 self.fold_inputs(inputs.as_slice());