diff --git a/barretenberg/cpp/src/barretenberg/bb/main.cpp b/barretenberg/cpp/src/barretenberg/bb/main.cpp
index 7648a9dbdbe..2d9d5d9e382 100644
--- a/barretenberg/cpp/src/barretenberg/bb/main.cpp
+++ b/barretenberg/cpp/src/barretenberg/bb/main.cpp
@@ -590,7 +590,7 @@ void prove_tube(const std::string& output_path)
     }
     ClientIVC verifier{ builder, input };
 
-    ClientIVC::Output client_ivc_rec_verifier_output = verifier.verify(proof);
+    verifier.verify(proof);
 
     PairingPointAccumulatorIndices current_aggregation_object =
         stdlib::recursion::init_default_agg_obj_indices<Builder>(*builder);
@@ -599,10 +599,6 @@ void prove_tube(const std::string& output_path)
     // This is currently just setting the aggregation object to the default one.
     builder->add_pairing_point_accumulator(current_aggregation_object);
 
-    // The tube only calls an IPA recursive verifier once, so we can just add this IPA claim and proof
-    builder->add_ipa_claim(client_ivc_rec_verifier_output.opening_claim.get_witness_indices());
-    builder->ipa_proof = convert_stdlib_proof_to_native(client_ivc_rec_verifier_output.ipa_transcript->proof_data);
-
     using Prover = UltraProver_<UltraFlavor>;
     using Verifier = UltraVerifier_<UltraFlavor>;
     Prover tube_prover{ *builder };
@@ -626,9 +622,8 @@ void prove_tube(const std::string& output_path)
     write_file(tubeAsFieldsVkPath, { data.begin(), data.end() });
 
     info("Native verification of the tube_proof");
-    auto ipa_verification_key = std::make_shared<VerifierCommitmentKey<curve::Grumpkin>>(1 << CONST_ECCVM_LOG_N);
-    Verifier tube_verifier(tube_verification_key, ipa_verification_key);
-    bool verified = tube_verifier.verify_proof(tube_proof, builder->ipa_proof);
+    Verifier tube_verifier(tube_verification_key);
+    bool verified = tube_verifier.verify_proof(tube_proof);
     info("Tube proof verification: ", verified);
 }
 
@@ -1137,22 +1132,14 @@ template <IsUltraFlavor Flavor> bool verify_honk(const std::string& proof_path,
 {
     using VerificationKey = Flavor::VerificationKey;
     using Verifier = UltraVerifier_<Flavor>;
+    using VerifierCommitmentKey = bb::VerifierCommitmentKey<curve::BN254>;
 
     auto g2_data = get_bn254_g2_data(CRS_PATH);
     srs::init_crs_factory({}, g2_data);
     auto proof = from_buffer<std::vector<bb::fr>>(read_file(proof_path));
     auto vk = std::make_shared<VerificationKey>(from_buffer<VerificationKey>(read_file(vk_path)));
-    vk->pcs_verification_key = std::make_shared<VerifierCommitmentKey<curve::BN254>>();
-
-    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1154): Remove this and pass in the IPA proof to the
-    // verifier.
-    std::shared_ptr<VerifierCommitmentKey<curve::Grumpkin>> ipa_verification_key = nullptr;
-    if constexpr (HasIPAAccumulatorFlavor<Flavor>) {
-        init_grumpkin_crs(1 << 16);
-        vk->contains_ipa_claim = false;
-        ipa_verification_key = std::make_shared<VerifierCommitmentKey<curve::Grumpkin>>(1 << CONST_ECCVM_LOG_N);
-    }
-    Verifier verifier{ vk, ipa_verification_key };
+    vk->pcs_verification_key = std::make_shared<VerifierCommitmentKey>();
+    Verifier verifier{ vk };
 
     bool verified = verifier.verify_proof(proof);
 
diff --git a/barretenberg/cpp/src/barretenberg/client_ivc/client_ivc.cpp b/barretenberg/cpp/src/barretenberg/client_ivc/client_ivc.cpp
index ce873d3cafd..9119e17f6ea 100644
--- a/barretenberg/cpp/src/barretenberg/client_ivc/client_ivc.cpp
+++ b/barretenberg/cpp/src/barretenberg/client_ivc/client_ivc.cpp
@@ -25,7 +25,7 @@ void ClientIVC::instantiate_stdlib_verification_queue(
     size_t key_idx = 0;
     for (auto& [proof, vkey, type] : verification_queue) {
         // Construct stdlib proof directly from the internal native queue data
-        auto stdlib_proof = bb::convert_native_proof_to_stdlib(&circuit, proof);
+        auto stdlib_proof = bb::convert_proof_to_witness(&circuit, proof);
 
         // Use the provided stdlib vkey if present, otherwise construct one from the internal native queue
         auto stdlib_vkey =
@@ -261,7 +261,7 @@ HonkProof ClientIVC::construct_and_prove_hiding_circuit()
     auto stdlib_decider_vk =
         std::make_shared<RecursiveVerificationKey>(&builder, verification_queue[0].honk_verification_key);
 
-    auto stdlib_proof = bb::convert_native_proof_to_stdlib(&builder, fold_proof);
+    auto stdlib_proof = bb::convert_proof_to_witness(&builder, fold_proof);
 
     // Perform recursive folding verification of the last folding proof
     FoldingRecursiveVerifier folding_verifier{ &builder, stdlib_verifier_accumulator, { stdlib_decider_vk } };
diff --git a/barretenberg/cpp/src/barretenberg/commitment_schemes/claim.hpp b/barretenberg/cpp/src/barretenberg/commitment_schemes/claim.hpp
index 27917a072fa..129cb4df521 100644
--- a/barretenberg/cpp/src/barretenberg/commitment_schemes/claim.hpp
+++ b/barretenberg/cpp/src/barretenberg/commitment_schemes/claim.hpp
@@ -1,9 +1,7 @@
 #pragma once
 
 #include "barretenberg/commitment_schemes/commitment_key.hpp"
-#include "barretenberg/plonk_honk_shared/types/aggregation_object_type.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
-#include "barretenberg/stdlib/primitives/curves/grumpkin.hpp"
 
 namespace bb {
 /**
@@ -53,32 +51,6 @@ template <typename Curve> class OpeningClaim {
     // commitment to univariate polynomial p(X)
     Commitment commitment;
 
-    IPAClaimIndices get_witness_indices() const
-        requires(std::is_same_v<Curve, stdlib::grumpkin<UltraCircuitBuilder>>)
-    {
-        return { opening_pair.challenge.binary_basis_limbs[0].element.normalize().witness_index,
-                 opening_pair.challenge.binary_basis_limbs[1].element.normalize().witness_index,
-                 opening_pair.challenge.binary_basis_limbs[2].element.normalize().witness_index,
-                 opening_pair.challenge.binary_basis_limbs[3].element.normalize().witness_index,
-                 // TODO(https://github.com/AztecProtocol/barretenberg/issues/1153): Uncomment this when we turn the
-                 // eval into witnesses.
-                 //  opening_pair.evaluation.binary_basis_limbs[0].element.normalize().witness_index,
-                 //  opening_pair.evaluation.binary_basis_limbs[1].element.normalize().witness_index,
-                 //  opening_pair.evaluation.binary_basis_limbs[2].element.normalize().witness_index,
-                 //  opening_pair.evaluation.binary_basis_limbs[3].element.normalize().witness_index,
-                 commitment.x.normalize().witness_index, // no idea if we need these normalize() calls...
-                 commitment.y.normalize().witness_index };
-    }
-
-    auto get_native_opening_claim() const
-        requires(Curve::is_stdlib_type)
-    {
-        return OpeningClaim<typename Curve::NativeCurve>{
-            { static_cast<typename Curve::NativeCurve::ScalarField>(opening_pair.challenge.get_value()),
-              static_cast<typename Curve::NativeCurve::ScalarField>(opening_pair.evaluation.get_value()) },
-            commitment.get_value()
-        };
-    }
     /**
      * @brief inefficiently check that the claim is correct by recomputing the commitment
      * and evaluating the polynomial in r.
diff --git a/barretenberg/cpp/src/barretenberg/commitment_schemes/ipa/ipa.hpp b/barretenberg/cpp/src/barretenberg/commitment_schemes/ipa/ipa.hpp
index c3e5bae6705..3a0afa05a06 100644
--- a/barretenberg/cpp/src/barretenberg/commitment_schemes/ipa/ipa.hpp
+++ b/barretenberg/cpp/src/barretenberg/commitment_schemes/ipa/ipa.hpp
@@ -749,8 +749,8 @@ template <typename Curve_> class IPA {
     }
 
     /**
-     * @brief Takes two IPA claims and accumulates them into 1 IPA claim. Also computes IPA proof for the claim.
-     * @details We create an IPA accumulator by running the IPA recursive verifier on each claim. Then, we generate challenges, and use these challenges to compute the new accumulator. We also create the accumulated polynomial, and generate the IPA proof for the accumulated claim.
+     * @brief Takes two IPA claims and accumulates them into 1 IPA claim.
+     * @details We create an IPA accumulator by running the IPA recursive verifier on each claim. Then, we generate challenges, and use these challenges to compute the new accumulator. We also create the accumulated polynomial. 
      * More details are described here: https://hackmd.io/IXoLIPhVT_ej8yhZ_Ehvuw?both.
      * 
      * @param verifier_ck 
@@ -758,12 +758,11 @@ template <typename Curve_> class IPA {
      * @param claim_1 
      * @param transcript_2 
      * @param claim_2 
-     * @return std::pair<OpeningClaim<Curve>, HonkProof> 
+     * @return std::pair<OpeningClaim<Curve>, Polynomial<bb::fq>> 
      */
-    static std::pair<OpeningClaim<Curve>, HonkProof> accumulate(const std::shared_ptr<CommitmentKey<curve::Grumpkin>>& ck, auto& transcript_1, OpeningClaim<Curve> claim_1, auto& transcript_2, OpeningClaim<Curve> claim_2)
+    static std::pair<OpeningClaim<Curve>, Polynomial<bb::fq>> accumulate(auto& transcript_1, OpeningClaim<Curve> claim_1, auto& transcript_2, OpeningClaim<Curve> claim_2)
     requires Curve::is_stdlib_type
     {
-        using NativeCurve = curve::Grumpkin;
         using Builder = typename Curve::Builder;
         // Step 1: Run the verifier for each IPA instance
         VerifierAccumulator pair_1 = reduce_verify(claim_1, transcript_1);
@@ -794,23 +793,7 @@ template <typename Curve_> class IPA {
         for (Fr u_inv_i : pair_2.u_challenges_inv) {
             native_u_challenges_inv_2.push_back(bb::fq(u_inv_i.get_value()));
         }
-        
-        // Compute proof for the claim
-        auto prover_transcript = std::make_shared<NativeTranscript>();
-        const OpeningPair<NativeCurve> opening_pair{ bb::fq(output_claim.opening_pair.challenge.get_value()),
-                                                     bb::fq(output_claim.opening_pair.evaluation.get_value()) };
-        Polynomial<fq> challenge_poly = create_challenge_poly(uint32_t(pair_1.log_poly_length.get_value()), native_u_challenges_inv_1, uint32_t(pair_2.log_poly_length.get_value()), native_u_challenges_inv_2, fq(alpha.get_value()));
-
-        ASSERT(challenge_poly.evaluate(opening_pair.challenge) == opening_pair.evaluation && "Opening claim does not hold for challenge polynomial.");
-
-        IPA<NativeCurve>::compute_opening_proof(ck, { challenge_poly, opening_pair }, prover_transcript);
-
-        // Since we know this circuit will not have any more IPA claims to accumulate, add IPA Claim to public inputs of circuit and add the proof to the builder.
-        Builder* builder = r.get_context();
-        builder->add_ipa_claim(output_claim.get_witness_indices());
-        builder->ipa_proof = prover_transcript->proof_data;
-
-        return {output_claim, prover_transcript->proof_data};
+        return {output_claim, create_challenge_poly(uint32_t(pair_1.log_poly_length.get_value()), native_u_challenges_inv_1, uint32_t(pair_2.log_poly_length.get_value()), native_u_challenges_inv_2, fq(alpha.get_value()))};
     }
 };
 
diff --git a/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/ipa_recursive.test.cpp b/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/ipa_recursive.test.cpp
index fa55d812441..8b59b2b90b8 100644
--- a/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/ipa_recursive.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/ipa_recursive.test.cpp
@@ -56,8 +56,8 @@ class IPARecursiveTests : public CommitmentTest<NativeCurve> {
         OpeningClaim<Curve> stdlib_opening_claim{ { stdlib_x, stdlib_eval }, stdlib_comm };
 
         // Construct stdlib verifier transcript
-        auto recursive_verifier_transcript = std::make_shared<StdlibTranscript>(
-            bb::convert_native_proof_to_stdlib(&builder, prover_transcript->proof_data));
+        auto recursive_verifier_transcript =
+            std::make_shared<StdlibTranscript>(bb::convert_proof_to_witness(&builder, prover_transcript->proof_data));
         return { recursive_verifier_transcript, stdlib_opening_claim };
     }
 
@@ -158,21 +158,25 @@ class IPARecursiveTests : public CommitmentTest<NativeCurve> {
 
         // Creates two IPA accumulators and accumulators from the two claims. Also constructs the accumulated h
         // polynomial.
-        auto [output_claim, ipa_proof] =
-            RecursiveIPA::accumulate(this->ck(), transcript_1, claim_1, transcript_2, claim_2);
+        auto [output_claim, challenge_poly] = RecursiveIPA::accumulate(transcript_1, claim_1, transcript_2, claim_2);
         builder.finalize_circuit(/*ensure_nonzero=*/false);
         info("Circuit with 2 IPA Recursive Verifiers and IPA Accumulation num finalized gates = ",
              builder.get_num_finalized_gates());
 
         EXPECT_TRUE(CircuitChecker::check(builder));
 
+        // Run the IPA prover on this new accumulated claim.
+        auto prover_transcript = std::make_shared<NativeTranscript>();
         const OpeningPair<NativeCurve> opening_pair{ bb::fq(output_claim.opening_pair.challenge.get_value()),
                                                      bb::fq(output_claim.opening_pair.evaluation.get_value()) };
         Commitment native_comm = output_claim.commitment.get_value();
         const OpeningClaim<NativeCurve> opening_claim{ opening_pair, native_comm };
 
+        NativeIPA::compute_opening_proof(this->ck(), { challenge_poly, opening_pair }, prover_transcript);
+
+        EXPECT_EQ(challenge_poly.evaluate(opening_pair.challenge), opening_pair.evaluation);
         // Natively verify this proof to check it.
-        auto verifier_transcript = std::make_shared<NativeTranscript>(ipa_proof);
+        auto verifier_transcript = std::make_shared<NativeTranscript>(prover_transcript->proof_data);
 
         auto result = NativeIPA::reduce_verify(this->vk(), opening_claim, verifier_transcript);
         EXPECT_TRUE(result);
diff --git a/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/shplemini.test.cpp b/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/shplemini.test.cpp
index 97051dc2b08..b94b0c95085 100644
--- a/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/shplemini.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/shplemini.test.cpp
@@ -88,7 +88,7 @@ TEST(ShpleminiRecursionTest, ProveAndVerifySingle)
             N, RefVector(f_polynomials), RefVector(g_polynomials), u_challenge, commitment_key, prover_transcript);
         KZG<NativeCurve>::compute_opening_proof(commitment_key, prover_opening_claims, prover_transcript);
         Builder builder;
-        StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(&builder, prover_transcript->proof_data);
+        StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(&builder, prover_transcript->proof_data);
         auto stdlib_verifier_transcript = std::make_shared<Transcript>(stdlib_proof);
         stdlib_verifier_transcript->template receive_from_prover<Fr>("Init");
 
diff --git a/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/zeromorph.test.cpp b/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/zeromorph.test.cpp
index fb70282a51f..5c6f22d6af4 100644
--- a/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/zeromorph.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/zeromorph.test.cpp
@@ -95,7 +95,7 @@ TEST(ZeroMorphRecursionTest, ProveAndVerifySingle)
                            prover_transcript);
 
     Builder builder;
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(&builder, prover_transcript->proof_data);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(&builder, prover_transcript->proof_data);
     auto stdlib_verifier_transcript = std::make_shared<Transcript>(stdlib_proof);
     [[maybe_unused]] auto _ = stdlib_verifier_transcript->template receive_from_prover<Fr>("Init");
 
diff --git a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
index 1cb9bb642bd..d0eb9d767d6 100644
--- a/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
+++ b/barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp
@@ -299,7 +299,7 @@ void process_plonk_recursion_constraints(Builder& builder,
         // they want these constants set by keeping the nested aggregation object attached to
         // the proof as public inputs. As this is the only object that can prepended to the
         // proof if the proof is above the expected size (with public inputs stripped)
-        PairingPointAccumulatorPubInputIndices nested_aggregation_object = {};
+        PairingPointAccumPubInputIndices nested_aggregation_object = {};
         // If the proof has public inputs attached to it, we should handle setting the nested
         // aggregation object
         if (constraint.proof.size() > proof_size_no_pub_inputs) {
@@ -343,9 +343,16 @@ void process_plonk_recursion_constraints(Builder& builder,
     // inputs.
     if (!constraint_system.recursion_constraints.empty()) {
 
+        // First add the output aggregation object as public inputs
+        // Set the indices as public inputs because they are no longer being
+        // created in ACIR
+        for (const auto& idx : current_output_aggregation_object) {
+            builder.set_public_input(idx);
+        }
+
         // Make sure the verification key records the public input indices of the
         // final recursion output.
-        builder.add_pairing_point_accumulator(current_output_aggregation_object);
+        builder.set_pairing_point_accumulator(current_output_aggregation_object);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/examples/join_split/join_split.test.cpp b/barretenberg/cpp/src/barretenberg/examples/join_split/join_split.test.cpp
index 677e30f198c..f56dbf882e7 100644
--- a/barretenberg/cpp/src/barretenberg/examples/join_split/join_split.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/examples/join_split/join_split.test.cpp
@@ -33,8 +33,8 @@ using namespace bb::join_split_example::proofs::notes::native;
 using key_pair = join_split_example::fixtures::grumpkin_key_pair;
 
 auto create_account_leaf_data(fr const& account_alias_hash,
-                              bb::grumpkin::g1::affine_element const& owner_key,
-                              bb::grumpkin::g1::affine_element const& signing_key)
+                              grumpkin::g1::affine_element const& owner_key,
+                              grumpkin::g1::affine_element const& signing_key)
 {
     return notes::native::account::account_note{ account_alias_hash, owner_key, signing_key }.commit();
 }
@@ -869,7 +869,7 @@ TEST_P(test_allow_chain_to_other_users_fail, )
 {
     join_split_tx tx = simple_setup();
     tx.allow_chain = GetParam();
-    tx.output_note[tx.allow_chain - 1].owner = bb::grumpkin::g1::element::random_element(); // i.e. not owned by self.
+    tx.output_note[tx.allow_chain - 1].owner = grumpkin::g1::element::random_element(); // i.e. not owned by self.
     auto result = sign_and_verify_logic(tx, user.owner);
     EXPECT_FALSE(result.valid);
     EXPECT_EQ(result.err, "inter-user chaining disallowed");
@@ -1028,7 +1028,7 @@ TEST_F(join_split_tests, test_total_output_value_larger_than_total_input_value_f
 TEST_F(join_split_tests, test_different_input_note_owners_fails)
 {
     join_split_tx tx = simple_setup({ 1, 2 });
-    tx.input_note[0].owner = bb::grumpkin::g1::affine_element::hash_to_curve({ 1 });
+    tx.input_note[0].owner = grumpkin::g1::affine_element::hash_to_curve({ 1 });
 
     auto result = sign_and_verify_logic(tx, user.owner);
     EXPECT_FALSE(result.valid);
@@ -1073,7 +1073,7 @@ TEST_F(join_split_tests, test_different_note_account_required_vs_account_require
 TEST_F(join_split_tests, test_wrong_input_note_owner_fails)
 {
     join_split_tx tx = simple_setup();
-    tx.input_note[0].owner = bb::grumpkin::g1::element::random_element();
+    tx.input_note[0].owner = grumpkin::g1::element::random_element();
     tx.input_note[1].owner = tx.input_note[0].owner;
 
     auto result = sign_and_verify_logic(tx, user.owner);
@@ -1084,8 +1084,8 @@ TEST_F(join_split_tests, test_wrong_input_note_owner_fails)
 TEST_F(join_split_tests, test_random_output_note_owners)
 {
     join_split_tx tx = simple_setup();
-    tx.output_note[0].owner = bb::grumpkin::g1::element::random_element();
-    tx.output_note[1].owner = bb::grumpkin::g1::element::random_element();
+    tx.output_note[0].owner = grumpkin::g1::element::random_element();
+    tx.output_note[1].owner = grumpkin::g1::element::random_element();
 
     EXPECT_TRUE(sign_and_verify_logic(tx, user.owner).valid);
 }
@@ -1097,7 +1097,7 @@ TEST_F(join_split_tests, test_random_output_note_owners)
 TEST_F(join_split_tests, test_wrong_account_private_key_fails)
 {
     join_split_tx tx = simple_setup();
-    tx.account_private_key = bb::grumpkin::fr::random_element();
+    tx.account_private_key = grumpkin::fr::random_element();
 
     auto result = sign_and_verify_logic(tx, user.owner);
     EXPECT_FALSE(result.valid);
diff --git a/barretenberg/cpp/src/barretenberg/flavor/flavor.hpp b/barretenberg/cpp/src/barretenberg/flavor/flavor.hpp
index 67c20814a34..f0b7158e5c6 100644
--- a/barretenberg/cpp/src/barretenberg/flavor/flavor.hpp
+++ b/barretenberg/cpp/src/barretenberg/flavor/flavor.hpp
@@ -110,7 +110,7 @@ template <typename FF, typename CommitmentKey_> class ProvingKey_ {
   public:
     size_t circuit_size;
     bool contains_pairing_point_accumulator;
-    PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices;
+    PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices;
     bb::EvaluationDomain<FF> evaluation_domain;
     std::shared_ptr<CommitmentKey_> commitment_key;
     size_t num_public_inputs;
@@ -152,7 +152,7 @@ class VerificationKey_ : public PrecomputedCommitments {
     using Commitment = typename VerifierCommitmentKey::Commitment;
     std::shared_ptr<VerifierCommitmentKey> pcs_verification_key;
     bool contains_pairing_point_accumulator = false;
-    PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices = {};
+    PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices = {};
     uint64_t pub_inputs_offset = 0;
 
     bool operator==(const VerificationKey_&) const = default;
@@ -373,9 +373,6 @@ MegaZKRecursiveFlavor_<UltraCircuitBuilder>>;
 template <typename T>
 concept HasDataBus = IsMegaFlavor<T>;
 
-template <typename T>
-concept HasIPAAccumulatorFlavor = IsAnyOf<T, UltraFlavor, UltraFlavorWithZK>;
-
 template <typename T>
 concept IsRecursiveFlavor = IsAnyOf<T, UltraRecursiveFlavor_<UltraCircuitBuilder>,
                                        UltraRecursiveFlavor_<MegaCircuitBuilder>,
diff --git a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp
index e8e5e51ff6b..2ddcdfb2038 100644
--- a/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp
+++ b/barretenberg/cpp/src/barretenberg/goblin/mock_circuits.hpp
@@ -212,7 +212,7 @@ class GoblinMockCircuits {
 
         // Execute recursive aggregation of function proof
         auto verification_key = std::make_shared<RecursiveVerificationKey>(&builder, function_accum.verification_key);
-        auto proof = bb::convert_native_proof_to_stdlib(&builder, function_accum.proof);
+        auto proof = bb::convert_proof_to_witness(&builder, function_accum.proof);
         RecursiveVerifier verifier1{ &builder, verification_key };
         verifier1.verify_proof(
             proof, stdlib::recursion::init_default_aggregation_state<MegaBuilder, RecursiveFlavor::Curve>(builder));
@@ -221,7 +221,7 @@ class GoblinMockCircuits {
         if (!prev_kernel_accum.proof.empty()) {
             auto verification_key =
                 std::make_shared<RecursiveVerificationKey>(&builder, prev_kernel_accum.verification_key);
-            auto proof = bb::convert_native_proof_to_stdlib(&builder, prev_kernel_accum.proof);
+            auto proof = bb::convert_proof_to_witness(&builder, prev_kernel_accum.proof);
             RecursiveVerifier verifier2{ &builder, verification_key };
             verifier2.verify_proof(
                 proof, stdlib::recursion::init_default_aggregation_state<MegaBuilder, RecursiveFlavor::Curve>(builder));
diff --git a/barretenberg/cpp/src/barretenberg/plonk/proof_system/proving_key/proving_key.hpp b/barretenberg/cpp/src/barretenberg/plonk/proof_system/proving_key/proving_key.hpp
index eedd49442d0..e0a2097adda 100644
--- a/barretenberg/cpp/src/barretenberg/plonk/proof_system/proving_key/proving_key.hpp
+++ b/barretenberg/cpp/src/barretenberg/plonk/proof_system/proving_key/proving_key.hpp
@@ -25,7 +25,7 @@ struct proving_key_data {
     uint32_t circuit_size;
     uint32_t num_public_inputs;
     bool contains_pairing_point_accumulator;
-    PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices;
+    PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices;
     std::vector<uint32_t> memory_read_records;
     std::vector<uint32_t> memory_write_records;
 #ifdef __wasm__
@@ -60,7 +60,7 @@ struct proving_key {
     size_t log_circuit_size;
     size_t num_public_inputs;
     bool contains_pairing_point_accumulator = false;
-    PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices;
+    PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices;
     std::vector<uint32_t> memory_read_records;  // Used by UltraPlonkComposer only; for ROM, RAM reads.
     std::vector<uint32_t> memory_write_records; // Used by UltraPlonkComposer only, for RAM writes.
 
diff --git a/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp b/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
index f3b84e29fc9..face2fba637 100644
--- a/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
+++ b/barretenberg/cpp/src/barretenberg/plonk/proof_system/verification_key/verification_key.hpp
@@ -18,7 +18,7 @@ struct verification_key_data {
     uint32_t num_public_inputs;
     std::map<std::string, bb::g1::affine_element> commitments;
     bool contains_pairing_point_accumulator = false;
-    PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices;
+    PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices;
     bool is_recursive_circuit = false;
 
     // for serialization: update with any new fields
@@ -99,7 +99,7 @@ struct verification_key {
     bb::fr z_pow_n; // ʓ^n (ʓ being the 'evaluation challenge')
 
     bool contains_pairing_point_accumulator = false;
-    PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices;
+    PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices;
 
     bool is_recursive_circuit = false;
 
diff --git a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/types/aggregation_object_type.hpp b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/types/aggregation_object_type.hpp
index 99608cc626f..5f9bb79cda6 100644
--- a/barretenberg/cpp/src/barretenberg/plonk_honk_shared/types/aggregation_object_type.hpp
+++ b/barretenberg/cpp/src/barretenberg/plonk_honk_shared/types/aggregation_object_type.hpp
@@ -7,14 +7,10 @@ namespace bb {
 // An aggregation state is represented by two G1 affine elements. Each G1 point has
 // two field element coordinates (x, y). Thus, four base field elements
 // Four limbs are used when simulating a non-native field using the bigfield class, so 16 total field elements.
-static constexpr uint32_t PAIRING_POINT_ACCUMULATOR_SIZE = 16;
+constexpr uint32_t PAIRING_POINT_ACCUMULATOR_SIZE = 16;
 // PairingPointAccumulatorIndices represents an array of 16 witness indices pointing to the nested aggregation object.
 using PairingPointAccumulatorIndices = std::array<uint32_t, PAIRING_POINT_ACCUMULATOR_SIZE>;
-// PairingPointAccumulatorPubInputIndices represents an array of 16 public input indices pointing to the witness indices
-// of the nested aggregation object.
-using PairingPointAccumulatorPubInputIndices = std::array<uint32_t, PAIRING_POINT_ACCUMULATOR_SIZE>;
-
-static constexpr uint32_t IPA_CLAIM_SIZE = 6;
-using IPAClaimIndices = std::array<uint32_t, IPA_CLAIM_SIZE>;
-using IPAClaimPubInputIndices = std::array<uint32_t, IPA_CLAIM_SIZE>;
+// PairingPointAccumPubInputIndices represents an array of 16 public input indices pointing to the witness indices of
+// the nested aggregation object.
+using PairingPointAccumPubInputIndices = std::array<uint32_t, PAIRING_POINT_ACCUMULATOR_SIZE>;
 } // namespace bb
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.cpp
index 90a7df0e894..15f7ce40f3d 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.cpp
@@ -8,7 +8,7 @@ namespace bb::stdlib::recursion::honk {
  * @todo (https://github.com/AztecProtocol/barretenberg/issues/934):  Add logic for accumulating the pairing points
  * produced by the verifiers (and potentially IPA accumulators for ECCVM verifier)
  */
-ClientIVCRecursiveVerifier::Output ClientIVCRecursiveVerifier::verify(const ClientIVC::Proof& proof)
+void ClientIVCRecursiveVerifier::verify(const ClientIVC::Proof& proof)
 {
     // Construct stdlib Mega verification key
     auto stdlib_mega_vk =
@@ -24,9 +24,7 @@ ClientIVCRecursiveVerifier::Output ClientIVCRecursiveVerifier::verify(const Clie
 
     // Perform Goblin recursive verification
     GoblinVerifier goblin_verifier{ builder.get(), verifier_input.goblin_input };
-    GoblinRecursiveVerifierOutput output = goblin_verifier.verify(proof.goblin_proof);
-
-    return output;
+    goblin_verifier.verify(proof.goblin_proof);
 }
 
 } // namespace bb::stdlib::recursion::honk
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.hpp b/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.hpp
index 4381b1f5faf..d6954bb0532 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.hpp
@@ -21,8 +21,6 @@ class ClientIVCRecursiveVerifier {
     using Proof = ClientIVC::Proof;
     using FoldVerifierInput = FoldingVerifier::VerifierInput;
     using GoblinVerifierInput = GoblinVerifier::VerifierInput;
-    using Output = GoblinRecursiveVerifierOutput;
-
     struct VerifierInput {
         std::shared_ptr<VerificationKey> mega_verification_key;
         GoblinVerifierInput goblin_input;
@@ -32,7 +30,7 @@ class ClientIVCRecursiveVerifier {
         : builder(builder)
         , verifier_input(verifier_input){};
 
-    Output verify(const ClientIVC::Proof&);
+    void verify(const ClientIVC::Proof&);
 
   private:
     std::shared_ptr<Builder> builder;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.test.cpp
index 436e62b88a8..aff80907915 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.test.cpp
@@ -74,8 +74,6 @@ TEST_F(ClientIVCRecursionTests, NativeVerification)
  */
 TEST_F(ClientIVCRecursionTests, Basic)
 {
-    using CIVCRecVerifierOutput = ClientIVCRecursiveVerifier::Output;
-
     // Generate a genuine ClientIVC prover output
     ClientIVC ivc{ {}, /*auto_verify_mode=*/true };
     auto [proof, verifier_input] = construct_client_ivc_prover_output(ivc);
@@ -85,7 +83,7 @@ TEST_F(ClientIVCRecursionTests, Basic)
     ClientIVCVerifier verifier{ builder, verifier_input };
 
     // Generate the recursive verification circuit
-    CIVCRecVerifierOutput output = verifier.verify(proof);
+    verifier.verify(proof);
 
     EXPECT_EQ(builder->failed(), false) << builder->err();
 
@@ -97,8 +95,6 @@ TEST_F(ClientIVCRecursionTests, Basic)
 
 TEST_F(ClientIVCRecursionTests, ClientTubeBase)
 {
-    using CIVCRecVerifierOutput = ClientIVCRecursiveVerifier::Output;
-
     // Generate a genuine ClientIVC prover output
     ClientIVC ivc{ {}, /*auto_verify_mode=*/true };
     auto [proof, verifier_input] = construct_client_ivc_prover_output(ivc);
@@ -108,15 +104,10 @@ TEST_F(ClientIVCRecursionTests, ClientTubeBase)
     ClientIVCVerifier verifier{ tube_builder, verifier_input };
 
     // Generate the recursive verification circuit
-    CIVCRecVerifierOutput client_ivc_rec_verifier_output = verifier.verify(proof);
+    verifier.verify(proof);
 
-    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1069): fix this by taking it from the output instead of
-    // just using default.
     tube_builder->add_pairing_point_accumulator(
         stdlib::recursion::init_default_agg_obj_indices<Builder>(*tube_builder));
-    // The tube only calls an IPA recursive verifier once, so we can just add this IPA claim and proof
-    tube_builder->add_ipa_claim(client_ivc_rec_verifier_output.opening_claim.get_witness_indices());
-    tube_builder->ipa_proof = convert_stdlib_proof_to_native(client_ivc_rec_verifier_output.ipa_transcript->proof_data);
 
     info("ClientIVC Recursive Verifier: num prefinalized gates = ", tube_builder->num_gates);
 
@@ -129,16 +120,10 @@ TEST_F(ClientIVCRecursionTests, ClientTubeBase)
     UltraProver tube_prover{ proving_key };
     auto native_tube_proof = tube_prover.construct_proof();
 
-    // Natively verify the tube proof
-    auto native_vk = std::make_shared<NativeFlavor::VerificationKey>(proving_key->proving_key);
-    auto ipa_verification_key = std::make_shared<VerifierCommitmentKey<curve::Grumpkin>>(1 << CONST_ECCVM_LOG_N);
-    UltraVerifier native_verifier(native_vk, ipa_verification_key);
-    EXPECT_TRUE(native_verifier.verify_proof(native_tube_proof, tube_prover.proving_key->proving_key.ipa_proof));
-
-    // Construct a base rollup circuit that recursively verifies the tube proof.
     Builder base_builder;
+    auto native_vk = std::make_shared<NativeFlavor::VerificationKey>(proving_key->proving_key);
     auto vk = std::make_shared<Flavor::VerificationKey>(&base_builder, native_vk);
-    auto tube_proof = bb::convert_native_proof_to_stdlib(&base_builder, native_tube_proof);
+    auto tube_proof = bb::convert_proof_to_witness(&base_builder, native_tube_proof);
     UltraRecursiveVerifier base_verifier{ &base_builder, vk };
     base_verifier.verify_proof(tube_proof,
                                stdlib::recursion::init_default_aggregation_state<Builder, Flavor::Curve>(base_builder));
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.cpp
index a9422482854..dd1868f2cc6 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.cpp
@@ -15,11 +15,8 @@ ECCVMRecursiveVerifier_<Flavor>::ECCVMRecursiveVerifier_(
 
 /**
  * @brief This function verifies an ECCVM Honk proof for given program settings up to sumcheck.
- *
  */
-template <typename Flavor>
-std::pair<OpeningClaim<typename Flavor::Curve>, std::shared_ptr<typename ECCVMRecursiveVerifier_<Flavor>::Transcript>>
-ECCVMRecursiveVerifier_<Flavor>::verify_proof(const ECCVMProof& proof)
+template <typename Flavor> void ECCVMRecursiveVerifier_<Flavor>::verify_proof(const ECCVMProof& proof)
 {
     using Curve = typename Flavor::Curve;
     using Shplemini = ShpleminiVerifier_<Curve>;
@@ -28,8 +25,8 @@ ECCVMRecursiveVerifier_<Flavor>::verify_proof(const ECCVMProof& proof)
 
     RelationParameters<FF> relation_parameters;
 
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(builder, proof.pre_ipa_proof);
-    StdlibProof<Builder> stdlib_ipa_proof = bb::convert_native_proof_to_stdlib(builder, proof.ipa_proof);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(builder, proof.pre_ipa_proof);
+    StdlibProof<Builder> stdlib_ipa_proof = bb::convert_proof_to_witness(builder, proof.ipa_proof);
     transcript = std::make_shared<Transcript>(stdlib_proof);
     ipa_transcript = std::make_shared<Transcript>(stdlib_ipa_proof);
 
@@ -145,8 +142,10 @@ ECCVMRecursiveVerifier_<Flavor>::verify_proof(const ECCVMProof& proof)
     const OpeningClaim batch_opening_claim =
         Shplonk::reduce_verification(key->pcs_verification_key->get_g1_identity(), opening_claims, transcript);
 
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/1142): Handle this return value correctly.
+    const typename PCS::VerifierAccumulator batched_opening_accumulator =
+        PCS::reduce_verify(batch_opening_claim, ipa_transcript);
     ASSERT(sumcheck_verified);
-    return { batch_opening_claim, ipa_transcript };
 }
 
 template class ECCVMRecursiveVerifier_<ECCVMRecursiveFlavor_<UltraCircuitBuilder>>;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.hpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.hpp
index 729740aa707..58103e9644b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.hpp
@@ -21,7 +21,7 @@ template <typename Flavor> class ECCVMRecursiveVerifier_ {
                                      const std::shared_ptr<NativeVerificationKey>& native_verifier_key);
 
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/991): switch recursive verifiers to StdlibProof
-    std::pair<OpeningClaim<Curve>, std::shared_ptr<Transcript>> verify_proof(const ECCVMProof& proof);
+    void verify_proof(const ECCVMProof& proof);
 
     std::shared_ptr<VerificationKey> key;
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.test.cpp
index 8c5581e22b6..0aae8567845 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.test.cpp
@@ -83,8 +83,7 @@ template <typename RecursiveFlavor> class ECCVMRecursiveTests : public ::testing
         info("ECCVM Recursive Verifier");
         OuterBuilder outer_circuit;
         RecursiveVerifier verifier{ &outer_circuit, verification_key };
-        auto [opening_claim, ipa_transcript] = verifier.verify_proof(proof);
-
+        verifier.verify_proof(proof);
         info("Recursive Verifier: num gates = ", outer_circuit.get_estimated_num_finalized_gates());
 
         // Check for a failure flag in the recursive verifier circuit
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
index a852624235a..ea93c1c161d 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
@@ -7,13 +7,14 @@
 #include "schnorr.hpp"
 
 using namespace bb;
+using namespace bb::stdlib;
 using namespace bb::crypto;
 
 using Builder = UltraCircuitBuilder;
-using bool_ct = stdlib::bool_t<Builder>;
-using byte_array_ct = stdlib::byte_array<Builder>;
-using field_ct = stdlib::field_t<Builder>;
-using witness_ct = stdlib::witness_t<Builder>;
+using bool_ct = bool_t<Builder>;
+using byte_array_ct = byte_array<Builder>;
+using field_ct = field_t<Builder>;
+using witness_ct = witness_t<Builder>;
 
 /**
  * @test Test circuit verifying a Schnorr signature generated by \see{crypto::schnorr_verify_signature}.
@@ -41,10 +42,10 @@ TEST(stdlib_schnorr, schnorr_verify_signature)
             message_string, account.public_key, signature);
         EXPECT_EQ(first_result, true);
 
-        stdlib::cycle_group<Builder> pub_key{ witness_ct(&builder, account.public_key.x),
-                                              witness_ct(&builder, account.public_key.y),
-                                              false };
-        stdlib::schnorr_signature_bits sig = stdlib::schnorr_convert_signature(&builder, signature);
+        cycle_group<Builder> pub_key{ witness_ct(&builder, account.public_key.x),
+                                      witness_ct(&builder, account.public_key.y),
+                                      false };
+        schnorr_signature_bits sig = schnorr_convert_signature(&builder, signature);
         byte_array_ct message(&builder, message_string);
         schnorr_verify_signature(message, pub_key, sig);
 
@@ -83,10 +84,10 @@ TEST(stdlib_schnorr, verify_signature_failure)
     EXPECT_EQ(native_result, false);
 
     // check stdlib verification with account 2 public key fails
-    stdlib::cycle_group<Builder> pub_key2_ct{ witness_ct(&builder, account2.public_key.x),
-                                              witness_ct(&builder, account2.public_key.y),
-                                              false };
-    stdlib::schnorr_signature_bits sig = stdlib::schnorr_convert_signature(&builder, signature);
+    cycle_group<Builder> pub_key2_ct{ witness_ct(&builder, account2.public_key.x),
+                                      witness_ct(&builder, account2.public_key.y),
+                                      false };
+    schnorr_signature_bits sig = schnorr_convert_signature(&builder, signature);
     byte_array_ct message(&builder, message_string);
     schnorr_verify_signature(message, pub_key2_ct, sig);
 
@@ -117,10 +118,10 @@ TEST(stdlib_schnorr, schnorr_signature_verification_result)
         longer_string, account.public_key, signature);
     EXPECT_EQ(first_result, true);
 
-    stdlib::cycle_group<Builder> pub_key{ witness_ct(&builder, account.public_key.x),
-                                          witness_ct(&builder, account.public_key.y),
-                                          false };
-    stdlib::schnorr_signature_bits sig = stdlib::schnorr_convert_signature(&builder, signature);
+    cycle_group<Builder> pub_key{ witness_ct(&builder, account.public_key.x),
+                                  witness_ct(&builder, account.public_key.y),
+                                  false };
+    schnorr_signature_bits sig = schnorr_convert_signature(&builder, signature);
     byte_array_ct message(&builder, longer_string);
     bool_ct signature_result = schnorr_signature_verification_result(message, pub_key, sig);
     EXPECT_EQ(signature_result.witness_bool, true);
@@ -160,10 +161,10 @@ TEST(stdlib_schnorr, signature_verification_result_failure)
     EXPECT_EQ(native_result, false);
 
     // check stdlib verification with account 2 public key fails
-    stdlib::cycle_group<Builder> pub_key2_ct{ witness_ct(&builder, account2.public_key.x),
-                                              witness_ct(&builder, account2.public_key.y),
-                                              false };
-    stdlib::schnorr_signature_bits sig = stdlib::schnorr_convert_signature(&builder, signature);
+    cycle_group<Builder> pub_key2_ct{ witness_ct(&builder, account2.public_key.x),
+                                      witness_ct(&builder, account2.public_key.y),
+                                      false };
+    schnorr_signature_bits sig = schnorr_convert_signature(&builder, signature);
     byte_array_ct message(&builder, message_string);
     bool_ct signature_result = schnorr_signature_verification_result(message, pub_key2_ct, sig);
     EXPECT_EQ(signature_result.witness_bool, false);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.cpp
index b9bf165bc96..8a6980ff4b0 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.cpp
@@ -8,11 +8,11 @@ namespace bb::stdlib::recursion::honk {
  * @todo https://github.com/AztecProtocol/barretenberg/issues/934: Add logic for accumulating the pairing points
  * produced by the translator and merge verifier (and potentially IPA accumulators for ECCVM verifier)
  */
-GoblinRecursiveVerifierOutput GoblinRecursiveVerifier::verify(const GoblinProof& proof)
+void GoblinRecursiveVerifier::verify(const GoblinProof& proof)
 {
     // Run the ECCVM recursive verifier
     ECCVMVerifier eccvm_verifier{ builder, verification_keys.eccvm_verification_key };
-    auto [opening_claim, ipa_transcript] = eccvm_verifier.verify_proof(proof.eccvm_proof);
+    eccvm_verifier.verify_proof(proof.eccvm_proof);
 
     // Run the Translator recursive verifier
     TranslatorVerifier translator_verifier{ builder,
@@ -36,6 +36,5 @@ GoblinRecursiveVerifierOutput GoblinRecursiveVerifier::verify(const GoblinProof&
 
     MergeVerifier merge_verifier{ builder };
     merge_verifier.verify_proof(proof.merge_proof);
-    return { opening_claim, ipa_transcript };
 }
 } // namespace bb::stdlib::recursion::honk
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.hpp b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.hpp
index a3c0828ce90..92ae344af66 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.hpp
@@ -5,16 +5,6 @@
 #include "barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.hpp"
 
 namespace bb::stdlib::recursion::honk {
-
-struct GoblinRecursiveVerifierOutput {
-    using Builder = UltraCircuitBuilder;
-    using ECCVMFlavor = ECCVMRecursiveFlavor_<Builder>;
-    using Curve = grumpkin<Builder>;
-    using Transcript = bb::BaseTranscript<bb::stdlib::recursion::honk::StdlibTranscriptParams<Builder>>;
-    OpeningClaim<Curve> opening_claim;
-    std::shared_ptr<Transcript> ipa_transcript;
-};
-
 class GoblinRecursiveVerifier {
   public:
     // Goblin Recursive Verifier circuit is using Ultra arithmetisation
@@ -45,7 +35,7 @@ class GoblinRecursiveVerifier {
      *
      * @todo(https://github.com/AztecProtocol/barretenberg/issues/991): The GoblinProof should aleady be a stdlib proof
      */
-    GoblinRecursiveVerifierOutput verify(const GoblinProof&);
+    void verify(const GoblinProof&);
 
   private:
     Builder* builder;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.test.cpp
index a7f9512ec9b..80ee773f2df 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.test.cpp
@@ -113,7 +113,7 @@ TEST_F(GoblinRecursiveVerifierTests, ECCVMFailure)
 
     // Tamper with the ECCVM proof
     for (auto& val : proof.eccvm_proof.pre_ipa_proof) {
-        if (val > 0) { // tamper by finding the first non-zero value and incrementing it by 1
+        if (val > 0) { // tamper by finding the tenth non-zero value and incrementing it by 1
             // tamper by finding the first non-zero value
             // and incrementing it by 1
             val += 1;
@@ -123,18 +123,8 @@ TEST_F(GoblinRecursiveVerifierTests, ECCVMFailure)
 
     Builder builder;
     GoblinRecursiveVerifier verifier{ &builder, verifier_input };
-    GoblinRecursiveVerifierOutput goblin_rec_verifier_output = verifier.verify(proof);
-
-    auto crs_factory =
-        std::make_shared<srs::factories::FileCrsFactory<curve::Grumpkin>>("../srs_db/grumpkin", 1 << CONST_ECCVM_LOG_N);
-    auto grumpkin_verifier_commitment_key =
-        std::make_shared<VerifierCommitmentKey<curve::Grumpkin>>(1 << CONST_ECCVM_LOG_N, crs_factory);
-    OpeningClaim<curve::Grumpkin> native_claim = goblin_rec_verifier_output.opening_claim.get_native_opening_claim();
-    auto native_ipa_transcript = std::make_shared<NativeTranscript>(
-        convert_stdlib_proof_to_native(goblin_rec_verifier_output.ipa_transcript->proof_data));
-
-    EXPECT_FALSE(
-        IPA<curve::Grumpkin>::reduce_verify(grumpkin_verifier_commitment_key, native_claim, native_ipa_transcript));
+
+    EXPECT_DEBUG_DEATH(verifier.verify(proof), "(ipa_relation.get_value.* == -opening_claim.commitment.get_value.*)");
 }
 
 /**
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/merge_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/merge_recursive_verifier.cpp
index 6f3ea52555c..593564fe4ed 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/merge_recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/merge_recursive_verifier.cpp
@@ -19,7 +19,7 @@ std::array<typename bn254<CircuitBuilder>::Element, 2> MergeRecursiveVerifier_<C
     const HonkProof& proof)
 {
     // transform it into stdlib proof
-    StdlibProof<CircuitBuilder> stdlib_proof = bb::convert_native_proof_to_stdlib(builder, proof);
+    StdlibProof<CircuitBuilder> stdlib_proof = bb::convert_proof_to_witness(builder, proof);
     transcript = std::make_shared<Transcript>(stdlib_proof);
 
     // Receive commitments [t_i^{shift}], [T_{i-1}], and [T_i]
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/decider_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/decider_recursive_verifier.cpp
index 162a890e5ff..57fc7f27b08 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/decider_recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/decider_recursive_verifier.cpp
@@ -19,7 +19,7 @@ std::array<typename Flavor::GroupElement, 2> DeciderRecursiveVerifier_<Flavor>::
     using VerifierCommitments = typename Flavor::VerifierCommitments;
     using Transcript = typename Flavor::Transcript;
 
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(builder, proof);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(builder, proof);
     transcript = std::make_shared<Transcript>(stdlib_proof);
 
     VerifierCommitments commitments{ accumulator->verification_key, accumulator->witness_commitments };
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/ultra_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/ultra_recursive_verifier.cpp
index 2bd074dfd97..26c2297b41d 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/ultra_recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/ultra_recursive_verifier.cpp
@@ -27,7 +27,7 @@ template <typename Flavor>
 UltraRecursiveVerifier_<Flavor>::AggregationObject UltraRecursiveVerifier_<Flavor>::verify_proof(
     const HonkProof& proof, AggregationObject agg_obj)
 {
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(builder, proof);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(builder, proof);
     return verify_proof(stdlib_proof, agg_obj);
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/plonk_recursion/verification_key/verification_key.hpp b/barretenberg/cpp/src/barretenberg/stdlib/plonk_recursion/verification_key/verification_key.hpp
index 5fc139f72ba..fc4f6ad3993 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/plonk_recursion/verification_key/verification_key.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/plonk_recursion/verification_key/verification_key.hpp
@@ -240,7 +240,7 @@ template <typename Curve> struct verification_key {
         Builder* ctx,
         const std::vector<field_t<Builder>>& fields,
         bool inner_proof_contains_pairing_point_accumulator = false,
-        PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices = {})
+        PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices = {})
     {
         std::vector<fr> fields_raw;
         std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
@@ -446,7 +446,7 @@ template <typename Curve> struct verification_key {
     plonk::PolynomialManifest polynomial_manifest;
     // Used to check in the circuit if a proof contains any aggregated state.
     bool contains_pairing_point_accumulator = false;
-    PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices;
+    PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices;
     size_t program_width = 4;
     Builder* context;
 };
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.test.cpp
index 81586173b6c..84a1b22d036 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.test.cpp
@@ -203,8 +203,7 @@ template <typename RecursiveFlavor> class ProtogalaxyRecursiveTests : public tes
         auto recursive_decider_vk_1 = std::make_shared<RecursiveDeciderVerificationKey>(&folding_circuit, decider_vk_1);
         auto recursive_decider_vk_2 =
             std::make_shared<RecursiveVerificationKey>(&folding_circuit, decider_vk_2->verification_key);
-        StdlibProof<OuterBuilder> stdlib_proof =
-            bb::convert_native_proof_to_stdlib(&folding_circuit, folding_proof.proof);
+        StdlibProof<OuterBuilder> stdlib_proof = bb::convert_proof_to_witness(&folding_circuit, folding_proof.proof);
 
         auto verifier =
             FoldingRecursiveVerifier{ &folding_circuit, recursive_decider_vk_1, { recursive_decider_vk_2 } };
@@ -293,8 +292,7 @@ template <typename RecursiveFlavor> class ProtogalaxyRecursiveTests : public tes
         auto recursive_decider_vk_1 = std::make_shared<RecursiveDeciderVerificationKey>(&folding_circuit, decider_vk_1);
         auto recursive_decider_vk_2 =
             std::make_shared<RecursiveVerificationKey>(&folding_circuit, decider_vk_2->verification_key);
-        StdlibProof<OuterBuilder> stdlib_proof =
-            bb::convert_native_proof_to_stdlib(&folding_circuit, folding_proof.proof);
+        StdlibProof<OuterBuilder> stdlib_proof = bb::convert_proof_to_witness(&folding_circuit, folding_proof.proof);
 
         auto verifier =
             FoldingRecursiveVerifier{ &folding_circuit, recursive_decider_vk_1, { recursive_decider_vk_2 } };
@@ -400,8 +398,7 @@ template <typename RecursiveFlavor> class ProtogalaxyRecursiveTests : public tes
             std::make_shared<RecursiveDeciderVerificationKey>(&folding_circuit, verifier_accumulator);
         auto recursive_decider_vk_2 =
             std::make_shared<RecursiveVerificationKey>(&folding_circuit, verifier_inst->verification_key);
-        StdlibProof<OuterBuilder> stdlib_proof =
-            bb::convert_native_proof_to_stdlib(&folding_circuit, folding_proof.proof);
+        StdlibProof<OuterBuilder> stdlib_proof = bb::convert_proof_to_witness(&folding_circuit, folding_proof.proof);
 
         auto verifier =
             FoldingRecursiveVerifier{ &folding_circuit, recursive_decider_vk_1, { recursive_decider_vk_2 } };
@@ -439,8 +436,7 @@ template <typename RecursiveFlavor> class ProtogalaxyRecursiveTests : public tes
             auto recursive_decider_vk_1 =
                 std::make_shared<RecursiveDeciderVerificationKey>(&verifier_circuit, honk_vk_1);
             auto recursive_decider_vk_2 = std::make_shared<RecursiveVerificationKey>(&verifier_circuit, honk_vk_2);
-            StdlibProof<OuterBuilder> stdlib_proof =
-                bb::convert_native_proof_to_stdlib(&verifier_circuit, fold_result.proof);
+            StdlibProof<OuterBuilder> stdlib_proof = bb::convert_proof_to_witness(&verifier_circuit, fold_result.proof);
 
             auto verifier =
                 FoldingRecursiveVerifier{ &verifier_circuit, recursive_decider_vk_1, { recursive_decider_vk_2 } };
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/transcript/transcript.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/transcript/transcript.test.cpp
index debefb03a5d..0344b1f8835 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/transcript/transcript.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/transcript/transcript.test.cpp
@@ -111,7 +111,7 @@ TEST(RecursiveHonkTranscript, InterfacesMatch)
     EXPECT_EQ(prover_transcript.get_manifest(), native_transcript.get_manifest());
 
     // Instantiate a stdlib Transcript and perform the same operations
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(&builder, proof_data);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(&builder, proof_data);
     StdlibTranscript transcript{ stdlib_proof };
     perform_mock_verifier_transcript_operations<UltraRecursiveFlavor, LENGTH>(transcript);
 
@@ -164,7 +164,7 @@ TEST(RecursiveHonkTranscript, ReturnValuesMatch)
     auto [native_alpha, native_beta] = native_transcript.template get_challenges<FF>("alpha", "beta");
 
     // Perform the same operations with the stdlib verifier transcript
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(&builder, proof_data);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(&builder, proof_data);
     StdlibTranscript stdlib_transcript{ stdlib_proof };
     auto stdlib_scalar = stdlib_transcript.template receive_from_prover<field_ct>("scalar");
     auto stdlib_commitment = stdlib_transcript.template receive_from_prover<element_ct>("commitment");
@@ -210,7 +210,7 @@ TEST(RecursiveTranscript, InfinityConsistencyGrumpkin)
     verifier_transcript.receive_from_prover<NativeCommitment>("infinity");
     auto verifier_challenge = verifier_transcript.get_challenge<NativeFF>("challenge");
 
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(&builder, proof_data);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(&builder, proof_data);
     StdlibTranscript stdlib_transcript{ stdlib_proof };
     auto stdlib_infinity = stdlib_transcript.receive_from_prover<Commitment>("infinity");
     EXPECT_TRUE(stdlib_infinity.is_point_at_infinity().get_value());
@@ -248,7 +248,7 @@ TEST(RecursiveTranscript, InfinityConsistencyBN254)
     verifier_transcript.receive_from_prover<NativeCommitment>("infinity");
     auto verifier_challenge = verifier_transcript.get_challenge<NativeFF>("challenge");
 
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(&builder, proof_data);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(&builder, proof_data);
     StdlibTranscript stdlib_transcript{ stdlib_proof };
     auto stdlib_commitment = stdlib_transcript.receive_from_prover<Commitment>("infinity");
     EXPECT_TRUE(stdlib_commitment.is_point_at_infinity().get_value());
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.cpp
index ce321b18ea8..2849fdd48b5 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.cpp
@@ -66,7 +66,7 @@ std::array<typename Flavor::GroupElement, 2> TranslatorRecursiveVerifier_<Flavor
     using VerifierCommitments = typename Flavor::VerifierCommitments;
     using CommitmentLabels = typename Flavor::CommitmentLabels;
 
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(builder, proof);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(builder, proof);
     transcript->load_proof(stdlib_proof);
 
     batching_challenge_v = transcript->template get_challenge<BF>("Translation:batching_challenge");
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.test.cpp
index 1e2ab4beac0..27de41a35d3 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/translator_vm_verifier/translator_recursive_verifier.test.cpp
@@ -75,7 +75,7 @@ template <typename RecursiveFlavor> class TranslatorRecursiveTests : public ::te
         OuterBuilder outer_circuit;
 
         // Mock a previous verifier that would in reality be the ECCVM recursive verifier
-        StdlibProof<OuterBuilder> stdlib_proof = bb::convert_native_proof_to_stdlib(&outer_circuit, fake_inital_proof);
+        StdlibProof<OuterBuilder> stdlib_proof = bb::convert_proof_to_witness(&outer_circuit, fake_inital_proof);
         auto transcript = std::make_shared<typename RecursiveFlavor::Transcript>(stdlib_proof);
         transcript->template receive_from_prover<typename RecursiveFlavor::BF>("init");
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base.hpp
index 28b2c9ad8f6..642b8f0ba82 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base.hpp
@@ -37,13 +37,9 @@ template <typename FF_> class CircuitBuilderBase {
     std::map<uint32_t, uint32_t> tau;
 
     // Public input indices which contain recursive proof information
-    PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices;
+    PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices;
     bool contains_pairing_point_accumulator = false;
 
-    // Public input indices which contain the output IPA opening claim
-    IPAClaimPubInputIndices ipa_claim_public_input_indices;
-    bool contains_ipa_claim = false;
-
     // We know from the CLI arguments during proving whether a circuit should use a prover which produces
     // proofs that are friendly to verify in a circuit themselves. A verifier does not need a full circuit
     // description and should be able to verify a proof with just the verification key and the proof.
@@ -210,9 +206,18 @@ template <typename FF_> class CircuitBuilderBase {
      * @param proof_output_witness_indices Witness indices that need to become public and stored as recurisve proof
      * specific
      */
-    void add_pairing_point_accumulator(const PairingPointAccumulatorIndices& pairing_point_accum_witness_indices);
+    void add_pairing_point_accumulator(const PairingPointAccumulatorIndices& proof_output_witness_indices);
 
-    void add_ipa_claim(const IPAClaimIndices& ipa_claim_witness_indices);
+    /**
+     * TODO: We can remove this and use `add_pairing_point_accumulator` once my question has been addressed
+     * TODO: using `add_pairing_point_accumulator` also means that we will need to remove the cde which is
+     * TODO: adding the public_inputs
+     * @brief Update pairing_point_accumulator_public_input_indices with existing public inputs that represent a
+     * recursive proof
+     *
+     * @param proof_output_witness_indices
+     */
+    void set_pairing_point_accumulator(const PairingPointAccumulatorIndices& proof_output_witness_indices);
 
     bool failed() const;
     const std::string& err() const;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base_impl.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base_impl.hpp
index e3e4bbcfe9d..a192a8587b3 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_builder_base_impl.hpp
@@ -237,35 +237,34 @@ void CircuitBuilderBase<FF_>::assert_valid_variables(const std::vector<uint32_t>
 
 template <typename FF_>
 void CircuitBuilderBase<FF_>::add_pairing_point_accumulator(
-    const PairingPointAccumulatorIndices& pairing_point_accum_witness_indices)
+    const PairingPointAccumulatorIndices& proof_output_witness_indices)
 {
     if (contains_pairing_point_accumulator) {
-        failure("added pairing point accumulator when one already exists");
+        failure("added recursive proof when one already exists");
         ASSERT(0);
     }
     contains_pairing_point_accumulator = true;
 
     size_t i = 0;
-    for (const auto& idx : pairing_point_accum_witness_indices) {
+    for (const auto& idx : proof_output_witness_indices) {
         set_public_input(idx);
         pairing_point_accumulator_public_input_indices[i] = static_cast<uint32_t>(public_inputs.size() - 1);
         ++i;
     }
 }
 
-template <typename FF_> void CircuitBuilderBase<FF_>::add_ipa_claim(const IPAClaimIndices& ipa_claim_witness_indices)
+template <typename FF_>
+void CircuitBuilderBase<FF_>::set_pairing_point_accumulator(
+    const PairingPointAccumulatorIndices& proof_output_witness_indices)
 {
-    if (contains_ipa_claim) {
-        failure("added IPA claim when one already exists");
+    if (contains_pairing_point_accumulator) {
+        failure("added recursive proof when one already exists");
         ASSERT(0);
     }
-    contains_ipa_claim = true;
-
-    size_t i = 0;
-    for (const auto& idx : ipa_claim_witness_indices) {
-        set_public_input(idx);
-        ipa_claim_public_input_indices[i] = static_cast<uint32_t>(public_inputs.size() - 1);
-        ++i;
+    contains_pairing_point_accumulator = true;
+    for (size_t i = 0; i < proof_output_witness_indices.size(); ++i) {
+        pairing_point_accumulator_public_input_indices[i] =
+            get_public_input_index(real_variable_index[proof_output_witness_indices[i]]);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_simulator.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_simulator.hpp
index 017c04e8d0d..dc8ed11da34 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_simulator.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/circuit_simulator.hpp
@@ -191,7 +191,7 @@ class CircuitSimulatorBN254 {
     [[nodiscard]] bool check_circuit() const { return !_failed; }
 
     // Public input indices which contain recursive proof information
-    PairingPointAccumulatorPubInputIndices pairing_point_accumulator_public_input_indices;
+    PairingPointAccumPubInputIndices pairing_point_accumulator_public_input_indices;
 };
 
 class SimulatorCircuitChecker {
diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mega_flavor.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mega_flavor.hpp
index 1db6dde5c7d..e87ebe9ea76 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mega_flavor.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/mega_flavor.hpp
@@ -625,7 +625,7 @@ class MegaFlavor {
                         const size_t num_public_inputs,
                         const size_t pub_inputs_offset,
                         const bool contains_pairing_point_accumulator,
-                        const PairingPointAccumulatorPubInputIndices& pairing_point_accumulator_public_input_indices,
+                        const PairingPointAccumPubInputIndices& pairing_point_accumulator_public_input_indices,
                         const DatabusPropagationData& databus_propagation_data,
                         const Commitment& q_m,
                         const Commitment& q_c,
diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp
index 572e095f604..058d6fca95a 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp
@@ -330,8 +330,6 @@ class UltraCircuitBuilder_ : public CircuitBuilderBase<typename ExecutionTrace_:
 
     bool circuit_finalized = false;
 
-    std::vector<fr> ipa_proof;
-
     void process_non_native_field_multiplications();
     UltraCircuitBuilder_(const size_t size_hint = 0)
         : CircuitBuilderBase<FF>(size_hint)
diff --git a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_flavor.hpp b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_flavor.hpp
index e524d22fb62..d8be56ad096 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_flavor.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib_circuit_builders/ultra_flavor.hpp
@@ -284,6 +284,7 @@ class UltraFlavor {
         };
     };
 
+  public:
     /**
      * @brief A field element for each entity of the flavor. These entities represent the prover polynomials
      * evaluated at one point.
@@ -352,10 +353,6 @@ class UltraFlavor {
       public:
         using Base = ProvingKey_<FF, CommitmentKey>;
 
-        bool contains_ipa_claim;
-        IPAClaimPubInputIndices ipa_claim_public_input_indices;
-        HonkProof ipa_proof;
-
         ProvingKey() = default;
         ProvingKey(const size_t dyadic_circuit_size,
                    const size_t num_public_inputs,
@@ -442,17 +439,12 @@ class UltraFlavor {
      */
     class VerificationKey : public VerificationKey_<PrecomputedEntities<Commitment>, VerifierCommitmentKey> {
       public:
-        bool contains_ipa_claim;
-        IPAClaimPubInputIndices ipa_claim_public_input_indices;
-
         bool operator==(const VerificationKey&) const = default;
         VerificationKey() = default;
         VerificationKey(const size_t circuit_size, const size_t num_public_inputs)
             : VerificationKey_(circuit_size, num_public_inputs)
         {}
         VerificationKey(ProvingKey& proving_key)
-            : contains_ipa_claim(proving_key.contains_ipa_claim)
-            , ipa_claim_public_input_indices(proving_key.ipa_claim_public_input_indices)
         {
             this->pcs_verification_key = std::make_shared<VerifierCommitmentKey>();
             this->circuit_size = proving_key.circuit_size;
@@ -476,9 +468,7 @@ class UltraFlavor {
                         const uint64_t num_public_inputs,
                         const uint64_t pub_inputs_offset,
                         const bool contains_pairing_point_accumulator,
-                        const PairingPointAccumulatorPubInputIndices& pairing_point_accumulator_public_input_indices,
-                        const bool contains_ipa_claim,
-                        const IPAClaimPubInputIndices& ipa_claim_public_input_indices,
+                        const PairingPointAccumPubInputIndices& pairing_point_accumulator_public_input_indices,
                         const Commitment& q_m,
                         const Commitment& q_c,
                         const Commitment& q_l,
@@ -506,8 +496,6 @@ class UltraFlavor {
                         const Commitment& table_4,
                         const Commitment& lagrange_first,
                         const Commitment& lagrange_last)
-            : contains_ipa_claim(contains_ipa_claim)
-            , ipa_claim_public_input_indices(ipa_claim_public_input_indices)
         {
             this->circuit_size = circuit_size;
             this->log_circuit_size = numeric::get_msb(this->circuit_size);
@@ -551,8 +539,6 @@ class UltraFlavor {
                        pub_inputs_offset,
                        contains_pairing_point_accumulator,
                        pairing_point_accumulator_public_input_indices,
-                       contains_ipa_claim,
-                       ipa_claim_public_input_indices,
                        q_m,
                        q_c,
                        q_l,
diff --git a/barretenberg/cpp/src/barretenberg/transcript/transcript.hpp b/barretenberg/cpp/src/barretenberg/transcript/transcript.hpp
index fa7853a3d96..06f69bdcb13 100644
--- a/barretenberg/cpp/src/barretenberg/transcript/transcript.hpp
+++ b/barretenberg/cpp/src/barretenberg/transcript/transcript.hpp
@@ -441,7 +441,7 @@ template <typename TranscriptParams> class BaseTranscript {
 };
 
 template <typename Builder>
-static bb::StdlibProof<Builder> convert_native_proof_to_stdlib(Builder* builder, const HonkProof& proof)
+static bb::StdlibProof<Builder> convert_proof_to_witness(Builder* builder, const HonkProof& proof)
 {
     bb::StdlibProof<Builder> result;
     for (const auto& element : proof) {
@@ -450,15 +450,6 @@ static bb::StdlibProof<Builder> convert_native_proof_to_stdlib(Builder* builder,
     return result;
 }
 
-template <typename Builder> static bb::HonkProof convert_stdlib_proof_to_native(const StdlibProof<Builder>& proof)
-{
-    bb::HonkProof result;
-    for (const auto& element : proof) {
-        result.push_back(element.get_value());
-    }
-    return result;
-}
-
 using NativeTranscript = BaseTranscript<NativeTranscriptParams>;
 
 ///////////////////////////////////////////
diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/decider_proving_key.hpp b/barretenberg/cpp/src/barretenberg/ultra_honk/decider_proving_key.hpp
index 77cabf182d9..cb9f954d193 100644
--- a/barretenberg/cpp/src/barretenberg/ultra_honk/decider_proving_key.hpp
+++ b/barretenberg/cpp/src/barretenberg/ultra_honk/decider_proving_key.hpp
@@ -307,17 +307,12 @@ template <IsUltraFlavor Flavor> class DeciderProvingKey_ {
             proving_key.public_inputs.emplace_back(proving_key.polynomials.w_r[idx]);
         }
 
-        if constexpr (HasIPAAccumulatorFlavor<Flavor>) { // Set the IPA claim indices
-            proving_key.ipa_claim_public_input_indices = circuit.ipa_claim_public_input_indices;
-            proving_key.contains_ipa_claim = circuit.contains_ipa_claim;
-            proving_key.ipa_proof = circuit.ipa_proof;
-        }
-        // Set the pairing point accumulator indices
+        // Set the recursive proof indices
         proving_key.pairing_point_accumulator_public_input_indices =
             circuit.pairing_point_accumulator_public_input_indices;
         proving_key.contains_pairing_point_accumulator = circuit.contains_pairing_point_accumulator;
 
-        if constexpr (HasDataBus<Flavor>) { // Set databus commitment propagation data
+        if constexpr (IsMegaFlavor<Flavor>) { // Set databus commitment propagation data
             proving_key.databus_propagation_data = circuit.databus_propagation_data;
         }
         auto end = std::chrono::steady_clock::now();
diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp
index 820aeee03a6..d43f4cadb1c 100644
--- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp
@@ -1,5 +1,4 @@
 #include "./ultra_verifier.hpp"
-#include "barretenberg/commitment_schemes/ipa/ipa.hpp"
 #include "barretenberg/numeric/bitop/get_msb.hpp"
 #include "barretenberg/transcript/transcript.hpp"
 #include "barretenberg/ultra_honk/oink_verifier.hpp"
@@ -10,7 +9,7 @@ namespace bb {
  * @brief This function verifies an Ultra Honk proof for a given Flavor.
  *
  */
-template <typename Flavor> bool UltraVerifier_<Flavor>::verify_proof(const HonkProof& proof, const HonkProof& ipa_proof)
+template <typename Flavor> bool UltraVerifier_<Flavor>::verify_proof(const HonkProof& proof)
 {
     using FF = typename Flavor::FF;
 
@@ -23,40 +22,6 @@ template <typename Flavor> bool UltraVerifier_<Flavor>::verify_proof(const HonkP
             transcript->template get_challenge<FF>("Sumcheck:gate_challenge_" + std::to_string(idx)));
     }
 
-    const auto recover_fq_from_public_inputs = [](std::array<FF, 4> limbs) {
-        const uint256_t limb = uint256_t(limbs[0]) +
-                               (uint256_t(limbs[1]) << stdlib::NUM_LIMB_BITS_IN_FIELD_SIMULATION) +
-                               (uint256_t(limbs[2]) << (stdlib::NUM_LIMB_BITS_IN_FIELD_SIMULATION * 2)) +
-                               (uint256_t(limbs[3]) << (stdlib::NUM_LIMB_BITS_IN_FIELD_SIMULATION * 3));
-        return fq(limb);
-    };
-
-    // Parse out the nested IPA claim using key->ipa_claim_public_input_indices and runs the native IPA verifier.
-    if constexpr (HasIPAAccumulatorFlavor<Flavor>) {
-        if (verification_key->verification_key->contains_ipa_claim) {
-            OpeningClaim<curve::Grumpkin> ipa_claim;
-            std::array<FF, 4> bigfield_limbs;
-            for (size_t k = 0; k < 4; k++) {
-                bigfield_limbs[k] =
-                    verification_key
-                        ->public_inputs[verification_key->verification_key->ipa_claim_public_input_indices[k]];
-            }
-            ipa_claim.opening_pair.challenge = recover_fq_from_public_inputs(bigfield_limbs);
-            ipa_claim.opening_pair.evaluation = 0;
-            ipa_claim.commitment = {
-                verification_key->public_inputs[verification_key->verification_key->ipa_claim_public_input_indices[4]],
-                verification_key->public_inputs[verification_key->verification_key->ipa_claim_public_input_indices[5]]
-            };
-
-            // verify the ipa_proof with this claim
-            auto ipa_transcript = std::make_shared<Transcript>(ipa_proof);
-            bool ipa_result = IPA<curve::Grumpkin>::reduce_verify(ipa_verification_key, ipa_claim, ipa_transcript);
-            if (!ipa_result) {
-                return false;
-            }
-        }
-    }
-
     DeciderVerifier decider_verifier{ verification_key, transcript };
 
     return decider_verifier.verify();
diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.hpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.hpp
index 01b1ec5cc15..7365303b655 100644
--- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.hpp
+++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.hpp
@@ -12,23 +12,20 @@ template <typename Flavor> class UltraVerifier_ {
     using FF = typename Flavor::FF;
     using Commitment = typename Flavor::Commitment;
     using VerificationKey = typename Flavor::VerificationKey;
+    using VerifierCommitmentKey = typename Flavor::VerifierCommitmentKey;
     using Transcript = typename Flavor::Transcript;
     using DeciderVK = DeciderVerificationKey_<Flavor>;
     using DeciderVerifier = DeciderVerifier_<Flavor>;
 
   public:
-    explicit UltraVerifier_(
-        const std::shared_ptr<VerificationKey>& verifier_key,
-        const std::shared_ptr<VerifierCommitmentKey<curve::Grumpkin>>& ipa_verification_key = nullptr)
+    explicit UltraVerifier_(const std::shared_ptr<VerificationKey>& verifier_key)
         : verification_key(std::make_shared<DeciderVK>(verifier_key))
-        , ipa_verification_key(ipa_verification_key)
     {}
 
-    bool verify_proof(const HonkProof& proof, const HonkProof& ipa_proof = {});
+    bool verify_proof(const HonkProof& proof);
 
     std::shared_ptr<Transcript> transcript{ nullptr };
     std::shared_ptr<DeciderVK> verification_key;
-    std::shared_ptr<VerifierCommitmentKey<curve::Grumpkin>> ipa_verification_key;
 };
 
 using UltraVerifier = UltraVerifier_<UltraFlavor>;
diff --git a/barretenberg/cpp/src/barretenberg/vm/avm/generated/recursive_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/avm/generated/recursive_verifier.cpp
index 71518f7b6cf..d61e6d7f0be 100644
--- a/barretenberg/cpp/src/barretenberg/vm/avm/generated/recursive_verifier.cpp
+++ b/barretenberg/cpp/src/barretenberg/vm/avm/generated/recursive_verifier.cpp
@@ -48,7 +48,7 @@ template <typename Flavor>
 AvmRecursiveVerifier_<Flavor>::AggregationObject AvmRecursiveVerifier_<Flavor>::verify_proof(
     const HonkProof& proof, const std::vector<std::vector<bb::fr>>& public_inputs_vec_nt, AggregationObject agg_obj)
 {
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(builder, proof);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(builder, proof);
 
     std::vector<std::vector<FF>> public_inputs_ct;
     public_inputs_ct.reserve(public_inputs_vec_nt.size());
diff --git a/bb-pilcom/bb-pil-backend/templates/recursive_verifier.cpp.hbs b/bb-pilcom/bb-pil-backend/templates/recursive_verifier.cpp.hbs
index 80e5538a7d1..3e7d779b523 100644
--- a/bb-pilcom/bb-pil-backend/templates/recursive_verifier.cpp.hbs
+++ b/bb-pilcom/bb-pil-backend/templates/recursive_verifier.cpp.hbs
@@ -48,7 +48,7 @@ template <typename Flavor>
 {{name}}RecursiveVerifier_<Flavor>::AggregationObject {{name}}RecursiveVerifier_<Flavor>::verify_proof(
     const HonkProof& proof, const std::vector<std::vector<bb::fr>>& public_inputs_vec_nt, AggregationObject agg_obj)
 {
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(builder, proof);
+    StdlibProof<Builder> stdlib_proof = bb::convert_proof_to_witness(builder, proof);
 
     std::vector<std::vector<FF>> public_inputs_ct;
     public_inputs_ct.reserve(public_inputs_vec_nt.size());