mock_transcript.hpp

Go to the documentation of this file.

#include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
#include "barretenberg/numeric/uint256/uint256.hpp"
#include <vector>
namespace bb {
class MockTranscript {
  public:
    // Vector of challenges sent to the verifier
    std::vector<uint256_t> challenges;
    // Vector of group elements received from the prover / sent to the verifier
    std::vector<bb::curve::Grumpkin::AffineElement> group_elements;
    // Vector of field elements received from the prover / sent to the verifier. uint256_t is used to ignore field type
    std::vector<uint256_t> field_elements;
 
    // Vector of group elements added to the hash buffer.
    std::vector<bb::curve::Grumpkin::AffineElement> hash_buffer_group_elements;
    // Vector of field elements added to the hash buffer. uint256_t is used to ignore field type
    std::vector<uint256_t> hash_buffer_field_elements;
 
    // Indices of the elements being sampled
    size_t current_challenge_index = 0;
    size_t current_field_index = 0;
    size_t current_group_index = 0;
 
    void initialize(std::vector<uint256_t> challenges_,
                    std::vector<bb::curve::Grumpkin::AffineElement> group_elements_ = {},
                    std::vector<uint256_t> field_elements_ = {})
    {
        challenges = std::move(challenges_);
        current_challenge_index = 0;
        current_field_index = 0;
        current_group_index = 0;
        group_elements = std::move(group_elements_);
        field_elements = std::move(field_elements_);
    }
    void reset_indices()
    {
        current_challenge_index = 0;
        current_field_index = 0;
        current_challenge_index = 0;
    }
    template <typename T> void send_to_verifier(const std::string&, const T& element)
    {
        // GCC breaks explicit specialization, so I have to do this
        if constexpr (std::is_same_v<bb::curve::Grumpkin::AffineElement, T>) {
 
            group_elements.push_back(element);
        } else {
            field_elements.push_back(static_cast<uint256_t>(element));
        }
    }
 
    template <typename T> void add_to_hash_buffer(const std::string&, const T& element)
    {
        // GCC breaks explicit specialization, so I have to do this
        if constexpr (std::is_same_v<bb::curve::Grumpkin::AffineElement, T>) {
            hash_buffer_group_elements.push_back(element);
        } else {
            hash_buffer_field_elements.push_back(static_cast<uint256_t>(element));
        }
    }
    template <typename T> T get_challenge(const std::string&)
    {
        // No heap overreads, please
        BB_ASSERT_LT(current_challenge_index, challenges.size());
        T result = static_cast<T>(challenges[current_challenge_index]);
        current_challenge_index++;
        return result;
    }
    template <typename T> T receive_from_prover(const std::string&)
    {
        if constexpr (std::is_same_v<bb::curve::Grumpkin::ScalarField, T> ||
                      std::is_same_v<bb::curve::Grumpkin::BaseField, T>) {
            BB_ASSERT_GT(field_elements.size(), current_field_index);
            return field_elements[current_field_index++];
        }
        if constexpr (std::is_same_v<bb::curve::Grumpkin::AffineElement, T>) {
            BB_ASSERT_GT(group_elements.size(), current_group_index);
            return group_elements[current_group_index++];
        }
    }
};
} // namespace bb