feat: intial private kernel

circuits/cpp/src/aztec3/circuits/abis/.test.cpp

@@ -1,6 +1,5 @@
 #include "index.hpp"
 #include "previous_kernel_data.hpp"
-#include "private_kernel/private_inputs.hpp"
 
 #include "aztec3/circuits/abis/combined_accumulated_data.hpp"
 

circuits/cpp/src/aztec3/circuits/abis/c_bind.cpp

@@ -8,7 +8,7 @@
 #include "private_circuit_public_inputs.hpp"
 #include "tx_context.hpp"
 #include "tx_request.hpp"
-#include "private_kernel/private_inputs.hpp"
+#include "private_kernel/private_kernel_inputs_inner.hpp"
 #include "public_kernel/public_kernel_inputs.hpp"
 #include "public_kernel/public_kernel_inputs_no_previous_kernel.hpp"
 #include "rollup/base/base_or_merge_rollup_public_inputs.hpp"
@@ -18,6 +18,7 @@
 
 #include "aztec3/circuits/abis/combined_accumulated_data.hpp"
 #include "aztec3/circuits/abis/new_contract_data.hpp"
+#include "aztec3/circuits/abis/private_kernel/private_kernel_inputs_init.hpp"
 #include "aztec3/circuits/abis/signed_tx_request.hpp"
 #include "aztec3/circuits/abis/types.hpp"
 #include <aztec3/circuits/hash.hpp>
@@ -441,9 +442,14 @@ WASM_EXPORT const char* abis__test_roundtrip_serialize_signed_tx_request(uint8_t
     return as_string_output<aztec3::circuits::abis::SignedTxRequest<NT>>(input, size);
 }
 
-WASM_EXPORT const char* abis__test_roundtrip_serialize_private_kernel_inputs(uint8_t const* input, uint32_t* size)
+WASM_EXPORT const char* abis__test_roundtrip_serialize_private_kernel_inputs_inner(uint8_t const* input, uint32_t* size)
 {
-    return as_string_output<aztec3::circuits::abis::private_kernel::PrivateInputs<NT>>(input, size);
+    return as_string_output<aztec3::circuits::abis::private_kernel::PrivateKernelInputsInner<NT>>(input, size);
+}
+
+WASM_EXPORT const char* abis__test_roundtrip_serialize_private_kernel_inputs_init(uint8_t const* input, uint32_t* size)
+{
+    return as_string_output<aztec3::circuits::abis::private_kernel::PrivateKernelInputsInit<NT>>(input, size);
 }
 
 WASM_EXPORT const char* abis__test_roundtrip_serialize_kernel_circuit_public_inputs(uint8_t const* input,

circuits/cpp/src/aztec3/circuits/abis/c_bind.test.cpp

@@ -1,5 +1,4 @@
 #include "c_bind.h"
-
 #include "function_leaf_preimage.hpp"
 #include "tx_request.hpp"
 

circuits/cpp/src/aztec3/circuits/abis/private_kernel/private_inputs.hpp → circuits/cpp/src/aztec3/circuits/abis/private_kernel/private_kernel_inputs_init.hpp

@@ -1,75 +1,64 @@
 #pragma once
 
 #include "private_call_data.hpp"
-#include "../combined_accumulated_data.hpp"
-#include "../previous_kernel_data.hpp"
 #include "../signed_tx_request.hpp"
 
-#include <aztec3/utils/types/circuit_types.hpp>
-#include <aztec3/utils/types/convert.hpp>
-#include <aztec3/utils/types/native_types.hpp>
-
-#include <barretenberg/stdlib/primitives/witness/witness.hpp>
+#include "aztec3/utils/types/circuit_types.hpp"
+#include "aztec3/utils/types/native_types.hpp"
 
 namespace aztec3::circuits::abis::private_kernel {
 
 using aztec3::utils::types::CircuitTypes;
 using aztec3::utils::types::NativeTypes;
 using std::is_same;
 
-template <typename NCT> struct PrivateInputs {
+template <typename NCT> struct PrivateKernelInputsInit {
     using fr = typename NCT::fr;
     using boolean = typename NCT::boolean;
 
     SignedTxRequest<NCT> signed_tx_request{};
-    PreviousKernelData<NCT> previous_kernel{};
     PrivateCallData<NCT> private_call{};
 
-    boolean operator==(PrivateInputs<NCT> const& other) const
+    boolean operator==(PrivateKernelInputsInit<NCT> const& other) const
     {
-        return signed_tx_request == other.signed_tx_request && previous_kernel == other.previous_kernel &&
-               private_call == other.private_call;
+        return signed_tx_request == other.signed_tx_request && private_call == other.private_call;
     };
 
-    template <typename Composer> PrivateInputs<CircuitTypes<Composer>> to_circuit_type(Composer& composer) const
+    template <typename Composer>
+    PrivateKernelInputsInit<CircuitTypes<Composer>> to_circuit_type(Composer& composer) const
     {
         static_assert((std::is_same<NativeTypes, NCT>::value));
 
-        PrivateInputs<CircuitTypes<Composer>> private_inputs = {
+        PrivateKernelInputsInit<CircuitTypes<Composer>> private_inputs = {
             // TODO to_ct(signature),
             signed_tx_request.to_circuit_type(composer),
-            previous_kernel.to_circuit_type(composer),
             private_call.to_circuit_type(composer),
         };
 
         return private_inputs;
     };
 };
 
-template <typename NCT> void read(uint8_t const*& it, PrivateInputs<NCT>& private_inputs)
+template <typename NCT> void read(uint8_t const*& it, PrivateKernelInputsInit<NCT>& private_inputs)
 {
     using serialize::read;
 
     read(it, private_inputs.signed_tx_request);
-    read(it, private_inputs.previous_kernel);
     read(it, private_inputs.private_call);
 };
 
-template <typename NCT> void write(std::vector<uint8_t>& buf, PrivateInputs<NCT> const& private_inputs)
+template <typename NCT> void write(std::vector<uint8_t>& buf, PrivateKernelInputsInit<NCT> const& private_inputs)
 {
     using serialize::write;
 
     write(buf, private_inputs.signed_tx_request);
-    write(buf, private_inputs.previous_kernel);
     write(buf, private_inputs.private_call);
 };
 
-template <typename NCT> std::ostream& operator<<(std::ostream& os, PrivateInputs<NCT> const& private_inputs)
+template <typename NCT> std::ostream& operator<<(std::ostream& os, PrivateKernelInputsInit<NCT> const& private_inputs)
 {
     return os << "signed_tx_request:\n"
               << private_inputs.signed_tx_request << "\n"
-              << "previous_kernel:\n"
-              << private_inputs.previous_kernel << "\n"
               << "private_call:\n"
               << private_inputs.private_call << "\n";
 }

circuits/cpp/src/aztec3/circuits/abis/private_kernel/private_kernel_inputs_inner.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "private_call_data.hpp"
+#include "../previous_kernel_data.hpp"
+
+#include "aztec3/utils/types/circuit_types.hpp"
+#include "aztec3/utils/types/convert.hpp"
+#include "aztec3/utils/types/native_types.hpp"
+
+#include <barretenberg/stdlib/primitives/witness/witness.hpp>
+
+namespace aztec3::circuits::abis::private_kernel {
+
+using aztec3::utils::types::CircuitTypes;
+using aztec3::utils::types::NativeTypes;
+using std::is_same;
+
+template <typename NCT> struct PrivateKernelInputsInner {
+    using fr = typename NCT::fr;
+    using boolean = typename NCT::boolean;
+
+    PreviousKernelData<NCT> previous_kernel{};
+    PrivateCallData<NCT> private_call{};
+
+    boolean operator==(PrivateKernelInputsInner<NCT> const& other) const
+    {
+        return previous_kernel == other.previous_kernel && private_call == other.private_call;
+    };
+
+    template <typename Composer>
+    PrivateKernelInputsInner<CircuitTypes<Composer>> to_circuit_type(Composer& composer) const
+    {
+        static_assert((std::is_same<NativeTypes, NCT>::value));
+
+        PrivateKernelInputsInner<CircuitTypes<Composer>> private_inputs = {
+            previous_kernel.to_circuit_type(composer),
+            private_call.to_circuit_type(composer),
+        };
+
+        return private_inputs;
+    };
+};
+
+template <typename NCT> void read(uint8_t const*& it, PrivateKernelInputsInner<NCT>& private_inputs)
+{
+    using serialize::read;
+
+    read(it, private_inputs.previous_kernel);
+    read(it, private_inputs.private_call);
+};
+
+template <typename NCT> void write(std::vector<uint8_t>& buf, PrivateKernelInputsInner<NCT> const& private_inputs)
+{
+    using serialize::write;
+
+    write(buf, private_inputs.previous_kernel);
+    write(buf, private_inputs.private_call);
+};
+
+template <typename NCT> std::ostream& operator<<(std::ostream& os, PrivateKernelInputsInner<NCT> const& private_inputs)
+{
+    return os << "previous_kernel:\n"
+              << private_inputs.previous_kernel << "\n"
+              << "private_call:\n"
+              << private_inputs.private_call << "\n";
+}
+
+}  // namespace aztec3::circuits::abis::private_kernel