feat: stdlib::Proof

barretenberg/cpp/src/barretenberg/api/prove_tube.cpp

@@ -42,7 +42,7 @@ void prove_tube(const std::string& output_path, const std::string& vk_path)
     client_ivc_rec_verifier_output.points_accumulator.set_public();
     // The tube only calls an IPA recursive verifier once, so we can just add this IPA claim and proof
     client_ivc_rec_verifier_output.opening_claim.set_public();
-    builder->ipa_proof = convert_stdlib_proof_to_native(client_ivc_rec_verifier_output.ipa_proof);
+    builder->ipa_proof = client_ivc_rec_verifier_output.ipa_proof.get_value();
     BB_ASSERT_EQ(builder->ipa_proof.size(), IPA_PROOF_LENGTH, "IPA proof should be set.");
 
     using Prover = UltraProver_<UltraRollupFlavor>;

barretenberg/cpp/src/barretenberg/boomerang_value_detection/graph_description_ultra_recursive_verifier.test.cpp

@@ -120,7 +120,7 @@ template <typename RecursiveFlavor> class BoomerangRecursiveVerifierTest : publi
         pairing_points.P1.y.fix_witness();
         if constexpr (HasIPAAccumulator<OuterFlavor>) {
             output.ipa_claim.set_public();
-            outer_circuit.ipa_proof = convert_stdlib_proof_to_native(output.ipa_proof);
+            outer_circuit.ipa_proof = output.ipa_proof.get_value();
         }
         info("Recursive Verifier: num gates = ", outer_circuit.get_estimated_num_finalized_gates());
 

barretenberg/cpp/src/barretenberg/client_ivc/client_ivc.cpp

@@ -54,7 +54,7 @@ void ClientIVC::instantiate_stdlib_verification_queue(
         auto& [proof, vkey, type] = verification_queue.front();
 
         // Construct stdlib proof directly from the internal native queue data
-        auto stdlib_proof = bb::convert_native_proof_to_stdlib(&circuit, proof);
+        StdlibProof stdlib_proof(circuit, proof);
 
         // Use the provided stdlib vkey if present, otherwise construct one from the internal native queue
         auto stdlib_vkey =
@@ -338,7 +338,7 @@ std::shared_ptr<ClientIVC::DeciderZKProvingKey> ClientIVC::construct_hiding_circ
     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);
+    StdlibProof stdlib_proof(builder, fold_proof);
 
     // Perform recursive folding verification of the last folding proof
     FoldingRecursiveVerifier folding_verifier{

barretenberg/cpp/src/barretenberg/client_ivc/client_ivc.hpp

@@ -14,6 +14,7 @@
 #include "barretenberg/stdlib/honk_verifier/oink_recursive_verifier.hpp"
 #include "barretenberg/stdlib/honk_verifier/ultra_recursive_verifier.hpp"
 #include "barretenberg/stdlib/primitives/databus/databus.hpp"
+#include "barretenberg/stdlib/proof/proof.hpp"
 #include "barretenberg/stdlib/protogalaxy_verifier/protogalaxy_recursive_verifier.hpp"
 #include "barretenberg/ultra_honk/decider_keys.hpp"
 #include "barretenberg/ultra_honk/decider_prover.hpp"
@@ -71,6 +72,7 @@ class ClientIVC {
     using DataBusDepot = stdlib::DataBusDepot<ClientCircuit>;
     using PairingPoints = stdlib::recursion::PairingPoints<ClientCircuit>;
     using PublicPairingPoints = stdlib::PublicInputComponent<PairingPoints>;
+    using StdlibProof = stdlib::Proof<ClientCircuit>;
 
     /**
      * @brief A full proof for the IVC scheme containing a Mega proof showing correctness of the hiding circuit (which
@@ -134,7 +136,7 @@ class ClientIVC {
 
     // An entry in the stdlib verification queue
     struct StdlibVerifierInputs {
-        StdlibProof<ClientCircuit> proof; // oink or PG
+        StdlibProof proof; // oink or PG
         std::shared_ptr<RecursiveVerificationKey> honk_verification_key;
         QUEUE_TYPE type;
     };

barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/ipa_recursive.test.cpp

@@ -6,6 +6,7 @@
 #include "barretenberg/stdlib/eccvm_verifier/verifier_commitment_key.hpp"
 #include "barretenberg/stdlib/pairing_points.hpp"
 #include "barretenberg/stdlib/primitives/curves/grumpkin.hpp"
+#include "barretenberg/stdlib/proof/proof.hpp"
 #include "barretenberg/stdlib/transcript/transcript.hpp"
 #include "barretenberg/transcript/transcript.hpp"
 #include "barretenberg/ultra_honk/decider_proving_key.hpp"
@@ -25,6 +26,7 @@ class IPARecursiveTests : public CommitmentTest<NativeCurve> {
     using VK = VerifierCommitmentKey<NativeCurve>;
     using Polynomial = bb::Polynomial<Fr>;
     using Commitment = typename NativeCurve::AffineElement;
+    using StdlibProof = bb::stdlib::Proof<Builder>;
 
     using StdlibTranscript = bb::stdlib::recursion::honk::UltraStdlibTranscript;
     template <size_t log_poly_length>
@@ -64,7 +66,7 @@ class IPARecursiveTests : public CommitmentTest<NativeCurve> {
 
         // Construct stdlib verifier transcript
         auto recursive_verifier_transcript = std::make_shared<StdlibTranscript>();
-        recursive_verifier_transcript->load_proof(bb::convert_native_proof_to_stdlib(&builder, proof));
+        recursive_verifier_transcript->load_proof(StdlibProof(builder, proof));
         return { recursive_verifier_transcript, stdlib_opening_claim };
     }
     template <size_t log_poly_length> Builder build_ipa_recursive_verifier_circuit()
@@ -240,7 +242,7 @@ TEST_F(IPARecursiveTests, AccumulationAndFullRecursiveVerifier)
     // Fully recursively verify this proof to check it.
     VerifierCommitmentKey<Curve> stdlib_pcs_vkey(&root_rollup, 1UL << log_poly_length, this->vk());
     auto stdlib_verifier_transcript = std::make_shared<StdlibTranscript>();
-    stdlib_verifier_transcript->load_proof(convert_native_proof_to_stdlib(&root_rollup, ipa_proof));
+    stdlib_verifier_transcript->load_proof(StdlibProof(root_rollup, ipa_proof));
     OpeningClaim<Curve> ipa_claim;
     ipa_claim.opening_pair.challenge =
         Curve::ScalarField::create_from_u512_as_witness(&root_rollup, output_claim.opening_pair.challenge.get_value());

barretenberg/cpp/src/barretenberg/commitment_schemes_recursion/shplemini.test.cpp

@@ -10,6 +10,7 @@
 #include "barretenberg/stdlib/primitives/curves/bn254.hpp"
 #include "barretenberg/stdlib/primitives/curves/grumpkin.hpp"
 #include "barretenberg/stdlib/primitives/padding_indicator_array/padding_indicator_array.hpp"
+#include "barretenberg/stdlib/proof/proof.hpp"
 #include "barretenberg/stdlib/transcript/transcript.hpp"
 #include "barretenberg/stdlib_circuit_builders/ultra_circuit_builder.hpp"
 #include <gtest/gtest.h>
@@ -43,6 +44,7 @@ TEST(ShpleminiRecursionTest, ProveAndVerifySingle)
     using ClaimBatcher = ClaimBatcher_<Curve>;
     using ClaimBatch = ClaimBatcher::Batch;
     using MockClaimGen = MockClaimGenerator<NativeCurve>;
+    using StdlibProof = bb::stdlib::Proof<Builder>;
 
     bb::srs::init_file_crs_factory(bb::srs::bb_crs_path());
     auto run_shplemini = [](size_t log_circuit_size) {
@@ -76,8 +78,7 @@ TEST(ShpleminiRecursionTest, ProveAndVerifySingle)
             ShpleminiProver::prove(N, mock_claims.polynomial_batcher, 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->export_proof());
+        StdlibProof stdlib_proof(builder, prover_transcript->export_proof());
         auto stdlib_verifier_transcript = std::make_shared<Transcript>();
         stdlib_verifier_transcript->load_proof(stdlib_proof);
         [[maybe_unused]] auto _ = stdlib_verifier_transcript->template receive_from_prover<Fr>("Init");

barretenberg/cpp/src/barretenberg/dsl/acir_format/acir_format.cpp

@@ -36,14 +36,14 @@ template class DSLBigInts<MegaCircuitBuilder>;
 template <typename Builder>
 void handle_IPA_accumulation(Builder& builder,
                              const std::vector<OpeningClaim<stdlib::grumpkin<Builder>>>& nested_ipa_claims,
-                             const std::vector<StdlibProof<Builder>>& nested_ipa_proofs,
+                             const std::vector<stdlib::Proof<Builder>>& nested_ipa_proofs,
                              bool is_root_rollup);
 
 template <typename Builder> struct HonkRecursionConstraintsOutput {
     using PairingPoints = stdlib::recursion::PairingPoints<Builder>;
     PairingPoints points_accumulator;
     std::vector<OpeningClaim<stdlib::grumpkin<Builder>>> nested_ipa_claims;
-    std::vector<StdlibProof<Builder>> nested_ipa_proofs;
+    std::vector<stdlib::Proof<Builder>> nested_ipa_proofs;
     bool is_root_rollup = false;
 };
 
@@ -339,7 +339,7 @@ void build_constraints(Builder& builder, AcirProgram& program, const ProgramMeta
 template <typename Builder>
 void handle_IPA_accumulation(Builder& builder,
                              const std::vector<OpeningClaim<stdlib::grumpkin<Builder>>>& nested_ipa_claims,
-                             const std::vector<StdlibProof<Builder>>& nested_ipa_proofs,
+                             const std::vector<stdlib::Proof<Builder>>& nested_ipa_proofs,
                              bool is_root_rollup)
 {
     BB_ASSERT_EQ(
@@ -366,7 +366,7 @@ void handle_IPA_accumulation(Builder& builder,
                 &builder, 1 << CONST_ECCVM_LOG_N, VerifierCommitmentKey<curve::Grumpkin>(1 << CONST_ECCVM_LOG_N));
             // do full IPA verification
             auto accumulated_ipa_transcript = std::make_shared<StdlibTranscript>();
-            accumulated_ipa_transcript->load_proof(convert_native_proof_to_stdlib(&builder, ipa_proof));
+            accumulated_ipa_transcript->load_proof(stdlib::Proof<Builder>(builder, ipa_proof));
             IPA<stdlib::grumpkin<Builder>>::full_verify_recursive(
                 verifier_commitment_key, ipa_claim, accumulated_ipa_transcript);
         } else {
@@ -378,7 +378,7 @@ void handle_IPA_accumulation(Builder& builder,
         final_ipa_claim = nested_ipa_claims[0];
         // This conversion looks suspicious but there's no need to make this an output of the circuit since
         // its a proof that will be checked anyway.
-        final_ipa_proof = convert_stdlib_proof_to_native(nested_ipa_proofs[0]);
+        final_ipa_proof = nested_ipa_proofs[0].get_value();
     } else if (nested_ipa_claims.size() == 0) {
         // If we don't have any claims, we may need to inject a fake one if we're proving with
         // UltraRollupHonk, indicated by the manual setting of the honk_recursion metadata to 2.

barretenberg/cpp/src/barretenberg/dsl/acir_format/honk_recursion_constraint.cpp

@@ -16,6 +16,7 @@
 #include "barretenberg/stdlib/primitives/bigfield/constants.hpp"
 #include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp"
 #include "barretenberg/stdlib/primitives/curves/bn254.hpp"
+#include "barretenberg/stdlib/proof/proof.hpp"
 #include "proof_surgeon.hpp"
 #include "recursion_constraint.hpp"
 
@@ -248,7 +249,7 @@ HonkRecursionConstraintOutput<typename Flavor::CircuitBuilder> create_honk_recur
         key_fields.emplace_back(field);
     }
 
-    std::vector<field_ct<Builder>> proof_fields;
+    stdlib::Proof<Builder> proof_fields;
 
     // Create witness indices for the proof with public inputs reinserted
     std::vector<uint32_t> proof_indices =

barretenberg/cpp/src/barretenberg/dsl/acir_format/proof_surgeon.hpp

@@ -12,6 +12,7 @@
 #include "barretenberg/honk/proof_system/types/proof.hpp"
 #include "barretenberg/honk/types/aggregation_object_type.hpp"
 #include "barretenberg/serialize/msgpack.hpp"
+#include "barretenberg/stdlib/proof/proof.hpp"
 #include <barretenberg/common/container.hpp>
 #include <cstdint>
 
@@ -122,7 +123,7 @@ class ProofSurgeon {
      * @return std::vector<bb::fr> The corresponding public input witness indices
      */
     static std::vector<uint32_t> get_public_inputs_witness_indices_from_proof(
-        const bb::StdlibProof<bb::MegaCircuitBuilder>& proof, const size_t num_public_inputs_to_extract)
+        const bb::stdlib::Proof<bb::MegaCircuitBuilder>& proof, const size_t num_public_inputs_to_extract)
     {
         std::vector<uint32_t> public_input_witness_indices;
         public_input_witness_indices.reserve(num_public_inputs_to_extract);

barretenberg/cpp/src/barretenberg/goblin/goblin.cpp

@@ -80,7 +80,7 @@ Goblin::PairingPoints Goblin::recursively_verify_merge(
     ASSERT(!merge_verification_queue.empty());
     // Recursively verify the next merge proof in the verification queue in a FIFO manner
     const MergeProof& merge_proof = merge_verification_queue.front();
-    const StdlibProof<MegaBuilder> stdlib_merge_proof = bb::convert_native_proof_to_stdlib(&builder, merge_proof);
+    const stdlib::Proof<MegaBuilder> stdlib_merge_proof(builder, merge_proof);
 
     MergeRecursiveVerifier merge_verifier{ &builder, transcript };
     PairingPoints pairing_points = merge_verifier.verify_proof(stdlib_merge_proof, t_commitments);

barretenberg/cpp/src/barretenberg/goblin/goblin.hpp

@@ -12,6 +12,7 @@
 #include "barretenberg/flavor/mega_flavor.hpp"
 #include "barretenberg/goblin/types.hpp"
 #include "barretenberg/stdlib/merge_verifier/merge_recursive_verifier.hpp"
+#include "barretenberg/stdlib/proof/proof.hpp"
 #include "barretenberg/translator_vm/translator_circuit_builder.hpp"
 #include "barretenberg/translator_vm/translator_flavor.hpp"
 #include "barretenberg/ultra_honk/decider_proving_key.hpp"

barretenberg/cpp/src/barretenberg/honk/proof_system/types/proof.hpp

@@ -26,6 +26,5 @@ struct ECCVMProof {
     MSGPACK_FIELDS(pre_ipa_proof, ipa_proof);
 };
 template <typename Builder> using StdlibPublicInputsVector = std::vector<bb::stdlib::field_t<Builder>>;
-template <typename Builder> using StdlibProof = std::vector<bb::stdlib::field_t<Builder>>;
 
 } // namespace bb

barretenberg/cpp/src/barretenberg/stdlib/CMakeLists.txt

@@ -7,6 +7,7 @@ add_subdirectory(goblin_verifier)
 add_subdirectory(merge_verifier)
 add_subdirectory(primitives)
 add_subdirectory(honk_verifier)
+add_subdirectory(proof)
 add_subdirectory(transcript)
 add_subdirectory(translator_vm_verifier)
 add_subdirectory(protogalaxy_verifier)

barretenberg/cpp/src/barretenberg/stdlib/client_ivc_verifier/client_ivc_recursive_verifier.test.cpp

@@ -104,7 +104,7 @@ TEST_F(ClientIVCRecursionTests, ClientTubeBase)
     client_ivc_rec_verifier_output.points_accumulator.set_public();
     // The tube only calls an IPA recursive verifier once, so we can just add this IPA claim and proof
     client_ivc_rec_verifier_output.opening_claim.set_public();
-    tube_builder->ipa_proof = convert_stdlib_proof_to_native(client_ivc_rec_verifier_output.ipa_proof);
+    tube_builder->ipa_proof = client_ivc_rec_verifier_output.ipa_proof.get_value();
 
     info("ClientIVC Recursive Verifier: num prefinalized gates = ", tube_builder->num_gates);
 
@@ -128,7 +128,7 @@ TEST_F(ClientIVCRecursionTests, ClientTubeBase)
     Builder base_builder;
     auto tube_vk = std::make_shared<NativeFlavor::VerificationKey>(proving_key->proving_key);
     auto base_vk = std::make_shared<RollupFlavor::VerificationKey>(&base_builder, tube_vk);
-    auto base_tube_proof = bb::convert_native_proof_to_stdlib(&base_builder, native_tube_proof);
+    stdlib::Proof<Builder> base_tube_proof(base_builder, native_tube_proof);
     UltraRecursiveVerifier base_verifier{ &base_builder, base_vk };
     UltraRecursiveVerifierOutput<Builder> output = base_verifier.verify_proof(base_tube_proof);
     info("Tube UH Recursive Verifier: num prefinalized gates = ", base_builder.num_gates);
@@ -165,7 +165,7 @@ TEST_F(ClientIVCRecursionTests, TubeVKIndependentOfInputCircuits)
         client_ivc_rec_verifier_output.points_accumulator.set_public();
         // The tube only calls an IPA recursive verifier once, so we can just add this IPA claim and proof
         client_ivc_rec_verifier_output.opening_claim.set_public();
-        tube_builder->ipa_proof = convert_stdlib_proof_to_native(client_ivc_rec_verifier_output.ipa_proof);
+        tube_builder->ipa_proof = client_ivc_rec_verifier_output.ipa_proof.get_value();
 
         info("ClientIVC Recursive Verifier: num prefinalized gates = ", tube_builder->num_gates);
 

barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.cpp

@@ -7,6 +7,7 @@
 #include "./eccvm_recursive_verifier.hpp"
 #include "barretenberg/commitment_schemes/shplonk/shplemini.hpp"
 #include "barretenberg/commitment_schemes/shplonk/shplonk.hpp"
+#include "barretenberg/stdlib/proof/proof.hpp"
 #include "barretenberg/sumcheck/sumcheck.hpp"
 #include "barretenberg/transcript/transcript.hpp"
 
@@ -27,7 +28,7 @@ ECCVMRecursiveVerifier_<Flavor>::ECCVMRecursiveVerifier_(
  *
  */
 template <typename Flavor>
-std::pair<OpeningClaim<typename Flavor::Curve>, StdlibProof<typename ECCVMRecursiveVerifier_<Flavor>::Builder>>
+std::pair<OpeningClaim<typename Flavor::Curve>, stdlib::Proof<typename ECCVMRecursiveVerifier_<Flavor>::Builder>>
 ECCVMRecursiveVerifier_<Flavor>::verify_proof(const ECCVMProof& proof)
 {
     using Curve = typename Flavor::Curve;
@@ -40,8 +41,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> ipa_proof = bb::convert_native_proof_to_stdlib(builder, proof.ipa_proof);
+    StdlibProof stdlib_proof(*builder, proof.pre_ipa_proof);
+    StdlibProof ipa_proof(*builder, proof.ipa_proof);
     transcript->load_proof(stdlib_proof);
 
     VerifierCommitments commitments{ key };

barretenberg/cpp/src/barretenberg/stdlib/eccvm_verifier/eccvm_recursive_verifier.hpp

@@ -7,6 +7,7 @@
 #pragma once
 #include "barretenberg/goblin/translation_evaluations.hpp"
 #include "barretenberg/stdlib/eccvm_verifier/eccvm_recursive_flavor.hpp"
+#include "barretenberg/stdlib/proof/proof.hpp"
 
 namespace bb {
 template <typename Flavor> class ECCVMRecursiveVerifier_ {
@@ -22,22 +23,23 @@ template <typename Flavor> class ECCVMRecursiveVerifier_ {
     using PCS = typename Flavor::PCS;
     using Transcript = bb::BaseTranscript<bb::stdlib::recursion::honk::StdlibTranscriptParams<Builder>>;
     using VerifierCommitments = typename Flavor::VerifierCommitments;
+    using StdlibProof = bb::stdlib::Proof<Builder>;
 
   public:
     explicit ECCVMRecursiveVerifier_(Builder* builder,
                                      const std::shared_ptr<NativeVerificationKey>& native_verifier_key,
                                      const std::shared_ptr<Transcript>& transcript);
 
     // TODO(https://github.com/AztecProtocol/barretenberg/issues/991): switch recursive verifiers to StdlibProof
-    [[nodiscard("IPA claim should be accumulated")]] std::pair<OpeningClaim<Curve>, StdlibProof<Builder>> verify_proof(
+    [[nodiscard("IPA claim should be accumulated")]] std::pair<OpeningClaim<Curve>, StdlibProof> verify_proof(
         const ECCVMProof& proof);
     void compute_translation_opening_claims(const std::vector<Commitment>& translation_commitments);
 
     std::shared_ptr<VerificationKey> key;
 
     Builder* builder;
     std::shared_ptr<Transcript> transcript;
-    StdlibProof<Builder> ipa_proof;
+    StdlibProof ipa_proof;
     TranslationEvaluations_<FF> translation_evaluations;
 
     // Final ShplonkVerifier consumes an array consisting of Translation Opening Claims and a

barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.cpp

@@ -20,7 +20,7 @@ GoblinRecursiveVerifierOutput GoblinRecursiveVerifier::verify(
 {
     // Verify the final merge step
     MergeVerifier merge_verifier{ builder, transcript };
-    StdlibProof<Builder> stdlib_merge_proof = bb::convert_native_proof_to_stdlib(builder, proof.merge_proof);
+    stdlib::Proof<Builder> stdlib_merge_proof(*builder, proof.merge_proof);
     PairingPoints<Builder> merge_pairing_points = merge_verifier.verify_proof(stdlib_merge_proof, t_commitments);
 
     // Run the ECCVM recursive verifier

barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.hpp

@@ -20,7 +20,7 @@ struct GoblinRecursiveVerifierOutput {
     using PairingAccumulator = PairingPoints<Builder>;
     PairingAccumulator points_accumulator;
     OpeningClaim<Curve> opening_claim;
-    StdlibProof<Builder> ipa_proof;
+    stdlib::Proof<Builder> ipa_proof;
 };
 
 class GoblinRecursiveVerifier {

barretenberg/cpp/src/barretenberg/stdlib/goblin_verifier/goblin_recursive_verifier.test.cpp

@@ -215,7 +215,7 @@ TEST_F(GoblinRecursiveVerifierTests, ECCVMFailure)
     VerifierCommitmentKey<curve::Grumpkin> grumpkin_verifier_commitment_key(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>();
-    native_ipa_transcript->load_proof(convert_stdlib_proof_to_native(goblin_rec_verifier_output.ipa_proof));
+    native_ipa_transcript->load_proof(goblin_rec_verifier_output.ipa_proof.get_value());
 
     EXPECT_FALSE(
         IPA<curve::Grumpkin>::reduce_verify(grumpkin_verifier_commitment_key, native_claim, native_ipa_transcript));

barretenberg/cpp/src/barretenberg/stdlib/honk_verifier/decider_recursive_verifier.cpp

@@ -27,7 +27,7 @@ DeciderRecursiveVerifier_<Flavor>::PairingPoints DeciderRecursiveVerifier_<Flavo
     using ClaimBatcher = ClaimBatcher_<Curve>;
     using ClaimBatch = ClaimBatcher::Batch;
 
-    StdlibProof<Builder> stdlib_proof = bb::convert_native_proof_to_stdlib(builder, proof);
+    StdlibProof stdlib_proof(*builder, proof);
     transcript->load_proof(stdlib_proof);
 
     VerifierCommitments commitments{ accumulator->verification_key, accumulator->witness_commitments };