feat: Integrate databus in the private kernels (#9028)

Integrates the databus in the private kernels. We do this by annotating
with call_data(0) for previous kernel public inputs and call_data(1) for
app public inputs. Kernels and apps expose their own public inputs as
return_data except the tail kernel who does it via the traditional
public inputs mechanism for the tube.

barretenberg/cpp/src/barretenberg/bb/main.cpp

@@ -608,7 +608,7 @@ void prove_tube(const std::string& output_path)
     // set_public on each witness
     auto num_public_inputs = static_cast<uint32_t>(static_cast<uint256_t>(proof.folding_proof[1]));
     num_public_inputs -= bb::AGGREGATION_OBJECT_SIZE; // don't add the agg object
-    num_public_inputs -= 2 * 8;                       // don't add the databus return data commitments (2x)
+    num_public_inputs -= 1 * 8; // TODO(https://github.com/AztecProtocol/barretenberg/issues/1125) Make this dynamic
     for (size_t i = 0; i < num_public_inputs; i++) {
         auto offset = acir_format::HONK_RECURSION_PUBLIC_INPUT_OFFSET;
         builder->add_public_variable(proof.folding_proof[i + offset]);

barretenberg/cpp/src/barretenberg/constants.hpp

@@ -13,5 +13,5 @@ static constexpr uint32_t CONST_PG_LOG_N = 20;
 
 static constexpr uint32_t MAX_LOOKUP_TABLES_SIZE = 70000;
 
-static constexpr uint32_t MAX_DATABUS_SIZE = 10;
+static constexpr uint32_t MAX_DATABUS_SIZE = 10000;
 } // namespace bb

barretenberg/cpp/src/barretenberg/plonk_honk_shared/arithmetization/mega_arithmetization.hpp

@@ -94,7 +94,7 @@ template <typename FF_> class MegaArith {
             this->elliptic = 80000;
             this->aux = 100000;
             this->lookup = 200000;
-            this->busread = 100;
+            this->busread = 6000;
             this->poseidon2_external = 30000;
             this->poseidon2_internal = 150000;
         }

l1-contracts/src/core/libraries/ConstantsGen.sol

@@ -191,6 +191,7 @@ library Constants {
   uint256 internal constant PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = 544;
   uint256 internal constant PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = 691;
   uint256 internal constant PRIVATE_CALL_STACK_ITEM_LENGTH = 547;
+  uint256 internal constant PRIVATE_CONTEXT_INPUTS_LENGTH = 39;
   uint256 internal constant PUBLIC_CONTEXT_INPUTS_LENGTH = 42;
   uint256 internal constant AGGREGATION_OBJECT_LENGTH = 16;
   uint256 internal constant SCOPED_READ_REQUEST_LEN = 3;

noir-projects/aztec-nr/aztec/src/macros/functions/mod.nr

@@ -215,10 +215,10 @@ pub comptime fn private(f: FunctionDefinition) -> Quoted {
     let modified_body = modify_fn_body(body, to_prepend, to_append);
     f.set_body(modified_body);
     f.add_attribute("recursive");
-    f.set_return_public(true);
     f.set_return_type(
         quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }.as_type()
     );
+    f.set_return_data();
 
     fn_abi
 }

noir-projects/mock-protocol-circuits/crates/mock-private-kernel-tail/src/main.nr

@@ -1,7 +1,7 @@
 use dep::mock_types::{PrivateKernelPublicInputs, KernelPublicInputs, MAX_COMMITMENT_READ_REQUESTS_PER_TX};
 
 // The tail kernel finishes the client IVC chain exposing the final public inputs with no remaining calls or unfulfilled read requests.
-fn main(prev_kernel_public_inputs: call_data(0) PrivateKernelPublicInputs) -> return_data KernelPublicInputs {
+fn main(prev_kernel_public_inputs: call_data(0) PrivateKernelPublicInputs) -> pub KernelPublicInputs {
     assert_eq(prev_kernel_public_inputs.remaining_calls, 0);
     for i in 0..MAX_COMMITMENT_READ_REQUESTS_PER_TX {
         assert_eq(prev_kernel_public_inputs.read_requests[i], 0);

noir-projects/noir-protocol-circuits/crates/private-kernel-init-simulated/src/main.nr

@@ -1,6 +1,15 @@
 use dep::private_kernel_lib::PrivateKernelInitCircuitPrivateInputs;
 use dep::types::PrivateKernelCircuitPublicInputs;
+use types::transaction::tx_request::TxRequest;
+use types::abis::private_kernel::private_call_data::PrivateCallDataWithoutPublicInputs;
+use types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs;
 
-unconstrained fn main(input: PrivateKernelInitCircuitPrivateInputs) -> pub PrivateKernelCircuitPublicInputs {
-    input.execute()
+unconstrained fn main(
+    tx_request: TxRequest,
+    vk_tree_root: Field,
+    private_call: PrivateCallDataWithoutPublicInputs,
+    app_public_inputs: PrivateCircuitPublicInputs
+) -> pub PrivateKernelCircuitPublicInputs {
+    let private_inputs = PrivateKernelInitCircuitPrivateInputs::new(tx_request, vk_tree_root, private_call, app_public_inputs);
+    private_inputs.execute()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-init/src/main.nr

@@ -1,7 +1,15 @@
 use dep::private_kernel_lib::PrivateKernelInitCircuitPrivateInputs;
 use dep::types::PrivateKernelCircuitPublicInputs;
+use types::transaction::tx_request::TxRequest;
+use types::abis::private_kernel::private_call_data::PrivateCallDataWithoutPublicInputs;
+use types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs;
 
-#[recursive]
-fn main(input: PrivateKernelInitCircuitPrivateInputs) -> pub PrivateKernelCircuitPublicInputs {
-    input.execute()
+fn main(
+    tx_request: TxRequest,
+    vk_tree_root: Field,
+    private_call: PrivateCallDataWithoutPublicInputs,
+    app_public_inputs: call_data(1) PrivateCircuitPublicInputs
+) -> return_data PrivateKernelCircuitPublicInputs {
+    let private_inputs = PrivateKernelInitCircuitPrivateInputs::new(tx_request, vk_tree_root, private_call, app_public_inputs);
+    private_inputs.execute()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-inner-simulated/src/main.nr

@@ -1,6 +1,20 @@
 use dep::private_kernel_lib::PrivateKernelInnerCircuitPrivateInputs;
 use dep::types::PrivateKernelCircuitPublicInputs;
+use types::abis::private_kernel_data::PrivateKernelDataWithoutPublicInputs;
+use types::abis::private_kernel::private_call_data::PrivateCallDataWithoutPublicInputs;
+use types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs;
 
-unconstrained fn main(input: PrivateKernelInnerCircuitPrivateInputs) -> pub PrivateKernelCircuitPublicInputs {
-    input.execute()
+unconstrained fn main(
+    previous_kernel: PrivateKernelDataWithoutPublicInputs,
+    previous_kernel_public_inputs: PrivateKernelCircuitPublicInputs,
+    private_call: PrivateCallDataWithoutPublicInputs,
+    app_public_inputs: PrivateCircuitPublicInputs
+) -> pub PrivateKernelCircuitPublicInputs {
+    let private_inputs = PrivateKernelInnerCircuitPrivateInputs::new(
+        previous_kernel,
+        previous_kernel_public_inputs,
+        private_call,
+        app_public_inputs
+    );
+    private_inputs.execute()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-inner/src/main.nr

@@ -1,7 +1,20 @@
 use dep::private_kernel_lib::PrivateKernelInnerCircuitPrivateInputs;
 use dep::types::PrivateKernelCircuitPublicInputs;
+use types::abis::private_kernel_data::PrivateKernelDataWithoutPublicInputs;
+use types::abis::private_kernel::private_call_data::PrivateCallDataWithoutPublicInputs;
+use types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs;
 
-#[recursive]
-fn main(input: PrivateKernelInnerCircuitPrivateInputs) -> pub PrivateKernelCircuitPublicInputs {
-    input.execute()
+fn main(
+    previous_kernel: PrivateKernelDataWithoutPublicInputs,
+    previous_kernel_public_inputs: call_data(0) PrivateKernelCircuitPublicInputs,
+    private_call: PrivateCallDataWithoutPublicInputs,
+    app_public_inputs: call_data(1) PrivateCircuitPublicInputs
+) -> return_data PrivateKernelCircuitPublicInputs {
+    let private_inputs = PrivateKernelInnerCircuitPrivateInputs::new(
+        previous_kernel,
+        previous_kernel_public_inputs,
+        private_call,
+        app_public_inputs
+    );
+    private_inputs.execute()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/private_kernel_init.nr

@@ -8,7 +8,8 @@ use crate::{
 use dep::types::{
     abis::{
     kernel_circuit_public_inputs::PrivateKernelCircuitPublicInputs,
-    private_kernel::private_call_data::PrivateCallData
+    private_kernel::private_call_data::{PrivateCallData, PrivateCallDataWithoutPublicInputs},
+    private_circuit_public_inputs::PrivateCircuitPublicInputs
 },
     transaction::tx_request::TxRequest
 };
@@ -21,6 +22,15 @@ pub struct PrivateKernelInitCircuitPrivateInputs {
 }
 
 impl PrivateKernelInitCircuitPrivateInputs {
+    pub fn new(
+        tx_request: TxRequest,
+        vk_tree_root: Field,
+        private_call: PrivateCallDataWithoutPublicInputs,
+        app_public_inputs: PrivateCircuitPublicInputs
+    ) -> Self {
+        Self { tx_request, vk_tree_root, private_call: private_call.to_private_call_data(app_public_inputs) }
+    }
+
     unconstrained fn generate_output(self) -> PrivateKernelCircuitPublicInputs {
         let private_call_public_inputs = self.private_call.call_stack_item.public_inputs;
         PrivateKernelCircuitPublicInputsComposer::new_from_tx_request(self.tx_request, private_call_public_inputs, self.vk_tree_root).with_private_call(

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/private_kernel_inner.nr

@@ -9,7 +9,9 @@ use crate::{
 use dep::types::{
     abis::{
     kernel_circuit_public_inputs::{PrivateKernelCircuitPublicInputs, PrivateKernelCircuitPublicInputsArrayLengths},
-    private_kernel_data::PrivateKernelData, private_kernel::private_call_data::PrivateCallData
+    private_kernel_data::{PrivateKernelData, PrivateKernelDataWithoutPublicInputs},
+    private_kernel::private_call_data::{PrivateCallData, PrivateCallDataWithoutPublicInputs},
+    private_circuit_public_inputs::PrivateCircuitPublicInputs
 },
     constants::{PRIVATE_KERNEL_INIT_INDEX, PRIVATE_KERNEL_INNER_INDEX, PRIVATE_KERNEL_RESET_INDEX}
 };
@@ -26,6 +28,18 @@ pub struct PrivateKernelInnerCircuitPrivateInputs {
 }
 
 impl PrivateKernelInnerCircuitPrivateInputs {
+    pub fn new(
+        previous_kernel: PrivateKernelDataWithoutPublicInputs,
+        previous_kernel_public_inputs: PrivateKernelCircuitPublicInputs,
+        private_call: PrivateCallDataWithoutPublicInputs,
+        app_public_inputs: PrivateCircuitPublicInputs
+    ) -> Self {
+        Self {
+            previous_kernel: previous_kernel.to_private_kernel_data(previous_kernel_public_inputs),
+            private_call: private_call.to_private_call_data(app_public_inputs)
+        }
+    }
+
     unconstrained fn generate_output(self) -> PrivateKernelCircuitPublicInputs {
         PrivateKernelCircuitPublicInputsComposer::new_from_previous_kernel(self.previous_kernel.public_inputs).pop_top_call_request().with_private_call(
             self.private_call.call_stack_item.public_inputs,

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/private_kernel_reset.nr

@@ -8,7 +8,7 @@ use dep::reset_kernel_lib::{
     PrivateValidationRequestProcessor, TransientDataIndexHint
 };
 use dep::types::{
-    abis::private_kernel_data::PrivateKernelData,
+    abis::private_kernel_data::{PrivateKernelData, PrivateKernelDataWithoutPublicInputs},
     constants::{PRIVATE_KERNEL_INIT_INDEX, PRIVATE_KERNEL_INNER_INDEX, PRIVATE_KERNEL_RESET_INDEX},
     PrivateKernelCircuitPublicInputs
 };
@@ -40,6 +40,14 @@ impl<
     let KEY_VALIDATION_REQUESTS: u32,
     let TRANSIENT_DATA_AMOUNT: u32
 > PrivateKernelResetCircuitPrivateInputs<NH_RR_PENDING, NH_RR_SETTLED, NLL_RR_PENDING, NLL_RR_SETTLED, KEY_VALIDATION_REQUESTS, TRANSIENT_DATA_AMOUNT> {
+    fn new(
+        previous_kernel: PrivateKernelDataWithoutPublicInputs,
+        previous_kernel_public_inputs: PrivateKernelCircuitPublicInputs,
+        hints: PrivateKernelResetHints<NH_RR_PENDING, NH_RR_SETTLED, NLL_RR_PENDING, NLL_RR_SETTLED, KEY_VALIDATION_REQUESTS, TRANSIENT_DATA_AMOUNT>
+    ) -> Self {
+        Self { previous_kernel: previous_kernel.to_private_kernel_data(previous_kernel_public_inputs), hints }
+    }
+
     unconstrained fn generate_output(
         self,
         validation_request_processor: PrivateValidationRequestProcessor<NH_RR_PENDING, NH_RR_SETTLED, NLL_RR_PENDING, NLL_RR_SETTLED, KEY_VALIDATION_REQUESTS>,

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/private_kernel_tail.nr

@@ -3,8 +3,12 @@ use crate::components::{
     tail_output_validator::TailOutputValidator
 };
 use dep::types::{
-    abis::{private_kernel_data::PrivateKernelData, kernel_circuit_public_inputs::KernelCircuitPublicInputs},
-    constants::{PRIVATE_KERNEL_INIT_INDEX, PRIVATE_KERNEL_INNER_INDEX, PRIVATE_KERNEL_RESET_INDEX}
+    abis::{
+    private_kernel_data::{PrivateKernelData, PrivateKernelDataWithoutPublicInputs},
+    kernel_circuit_public_inputs::KernelCircuitPublicInputs
+},
+    constants::{PRIVATE_KERNEL_INIT_INDEX, PRIVATE_KERNEL_INNER_INDEX, PRIVATE_KERNEL_RESET_INDEX},
+    PrivateKernelCircuitPublicInputs
 };
 
 global ALLOWED_PREVIOUS_CIRCUITS = [
@@ -18,6 +22,13 @@ pub struct PrivateKernelTailCircuitPrivateInputs {
 }
 
 impl PrivateKernelTailCircuitPrivateInputs {
+    pub fn new(
+        previous_kernel: PrivateKernelDataWithoutPublicInputs,
+        previous_kernel_public_inputs: PrivateKernelCircuitPublicInputs
+    ) -> Self {
+        Self { previous_kernel: previous_kernel.to_private_kernel_data(previous_kernel_public_inputs) }
+    }
+
     unconstrained fn generate_output(self) -> KernelCircuitPublicInputs {
         TailOutputComposer::new(self.previous_kernel.public_inputs).finish()
     }

noir-projects/noir-protocol-circuits/crates/private-kernel-lib/src/private_kernel_tail_to_public.nr

@@ -4,8 +4,12 @@ use crate::components::{
     tail_to_public_output_validator::TailToPublicOutputValidator
 };
 use dep::types::{
-    abis::{private_kernel_data::PrivateKernelData, kernel_circuit_public_inputs::PublicKernelCircuitPublicInputs},
-    constants::{PRIVATE_KERNEL_INIT_INDEX, PRIVATE_KERNEL_INNER_INDEX, PRIVATE_KERNEL_RESET_INDEX}
+    abis::{
+    private_kernel_data::{PrivateKernelData, PrivateKernelDataWithoutPublicInputs},
+    kernel_circuit_public_inputs::PublicKernelCircuitPublicInputs
+},
+    constants::{PRIVATE_KERNEL_INIT_INDEX, PRIVATE_KERNEL_INNER_INDEX, PRIVATE_KERNEL_RESET_INDEX},
+    PrivateKernelCircuitPublicInputs
 };
 
 global ALLOWED_PREVIOUS_CIRCUITS = [
@@ -19,6 +23,13 @@ pub struct PrivateKernelTailToPublicCircuitPrivateInputs {
 }
 
 impl PrivateKernelTailToPublicCircuitPrivateInputs {
+    pub fn new(
+        previous_kernel: PrivateKernelDataWithoutPublicInputs,
+        previous_kernel_public_inputs: PrivateKernelCircuitPublicInputs
+    ) -> Self {
+        Self { previous_kernel: previous_kernel.to_private_kernel_data(previous_kernel_public_inputs) }
+    }
+
     unconstrained fn generate_output(self) -> PublicKernelCircuitPublicInputs {
         TailToPublicOutputComposer::new(self.previous_kernel.public_inputs).finish()
     }

noir-projects/noir-protocol-circuits/crates/private-kernel-reset-simulated/src/main.nr

@@ -1,26 +1,33 @@
-use dep::private_kernel_lib::PrivateKernelResetCircuitPrivateInputs;
+use dep::private_kernel_lib::private_kernel_reset::{PrivateKernelResetHints, PrivateKernelResetCircuitPrivateInputs};
 use dep::types::{
     PrivateKernelCircuitPublicInputs,
     constants::{
     MAX_ENCRYPTED_LOGS_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_TX, MAX_NOTE_HASHES_PER_TX,
     MAX_NULLIFIER_READ_REQUESTS_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_KEY_VALIDATION_REQUESTS_PER_TX
 }
 };
+use types::abis::private_kernel_data::PrivateKernelDataWithoutPublicInputs;
 
-global NOTE_HASH_PENDING_AMOUNT = MAX_NOTE_HASH_READ_REQUESTS_PER_TX; // 128
+global NOTE_HASH_PENDING_AMOUNT = MAX_NOTE_HASH_READ_REQUESTS_PER_TX; // 64
 global NOTE_HASH_SETTLED_AMOUNT = MAX_NOTE_HASH_READ_REQUESTS_PER_TX;
-global NULLIFIER_PENDING_AMOUNT = MAX_NULLIFIER_READ_REQUESTS_PER_TX; // 128
+global NULLIFIER_PENDING_AMOUNT = MAX_NULLIFIER_READ_REQUESTS_PER_TX; // 64
 global NULLIFIER_SETTLED_AMOUNT = MAX_NULLIFIER_READ_REQUESTS_PER_TX;
 global NULLIFIER_KEYS = MAX_KEY_VALIDATION_REQUESTS_PER_TX; // 64
 global TRANSIENT_DATA_AMOUNT = MAX_NULLIFIERS_PER_TX; // 64
 global NOTE_HASH_SILOING_AMOUNT = MAX_NOTE_HASHES_PER_TX; // 64
 global NULLIFIER_SILOING_AMOUNT = MAX_NULLIFIERS_PER_TX; // 64
 global ENCRYPTED_LOG_SILOING_AMOUNT = MAX_ENCRYPTED_LOGS_PER_TX; // 8
 
-unconstrained fn main(input: PrivateKernelResetCircuitPrivateInputs<NOTE_HASH_PENDING_AMOUNT, NOTE_HASH_SETTLED_AMOUNT, NULLIFIER_PENDING_AMOUNT, NULLIFIER_SETTLED_AMOUNT, NULLIFIER_KEYS, TRANSIENT_DATA_AMOUNT>) -> pub PrivateKernelCircuitPublicInputs {
-    input.execute(
+unconstrained fn main(
+    previous_kernel: PrivateKernelDataWithoutPublicInputs,
+    previous_kernel_public_inputs: PrivateKernelCircuitPublicInputs,
+    hints: PrivateKernelResetHints<NOTE_HASH_PENDING_AMOUNT, NOTE_HASH_SETTLED_AMOUNT, NULLIFIER_PENDING_AMOUNT, NULLIFIER_SETTLED_AMOUNT, NULLIFIER_KEYS, TRANSIENT_DATA_AMOUNT>
+) -> pub PrivateKernelCircuitPublicInputs {
+    let private_inputs = PrivateKernelResetCircuitPrivateInputs::new(previous_kernel, previous_kernel_public_inputs, hints);
+    private_inputs.execute(
         NOTE_HASH_SILOING_AMOUNT,
         NULLIFIER_SILOING_AMOUNT,
         ENCRYPTED_LOG_SILOING_AMOUNT
     )
 }
+

noir-projects/noir-protocol-circuits/crates/private-kernel-reset/src/main.nr

@@ -1,11 +1,12 @@
-use dep::private_kernel_lib::PrivateKernelResetCircuitPrivateInputs;
+use dep::private_kernel_lib::private_kernel_reset::{PrivateKernelResetHints, PrivateKernelResetCircuitPrivateInputs};
 use dep::types::{
     PrivateKernelCircuitPublicInputs,
     constants::{
     MAX_ENCRYPTED_LOGS_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_TX, MAX_NOTE_HASHES_PER_TX,
     MAX_NULLIFIER_READ_REQUESTS_PER_TX, MAX_NULLIFIERS_PER_TX, MAX_KEY_VALIDATION_REQUESTS_PER_TX
 }
 };
+use types::abis::private_kernel_data::PrivateKernelDataWithoutPublicInputs;
 
 global NOTE_HASH_PENDING_AMOUNT = MAX_NOTE_HASH_READ_REQUESTS_PER_TX; // 64
 global NOTE_HASH_SETTLED_AMOUNT = MAX_NOTE_HASH_READ_REQUESTS_PER_TX;
@@ -17,11 +18,16 @@ global NOTE_HASH_SILOING_AMOUNT = MAX_NOTE_HASHES_PER_TX; // 64
 global NULLIFIER_SILOING_AMOUNT = MAX_NULLIFIERS_PER_TX; // 64
 global ENCRYPTED_LOG_SILOING_AMOUNT = MAX_ENCRYPTED_LOGS_PER_TX; // 8
 
-#[recursive]
-fn main(input: PrivateKernelResetCircuitPrivateInputs<NOTE_HASH_PENDING_AMOUNT, NOTE_HASH_SETTLED_AMOUNT, NULLIFIER_PENDING_AMOUNT, NULLIFIER_SETTLED_AMOUNT, NULLIFIER_KEYS, TRANSIENT_DATA_AMOUNT>) -> pub PrivateKernelCircuitPublicInputs {
-    input.execute(
+fn main(
+    previous_kernel: PrivateKernelDataWithoutPublicInputs,
+    previous_kernel_public_inputs: call_data(0) PrivateKernelCircuitPublicInputs,
+    hints: PrivateKernelResetHints<NOTE_HASH_PENDING_AMOUNT, NOTE_HASH_SETTLED_AMOUNT, NULLIFIER_PENDING_AMOUNT, NULLIFIER_SETTLED_AMOUNT, NULLIFIER_KEYS, TRANSIENT_DATA_AMOUNT>
+) -> return_data PrivateKernelCircuitPublicInputs {
+    let private_inputs = PrivateKernelResetCircuitPrivateInputs::new(previous_kernel, previous_kernel_public_inputs, hints);
+    private_inputs.execute(
         NOTE_HASH_SILOING_AMOUNT,
         NULLIFIER_SILOING_AMOUNT,
         ENCRYPTED_LOG_SILOING_AMOUNT
     )
 }
+

noir-projects/noir-protocol-circuits/crates/private-kernel-tail-simulated/src/main.nr

@@ -1,6 +1,12 @@
 use dep::private_kernel_lib::PrivateKernelTailCircuitPrivateInputs;
 use dep::types::KernelCircuitPublicInputs;
+use types::abis::private_kernel_data::PrivateKernelDataWithoutPublicInputs;
+use types::abis::kernel_circuit_public_inputs::PrivateKernelCircuitPublicInputs;
 
-unconstrained fn main(input: PrivateKernelTailCircuitPrivateInputs) -> pub KernelCircuitPublicInputs {
-    input.execute()
+unconstrained fn main(
+    previous_kernel: PrivateKernelDataWithoutPublicInputs,
+    previous_kernel_public_inputs: PrivateKernelCircuitPublicInputs
+) -> pub KernelCircuitPublicInputs {
+    let private_inputs = PrivateKernelTailCircuitPrivateInputs::new(previous_kernel, previous_kernel_public_inputs);
+    private_inputs.execute()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-tail-to-public-simulated/src/main.nr

@@ -1,6 +1,12 @@
 use dep::private_kernel_lib::PrivateKernelTailToPublicCircuitPrivateInputs;
 use dep::types::PublicKernelCircuitPublicInputs;
+use types::abis::private_kernel_data::PrivateKernelDataWithoutPublicInputs;
+use types::abis::kernel_circuit_public_inputs::PrivateKernelCircuitPublicInputs;
 
-unconstrained fn main(input: PrivateKernelTailToPublicCircuitPrivateInputs) -> pub PublicKernelCircuitPublicInputs {
-    input.execute()
+unconstrained fn main(
+    previous_kernel: PrivateKernelDataWithoutPublicInputs,
+    previous_kernel_public_inputs: PrivateKernelCircuitPublicInputs
+) -> pub PublicKernelCircuitPublicInputs {
+    let private_inputs = PrivateKernelTailToPublicCircuitPrivateInputs::new(previous_kernel, previous_kernel_public_inputs);
+    private_inputs.execute()
 }

noir-projects/noir-protocol-circuits/crates/private-kernel-tail-to-public/src/main.nr

@@ -1,7 +1,12 @@
 use dep::private_kernel_lib::PrivateKernelTailToPublicCircuitPrivateInputs;
 use dep::types::PublicKernelCircuitPublicInputs;
+use types::abis::private_kernel_data::PrivateKernelDataWithoutPublicInputs;
+use types::abis::kernel_circuit_public_inputs::PrivateKernelCircuitPublicInputs;
 
-#[recursive]
-fn main(input: PrivateKernelTailToPublicCircuitPrivateInputs) -> pub PublicKernelCircuitPublicInputs {
-    input.execute()
+fn main(
+    previous_kernel: PrivateKernelDataWithoutPublicInputs,
+    previous_kernel_public_inputs: call_data(0) PrivateKernelCircuitPublicInputs
+) -> pub PublicKernelCircuitPublicInputs {
+    let private_inputs = PrivateKernelTailToPublicCircuitPrivateInputs::new(previous_kernel, previous_kernel_public_inputs);
+    private_inputs.execute()
 }