goblin.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Planned, auditors: [], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
 
#include "barretenberg/eccvm/eccvm_flavor.hpp"
#include "barretenberg/eccvm/eccvm_prover.hpp"
#include "barretenberg/flavor/mega_flavor.hpp"
#include "barretenberg/goblin/merge_prover.hpp"
#include "barretenberg/goblin/merge_verifier.hpp"
#include "barretenberg/goblin/types.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/prover_instance.hpp"
 
namespace bb {
 
class Goblin {
    using Commitment = MegaFlavor::Commitment;
    using FF = MegaFlavor::FF;
 
  protected:
    // In AVM we only use Goblin for a single circuit whose proof is not required to be zero-knowledge. While Translator
    // will still expect to find random ops at the beginning to ensure the accumulation result remains at a fixed row we
    // opt for not adding random ops at the end of the op queue.
    bool avm_mode = false;
 
  public:
    using MegaBuilder = MegaCircuitBuilder;
    using Fr = bb::fr;
    using Transcript = NativeTranscript;
    using OpQueue = ECCOpQueue;
    using ECCVMBuilder = ECCVMFlavor::CircuitBuilder;
    using ECCVMProvingKey = ECCVMFlavor::ProvingKey;
    using TranslatorBuilder = TranslatorCircuitBuilder;
    using MergeProof = MergeProver::MergeProof;
    using ECCVMVerificationKey = ECCVMFlavor::VerificationKey;
    using TranslatorVerificationKey = TranslatorFlavor::VerificationKey;
    using MergeRecursiveVerifier = stdlib::recursion::goblin::MergeRecursiveVerifier<MegaBuilder>;
    using PairingPoints = MergeRecursiveVerifier::PairingPoints;
    using TableCommitments = MergeVerifier::TableCommitments;
    using RecursiveTableCommitments = MergeRecursiveVerifier::TableCommitments;
    using MergeCommitments = MergeVerifier::InputCommitments;
    using RecursiveMergeCommitments = MergeRecursiveVerifier::InputCommitments;
    using RecursiveCommitment = MergeRecursiveVerifier::Commitment;
    using RecursiveTranscript = MegaStdlibTranscript;
    using TranslatorInputData = TranslatorInputData_<fq>;
    using IPA_PCS = IPA<ECCVMFlavor::Curve, CONST_ECCVM_LOG_N>;
 
    std::shared_ptr<OpQueue> op_queue = std::make_shared<OpQueue>();
 
    GoblinProof goblin_proof;
 
    fq translation_batching_challenge_v;    // challenge for batching the translation polynomials
    fq evaluation_challenge_x;              // challenge for evaluating the translation polynomials
    std::shared_ptr<Transcript> transcript; // shared between ECCVM and Translator
 
    std::deque<MergeProof> merge_verification_queue; // queue of merge proofs to be verified
 
    struct VerificationKey {
        std::shared_ptr<ECCVMVerificationKey> eccvm_verification_key = std::make_shared<ECCVMVerificationKey>();
        std::shared_ptr<TranslatorVerificationKey> translator_verification_key =
            std::make_shared<TranslatorVerificationKey>();
    };
 
    Goblin(const std::shared_ptr<Transcript>& transcript = std::make_shared<Transcript>());
 
    void prove_merge(const std::shared_ptr<Transcript>& transcript = std::make_shared<Transcript>(),
                     const MergeSettings merge_settings = MergeSettings::PREPEND);
 
    void prove_eccvm();
 
    void prove_translator();
 
    GoblinProof prove();
 
    std::pair<PairingPoints, RecursiveTableCommitments> recursively_verify_merge(
        MegaBuilder& builder,
        const RecursiveMergeCommitments& merge_commitments,
        const std::shared_ptr<RecursiveTranscript>& transcript,
        const MergeSettings merge_settings = MergeSettings::PREPEND);
};
 
} // namespace bb