feat: Sync from aztec-packages

.aztec-sync-commit

@@ -1 +1 @@
-91042c7bcebfebeb4e629162f44988e2cda1ed41
+57f3c9bdc99103862a165bc235efdc8ef01b4e92

acvm-repo/acir/codegen/acir.cpp

@@ -464,6 +464,7 @@ namespace Program {
             Program::MemoryAddress input;
             uint32_t radix;
             Program::HeapArray output;
+            bool output_bits;
 
             friend bool operator==(const ToRadix&, const ToRadix&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -635,6 +636,16 @@ namespace Program {
             static Const bincodeDeserialize(std::vector<uint8_t>);
         };
 
+        struct IndirectConst {
+            Program::MemoryAddress destination_pointer;
+            Program::BitSize bit_size;
+            std::string value;
+
+            friend bool operator==(const IndirectConst&, const IndirectConst&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static IndirectConst bincodeDeserialize(std::vector<uint8_t>);
+        };
+
         struct Return {
             friend bool operator==(const Return&, const Return&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -716,7 +727,7 @@ namespace Program {
             static Stop bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<BinaryFieldOp, BinaryIntOp, Cast, JumpIfNot, JumpIf, Jump, CalldataCopy, Call, Const, Return, ForeignCall, Mov, ConditionalMov, Load, Store, BlackBox, Trap, Stop> value;
+        std::variant<BinaryFieldOp, BinaryIntOp, Cast, JumpIfNot, JumpIf, Jump, CalldataCopy, Call, Const, IndirectConst, Return, ForeignCall, Mov, ConditionalMov, Load, Store, BlackBox, Trap, Stop> value;
 
         friend bool operator==(const BrilligOpcode&, const BrilligOpcode&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -933,6 +944,7 @@ namespace Program {
             std::vector<Program::FunctionInput> proof;
             std::vector<Program::FunctionInput> public_inputs;
             Program::FunctionInput key_hash;
+            uint32_t proof_type;
 
             friend bool operator==(const RecursiveAggregation&, const RecursiveAggregation&);
             std::vector<uint8_t> bincodeSerialize() const;
@@ -3149,6 +3161,7 @@ namespace Program {
         if (!(lhs.proof == rhs.proof)) { return false; }
         if (!(lhs.public_inputs == rhs.public_inputs)) { return false; }
         if (!(lhs.key_hash == rhs.key_hash)) { return false; }
+        if (!(lhs.proof_type == rhs.proof_type)) { return false; }
         return true;
     }
 
@@ -3176,6 +3189,7 @@ void serde::Serializable<Program::BlackBoxFuncCall::RecursiveAggregation>::seria
     serde::Serializable<decltype(obj.proof)>::serialize(obj.proof, serializer);
     serde::Serializable<decltype(obj.public_inputs)>::serialize(obj.public_inputs, serializer);
     serde::Serializable<decltype(obj.key_hash)>::serialize(obj.key_hash, serializer);
+    serde::Serializable<decltype(obj.proof_type)>::serialize(obj.proof_type, serializer);
 }
 
 template <>
@@ -3186,6 +3200,7 @@ Program::BlackBoxFuncCall::RecursiveAggregation serde::Deserializable<Program::B
     obj.proof = serde::Deserializable<decltype(obj.proof)>::deserialize(deserializer);
     obj.public_inputs = serde::Deserializable<decltype(obj.public_inputs)>::deserialize(deserializer);
     obj.key_hash = serde::Deserializable<decltype(obj.key_hash)>::deserialize(deserializer);
+    obj.proof_type = serde::Deserializable<decltype(obj.proof_type)>::deserialize(deserializer);
     return obj;
 }
 
@@ -4525,6 +4540,7 @@ namespace Program {
         if (!(lhs.input == rhs.input)) { return false; }
         if (!(lhs.radix == rhs.radix)) { return false; }
         if (!(lhs.output == rhs.output)) { return false; }
+        if (!(lhs.output_bits == rhs.output_bits)) { return false; }
         return true;
     }
 
@@ -4551,6 +4567,7 @@ void serde::Serializable<Program::BlackBoxOp::ToRadix>::serialize(const Program:
     serde::Serializable<decltype(obj.input)>::serialize(obj.input, serializer);
     serde::Serializable<decltype(obj.radix)>::serialize(obj.radix, serializer);
     serde::Serializable<decltype(obj.output)>::serialize(obj.output, serializer);
+    serde::Serializable<decltype(obj.output_bits)>::serialize(obj.output_bits, serializer);
 }
 
 template <>
@@ -4560,6 +4577,7 @@ Program::BlackBoxOp::ToRadix serde::Deserializable<Program::BlackBoxOp::ToRadix>
     obj.input = serde::Deserializable<decltype(obj.input)>::deserialize(deserializer);
     obj.radix = serde::Deserializable<decltype(obj.radix)>::deserialize(deserializer);
     obj.output = serde::Deserializable<decltype(obj.output)>::deserialize(deserializer);
+    obj.output_bits = serde::Deserializable<decltype(obj.output_bits)>::deserialize(deserializer);
     return obj;
 }
 
@@ -5382,6 +5400,50 @@ Program::BrilligOpcode::Const serde::Deserializable<Program::BrilligOpcode::Cons
     return obj;
 }
 
+namespace Program {
+
+    inline bool operator==(const BrilligOpcode::IndirectConst &lhs, const BrilligOpcode::IndirectConst &rhs) {
+        if (!(lhs.destination_pointer == rhs.destination_pointer)) { return false; }
+        if (!(lhs.bit_size == rhs.bit_size)) { return false; }
+        if (!(lhs.value == rhs.value)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> BrilligOpcode::IndirectConst::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BrilligOpcode::IndirectConst>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BrilligOpcode::IndirectConst BrilligOpcode::IndirectConst::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BrilligOpcode::IndirectConst>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Program
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Program::BrilligOpcode::IndirectConst>::serialize(const Program::BrilligOpcode::IndirectConst &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.destination_pointer)>::serialize(obj.destination_pointer, serializer);
+    serde::Serializable<decltype(obj.bit_size)>::serialize(obj.bit_size, serializer);
+    serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Program::BrilligOpcode::IndirectConst serde::Deserializable<Program::BrilligOpcode::IndirectConst>::deserialize(Deserializer &deserializer) {
+    Program::BrilligOpcode::IndirectConst obj;
+    obj.destination_pointer = serde::Deserializable<decltype(obj.destination_pointer)>::deserialize(deserializer);
+    obj.bit_size = serde::Deserializable<decltype(obj.bit_size)>::deserialize(deserializer);
+    obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Program {
 
     inline bool operator==(const BrilligOpcode::Return &lhs, const BrilligOpcode::Return &rhs) {

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

@@ -159,6 +159,7 @@ pub enum BlackBoxFuncCall<F> {
         /// The circuit implementing this opcode can use this hash to ensure that the
         /// key provided to the circuit matches the key produced by the circuit creator
         key_hash: FunctionInput<F>,
+        proof_type: u32,
     },
     BigIntAdd {
         lhs: u32,
@@ -350,6 +351,7 @@ impl<F: Copy> BlackBoxFuncCall<F> {
                 proof,
                 public_inputs,
                 key_hash,
+                proof_type: _,
             } => {
                 let mut inputs = Vec::new();
                 inputs.extend(key.iter().copied());

acvm-repo/acir/tests/test_program_serialization.rs

@@ -204,11 +204,11 @@ fn simple_brillig_foreign_call() {
     let bytes = Program::serialize_program(&program);
 
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 80, 49, 10, 192, 32, 12, 52, 45, 45, 165, 155, 63,
-        209, 31, 248, 25, 7, 23, 7, 17, 223, 175, 96, 2, 65, 162, 139, 30, 132, 203, 221, 65, 72,
-        2, 170, 227, 107, 5, 216, 63, 200, 164, 57, 200, 115, 200, 102, 15, 22, 206, 205, 50, 124,
-        223, 107, 108, 128, 155, 106, 113, 217, 141, 252, 10, 25, 225, 103, 121, 136, 197, 167,
-        188, 250, 213, 76, 75, 158, 22, 178, 10, 176, 188, 242, 119, 164, 1, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 80, 49, 10, 192, 32, 12, 52, 45, 45, 133, 110, 190,
+        68, 127, 224, 103, 28, 92, 28, 68, 124, 191, 130, 9, 4, 137, 46, 122, 16, 46, 119, 7, 33,
+        9, 168, 142, 175, 21, 96, 255, 32, 147, 230, 32, 207, 33, 155, 61, 88, 56, 55, 203, 240,
+        125, 175, 177, 1, 110, 170, 197, 101, 55, 242, 43, 100, 132, 159, 229, 33, 22, 159, 242,
+        234, 87, 51, 45, 121, 90, 200, 42, 48, 209, 35, 111, 164, 1, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)
@@ -307,15 +307,15 @@ fn complex_brillig_foreign_call() {
 
     let bytes = Program::serialize_program(&program);
     let expected_serialization: Vec<u8> = vec![
-        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 77, 90, 199, 145, 217,
-        205, 13, 6, 102, 14, 208, 241, 4, 222, 69, 220, 41, 186, 244, 248, 90, 140, 24, 159, 5, 23,
-        86, 208, 7, 37, 253, 228, 243, 146, 144, 50, 77, 200, 198, 197, 178, 127, 136, 52, 34, 253,
-        189, 165, 53, 102, 221, 66, 164, 59, 134, 63, 199, 243, 229, 206, 226, 104, 110, 192, 209,
-        158, 192, 145, 84, 255, 47, 216, 239, 152, 125, 137, 90, 63, 27, 152, 159, 132, 166, 249,
-        74, 229, 252, 20, 153, 97, 161, 189, 145, 161, 237, 224, 173, 128, 19, 235, 189, 126, 192,
-        17, 97, 4, 177, 75, 162, 101, 154, 187, 84, 113, 97, 136, 255, 82, 89, 150, 109, 211, 213,
-        85, 111, 65, 21, 233, 126, 213, 254, 7, 239, 12, 118, 104, 171, 161, 63, 176, 144, 46, 7,
-        244, 246, 124, 191, 105, 41, 241, 92, 246, 1, 235, 222, 207, 212, 69, 5, 0, 0,
+        31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 77, 90, 199, 17, 102, 55,
+        39, 24, 152, 57, 64, 199, 19, 120, 23, 113, 167, 232, 210, 227, 107, 49, 98, 124, 22, 92,
+        88, 65, 31, 148, 244, 147, 207, 75, 66, 202, 52, 33, 27, 23, 203, 254, 33, 210, 136, 244,
+        247, 150, 214, 152, 117, 11, 145, 238, 24, 254, 28, 207, 151, 59, 139, 163, 185, 1, 71,
+        123, 2, 71, 82, 253, 191, 96, 191, 99, 246, 37, 106, 253, 108, 96, 126, 18, 154, 230, 43,
+        149, 243, 83, 100, 134, 133, 246, 70, 134, 182, 131, 183, 2, 78, 172, 247, 250, 1, 71, 132,
+        17, 196, 46, 137, 150, 105, 238, 82, 197, 133, 33, 254, 75, 101, 89, 182, 77, 87, 87, 189,
+        5, 85, 164, 251, 85, 251, 31, 188, 51, 216, 161, 173, 134, 254, 192, 66, 186, 28, 208, 219,
+        243, 253, 166, 165, 196, 115, 217, 7, 253, 216, 100, 109, 69, 5, 0, 0,
     ];
 
     assert_eq!(bytes, expected_serialization)

acvm-repo/acvm_js/test/shared/complex_foreign_call.ts

@@ -2,13 +2,13 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `complex_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 77, 90, 199, 145, 217, 205, 13, 6, 102, 14, 208, 241,
-  4, 222, 69, 220, 41, 186, 244, 248, 90, 140, 24, 159, 5, 23, 86, 208, 7, 37, 253, 228, 243, 146, 144, 50, 77, 200,
-  198, 197, 178, 127, 136, 52, 34, 253, 189, 165, 53, 102, 221, 66, 164, 59, 134, 63, 199, 243, 229, 206, 226, 104, 110,
-  192, 209, 158, 192, 145, 84, 255, 47, 216, 239, 152, 125, 137, 90, 63, 27, 152, 159, 132, 166, 249, 74, 229, 252, 20,
-  153, 97, 161, 189, 145, 161, 237, 224, 173, 128, 19, 235, 189, 126, 192, 17, 97, 4, 177, 75, 162, 101, 154, 187, 84,
-  113, 97, 136, 255, 82, 89, 150, 109, 211, 213, 85, 111, 65, 21, 233, 126, 213, 254, 7, 239, 12, 118, 104, 171, 161,
-  63, 176, 144, 46, 7, 244, 246, 124, 191, 105, 41, 241, 92, 246, 1, 235, 222, 207, 212, 69, 5, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 213, 84, 75, 10, 132, 48, 12, 77, 90, 199, 17, 102, 55, 39, 24, 152, 57, 64, 199,
+  19, 120, 23, 113, 167, 232, 210, 227, 107, 49, 98, 124, 22, 92, 88, 65, 31, 148, 244, 147, 207, 75, 66, 202, 52, 33,
+  27, 23, 203, 254, 33, 210, 136, 244, 247, 150, 214, 152, 117, 11, 145, 238, 24, 254, 28, 207, 151, 59, 139, 163, 185,
+  1, 71, 123, 2, 71, 82, 253, 191, 96, 191, 99, 246, 37, 106, 253, 108, 96, 126, 18, 154, 230, 43, 149, 243, 83, 100,
+  134, 133, 246, 70, 134, 182, 131, 183, 2, 78, 172, 247, 250, 1, 71, 132, 17, 196, 46, 137, 150, 105, 238, 82, 197,
+  133, 33, 254, 75, 101, 89, 182, 77, 87, 87, 189, 5, 85, 164, 251, 85, 251, 31, 188, 51, 216, 161, 173, 134, 254, 192,
+  66, 186, 28, 208, 219, 243, 253, 166, 165, 196, 115, 217, 7, 253, 216, 100, 109, 69, 5, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000001'],

acvm-repo/acvm_js/test/shared/foreign_call.ts

@@ -2,10 +2,10 @@ import { WitnessMap } from '@noir-lang/acvm_js';
 
 // See `simple_brillig_foreign_call` integration test in `acir/tests/test_program_serialization.rs`.
 export const bytecode = Uint8Array.from([
-  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 80, 49, 10, 192, 32, 12, 52, 45, 45, 165, 155, 63, 209, 31, 248, 25, 7, 23, 7,
-  17, 223, 175, 96, 2, 65, 162, 139, 30, 132, 203, 221, 65, 72, 2, 170, 227, 107, 5, 216, 63, 200, 164, 57, 200, 115,
-  200, 102, 15, 22, 206, 205, 50, 124, 223, 107, 108, 128, 155, 106, 113, 217, 141, 252, 10, 25, 225, 103, 121, 136,
-  197, 167, 188, 250, 213, 76, 75, 158, 22, 178, 10, 176, 188, 242, 119, 164, 1, 0, 0,
+  31, 139, 8, 0, 0, 0, 0, 0, 0, 255, 173, 80, 49, 10, 192, 32, 12, 52, 45, 45, 133, 110, 190, 68, 127, 224, 103, 28, 92,
+  28, 68, 124, 191, 130, 9, 4, 137, 46, 122, 16, 46, 119, 7, 33, 9, 168, 142, 175, 21, 96, 255, 32, 147, 230, 32, 207,
+  33, 155, 61, 88, 56, 55, 203, 240, 125, 175, 177, 1, 110, 170, 197, 101, 55, 242, 43, 100, 132, 159, 229, 33, 22, 159,
+  242, 234, 87, 51, 45, 121, 90, 200, 42, 48, 209, 35, 111, 164, 1, 0, 0,
 ]);
 export const initialWitnessMap: WitnessMap = new Map([
   [1, '0x0000000000000000000000000000000000000000000000000000000000000005'],

acvm-repo/brillig/src/black_box.rs

@@ -132,5 +132,6 @@ pub enum BlackBoxOp {
         input: MemoryAddress,
         radix: u32,
         output: HeapArray,
+        output_bits: bool,
     },
 }

acvm-repo/brillig/src/opcodes.rs

@@ -223,6 +223,11 @@ pub enum BrilligOpcode<F> {
         bit_size: BitSize,
         value: F,
     },
+    IndirectConst {
+        destination_pointer: MemoryAddress,
+        bit_size: BitSize,
+        value: F,
+    },
     Return,
     /// Used to get data from an outside source.
     /// Also referred to as an Oracle. However, we don't use that name as

acvm-repo/brillig_vm/src/black_box.rs

@@ -1,11 +1,12 @@
-use acir::brillig::{BlackBoxOp, HeapArray, HeapVector};
+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, keccak256,
     keccakf1600, sha256, sha256compression, BlackBoxFunctionSolver, BlackBoxResolutionError,
 };
 use num_bigint::BigUint;
+use num_traits::Zero;
 
 use crate::memory::MemoryValue;
 use crate::Memory;
@@ -366,7 +367,7 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
             memory.write_slice(memory.read_ref(output.pointer), &state);
             Ok(())
         }
-        BlackBoxOp::ToRadix { input, radix, output } => {
+        BlackBoxOp::ToRadix { input, radix, output, output_bits } => {
             let input: F = *memory.read(*input).extract_field().expect("ToRadix input not a field");
 
             let mut input = BigUint::from_bytes_be(&input.to_be_bytes());
@@ -376,7 +377,15 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
 
             for _ in 0..output.size {
                 let limb = &input % &radix;
-                limbs.push(MemoryValue::new_field(F::from_be_bytes_reduce(&limb.to_bytes_be())));
+                if *output_bits {
+                    limbs.push(MemoryValue::new_integer(
+                        if limb.is_zero() { 0 } else { 1 },
+                        IntegerBitSize::U1,
+                    ));
+                } else {
+                    let limb: u8 = limb.try_into().unwrap();
+                    limbs.push(MemoryValue::new_integer(limb as u128, IntegerBitSize::U8));
+                };
                 input /= &radix;
             }
 

acvm-repo/brillig_vm/src/lib.rs

@@ -339,6 +339,13 @@ impl<'a, F: AcirField, B: BlackBoxFunctionSolver<F>> VM<'a, F, B> {
                 self.memory.write(*destination, MemoryValue::new_from_field(*value, *bit_size));
                 self.increment_program_counter()
             }
+            Opcode::IndirectConst { destination_pointer, bit_size, value } => {
+                // Convert our destination_pointer to an address
+                let destination = self.memory.read_ref(*destination_pointer);
+                // Use our usize destination index to set the value in memory
+                self.memory.write(destination, MemoryValue::new_from_field(*value, *bit_size));
+                self.increment_program_counter()
+            }
             Opcode::BlackBox(black_box_op) => {
                 match evaluate_black_box(
                     black_box_op,
@@ -1189,6 +1196,34 @@ mod tests {
         assert_eq!(memory, expected);
     }
 
+    #[test]
+    fn iconst_opcode() {
+        let opcodes = &[
+            Opcode::Const {
+                destination: MemoryAddress(0),
+                bit_size: BitSize::Integer(MEMORY_ADDRESSING_BIT_SIZE),
+                value: FieldElement::from(8_usize),
+            },
+            Opcode::IndirectConst {
+                destination_pointer: MemoryAddress(0),
+                bit_size: BitSize::Integer(MEMORY_ADDRESSING_BIT_SIZE),
+                value: FieldElement::from(27_usize),
+            },
+        ];
+        let mut vm = VM::new(vec![], opcodes, vec![], &StubbedBlackBoxSolver);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::InProgress);
+
+        let status = vm.process_opcode();
+        assert_eq!(status, VMStatus::Finished { return_data_offset: 0, return_data_size: 0 });
+
+        let VM { memory, .. } = vm;
+
+        let destination_value = memory.read(MemoryAddress::from(8));
+        assert_eq!(destination_value.to_field(), (27_usize).into());
+    }
+
     #[test]
     fn load_opcode() {
         /// Brillig code for the following:

compiler/noirc_evaluator/src/brillig/brillig_gen.rs

@@ -9,7 +9,10 @@ mod variable_liveness;
 use acvm::FieldElement;
 
 use self::{brillig_block::BrilligBlock, brillig_fn::FunctionContext};
-use super::brillig_ir::{artifact::BrilligArtifact, BrilligContext};
+use super::brillig_ir::{
+    artifact::{BrilligArtifact, Label},
+    BrilligContext,
+};
 use crate::ssa::ir::function::Function;
 
 /// Converting an SSA function into Brillig bytecode.
@@ -21,7 +24,7 @@ pub(crate) fn convert_ssa_function(
 
     let mut function_context = FunctionContext::new(func);
 
-    brillig_context.enter_context(FunctionContext::function_id_to_function_label(func.id()));
+    brillig_context.enter_context(Label::function(func.id()));
 
     for block in function_context.blocks.clone() {
         BrilligBlock::compile(&mut function_context, &mut brillig_context, block, &func.dfg);