feat(comptime): Implement blackbox functions in comptime interpreter

Cargo.toml

@@ -157,6 +157,8 @@ proptest-derive = "0.4.0"
 rayon = "1.8.0"
 sha2 = { version = "0.10.6", features = ["compress"] }
 sha3 = "0.10.6"
+strum = "0.24"
+strum_macros = "0.24"
 
 im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"

acvm-repo/acir/Cargo.toml

@@ -24,11 +24,11 @@ flate2.workspace = true
 bincode.workspace = true
 base64.workspace = true
 serde-big-array = "0.5.1"
+strum = { workspace = true }
+strum_macros = { workspace = true }
 
 [dev-dependencies]
 serde_json = "1.0"
-strum = "0.24"
-strum_macros = "0.24"
 serde-reflection = "0.3.6"
 serde-generate = "0.25.1"
 fxhash.workspace = true

acvm-repo/acir/src/circuit/black_box_functions.rs

@@ -4,15 +4,13 @@
 //! implemented in more basic constraints.
 
 use serde::{Deserialize, Serialize};
-#[cfg(test)]
 use strum_macros::EnumIter;
 
 #[allow(clippy::upper_case_acronyms)]
-#[derive(Clone, Debug, Hash, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[cfg_attr(test, derive(EnumIter))]
+#[derive(Clone, Debug, Hash, Copy, PartialEq, Eq, Serialize, Deserialize, EnumIter)]
 pub enum BlackBoxFunc {
     /// Ciphers (encrypts) the provided plaintext using AES128 in CBC mode,
     /// padding the input using PKCS#7.
     /// - inputs: byte array `[u8; N]`
     /// - iv: initialization vector `[u8; 16]`
     /// - key: user key `[u8; 16]`

acvm-repo/acvm/Cargo.toml

@@ -25,22 +25,19 @@ acvm_blackbox_solver.workspace = true
 indexmap = "1.7.0"
 
 [features]
-bn254 = [
-    "acir/bn254",
-    "brillig_vm/bn254",
-    "acvm_blackbox_solver/bn254",
-]
+bn254 = ["acir/bn254", "brillig_vm/bn254", "acvm_blackbox_solver/bn254"]
 bls12_381 = [
     "acir/bls12_381",
     "brillig_vm/bls12_381",
     "acvm_blackbox_solver/bls12_381",
 ]
 
 [dev-dependencies]
-ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
+ark-bls12-381 = { version = "^0.4.0", default-features = false, features = [
+    "curve",
+] }
 ark-bn254.workspace = true
 bn254_blackbox_solver.workspace = true
 proptest.workspace = true
 zkhash = { version = "^0.2.0", default-features = false }
 num-bigint.workspace = true
-

acvm-repo/blackbox_solver/src/bigint.rs

@@ -84,7 +84,7 @@
             }
             BlackBoxFunc::BigIntMul => lhs * rhs,
             BlackBoxFunc::BigIntDiv => {
                 lhs * rhs.modpow(&(&modulus - BigUint::from(2_u32)), &modulus)
             } //TODO ensure that modulus is prime
             _ => unreachable!("ICE - bigint_op must be called for an operation"),
         };
@@ -97,3 +97,51 @@
         Ok(())
     }
 }
+
+/// Wrapper over the generic bigint solver to automatically assign bigint IDs.
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct BigintSolverWithId {
+    solver: BigIntSolver,
+    last_id: u32,
+}
+
+impl BigintSolverWithId {
+    pub fn create_bigint_id(&mut self) -> u32 {
+        let output = self.last_id;
+        self.last_id += 1;
+        output
+    }
+
+    pub fn bigint_from_bytes(
+        &mut self,
+        inputs: &[u8],
+        modulus: &[u8],
+    ) -> Result<u32, BlackBoxResolutionError> {
+        let id = self.create_bigint_id();
+        self.solver.bigint_from_bytes(inputs, modulus, id)?;
+        Ok(id)
+    }
+
+    pub fn bigint_to_bytes(&self, input: u32) -> Result<Vec<u8>, BlackBoxResolutionError> {
+        self.solver.bigint_to_bytes(input)
+    }
+
+    pub fn bigint_op(
+        &mut self,
+        lhs: u32,
+        rhs: u32,
+        func: BlackBoxFunc,
+    ) -> Result<u32, BlackBoxResolutionError> {
+        let modulus_lhs = self.solver.get_modulus(lhs, func)?;
+        let modulus_rhs = self.solver.get_modulus(rhs, func)?;
+        if modulus_lhs != modulus_rhs {
+            return Err(BlackBoxResolutionError::Failed(
+                func,
+                "moduli should be identical in BigInt operation".to_string(),
+            ));
+        }
+        let id = self.create_bigint_id();
+        self.solver.bigint_op(lhs, rhs, id, func)?;
+        Ok(id)
+    }
+}

acvm-repo/blackbox_solver/src/lib.rs

@@ -18,7 +18,7 @@ mod hash;
 mod logic;
 
 pub use aes128::aes128_encrypt;
-pub use bigint::BigIntSolver;
+pub use bigint::{BigIntSolver, BigintSolverWithId};
 pub use curve_specific_solver::{BlackBoxFunctionSolver, StubbedBlackBoxSolver};
 pub use ecdsa::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
 pub use hash::{blake2s, blake3, keccakf1600, sha256_compression};

acvm-repo/brillig_vm/src/black_box.rs

@@ -1,9 +1,8 @@
 use acir::brillig::{BlackBoxOp, HeapArray, HeapVector, IntegerBitSize};
 use acir::{AcirField, BlackBoxFunc};
-use acvm_blackbox_solver::BigIntSolver;
 use acvm_blackbox_solver::{
     aes128_encrypt, blake2s, blake3, ecdsa_secp256k1_verify, ecdsa_secp256r1_verify, keccakf1600,
-    sha256_compression, BlackBoxFunctionSolver, BlackBoxResolutionError,
+    sha256_compression, BigintSolverWithId, BlackBoxFunctionSolver, BlackBoxResolutionError,
 };
 use num_bigint::BigUint;
 use num_traits::Zero;
@@ -39,6 +38,8 @@
     input.iter().map(|&x| x.into()).collect()
 }
 
+pub(crate) type BrilligBigintSolver = BigintSolverWithId;
+
 pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>>(
     op: &BlackBoxOp,
     solver: &Solver,
@@ -56,11 +57,11 @@
             })?;
             let key: [u8; 16] =
                 to_u8_vec(read_heap_array(memory, key)).try_into().map_err(|_| {
-                    BlackBoxResolutionError::Failed(bb_func, "Invalid ley length".to_string())
+                    BlackBoxResolutionError::Failed(bb_func, "Invalid key length".to_string())
                 })?;
             let ciphertext = aes128_encrypt(&inputs, iv, key)?;
 
             memory.write(outputs.size, ciphertext.len().into());
             memory.write_slice(memory.read_ref(outputs.pointer), &to_value_vec(&ciphertext));
 
             Ok(())
@@ -353,54 +354,6 @@
     }
 }
 
-/// Wrapper over the generic bigint solver to automatically assign bigint ids in brillig
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub(crate) struct BrilligBigintSolver {
-    bigint_solver: BigIntSolver,
-    last_id: u32,
-}
-
-impl BrilligBigintSolver {
-    pub(crate) fn create_bigint_id(&mut self) -> u32 {
-        let output = self.last_id;
-        self.last_id += 1;
-        output
-    }
-
-    pub(crate) fn bigint_from_bytes(
-        &mut self,
-        inputs: &[u8],
-        modulus: &[u8],
-    ) -> Result<u32, BlackBoxResolutionError> {
-        let id = self.create_bigint_id();
-        self.bigint_solver.bigint_from_bytes(inputs, modulus, id)?;
-        Ok(id)
-    }
-
-    pub(crate) fn bigint_to_bytes(&self, input: u32) -> Result<Vec<u8>, BlackBoxResolutionError> {
-        self.bigint_solver.bigint_to_bytes(input)
-    }
-
-    pub(crate) fn bigint_op(
-        &mut self,
-        lhs: u32,
-        rhs: u32,
-        func: BlackBoxFunc,
-    ) -> Result<u32, BlackBoxResolutionError> {
-        let modulus_lhs = self.bigint_solver.get_modulus(lhs, func)?;
-        let modulus_rhs = self.bigint_solver.get_modulus(rhs, func)?;
-        if modulus_lhs != modulus_rhs {
-            return Err(BlackBoxResolutionError::Failed(
-                func,
-                "moduli should be identical in BigInt operation".to_string(),
-            ));
-        }
-        let id = self.create_bigint_id();
-        self.bigint_solver.bigint_op(lhs, rhs, id, func)?;
-        Ok(id)
-    }
-}
-
 fn black_box_function_from_op(op: &BlackBoxOp) -> BlackBoxFunc {
     match op {
         BlackBoxOp::AES128Encrypt { .. } => BlackBoxFunc::AES128Encrypt,

compiler/noirc_frontend/Cargo.toml

@@ -30,8 +30,8 @@ cfg-if.workspace = true
 tracing.workspace = true
 petgraph = "0.6"
 rangemap = "1.4.0"
-strum = "0.24"
-strum_macros = "0.24"
+strum.workspace = true
+strum_macros.workspace = true
 
 
 [dev-dependencies]

compiler/noirc_frontend/src/hir/comptime/errors.rs

@@ -200,6 +200,11 @@ pub enum InterpreterError {
         item: String,
         location: Location,
     },
+    InvalidInComptimeContext {
+        item: String,
+        location: Location,
+        explanation: String,
+    },
     TypeAnnotationsNeededForMethodCall {
         location: Location,
     },
@@ -291,6 +296,7 @@ impl InterpreterError {
             | InterpreterError::UnsupportedTopLevelItemUnquote { location, .. }
             | InterpreterError::ComptimeDependencyCycle { location, .. }
             | InterpreterError::Unimplemented { location, .. }
+            | InterpreterError::InvalidInComptimeContext { location, .. }
             | InterpreterError::NoImpl { location, .. }
             | InterpreterError::ImplMethodTypeMismatch { location, .. }
             | InterpreterError::DebugEvaluateComptime { location, .. }
@@ -540,6 +546,10 @@ impl<'a> From<&'a InterpreterError> for CustomDiagnostic {
                 let msg = format!("{item} is currently unimplemented");
                 CustomDiagnostic::simple_error(msg, String::new(), location.span)
             }
+            InterpreterError::InvalidInComptimeContext { item, location, explanation } => {
+                let msg = format!("{item} is invalid in comptime context");
+                CustomDiagnostic::simple_error(msg, explanation.clone(), location.span)
+            }
             InterpreterError::BreakNotInLoop { location } => {
                 let msg = "There is no loop to break out of!".into();
                 CustomDiagnostic::simple_error(msg, String::new(), location.span)