feat!: add block opcode

acir/src/circuit/opcodes.rs

@@ -6,11 +6,25 @@ use crate::serialization::{read_n, read_u16, read_u32, write_bytes, write_u16, w
 use crate::BlackBoxFunc;
 use serde::{Deserialize, Serialize};
 
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Hash, Copy, Default)]
+pub struct BlockId(u32);
+
+/// Operation on a block
+/// We can either write or read at a block index
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct MemOp {
+    pub operation: Expression,
+    pub index: Expression,
+    pub value: Expression,
+}
+
 #[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum Opcode {
     Arithmetic(Expression),
     BlackBoxFuncCall(BlackBoxFuncCall),
     Directive(Directive),
+    // Abstract read/write operations on a block of data
+    Block(BlockId, Vec<MemOp>),
 }
 
 impl Opcode {
@@ -21,17 +35,18 @@ impl Opcode {
             Opcode::Arithmetic(_) => "arithmetic",
             Opcode::Directive(directive) => directive.name(),
             Opcode::BlackBoxFuncCall(g) => g.name.name(),
+            Opcode::Block(_, _) => "block",
         }
     }
-    // We have three types of opcodes allowed in the IR
-    // Expression, BlackBoxFuncCall and Directives
-    // When we serialize these opcodes, we use the index
+
+    // When we serialize the opcodes, we use the index
     // to uniquely identify which category of opcode we are dealing with.
     pub(crate) fn to_index(&self) -> u8 {
         match self {
             Opcode::Arithmetic(_) => 0,
             Opcode::BlackBoxFuncCall(_) => 1,
             Opcode::Directive(_) => 2,
+            Opcode::Block(_, _) => 3,
         }
     }
 
@@ -53,6 +68,17 @@ impl Opcode {
             Opcode::Arithmetic(expr) => expr.write(writer),
             Opcode::BlackBoxFuncCall(func_call) => func_call.write(writer),
             Opcode::Directive(directive) => directive.write(writer),
+            Opcode::Block(id, trace) => {
+                write_u32(&mut writer, id.0)?;
+                write_u32(&mut writer, trace.len() as u32)?;
+
+                for op in trace {
+                    op.operation.write(&mut writer)?;
+                    op.index.write(&mut writer)?;
+                    op.value.write(&mut writer)?;
+                }
+                Ok(())
+            }
         }
     }
     pub fn read<R: Read>(mut reader: R) -> std::io::Result<Self> {
@@ -74,6 +100,18 @@ impl Opcode {
                 let directive = Directive::read(reader)?;
                 Ok(Opcode::Directive(directive))
             }
+            3 => {
+                let id = read_u32(&mut reader)?;
+                let len = read_u32(&mut reader)?;
+                let mut trace = Vec::with_capacity(len as usize);
+                for _i in 0..len {
+                    let operation = Expression::read(&mut reader)?;
+                    let index = Expression::read(&mut reader)?;
+                    let value = Expression::read(&mut reader)?;
+                    trace.push(MemOp { operation, index, value });
+                }
+                Ok(Opcode::Block(BlockId(id), trace))
+            }
             _ => Err(std::io::ErrorKind::InvalidData.into()),
         }
     }
@@ -175,6 +213,10 @@ impl std::fmt::Display for Opcode {
                     witnesses.last().unwrap().witness_index()
                 ),
             },
+            Opcode::Block(id, trace) => {
+                write!(f, "BLOCK ")?;
+                write!(f, "(id: {}, len: {}) ", id.0, trace.len())
+            }
         }
     }
 }

acir/src/native_types/arithmetic.rs

@@ -149,6 +149,20 @@ impl Expression {
         Ok(expr)
     }
 
+    // Returns one witness belonging to the expression, in no relevant order
+    // Returns None if the expression is const
+    pub fn any_witness(&self) -> Option<Witness> {
+        if self.linear_combinations.is_empty() {
+            if self.mul_terms.is_empty() {
+                None
+            } else {
+                Some(self.mul_terms[0].1)
+            }
+        } else {
+            Some(self.linear_combinations[0].1)
+        }
+    }
+
     pub fn term_addition(&mut self, coefficient: acir_field::FieldElement, variable: Witness) {
         self.linear_combinations.push((coefficient, variable))
     }
@@ -171,7 +185,7 @@ impl Expression {
         self.mul_terms.is_empty() && self.linear_combinations.is_empty()
     }
 
-    /// Returns `true` if highest degree term in the expression is one.
+    /// Returns `true` if highest degree term in the expression is one or less.
     ///
     /// - `mul_term` in an expression contains degree-2 terms
     /// - `linear_combinations` contains degree-1 terms

acvm/src/compiler/transformers/fallback.rs

@@ -22,9 +22,8 @@ impl FallbackTransformer {
 
         for opcode in acir.opcodes {
             let bb_func_call = match &opcode {
-                Opcode::Arithmetic(_) | Opcode::Directive(_) => {
-                    // If it is not a black box function, then it is a directive or
-                    // an arithmetic expression which are always supported
+                Opcode::Arithmetic(_) | Opcode::Directive(_) | Opcode::Block(_, _) => {
+                    // directive, arithmetic expression or block are handled by acvm
                     acir_supported_opcodes.push(opcode);
                     continue;
                 }

acvm/src/lib.rs

@@ -13,6 +13,7 @@ use acir::{
     native_types::{Expression, Witness},
     BlackBoxFunc,
 };
+use pwg::block::Blocks;
 use std::collections::BTreeMap;
 use thiserror::Error;
 
@@ -61,13 +62,14 @@ pub trait PartialWitnessGenerator {
     fn solve(
         &self,
         initial_witness: &mut BTreeMap<Witness, FieldElement>,
-        mut opcodes: Vec<Opcode>,
+        mut opcode_to_solve: Vec<Opcode>,
     ) -> Result<(), OpcodeResolutionError> {
         let mut unresolved_opcodes: Vec<Opcode> = Vec::new();
-        while !opcodes.is_empty() {
+        let mut blocks = Blocks::default();
+        while !opcode_to_solve.is_empty() {
             unresolved_opcodes.clear();
 
-            for opcode in &opcodes {
+            for opcode in &opcode_to_solve {
                 let resolution = match opcode {
                     Opcode::Arithmetic(expr) => ArithmeticSolver::solve(initial_witness, expr),
                     Opcode::BlackBoxFuncCall(bb_func) => {
@@ -76,8 +78,8 @@ pub trait PartialWitnessGenerator {
                     Opcode::Directive(directive) => {
                         Self::solve_directives(initial_witness, directive)
                     }
+                    Opcode::Block(id, trace) => blocks.solve(*id, trace, initial_witness),
                 };
-
                 match resolution {
                     Ok(_) => {
                         // We do nothing in the happy case
@@ -91,7 +93,7 @@ pub trait PartialWitnessGenerator {
                     Err(err) => return Err(err),
                 }
             }
-            std::mem::swap(&mut opcodes, &mut unresolved_opcodes);
+            std::mem::swap(&mut opcode_to_solve, &mut unresolved_opcodes);
         }
         Ok(())
     }

acvm/src/pwg.rs

@@ -7,21 +7,33 @@ use acir::{
 };
 use std::collections::BTreeMap;
 
+use self::arithmetic::ArithmeticSolver;
+
 // arithmetic
 pub mod arithmetic;
 // Directives
 pub mod directives;
 // black box functions
+pub mod block;
 pub mod hash;
 pub mod logic;
 pub mod range;
 pub mod signature;
 pub mod sorting;
 
+// Returns the concrete value for a particular witness
+// Returns None if the witness has no assignment
+pub fn witness_to_value(
+    initial_witness: &BTreeMap<Witness, FieldElement>,
+    witness: Witness,
+) -> Option<&FieldElement> {
+    initial_witness.get(&witness)
+}
+
 // Returns the concrete value for a particular witness
 // If the witness has no assignment, then
 // an error is returned
-pub fn witness_to_value(
+pub fn witness_to_value_unwrap(
     initial_witness: &BTreeMap<Witness, FieldElement>,
     witness: Witness,
 ) -> Result<&FieldElement, OpcodeResolutionError> {
@@ -30,37 +42,31 @@ pub fn witness_to_value(
         None => Err(OpcodeNotSolvable::MissingAssignment(witness.0).into()),
     }
 }
+
+pub fn expression_to_const(expr: &Expression) -> Option<FieldElement> {
+    expr.is_const().then_some(expr.q_c)
+}
+
 // TODO: There is an issue open to decide on whether we need to get values from Expressions
 // TODO versus just getting values from Witness
 pub fn get_value(
     expr: &Expression,
     initial_witness: &BTreeMap<Witness, FieldElement>,
-) -> Result<FieldElement, OpcodeResolutionError> {
-    let mut result = expr.q_c;
-
-    for term in &expr.linear_combinations {
-        let coefficient = term.0;
-        let variable = term.1;
-
-        // Get the value assigned to that variable
-        let assignment = *witness_to_value(initial_witness, variable)?;
-
-        result += coefficient * assignment;
-    }
-
-    for term in &expr.mul_terms {
-        let coefficient = term.0;
-        let lhs_variable = term.1;
-        let rhs_variable = term.2;
-
-        // Get the values assigned to those variables
-        let lhs_assignment = *witness_to_value(initial_witness, lhs_variable)?;
-        let rhs_assignment = *witness_to_value(initial_witness, rhs_variable)?;
+) -> Option<FieldElement> {
+    expression_to_const(&ArithmeticSolver::evaluate(expr, initial_witness))
+}
 
-        result += coefficient * lhs_assignment * rhs_assignment;
+pub fn get_value_unwrap(
+    expr: &Expression,
+    initial_witness: &BTreeMap<Witness, FieldElement>,
+) -> Result<FieldElement, OpcodeResolutionError> {
+    let expr = ArithmeticSolver::evaluate(expr, initial_witness);
+    match expression_to_const(&expr) {
+        Some(value) => Ok(value),
+        None => Err(OpcodeResolutionError::OpcodeNotSolvable(
+            OpcodeNotSolvable::MissingAssignment(expr.any_witness().unwrap().0),
+        )),
     }
-
-    Ok(result)
 }
 
 // Inserts `value` into the initial witness map

acvm/src/pwg/arithmetic.rs

@@ -11,7 +11,7 @@ use crate::{OpcodeNotSolvable, OpcodeResolutionError};
 pub struct ArithmeticSolver;
 
 #[allow(clippy::enum_variant_names)]
-enum GateStatus {
+pub enum GateStatus {
     GateSatisfied(FieldElement),
     GateSolvable(FieldElement, (FieldElement, Witness)),
     GateUnsolvable,
@@ -162,7 +162,7 @@ impl ArithmeticSolver {
     /// Returns the summation of all of the variables, plus the unknown variable
     /// Returns None, if there is more than one unknown variable
     /// We cannot assign
-    fn solve_fan_in_term(
+    pub fn solve_fan_in_term(
         arith_gate: &Expression,
         witness_assignments: &BTreeMap<Witness, FieldElement>,
     ) -> GateStatus {