feat: Sync from noir (AztecProtocol/aztec-packages#5286)

Automated pull of development from the [noir](https://github.com/noir-lang/noir) programming language, a dependency of Aztec. BEGIN_COMMIT_OVERRIDE feat: add as_slice builtin function, add execution test (#4523) chore: making docs build before cutting versions (#4568) chore: fix docker test workflows (#4566) feat: allow usage of noir `#[test]` syntax in stdlib (#4553) feat: Add more impls on Option (#4549) chore: fixing some broken links (#4556) chore: separate tests for execution failures from compilation failures (#4559) feat: remove curly braces with fmt (#4529) fix: Make `nargo` the default binary for cargo run (#4554) fix: Evaluate operators in globals in types (#4537) chore: Add more `Hash` impls to stdlib (#4470) END_COMMIT_OVERRIDE --------- Co-authored-by: sirasistant <[email protected]>
noir-lang · Mar 18, 2024 · 3c37e4f · 3c37e4f
1 parent d4213a0
commit 3c37e4f
Show file tree

Hide file tree

Showing 153 changed files with 3,426 additions and 1,706 deletions.
diff --git a/.aztec-sync-commit b/.aztec-sync-commit
@@ -1 +1 @@
-aa90f6ed7bfae06bdf6990816d154bbd24993689
+86e1a86461bff5263567af33f20756ce560e22ca
diff --git a/.github/scripts/noir-wasm-build.sh b/.github/scripts/noir-wasm-build.sh
@@ -2,4 +2,5 @@
 set -eu
 
 .github/scripts/wasm-pack-install.sh
+yarn workspace @noir-lang/types build
 yarn workspace @noir-lang/noir_wasm build
diff --git a/.github/scripts/wasm-bindgen-install.sh b/.github/scripts/wasm-bindgen-install.sh
@@ -6,7 +6,7 @@ cd $(dirname "$0")
 ./cargo-binstall-install.sh
 
 # Install wasm-bindgen-cli.
-if [ "$(wasm-bindgen --version | cut -d' ' -f2)" != "0.2.86" ]; then
+if [ "$(wasm-bindgen --version &> /dev/null | cut -d' ' -f2)" != "0.2.86" ]; then
   echo "Building wasm-bindgen..."
   cargo binstall [email protected] --force --no-confirm
 fi

diff --git a/acvm-repo/acir/codegen/acir.cpp b/acvm-repo/acir/codegen/acir.cpp
@@ -31,13 +31,31 @@ namespace Circuit {
             static Div bincodeDeserialize(std::vector<uint8_t>);
         };
 
+        struct IntegerDiv {
+            friend bool operator==(const IntegerDiv&, const IntegerDiv&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static IntegerDiv bincodeDeserialize(std::vector<uint8_t>);
+        };
+
         struct Equals {
             friend bool operator==(const Equals&, const Equals&);
             std::vector<uint8_t> bincodeSerialize() const;
             static Equals bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<Add, Sub, Mul, Div, Equals> value;
+        struct LessThan {
+            friend bool operator==(const LessThan&, const LessThan&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static LessThan bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        struct LessThanEquals {
+            friend bool operator==(const LessThanEquals&, const LessThanEquals&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static LessThanEquals bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<Add, Sub, Mul, Div, IntegerDiv, Equals, LessThan, LessThanEquals> value;
 
         friend bool operator==(const BinaryFieldOp&, const BinaryFieldOp&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1053,7 +1071,17 @@ namespace Circuit {
             static MemoryInit bincodeDeserialize(std::vector<uint8_t>);
         };
 
-        std::variant<AssertZero, BlackBoxFuncCall, Directive, Brillig, MemoryOp, MemoryInit> value;
+        struct Call {
+            uint32_t id;
+            std::vector<Circuit::Witness> inputs;
+            std::vector<Circuit::Witness> outputs;
+
+            friend bool operator==(const Call&, const Call&);
+            std::vector<uint8_t> bincodeSerialize() const;
+            static Call bincodeDeserialize(std::vector<uint8_t>);
+        };
+
+        std::variant<AssertZero, BlackBoxFuncCall, Directive, Brillig, MemoryOp, MemoryInit, Call> value;
 
         friend bool operator==(const Opcode&, const Opcode&);
         std::vector<uint8_t> bincodeSerialize() const;
@@ -1317,6 +1345,41 @@ Circuit::BinaryFieldOp::Div serde::Deserializable<Circuit::BinaryFieldOp::Div>::
     return obj;
 }
 
+namespace Circuit {
+
+    inline bool operator==(const BinaryFieldOp::IntegerDiv &lhs, const BinaryFieldOp::IntegerDiv &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BinaryFieldOp::IntegerDiv::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BinaryFieldOp::IntegerDiv>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BinaryFieldOp::IntegerDiv BinaryFieldOp::IntegerDiv::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BinaryFieldOp::IntegerDiv>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BinaryFieldOp::IntegerDiv>::serialize(const Circuit::BinaryFieldOp::IntegerDiv &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BinaryFieldOp::IntegerDiv serde::Deserializable<Circuit::BinaryFieldOp::IntegerDiv>::deserialize(Deserializer &deserializer) {
+    Circuit::BinaryFieldOp::IntegerDiv obj;
+    return obj;
+}
+
 namespace Circuit {
 
     inline bool operator==(const BinaryFieldOp::Equals &lhs, const BinaryFieldOp::Equals &rhs) {
@@ -1352,6 +1415,76 @@ Circuit::BinaryFieldOp::Equals serde::Deserializable<Circuit::BinaryFieldOp::Equ
     return obj;
 }
 
+namespace Circuit {
+
+    inline bool operator==(const BinaryFieldOp::LessThan &lhs, const BinaryFieldOp::LessThan &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BinaryFieldOp::LessThan::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BinaryFieldOp::LessThan>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BinaryFieldOp::LessThan BinaryFieldOp::LessThan::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BinaryFieldOp::LessThan>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BinaryFieldOp::LessThan>::serialize(const Circuit::BinaryFieldOp::LessThan &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BinaryFieldOp::LessThan serde::Deserializable<Circuit::BinaryFieldOp::LessThan>::deserialize(Deserializer &deserializer) {
+    Circuit::BinaryFieldOp::LessThan obj;
+    return obj;
+}
+
+namespace Circuit {
+
+    inline bool operator==(const BinaryFieldOp::LessThanEquals &lhs, const BinaryFieldOp::LessThanEquals &rhs) {
+        return true;
+    }
+
+    inline std::vector<uint8_t> BinaryFieldOp::LessThanEquals::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<BinaryFieldOp::LessThanEquals>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline BinaryFieldOp::LessThanEquals BinaryFieldOp::LessThanEquals::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<BinaryFieldOp::LessThanEquals>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::BinaryFieldOp::LessThanEquals>::serialize(const Circuit::BinaryFieldOp::LessThanEquals &obj, Serializer &serializer) {
+}
+
+template <>
+template <typename Deserializer>
+Circuit::BinaryFieldOp::LessThanEquals serde::Deserializable<Circuit::BinaryFieldOp::LessThanEquals>::deserialize(Deserializer &deserializer) {
+    Circuit::BinaryFieldOp::LessThanEquals obj;
+    return obj;
+}
+
 namespace Circuit {
 
     inline bool operator==(const BinaryIntOp &lhs, const BinaryIntOp &rhs) {
@@ -6012,6 +6145,50 @@ Circuit::Opcode::MemoryInit serde::Deserializable<Circuit::Opcode::MemoryInit>::
     return obj;
 }
 
+namespace Circuit {
+
+    inline bool operator==(const Opcode::Call &lhs, const Opcode::Call &rhs) {
+        if (!(lhs.id == rhs.id)) { return false; }
+        if (!(lhs.inputs == rhs.inputs)) { return false; }
+        if (!(lhs.outputs == rhs.outputs)) { return false; }
+        return true;
+    }
+
+    inline std::vector<uint8_t> Opcode::Call::bincodeSerialize() const {
+        auto serializer = serde::BincodeSerializer();
+        serde::Serializable<Opcode::Call>::serialize(*this, serializer);
+        return std::move(serializer).bytes();
+    }
+
+    inline Opcode::Call Opcode::Call::bincodeDeserialize(std::vector<uint8_t> input) {
+        auto deserializer = serde::BincodeDeserializer(input);
+        auto value = serde::Deserializable<Opcode::Call>::deserialize(deserializer);
+        if (deserializer.get_buffer_offset() < input.size()) {
+            throw serde::deserialization_error("Some input bytes were not read");
+        }
+        return value;
+    }
+
+} // end of namespace Circuit
+
+template <>
+template <typename Serializer>
+void serde::Serializable<Circuit::Opcode::Call>::serialize(const Circuit::Opcode::Call &obj, Serializer &serializer) {
+    serde::Serializable<decltype(obj.id)>::serialize(obj.id, serializer);
+    serde::Serializable<decltype(obj.inputs)>::serialize(obj.inputs, serializer);
+    serde::Serializable<decltype(obj.outputs)>::serialize(obj.outputs, serializer);
+}
+
+template <>
+template <typename Deserializer>
+Circuit::Opcode::Call serde::Deserializable<Circuit::Opcode::Call>::deserialize(Deserializer &deserializer) {
+    Circuit::Opcode::Call obj;
+    obj.id = serde::Deserializable<decltype(obj.id)>::deserialize(deserializer);
+    obj.inputs = serde::Deserializable<decltype(obj.inputs)>::deserialize(deserializer);
+    obj.outputs = serde::Deserializable<decltype(obj.outputs)>::deserialize(deserializer);
+    return obj;
+}
+
 namespace Circuit {
 
     inline bool operator==(const OpcodeLocation &lhs, const OpcodeLocation &rhs) {

diff --git a/acvm-repo/acir/src/circuit/opcodes.rs b/acvm-repo/acir/src/circuit/opcodes.rs
@@ -29,6 +29,17 @@ pub enum Opcode {
         block_id: BlockId,
         init: Vec<Witness>,
     },
+    /// Calls to functions represented as a separate circuit. A call opcode allows us
+    /// to build a call stack when executing the outer-most circuit.
+    Call {
+        /// Id for the function being called. It is the responsibility of the executor
+        /// to fetch the appropriate circuit from this id.
+        id: u32,
+        /// Inputs to the function call
+        inputs: Vec<Witness>,
+        /// Outputs of the function call
+        outputs: Vec<Witness>,
+    },
 }
 
 impl std::fmt::Display for Opcode {
@@ -86,6 +97,11 @@ impl std::fmt::Display for Opcode {
                 write!(f, "INIT ")?;
                 write!(f, "(id: {}, len: {}) ", block_id.0, init.len())
             }
+            Opcode::Call { id, inputs, outputs } => {
+                write!(f, "CALL func {}: ", id)?;
+                writeln!(f, "inputs: {:?}", inputs)?;
+                writeln!(f, "outputs: {:?}", outputs)
+            }
         }
     }
 }

diff --git a/acvm-repo/acvm/src/compiler/transformers/mod.rs b/acvm-repo/acvm/src/compiler/transformers/mod.rs
@@ -145,6 +145,7 @@ pub(super) fn transform_internal(
                 new_acir_opcode_positions.push(acir_opcode_positions[index]);
                 transformed_opcodes.push(opcode);
             }
+            Opcode::Call { .. } => todo!("Handle Call opcodes in the ACVM"),
         }
     }
 

diff --git a/acvm-repo/acvm/src/pwg/mod.rs b/acvm-repo/acvm/src/pwg/mod.rs
@@ -281,6 +281,7 @@ impl<'a, B: BlackBoxFunctionSolver> ACVM<'a, B> {
                 Ok(Some(foreign_call)) => return self.wait_for_foreign_call(foreign_call),
                 res => res.map(|_| ()),
             },
+            Opcode::Call { .. } => todo!("Handle Call opcodes in the ACVM"),
         };
         self.handle_opcode_resolution(resolution)
     }

diff --git a/acvm-repo/brillig/src/opcodes.rs b/acvm-repo/brillig/src/opcodes.rs
@@ -180,9 +180,16 @@ pub enum BinaryFieldOp {
     Add,
     Sub,
     Mul,
+    /// Field division
     Div,
+    /// Integer division
+    IntegerDiv,
     /// (==) equal
     Equals,
+    /// (<) Field less than
+    LessThan,
+    /// (<=) field less or equal
+    LessThanEquals,
 }
 
 /// Binary fixed-length integer expressions

diff --git a/acvm-repo/brillig_vm/src/arithmetic.rs b/acvm-repo/brillig_vm/src/arithmetic.rs
@@ -15,7 +15,16 @@ pub(crate) fn evaluate_binary_field_op(
         BinaryFieldOp::Sub => a - b,
         BinaryFieldOp::Mul => a * b,
         BinaryFieldOp::Div => a / b,
+        BinaryFieldOp::IntegerDiv => {
+            let a_big = BigUint::from_bytes_be(&a.to_be_bytes());
+            let b_big = BigUint::from_bytes_be(&b.to_be_bytes());
+
+            let result = a_big / b_big;
+            FieldElement::from_be_bytes_reduce(&result.to_bytes_be())
+        }
         BinaryFieldOp::Equals => (a == b).into(),
+        BinaryFieldOp::LessThan => (a < b).into(),
+        BinaryFieldOp::LessThanEquals => (a <= b).into(),
     }
 }
 

diff --git a/aztec_macros/src/lib.rs b/aztec_macros/src/lib.rs
@@ -179,15 +179,6 @@ fn transform_module(
                 crate_graph.root_file_id,
             ));
         }
-
-        let constructor_defined = module.functions.iter().any(|func| func.name() == "constructor");
-        if !constructor_defined {
-            let crate_graph = &context.crate_graph[crate_id];
-            return Err((
-                AztecMacroError::ContractConstructorMissing { span: Span::default() },
-                crate_graph.root_file_id,
-            ));
-        }
     }
 
     Ok(has_transformed_module)

diff --git a/aztec_macros/src/transforms/functions.rs b/aztec_macros/src/transforms/functions.rs
@@ -48,10 +48,9 @@ pub fn transform_function(
         func.def.body.0.insert(0, init_check);
     }
 
-    // Add assertion for initialization arguments
+    // Add assertion for initialization arguments and sender
     if is_initializer {
-        let assert_init_args = create_assert_init_args();
-        func.def.body.0.insert(0, assert_init_args);
+        func.def.body.0.insert(0, create_assert_initializer());
     }
 
     // Add access to the storage struct
@@ -120,9 +119,6 @@ pub fn transform_vm_function(
     // We want the function to be seen as a public function
     func.def.is_unconstrained = true;
 
-    // NOTE: the line below is a temporary hack to trigger external transpilation tools
-    // It will be removed once the transpiler is integrated into the Noir compiler
-    func.def.name.0.contents = format!("avm_{}", func.def.name.0.contents);
     Ok(())
 }
 
@@ -211,18 +207,19 @@ fn create_internal_check(fname: &str) -> Statement {
     )))
 }
 
-/// Creates a call to assert_initialization_args_match_address_preimage to ensure
-/// the initialization arguments used in the init call match the address preimage.
+/// Creates a call to assert_initialization_matches_address_preimage to be inserted
+/// in the initializer. Checks that the args and sender to the initializer match the
+/// commitments from the address preimage.
 ///
 /// ```noir
-/// assert_initialization_args_match_address_preimage(context);
+/// assert_initialization_matches_address_preimage(context);
 /// ```
-fn create_assert_init_args() -> Statement {
+fn create_assert_initializer() -> Statement {
     make_statement(StatementKind::Expression(call(
         variable_path(chained_dep!(
             "aztec",
             "initializer",
-            "assert_initialization_args_match_address_preimage"
+            "assert_initialization_matches_address_preimage"
         )),
         vec![variable("context")],
     )))
Original file line number	Diff line number	Diff line change
		@@ -1 +1 @@
		aa90f6ed7bfae06bdf6990816d154bbd24993689
		86e1a86461bff5263567af33f20756ce560e22ca
-Original file line number
+Diff line change
@@ Expand Up / @@ -145,6 +145,7 @@ pub(super) fn transform_internal( @@
                     new_acir_opcode_positions.push(acir_opcode_positions[index]);
                     transformed_opcodes.push(opcode);
                 }
+                Opcode::Call { .. } => todo!("Handle Call opcodes in the ACVM"),
             }
         }
@@ Expand Down @@