fix: solvable intermediate gates for csat

Cargo.toml

@@ -13,7 +13,6 @@ repository = "https://github.com/noir-lang/acvm/"
 acir = { version = "0.17.0", path = "acir", default-features = false }
 acir_field = { version = "0.17.0", path = "acir_field", default-features = false }
 stdlib = { package = "acvm_stdlib", version = "0.17.0", path = "stdlib", default-features = false }
-rmp-serde = "1.1.0"
 
 num-bigint = "0.4"
 num-traits = "0.2"

acir/Cargo.toml

@@ -15,7 +15,7 @@ acir_field.workspace = true
 serde.workspace = true
 brillig_vm = { version = "0.17.0", path = "../brillig_vm", default-features = false }
 thiserror.workspace = true
-rmp-serde.workspace = true
+rmp-serde = "1.1.0"
 flate2 = "1.0.24"
 
 [dev-dependencies]

acir/src/circuit/brillig.rs

@@ -4,15 +4,15 @@ use serde::{Deserialize, Serialize};
 
 /// Inputs for the Brillig VM. These are the initial inputs
 /// that the Brillig VM will use to start.
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug, Hash)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
 pub enum BrilligInputs {
     Single(Expression),
     Array(Vec<Expression>),
 }
 
 /// Outputs for the Brillig VM. Once the VM has completed
 /// execution, this will be the object that is returned.
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug, Hash)]
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
 pub enum BrilligOutputs {
     Simple(Witness),
     Array(Vec<Witness>),

acvm/Cargo.toml

@@ -14,7 +14,6 @@ repository.workspace = true
 num-bigint.workspace = true
 num-traits.workspace = true
 thiserror.workspace = true
-rmp-serde.workspace = true
 
 acir.workspace = true
 stdlib.workspace = true

acvm/src/compiler/mod.rs

@@ -1,5 +1,5 @@
 use acir::{
-    circuit::{Circuit, Opcode, OpcodeLabel},
+    circuit::{brillig::BrilligOutputs, directives::Directive, Circuit, Opcode, OpcodeLabel},
     native_types::{Expression, Witness},
     BlackBoxFunc, FieldElement,
 };
@@ -26,6 +26,7 @@ pub enum CompileError {
 /// Applies [`ProofSystemCompiler`][crate::ProofSystemCompiler] specific optimizations to a [`Circuit`].
 pub fn compile(
     acir: Circuit,
+    inputs: Vec<Witness>,
     np_language: Language,
     is_opcode_supported: impl Fn(&Opcode) -> bool,
     simplifier: &CircuitSimplifier,
@@ -58,12 +59,18 @@ pub fn compile(
     let range_optimizer = RangeOptimizer::new(acir);
     let (acir, opcode_label) = range_optimizer.replace_redundant_ranges(opcode_label);
 
-    let transformer = match &np_language {
+    let mut transformer = match &np_language {
         crate::Language::R1CS => {
             let transformer = R1CSTransformer::new(acir);
             return Ok((transformer.transform(), opcode_label));
         }
-        crate::Language::PLONKCSat { width } => CSatTransformer::new(*width),
+        crate::Language::PLONKCSat { width } => {
+            let mut csat = CSatTransformer::new(*width);
+            for value in inputs {
+                csat.solvable(value);
+            }
+            csat
+        }
     };
 
     // TODO: the code below is only for CSAT transformer
@@ -102,15 +109,96 @@ pub fn compile(
                     new_gates.push(intermediate_gate);
                 }
                 new_gates.push(arith_expr);
-                new_gates.sort();
                 for gate in new_gates {
                     new_opcode_labels.push(opcode_label[index]);
                     transformed_gates.push(Opcode::Arithmetic(gate));
                 }
             }
-            other_gate => {
+            Opcode::BlackBoxFuncCall(func) => {
+                match func {
+                    acir::circuit::opcodes::BlackBoxFuncCall::AND { output, .. }
+                    | acir::circuit::opcodes::BlackBoxFuncCall::XOR { output, .. } => {
+                        transformer.solvable(*output)
+                    }
+                    acir::circuit::opcodes::BlackBoxFuncCall::RANGE { .. } => (),
+                    acir::circuit::opcodes::BlackBoxFuncCall::SHA256 { outputs, .. }
+                    | acir::circuit::opcodes::BlackBoxFuncCall::Keccak256 { outputs, .. }
+                    | acir::circuit::opcodes::BlackBoxFuncCall::Keccak256VariableLength {
+                        outputs,
+                        ..
+                    }
+                    | acir::circuit::opcodes::BlackBoxFuncCall::RecursiveAggregation {
+                        output_aggregation_object: outputs,
+                        ..
+                    }
+                    | acir::circuit::opcodes::BlackBoxFuncCall::Blake2s { outputs, .. } => {
+                        for witness in outputs {
+                            transformer.solvable(*witness);
+                        }
+                    }
+                    acir::circuit::opcodes::BlackBoxFuncCall::FixedBaseScalarMul {
+                        outputs,
+                        ..
+                    }
+                    | acir::circuit::opcodes::BlackBoxFuncCall::Pedersen { outputs, .. } => {
+                        transformer.solvable(outputs.0);
+                        transformer.solvable(outputs.1)
+                    }
+                    acir::circuit::opcodes::BlackBoxFuncCall::HashToField128Security {
+                        output,
+                        ..
+                    }
+                    | acir::circuit::opcodes::BlackBoxFuncCall::EcdsaSecp256k1 { output, .. }
+                    | acir::circuit::opcodes::BlackBoxFuncCall::EcdsaSecp256r1 { output, .. }
+                    | acir::circuit::opcodes::BlackBoxFuncCall::SchnorrVerify { output, .. } => {
+                        transformer.solvable(*output)
+                    }
+                }
+
+                new_opcode_labels.push(opcode_label[index]);
+                transformed_gates.push(opcode.clone());
+            }
+            Opcode::Directive(directive) => {
+                dbg!(&directive);
+                match directive {
+                    Directive::Invert { result, .. } => {
+                        transformer.solvable(*result);
+                    }
+                    Directive::Quotient(quotient_directive) => {
+                        transformer.solvable(quotient_directive.q);
+                        transformer.solvable(quotient_directive.r);
+                    }
+                    Directive::ToLeRadix { b, .. } => {
+                        for w in b {
+                            transformer.solvable(*w);
+                        }
+                    }
+                    Directive::PermutationSort { bits, .. } => {
+                        for w in bits {
+                            transformer.solvable(*w);
+                        }
+                    }
+                    Directive::Log(_) => (),
+                }
+                new_opcode_labels.push(opcode_label[index]);
+                transformed_gates.push(opcode.clone());
+            }
+            Opcode::Block(_) => todo!(),
+            Opcode::ROM(_) => todo!(),
+            Opcode::RAM(_) => todo!(),
+            Opcode::Brillig(brillig) => {
+                for output in &brillig.outputs {
+                    match output {
+                        BrilligOutputs::Simple(w) => transformer.solvable(*w),
+                        BrilligOutputs::Array(v) => {
+                            for w in v {
+                                transformer.solvable(*w);
+                            }
+                        }
+                    }
+                }
                 new_opcode_labels.push(opcode_label[index]);
-                transformed_gates.push(other_gate.clone())
+                transformed_gates.push(opcode.clone());
             }
         }
     }