Merge branch 'master' into jl/brillig_entry

Author: TomAFrench

.github/scripts/run-external-repo-tests.sh

@@ -28,7 +28,7 @@ sed -i '/^compiler_version/d' {Nargo.toml,./**/Nargo.toml}
 set -e
 
 BEFORE=$SECONDS
-$NARGO test --silence-warnings --skip-brillig-constraints-check --pedantic-solving --format json $NARGO_ARGS | tee $OUTPUT_FILE
+$NARGO test --silence-warnings --skip-brillig-constraints-check --format json $NARGO_ARGS | tee $OUTPUT_FILE
 TIME=$(($SECONDS-$BEFORE))
 
 if [ ! -s $OUTPUT_FILE ]; then

EXTERNAL_NOIR_LIBRARIES.yml

@@ -89,7 +89,7 @@ libraries:
     repo: AztecProtocol/aztec-packages
     ref: *AZ_COMMIT
     path: noir-projects/noir-protocol-circuits/crates/private-kernel-lib
-    timeout: 400
+    timeout: 450
     critical: false
   protocol_circuits_types:
     repo: AztecProtocol/aztec-packages

acvm-repo/acvm/benches/arithmetic_solver.rs

@@ -72,7 +72,7 @@ fn bench_bytecode<F: AcirField>(c: &mut Criterion, benchmark_name: &str, bytecod
         b.iter_batched(
             || {
                 let initial_witness = WitnessMap::from(BTreeMap::from([(Witness(0), F::one())]));
-                ACVM::new(&StubbedBlackBoxSolver(true), bytecode, initial_witness, &[], &[])
+                ACVM::new(&StubbedBlackBoxSolver, bytecode, initial_witness, &[], &[])
             },
             |mut vm| {
                 let status = vm.solve();

acvm-repo/acvm/src/compiler/validator.rs

@@ -476,7 +476,7 @@ mod tests {
             (Witness(3), FieldElement::from(5u128)),
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 
@@ -501,7 +501,7 @@ mod tests {
             (Witness(3), FieldElement::from(6u128)), // Wrong value!
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_err());
     }
 
@@ -522,7 +522,7 @@ mod tests {
             (Witness(3), FieldElement::from(12u128)),
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 
@@ -538,7 +538,7 @@ mod tests {
             (Witness(1), FieldElement::from(255u128)), // Max 8-bit value
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 
@@ -554,7 +554,7 @@ mod tests {
             (Witness(1), FieldElement::from(256u128)), // Too large for 8 bits
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_err());
     }
 
@@ -574,7 +574,7 @@ mod tests {
             (Witness(3), FieldElement::from(0b1000u128)),
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 
@@ -594,7 +594,7 @@ mod tests {
             (Witness(3), FieldElement::from(0b1111u128)), // Wrong!
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_err());
     }
 
@@ -614,7 +614,7 @@ mod tests {
             (Witness(3), FieldElement::from(0b0110u128)),
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 
@@ -634,7 +634,7 @@ mod tests {
             (Witness(3), FieldElement::from(0b1111u128)), // Wrong!
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_err());
     }
 
@@ -651,7 +651,7 @@ mod tests {
         // Empty witness map - missing w1
         let witness_map = WitnessMap::default();
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         // The expression evaluates with missing witness, but won't be zero
         // so this should fail
         assert!(validate_witness(&backend, witness_map, &circuit).is_err());
@@ -674,7 +674,7 @@ mod tests {
             (Witness(3), FieldElement::from(3u128)),
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 
@@ -695,7 +695,7 @@ mod tests {
             (Witness(3), FieldElement::from(3u128)),
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_err());
     }
 
@@ -716,7 +716,7 @@ mod tests {
             (Witness(2), FieldElement::from(2u128)),
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_err());
     }
 
@@ -741,7 +741,7 @@ mod tests {
         let witness_map =
             WitnessMap::from(BTreeMap::from_iter([(Witness(4), FieldElement::zero())]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 
@@ -771,7 +771,7 @@ mod tests {
             (Witness(3), FieldElement::from(42u128)), // Should match value at index 0
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 
@@ -799,7 +799,7 @@ mod tests {
             (Witness(3), FieldElement::from(99u128)), // Wrong! Should be 42
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_err());
     }
 
@@ -835,7 +835,7 @@ mod tests {
             (Witness(4), FieldElement::from(100u128)), // Read should get written value
         ]));
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 
@@ -859,7 +859,7 @@ mod tests {
         // Empty witness map
         let witness_map = WitnessMap::default();
 
-        let backend = Bn254BlackBoxSolver(false);
+        let backend = Bn254BlackBoxSolver;
         assert!(validate_witness(&backend, witness_map, &circuit).is_ok());
     }
 }

acvm-repo/acvm/src/pwg/brillig.rs

@@ -377,7 +377,7 @@ mod tests {
         let inputs =
             vec![BrilligInputs::Single(w1), BrilligInputs::Single(w2), BrilligInputs::Single(w3)];
 
-        let backend = acvm_blackbox_solver::StubbedBlackBoxSolver(false);
+        let backend = acvm_blackbox_solver::StubbedBlackBoxSolver;
         let bytecode = vec![
             Opcode::Const {
                 destination: MemoryAddress::Direct(21),

acvm-repo/acvm/src/pwg/memory_op.rs

@@ -106,7 +106,6 @@ impl<F: AcirField> MemoryOpSolver<F> {
         &mut self,
         op: &MemOp<F>,
         initial_witness: &mut WitnessMap<F>,
-        pedantic_solving: bool,
     ) -> Result<(), OpcodeResolutionError<F>> {
         let operation = get_value(&op.operation, initial_witness)?;
 
@@ -122,15 +121,13 @@ impl<F: AcirField> MemoryOpSolver<F> {
 
         // `operation == 0` implies a read operation. (`operation == 1` implies write operation).
         let is_read_operation = operation.is_zero();
-        if pedantic_solving {
-            // We expect that the 'operation' should resolve to either 0 or 1.
-            if !is_read_operation && !operation.is_one() {
-                let opcode_location = ErrorLocation::Unresolved;
-                return Err(OpcodeResolutionError::MemoryOperationLargerThanOne {
-                    opcode_location,
-                    operation,
-                });
-            }
+        // We expect that the 'operation' should resolve to either 0 or 1.
+        if !is_read_operation && !operation.is_one() {
+            let opcode_location = ErrorLocation::Unresolved;
+            return Err(OpcodeResolutionError::MemoryOperationLargerThanOne {
+                opcode_location,
+                operation,
+            });
         }
 
         if is_read_operation {
@@ -187,8 +184,7 @@ mod tests {
         let mut block_solver = MemoryOpSolver::new(&init, &initial_witness).unwrap();
 
         for op in trace {
-            let pedantic_solving = true;
-            block_solver.solve_memory_op(&op, &mut initial_witness, pedantic_solving).unwrap();
+            block_solver.solve_memory_op(&op, &mut initial_witness).unwrap();
         }
 
         assert_eq!(initial_witness[&Witness(4)], FieldElement::from(2u128));
@@ -212,9 +208,7 @@ mod tests {
         let mut err = None;
         for op in invalid_trace {
             if err.is_none() {
-                let pedantic_solving = true;
-                err =
-                    block_solver.solve_memory_op(&op, &mut initial_witness, pedantic_solving).err();
+                err = block_solver.solve_memory_op(&op, &mut initial_witness).err();
             }
         }
 

acvm-repo/acvm/src/pwg/mod.rs

@@ -504,7 +504,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
                     .block_solvers
                     .get_mut(block_id)
                     .expect("Memory block should have been initialized before use");
-                solver.solve_memory_op(op, &mut self.witness_map, self.backend.pedantic_solving())
+                solver.solve_memory_op(op, &mut self.witness_map)
             }
             Opcode::BrilligCall { id, inputs, outputs, predicate } => {
                 match self.solve_brillig_call_opcode(id, inputs, outputs, predicate) {
@@ -612,12 +612,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
     ) -> Result<Option<ForeignCallWaitInfo<F>>, OpcodeResolutionError<F>> {
         let opcode_location =
             ErrorLocation::Resolved(OpcodeLocation::Acir(self.instruction_pointer()));
-        if is_predicate_false(
-            &self.witness_map,
-            predicate,
-            self.backend.pedantic_solving(),
-            &opcode_location,
-        )? {
+        if is_predicate_false(&self.witness_map, predicate, &opcode_location)? {
             return BrilligSolver::<F, B>::zero_out_brillig_outputs(&mut self.witness_map, outputs)
                 .map(|_| None);
         }
@@ -696,12 +691,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
         let opcode_location =
             ErrorLocation::Resolved(OpcodeLocation::Acir(self.instruction_pointer()));
         let witness = &mut self.witness_map;
-        let should_skip = match is_predicate_false(
-            witness,
-            predicate,
-            self.backend.pedantic_solving(),
-            &opcode_location,
-        ) {
+        let should_skip = match is_predicate_false(witness, predicate, &opcode_location) {
             Ok(result) => result,
             Err(err) => return StepResult::Status(self.handle_opcode_resolution(Err(err))),
         };
@@ -754,12 +744,7 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> ACVM<'a, F, B> {
             return Err(OpcodeResolutionError::AcirMainCallAttempted { opcode_location });
         }
 
-        if is_predicate_false(
-            &self.witness_map,
-            predicate,
-            self.backend.pedantic_solving(),
-            &opcode_location,
-        )? {
+        if is_predicate_false(&self.witness_map, predicate, &opcode_location)? {
             // Zero out the outputs if we have a false predicate
             for output in outputs {
                 insert_value(output, F::zero(), &mut self.witness_map)?;
@@ -898,21 +883,17 @@ fn any_witness_from_expression<F>(expr: &Expression<F>) -> Option<Witness> {
 pub(crate) fn is_predicate_false<F: AcirField>(
     witness: &WitnessMap<F>,
     predicate: &Expression<F>,
-    pedantic_solving: bool,
     opcode_location: &ErrorLocation,
 ) -> Result<bool, OpcodeResolutionError<F>> {
     let pred_value = get_value(predicate, witness)?;
     let predicate_is_false = pred_value.is_zero();
-    if pedantic_solving {
-        // We expect that the predicate should resolve to either 0 or 1.
-        if !predicate_is_false && !pred_value.is_one() {
-            let opcode_location = *opcode_location;
-            return Err(OpcodeResolutionError::PredicateLargerThanOne {
-                opcode_location,
-                pred_value,
-            });
-        }
+
+    // We expect that the predicate should resolve to either 0 or 1.
+    if !predicate_is_false && !pred_value.is_one() {
+        let opcode_location = *opcode_location;
+        return Err(OpcodeResolutionError::PredicateLargerThanOne { opcode_location, pred_value });
     }
+
     Ok(predicate_is_false)
 }
 
@@ -947,7 +928,7 @@ mod tests {
             (Witness(2), FieldElement::from(1u128)),
             (Witness(3), FieldElement::from(2u128)),
         ]));
-        let backend = acvm_blackbox_solver::StubbedBlackBoxSolver(false);
+        let backend = acvm_blackbox_solver::StubbedBlackBoxSolver;
 
         let src = "
         BLACKBOX::RANGE input: w1, bits: 32
@@ -967,7 +948,7 @@ mod tests {
     fn errors_when_calling_function_zero() {
         let initial_witness =
             WitnessMap::from(BTreeMap::from_iter([(Witness(1), FieldElement::from(1u128))]));
-        let backend = acvm_blackbox_solver::StubbedBlackBoxSolver(false);
+        let backend = acvm_blackbox_solver::StubbedBlackBoxSolver;
 
         let src = "
         CALL func: 0, predicate: 1, inputs: [w1], outputs: [w2]