feat: public kernel in noir

yarn-project/noir-protocol-circuits/src/crates/public-kernel-lib/Nargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "public_kernel_lib"
+type = "lib"
+authors = [""]
+compiler_version = ">=0.18.0"
+
+[dependencies]
+aztec = { path="../../../../aztec-nr/aztec" }

yarn-project/noir-protocol-circuits/src/crates/public-kernel-lib/src/abis/historical_block_data.nr

@@ -0,0 +1,40 @@
+use crate::block::Block;
+
+struct HistoricalBlockData {
+    blocks_tree_root : Field,
+    block : Block,
+    // Private data
+    // This is marked in the cpp code as an enhancement
+    private_kernel_vk_tree_root : Field,
+}
+
+impl HistoricalBlockData {
+    fn assert_is_zero(self) {
+        self.block.assert_is_zero();
+        assert(self.private_kernel_vk_tree_root == 0);
+    }
+
+    fn to_array(self) -> [Field;7] {
+        // This comment was copied from the cpp codebase.
+        //
+        // TODO: Note private_kernel_vk_tree_root, is not included yet as
+        // it is not present in noir,
+        [
+            self.block.note_hash_tree_root,
+            self.block.nullifier_tree_root,
+            self.block.contract_tree_root,
+            self.block.l1_to_l2_data_tree_root,
+            self.blocks_tree_root,
+            self.block.public_data_tree_root,
+            self.block.global_variables_hash
+        ]
+    }
+
+    fn note_hash_tree_root(self) -> Field {
+        self.block.note_hash_tree_root
+    }
+
+    fn contract_tree_root(self) -> Field {
+        self.block.contract_tree_root
+    }
+}

yarn-project/noir-protocol-circuits/src/crates/public-kernel-lib/src/abis/public_circuit_public_inputs.nr

@@ -0,0 +1,69 @@
+use crate::contrakt::storage_read::StorageRead;
+use crate::contrakt::storage_update_request::StorageUpdateRequest;
+use crate::address::Address;
+use crate::abis::historical_block_data::HistoricalBlockData;
+use dep::aztec::constants_gen;
+use crate::hash::{NUM_FIELDS_PER_SHA256};
+use dep::aztec::constants_gen::{
+    MAX_NEW_L2_TO_L1_MSGS_PER_CALL,
+    MAX_NEW_NULLIFIERS_PER_CALL,
+    MAX_NEW_COMMITMENTS_PER_CALL,
+    MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
+    MAX_PUBLIC_DATA_READS_PER_CALL,
+    MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,
+    RETURN_VALUES_LENGTH,
+};
+use crate::abis::call_context::CallContext;
+use crate::utils::bounded_vec::BoundedVec;
+
+struct PublicCircuitPublicInputs{
+    call_context : CallContext,
+
+    args_hash : Field,
+    return_values : [Field; RETURN_VALUES_LENGTH],
+
+    contract_storage_update_requests : [StorageUpdateRequest;MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],
+    contract_storage_reads : [StorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],
+
+    public_call_stack : [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],
+    new_commitments : [Field; MAX_NEW_COMMITMENTS_PER_CALL],
+    new_nullifiers : [Field; MAX_NEW_NULLIFIERS_PER_CALL],
+    new_l2_to_l1_msgs : [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],
+
+    unencrypted_logs_hash : [Field; NUM_FIELDS_PER_SHA256],
+
+    // Here so that the gas cost of this request can be measured by circuits, without actually needing to feed in the
+    // variable-length data.
+    unencrypted_log_preimages_length : Field,
+
+    historical_block_data : HistoricalBlockData,
+
+    prover_address : Address,
+}
+
+
+impl PublicCircuitPublicInputs{
+    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/3059) : Reuse aztec-nr
+    fn hash(self) -> Field {        
+        let mut inputs: BoundedVec<Field, constants_gen::PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH> = BoundedVec::new(0);
+        inputs.push(self.call_context.hash());
+        inputs.push(self.args_hash);
+        inputs.push_array(self.return_values);
+        for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {
+            inputs.push(self.contract_storage_update_requests[i].hash());
+        }
+        for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {
+            inputs.push(self.contract_storage_reads[i].hash());
+        }
+        inputs.push_array(self.public_call_stack);
+        inputs.push_array(self.new_commitments);
+        inputs.push_array(self.new_nullifiers);
+        inputs.push_array(self.new_l2_to_l1_msgs);
+        inputs.push_array(self.unencrypted_logs_hash);
+        inputs.push(self.unencrypted_log_preimages_length);
+        inputs.push_array(self.historical_block_data.to_array());
+        inputs.push(self.prover_address.to_field());
+
+        dep::std::hash::pedersen_hash_with_separator(inputs.storage, constants_gen::GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)
+    }
+}

yarn-project/noir-protocol-circuits/src/crates/public-kernel-lib/src/abis/public_data_read.nr

@@ -0,0 +1,15 @@
+use dep::aztec::constants_gen;
+
+struct PublicDataRead {
+    leaf_index : Field,
+    value : Field,
+}
+
+impl PublicDataRead {
+    fn hash(self) -> Field {
+        dep::std::hash::pedersen_hash_with_separator([
+            self.leaf_index,
+            self.value,
+        ], constants_gen::GENERATOR_INDEX__PUBLIC_DATA_READ)
+    }
+}

yarn-project/noir-protocol-circuits/src/crates/public-kernel-lib/src/abis/public_data_update_request.nr

@@ -0,0 +1,17 @@
+use dep::aztec::constants_gen;
+
+struct PublicDataUpdateRequest {
+    leaf_index : Field,
+    old_value : Field,
+    new_value : Field
+}
+
+impl PublicDataUpdateRequest {
+    fn hash(self) -> Field {
+        dep::std::hash::pedersen_hash_with_separator([
+            self.leaf_index,
+            self.old_value,
+            self.new_value
+        ], constants_gen::GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)
+    }
+}

yarn-project/noir-protocol-circuits/src/crates/public-kernel-lib/src/abis/public_kernel/public_call_data.nr

@@ -0,0 +1,14 @@
+use crate::address::{Address, EthAddress};
+use crate::utils::bounded_vec:BoundedVec;
+use dep::aztec::constants_gen::{MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL};
+use crate::abis::call_stack_item::PublicCallStackItem;
+
+struct PublicCallData {
+    call_stack_item: PublicCallStackItem,
+    public_call_stack_preimages: [PublicCallStackItem; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],
+
+    proof: Proof,
+    portal_contract_address: EthAddress,
+    bytecode_hash: Field,
+
+}

yarn-project/noir-protocol-circuits/src/crates/public-kernel-lib/src/address.nr

@@ -0,0 +1,79 @@
+use crate::utils;
+
+// Aztec address
+struct Address{
+    inner : Field
+}
+
+impl Address{
+
+    pub fn default() -> Self {
+        Self {
+            inner : 0
+        }
+    }
+
+    pub fn from_field(field : Field) -> Self {
+        Self {
+            inner : field
+        }
+    }
+
+    pub fn to_field(self) -> Field{
+        self.inner
+    }
+
+    pub fn assert_is_zero(self) {
+        assert(self.to_field() == 0);
+    }
+
+    pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{
+        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());
+        Self {
+            inner : result
+        }
+    }
+
+    pub fn eq(self, other : Self) -> bool {
+        self.to_field() == other.to_field()
+    }
+}
+
+struct EthAddress{
+    inner : Field
+}
+
+impl EthAddress{
+
+    pub fn default() -> Self {
+        Self {
+            inner : 0
+        }
+    }
+
+    pub fn from_field(field : Field) -> Self {
+        Self {
+            inner : field
+        }
+    }
+
+    pub fn to_field(self) -> Field{
+        self.inner
+    }
+
+    pub fn assert_is_zero(self) {
+        assert(self.to_field() == 0);
+    }
+
+    pub fn conditional_assign(predicate: bool, lhs : Self, rhs : Self) -> Self{
+        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());
+        Self {
+            inner : result
+        }
+    }
+
+    pub fn eq(self, other : Self) -> bool {
+        self.to_field() == other.to_field()
+    }
+}
+

yarn-project/noir-protocol-circuits/src/crates/public-kernel-lib/src/call_context.nr

@@ -0,0 +1,39 @@
+use crate::abis::function_selector::FunctionSelector;
+use crate::address::{EthAddress,Address};
+use dep::aztec::constants_gen;
+
+struct CallContext{
+    msg_sender : Address,
+    storage_contract_address : Address,
+    portal_contract_address : EthAddress,
+
+    function_selector : FunctionSelector,
+
+    is_delegate_call : bool,
+    is_static_call : bool,
+    is_contract_deployment : bool,
+}
+
+impl CallContext {
+    fn hash(self) -> Field {
+        dep::std::hash::pedersen_hash_with_separator([
+            self.msg_sender.to_field(),
+            self.storage_contract_address.to_field(),
+            self.portal_contract_address.to_field(),
+            self.function_selector.to_field(),
+            self.is_delegate_call as Field,
+            self.is_static_call as Field,
+            self.is_contract_deployment as Field,
+        ], constants_gen::GENERATOR_INDEX__CALL_CONTEXT)
+    }
+
+    fn assert_is_zero(self) {
+        assert(self.msg_sender.to_field() == 0);
+        assert(self.storage_contract_address.to_field() == 0);
+        assert(self.portal_contract_address.to_field() == 0);
+        assert(self.function_selector.to_field() == 0);
+        assert(self.is_delegate_call == false);
+        assert(self.is_static_call == false);
+        assert(self.is_contract_deployment == false);
+    }
+}

yarn-project/noir-protocol-circuits/src/crates/public-kernel-lib/src/call_stack_item.nr

@@ -0,0 +1,89 @@
+use crate::address::Address;
+use crate::abis::function_data::FunctionData;
+use dep::aztec::constants_gen::{MAX_READ_REQUESTS_PER_CALL};
+use crate::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs;
+use crate::abis::public_circuit_public_inputs::PublicCircuitPublicInputs;
+use dep::aztec::constants_gen;
+
+// TODO(Noir-bug): These should be type aliases
+
+struct PublicCallStackItem {
+    inner : CallStackItem<PublicCircuitPublicInputs>
+}
+
+struct PrivateCallStackItem {
+    inner : CallStackItem<PrivateCircuitPublicInputs>
+}
+
+// Parametrize function over the public inputs.
+// The public inputs can be from either a public or a private circuit
+// TODO: We could monomorphize this struct and create a PrivateCallStackItem and 
+// TODO: a PublicCallStackItem
+struct CallStackItem<AppCircuitPublicInputs> {
+    // Comment copied from the cpp codebase
+    //
+    // This is the _actual_ contract address relating to where this function's code resides in the
+    // contract tree. Regardless of whether this is a call or delegatecall, this
+    // `contract_address` _does not change_. Amongst other things, it's used as a lookup for
+    // getting the correct code from the tree. There is a separate `storage_contract_address`
+    // within a CallStackItem which varies depending on whether this is a call or delegatecall.
+    contract_address : Address,
+
+    public_inputs : AppCircuitPublicInputs,
+
+    // True if this call stack item represents a request to execute a function rather than a
+    // fulfilled execution. Used when enqueuing calls from private to public functions.
+    is_execution_request : bool,
+
+    function_data : FunctionData,
+}
+
+// TODO(Traits): Defining a hash trait bound
+// Would allow the impl to be over `T : Hash`
+// Where T is public inputs
+
+// Noir(bug): If we can use a type alias instead of a new struct
+// then we can remove the getter methods below for things like
+// public_inputs and contract_address
+impl PublicCallStackItem {
+    fn hash(self) -> Field {
+        dep::std::hash::pedersen_hash_with_separator([
+            self.inner.contract_address.to_field(),
+            self.inner.function_data.hash(),
+            self.inner.public_inputs.hash(),
+        ], constants_gen::GENERATOR_INDEX__CALL_STACK_ITEM)
+    }
+
+    fn public_inputs(self) -> PublicCircuitPublicInputs {
+        self.inner.public_inputs
+    }
+
+    fn contract_address(self) -> Address{
+        self.inner.contract_address
+    }
+
+    fn function_data(self) -> FunctionData{
+        self.inner.function_data
+    }
+}
+impl PrivateCallStackItem {
+    fn hash(self) -> Field {
+        dep::std::hash::pedersen_hash_with_separator([
+            self.inner.contract_address.to_field(),
+            self.inner.function_data.hash(),
+            self.inner.public_inputs.hash(),
+        ], constants_gen::GENERATOR_INDEX__CALL_STACK_ITEM)
+    }
+
+    fn public_inputs(self) -> PrivateCircuitPublicInputs {
+        self.inner.public_inputs
+    }
+
+    fn contract_address(self) -> Address{
+        self.inner.contract_address
+    }
+
+    fn function_data(self) -> FunctionData{
+        self.inner.function_data
+    }
+}