AztecProtocol
diff --git a/‎barretenberg/cpp/scripts/test_chonk_standalone_vks_havent_changed.sh‎
Lines changed: 1 addition & 1 deletion b/‎barretenberg/cpp/scripts/test_chonk_standalone_vks_havent_changed.sh‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎barretenberg/cpp/src/barretenberg/chonk/README.md‎
Lines changed: 17 additions & 16 deletions b/‎barretenberg/cpp/src/barretenberg/chonk/README.md‎
Lines changed: 17 additions & 16 deletions
diff --git a/‎barretenberg/cpp/src/barretenberg/chonk/batched_honk_translator/batched_honk_translator.test.cpp‎
Lines changed: 12 additions & 6 deletions b/‎barretenberg/cpp/src/barretenberg/chonk/batched_honk_translator/batched_honk_translator.test.cpp‎
Lines changed: 12 additions & 6 deletions
diff --git a/‎barretenberg/cpp/src/barretenberg/chonk/batched_honk_translator/batched_honk_translator_verifier.cpp‎
Lines changed: 1 addition & 1 deletion b/‎barretenberg/cpp/src/barretenberg/chonk/batched_honk_translator/batched_honk_translator_verifier.cpp‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎barretenberg/cpp/src/barretenberg/chonk/batched_honk_translator/batched_honk_translator_verifier.hpp‎
Lines changed: 2 additions & 2 deletions b/‎barretenberg/cpp/src/barretenberg/chonk/batched_honk_translator/batched_honk_translator_verifier.hpp‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎barretenberg/cpp/src/barretenberg/chonk/chonk.cpp‎
Lines changed: 14 additions & 14 deletions b/‎barretenberg/cpp/src/barretenberg/chonk/chonk.cpp‎
Lines changed: 14 additions & 14 deletions
diff --git a/‎barretenberg/cpp/src/barretenberg/chonk/chonk_verifier.cpp‎
Lines changed: 5 additions & 5 deletions b/‎barretenberg/cpp/src/barretenberg/chonk/chonk_verifier.cpp‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎barretenberg/cpp/src/barretenberg/chonk/mock_circuit_producer.hpp‎
Lines changed: 6 additions & 6 deletions b/‎barretenberg/cpp/src/barretenberg/chonk/mock_circuit_producer.hpp‎
Lines changed: 6 additions & 6 deletions
diff --git a/‎barretenberg/cpp/src/barretenberg/circuit_checker/ultra_circuit_checker.cpp‎
Lines changed: 3 additions & 1 deletion b/‎barretenberg/cpp/src/barretenberg/circuit_checker/ultra_circuit_checker.cpp‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎barretenberg/cpp/src/barretenberg/constants.hpp‎
Lines changed: 3 additions & 3 deletions b/‎barretenberg/cpp/src/barretenberg/constants.hpp‎
Lines changed: 3 additions & 3 deletions
@@ -21,7 +21,7 @@ script_path="$root/barretenberg/cpp/scripts/test_chonk_standalone_vks_havent_cha
 # - Generate a hash for versioning: sha256sum bb-chonk-inputs.tar.gz
 # - Upload the compressed results: aws s3 cp bb-chonk-inputs.tar.gz s3://aztec-ci-artifacts/protocol/bb-chonk-inputs-[hash(0:8)].tar.gz
 # Note: In case of the "Test suite failed to run ... Unexpected token 'with' " error, need to run: docker pull aztecprotocol/build:3.0
-pinned_short_hash="c09aeb0c"
+pinned_short_hash="341842bf"
 pinned_chonk_inputs_url="https://aztec-ci-artifacts.s3.us-east-2.amazonaws.com/protocol/bb-chonk-inputs-${pinned_short_hash}.tar.gz"
 
 function update_pinned_hash_in_script {
 
@@ -111,8 +111,8 @@ MegaZK Oink → Merge → ECCVM → Translator Oink + Joint Sumcheck + Joint PCS
 
 Concretely (`ChonkVerifier::reduce_to_ipa_claim` / `ChonkVerifier::verify`):
 
-1. **MegaZK Oink verification**: `BatchedHonkTranslatorVerifier::verify_mega_zk_oink` processes the hiding kernel's pre-sumcheck proof and extracts `HidingKernelIO` (pairing points, calldata commitment, ECC op wire commitments)
-2. **Databus consistency check**: Asserts the hiding kernel's calldata commitment equals its `kernel_return_data` commitment
+1. **MegaZK Oink verification**: `BatchedHonkTranslatorVerifier::verify_mega_zk_oink` processes the hiding kernel's pre-sumcheck proof and extracts `HidingKernelIO` (pairing points, kernel return data commitment, ECC op wire commitments)
+2. **Databus consistency check**: Asserts the hiding kernel's kernel calldata commitment equals the `kernel_return_data` commitment contained it its public inputs
 3. **Merge verification**: Verifies the hiding kernel's APPEND-mode merge proof using the ECC op wire commitments from step 1 and `ecc_op_tables` from `HidingKernelIO`
 4. **ECCVM verification**: Reduces to an IPA opening claim; extracts translator input parameters (`v`, `x`, `accumulated_result`)
 5. **Joint verification**: `BatchedHonkTranslatorVerifier::verify` processes the translator Oink, runs the 17-round joint sumcheck, and performs the joint Shplemini/KZG PCS reduction
@@ -269,13 +269,13 @@ The databus solves this by using **commitments** instead of raw data. Rather tha
 
 | Column | Purpose |
 |--------|---------|
-| `calldata` | Input from previous kernel's return data ($C_i$) |
-| `secondary_calldata` | Input from previous app's return data ($C'_i$) |
+| `kernel_calldata` | Input from previous kernel's return data ($C_i$) |
+| `app_calldata[0..2]` | Inputs from up to three apps' return data ($C'_{i,j}$) |
 | `return_data` | Output to be consumed by next circuit ($R_i$) |
 
-App circuits only produce `return_data` (no calldata). Kernel circuits receive both:
-- `calldata` from the previous kernel's return data
-- `secondary_calldata` from the corresponding app's return data
+App circuits only produce `return_data` (no calldata). Kernel circuits receive:
+- `kernel_calldata` from the previous kernel's return data
+- `app_calldata[0..2]` from the corresponding apps' return data
 
 #### Lookup Relations
 
@@ -301,7 +301,7 @@ $$\sum_{i=0}^{n-1} a_i \cdot I_i \cdot (w_{1,i} + w_{2,i}\beta + \gamma) - q_{bu
 
 Inverse correctness is enforced by two separate gating subrelations: $(I \cdot L \cdot T - 1) \cdot \text{is\_read} = 0$ on read rows, and $(I \cdot L \cdot T - 1) \cdot \text{count} = 0$ on write rows. At inactive rows (where both gates are zero), $I$ is unconstrained but the lookup identity contribution is also zero, so the prover gets no free degrees of freedom.
 
-**Multiple columns**: Each bus column (calldata, secondary_calldata, return_data) has separate subrelations, distinguished by column-specific selectors $q_j$.
+**Multiple columns**: Each bus column (kernel calldata, three app calldata columns, return data) has separate subrelations, distinguished by column-specific selectors $q_j$.
 
 #### Population
 
@@ -315,14 +315,15 @@ The databus columns are populated from ACIR constraints generated by the Noir co
 ```
 App₀ ──return_data [R'₀]──┐
                           ↓
-                    Kernel₀ ←─calldata─── (empty for first kernel)
+                    Kernel₀ ←─kernel_calldata─── (empty for first kernel)
+                            ←─app_calldata[0] [C'₀,0]─── App₀.return_data
                       │
                 return_data [R₀]
                       ↓
 App₁ ──return_data [R'₁]──┐
                           ↓
-                    Kernel₁ ←─calldata [C₁]─── Kernel₀.return_data
-                            ←─secondary_calldata [C'₁]─── App₁.return_data
+                    Kernel₁ ←─kernel_calldata [C₁]─── Kernel₀.return_data
+                            ←─app_calldata[0] [C'₁,0]─── App₁.return_data
                       │
                 return_data [R₁]
                       ↓
@@ -685,8 +686,8 @@ Kernel circuits output a structured public input block that carries cross-circui
 struct KernelIO {
     PairingInputs pairing_inputs;      // Accumulated {P0, P1} for deferred pairing check
     G1 kernel_return_data;             // Commitment to this kernel's return data
-    G1 app_return_data;                // Commitment to the app's return data
-    TableCommitments ecc_op_tables;    // [M_1]...[M_4] merged op queue tables from Merge
+    std::array<G1, MAX_APPS_PER_KERNEL> app_return_data; // App return data commitments
+    FF ecc_op_hash;                    // Running hash over ECC op column commitments
     FF output_hn_accum_hash;           // Hash of the HyperNova accumulator state
 };
 
@@ -722,10 +723,10 @@ The [Databus](#databus) section explains how circuits pass data via commitment e
 
 ```cpp
 // Kernel's calldata must match previous kernel's return_data
-kernel_input.kernel_return_data.incomplete_assert_equal(witness_commitments.calldata);
+kernel_input.kernel_return_data.incomplete_assert_equal(witness_commitments.kernel_calldata);
 
-// Kernel's secondary_calldata must match previous app's return_data
-kernel_input.app_return_data.incomplete_assert_equal(witness_commitments.secondary_calldata);
+// Each app calldata column must match the corresponding app's return_data
+kernel_input.app_return_data[idx].incomplete_assert_equal(*app_calldata_commitments[idx]);
 ```
 
 The `incomplete_assert_equal` (for non-native G1 points) adds in-circuit constraints that the commitments are equal. Combined with the HyperNova binding of public inputs to proofs, tampering with databus content invalidates the proof.
 
@@ -142,10 +142,14 @@ class BatchedHonkTranslatorTests : public ::testing::Test {
         // DataBus entities:
         for (const auto& label : { "KERNEL_CALLDATA",
                                    "KERNEL_CALLDATA_READ_COUNTS",
-                                   "APP_CALLDATA",
-                                   "APP_CALLDATA_READ_COUNTS",
-                                   "RETURNDATA",
-                                   "RETURNDATA_READ_COUNTS" }) {
+                                   "FIRST_APP_CALLDATA",
+                                   "FIRST_APP_CALLDATA_READ_COUNTS",
+                                   "SECOND_APP_CALLDATA",
+                                   "SECOND_APP_CALLDATA_READ_COUNTS",
+                                   "THIRD_APP_CALLDATA",
+                                   "THIRD_APP_CALLDATA_READ_COUNTS",
+                                   "RETURN_DATA",
+                                   "RETURN_DATA_READ_COUNTS" }) {
             m.add_entry(round, label, G);
         }
         m.add_challenge(round, "eta");
@@ -161,8 +165,10 @@ class BatchedHonkTranslatorTests : public ::testing::Test {
         // ── Round 2: MegaZK logderiv inverses + Z_PERM + translator Oink ─────────
         m.add_entry(round, "LOOKUP_INVERSES", G);
         m.add_entry(round, "KERNEL_CALLDATA_INVERSES", G);
-        m.add_entry(round, "APP_CALLDATA_INVERSES", G);
-        m.add_entry(round, "RETURNDATA_INVERSES", G);
+        m.add_entry(round, "FIRST_APP_CALLDATA_INVERSES", G);
+        m.add_entry(round, "SECOND_APP_CALLDATA_INVERSES", G);
+        m.add_entry(round, "THIRD_APP_CALLDATA_INVERSES", G);
+        m.add_entry(round, "RETURN_DATA_INVERSES", G);
         m.add_entry(round, "Z_PERM", G);
         // Translator Oink: vk_hash, masking commitment, 10 wire commitments
         m.add_entry(round, "vk_hash", Fr);
 
@@ -55,7 +55,7 @@ typename BatchedHonkTranslatorVerifier_<Curve>::OinkResult BatchedHonkTranslator
 
     return OinkResult{
         .public_inputs = mega_zk_verifier_instance->public_inputs,
-        .calldata_commitment = mega_zk_verifier_instance->witness_commitments.calldata,
+        .kernel_calldata_commitment = mega_zk_verifier_instance->witness_commitments.kernel_calldata,
         .ecc_op_wires = mega_zk_verifier_instance->witness_commitments.get_ecc_op_wires().get_copy(),
     };
 }
 
@@ -99,7 +99,7 @@ template <typename Curve> class BatchedHonkTranslatorVerifier_ {
      */
     struct OinkResult {
         std::vector<FF> public_inputs;
-        Commitment calldata_commitment;
+        Commitment kernel_calldata_commitment;
         std::array<Commitment, MegaZKFlavorT::NUM_WIRES> ecc_op_wires;
     };
 
@@ -114,7 +114,7 @@ template <typename Curve> class BatchedHonkTranslatorVerifier_ {
     /**
      * @brief Phase 1: Verify the MegaZK Oink phase on the shared transcript.
      * @details Loads mega_zk_proof into the transcript, runs OinkVerifier, stores verifier instance.
-     * @return OinkResult with public inputs, calldata commitment, and ECC op wires.
+     * @return OinkResult with public inputs, kernel calldata commitment, and ECC op wires.
      */
     OinkResult verify_mega_zk_oink(const Proof& mega_zk_proof);
 
 
@@ -19,6 +19,7 @@
 #include "barretenberg/translator_vm/translator_proving_key.hpp"
 #include "barretenberg/ultra_honk/oink_prover.hpp"
 #include "barretenberg/ultra_honk/oink_verifier.hpp"
+#include <array>
 
 namespace bb {
 
@@ -164,25 +165,24 @@ Chonk::PublicInputsResult Chonk::process_public_inputs_and_consistency_checks(
 
         // Kernel return data
         bool kernel_return_data_match =
-            kernel_input.kernel_return_data.get_value() == witness_commitments.calldata.get_value();
+            kernel_input.kernel_return_data.get_value() == witness_commitments.kernel_calldata.get_value();
         BB_ASSERT_DEBUG(kernel_return_data_match,
-                        "kernel_return_data mismatch: proof contains " << kernel_input.kernel_return_data.get_value()
-                                                                       << " but calldata commitment is "
-                                                                       << witness_commitments.calldata.get_value());
-        kernel_input.kernel_return_data.incomplete_assert_equal(witness_commitments.calldata);
-
-        // App return data. Mega currently exposes a single app calldata witness commitment
-        // (`secondary_calldata`), so MAX_APPS_PER_KERNEL remains 1.
-        static_assert(MAX_APPS_PER_KERNEL == 1, "Multiple app calldata witness columns are not wired yet");
+                        "kernel_return_data mismatch: proof contains "
+                            << kernel_input.kernel_return_data.get_value() << " but kernel_calldata commitment is "
+                            << witness_commitments.kernel_calldata.get_value());
+        kernel_input.kernel_return_data.incomplete_assert_equal(witness_commitments.kernel_calldata);
+
+        const std::array app_calldata_commitments{ &witness_commitments.first_app_calldata,
+                                                   &witness_commitments.second_app_calldata,
+                                                   &witness_commitments.third_app_calldata };
         for (size_t idx = 0; idx < MAX_APPS_PER_KERNEL; ++idx) {
             bool app_return_data_match =
-                kernel_input.app_return_data[idx].get_value() == witness_commitments.secondary_calldata.get_value();
+                kernel_input.app_return_data[idx].get_value() == app_calldata_commitments[idx]->get_value();
             BB_ASSERT_DEBUG(app_return_data_match,
                             "app_return_data mismatch: proof contains "
-                                << kernel_input.app_return_data[idx].get_value()
-                                << " but secondary_calldata commitment is "
-                                << witness_commitments.secondary_calldata.get_value());
-            kernel_input.app_return_data[idx].incomplete_assert_equal(witness_commitments.secondary_calldata);
+                                << kernel_input.app_return_data[idx].get_value() << " but app calldata commitment "
+                                << idx << " is " << app_calldata_commitments[idx]->get_value());
+            kernel_input.app_return_data[idx].incomplete_assert_equal(*app_calldata_commitments[idx]);
         }
 
         // ============= Perform accumulator hash consistency check =========================
 
@@ -42,9 +42,9 @@ template <> ChonkVerifier<false>::IPAReductionResult ChonkVerifier<false>::reduc
     }
 
     // Step 2: Databus consistency check
-    const Commitment calldata_commitment = oink_result.calldata_commitment;
+    const Commitment kernel_calldata_commitment = oink_result.kernel_calldata_commitment;
     const Commitment return_data_commitment = kernel_io.kernel_return_data;
-    bool databus_consistency_verified = (calldata_commitment == return_data_commitment);
+    bool databus_consistency_verified = (kernel_calldata_commitment == return_data_commitment);
     vinfo("ChonkVerifier: databus consistency verified: ", databus_consistency_verified);
     if (!databus_consistency_verified) {
         info("ChonkVerifier: verification failed at databus consistency check");
@@ -146,11 +146,11 @@ template <> ChonkVerifier<true>::Output ChonkVerifier<true>::verify(const Proof&
     kernel_io.reconstruct_from_public(oink_result.public_inputs);
 
     // Step 2: Databus consistency check (in-circuit)
-    const Commitment calldata_commitment = oink_result.calldata_commitment;
-    if (kernel_io.kernel_return_data.get_value() != calldata_commitment.get_value()) {
+    const Commitment kernel_calldata_commitment = oink_result.kernel_calldata_commitment;
+    if (kernel_io.kernel_return_data.get_value() != kernel_calldata_commitment.get_value()) {
         info("ChonkRecursiveVerifier: Databus Consistency check failure");
     }
-    kernel_io.kernel_return_data.incomplete_assert_equal(calldata_commitment);
+    kernel_io.kernel_return_data.incomplete_assert_equal(kernel_calldata_commitment);
 
     // Step 3: Merge verification
     MergeCommitments merge_commitments{ .t_commitments = oink_result.ecc_op_wires,
 
@@ -13,8 +13,8 @@ namespace {
 /**
  * @brief Test utility for coordinating passing of databus data between mocked private function execution circuits
  * @details Facilitates testing of the databus consistency checks that establish the correct passing of databus data
- * between circuits. Generates arbitrary return data for each app/kernel. Sets the kernel calldata and
- * secondary_calldata based respectively on the previous kernel return data and app return data.
+ * between circuits. Generates arbitrary return data for each app/kernel. Sets the kernel calldata and app calldata
+ * columns based respectively on the previous kernel return data and each app return data.
  */
 class MockDatabusProducer {
   private:
@@ -57,16 +57,16 @@ class MockDatabusProducer {
     };
 
     /**
-     * @brief Populate the calldata and secondary calldata in the kernel from respectively the previous kernel and app
-     * return data. Update and populate the return data for the present kernel.
+     * @brief Populate the kernel calldata and app calldata columns from respectively the previous kernel and app return
+     * data. Update and populate the return data for the present kernel.
      */
     void populate_kernel_databus(ClientCircuit& circuit)
     {
-        // Populate calldata from previous kernel return data (if it exists)
+        // Populate kernel calldata from previous kernel return data (if it exists)
         for (auto& val : kernel_return_data) {
             circuit.add_public_calldata(BusId::KERNEL_CALLDATA, circuit.add_variable(val));
         }
-        // Populate secondary_calldata from app return data (if it exists), then clear the app return data
+        // Populate app calldata from app return data (if it exists), then clear the app return data
         for (size_t idx = 0; idx < app_return_data.size(); ++idx) {
             for (auto& val : app_return_data[idx]) {
                 circuit.add_public_calldata(static_cast<BusId>(idx + 1), circuit.add_variable(val));
 
@@ -242,7 +242,9 @@ template <typename Builder> bool UltraCircuitChecker::check_databus_read(auto& v
         auto value = values.w_l;
 
         // Map bus_idx → wire-linear selector on the values struct (mirrors BusData<i>::selector in the relation).
-        const std::array<const FF*, NUM_BUS_COLUMNS> bus_selectors{ &values.q_l, &values.q_r, &values.q_o };
+        const std::array<const FF*, NUM_BUS_COLUMNS> bus_selectors{
+            &values.q_l, &values.q_r, &values.q_o, &values.q_4, &values.q_m
+        };
 
         // Locate the bus column being read (exactly one selector should be active on a busread row) and look up the
         // expected value from the builder's bus vector.
 
@@ -62,10 +62,10 @@ static constexpr uint32_t NUM_TRANSLATION_EVALUATIONS = 5;
 // The number of leading zero rows in the execution trace. Used to enable shifted polynomials.
 static constexpr size_t NUM_ZERO_ROWS = 1;
 
-// The maximum number of app circuits a single kernel can recursively verify
-static constexpr uint8_t MAX_APPS_PER_KERNEL = 1;
+// The maximum number of app circuits a single kernel can recursively verify in one accumulation group.
+static constexpr uint8_t MAX_APPS_PER_KERNEL = 3;
 
-static constexpr size_t CHONK_MAX_NUM_CIRCUITS = 56 + /*trailing kernels*/ 3;
+static constexpr size_t CHONK_MAX_NUM_CIRCUITS = 52 + /*trailing kernels*/ 3;
 
 static constexpr size_t BATCH_MERGE_PROOF_SIZE =
     /*num subtables*/ 1 +
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ typename BatchedHonkTranslatorVerifier_<Curve>::OinkResult BatchedHonkTranslator`
`55`	`55`
`56`	`56`	`return OinkResult{`
`57`	`57`	`.public_inputs = mega_zk_verifier_instance->public_inputs,`
`58`		`- .calldata_commitment = mega_zk_verifier_instance->witness_commitments.calldata,`
	`58`	`+ .kernel_calldata_commitment = mega_zk_verifier_instance->witness_commitments.kernel_calldata,`
`59`	`59`	`.ecc_op_wires = mega_zk_verifier_instance->witness_commitments.get_ecc_op_wires().get_copy(),`
`60`	`60`	`};`
`61`	`61`	`}`