honk_key_gen.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Completed, auditors: [Sergei], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
 
#include "barretenberg/ecc/fields/field_conversion.hpp"
#include <ostream>
#include <string>
#include <type_traits>
 
inline void output_vk_sol_ultra_honk(std::ostream& os,
                                     auto const& key,
                                     std::string const& class_name,
                                     bool include_types_import = false)
{
 
    const auto print_u256_const = [&](const auto& element, const std::string& name) {
        os << "uint256 constant " << name << " = " << element << ";" << std::endl;
    };
 
    const auto print_u256 = [&](const auto& element, const std::string& name) {
        os << "            " << name << ": uint256(" << element << ")," << std::endl;
    };
 
    const auto print_g1 = [&](const auto& element, const std::string& name, const bool last = false) {
        // Route through U256Codec so the EIP-196 canonical (0, 0) is emitted for
        // points at infinity (e.g. selectors that commit to identically-zero polys),
        // matching the proof-side transcript codec.
        const auto coords =
            bb::U256Codec::template serialize_to_fields<std::remove_cvref_t<decltype(element)>>(element);
        os << "            " << name << ": Honk.G1Point({ \n"
           << "               x: uint256(" << coords[0] << "),\n"
           << "               y: uint256(" << coords[1] << ")\n"
           << "            })";
 
        // only include comma if we are not the last element
        if (!last) {
            os << ",\n";
        } else {
            os << "\n";
        }
    };
 
    // Include the types import if working with the local test suite
    const auto print_types_import = [&]() {
        if (include_types_import) {
            os << "import { Honk } from \"../HonkTypes.sol\";\n";
        }
    };
 
    // clang-format off
    os <<
"// SPDX-License-Identifier: Apache-2.0\n"
      "// Copyright 2022 Aztec\n"
      "pragma solidity >=0.8.21;\n"
      "\n"
    "";
    print_types_import();
    print_u256_const(1 << key->log_circuit_size, "N");
    print_u256_const(key->log_circuit_size, "LOG_N");
    print_u256_const(key->num_public_inputs, "NUMBER_OF_PUBLIC_INPUTS");
    print_u256_const(key->hash(), "VK_HASH");
    os << ""
    "library " << class_name << " {\n"
      "    function loadVerificationKey() internal pure returns (Honk.VerificationKey memory) {\n"
      "        Honk.VerificationKey memory vk = Honk.VerificationKey({\n";
    print_u256(1 << key->log_circuit_size, "circuitSize");
    print_u256(key->log_circuit_size, "logCircuitSize");
    print_u256(key->num_public_inputs, "publicInputsSize");
    print_g1(key->q_l, "ql");
    print_g1(key->q_r, "qr");
    print_g1(key->q_o, "qo");
    print_g1(key->q_4, "q4");
    print_g1(key->q_m, "qm");
    print_g1(key->q_c, "qc");
    print_g1(key->q_lookup, "qLookup");
    print_g1(key->q_arith, "qArith");
    print_g1(key->q_delta_range, "qDeltaRange");
    print_g1(key->q_elliptic, "qElliptic");
    print_g1(key->q_memory, "qMemory");
    print_g1(key->q_nnf, "qNnf");
    print_g1(key->q_poseidon2_external, "qPoseidon2External");
    print_g1(key->q_poseidon2_internal, "qPoseidon2Internal");
    print_g1(key->sigma_1, "s1");
    print_g1(key->sigma_2, "s2");
    print_g1(key->sigma_3, "s3");
    print_g1(key->sigma_4, "s4");
    print_g1(key->table_1, "t1");
    print_g1(key->table_2, "t2");
    print_g1(key->table_3, "t3");
    print_g1(key->table_4, "t4");
    print_g1(key->id_1, "id1");
    print_g1(key->id_2, "id2");
    print_g1(key->id_3, "id3");
    print_g1(key->id_4, "id4");
    print_g1(key->lagrange_first, "lagrangeFirst");
    print_g1(key->lagrange_last, "lagrangeLast", /*last=*/ true);
    os <<
        "        });\n"
        "        return vk;\n"
        "    }\n"
        "}\n";
 
    os << std::flush;
}