feat: Sync commits from aztec-packages

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

@@ -47,8 +47,22 @@ pub enum BlackBoxFunc {
     RecursiveAggregation,
     /// Addition over the embedded curve on which [`FieldElement`][acir_field::FieldElement] is defined.
     EmbeddedCurveAdd,
-    /// Point doubling over the embedded curve on which [`FieldElement`][acir_field::FieldElement] is defined.
-    EmbeddedCurveDouble,
+    /// BigInt addition
+    BigIntAdd,
+    /// BigInt subtraction
+    BigIntNeg,
+    /// BigInt multiplication
+    BigIntMul,
+    /// BigInt division
+    BigIntDiv,
+    /// BigInt from le bytes
+    BigIntFromLeBytes,
+    /// BigInt to le bytes
+    BigIntToLeBytes,
+    /// Permutation function of Poseidon2
+    Poseidon2Permutation,
+    /// SHA256 compression function
+    Sha256Compression,
 }
 
 impl std::fmt::Display for BlackBoxFunc {
@@ -68,17 +82,25 @@ impl BlackBoxFunc {
             BlackBoxFunc::PedersenHash => "pedersen_hash",
             BlackBoxFunc::EcdsaSecp256k1 => "ecdsa_secp256k1",
             BlackBoxFunc::FixedBaseScalarMul => "fixed_base_scalar_mul",
-            BlackBoxFunc::EmbeddedCurveAdd => "ec_add",
-            BlackBoxFunc::EmbeddedCurveDouble => "ec_double",
+            BlackBoxFunc::EmbeddedCurveAdd => "embedded_curve_add",
             BlackBoxFunc::AND => "and",
             BlackBoxFunc::XOR => "xor",
             BlackBoxFunc::RANGE => "range",
             BlackBoxFunc::Keccak256 => "keccak256",
             BlackBoxFunc::Keccakf1600 => "keccakf1600",
             BlackBoxFunc::RecursiveAggregation => "recursive_aggregation",
             BlackBoxFunc::EcdsaSecp256r1 => "ecdsa_secp256r1",
+            BlackBoxFunc::BigIntAdd => "bigint_add",
+            BlackBoxFunc::BigIntNeg => "bigint_neg",
+            BlackBoxFunc::BigIntMul => "bigint_mul",
+            BlackBoxFunc::BigIntDiv => "bigint_div",
+            BlackBoxFunc::BigIntFromLeBytes => "bigint_from_le_bytes",
+            BlackBoxFunc::BigIntToLeBytes => "bigint_to_le_bytes",
+            BlackBoxFunc::Poseidon2Permutation => "poseidon2_permutation",
+            BlackBoxFunc::Sha256Compression => "sha256_compression",
         }
     }
+
     pub fn lookup(op_name: &str) -> Option<BlackBoxFunc> {
         match op_name {
             "sha256" => Some(BlackBoxFunc::SHA256),
@@ -90,17 +112,25 @@ impl BlackBoxFunc {
             "ecdsa_secp256k1" => Some(BlackBoxFunc::EcdsaSecp256k1),
             "ecdsa_secp256r1" => Some(BlackBoxFunc::EcdsaSecp256r1),
             "fixed_base_scalar_mul" => Some(BlackBoxFunc::FixedBaseScalarMul),
-            "ec_add" => Some(BlackBoxFunc::EmbeddedCurveAdd),
-            "ec_double" => Some(BlackBoxFunc::EmbeddedCurveDouble),
+            "embedded_curve_add" => Some(BlackBoxFunc::EmbeddedCurveAdd),
             "and" => Some(BlackBoxFunc::AND),
             "xor" => Some(BlackBoxFunc::XOR),
             "range" => Some(BlackBoxFunc::RANGE),
             "keccak256" => Some(BlackBoxFunc::Keccak256),
             "keccakf1600" => Some(BlackBoxFunc::Keccakf1600),
             "recursive_aggregation" => Some(BlackBoxFunc::RecursiveAggregation),
+            "bigint_add" => Some(BlackBoxFunc::BigIntAdd),
+            "bigint_neg" => Some(BlackBoxFunc::BigIntNeg),
+            "bigint_mul" => Some(BlackBoxFunc::BigIntMul),
+            "bigint_div" => Some(BlackBoxFunc::BigIntDiv),
+            "bigint_from_le_bytes" => Some(BlackBoxFunc::BigIntFromLeBytes),
+            "bigint_to_le_bytes" => Some(BlackBoxFunc::BigIntToLeBytes),
+            "poseidon2_permutation" => Some(BlackBoxFunc::Poseidon2Permutation),
+            "sha256_compression" => Some(BlackBoxFunc::Sha256Compression),
             _ => None,
         }
     }
+
     pub fn is_valid_black_box_func_name(op_name: &str) -> bool {
         BlackBoxFunc::lookup(op_name).is_some()
     }

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

@@ -86,11 +86,6 @@ pub enum BlackBoxFuncCall {
         input2_y: FunctionInput,
         outputs: (Witness, Witness),
     },
-    EmbeddedCurveDouble {
-        input_x: FunctionInput,
-        input_y: FunctionInput,
-        outputs: (Witness, Witness),
-    },
     Keccak256 {
         inputs: Vec<FunctionInput>,
         outputs: Vec<Witness>,
@@ -120,6 +115,61 @@ pub enum BlackBoxFuncCall {
         /// key provided to the circuit matches the key produced by the circuit creator
         key_hash: FunctionInput,
     },
+    BigIntAdd {
+        lhs: u32,
+        rhs: u32,
+        output: u32,
+    },
+    BigIntNeg {
+        lhs: u32,
+        rhs: u32,
+        output: u32,
+    },
+    BigIntMul {
+        lhs: u32,
+        rhs: u32,
+        output: u32,
+    },
+    BigIntDiv {
+        lhs: u32,
+        rhs: u32,
+        output: u32,
+    },
+    BigIntFromLeBytes {
+        inputs: Vec<FunctionInput>,
+        modulus: Vec<u8>,
+        output: u32,
+    },
+    BigIntToLeBytes {
+        input: u32,
+        outputs: Vec<Witness>,
+    },
+    /// Applies the Poseidon2 permutation function to the given state,
+    /// outputting the permuted state.
+    Poseidon2Permutation {
+        /// Input state for the permutation of Poseidon2
+        inputs: Vec<FunctionInput>,
+        /// Permuted state
+        outputs: Vec<Witness>,
+        /// State length (in number of field elements)
+        /// It is the length of inputs and outputs vectors
+        len: u32,
+    },
+    /// Applies the SHA-256 compression function to the input message
+    ///
+    /// # Arguments
+    ///
+    /// * `inputs` - input message block
+    /// * `hash_values` - state from the previous compression
+    /// * `outputs` - result of the input compressed into 256 bits
+    Sha256Compression {
+        /// 512 bits of the input message, represented by 16 u32s
+        inputs: Vec<FunctionInput>,
+        /// Vector of 8 u32s used to compress the input
+        hash_values: Vec<FunctionInput>,
+        /// Output of the compression, represented by 8 u32s
+        outputs: Vec<Witness>,
+    },
 }
 
 impl BlackBoxFuncCall {
@@ -138,11 +188,18 @@ impl BlackBoxFuncCall {
             BlackBoxFuncCall::EcdsaSecp256r1 { .. } => BlackBoxFunc::EcdsaSecp256r1,
             BlackBoxFuncCall::FixedBaseScalarMul { .. } => BlackBoxFunc::FixedBaseScalarMul,
             BlackBoxFuncCall::EmbeddedCurveAdd { .. } => BlackBoxFunc::EmbeddedCurveAdd,
-            BlackBoxFuncCall::EmbeddedCurveDouble { .. } => BlackBoxFunc::EmbeddedCurveDouble,
             BlackBoxFuncCall::Keccak256 { .. } => BlackBoxFunc::Keccak256,
             BlackBoxFuncCall::Keccak256VariableLength { .. } => BlackBoxFunc::Keccak256,
             BlackBoxFuncCall::Keccakf1600 { .. } => BlackBoxFunc::Keccakf1600,
             BlackBoxFuncCall::RecursiveAggregation { .. } => BlackBoxFunc::RecursiveAggregation,
+            BlackBoxFuncCall::BigIntAdd { .. } => BlackBoxFunc::BigIntAdd,
+            BlackBoxFuncCall::BigIntNeg { .. } => BlackBoxFunc::BigIntNeg,
+            BlackBoxFuncCall::BigIntMul { .. } => BlackBoxFunc::BigIntMul,
+            BlackBoxFuncCall::BigIntDiv { .. } => BlackBoxFunc::BigIntDiv,
+            BlackBoxFuncCall::BigIntFromLeBytes { .. } => BlackBoxFunc::BigIntFromLeBytes,
+            BlackBoxFuncCall::BigIntToLeBytes { .. } => BlackBoxFunc::BigIntToLeBytes,
+            BlackBoxFuncCall::Poseidon2Permutation { .. } => BlackBoxFunc::Poseidon2Permutation,
+            BlackBoxFuncCall::Sha256Compression { .. } => BlackBoxFunc::Sha256Compression,
         }
     }
 
@@ -158,17 +215,22 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::Keccak256 { inputs, .. }
             | BlackBoxFuncCall::Keccakf1600 { inputs, .. }
             | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
-            | BlackBoxFuncCall::PedersenHash { inputs, .. } => inputs.to_vec(),
+            | BlackBoxFuncCall::PedersenHash { inputs, .. }
+            | BlackBoxFuncCall::BigIntFromLeBytes { inputs, .. }
+            | BlackBoxFuncCall::Poseidon2Permutation { inputs, .. }
+            | BlackBoxFuncCall::Sha256Compression { inputs, .. } => inputs.to_vec(),
             BlackBoxFuncCall::AND { lhs, rhs, .. } | BlackBoxFuncCall::XOR { lhs, rhs, .. } => {
                 vec![*lhs, *rhs]
             }
+            BlackBoxFuncCall::BigIntAdd { .. }
+            | BlackBoxFuncCall::BigIntNeg { .. }
+            | BlackBoxFuncCall::BigIntMul { .. }
+            | BlackBoxFuncCall::BigIntDiv { .. }
+            | BlackBoxFuncCall::BigIntToLeBytes { .. } => Vec::new(),
             BlackBoxFuncCall::FixedBaseScalarMul { low, high, .. } => vec![*low, *high],
             BlackBoxFuncCall::EmbeddedCurveAdd {
                 input1_x, input1_y, input2_x, input2_y, ..
             } => vec![*input1_x, *input1_y, *input2_x, *input2_y],
-            BlackBoxFuncCall::EmbeddedCurveDouble { input_x, input_y, .. } => {
-                vec![*input_x, *input_y]
-            }
             BlackBoxFuncCall::RANGE { input } => vec![*input],
             BlackBoxFuncCall::SchnorrVerify {
                 public_key_x,
@@ -249,7 +311,10 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::Blake2s { outputs, .. }
             | BlackBoxFuncCall::Blake3 { outputs, .. }
             | BlackBoxFuncCall::Keccak256 { outputs, .. }
-            | BlackBoxFuncCall::Keccakf1600 { outputs, .. } => outputs.to_vec(),
+            | BlackBoxFuncCall::Keccakf1600 { outputs, .. }
+            | BlackBoxFuncCall::Keccak256VariableLength { outputs, .. }
+            | BlackBoxFuncCall::Poseidon2Permutation { outputs, .. }
+            | BlackBoxFuncCall::Sha256Compression { outputs, .. } => outputs.to_vec(),
             BlackBoxFuncCall::AND { output, .. }
             | BlackBoxFuncCall::XOR { output, .. }
             | BlackBoxFuncCall::SchnorrVerify { output, .. }
@@ -258,12 +323,17 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
             BlackBoxFuncCall::FixedBaseScalarMul { outputs, .. }
             | BlackBoxFuncCall::PedersenCommitment { outputs, .. }
-            | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. }
-            | BlackBoxFuncCall::EmbeddedCurveDouble { outputs, .. } => vec![outputs.0, outputs.1],
-            BlackBoxFuncCall::RANGE { .. } | BlackBoxFuncCall::RecursiveAggregation { .. } => {
+            | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => vec![outputs.0, outputs.1],
+            BlackBoxFuncCall::RANGE { .. }
+            | BlackBoxFuncCall::RecursiveAggregation { .. }
+            | BlackBoxFuncCall::BigIntFromLeBytes { .. }
+            | BlackBoxFuncCall::BigIntAdd { .. }
+            | BlackBoxFuncCall::BigIntNeg { .. }
+            | BlackBoxFuncCall::BigIntMul { .. }
+            | BlackBoxFuncCall::BigIntDiv { .. } => {
                 vec![]
             }
-            BlackBoxFuncCall::Keccak256VariableLength { outputs, .. } => outputs.to_vec(),
+            BlackBoxFuncCall::BigIntToLeBytes { outputs, .. } => outputs.to_vec(),
         }
     }
 }

acvm-repo/acir/src/lib.rs

@@ -31,9 +31,7 @@ mod reflection {
         path::{Path, PathBuf},
     };
 
-    use brillig::{
-        BinaryFieldOp, BinaryIntOp, BlackBoxOp, Opcode as BrilligOpcode, RegisterOrMemory,
-    };
+    use brillig::{BinaryFieldOp, BinaryIntOp, BlackBoxOp, Opcode as BrilligOpcode, ValueOrArray};
     use serde_reflection::{Tracer, TracerConfig};
 
     use crate::{
@@ -69,7 +67,7 @@ mod reflection {
         tracer.trace_simple_type::<BinaryIntOp>().unwrap();
         tracer.trace_simple_type::<BlackBoxOp>().unwrap();
         tracer.trace_simple_type::<Directive>().unwrap();
-        tracer.trace_simple_type::<RegisterOrMemory>().unwrap();
+        tracer.trace_simple_type::<ValueOrArray>().unwrap();
 
         let registry = tracer.registry().unwrap();
 

acvm-repo/acir/tests/test_program_serialization.rs

@@ -20,7 +20,7 @@ use acir::{
     native_types::{Expression, Witness},
 };
 use acir_field::FieldElement;
-use brillig::{HeapArray, RegisterIndex, RegisterOrMemory};
+use brillig::{HeapArray, MemoryAddress, ValueOrArray};
 
 #[test]
 fn addition_circuit() {
@@ -173,15 +173,23 @@ fn simple_brillig_foreign_call() {
         inputs: vec![
             BrilligInputs::Single(w_input.into()), // Input Register 0,
         ],
-        // This tells the BrilligSolver which witnesses its output registers correspond to
+        // This tells the BrilligSolver which witnesses its output values correspond to
         outputs: vec![
             BrilligOutputs::Simple(w_inverted), // Output Register 1
         ],
-        bytecode: vec![brillig::Opcode::ForeignCall {
-            function: "invert".into(),
-            destinations: vec![RegisterOrMemory::RegisterIndex(RegisterIndex::from(0))],
-            inputs: vec![RegisterOrMemory::RegisterIndex(RegisterIndex::from(0))],
-        }],
+        bytecode: vec![
+            brillig::Opcode::CalldataCopy {
+                destination_address: MemoryAddress(0),
+                size: 1,
+                offset: 0,
+            },
+            brillig::Opcode::ForeignCall {
+                function: "invert".into(),
+                destinations: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+                inputs: vec![ValueOrArray::MemoryAddress(MemoryAddress::from(0))],
+            },
+            brillig::Opcode::Stop { return_data_offset: 0, return_data_size: 1 },
+        ],
         predicate: None,
     };
 
@@ -196,10 +204,11 @@ fn simple_brillig_foreign_call() {
     let bytes = Circuit::serialize_circuit(&circuit);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 49, 10, 64, 33, 12, 67, 99, 63, 124, 60, 142,
-        222, 192, 203, 56, 184, 56, 136, 120, 126, 5, 21, 226, 160, 139, 62, 40, 13, 45, 132, 68,
-        3, 80, 232, 124, 164, 153, 121, 115, 99, 155, 59, 172, 122, 231, 101, 56, 175, 80, 86, 221,
-        230, 31, 58, 196, 226, 83, 62, 53, 91, 16, 122, 10, 246, 84, 99, 243, 0, 30, 59, 1, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 143, 177, 10, 192, 32, 12, 68, 207, 148, 150, 118,
+        234, 175, 216, 63, 232, 207, 116, 232, 210, 161, 136, 223, 175, 98, 132, 27, 212, 69, 31,
+        132, 28, 23, 8, 119, 59, 0, 131, 204, 66, 154, 41, 222, 173, 219, 142, 113, 153, 121, 191,
+        44, 231, 21, 237, 144, 88, 43, 249, 11, 71, 156, 77, 245, 251, 249, 231, 119, 189, 214,
+        204, 89, 187, 11, 25, 130, 54, 1, 36, 1, 124, 242, 107, 1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -221,39 +230,54 @@ fn complex_brillig_foreign_call() {
 
     let brillig_data = Brillig {
         inputs: vec![
-            // Input Register 0
+            // Input 0,1,2
             BrilligInputs::Array(vec![
                 Expression::from(a),
                 Expression::from(b),
                 Expression::from(c),
             ]),
-            // Input Register 1
+            // Input 3
             BrilligInputs::Single(Expression {
                 mul_terms: vec![],
                 linear_combinations: vec![(fe_1, a), (fe_1, b), (fe_1, c)],
                 q_c: fe_0,
             }),
         ],
-        // This tells the BrilligSolver which witnesses its output registers correspond to
+        // This tells the BrilligSolver which witnesses its output values correspond to
         outputs: vec![
-            BrilligOutputs::Array(vec![a_times_2, b_times_3, c_times_4]), // Output Register 0
-            BrilligOutputs::Simple(a_plus_b_plus_c),                      // Output Register 1
-            BrilligOutputs::Simple(a_plus_b_plus_c_times_2),              // Output Register 2
+            BrilligOutputs::Array(vec![a_times_2, b_times_3, c_times_4]), // Output 0,1,2
+            BrilligOutputs::Simple(a_plus_b_plus_c),                      // Output 3
+            BrilligOutputs::Simple(a_plus_b_plus_c_times_2),              // Output 4
         ],
         bytecode: vec![
+            brillig::Opcode::CalldataCopy {
+                destination_address: MemoryAddress(32),
+                size: 3,
+                offset: 0,
+            },
+            brillig::Opcode::Const {
+                destination: MemoryAddress(0),
+                value: brillig::Value::from(32_usize),
+            },
+            brillig::Opcode::CalldataCopy {
+                destination_address: MemoryAddress(1),
+                size: 1,
+                offset: 3,
+            },
             // Oracles are named 'foreign calls' in brillig
             brillig::Opcode::ForeignCall {
                 function: "complex".into(),
                 inputs: vec![
-                    RegisterOrMemory::HeapArray(HeapArray { pointer: 0.into(), size: 3 }),
-                    RegisterOrMemory::RegisterIndex(RegisterIndex::from(1)),
+                    ValueOrArray::HeapArray(HeapArray { pointer: 0.into(), size: 3 }),
+                    ValueOrArray::MemoryAddress(MemoryAddress::from(1)),
                 ],
                 destinations: vec![
-                    RegisterOrMemory::HeapArray(HeapArray { pointer: 0.into(), size: 3 }),
-                    RegisterOrMemory::RegisterIndex(RegisterIndex::from(1)),
-                    RegisterOrMemory::RegisterIndex(RegisterIndex::from(2)),
+                    ValueOrArray::HeapArray(HeapArray { pointer: 0.into(), size: 3 }),
+                    ValueOrArray::MemoryAddress(MemoryAddress::from(35)),
+                    ValueOrArray::MemoryAddress(MemoryAddress::from(36)),
                 ],
             },
+            brillig::Opcode::Stop { return_data_offset: 32, return_data_size: 5 },
         ],
         predicate: None,
     };
@@ -269,13 +293,14 @@ fn complex_brillig_foreign_call() {
     let bytes = Circuit::serialize_circuit(&circuit);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 83, 219, 10, 128, 48, 8, 117, 174, 139, 159, 179,
-        254, 160, 127, 137, 222, 138, 122, 236, 243, 19, 114, 32, 22, 244, 144, 131, 118, 64, 156,
-        178, 29, 14, 59, 74, 0, 16, 224, 66, 228, 64, 57, 7, 169, 53, 242, 189, 81, 114, 250, 134,
-        33, 248, 113, 165, 82, 26, 177, 2, 141, 177, 128, 198, 60, 15, 63, 245, 219, 211, 23, 215,
-        255, 139, 15, 251, 211, 112, 180, 28, 157, 212, 189, 100, 82, 179, 64, 170, 63, 109, 235,
-        190, 204, 135, 166, 178, 150, 216, 62, 154, 252, 250, 70, 147, 35, 220, 119, 93, 227, 4,
-        182, 131, 81, 25, 36, 4, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 83, 65, 10, 132, 48, 12, 76, 218, 237, 174, 123,
+        242, 11, 130, 62, 160, 250, 2, 255, 34, 222, 20, 61, 250, 124, 11, 78, 49, 4, 193, 131, 21,
+        52, 16, 210, 132, 105, 50, 77, 210, 140, 136, 152, 54, 177, 65, 13, 206, 12, 95, 74, 196,
+        181, 176, 254, 154, 212, 156, 46, 151, 191, 139, 163, 121, 1, 71, 123, 3, 199, 184, 15, 15,
+        157, 119, 202, 185, 36, 237, 159, 61, 248, 63, 159, 160, 46, 232, 23, 254, 15, 54, 67, 156,
+        96, 11, 213, 119, 82, 248, 116, 179, 104, 188, 163, 125, 15, 89, 213, 253, 139, 154, 221,
+        52, 206, 67, 191, 88, 5, 213, 52, 75, 113, 174, 96, 205, 201, 157, 24, 207, 197, 211, 157,
+        6, 50, 18, 233, 158, 72, 89, 1, 53, 215, 75, 175, 196, 4, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)