feat(public kernel): add new_commitments, new_nullifiers, new_l2_to_l1_msgs aggregation

circuits/cpp/src/aztec3/circuits/abis/public_circuit_public_inputs.hpp

@@ -34,7 +34,10 @@ template <typename NCT> struct PublicCircuitPublicInputs {
     std::array<ContractStorageRead<NCT>, KERNEL_PUBLIC_DATA_READS_LENGTH> contract_storage_reads{};
 
     std::array<fr, PUBLIC_CALL_STACK_LENGTH> public_call_stack = zero_array<fr, PUBLIC_CALL_STACK_LENGTH>();
-    std::array<fr, NEW_L2_TO_L1_MSGS_LENGTH> new_l2_to_l1_msgs = zero_array<fr, NEW_L2_TO_L1_MSGS_LENGTH>();
+    std::array<fr, KERNEL_NEW_COMMITMENTS_LENGTH> new_commitments = zero_array<fr, KERNEL_NEW_COMMITMENTS_LENGTH>();
+    std::array<fr, KERNEL_NEW_NULLIFIERS_LENGTH> new_nullifiers = zero_array<fr, KERNEL_NEW_NULLIFIERS_LENGTH>();
+    std::array<fr, KERNEL_NEW_L2_TO_L1_MSGS_LENGTH> new_l2_to_l1_msgs =
+        zero_array<fr, KERNEL_NEW_L2_TO_L1_MSGS_LENGTH>();
 
     fr historic_public_data_tree_root = 0;
 
@@ -47,9 +50,12 @@ template <typename NCT> struct PublicCircuitPublicInputs {
                    contract_storage_update_requests,
                    contract_storage_reads,
                    public_call_stack,
+                   new_commitments,
+                   new_nullifiers,
                    new_l2_to_l1_msgs,
                    historic_public_data_tree_root,
                    prover_address);
+
     boolean operator==(PublicCircuitPublicInputs<NCT> const& other) const
     {
         return msgpack_derived_equals<boolean>(*this, other);
@@ -74,6 +80,8 @@ template <typename NCT> struct PublicCircuitPublicInputs {
             .contract_storage_reads = map(contract_storage_reads, to_circuit_type),
 
             .public_call_stack = to_ct(public_call_stack),
+            .new_commitments = to_ct(new_commitments),
+            .new_nullifiers = to_ct(new_nullifiers),
             .new_l2_to_l1_msgs = to_ct(new_l2_to_l1_msgs),
 
             .historic_public_data_tree_root = to_ct(historic_public_data_tree_root),
@@ -101,6 +109,8 @@ template <typename NCT> struct PublicCircuitPublicInputs {
         spread_arr_into_vec(map(contract_storage_reads, to_hashes), inputs);
 
         spread_arr_into_vec(public_call_stack, inputs);
+        spread_arr_into_vec(new_commitments, inputs);
+        spread_arr_into_vec(new_nullifiers, inputs);
         spread_arr_into_vec(new_l2_to_l1_msgs, inputs);
 
         inputs.push_back(historic_public_data_tree_root);
@@ -128,6 +138,8 @@ template <typename NCT> void read(uint8_t const*& it, PublicCircuitPublicInputs<
     read(it, pis.contract_storage_reads);
 
     read(it, pis.public_call_stack);
+    read(it, pis.new_commitments);
+    read(it, pis.new_nullifiers);
     read(it, pis.new_l2_to_l1_msgs);
 
     read(it, pis.historic_public_data_tree_root);
@@ -150,6 +162,8 @@ void write(std::vector<uint8_t>& buf, PublicCircuitPublicInputs<NCT> const& publ
     write(buf, pis.contract_storage_reads);
 
     write(buf, pis.public_call_stack);
+    write(buf, pis.new_commitments);
+    write(buf, pis.new_nullifiers);
     write(buf, pis.new_l2_to_l1_msgs);
 
     write(buf, pis.historic_public_data_tree_root);

circuits/cpp/src/aztec3/circuits/kernel/public/common.hpp

@@ -196,6 +196,26 @@ void common_validate_inputs(DummyComposer& composer, KernelInput const& public_k
                        CircuitErrorCode::PUBLIC_KERNEL__BYTECODE_HASH_INVALID);
 }
 
+template <typename KernelInput, typename Composer>
+void perform_static_call_checks(Composer& composer, KernelInput const& public_kernel_inputs)
+{
+    // If the call is a static call, there should be no new commitments or nullifiers.
+    const auto& public_call_public_inputs = public_kernel_inputs.public_call.call_stack_item.public_inputs;
+
+    const auto& is_static_call = public_call_public_inputs.call_context.is_static_call;
+    const auto& new_commitments = public_call_public_inputs.new_commitments;
+    const auto& new_nullifiers = public_call_public_inputs.new_nullifiers;
+
+    if (is_static_call) {
+        composer.do_assert(utils::is_array_empty(new_commitments) == true,
+                           "perform_static_call_checks in static call new commitments must be empty",
+                           CircuitErrorCode::PUBLIC_KERNEL__NEW_COMMITMENTS_PROHIBITED_IN_STATIC_CALL);
+        composer.do_assert(utils::is_array_empty(new_nullifiers) == true,
+                           "perform_static_call_checks in static call new nullifiers must be empty",
+                           CircuitErrorCode::PUBLIC_KERNEL__NEW_NULLIFIERS_PROHIBITED_IN_STATIC_CALL);
+    }
+}
+
 /**
  * @brief Proagates valid (i.e. non-empty) update requests from this iteration to the circuit output
  * @tparam The type of kernel input
@@ -250,6 +270,99 @@ void propagate_valid_public_data_reads(Composer& composer,
     }
 }
 
+/**
+ * @brief Propagates new commitments from this iteration to the circuit output.
+ *
+ * @tparam The type of the kernel input
+ * @tparam The composer type
+ * @param public_kernel_inputs The inputs to this iteration to the kernel circuit.
+ * @param circuit_outputs The circuit outputs to be populated
+ */
+template <typename KernelInput, typename Composer>
+void propagate_new_commitments(Composer& composer,
+                               KernelInput const& public_kernel_inputs,
+                               KernelCircuitPublicInputs<NT>& circuit_outputs)
+{
+    // Get the new commitments
+    const auto& public_call_public_inputs = public_kernel_inputs.public_call.call_stack_item.public_inputs;
+
+    const auto& new_commitments = public_call_public_inputs.new_commitments;
+    const auto& storage_contract_address = public_call_public_inputs.call_context.storage_contract_address;
+
+    std::array<NT::fr, KERNEL_NEW_COMMITMENTS_LENGTH> siloed_new_commitments{};
+    for (size_t i = 0; i < new_commitments.size(); ++i) {
+        if (!new_commitments[i].is_zero()) {
+            siloed_new_commitments[i] = silo_commitment<NT>(storage_contract_address, new_commitments[i]);
+        }
+    }
+
+    push_array_to_array(composer, siloed_new_commitments, circuit_outputs.end.new_commitments);
+}
+
+/**
+ * @brief Propagates new nullifiers from this iteration to the circuit output.
+ *
+ * @tparam The type of the kernel input
+ * @tparam The composer type
+ * @param public_kernel_inputs The inputs to this iteration to the kernel circuit.
+ * @param circuit_outputs The circuit outputs to be populated
+ */
+template <typename KernelInput, typename Composer>
+void propagate_new_nullifiers(Composer& composer,
+                              KernelInput const& public_kernel_inputs,
+                              KernelCircuitPublicInputs<NT>& circuit_outputs)
+{
+    // Get the new commitments
+    const auto& public_call_public_inputs = public_kernel_inputs.public_call.call_stack_item.public_inputs;
+
+    const auto& new_nullifiers = public_call_public_inputs.new_nullifiers;
+    const auto& storage_contract_address = public_call_public_inputs.call_context.storage_contract_address;
+
+    std::array<NT::fr, KERNEL_NEW_NULLIFIERS_LENGTH> siloed_new_nullifiers{};
+    for (size_t i = 0; i < new_nullifiers.size(); ++i) {
+        if (!new_nullifiers[i].is_zero()) {
+            siloed_new_nullifiers[i] = silo_nullifier<NT>(storage_contract_address, new_nullifiers[i]);
+        }
+    }
+
+    push_array_to_array(composer, siloed_new_nullifiers, circuit_outputs.end.new_nullifiers);
+}
+
+/**
+ * @brief Propagates new l2 to l1 messages from this iteration to the circuit output.
+ *
+ * @tparam The type of the kernel input
+ * @param public_kernel_inputs The inputs to this iteration to the kernel circuit.
+ * @param circuit_outputs The circuit outputs to be populated
+ */
+template <typename KernelInput, typename Composer>
+void propagate_new_l2_to_l1_messages(Composer& composer,
+                                     KernelInput const& public_kernel_inputs,
+                                     KernelCircuitPublicInputs<NT>& circuit_outputs)
+{
+    // Get the new l2 messages
+    const auto& public_call_public_inputs = public_kernel_inputs.public_call.call_stack_item.public_inputs;
+
+    const auto& portal_contract_address = public_kernel_inputs.public_call.portal_contract_address;
+    const auto& storage_contract_address = public_call_public_inputs.call_context.storage_contract_address;
+    const auto& new_l2_to_l1_msgs = public_call_public_inputs.new_l2_to_l1_msgs;
+
+    std::array<NT::fr, NEW_L2_TO_L1_MSGS_LENGTH> new_l2_to_l1_msgs_to_insert{};
+    for (size_t i = 0; i < new_l2_to_l1_msgs.size(); ++i) {
+        if (!new_l2_to_l1_msgs[i].is_zero()) {
+            // @todo @lherskind chain-ids and rollup version id should be added here. right now, just hard coded.
+            // @todo @lherskind chain-id is hardcoded for foundry
+            const auto chain_id = fr(31337);
+            new_l2_to_l1_msgs_to_insert[i] = compute_l2_to_l1_hash<NT>(storage_contract_address,
+                                                                       fr(1),  // rollup version id
+                                                                       portal_contract_address,
+                                                                       chain_id,
+                                                                       new_l2_to_l1_msgs[i]);
+        }
+    }
+    push_array_to_array(composer, new_l2_to_l1_msgs_to_insert, circuit_outputs.end.new_l2_to_l1_msgs);
+}
+
 /**
  * @brief Propagates valid (i.e. non-empty) public data reads from this iteration to the circuit output
  * @tparam The type of kernel input
@@ -265,9 +378,17 @@ void common_update_public_end_values(Composer& composer,
     // Updates the circuit outputs with new state changes, call stack etc
     circuit_outputs.is_private = false;
 
+    // If this call is a static call, certain operations are disallowed, such as creating new state.
+    perform_static_call_checks(composer, public_kernel_inputs);
+
     const auto& stack = public_kernel_inputs.public_call.call_stack_item.public_inputs.public_call_stack;
     push_array_to_array(composer, stack, circuit_outputs.end.public_call_stack);
 
+    propagate_new_commitments(composer, public_kernel_inputs, circuit_outputs);
+    propagate_new_nullifiers(composer, public_kernel_inputs, circuit_outputs);
+
+    propagate_new_l2_to_l1_messages(composer, public_kernel_inputs, circuit_outputs);
+
     propagate_valid_public_data_update_requests(composer, public_kernel_inputs, circuit_outputs);
 
     propagate_valid_public_data_reads(composer, public_kernel_inputs, circuit_outputs);

circuits/cpp/src/aztec3/utils/circuit_errors.hpp

@@ -55,6 +55,8 @@ enum CircuitErrorCode : uint16_t {
     PUBLIC_KERNEL__CALL_CONTEXT_INVALID_STORAGE_ADDRESS_FOR_DELEGATE_CALL = 3023,
     PUBLIC_KERNEL__CALL_CONTEXT_CONTRACT_STORAGE_UPDATE_REQUESTS_PROHIBITED_FOR_STATIC_CALL = 3024,
     PUBLIC_KERNEL__NEW_NULLIFIERS_NOT_EMPTY_IN_FIRST_ITERATION = 3025,
+    PUBLIC_KERNEL__NEW_COMMITMENTS_PROHIBITED_IN_STATIC_CALL = 3026,
+    PUBLIC_KERNEL__NEW_NULLIFIERS_PROHIBITED_IN_STATIC_CALL = 3027,
 
     BASE_FAILED = 4000,
     BASE__KERNEL_PROOF_VERIFICATION_FAILED = 4001,

yarn-project/circuits.js/package.json

@@ -22,7 +22,7 @@
     "clean": "rm -rf ./dest .tsbuildinfo",
     "formatting": "run -T prettier --check ./src && run -T eslint ./src",
     "formatting:fix": "run -T prettier -w ./src",
-    "remake-bindings": "DEBUG=wasm ts-node-esm src/cbind/circuits.in.ts && prettier -w src/cbind/circuits.gen.ts",
+    "remake-bindings": "DEBUG=wasm ts-node-esm src/cbind/circuits.in.ts && sed -i 's/CallStackItem/PublicCallStackItem/g' src/cbind/circuits.gen.ts && prettier -w src/cbind/circuits.gen.ts ",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --passWithNoTests"
   },
   "inherits": [

yarn-project/circuits.js/src/cbind/circuits.gen.ts

@@ -1006,6 +1006,8 @@ interface MsgpackPublicCircuitPublicInputs {
   contract_storage_update_requests: Tuple<MsgpackContractStorageUpdateRequest, 4>;
   contract_storage_reads: Tuple<MsgpackContractStorageRead, 4>;
   public_call_stack: Tuple<Buffer, 4>;
+  new_commitments: Tuple<Buffer, 4>;
+  new_nullifiers: Tuple<Buffer, 4>;
   new_l2_to_l1_msgs: Tuple<Buffer, 2>;
   historic_public_data_tree_root: Buffer;
   prover_address: Buffer;
@@ -1030,6 +1032,12 @@ export function toPublicCircuitPublicInputs(o: MsgpackPublicCircuitPublicInputs)
   if (o.public_call_stack === undefined) {
     throw new Error('Expected public_call_stack in PublicCircuitPublicInputs deserialization');
   }
+  if (o.new_commitments === undefined) {
+    throw new Error('Expected new_commitments in PublicCircuitPublicInputs deserialization');
+  }
+  if (o.new_nullifiers === undefined) {
+    throw new Error('Expected new_nullifiers in PublicCircuitPublicInputs deserialization');
+  }
   if (o.new_l2_to_l1_msgs === undefined) {
     throw new Error('Expected new_l2_to_l1_msgs in PublicCircuitPublicInputs deserialization');
   }
@@ -1048,6 +1056,8 @@ export function toPublicCircuitPublicInputs(o: MsgpackPublicCircuitPublicInputs)
     ),
     mapTuple(o.contract_storage_reads, (v: MsgpackContractStorageRead) => toContractStorageRead(v)),
     mapTuple(o.public_call_stack, (v: Buffer) => Fr.fromBuffer(v)),
+    mapTuple(o.new_commitments, (v: Buffer) => Fr.fromBuffer(v)),
+    mapTuple(o.new_nullifiers, (v: Buffer) => Fr.fromBuffer(v)),
     mapTuple(o.new_l2_to_l1_msgs, (v: Buffer) => Fr.fromBuffer(v)),
     Fr.fromBuffer(o.historic_public_data_tree_root),
     Address.fromBuffer(o.prover_address),
@@ -1073,6 +1083,12 @@ export function fromPublicCircuitPublicInputs(o: PublicCircuitPublicInputs): Msg
   if (o.publicCallStack === undefined) {
     throw new Error('Expected publicCallStack in PublicCircuitPublicInputs serialization');
   }
+  if (o.newCommitments === undefined) {
+    throw new Error('Expected newCommitments in PublicCircuitPublicInputs serialization');
+  }
+  if (o.newNullifiers === undefined) {
+    throw new Error('Expected newNullifiers in PublicCircuitPublicInputs serialization');
+  }
   if (o.newL2ToL1Msgs === undefined) {
     throw new Error('Expected newL2ToL1Msgs in PublicCircuitPublicInputs serialization');
   }
@@ -1091,6 +1107,8 @@ export function fromPublicCircuitPublicInputs(o: PublicCircuitPublicInputs): Msg
     ),
     contract_storage_reads: mapTuple(o.contractStorageReads, (v: ContractStorageRead) => fromContractStorageRead(v)),
     public_call_stack: mapTuple(o.publicCallStack, (v: Fr) => v.toBuffer()),
+    new_commitments: mapTuple(o.newCommitments, (v: Fr) => v.toBuffer()),
+    new_nullifiers: mapTuple(o.newNullifiers, (v: Fr) => v.toBuffer()),
     new_l2_to_l1_msgs: mapTuple(o.newL2ToL1Msgs, (v: Fr) => v.toBuffer()),
     historic_public_data_tree_root: o.historicPublicDataTreeRoot.toBuffer(),
     prover_address: o.proverAddress.toBuffer(),