From 885313281c110dc47946586e590ce46504ffa6d8 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Wed, 3 Apr 2024 15:47:35 +0000 Subject: [PATCH 01/40] avm_logderivative --- .../barretenberg/vm/generated/avm_flavor.hpp | 59 +++++++++++++++++++ .../barretenberg/vm/generated/avm_prover.cpp | 34 ++++++++++- .../barretenberg/vm/generated/avm_prover.hpp | 1 + docs/package.json | 10 ++-- 4 files changed, 96 insertions(+), 8 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 0c2f9abe7f8..5814cb14c53 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -52,6 +52,16 @@ class AvmFlavor { // the unshifted and one for the shifted static constexpr size_t NUM_ALL_ENTITIES = 159; + // TODO: what for? + using GrandProductRelations = std::tuple, + perm_main_bin_relation, + perm_main_mem_a_relation, + perm_main_mem_b_relation, + perm_main_mem_c_relation, + perm_main_mem_ind_a_relation, + perm_main_mem_ind_b_relation, + perm_main_mem_ind_c_relation>; + using Relations = std::tuple, Avm_vm::avm_binary, Avm_vm::avm_main, @@ -899,6 +909,41 @@ class AvmFlavor { // The plookup wires that store plookup read data. std::array get_table_column_wires() { return {}; }; + + void compute_logderivative_inverses(const RelationParameters& relation_parameters) + { + ProverPolynomials prover_polynomials = ProverPolynomials(*this); + + // perm_main_alu_relation, + // perm_main_bin_relation, + // perm_main_mem_a_relation, + // perm_main_mem_b_relation, + // perm_main_mem_c_relation, + // perm_main_mem_ind_a_relation, + // perm_main_mem_ind_b_relation, + // perm_main_mem_ind_c_relation>; + + // One of these for each + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + + // TODO: check if this has set the inverse for each of the polys + info("Computed logderivative inverses for all relations"); + } }; using VerificationKey = VerificationKey_, VerifierCommitmentKey>; @@ -923,6 +968,20 @@ class AvmFlavor { ProverPolynomials(ProverPolynomials&& o) noexcept = default; ProverPolynomials& operator=(ProverPolynomials&& o) noexcept = default; ~ProverPolynomials() = default; + + // NOTE: copied from goblin ultra + ProverPolynomials(ProvingKey& proving_key) + { + for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key.get_all())) { + ASSERT(flavor_get_label(*this, prover_poly) == flavor_get_label(proving_key, key_poly)); + prover_poly = key_poly.share(); + } + for (auto [prover_poly, key_poly] : zip_view(this->get_shifted(), proving_key.get_to_be_shifted())) { + ASSERT(flavor_get_label(*this, prover_poly) == (flavor_get_label(proving_key, key_poly) + "_shift")); + prover_poly = key_poly.shifted(); + } + } + [[nodiscard]] size_t get_polynomial_size() const { return avm_alu_alu_sel.size(); } /** * @brief Returns the evaluations of all prover polynomials at one point on the boolean hypercube, which diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index e887045bb96..3968cf5b6b7 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -63,6 +63,35 @@ void AvmProver::execute_wire_commitments_round() } } +void AvmProver::execute_log_derivative_inverse_round() +{ + auto [beta, gamma] = transcript->template get_challenges("beta", "gamma"); + relation_parameters.beta = beta; + relation_parameters.gamma = gamma; + + // TODO: Add an implementation of this to the flavor + // We will need to compute -> the inverse for each column and add it to the proving key + // -> I think we should be able to use each of the bespoke lookup relations for this??? + // -> + // snippet is below + /** + void compute_logderivative_inverse(const RelationParameters& relation_parameters) + { + auto prover_polynomials = ProverPolynomials(*this); + // Compute permutation and lookup grand product polynomials + bb::compute_logderivative_inverse( + prover_polynomials, relation_parameters, this->circuit_size); + this->lookup_inverses = prover_polynomials.lookup_inverses; + } + */ + + key->compute_logderivative_inverses(relation_parameters); + // Add commitments for each below + // witness_commitments.lookup_inverses = commitment_key->commit(proving_key.lookup_inverses); + // transcript->send_to_verifier(domain_separator + commitment_labels.lookup_inverses, + // witness_commitments.lookup_inverses); +} + /** * @brief Run Sumcheck resulting in u = (u_1,...,u_d) challenges and all evaluations at u being calculated. * @@ -112,13 +141,12 @@ HonkProof& AvmProver::construct_proof() // Compute wire commitments execute_wire_commitments_round(); - // TODO: not implemented for codegen just yet // Compute sorted list accumulator and commitment - // execute_log_derivative_commitments_round(); + execute_log_derivative_commitments_round(); // Fiat-Shamir: bbeta & gamma // Compute grand product(s) and commitments. - // execute_grand_product_computation_round(); + execute_grand_product_computation_round(); // Fiat-Shamir: alpha // Run sumcheck subprotocol. diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp index 1e15b341e17..324373fa7cc 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp @@ -28,6 +28,7 @@ class AvmProver { void execute_preamble_round(); void execute_wire_commitments_round(); + void execute_log_derivative_inverse_round(); void execute_relation_check_rounds(); void execute_zeromorph_rounds(); diff --git a/docs/package.json b/docs/package.json index 67a53d63e89..53e11c4e588 100644 --- a/docs/package.json +++ b/docs/package.json @@ -20,10 +20,10 @@ "write-heading-ids": "docusaurus write-heading-ids" }, "dependencies": { - "@docusaurus/core": "^2.4.1", - "@docusaurus/plugin-ideal-image": "^2.4.1", - "@docusaurus/preset-classic": "^2.4.1", - "@docusaurus/theme-mermaid": "^2.4.1", + "@docusaurus/core": "^3.2.0", + "@docusaurus/plugin-ideal-image": "^3.2.0", + "@docusaurus/preset-classic": "^3.2.0", + "@docusaurus/theme-mermaid": "^3.2.0", "@mdx-js/react": "^1.6.22", "axios": "^1.4.0", "clsx": "^1.1.1", @@ -32,7 +32,7 @@ "react": "^17.0.2", "react-dom": "^17.0.2", "react-player": "^2.12.0", - "rehype-katex": "5", + "rehype-katex": "^7.0.0", "remark-math": "3" }, "devDependencies": { From abc3cba9a0af2ef325f6bc4294eb15c7d5906969 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 4 Apr 2024 18:01:25 +0000 Subject: [PATCH 02/40] temp: chall line up --- .../src/barretenberg/sumcheck/sumcheck.hpp | 1 + .../barretenberg/ultra_honk/ultra_prover.cpp | 1 + .../vm/generated/avm_circuit_builder.hpp | 12 +- .../vm/generated/avm_composer.cpp | 3 +- .../vm/generated/avm_composer.hpp | 3 +- .../barretenberg/vm/generated/avm_flavor.hpp | 222 ++++++++++- .../barretenberg/vm/generated/avm_prover.cpp | 357 ++++++++++++++++-- .../barretenberg/vm/generated/avm_prover.hpp | 1 + .../vm/generated/avm_verifier.cpp | 41 +- .../barretenberg/vm/tests/helpers.test.cpp | 37 +- 10 files changed, 622 insertions(+), 56 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp index 3e5a3461a85..2ff1721a9c8 100644 --- a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp +++ b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp @@ -122,6 +122,7 @@ template class SumcheckProver { zip_view(multivariate_evaluations.get_all(), partially_evaluated_polynomials.get_all())) { eval = poly[0]; } + info("Multivariate evaluations: {}", multivariate_evaluations.get_all().size()); transcript->send_to_verifier("Sumcheck:evaluations", multivariate_evaluations.get_all()); return { multivariate_challenge, multivariate_evaluations }; diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp index f3fc6b0e5be..76c4843d4f5 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp @@ -45,6 +45,7 @@ template void UltraProver_::execute_relation_chec std::vector gate_challenges(numeric::get_msb(circuit_size)); for (size_t idx = 0; idx < gate_challenges.size(); idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); + info("gate_challenges[", idx, "] = ", gate_challenges[idx]); } instance->gate_challenges = gate_challenges; sumcheck_output = sumcheck.prove(instance); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 2d213345427..66e4210066e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -345,6 +345,14 @@ class AvmCircuitBuilder { polys.avm_mem_val[i] = rows[i].avm_mem_val; polys.avm_mem_w_in_tag[i] = rows[i].avm_mem_w_in_tag; polys.perm_main_alu[i] = rows[i].perm_main_alu; + + polys.lookup_byte_lengths_counts[i] = rows[i].lookup_byte_lengths_counts; + polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; + polys.incl_main_tag_err_counts[i] = rows[i].incl_main_tag_err_counts; + polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; + + // TODO: check that these are calculated at circuit building time - I believe they + // are rather added at proving time, and thus can be removed polys.perm_main_bin[i] = rows[i].perm_main_bin; polys.perm_main_mem_a[i] = rows[i].perm_main_mem_a; polys.perm_main_mem_b[i] = rows[i].perm_main_mem_b; @@ -356,10 +364,6 @@ class AvmCircuitBuilder { polys.lookup_byte_operations[i] = rows[i].lookup_byte_operations; polys.incl_main_tag_err[i] = rows[i].incl_main_tag_err; polys.incl_mem_tag_err[i] = rows[i].incl_mem_tag_err; - polys.lookup_byte_lengths_counts[i] = rows[i].lookup_byte_lengths_counts; - polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; - polys.incl_main_tag_err_counts[i] = rows[i].incl_main_tag_err_counts; - polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; } polys.avm_alu_u16_r0_shift = Polynomial(polys.avm_alu_u16_r0.shifted()); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp index a95109f38ca..b11475701be 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp @@ -31,7 +31,8 @@ AvmProver AvmComposer::create_prover(CircuitConstructor& circuit_constructor) compute_witness(circuit_constructor); compute_commitment_key(circuit_constructor.get_circuit_subgroup_size()); - AvmProver output_state(proving_key, commitment_key); + // TODO: check ptrs - align with other impls + AvmProver output_state(proving_key, proving_key->commitment_key); return output_state; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp index 1c072ebdf4e..2bde94ce2fb 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp @@ -60,9 +60,10 @@ class AvmComposer { void add_table_column_selector_poly_to_proving_key(bb::polynomial& small, const std::string& tag); + // TODO: probably need to move - feels like a hack void compute_commitment_key(size_t circuit_size) { - commitment_key = std::make_shared(circuit_size); + proving_key->commitment_key = std::make_shared(circuit_size); }; }; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 5814cb14c53..54529ea5174 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -17,6 +17,10 @@ #include "barretenberg/relations/generated/avm/avm_binary.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" #include "barretenberg/relations/generated/avm/avm_mem.hpp" +#include "barretenberg/relations/generated/avm/incl_main_tag_err.hpp" +#include "barretenberg/relations/generated/avm/incl_mem_tag_err.hpp" +#include "barretenberg/relations/generated/avm/lookup_byte_lengths.hpp" +#include "barretenberg/relations/generated/avm/lookup_byte_operations.hpp" #include "barretenberg/relations/generated/avm/perm_main_alu.hpp" #include "barretenberg/relations/generated/avm/perm_main_bin.hpp" #include "barretenberg/relations/generated/avm/perm_main_mem_a.hpp" @@ -60,7 +64,11 @@ class AvmFlavor { perm_main_mem_c_relation, perm_main_mem_ind_a_relation, perm_main_mem_ind_b_relation, - perm_main_mem_ind_c_relation>; + perm_main_mem_ind_c_relation, + incl_main_tag_err_relation, + incl_mem_tag_err_relation, + lookup_byte_lengths_relation, + lookup_byte_operations_relation>; using Relations = std::tuple, Avm_vm::avm_binary, @@ -73,7 +81,11 @@ class AvmFlavor { perm_main_mem_c_relation, perm_main_mem_ind_a_relation, perm_main_mem_ind_b_relation, - perm_main_mem_ind_c_relation>; + perm_main_mem_ind_c_relation, + incl_main_tag_err_relation, + incl_mem_tag_err_relation, + lookup_byte_lengths_relation, + lookup_byte_operations_relation>; static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); @@ -387,6 +399,152 @@ class AvmFlavor { incl_main_tag_err_counts, incl_mem_tag_err_counts }; }; + + // TEMP: only return relevant witness wires, we do not need lookup inverses etc + RefVector get_wit_wires() + { + return { + avm_alu_alu_sel, + avm_alu_cf, + avm_alu_clk, + avm_alu_ff_tag, + avm_alu_ia, + avm_alu_ib, + avm_alu_ic, + avm_alu_in_tag, + avm_alu_op_add, + avm_alu_op_div, + avm_alu_op_eq, + avm_alu_op_eq_diff_inv, + avm_alu_op_mul, + avm_alu_op_not, + avm_alu_op_sub, + avm_alu_u128_tag, + avm_alu_u16_r0, + avm_alu_u16_r1, + avm_alu_u16_r10, + avm_alu_u16_r11, + avm_alu_u16_r12, + avm_alu_u16_r13, + avm_alu_u16_r14, + avm_alu_u16_r2, + avm_alu_u16_r3, + avm_alu_u16_r4, + avm_alu_u16_r5, + avm_alu_u16_r6, + avm_alu_u16_r7, + avm_alu_u16_r8, + avm_alu_u16_r9, + avm_alu_u16_tag, + avm_alu_u32_tag, + avm_alu_u64_r0, + avm_alu_u64_tag, + avm_alu_u8_r0, + avm_alu_u8_r1, + avm_alu_u8_tag, + avm_binary_acc_ia, + avm_binary_acc_ib, + avm_binary_acc_ic, + avm_binary_bin_sel, + avm_binary_clk, + avm_binary_ia_bytes, + avm_binary_ib_bytes, + avm_binary_ic_bytes, + avm_binary_in_tag, + avm_binary_mem_tag_ctr, + avm_binary_mem_tag_ctr_inv, + avm_binary_op_id, + avm_binary_start, + avm_byte_lookup_bin_sel, + avm_byte_lookup_table_byte_lengths, + avm_byte_lookup_table_in_tags, + avm_byte_lookup_table_input_a, + avm_byte_lookup_table_input_b, + avm_byte_lookup_table_op_id, + avm_byte_lookup_table_output, + avm_main_alu_sel, + avm_main_bin_op_id, + avm_main_bin_sel, + avm_main_ia, + avm_main_ib, + avm_main_ic, + avm_main_ind_a, + avm_main_ind_b, + avm_main_ind_c, + avm_main_ind_op_a, + avm_main_ind_op_b, + avm_main_ind_op_c, + avm_main_internal_return_ptr, + avm_main_inv, + avm_main_last, + avm_main_mem_idx_a, + avm_main_mem_idx_b, + avm_main_mem_idx_c, + avm_main_mem_op_a, + avm_main_mem_op_b, + avm_main_mem_op_c, + avm_main_op_err, + avm_main_pc, + avm_main_r_in_tag, + avm_main_rwa, + avm_main_rwb, + avm_main_rwc, + avm_main_sel_halt, + avm_main_sel_internal_call, + avm_main_sel_internal_return, + avm_main_sel_jump, + avm_main_sel_mov, + avm_main_sel_op_add, + avm_main_sel_op_and, + avm_main_sel_op_div, + avm_main_sel_op_eq, + avm_main_sel_op_mul, + avm_main_sel_op_not, + avm_main_sel_op_or, + avm_main_sel_op_sub, + avm_main_sel_op_xor, + avm_main_sel_rng_16, + avm_main_sel_rng_8, + avm_main_tag_err, + avm_main_w_in_tag, + avm_mem_addr, + avm_mem_clk, + avm_mem_ind_op_a, + avm_mem_ind_op_b, + avm_mem_ind_op_c, + avm_mem_last, + avm_mem_lastAccess, + avm_mem_one_min_inv, + avm_mem_op_a, + avm_mem_op_b, + avm_mem_op_c, + avm_mem_r_in_tag, + avm_mem_rw, + avm_mem_sel_mov, + avm_mem_sub_clk, + avm_mem_tag, + avm_mem_tag_err, + avm_mem_val, + avm_mem_w_in_tag, + // perm_main_alu, + // perm_main_bin, + // perm_main_mem_a, + // perm_main_mem_b, + // perm_main_mem_c, + // perm_main_mem_ind_a, + // perm_main_mem_ind_b, + // perm_main_mem_ind_c, + // lookup_byte_lengths, + // lookup_byte_operations, + // incl_main_tag_err, + // incl_mem_tag_err, + // lookup_byte_lengths_counts, + // lookup_byte_operations_counts, + // incl_main_tag_err_counts, + // incl_mem_tag_err_counts + }; + }; + RefVector get_sorted_polynomials() { return {}; }; }; @@ -924,21 +1082,29 @@ class AvmFlavor { // perm_main_mem_ind_c_relation>; // One of these for each - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); // TODO: check if this has set the inverse for each of the polys @@ -946,7 +1112,30 @@ class AvmFlavor { } }; - using VerificationKey = VerificationKey_, VerifierCommitmentKey>; + // TODO: altered this to be a class + // using VerificationKey = VerificationKey_, VerifierCommitmentKey>; + class VerificationKey : public VerificationKey_, VerifierCommitmentKey> { + public: + VerificationKey() = default; + VerificationKey(const size_t circuit_size, const size_t num_public_inputs) + : VerificationKey_(circuit_size, num_public_inputs) + {} + + VerificationKey(ProvingKey& proving_key) + { + this->pcs_verification_key = std::make_shared(); + this->circuit_size = proving_key.circuit_size; + this->log_circuit_size = numeric::get_msb(this->circuit_size); + this->num_public_inputs = proving_key.num_public_inputs; + + // TODO(md): we shouldnt have this + this->pub_inputs_offset = proving_key.pub_inputs_offset; + + for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) { + commitment = proving_key.commitment_key->commit(polynomial); + } + } + }; using FoldedPolynomials = AllEntities>; @@ -1022,6 +1211,12 @@ class AvmFlavor { */ using ExtendedEdges = ProverUnivariates; + /** + * @brief A container for the witness commitments. + * + */ + using WitnessCommitments = WitnessEntities; + class CommitmentLabels : public AllEntities { private: using Base = AllEntities; @@ -1311,6 +1506,8 @@ class AvmFlavor { Commitment avm_mem_tag_err; Commitment avm_mem_val; Commitment avm_mem_w_in_tag; + + // Perm inverses Commitment perm_main_alu; Commitment perm_main_bin; Commitment perm_main_mem_a; @@ -1319,10 +1516,13 @@ class AvmFlavor { Commitment perm_main_mem_ind_a; Commitment perm_main_mem_ind_b; Commitment perm_main_mem_ind_c; + // Lookup inverses Commitment lookup_byte_lengths; Commitment lookup_byte_operations; Commitment incl_main_tag_err; Commitment incl_mem_tag_err; + + // Lookup counts Commitment lookup_byte_lengths_counts; Commitment lookup_byte_operations_counts; Commitment incl_main_tag_err_counts; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index 3968cf5b6b7..811e300f40e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -48,6 +48,7 @@ void AvmProver::execute_preamble_round() const auto circuit_size = static_cast(key->circuit_size); transcript->send_to_verifier("circuit_size", circuit_size); + info("Sent circuit size to verifier: ", circuit_size); } /** @@ -56,40 +57,344 @@ void AvmProver::execute_preamble_round() */ void AvmProver::execute_wire_commitments_round() { - auto wire_polys = key->get_wires(); - auto labels = commitment_labels.get_wires(); - for (size_t idx = 0; idx < wire_polys.size(); ++idx) { - transcript->send_to_verifier(labels[idx], commitment_key->commit(wire_polys[idx])); - } + // auto wire_polys = key->get_wit_wires(); + + // // TEMP: fine just using wires here and not wit wires as the indexes should still line up + // auto labels = commitment_labels.get_wires(); + // for (size_t idx = 0; idx < wire_polys.size(); ++idx) { + // info("Committing to wire ", labels[idx]); + // transcript->send_to_verifier(labels[idx], commitment_key->commit(wire_polys[idx])); + // } + + // TODO: while debugging Temporarily manually commit to each wire + // All witness commitments + // TODO: check these -> was done with a macro + auto labels = commitment_labels; + + witness_commitments.avm_alu_alu_sel = commitment_key->commit(key->avm_alu_alu_sel); + witness_commitments.avm_alu_cf = commitment_key->commit(key->avm_alu_cf); + witness_commitments.avm_alu_clk = commitment_key->commit(key->avm_alu_clk); + witness_commitments.avm_alu_ff_tag = commitment_key->commit(key->avm_alu_ff_tag); + witness_commitments.avm_alu_ia = commitment_key->commit(key->avm_alu_ia); + witness_commitments.avm_alu_ib = commitment_key->commit(key->avm_alu_ib); + witness_commitments.avm_alu_ic = commitment_key->commit(key->avm_alu_ic); + witness_commitments.avm_alu_in_tag = commitment_key->commit(key->avm_alu_in_tag); + witness_commitments.avm_alu_op_add = commitment_key->commit(key->avm_alu_op_add); + witness_commitments.avm_alu_op_div = commitment_key->commit(key->avm_alu_op_div); + witness_commitments.avm_alu_op_eq = commitment_key->commit(key->avm_alu_op_eq); + witness_commitments.avm_alu_op_eq_diff_inv = commitment_key->commit(key->avm_alu_op_eq_diff_inv); + witness_commitments.avm_alu_op_mul = commitment_key->commit(key->avm_alu_op_mul); + witness_commitments.avm_alu_op_not = commitment_key->commit(key->avm_alu_op_not); + witness_commitments.avm_alu_op_sub = commitment_key->commit(key->avm_alu_op_sub); + witness_commitments.avm_alu_u128_tag = commitment_key->commit(key->avm_alu_u128_tag); + witness_commitments.avm_alu_u16_r0 = commitment_key->commit(key->avm_alu_u16_r0); + witness_commitments.avm_alu_u16_r1 = commitment_key->commit(key->avm_alu_u16_r1); + witness_commitments.avm_alu_u16_r10 = commitment_key->commit(key->avm_alu_u16_r10); + witness_commitments.avm_alu_u16_r11 = commitment_key->commit(key->avm_alu_u16_r11); + witness_commitments.avm_alu_u16_r12 = commitment_key->commit(key->avm_alu_u16_r12); + witness_commitments.avm_alu_u16_r13 = commitment_key->commit(key->avm_alu_u16_r13); + witness_commitments.avm_alu_u16_r14 = commitment_key->commit(key->avm_alu_u16_r14); + witness_commitments.avm_alu_u16_r2 = commitment_key->commit(key->avm_alu_u16_r2); + witness_commitments.avm_alu_u16_r3 = commitment_key->commit(key->avm_alu_u16_r3); + witness_commitments.avm_alu_u16_r4 = commitment_key->commit(key->avm_alu_u16_r4); + witness_commitments.avm_alu_u16_r5 = commitment_key->commit(key->avm_alu_u16_r5); + witness_commitments.avm_alu_u16_r6 = commitment_key->commit(key->avm_alu_u16_r6); + witness_commitments.avm_alu_u16_r7 = commitment_key->commit(key->avm_alu_u16_r7); + witness_commitments.avm_alu_u16_r8 = commitment_key->commit(key->avm_alu_u16_r8); + witness_commitments.avm_alu_u16_r9 = commitment_key->commit(key->avm_alu_u16_r9); + witness_commitments.avm_alu_u16_tag = commitment_key->commit(key->avm_alu_u16_tag); + witness_commitments.avm_alu_u32_tag = commitment_key->commit(key->avm_alu_u32_tag); + witness_commitments.avm_alu_u64_r0 = commitment_key->commit(key->avm_alu_u64_r0); + witness_commitments.avm_alu_u64_tag = commitment_key->commit(key->avm_alu_u64_tag); + witness_commitments.avm_alu_u8_r0 = commitment_key->commit(key->avm_alu_u8_r0); + witness_commitments.avm_alu_u8_r1 = commitment_key->commit(key->avm_alu_u8_r1); + witness_commitments.avm_alu_u8_tag = commitment_key->commit(key->avm_alu_u8_tag); + witness_commitments.avm_binary_acc_ia = commitment_key->commit(key->avm_binary_acc_ia); + witness_commitments.avm_binary_acc_ib = commitment_key->commit(key->avm_binary_acc_ib); + witness_commitments.avm_binary_acc_ic = commitment_key->commit(key->avm_binary_acc_ic); + witness_commitments.avm_binary_bin_sel = commitment_key->commit(key->avm_binary_bin_sel); + witness_commitments.avm_binary_clk = commitment_key->commit(key->avm_binary_clk); + witness_commitments.avm_binary_ia_bytes = commitment_key->commit(key->avm_binary_ia_bytes); + witness_commitments.avm_binary_ib_bytes = commitment_key->commit(key->avm_binary_ib_bytes); + witness_commitments.avm_binary_ic_bytes = commitment_key->commit(key->avm_binary_ic_bytes); + witness_commitments.avm_binary_in_tag = commitment_key->commit(key->avm_binary_in_tag); + witness_commitments.avm_binary_mem_tag_ctr = commitment_key->commit(key->avm_binary_mem_tag_ctr); + witness_commitments.avm_binary_mem_tag_ctr_inv = commitment_key->commit(key->avm_binary_mem_tag_ctr_inv); + witness_commitments.avm_binary_op_id = commitment_key->commit(key->avm_binary_op_id); + witness_commitments.avm_binary_start = commitment_key->commit(key->avm_binary_start); + witness_commitments.avm_byte_lookup_bin_sel = commitment_key->commit(key->avm_byte_lookup_bin_sel); + witness_commitments.avm_byte_lookup_table_byte_lengths = + commitment_key->commit(key->avm_byte_lookup_table_byte_lengths); + witness_commitments.avm_byte_lookup_table_in_tags = commitment_key->commit(key->avm_byte_lookup_table_in_tags); + witness_commitments.avm_byte_lookup_table_input_a = commitment_key->commit(key->avm_byte_lookup_table_input_a); + witness_commitments.avm_byte_lookup_table_input_b = commitment_key->commit(key->avm_byte_lookup_table_input_b); + witness_commitments.avm_byte_lookup_table_op_id = commitment_key->commit(key->avm_byte_lookup_table_op_id); + witness_commitments.avm_byte_lookup_table_output = commitment_key->commit(key->avm_byte_lookup_table_output); + witness_commitments.avm_main_alu_sel = commitment_key->commit(key->avm_main_alu_sel); + witness_commitments.avm_main_bin_op_id = commitment_key->commit(key->avm_main_bin_op_id); + witness_commitments.avm_main_bin_sel = commitment_key->commit(key->avm_main_bin_sel); + witness_commitments.avm_main_ia = commitment_key->commit(key->avm_main_ia); + witness_commitments.avm_main_ib = commitment_key->commit(key->avm_main_ib); + witness_commitments.avm_main_ic = commitment_key->commit(key->avm_main_ic); + witness_commitments.avm_main_ind_a = commitment_key->commit(key->avm_main_ind_a); + witness_commitments.avm_main_ind_b = commitment_key->commit(key->avm_main_ind_b); + witness_commitments.avm_main_ind_c = commitment_key->commit(key->avm_main_ind_c); + witness_commitments.avm_main_ind_op_a = commitment_key->commit(key->avm_main_ind_op_a); + witness_commitments.avm_main_ind_op_b = commitment_key->commit(key->avm_main_ind_op_b); + witness_commitments.avm_main_ind_op_c = commitment_key->commit(key->avm_main_ind_op_c); + witness_commitments.avm_main_internal_return_ptr = commitment_key->commit(key->avm_main_internal_return_ptr); + witness_commitments.avm_main_inv = commitment_key->commit(key->avm_main_inv); + witness_commitments.avm_main_last = commitment_key->commit(key->avm_main_last); + witness_commitments.avm_main_mem_idx_a = commitment_key->commit(key->avm_main_mem_idx_a); + witness_commitments.avm_main_mem_idx_b = commitment_key->commit(key->avm_main_mem_idx_b); + witness_commitments.avm_main_mem_idx_c = commitment_key->commit(key->avm_main_mem_idx_c); + witness_commitments.avm_main_mem_op_a = commitment_key->commit(key->avm_main_mem_op_a); + witness_commitments.avm_main_mem_op_b = commitment_key->commit(key->avm_main_mem_op_b); + witness_commitments.avm_main_mem_op_c = commitment_key->commit(key->avm_main_mem_op_c); + witness_commitments.avm_main_op_err = commitment_key->commit(key->avm_main_op_err); + witness_commitments.avm_main_pc = commitment_key->commit(key->avm_main_pc); + witness_commitments.avm_main_r_in_tag = commitment_key->commit(key->avm_main_r_in_tag); + witness_commitments.avm_main_rwa = commitment_key->commit(key->avm_main_rwa); + witness_commitments.avm_main_rwb = commitment_key->commit(key->avm_main_rwb); + witness_commitments.avm_main_rwc = commitment_key->commit(key->avm_main_rwc); + witness_commitments.avm_main_sel_halt = commitment_key->commit(key->avm_main_sel_halt); + witness_commitments.avm_main_sel_internal_call = commitment_key->commit(key->avm_main_sel_internal_call); + witness_commitments.avm_main_sel_internal_return = commitment_key->commit(key->avm_main_sel_internal_return); + witness_commitments.avm_main_sel_jump = commitment_key->commit(key->avm_main_sel_jump); + witness_commitments.avm_main_sel_mov = commitment_key->commit(key->avm_main_sel_mov); + witness_commitments.avm_main_sel_op_add = commitment_key->commit(key->avm_main_sel_op_add); + witness_commitments.avm_main_sel_op_and = commitment_key->commit(key->avm_main_sel_op_and); + witness_commitments.avm_main_sel_op_div = commitment_key->commit(key->avm_main_sel_op_div); + witness_commitments.avm_main_sel_op_eq = commitment_key->commit(key->avm_main_sel_op_eq); + witness_commitments.avm_main_sel_op_mul = commitment_key->commit(key->avm_main_sel_op_mul); + witness_commitments.avm_main_sel_op_not = commitment_key->commit(key->avm_main_sel_op_not); + witness_commitments.avm_main_sel_op_or = commitment_key->commit(key->avm_main_sel_op_or); + witness_commitments.avm_main_sel_op_sub = commitment_key->commit(key->avm_main_sel_op_sub); + witness_commitments.avm_main_sel_op_xor = commitment_key->commit(key->avm_main_sel_op_xor); + witness_commitments.avm_main_sel_rng_16 = commitment_key->commit(key->avm_main_sel_rng_16); + witness_commitments.avm_main_sel_rng_8 = commitment_key->commit(key->avm_main_sel_rng_8); + witness_commitments.avm_main_tag_err = commitment_key->commit(key->avm_main_tag_err); + witness_commitments.avm_main_w_in_tag = commitment_key->commit(key->avm_main_w_in_tag); + witness_commitments.avm_mem_addr = commitment_key->commit(key->avm_mem_addr); + witness_commitments.avm_mem_clk = commitment_key->commit(key->avm_mem_clk); + witness_commitments.avm_mem_ind_op_a = commitment_key->commit(key->avm_mem_ind_op_a); + witness_commitments.avm_mem_ind_op_b = commitment_key->commit(key->avm_mem_ind_op_b); + witness_commitments.avm_mem_ind_op_c = commitment_key->commit(key->avm_mem_ind_op_c); + witness_commitments.avm_mem_last = commitment_key->commit(key->avm_mem_last); + witness_commitments.avm_mem_lastAccess = commitment_key->commit(key->avm_mem_lastAccess); + witness_commitments.avm_mem_one_min_inv = commitment_key->commit(key->avm_mem_one_min_inv); + witness_commitments.avm_mem_op_a = commitment_key->commit(key->avm_mem_op_a); + witness_commitments.avm_mem_op_b = commitment_key->commit(key->avm_mem_op_b); + witness_commitments.avm_mem_op_c = commitment_key->commit(key->avm_mem_op_c); + witness_commitments.avm_mem_r_in_tag = commitment_key->commit(key->avm_mem_r_in_tag); + witness_commitments.avm_mem_rw = commitment_key->commit(key->avm_mem_rw); + witness_commitments.avm_mem_sel_mov = commitment_key->commit(key->avm_mem_sel_mov); + witness_commitments.avm_mem_sub_clk = commitment_key->commit(key->avm_mem_sub_clk); + witness_commitments.avm_mem_tag = commitment_key->commit(key->avm_mem_tag); + witness_commitments.avm_mem_tag_err = commitment_key->commit(key->avm_mem_tag_err); + witness_commitments.avm_mem_val = commitment_key->commit(key->avm_mem_val); + witness_commitments.avm_mem_w_in_tag = commitment_key->commit(key->avm_mem_w_in_tag); + + // Lookup counts + witness_commitments.lookup_byte_lengths_counts = commitment_key->commit(key->lookup_byte_lengths_counts); + witness_commitments.lookup_byte_operations_counts = commitment_key->commit(key->lookup_byte_operations_counts); + witness_commitments.incl_main_tag_err_counts = commitment_key->commit(key->incl_main_tag_err_counts); + witness_commitments.incl_mem_tag_err_counts = commitment_key->commit(key->incl_mem_tag_err_counts); + + // print some of the commitments to check they have values + + // Send all witness commitments to the verifier + transcript->send_to_verifier(labels.avm_alu_alu_sel, witness_commitments.avm_alu_alu_sel); + transcript->send_to_verifier(labels.avm_alu_cf, witness_commitments.avm_alu_cf); + transcript->send_to_verifier(labels.avm_alu_clk, witness_commitments.avm_alu_clk); + transcript->send_to_verifier(labels.avm_alu_ff_tag, witness_commitments.avm_alu_ff_tag); + transcript->send_to_verifier(labels.avm_alu_ia, witness_commitments.avm_alu_ia); + transcript->send_to_verifier(labels.avm_alu_ib, witness_commitments.avm_alu_ib); + transcript->send_to_verifier(labels.avm_alu_ic, witness_commitments.avm_alu_ic); + transcript->send_to_verifier(labels.avm_alu_in_tag, witness_commitments.avm_alu_in_tag); + transcript->send_to_verifier(labels.avm_alu_op_add, witness_commitments.avm_alu_op_add); + transcript->send_to_verifier(labels.avm_alu_op_div, witness_commitments.avm_alu_op_div); + transcript->send_to_verifier(labels.avm_alu_op_eq, witness_commitments.avm_alu_op_eq); + transcript->send_to_verifier(labels.avm_alu_op_eq_diff_inv, witness_commitments.avm_alu_op_eq_diff_inv); + transcript->send_to_verifier(labels.avm_alu_op_mul, witness_commitments.avm_alu_op_mul); + transcript->send_to_verifier(labels.avm_alu_op_not, witness_commitments.avm_alu_op_not); + transcript->send_to_verifier(labels.avm_alu_op_sub, witness_commitments.avm_alu_op_sub); + transcript->send_to_verifier(labels.avm_alu_u128_tag, witness_commitments.avm_alu_u128_tag); + transcript->send_to_verifier(labels.avm_alu_u16_r0, witness_commitments.avm_alu_u16_r0); + transcript->send_to_verifier(labels.avm_alu_u16_r1, witness_commitments.avm_alu_u16_r1); + transcript->send_to_verifier(labels.avm_alu_u16_r10, witness_commitments.avm_alu_u16_r10); + transcript->send_to_verifier(labels.avm_alu_u16_r11, witness_commitments.avm_alu_u16_r11); + transcript->send_to_verifier(labels.avm_alu_u16_r12, witness_commitments.avm_alu_u16_r12); + transcript->send_to_verifier(labels.avm_alu_u16_r13, witness_commitments.avm_alu_u16_r13); + transcript->send_to_verifier(labels.avm_alu_u16_r14, witness_commitments.avm_alu_u16_r14); + transcript->send_to_verifier(labels.avm_alu_u16_r2, witness_commitments.avm_alu_u16_r2); + transcript->send_to_verifier(labels.avm_alu_u16_r3, witness_commitments.avm_alu_u16_r3); + transcript->send_to_verifier(labels.avm_alu_u16_r4, witness_commitments.avm_alu_u16_r4); + transcript->send_to_verifier(labels.avm_alu_u16_r5, witness_commitments.avm_alu_u16_r5); + transcript->send_to_verifier(labels.avm_alu_u16_r6, witness_commitments.avm_alu_u16_r6); + transcript->send_to_verifier(labels.avm_alu_u16_r7, witness_commitments.avm_alu_u16_r7); + transcript->send_to_verifier(labels.avm_alu_u16_r8, witness_commitments.avm_alu_u16_r8); + transcript->send_to_verifier(labels.avm_alu_u16_r9, witness_commitments.avm_alu_u16_r9); + transcript->send_to_verifier(labels.avm_alu_u16_tag, witness_commitments.avm_alu_u16_tag); + transcript->send_to_verifier(labels.avm_alu_u32_tag, witness_commitments.avm_alu_u32_tag); + transcript->send_to_verifier(labels.avm_alu_u64_r0, witness_commitments.avm_alu_u64_r0); + transcript->send_to_verifier(labels.avm_alu_u64_tag, witness_commitments.avm_alu_u64_tag); + transcript->send_to_verifier(labels.avm_alu_u8_r0, witness_commitments.avm_alu_u8_r0); + transcript->send_to_verifier(labels.avm_alu_u8_r1, witness_commitments.avm_alu_u8_r1); + transcript->send_to_verifier(labels.avm_alu_u8_tag, witness_commitments.avm_alu_u8_tag); + transcript->send_to_verifier(labels.avm_binary_acc_ia, witness_commitments.avm_binary_acc_ia); + transcript->send_to_verifier(labels.avm_binary_acc_ib, witness_commitments.avm_binary_acc_ib); + transcript->send_to_verifier(labels.avm_binary_acc_ic, witness_commitments.avm_binary_acc_ic); + transcript->send_to_verifier(labels.avm_binary_bin_sel, witness_commitments.avm_binary_bin_sel); + transcript->send_to_verifier(labels.avm_binary_clk, witness_commitments.avm_binary_clk); + transcript->send_to_verifier(labels.avm_binary_ia_bytes, witness_commitments.avm_binary_ia_bytes); + transcript->send_to_verifier(labels.avm_binary_ib_bytes, witness_commitments.avm_binary_ib_bytes); + transcript->send_to_verifier(labels.avm_binary_ic_bytes, witness_commitments.avm_binary_ic_bytes); + transcript->send_to_verifier(labels.avm_binary_in_tag, witness_commitments.avm_binary_in_tag); + transcript->send_to_verifier(labels.avm_binary_mem_tag_ctr, witness_commitments.avm_binary_mem_tag_ctr); + transcript->send_to_verifier(labels.avm_binary_mem_tag_ctr_inv, witness_commitments.avm_binary_mem_tag_ctr_inv); + transcript->send_to_verifier(labels.avm_binary_op_id, witness_commitments.avm_binary_op_id); + transcript->send_to_verifier(labels.avm_binary_start, witness_commitments.avm_binary_start); + transcript->send_to_verifier(labels.avm_byte_lookup_bin_sel, witness_commitments.avm_byte_lookup_bin_sel); + transcript->send_to_verifier(labels.avm_byte_lookup_table_byte_lengths, + witness_commitments.avm_byte_lookup_table_byte_lengths); + transcript->send_to_verifier(labels.avm_byte_lookup_table_in_tags, + witness_commitments.avm_byte_lookup_table_in_tags); + transcript->send_to_verifier(labels.avm_byte_lookup_table_input_a, + witness_commitments.avm_byte_lookup_table_input_a); + transcript->send_to_verifier(labels.avm_byte_lookup_table_input_b, + witness_commitments.avm_byte_lookup_table_input_b); + transcript->send_to_verifier(labels.avm_byte_lookup_table_op_id, witness_commitments.avm_byte_lookup_table_op_id); + transcript->send_to_verifier(labels.avm_byte_lookup_table_output, witness_commitments.avm_byte_lookup_table_output); + transcript->send_to_verifier(labels.avm_main_alu_sel, witness_commitments.avm_main_alu_sel); + transcript->send_to_verifier(labels.avm_main_bin_op_id, witness_commitments.avm_main_bin_op_id); + transcript->send_to_verifier(labels.avm_main_bin_sel, witness_commitments.avm_main_bin_sel); + transcript->send_to_verifier(labels.avm_main_ia, witness_commitments.avm_main_ia); + transcript->send_to_verifier(labels.avm_main_ib, witness_commitments.avm_main_ib); + transcript->send_to_verifier(labels.avm_main_ic, witness_commitments.avm_main_ic); + transcript->send_to_verifier(labels.avm_main_ind_a, witness_commitments.avm_main_ind_a); + transcript->send_to_verifier(labels.avm_main_ind_b, witness_commitments.avm_main_ind_b); + transcript->send_to_verifier(labels.avm_main_ind_c, witness_commitments.avm_main_ind_c); + transcript->send_to_verifier(labels.avm_main_ind_op_a, witness_commitments.avm_main_ind_op_a); + transcript->send_to_verifier(labels.avm_main_ind_op_b, witness_commitments.avm_main_ind_op_b); + transcript->send_to_verifier(labels.avm_main_ind_op_c, witness_commitments.avm_main_ind_op_c); + transcript->send_to_verifier(labels.avm_main_internal_return_ptr, witness_commitments.avm_main_internal_return_ptr); + transcript->send_to_verifier(labels.avm_main_inv, witness_commitments.avm_main_inv); + transcript->send_to_verifier(labels.avm_main_last, witness_commitments.avm_main_last); + transcript->send_to_verifier(labels.avm_main_mem_idx_a, witness_commitments.avm_main_mem_idx_a); + transcript->send_to_verifier(labels.avm_main_mem_idx_b, witness_commitments.avm_main_mem_idx_b); + transcript->send_to_verifier(labels.avm_main_mem_idx_c, witness_commitments.avm_main_mem_idx_c); + transcript->send_to_verifier(labels.avm_main_mem_op_a, witness_commitments.avm_main_mem_op_a); + transcript->send_to_verifier(labels.avm_main_mem_op_b, witness_commitments.avm_main_mem_op_b); + transcript->send_to_verifier(labels.avm_main_mem_op_c, witness_commitments.avm_main_mem_op_c); + transcript->send_to_verifier(labels.avm_main_op_err, witness_commitments.avm_main_op_err); + transcript->send_to_verifier(labels.avm_main_pc, witness_commitments.avm_main_pc); + transcript->send_to_verifier(labels.avm_main_r_in_tag, witness_commitments.avm_main_r_in_tag); + transcript->send_to_verifier(labels.avm_main_rwa, witness_commitments.avm_main_rwa); + transcript->send_to_verifier(labels.avm_main_rwb, witness_commitments.avm_main_rwb); + transcript->send_to_verifier(labels.avm_main_rwc, witness_commitments.avm_main_rwc); + transcript->send_to_verifier(labels.avm_main_sel_halt, witness_commitments.avm_main_sel_halt); + transcript->send_to_verifier(labels.avm_main_sel_internal_call, witness_commitments.avm_main_sel_internal_call); + transcript->send_to_verifier(labels.avm_main_sel_internal_return, witness_commitments.avm_main_sel_internal_return); + transcript->send_to_verifier(labels.avm_main_sel_jump, witness_commitments.avm_main_sel_jump); + transcript->send_to_verifier(labels.avm_main_sel_mov, witness_commitments.avm_main_sel_mov); + transcript->send_to_verifier(labels.avm_main_sel_op_add, witness_commitments.avm_main_sel_op_add); + transcript->send_to_verifier(labels.avm_main_sel_op_and, witness_commitments.avm_main_sel_op_and); + transcript->send_to_verifier(labels.avm_main_sel_op_div, witness_commitments.avm_main_sel_op_div); + transcript->send_to_verifier(labels.avm_main_sel_op_eq, witness_commitments.avm_main_sel_op_eq); + transcript->send_to_verifier(labels.avm_main_sel_op_mul, witness_commitments.avm_main_sel_op_mul); + transcript->send_to_verifier(labels.avm_main_sel_op_not, witness_commitments.avm_main_sel_op_not); + transcript->send_to_verifier(labels.avm_main_sel_op_or, witness_commitments.avm_main_sel_op_or); + transcript->send_to_verifier(labels.avm_main_sel_op_sub, witness_commitments.avm_main_sel_op_sub); + transcript->send_to_verifier(labels.avm_main_sel_op_xor, witness_commitments.avm_main_sel_op_xor); + transcript->send_to_verifier(labels.avm_main_sel_rng_16, witness_commitments.avm_main_sel_rng_16); + transcript->send_to_verifier(labels.avm_main_sel_rng_8, witness_commitments.avm_main_sel_rng_8); + transcript->send_to_verifier(labels.avm_main_tag_err, witness_commitments.avm_main_tag_err); + transcript->send_to_verifier(labels.avm_main_w_in_tag, witness_commitments.avm_main_w_in_tag); + transcript->send_to_verifier(labels.avm_mem_addr, witness_commitments.avm_mem_addr); + transcript->send_to_verifier(labels.avm_mem_clk, witness_commitments.avm_mem_clk); + transcript->send_to_verifier(labels.avm_mem_ind_op_a, witness_commitments.avm_mem_ind_op_a); + transcript->send_to_verifier(labels.avm_mem_ind_op_b, witness_commitments.avm_mem_ind_op_b); + transcript->send_to_verifier(labels.avm_mem_ind_op_c, witness_commitments.avm_mem_ind_op_c); + transcript->send_to_verifier(labels.avm_mem_last, witness_commitments.avm_mem_last); + transcript->send_to_verifier(labels.avm_mem_lastAccess, witness_commitments.avm_mem_lastAccess); + transcript->send_to_verifier(labels.avm_mem_one_min_inv, witness_commitments.avm_mem_one_min_inv); + transcript->send_to_verifier(labels.avm_mem_op_a, witness_commitments.avm_mem_op_a); + transcript->send_to_verifier(labels.avm_mem_op_b, witness_commitments.avm_mem_op_b); + transcript->send_to_verifier(labels.avm_mem_op_c, witness_commitments.avm_mem_op_c); + transcript->send_to_verifier(labels.avm_mem_r_in_tag, witness_commitments.avm_mem_r_in_tag); + transcript->send_to_verifier(labels.avm_mem_rw, witness_commitments.avm_mem_rw); + transcript->send_to_verifier(labels.avm_mem_sel_mov, witness_commitments.avm_mem_sel_mov); + transcript->send_to_verifier(labels.avm_mem_sub_clk, witness_commitments.avm_mem_sub_clk); + transcript->send_to_verifier(labels.avm_mem_tag, witness_commitments.avm_mem_tag); + transcript->send_to_verifier(labels.avm_mem_tag_err, witness_commitments.avm_mem_tag_err); + transcript->send_to_verifier(labels.avm_mem_val, witness_commitments.avm_mem_val); + transcript->send_to_verifier(labels.avm_mem_w_in_tag, witness_commitments.avm_mem_w_in_tag); + + // Lookup counts + transcript->send_to_verifier(labels.lookup_byte_lengths_counts, witness_commitments.lookup_byte_lengths_counts); + transcript->send_to_verifier(labels.lookup_byte_operations_counts, + witness_commitments.lookup_byte_operations_counts); + transcript->send_to_verifier(labels.incl_main_tag_err_counts, witness_commitments.incl_main_tag_err_counts); + transcript->send_to_verifier(labels.incl_mem_tag_err_counts, witness_commitments.incl_mem_tag_err_counts); + + info("sent all witness contributions to the prover manually "); } void AvmProver::execute_log_derivative_inverse_round() { auto [beta, gamma] = transcript->template get_challenges("beta", "gamma"); + + info("prover beta ", beta); + info("prover gamma ", gamma); + + auto beta_sqr = beta * beta; + auto beta_cube = beta_sqr * beta; relation_parameters.beta = beta; relation_parameters.gamma = gamma; + relation_parameters.beta_sqr = beta_sqr; + relation_parameters.beta_cube = beta_cube; // TODO: Add an implementation of this to the flavor // We will need to compute -> the inverse for each column and add it to the proving key // -> I think we should be able to use each of the bespoke lookup relations for this??? - // -> - // snippet is below - /** - void compute_logderivative_inverse(const RelationParameters& relation_parameters) - { - auto prover_polynomials = ProverPolynomials(*this); - // Compute permutation and lookup grand product polynomials - bb::compute_logderivative_inverse( - prover_polynomials, relation_parameters, this->circuit_size); - this->lookup_inverses = prover_polynomials.lookup_inverses; - } - */ key->compute_logderivative_inverses(relation_parameters); - // Add commitments for each below - // witness_commitments.lookup_inverses = commitment_key->commit(proving_key.lookup_inverses); - // transcript->send_to_verifier(domain_separator + commitment_labels.lookup_inverses, - // witness_commitments.lookup_inverses); + + // Send each computed inverse to the verifier + // TODO(md): why is it computed within the flavor and not here? seems like it could be? + + // Permutations + witness_commitments.perm_main_alu = commitment_key->commit(key->perm_main_alu); + witness_commitments.perm_main_bin = commitment_key->commit(key->perm_main_bin); + witness_commitments.perm_main_mem_a = commitment_key->commit(key->perm_main_mem_a); + witness_commitments.perm_main_mem_b = commitment_key->commit(key->perm_main_mem_b); + witness_commitments.perm_main_mem_c = commitment_key->commit(key->perm_main_mem_c); + witness_commitments.perm_main_mem_ind_a = commitment_key->commit(key->perm_main_mem_ind_a); + witness_commitments.perm_main_mem_ind_b = commitment_key->commit(key->perm_main_mem_ind_b); + witness_commitments.perm_main_mem_ind_c = commitment_key->commit(key->perm_main_mem_ind_c); + // Lookups + witness_commitments.incl_main_tag_err = commitment_key->commit(key->incl_main_tag_err); + witness_commitments.incl_mem_tag_err = commitment_key->commit(key->incl_mem_tag_err); + witness_commitments.lookup_byte_lengths = commitment_key->commit(key->lookup_byte_lengths); + witness_commitments.lookup_byte_operations = commitment_key->commit(key->lookup_byte_operations); + + // Perms + transcript->send_to_verifier(commitment_labels.perm_main_alu, witness_commitments.perm_main_alu); + transcript->send_to_verifier(commitment_labels.perm_main_bin, witness_commitments.perm_main_bin); + transcript->send_to_verifier(commitment_labels.perm_main_mem_a, witness_commitments.perm_main_mem_a); + transcript->send_to_verifier(commitment_labels.perm_main_mem_b, witness_commitments.perm_main_mem_b); + transcript->send_to_verifier(commitment_labels.perm_main_mem_c, witness_commitments.perm_main_mem_b); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_a, witness_commitments.perm_main_mem_ind_a); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_b, witness_commitments.perm_main_mem_ind_b); + transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_c, witness_commitments.perm_main_mem_ind_c); + // Lookups + transcript->send_to_verifier(commitment_labels.incl_main_tag_err, witness_commitments.incl_main_tag_err); + transcript->send_to_verifier(commitment_labels.incl_mem_tag_err, witness_commitments.incl_mem_tag_err); + transcript->send_to_verifier(commitment_labels.lookup_byte_lengths, witness_commitments.lookup_byte_lengths); + transcript->send_to_verifier(commitment_labels.lookup_byte_operations, witness_commitments.lookup_byte_operations); + + info("lookup byte operations ", witness_commitments.lookup_byte_operations); } /** @@ -98,17 +403,22 @@ void AvmProver::execute_log_derivative_inverse_round() */ void AvmProver::execute_relation_check_rounds() { + // TODO: check prover polynomials are set here + using Sumcheck = SumcheckProver; auto sumcheck = Sumcheck(key->circuit_size, transcript); FF alpha = transcript->template get_challenge("Sumcheck:alpha"); + info("get msb ", numeric::get_msb(key->circuit_size)); std::vector gate_challenges(numeric::get_msb(key->circuit_size)); for (size_t idx = 0; idx < gate_challenges.size(); idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); + info("gate chall", gate_challenges[idx]); } sumcheck_output = sumcheck.prove(prover_polynomials, relation_parameters, alpha, gate_challenges); + // info("Sumcheck output ", sumcheck_output); } /** @@ -142,11 +452,8 @@ HonkProof& AvmProver::construct_proof() execute_wire_commitments_round(); // Compute sorted list accumulator and commitment - execute_log_derivative_commitments_round(); - // Fiat-Shamir: bbeta & gamma - // Compute grand product(s) and commitments. - execute_grand_product_computation_round(); + execute_log_derivative_inverse_round(); // Fiat-Shamir: alpha // Run sumcheck subprotocol. diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp index 324373fa7cc..47e2603a9ca 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.hpp @@ -47,6 +47,7 @@ class AvmProver { ProverPolynomials prover_polynomials; CommitmentLabels commitment_labels; + typename Flavor::WitnessCommitments witness_commitments; Polynomial quotient_W; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 89676bd4a64..6e21e0e6ca3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -47,8 +47,10 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) const auto circuit_size = transcript->template receive_from_prover("circuit_size"); if (circuit_size != key->circuit_size) { + info("circuit_size does not line up: {} != {}", circuit_size, key->circuit_size); return false; } + info("circuit_size has lined up: {}", circuit_size); // Get commitments to VM wires commitments.avm_alu_alu_sel = @@ -246,6 +248,33 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) commitments.avm_mem_val = transcript->template receive_from_prover(commitment_labels.avm_mem_val); commitments.avm_mem_w_in_tag = transcript->template receive_from_prover(commitment_labels.avm_mem_w_in_tag); + + // Lookup counts + commitments.lookup_byte_lengths_counts = + transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths_counts); + commitments.lookup_byte_operations_counts = + transcript->template receive_from_prover(commitment_labels.lookup_byte_operations_counts); + commitments.incl_main_tag_err_counts = + transcript->template receive_from_prover(commitment_labels.incl_main_tag_err_counts); + commitments.incl_mem_tag_err_counts = + transcript->template receive_from_prover(commitment_labels.incl_mem_tag_err_counts); + + // TODO: Check that these all have values + + // Calculate the alpha and beta challenges - log derivative inverse round + auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); + + info("verifier beta = ", beta); + info("verifier gamma = ", gamm); + + auto beta_sqr = beta * beta; + auto beta_cube = beta_sqr * beta; + relation_parameters.beta = beta; + relation_parameters.gamma = gamm; + relation_parameters.beta_sqr = beta_sqr; + relation_parameters.beta_cube = beta_cube; + + // Permutations commitments.perm_main_alu = transcript->template receive_from_prover(commitment_labels.perm_main_alu); commitments.perm_main_bin = transcript->template receive_from_prover(commitment_labels.perm_main_bin); commitments.perm_main_mem_a = @@ -260,6 +289,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_b); commitments.perm_main_mem_ind_c = transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_c); + + // Lookups commitments.lookup_byte_lengths = transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths); commitments.lookup_byte_operations = @@ -268,14 +299,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.incl_main_tag_err); commitments.incl_mem_tag_err = transcript->template receive_from_prover(commitment_labels.incl_mem_tag_err); - commitments.lookup_byte_lengths_counts = - transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths_counts); - commitments.lookup_byte_operations_counts = - transcript->template receive_from_prover(commitment_labels.lookup_byte_operations_counts); - commitments.incl_main_tag_err_counts = - transcript->template receive_from_prover(commitment_labels.incl_main_tag_err_counts); - commitments.incl_mem_tag_err_counts = - transcript->template receive_from_prover(commitment_labels.incl_mem_tag_err_counts); // Execute Sumcheck Verifier const size_t log_circuit_size = numeric::get_msb(circuit_size); @@ -286,6 +309,7 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) auto gate_challenges = std::vector(log_circuit_size); for (size_t idx = 0; idx < log_circuit_size; idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); + info("verifier gate_challenges[", idx, "] = ", gate_challenges[idx]); } auto [multivariate_challenge, claimed_evaluations, sumcheck_verified] = @@ -293,6 +317,7 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) // If Sumcheck did not verify, return false if (sumcheck_verified.has_value() && !sumcheck_verified.value()) { + info("Sumcheck did not verify"); return false; } diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 3e5efaa4efa..978ac87f12e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -1,4 +1,25 @@ #include "avm_common.test.hpp" +#include "barretenberg/vm/generated/avm_flavor.hpp" +#include +#include + +// TODO: remove this +std::string bytes_to_hex_string(const std::vector& input) +{ + static const char characters[] = "0123456789ABCDEF"; + + // Zeroes out the buffer unnecessarily, can't be avoided for std::string. + std::string ret(input.size() * 2, 0); + + // Hack... Against the rules but avoids copying the whole buffer. + auto buf = const_cast(ret.data()); + + for (const auto& oneInputByte : input) { + *buf++ = characters[oneInputByte >> 4]; + *buf++ = characters[oneInputByte & 0x0F]; + } + return ret; +} namespace tests_avm { /** @@ -13,14 +34,18 @@ void validate_trace_proof(std::vector&& trace) EXPECT_TRUE(circuit_builder.check_circuit()); // TODO(#4944): uncomment the following lines to revive full verification - // auto composer = AvmComposer(); - // auto prover = composer.create_prover(circuit_builder); - // auto proof = prover.construct_proof(); + auto composer = AvmComposer(); + auto prover = composer.create_prover(circuit_builder); + info("batched relation partial lengh:", AvmFlavor::BATCHED_RELATION_PARTIAL_LENGTH); + auto proof = prover.construct_proof(); + info("Proof size: {}", proof.size()); + + // info("Proof ", bytes_to_hex_string(to_buffer(proof))); - // auto verifier = composer.create_verifier(circuit_builder); - // bool verified = verifier.verify_proof(proof); + auto verifier = composer.create_verifier(circuit_builder); + bool verified = verifier.verify_proof(proof); - // EXPECT_TRUE(verified); + EXPECT_TRUE(verified); // if (!verified) { // avm_trace::log_avm_trace(circuit_builder.rows, 0, 10); From 8b88dcd6c5a266c4009a1de8c1c204777cddaffe Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 5 Apr 2024 18:51:40 +0000 Subject: [PATCH 03/40] fix: degree too low for lookup relations --- .../generated/avm/incl_main_tag_err.hpp | 2 +- .../generated/avm/incl_mem_tag_err.hpp | 2 +- .../generated/avm/lookup_byte_lengths.hpp | 2 +- .../generated/avm/lookup_byte_operations.hpp | 2 +- .../src/barretenberg/sumcheck/sumcheck.hpp | 3 +- .../barretenberg/sumcheck/sumcheck_round.hpp | 2 +- .../ultra_honk/ultra_verifier.cpp | 1 - .../barretenberg/vm/generated/avm_flavor.hpp | 7 ++-- .../barretenberg/vm/generated/avm_prover.cpp | 35 +------------------ .../vm/generated/avm_verifier.cpp | 9 ----- 10 files changed, 11 insertions(+), 54 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_main_tag_err.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_main_tag_err.hpp index 01e8335fd7e..cfb4885c4b5 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_main_tag_err.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_main_tag_err.hpp @@ -60,7 +60,7 @@ class incl_main_tag_err_lookup_settings { * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed * */ - static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 2; + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; /** * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_mem_tag_err.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_mem_tag_err.hpp index 94b43658059..4055ceb7951 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_mem_tag_err.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/incl_mem_tag_err.hpp @@ -60,7 +60,7 @@ class incl_mem_tag_err_lookup_settings { * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed * */ - static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 2; + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; /** * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp index 4c5a6bd0d48..66268991c7c 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_lengths.hpp @@ -60,7 +60,7 @@ class lookup_byte_lengths_lookup_settings { * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed * */ - static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 2; + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; /** * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp index 92874d3d134..baf2995fcb8 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_byte_operations.hpp @@ -60,7 +60,7 @@ class lookup_byte_operations_lookup_settings { * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed * */ - static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 2; + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; /** * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read diff --git a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp index 2ff1721a9c8..bbf104425d6 100644 --- a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp +++ b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck.hpp @@ -103,7 +103,7 @@ template class SumcheckProver { pow_univariate.partially_evaluate(round_challenge); round.round_size = round.round_size >> 1; // TODO(#224)(Cody): Maybe partially_evaluate should do this and // release memory? // All but final round - // We operate on partially_evaluated_polynomials in place. + // We operate on partially_evaluated_polynomials in place. for (size_t round_idx = 1; round_idx < multivariate_d; round_idx++) { // Write the round univariate to the transcript round_univariate = @@ -122,7 +122,6 @@ template class SumcheckProver { zip_view(multivariate_evaluations.get_all(), partially_evaluated_polynomials.get_all())) { eval = poly[0]; } - info("Multivariate evaluations: {}", multivariate_evaluations.get_all().size()); transcript->send_to_verifier("Sumcheck:evaluations", multivariate_evaluations.get_all()); return { multivariate_challenge, multivariate_evaluations }; diff --git a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck_round.hpp b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck_round.hpp index 2a3441812d5..8360fe20f74 100644 --- a/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck_round.hpp +++ b/barretenberg/cpp/src/barretenberg/sumcheck/sumcheck_round.hpp @@ -108,7 +108,7 @@ template class SumcheckProverRound { { BB_OP_COUNT_TIME(); - // Compute the constant contribution of pow polynomials for each edge. This is the product of the partial + // Compute the constant contribution of pow polynomials for each edge. This is the product of the partial // evaluation result c_l (i.e. pow(u_0,...,u_{l-1})) where u_0,...,u_{l-1} are the verifier challenges from // previous rounds) and the elements of pow(\vec{β}) not containing β_0,..., β_l. std::vector pow_challenges(round_size >> 1); diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp index 6d5b19761b8..1d16e1c8c42 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_verifier.cpp @@ -82,7 +82,6 @@ template bool UltraVerifier_::verify_proof(const HonkP transcript); auto pcs_verified = key->pcs_verification_key->pairing_check(pairing_points[0], pairing_points[1]); return sumcheck_verified.value() && pcs_verified; - ; } template class UltraVerifier_; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 54529ea5174..6c109edd2dd 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -93,7 +93,7 @@ class AvmFlavor { // random polynomial e.g. For \sum(x) [A(x) * B(x) + C(x)] * PowZeta(X), relation length = 2 and random relation // length = 3 static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH = MAX_PARTIAL_RELATION_LENGTH + 1; - static constexpr size_t NUM_RELATIONS = std::tuple_size::value; + static constexpr size_t NUM_RELATIONS = std::tuple_size_v; template using ProtogalaxyTupleOfTuplesOfUnivariates = @@ -1126,10 +1126,10 @@ class AvmFlavor { this->pcs_verification_key = std::make_shared(); this->circuit_size = proving_key.circuit_size; this->log_circuit_size = numeric::get_msb(this->circuit_size); - this->num_public_inputs = proving_key.num_public_inputs; + // this->num_public_inputs = proving_key.num_public_inputs; // TODO(md): we shouldnt have this - this->pub_inputs_offset = proving_key.pub_inputs_offset; + // this->pub_inputs_offset = proving_key.pub_inputs_offset; for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) { commitment = proving_key.commitment_key->commit(polynomial); @@ -1211,6 +1211,7 @@ class AvmFlavor { */ using ExtendedEdges = ProverUnivariates; + // TODO: add derived entities + witness entities /** * @brief A container for the witness commitments. * diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index 811e300f40e..d456d6844a3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -48,7 +48,6 @@ void AvmProver::execute_preamble_round() const auto circuit_size = static_cast(key->circuit_size); transcript->send_to_verifier("circuit_size", circuit_size); - info("Sent circuit size to verifier: ", circuit_size); } /** @@ -57,18 +56,7 @@ void AvmProver::execute_preamble_round() */ void AvmProver::execute_wire_commitments_round() { - // auto wire_polys = key->get_wit_wires(); - - // // TEMP: fine just using wires here and not wit wires as the indexes should still line up - // auto labels = commitment_labels.get_wires(); - // for (size_t idx = 0; idx < wire_polys.size(); ++idx) { - // info("Committing to wire ", labels[idx]); - // transcript->send_to_verifier(labels[idx], commitment_key->commit(wire_polys[idx])); - // } - - // TODO: while debugging Temporarily manually commit to each wire - // All witness commitments - // TODO: check these -> was done with a macro + auto labels = commitment_labels; witness_commitments.avm_alu_alu_sel = commitment_key->commit(key->avm_alu_alu_sel); @@ -337,33 +325,17 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.lookup_byte_operations_counts); transcript->send_to_verifier(labels.incl_main_tag_err_counts, witness_commitments.incl_main_tag_err_counts); transcript->send_to_verifier(labels.incl_mem_tag_err_counts, witness_commitments.incl_mem_tag_err_counts); - - info("sent all witness contributions to the prover manually "); } void AvmProver::execute_log_derivative_inverse_round() { auto [beta, gamma] = transcript->template get_challenges("beta", "gamma"); - info("prover beta ", beta); - info("prover gamma ", gamma); - - auto beta_sqr = beta * beta; - auto beta_cube = beta_sqr * beta; relation_parameters.beta = beta; relation_parameters.gamma = gamma; - relation_parameters.beta_sqr = beta_sqr; - relation_parameters.beta_cube = beta_cube; - - // TODO: Add an implementation of this to the flavor - // We will need to compute -> the inverse for each column and add it to the proving key - // -> I think we should be able to use each of the bespoke lookup relations for this??? key->compute_logderivative_inverses(relation_parameters); - // Send each computed inverse to the verifier - // TODO(md): why is it computed within the flavor and not here? seems like it could be? - // Permutations witness_commitments.perm_main_alu = commitment_key->commit(key->perm_main_alu); witness_commitments.perm_main_bin = commitment_key->commit(key->perm_main_bin); @@ -393,8 +365,6 @@ void AvmProver::execute_log_derivative_inverse_round() transcript->send_to_verifier(commitment_labels.incl_mem_tag_err, witness_commitments.incl_mem_tag_err); transcript->send_to_verifier(commitment_labels.lookup_byte_lengths, witness_commitments.lookup_byte_lengths); transcript->send_to_verifier(commitment_labels.lookup_byte_operations, witness_commitments.lookup_byte_operations); - - info("lookup byte operations ", witness_commitments.lookup_byte_operations); } /** @@ -410,15 +380,12 @@ void AvmProver::execute_relation_check_rounds() auto sumcheck = Sumcheck(key->circuit_size, transcript); FF alpha = transcript->template get_challenge("Sumcheck:alpha"); - info("get msb ", numeric::get_msb(key->circuit_size)); std::vector gate_challenges(numeric::get_msb(key->circuit_size)); for (size_t idx = 0; idx < gate_challenges.size(); idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); - info("gate chall", gate_challenges[idx]); } sumcheck_output = sumcheck.prove(prover_polynomials, relation_parameters, alpha, gate_challenges); - // info("Sumcheck output ", sumcheck_output); } /** diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 6e21e0e6ca3..882ffbec552 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -47,10 +47,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) const auto circuit_size = transcript->template receive_from_prover("circuit_size"); if (circuit_size != key->circuit_size) { - info("circuit_size does not line up: {} != {}", circuit_size, key->circuit_size); return false; } - info("circuit_size has lined up: {}", circuit_size); // Get commitments to VM wires commitments.avm_alu_alu_sel = @@ -259,14 +257,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) commitments.incl_mem_tag_err_counts = transcript->template receive_from_prover(commitment_labels.incl_mem_tag_err_counts); - // TODO: Check that these all have values - // Calculate the alpha and beta challenges - log derivative inverse round auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); - - info("verifier beta = ", beta); - info("verifier gamma = ", gamm); - auto beta_sqr = beta * beta; auto beta_cube = beta_sqr * beta; relation_parameters.beta = beta; @@ -309,7 +301,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) auto gate_challenges = std::vector(log_circuit_size); for (size_t idx = 0; idx < log_circuit_size; idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); - info("verifier gate_challenges[", idx, "] = ", gate_challenges[idx]); } auto [multivariate_challenge, claimed_evaluations, sumcheck_verified] = From c8d9601c10e1a99252a95cd559b979af7e5e60f3 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 5 Apr 2024 18:54:27 +0000 Subject: [PATCH 04/40] chore: rename validate trace proof to check circuit, make another method for proof --- .../vm/tests/avm_arithmetic.test.cpp | 214 +++++++++--------- .../vm/tests/avm_bitwise.test.cpp | 26 +-- .../vm/tests/avm_control_flow.test.cpp | 8 +- .../vm/tests/avm_indirect_mem.test.cpp | 6 +- .../vm/tests/avm_inter_table.test.cpp | 42 ++-- .../vm/tests/avm_mem_opcodes.test.cpp | 18 +- .../barretenberg/vm/tests/avm_memory.test.cpp | 20 +- .../barretenberg/vm/tests/helpers.test.cpp | 37 +-- .../barretenberg/vm/tests/helpers.test.hpp | 1 + 9 files changed, 179 insertions(+), 193 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp index 6b4e422c891..c439cb57cd8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp @@ -334,7 +334,7 @@ TEST_F(AvmArithmeticTestsFF, addition) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over finite field type. @@ -354,7 +354,7 @@ TEST_F(AvmArithmeticTestsFF, subtraction) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); avm_trace::log_avm_trace(trace, 0, 10); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over finite field type. @@ -374,7 +374,7 @@ TEST_F(AvmArithmeticTestsFF, multiplication) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication by zero over finite field type. @@ -394,7 +394,7 @@ TEST_F(AvmArithmeticTestsFF, multiplicationByZero) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic division over finite field type. @@ -417,7 +417,7 @@ TEST_F(AvmArithmeticTestsFF, division) EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); EXPECT_EQ(row->avm_main_rwc, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on division with zero numerator over finite field type. @@ -440,7 +440,7 @@ TEST_F(AvmArithmeticTestsFF, divisionNumeratorZero) EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); EXPECT_EQ(row->avm_main_rwc, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on division by zero over finite field type. @@ -465,7 +465,7 @@ TEST_F(AvmArithmeticTestsFF, divisionByZeroError) EXPECT_EQ(row->avm_main_rwc, FF(1)); EXPECT_EQ(row->avm_main_op_err, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on division of zero by zero over finite field type. @@ -488,7 +488,7 @@ TEST_F(AvmArithmeticTestsFF, divisionZeroByZeroError) EXPECT_EQ(row->avm_main_rwc, FF(1)); EXPECT_EQ(row->avm_main_op_err, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing an execution of the different arithmetic opcodes over finite field @@ -513,7 +513,7 @@ TEST_F(AvmArithmeticTestsFF, mixedOperationsWithError) trace_builder.halt(); auto trace = trace_builder.finalize(); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test of equality on FF elements @@ -531,7 +531,7 @@ TEST_F(AvmArithmeticTestsFF, equality) EXPECT_EQ(alu_row.avm_alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); // Expect 0 as inv of (q-1) - (q-1) - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of FF elements @@ -548,7 +548,7 @@ TEST_F(AvmArithmeticTestsFF, nonEquality) EXPECT_EQ(alu_row.avm_alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-1).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -573,7 +573,7 @@ TEST_F(AvmArithmeticTestsU8, addition) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(91)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u8 type with carry. @@ -595,7 +595,7 @@ TEST_F(AvmArithmeticTestsU8, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(3)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u8 type. @@ -616,7 +616,7 @@ TEST_F(AvmArithmeticTestsU8, subtraction) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(133)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on subtraction over u8 type with carry. @@ -646,7 +646,7 @@ TEST_F(AvmArithmeticTestsU8, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u8 type. @@ -669,7 +669,7 @@ TEST_F(AvmArithmeticTestsU8, multiplication) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(195)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u8 type with overflow. @@ -693,7 +693,7 @@ TEST_F(AvmArithmeticTestsU8, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(208)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(132)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test of equality on u8 elements @@ -706,7 +706,7 @@ TEST_F(AvmArithmeticTestsU8, equality) EXPECT_EQ(alu_row.avm_alu_u8_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U8 elements @@ -719,7 +719,7 @@ TEST_F(AvmArithmeticTestsU8, nonEquality) EXPECT_EQ(alu_row.avm_alu_u8_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-116).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -745,7 +745,7 @@ TEST_F(AvmArithmeticTestsU16, addition) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0xDC)); // 34780 = 0x87DC EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0x87)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u16 type with carry. @@ -767,7 +767,7 @@ TEST_F(AvmArithmeticTestsU16, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(17)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u16 type. @@ -790,7 +790,7 @@ TEST_F(AvmArithmeticTestsU16, subtraction) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0x79)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u16 type with carry. @@ -820,7 +820,7 @@ TEST_F(AvmArithmeticTestsU16, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u16 type. @@ -845,7 +845,7 @@ TEST_F(AvmArithmeticTestsU16, multiplication) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0xBF)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u16 type with overflow. @@ -871,7 +871,7 @@ TEST_F(AvmArithmeticTestsU16, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(8)); EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test of equality on U16 elements @@ -884,7 +884,7 @@ TEST_F(AvmArithmeticTestsU16, equality) EXPECT_EQ(alu_row.avm_alu_u16_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U16 elements @@ -897,7 +897,7 @@ TEST_F(AvmArithmeticTestsU16, nonEquality) EXPECT_EQ(alu_row.avm_alu_u16_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-14'300).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -924,7 +924,7 @@ TEST_F(AvmArithmeticTestsU32, addition) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF((2234567891LLU >> 8) & UINT8_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(2234567891LLU >> 16)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u32 type with carry. @@ -946,7 +946,7 @@ TEST_F(AvmArithmeticTestsU32, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(231)); // 999 = 3 * 256 + 231 EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(3)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u32 type. @@ -972,7 +972,7 @@ TEST_F(AvmArithmeticTestsU32, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0x69F)); EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u32 type with carry. @@ -1004,7 +1004,7 @@ TEST_F(AvmArithmeticTestsU32, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u32 type. @@ -1033,7 +1033,7 @@ TEST_F(AvmArithmeticTestsU32, multiplication) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u32 type with overflow. @@ -1062,7 +1062,7 @@ TEST_F(AvmArithmeticTestsU32, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(71)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test of equality on U32 elements @@ -1076,7 +1076,7 @@ TEST_F(AvmArithmeticTestsU32, equality) EXPECT_EQ(alu_row.avm_alu_u32_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U32 elements @@ -1090,7 +1090,7 @@ TEST_F(AvmArithmeticTestsU32, nonEquality) EXPECT_EQ(alu_row.avm_alu_u32_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(1).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -1124,7 +1124,7 @@ TEST_F(AvmArithmeticTestsU64, addition) EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0x3684)); EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0x24)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u64 type with carry. @@ -1152,7 +1152,7 @@ TEST_F(AvmArithmeticTestsU64, additionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u64 type. @@ -1183,7 +1183,7 @@ TEST_F(AvmArithmeticTestsU64, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0X23)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u64 type with carry. @@ -1216,7 +1216,7 @@ TEST_F(AvmArithmeticTestsU64, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r4, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u64 type. @@ -1245,7 +1245,7 @@ TEST_F(AvmArithmeticTestsU64, multiplication) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0x7B5)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u64 type with overflow. @@ -1280,7 +1280,7 @@ TEST_F(AvmArithmeticTestsU64, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmArithmeticTestsU64, equality) @@ -1293,7 +1293,7 @@ TEST_F(AvmArithmeticTestsU64, equality) EXPECT_EQ(alu_row.avm_alu_u64_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U64 elements @@ -1307,7 +1307,7 @@ TEST_F(AvmArithmeticTestsU64, nonEquality) EXPECT_EQ(alu_row.avm_alu_u64_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0x510000).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -1350,7 +1350,7 @@ TEST_F(AvmArithmeticTestsU128, addition) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0x4444)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0x8888)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic addition over u128 type with carry. @@ -1390,7 +1390,7 @@ TEST_F(AvmArithmeticTestsU128, additionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0xFFFF)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0xFFFF)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u128 type. @@ -1432,7 +1432,7 @@ TEST_F(AvmArithmeticTestsU128, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r7, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic subtraction over u128 type with carry. @@ -1472,7 +1472,7 @@ TEST_F(AvmArithmeticTestsU128, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0x2222)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on basic multiplication over u128 type. @@ -1506,7 +1506,7 @@ TEST_F(AvmArithmeticTestsU128, multiplication) EXPECT_EQ(alu_row_second.avm_alu_u16_r1, FF(0x762C)); EXPECT_EQ(alu_row_second.avm_alu_u16_r2, FF(0xF92C)); EXPECT_EQ(alu_row_second.avm_alu_u16_r3, FF(0x1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test on multiplication over u128 type with overflow. @@ -1566,7 +1566,7 @@ TEST_F(AvmArithmeticTestsU128, multiplicationOverflow) EXPECT_EQ(alu_row_first.avm_alu_u64_r0, FF{ UINT64_MAX - 6 }); // 2^64 - 7 EXPECT_EQ(alu_row_first.avm_alu_cf, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmArithmeticTestsU128, equality) @@ -1586,7 +1586,7 @@ TEST_F(AvmArithmeticTestsU128, equality) EXPECT_EQ(alu_row.avm_alu_u128_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Test correct non-equality of U128 elements @@ -1608,7 +1608,7 @@ TEST_F(AvmArithmeticTestsU128, nonEquality) EXPECT_EQ(alu_row.avm_alu_u128_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0xdeadbeefLLU << 32).invert()); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -1640,21 +1640,21 @@ TEST_F(AvmArithmeticTestsU128, nonEquality) TEST_F(AvmArithmeticNegativeTestsFF, addition) { auto trace = gen_mutated_trace_add(FF(37), FF(4), FF(40), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_1"); } // Test on basic incorrect subtraction over finite field type. TEST_F(AvmArithmeticNegativeTestsFF, subtraction) { auto trace = gen_mutated_trace_sub(FF(17), FF(8), FF(-9), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_1"); } // Test on basic incorrect multiplication over finite field type. TEST_F(AvmArithmeticNegativeTestsFF, multiplication) { auto trace = gen_mutated_trace_mul(FF(9), FF(100), FF(9000000), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MULTIPLICATION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MULTIPLICATION_FF"); } // Test on basic incorrect division over finite field type. @@ -1670,7 +1670,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, divisionFF) auto select_row = [](Row r) { return r.avm_main_sel_op_div == FF(1); }; mutate_ic_in_trace(trace, std::move(select_row), FF(0)); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_DIVISION_FF"); } // Test where division is not by zero but an operation error is wrongly raised @@ -1693,11 +1693,11 @@ TEST_F(AvmArithmeticNegativeTestsFF, divisionNoZeroButError) trace[index].avm_main_op_err = FF(1); auto trace2 = trace; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); // Even more malicious, one makes the first relation passes by setting the inverse to zero. trace2[index].avm_main_inv = FF(0); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace2)), "SUBOP_DIVISION_ZERO_ERR2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace2)), "SUBOP_DIVISION_ZERO_ERR2"); } // Test with division by zero occurs and no error is raised (remove error flag) @@ -1716,7 +1716,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, divisionByZeroNoError) // Remove the operator error flag row->avm_main_op_err = FF(0); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_FF"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_DIVISION_FF"); } // Test with division of zero by zero occurs and no error is raised (remove error flag) @@ -1733,7 +1733,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, divisionZeroByZeroNoError) // Remove the operator error flag row->avm_main_op_err = FF(0); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_DIVISION_ZERO_ERR1"); } // Test that error flag cannot be raised for a non-relevant operation such as @@ -1754,7 +1754,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, operationWithErrorFlag) // Activate the operator error row->avm_main_op_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); trace_builder.reset(); @@ -1771,7 +1771,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, operationWithErrorFlag) // Activate the operator error row->avm_main_op_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); trace_builder.reset(); @@ -1788,14 +1788,14 @@ TEST_F(AvmArithmeticNegativeTestsFF, operationWithErrorFlag) // Activate the operator error row->avm_main_op_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "SUBOP_ERROR_RELEVANT_OP"); } // Tests a situation for field elements where a != b but c == 1; TEST_F(AvmArithmeticNegativeTestsFF, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF::modulus_minus_two, FF(0), FF(1), FF(0), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for field elements where a == b but c == 0; @@ -1803,7 +1803,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF::modulus_minus_two, FF::modulus_minus_two, FF(0), FF(0), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for field elements where c is non-boolean, i,e, c!= {0,1}; @@ -1811,7 +1811,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF::modulus_minus_two, FF::modulus_minus_two, FF(10), FF(0), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for field elements where the tag for c is not U8. @@ -1828,7 +1828,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(4); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for field elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -1837,7 +1837,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, invalidInverseDifference) // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(FF::modulus_minus_two, FF(0), FF(0), FF(5).invert(), AvmMemoryTag::FF); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** @@ -1848,42 +1848,42 @@ TEST_F(AvmArithmeticNegativeTestsFF, invalidInverseDifference) TEST_F(AvmArithmeticNegativeTestsU8, addition) { auto trace = gen_mutated_trace_add(FF(234), FF(22), FF(1), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U8. TEST_F(AvmArithmeticNegativeTestsU8, subtraction) { auto trace = gen_mutated_trace_sub(FF(100), FF(104), FF(253), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U8. TEST_F(AvmArithmeticNegativeTestsU8, multiplication) { auto trace = gen_mutated_trace_mul(FF(9), FF(100), FF(55), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MUL_COMMON_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MUL_COMMON_2"); } // Tests a situation for U8 elements where a != b but c == 1; TEST_F(AvmArithmeticNegativeTestsU8, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF(10), FF(255), FF(1), FF(0), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U8 elements where a == b but c == 0; TEST_F(AvmArithmeticNegativeTestsU8, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF(128), FF(128), FF(0), FF(0), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U8 elements where c is non-boolean, i,e, c!= {0,1}; TEST_F(AvmArithmeticNegativeTestsU8, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF(128), FF(128), FF(200), FF(0), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U8 elements where the tag for c is not U8. @@ -1896,7 +1896,7 @@ TEST_F(AvmArithmeticNegativeTestsU8, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(3); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U8 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -1904,7 +1904,7 @@ TEST_F(AvmArithmeticNegativeTestsU8, invalidInverseDifference) { // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(FF(130), FF(0), FF(0), FF(1000).invert(), AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** @@ -1915,42 +1915,42 @@ TEST_F(AvmArithmeticNegativeTestsU8, invalidInverseDifference) TEST_F(AvmArithmeticNegativeTestsU16, addition) { auto trace = gen_mutated_trace_add(FF(8234), FF(7428), FF(653), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U16. TEST_F(AvmArithmeticNegativeTestsU16, subtraction) { auto trace = gen_mutated_trace_sub(FF(100), FF(932), FF(25373), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U16. TEST_F(AvmArithmeticNegativeTestsU16, multiplication) { auto trace = gen_mutated_trace_mul(FF(8096), FF(1024), FF(1), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MUL_COMMON_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MUL_COMMON_2"); } // Tests a situation for U16 elements where a != b but c == 1; TEST_F(AvmArithmeticNegativeTestsU16, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF(10), FF(255), FF(1), FF(0), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U16 elements where a == b but c == 0; TEST_F(AvmArithmeticNegativeTestsU16, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF(128), FF(128), FF(0), FF(0), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U16 elements where c is non-boolean, i,e, c!= {0,1}; TEST_F(AvmArithmeticNegativeTestsU16, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF(128), FF(128), FF(200), FF(0), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U16 elements where the tag for c is not U8. @@ -1963,7 +1963,7 @@ TEST_F(AvmArithmeticNegativeTestsU16, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(5); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U16 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -1971,7 +1971,7 @@ TEST_F(AvmArithmeticNegativeTestsU16, invalidInverseDifference) { // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(FF(130), FF(0), FF(0), FF(1000).invert(), AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** * Negative Tests - U32 @@ -1981,35 +1981,35 @@ TEST_F(AvmArithmeticNegativeTestsU16, invalidInverseDifference) TEST_F(AvmArithmeticNegativeTestsU32, addition) { auto trace = gen_mutated_trace_add(FF(1972382341), FF(1111133221), FF(1222222222), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U32. TEST_F(AvmArithmeticNegativeTestsU32, subtraction) { auto trace = gen_mutated_trace_sub(FF(3999888777LLU), FF(UINT32_MAX), FF(2537332433LLU), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U32. TEST_F(AvmArithmeticNegativeTestsU32, multiplication) { auto trace = gen_mutated_trace_mul(FF(UINT32_MAX), FF(UINT32_MAX), FF(0), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MUL_COMMON_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MUL_COMMON_2"); } // Tests a situation for U32 elements where a != b but c == 1; TEST_F(AvmArithmeticNegativeTestsU32, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF(UINT32_MAX - 10), FF(UINT32_MAX), FF(1), FF(0), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U32 elements where a == b but c == 0; TEST_F(AvmArithmeticNegativeTestsU32, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF(73934721LLU), FF(73934721LLU), FF(0), FF(0), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U32 elements where c is non-boolean, i,e, c!= {0,1}; @@ -2017,7 +2017,7 @@ TEST_F(AvmArithmeticNegativeTestsU32, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF(623138LLU), FF(623138LLU), FF(8728342LLU), FF(0), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U32 elements where the tag for c is not U8. @@ -2030,7 +2030,7 @@ TEST_F(AvmArithmeticNegativeTestsU32, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(6); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U32 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2039,7 +2039,7 @@ TEST_F(AvmArithmeticNegativeTestsU32, invalidInverseDifference) // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(FF(74329231LLU), FF(74329231LLU), FF(0), FF(7432701LLU).invert(), AvmMemoryTag::U32); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** @@ -2051,7 +2051,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, addition) { auto trace = gen_mutated_trace_add( FF(3324236423198282341LLU), FF(999999991111133221LLU), FF(1222222222236LLU), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U64. @@ -2059,7 +2059,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, subtraction) { auto trace = gen_mutated_trace_sub(FF(399988877723434LLU), FF(UINT64_MAX), FF(25373324332342LLU), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U64. @@ -2067,7 +2067,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, multiplication) { auto trace = gen_mutated_trace_mul(FF(399988877723434LLU), FF(9998887772343LLU), FF(9283674827534LLU), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MUL_COMMON_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MUL_COMMON_2"); } // Tests a situation for U64 elements where a != b but c == 1; @@ -2075,7 +2075,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, invalidEquality) { std::vector trace = gen_mutated_trace_eq(FF(3999888777231234LLU), FF(3999882177231234LLU), FF(1), FF(0), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U64 elements where a == b but c == 0; @@ -2083,7 +2083,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, invalidInequality) { std::vector trace = gen_mutated_trace_eq(FF(9998887772343LLU), FF(73934721LLU), FF(0), FF(0), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U64 elements where c is non-boolean, i,e, c!= {0,1}; @@ -2091,7 +2091,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, nonBooleanEq) { std::vector trace = gen_mutated_trace_eq(FF(9998887772343LLU), FF(9998887772343LLU), FF(2), FF(0), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U64 elements where the tag for c is not U8. @@ -2104,7 +2104,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(2); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U64 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2113,7 +2113,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, invalidInverseDifference) // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq( FF(9998887772343LLU), FF(9998887772343LLU), FF(0), FF(0x373428).invert(), AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } /****************************************************************************** @@ -2131,7 +2131,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, addition) FF{ uint256_t::from_uint128(b) }, FF{ uint256_t::from_uint128(c) }, AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect subtraction over U128. @@ -2145,7 +2145,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, subtraction) FF{ uint256_t::from_uint128(b) }, FF{ uint256_t::from_uint128(c) }, AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_ADD_SUB_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_ADD_SUB_2"); } // Test on basic incorrect multiplication over U128. @@ -2159,7 +2159,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, multiplication) FF{ uint256_t::from_uint128(b) }, FF{ uint256_t::from_uint128(c) }, AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_MULTIPLICATION_OUT_U128"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_MULTIPLICATION_OUT_U128"); } // Tests a situation for U128 elements where a != b but c == 1; @@ -2171,7 +2171,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, invalidEquality) FF const ff_b = FF{ uint256_t::from_uint128(b) }; std::vector trace = gen_mutated_trace_eq(ff_a, ff_b, FF(1), FF(0), AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U128 elements where a == b but c == 0; @@ -2181,7 +2181,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, invalidInequality) FF const ff_a = FF{ uint256_t::from_uint128(a) }; std::vector trace = gen_mutated_trace_eq(ff_a, ff_a, FF(0), FF(0), AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } // Tests a situation for U128 elements where c is non-boolean, i,e, c!= {0,1}; @@ -2190,7 +2190,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, nonBooleanEq) uint128_t const a = (uint128_t{ 0x5555222233334444LLU } << 64) + uint128_t{ 0x88889999AAAABBBBLLU }; FF const ff_a = FF{ uint256_t::from_uint128(a) }; std::vector trace = gen_mutated_trace_eq(ff_a, ff_a, FF::modulus - FF(1), FF(0), AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_RES_IS_BOOL"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_RES_IS_BOOL"); } // Tests a situation for U128 elements where the tag for c is not U8. @@ -2203,7 +2203,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(4); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "EQ_OUTPUT_U8"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); } // Tests a situation for U128 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2213,7 +2213,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, invalidInverseDifference) FF const ff_a = FF{ uint256_t::from_uint128(a) }; // The a, b and c registers contain the correct information, only the inversion of differences is wrong. std::vector trace = gen_mutated_trace_eq(ff_a, ff_a, FF(0), FF(0x8efaddd292LLU).invert(), AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_EQ"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_EQ"); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp index 37d10a62712..13556db5d22 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp @@ -355,7 +355,7 @@ TEST_P(AvmBitwiseTestsNot, ParamTest) FF ff_a = FF(uint256_t::from_uint128(a)); FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_op_not(trace, ff_a, ff_output, FF(0), FF(1), mem_tag); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, @@ -377,7 +377,7 @@ TEST_P(AvmBitwiseTestsAnd, AllAndTest) FF ff_output = FF(uint256_t::from_uint128(output)); // EXPECT_EQ(1, 2) << "a ^ b " << (a ^ b) << '\n'; common_validate_bit_op(trace, 0, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsAnd, @@ -398,7 +398,7 @@ TEST_P(AvmBitwiseTestsOr, AllOrTest) FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_bit_op(trace, 1, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsOr, @@ -419,7 +419,7 @@ TEST_P(AvmBitwiseTestsXor, AllXorTest) FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_bit_op(trace, 2, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, @@ -481,7 +481,7 @@ TEST_P(AvmBitwiseNegativeTestsAnd, AllNegativeTests) FF ff_output = FF(uint256_t::from_uint128(output)); std::function&& select_row = [](Row r) { return r.avm_main_sel_op_and == FF(1); }; trace = gen_mutated_trace_bit(trace, std::move(select_row), ff_output, failure_mode); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), failure_string); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), failure_string); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseNegativeTests, AvmBitwiseNegativeTestsAnd, @@ -502,7 +502,7 @@ TEST_P(AvmBitwiseNegativeTestsOr, AllNegativeTests) FF ff_output = FF(uint256_t::from_uint128(output)); std::function&& select_row = [](Row r) { return r.avm_main_sel_op_or == FF(1); }; trace = gen_mutated_trace_bit(trace, std::move(select_row), ff_output, failure_mode); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), failure_string); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), failure_string); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseNegativeTests, AvmBitwiseNegativeTestsOr, @@ -522,7 +522,7 @@ TEST_P(AvmBitwiseNegativeTestsXor, AllNegativeTests) FF ff_output = FF(uint256_t::from_uint128(output)); std::function&& select_row = [](Row r) { return r.avm_main_sel_op_xor == FF(1); }; trace = gen_mutated_trace_bit(trace, std::move(select_row), ff_output, failure_mode); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), failure_string) + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), failure_string) } INSTANTIATE_TEST_SUITE_P(AvmBitwiseNegativeTests, AvmBitwiseNegativeTestsXor, @@ -553,32 +553,32 @@ TEST_F(AvmBitwiseNegativeTestsFF, UndefinedOverFF) trace.at(i).avm_alu_in_tag = FF(6); } - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_FF_NOT_XOR"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_FF_NOT_XOR"); } TEST_F(AvmBitwiseNegativeTestsU8, BitwiseNot) { std::vector trace = gen_mutated_trace_not(FF{ 1 }, FF{ 2 }, AvmMemoryTag::U8); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } TEST_F(AvmBitwiseNegativeTestsU16, BitwiseNot) { std::vector trace = gen_mutated_trace_not(FF{ 32'768 }, FF{ 8'192 }, AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } TEST_F(AvmBitwiseNegativeTestsU32, BitwiseNot) { std::vector trace = gen_mutated_trace_not(FF{ 0xdeadbeef }, FF{ 0x20020af }, AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } TEST_F(AvmBitwiseNegativeTestsU64, BitwiseNot) { std::vector trace = gen_mutated_trace_not(FF{ 0x10000000000000LLU }, FF{ 0x10000fed0100000LLU }, AvmMemoryTag::U64); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } TEST_F(AvmBitwiseNegativeTestsU128, BitwiseNot) @@ -587,6 +587,6 @@ TEST_F(AvmBitwiseNegativeTestsU128, BitwiseNot) uint128_t const b = uint128_t{ 0x300000ae921000 } << 64; std::vector trace = gen_mutated_trace_not(FF{ uint256_t::from_uint128(a) }, FF{ uint256_t::from_uint128(b) }, AvmMemoryTag::U128); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "ALU_OP_NOT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "ALU_OP_NOT"); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp index 8ac2da28f08..b721f65f5b9 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp @@ -54,7 +54,7 @@ TEST_F(AvmControlFlowTests, simpleCall) EXPECT_EQ(halt_row->avm_main_pc, FF(CALL_ADDRESS)); EXPECT_EQ(halt_row->avm_main_internal_return_ptr, FF(AvmTraceBuilder::CALLSTACK_OFFSET + 1)); } - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmControlFlowTests, simpleJump) @@ -87,7 +87,7 @@ TEST_F(AvmControlFlowTests, simpleJump) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avm_main_pc, FF(JUMP_ADDRESS)); } - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmControlFlowTests, simpleCallAndReturn) @@ -137,7 +137,7 @@ TEST_F(AvmControlFlowTests, simpleCallAndReturn) EXPECT_EQ(halt_row->avm_main_pc, FF(RETURN_ADDRESS)); } - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } TEST_F(AvmControlFlowTests, multipleCallsAndReturns) @@ -280,6 +280,6 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avm_main_pc, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp index e15356d5ae7..ab031397975 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp @@ -63,7 +63,7 @@ TEST_F(AvmIndirectMemTests, allIndirectAdd) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing a subtraction operation with direct input operands a, b, and an indirect @@ -109,7 +109,7 @@ TEST_F(AvmIndirectMemTests, indirectOutputSub) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing a multiplication operation with indirect input operand a, @@ -155,7 +155,7 @@ TEST_F(AvmIndirectMemTests, indirectInputAMul) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp index f2292cf5cac..f44e30d2fe8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_inter_table.test.cpp @@ -70,7 +70,7 @@ TEST_F(AvmInterTableTests, tagErrNotCopiedInMain) // Adjust the output in the memory trace. mem_row->avm_mem_val = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "INCL_MAIN_TAG_ERR"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "INCL_MAIN_TAG_ERR"); } /****************************************************************************** @@ -127,7 +127,7 @@ TEST_F(AvmPermMainAluNegativeTests, wrongAluOutputCopyInMain) trace.at(main_idx).avm_main_ic = 1008; trace.at(mem_idx).avm_mem_val = 1008; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIaInput) @@ -138,7 +138,7 @@ TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIaInput) trace.at(alu_idx).avm_alu_u8_r0 = 36; // 1060 % 256 = 36 trace.at(alu_idx).avm_alu_u8_r1 = 4; // 4 * 256 = 1024 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIbInput) @@ -149,7 +149,7 @@ TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluIbInput) trace.at(alu_idx).avm_alu_u8_r0 = 190; trace.at(alu_idx).avm_alu_u8_r1 = 0; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluOpSelector) @@ -160,7 +160,7 @@ TEST_F(AvmPermMainAluNegativeTests, wrongCopyToAluOpSelector) trace.at(alu_idx).avm_alu_u8_r0 = 72; trace.at(alu_idx).avm_alu_u8_r1 = 0; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } TEST_F(AvmPermMainAluNegativeTests, removeAluSelector) @@ -168,7 +168,7 @@ TEST_F(AvmPermMainAluNegativeTests, removeAluSelector) trace.at(alu_idx).avm_alu_alu_sel = 0; trace.at(alu_idx).avm_alu_op_mul = 0; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_ALU"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_ALU"); } /****************************************************************************** @@ -237,7 +237,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIaInMem) trace.at(mem_idx_a).avm_mem_val = 26; // Correct value: 21 trace.at(mem_idx_a - 1).avm_mem_val = 26; // We need to adjust the write operation beforehand (set opcode). - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongValueIbInMem) @@ -246,7 +246,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIbInMem) trace.at(mem_idx_b).avm_mem_val = 7; // Correct value: 3 trace.at(mem_idx_b - 1).avm_mem_val = 7; // We need to adjust the write operation beforehand (set opcode). - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongValueIcInMem) @@ -254,7 +254,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongValueIcInMem) executeSub(21, 3); trace.at(mem_idx_c).avm_mem_val = 17; // Correct value: 18 = 21 - 3 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } TEST_F(AvmPermMainMemNegativeTests, wrongAddressIaInMain) @@ -262,7 +262,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIaInMain) executeSub(21, 3); trace.at(main_idx).avm_main_mem_idx_a = 28; // Correct address: 52 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongAddressIbInMain) @@ -270,7 +270,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIbInMain) executeSub(21, 3); trace.at(main_idx).avm_main_mem_idx_b = 2; // Correct address: 11 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongAddressIcInMain) @@ -278,7 +278,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongAddressIcInMain) executeSub(21, 3); trace.at(main_idx).avm_main_mem_idx_c = 75; // Correct address: 55 - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } TEST_F(AvmPermMainMemNegativeTests, wrongInTagIaInMem) @@ -293,7 +293,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIaInMem) trace.at(mem_idx_a - 1).avm_mem_w_in_tag = wrong_in_tag; trace.at(mem_idx_a - 1).avm_mem_tag = wrong_in_tag; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongInTagIbInMem) @@ -308,7 +308,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIbInMem) trace.at(mem_idx_b - 1).avm_mem_w_in_tag = wrong_in_tag; trace.at(mem_idx_b - 1).avm_mem_tag = wrong_in_tag; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongInTagIcInMem) @@ -318,7 +318,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongInTagIcInMem) trace.at(mem_idx_c).avm_mem_w_in_tag = wrong_in_tag; // Correct value: AvmMemoryTag::U8 trace.at(mem_idx_c).avm_mem_tag = wrong_in_tag; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } TEST_F(AvmPermMainMemNegativeTests, wrongRwIaInMem) @@ -329,7 +329,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIaInMem) // Adjust sub_clk value trace.at(mem_idx_a).avm_mem_sub_clk = AvmMemTraceBuilder::SUB_CLK_STORE_A; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongRwIbInMem) @@ -340,7 +340,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIbInMem) // Adjust sub_clk value trace.at(mem_idx_b).avm_mem_sub_clk = AvmMemTraceBuilder::SUB_CLK_STORE_B; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongRwIcInMem) @@ -354,7 +354,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongRwIcInMem) // Adjust sub_clk value trace.at(mem_idx_c).avm_mem_sub_clk = AvmMemTraceBuilder::SUB_CLK_LOAD_C; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } TEST_F(AvmPermMainMemNegativeTests, wrongClkIaInMem) @@ -362,7 +362,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIaInMem) executeSub(87, 23); trace.at(mem_idx_a).avm_mem_clk = 11; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } TEST_F(AvmPermMainMemNegativeTests, wrongClkIbInMem) @@ -370,7 +370,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIbInMem) executeSub(87, 23); trace.at(mem_idx_b).avm_mem_clk = 21; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_B"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); } TEST_F(AvmPermMainMemNegativeTests, wrongClkIcInMem) @@ -378,7 +378,7 @@ TEST_F(AvmPermMainMemNegativeTests, wrongClkIcInMem) executeSub(87, 23); trace.at(mem_idx_c).avm_mem_clk = 7; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp index cb66a0f32b2..56af4b53c39 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp @@ -147,7 +147,7 @@ class AvmMemOpcodeTests : public ::testing::Test { Field(&Row::avm_mem_ind_op_c, 1))); } - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } }; @@ -218,7 +218,7 @@ TEST_F(AvmMemOpcodeTests, indirectMovInvalidAddressTag) Field(&Row::avm_mem_r_in_tag, static_cast(AvmMemoryTag::U32)), Field(&Row::avm_mem_ind_op_c, 1))); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } /****************************************************************************** @@ -233,7 +233,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputErrorTag) computeIndices(false); trace.at(main_idx).avm_main_tag_err = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "INCL_MEM_TAG_ERR"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "INCL_MEM_TAG_ERR"); } TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputValue) @@ -242,7 +242,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputValue) computeIndices(false); trace.at(main_idx).avm_main_ic = 233; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MOV_SAME_VALUE"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE"); } TEST_F(AvmMemOpcodeNegativeTests, indMovWrongOutputValue) @@ -251,7 +251,7 @@ TEST_F(AvmMemOpcodeNegativeTests, indMovWrongOutputValue) computeIndices(true); trace.at(main_idx).avm_main_ic = 8733; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MOV_SAME_VALUE"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE"); } // We want to test that the output tag for MOV cannot be altered. @@ -278,7 +278,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagLoadIa) trace.at(main_idx).avm_main_w_in_tag = tag_u64; trace.at(main_idx).avm_main_tag_err = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MOV_SAME_TAG"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_TAG"); } // Same as above but one tries to disable the selector of MOV opcode in @@ -304,7 +304,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagDisabledSelector) trace.at(main_idx).avm_main_w_in_tag = tag_u64; trace.at(main_idx).avm_main_tag_err = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_A"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_A"); } // Same goal as above but we alter the w_in_tag in the main trace @@ -321,7 +321,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagInMainTrace) trace.at(main_idx).avm_main_w_in_tag = tag_u64; trace.at(main_idx).avm_main_tag_err = 1; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MOV_MAIN_SAME_TAG"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_MAIN_SAME_TAG"); } // The manipulation of the tag occurs in the store operation. @@ -335,7 +335,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagMainTraceRead) trace.at(mem_c_idx).avm_mem_tag = tag_u64; trace.at(mem_c_idx).avm_mem_w_in_tag = tag_u64; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "PERM_MAIN_MEM_C"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp index a4f8ae95e1e..5a5b4659d65 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp @@ -69,7 +69,7 @@ TEST_F(AvmMemoryTests, mismatchedTagAddOperation) EXPECT_EQ(row->avm_mem_r_in_tag, FF(static_cast(AvmMemoryTag::U8))); EXPECT_EQ(row->avm_mem_tag, FF(static_cast(AvmMemoryTag::FF))); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing an equality operation with a mismatched memory tag. @@ -112,7 +112,7 @@ TEST_F(AvmMemoryTests, mismatchedTagEqOperation) EXPECT_EQ(row->avm_mem_r_in_tag, FF(static_cast(AvmMemoryTag::U32))); EXPECT_EQ(row->avm_mem_tag, FF(static_cast(AvmMemoryTag::U16))); - validate_trace_proof(std::move(trace)); + validate_trace_check_circuit(std::move(trace)); } // Testing violation that m_lastAccess is a delimiter for two different addresses @@ -143,7 +143,7 @@ TEST_F(AvmMemoryTests, mLastAccessViolation) row->avm_mem_lastAccess = FF(0); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_LAST_ACCESS_DELIMITER"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_LAST_ACCESS_DELIMITER"); } // Testing violation that a memory read operation must read the same value which was @@ -173,7 +173,7 @@ TEST_F(AvmMemoryTests, readWriteConsistencyValViolation) EXPECT_TRUE(row != trace.end()); row->avm_mem_val = FF(35); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_READ_WRITE_VAL_CONSISTENCY"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_READ_WRITE_VAL_CONSISTENCY"); } // Testing violation that memory read operation must read the same tag which was @@ -204,7 +204,7 @@ TEST_F(AvmMemoryTests, readWriteConsistencyTagViolation) row->avm_mem_tag = static_cast(AvmMemoryTag::U16); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_READ_WRITE_TAG_CONSISTENCY"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_READ_WRITE_TAG_CONSISTENCY"); } // Testing violation that a memory read at uninitialized location must have value 0. @@ -215,7 +215,7 @@ TEST_F(AvmMemoryTests, readUninitializedMemoryViolation) trace[1].avm_mem_val = 9; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_ZERO_INIT"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_ZERO_INIT"); } // Testing violation that an operation with a mismatched memory tag @@ -244,12 +244,12 @@ TEST_F(AvmMemoryTests, mismatchedTagErrorViolation) auto index = static_cast(row - trace.begin()); auto trace2 = trace; - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); // More sophisticated attempt by adapting witness "on_min_inv" to make pass the above constraint trace2[index].avm_mem_one_min_inv = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace2)), "MEM_IN_TAG_CONSISTENCY_2"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace2)), "MEM_IN_TAG_CONSISTENCY_2"); } // Testing violation that an operation with a consistent memory tag @@ -276,7 +276,7 @@ TEST_F(AvmMemoryTests, consistentTagNoErrorViolation) row->avm_mem_tag_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MEM_IN_TAG_CONSISTENCY_1"); } // Testing violation that a write operation must not set a VM error. @@ -303,7 +303,7 @@ TEST_F(AvmMemoryTests, noErrorTagWriteViolation) ASSERT_TRUE(row != trace.end()); row->avm_mem_tag_err = FF(1); - EXPECT_THROW_WITH_MESSAGE(validate_trace_proof(std::move(trace)), "NO_TAG_ERR_WRITE"); + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "NO_TAG_ERR_WRITE"); } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 978ac87f12e..b6884a49c20 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -3,25 +3,19 @@ #include #include -// TODO: remove this -std::string bytes_to_hex_string(const std::vector& input) +namespace tests_avm { +/** + * @brief Helper routine proving and verifying a proof based on the supplied trace + * + * @param trace The execution trace + */ +void validate_trace_check_circuit(std::vector&& trace) { - static const char characters[] = "0123456789ABCDEF"; - - // Zeroes out the buffer unnecessarily, can't be avoided for std::string. - std::string ret(input.size() * 2, 0); - - // Hack... Against the rules but avoids copying the whole buffer. - auto buf = const_cast(ret.data()); - - for (const auto& oneInputByte : input) { - *buf++ = characters[oneInputByte >> 4]; - *buf++ = characters[oneInputByte & 0x0F]; - } - return ret; -} + auto circuit_builder = AvmCircuitBuilder(); + circuit_builder.set_trace(std::move(trace)); + EXPECT_TRUE(circuit_builder.check_circuit()); +}; -namespace tests_avm { /** * @brief Helper routine proving and verifying a proof based on the supplied trace * @@ -33,23 +27,14 @@ void validate_trace_proof(std::vector&& trace) circuit_builder.set_trace(std::move(trace)); EXPECT_TRUE(circuit_builder.check_circuit()); - // TODO(#4944): uncomment the following lines to revive full verification auto composer = AvmComposer(); auto prover = composer.create_prover(circuit_builder); - info("batched relation partial lengh:", AvmFlavor::BATCHED_RELATION_PARTIAL_LENGTH); auto proof = prover.construct_proof(); - info("Proof size: {}", proof.size()); - - // info("Proof ", bytes_to_hex_string(to_buffer(proof))); auto verifier = composer.create_verifier(circuit_builder); bool verified = verifier.verify_proof(proof); EXPECT_TRUE(verified); - - // if (!verified) { - // avm_trace::log_avm_trace(circuit_builder.rows, 0, 10); - // } }; /** diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp index c794f7c5e13..0116ccaf538 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp @@ -16,6 +16,7 @@ using Flavor = bb::AvmFlavor; using FF = Flavor::FF; using Row = bb::AvmFullRow; +void validate_trace_check_circuit(std::vector&& trace); void validate_trace_proof(std::vector&& trace); void mutate_ic_in_trace(std::vector& trace, std::function&& selectRow, From c6959059435100a08dee1f22be1c326ef61981c9 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 5 Apr 2024 18:55:51 +0000 Subject: [PATCH 05/40] chore: remove dangling code --- .../barretenberg/vm/generated/avm_flavor.hpp | 19 ------------------- 1 file changed, 19 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 6c109edd2dd..7089601c2a3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -1072,16 +1072,6 @@ class AvmFlavor { { ProverPolynomials prover_polynomials = ProverPolynomials(*this); - // perm_main_alu_relation, - // perm_main_bin_relation, - // perm_main_mem_a_relation, - // perm_main_mem_b_relation, - // perm_main_mem_c_relation, - // perm_main_mem_ind_a_relation, - // perm_main_mem_ind_b_relation, - // perm_main_mem_ind_c_relation>; - - // One of these for each bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( @@ -1106,14 +1096,9 @@ class AvmFlavor { prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - - // TODO: check if this has set the inverse for each of the polys - info("Computed logderivative inverses for all relations"); } }; - // TODO: altered this to be a class - // using VerificationKey = VerificationKey_, VerifierCommitmentKey>; class VerificationKey : public VerificationKey_, VerifierCommitmentKey> { public: VerificationKey() = default; @@ -1126,10 +1111,6 @@ class AvmFlavor { this->pcs_verification_key = std::make_shared(); this->circuit_size = proving_key.circuit_size; this->log_circuit_size = numeric::get_msb(this->circuit_size); - // this->num_public_inputs = proving_key.num_public_inputs; - - // TODO(md): we shouldnt have this - // this->pub_inputs_offset = proving_key.pub_inputs_offset; for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) { commitment = proving_key.commitment_key->commit(polynomial); From 619175bd85f8df452d1f55cb3a786451f2b4d376 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 5 Apr 2024 19:23:56 +0000 Subject: [PATCH 06/40] chore: further cleanup --- .../barretenberg/ultra_honk/ultra_prover.cpp | 1 - .../vm/generated/avm_circuit_builder.hpp | 14 -- .../vm/generated/avm_composer.cpp | 1 - .../vm/generated/avm_composer.hpp | 1 - .../barretenberg/vm/generated/avm_flavor.hpp | 149 ------------------ .../barretenberg/vm/generated/avm_prover.cpp | 2 - .../vm/generated/avm_verifier.cpp | 4 - .../barretenberg/vm/tests/helpers.test.cpp | 2 - docs/package.json | 10 +- 9 files changed, 5 insertions(+), 179 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp index 76c4843d4f5..f3fc6b0e5be 100644 --- a/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/ultra_honk/ultra_prover.cpp @@ -45,7 +45,6 @@ template void UltraProver_::execute_relation_chec std::vector gate_challenges(numeric::get_msb(circuit_size)); for (size_t idx = 0; idx < gate_challenges.size(); idx++) { gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); - info("gate_challenges[", idx, "] = ", gate_challenges[idx]); } instance->gate_challenges = gate_challenges; sumcheck_output = sumcheck.prove(instance); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 66e4210066e..2498a690654 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -350,20 +350,6 @@ class AvmCircuitBuilder { polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; polys.incl_main_tag_err_counts[i] = rows[i].incl_main_tag_err_counts; polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; - - // TODO: check that these are calculated at circuit building time - I believe they - // are rather added at proving time, and thus can be removed - polys.perm_main_bin[i] = rows[i].perm_main_bin; - polys.perm_main_mem_a[i] = rows[i].perm_main_mem_a; - polys.perm_main_mem_b[i] = rows[i].perm_main_mem_b; - polys.perm_main_mem_c[i] = rows[i].perm_main_mem_c; - polys.perm_main_mem_ind_a[i] = rows[i].perm_main_mem_ind_a; - polys.perm_main_mem_ind_b[i] = rows[i].perm_main_mem_ind_b; - polys.perm_main_mem_ind_c[i] = rows[i].perm_main_mem_ind_c; - polys.lookup_byte_lengths[i] = rows[i].lookup_byte_lengths; - polys.lookup_byte_operations[i] = rows[i].lookup_byte_operations; - polys.incl_main_tag_err[i] = rows[i].incl_main_tag_err; - polys.incl_mem_tag_err[i] = rows[i].incl_mem_tag_err; } polys.avm_alu_u16_r0_shift = Polynomial(polys.avm_alu_u16_r0.shifted()); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp index b11475701be..d923c58c1cc 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.cpp @@ -31,7 +31,6 @@ AvmProver AvmComposer::create_prover(CircuitConstructor& circuit_constructor) compute_witness(circuit_constructor); compute_commitment_key(circuit_constructor.get_circuit_subgroup_size()); - // TODO: check ptrs - align with other impls AvmProver output_state(proving_key, proving_key->commitment_key); return output_state; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp index 2bde94ce2fb..a2f9fe68dcf 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_composer.hpp @@ -60,7 +60,6 @@ class AvmComposer { void add_table_column_selector_poly_to_proving_key(bb::polynomial& small, const std::string& tag); - // TODO: probably need to move - feels like a hack void compute_commitment_key(size_t circuit_size) { proving_key->commitment_key = std::make_shared(circuit_size); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 7089601c2a3..c2c664e1b4a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -56,7 +56,6 @@ class AvmFlavor { // the unshifted and one for the shifted static constexpr size_t NUM_ALL_ENTITIES = 159; - // TODO: what for? using GrandProductRelations = std::tuple, perm_main_bin_relation, perm_main_mem_a_relation, @@ -399,153 +398,6 @@ class AvmFlavor { incl_main_tag_err_counts, incl_mem_tag_err_counts }; }; - - // TEMP: only return relevant witness wires, we do not need lookup inverses etc - RefVector get_wit_wires() - { - return { - avm_alu_alu_sel, - avm_alu_cf, - avm_alu_clk, - avm_alu_ff_tag, - avm_alu_ia, - avm_alu_ib, - avm_alu_ic, - avm_alu_in_tag, - avm_alu_op_add, - avm_alu_op_div, - avm_alu_op_eq, - avm_alu_op_eq_diff_inv, - avm_alu_op_mul, - avm_alu_op_not, - avm_alu_op_sub, - avm_alu_u128_tag, - avm_alu_u16_r0, - avm_alu_u16_r1, - avm_alu_u16_r10, - avm_alu_u16_r11, - avm_alu_u16_r12, - avm_alu_u16_r13, - avm_alu_u16_r14, - avm_alu_u16_r2, - avm_alu_u16_r3, - avm_alu_u16_r4, - avm_alu_u16_r5, - avm_alu_u16_r6, - avm_alu_u16_r7, - avm_alu_u16_r8, - avm_alu_u16_r9, - avm_alu_u16_tag, - avm_alu_u32_tag, - avm_alu_u64_r0, - avm_alu_u64_tag, - avm_alu_u8_r0, - avm_alu_u8_r1, - avm_alu_u8_tag, - avm_binary_acc_ia, - avm_binary_acc_ib, - avm_binary_acc_ic, - avm_binary_bin_sel, - avm_binary_clk, - avm_binary_ia_bytes, - avm_binary_ib_bytes, - avm_binary_ic_bytes, - avm_binary_in_tag, - avm_binary_mem_tag_ctr, - avm_binary_mem_tag_ctr_inv, - avm_binary_op_id, - avm_binary_start, - avm_byte_lookup_bin_sel, - avm_byte_lookup_table_byte_lengths, - avm_byte_lookup_table_in_tags, - avm_byte_lookup_table_input_a, - avm_byte_lookup_table_input_b, - avm_byte_lookup_table_op_id, - avm_byte_lookup_table_output, - avm_main_alu_sel, - avm_main_bin_op_id, - avm_main_bin_sel, - avm_main_ia, - avm_main_ib, - avm_main_ic, - avm_main_ind_a, - avm_main_ind_b, - avm_main_ind_c, - avm_main_ind_op_a, - avm_main_ind_op_b, - avm_main_ind_op_c, - avm_main_internal_return_ptr, - avm_main_inv, - avm_main_last, - avm_main_mem_idx_a, - avm_main_mem_idx_b, - avm_main_mem_idx_c, - avm_main_mem_op_a, - avm_main_mem_op_b, - avm_main_mem_op_c, - avm_main_op_err, - avm_main_pc, - avm_main_r_in_tag, - avm_main_rwa, - avm_main_rwb, - avm_main_rwc, - avm_main_sel_halt, - avm_main_sel_internal_call, - avm_main_sel_internal_return, - avm_main_sel_jump, - avm_main_sel_mov, - avm_main_sel_op_add, - avm_main_sel_op_and, - avm_main_sel_op_div, - avm_main_sel_op_eq, - avm_main_sel_op_mul, - avm_main_sel_op_not, - avm_main_sel_op_or, - avm_main_sel_op_sub, - avm_main_sel_op_xor, - avm_main_sel_rng_16, - avm_main_sel_rng_8, - avm_main_tag_err, - avm_main_w_in_tag, - avm_mem_addr, - avm_mem_clk, - avm_mem_ind_op_a, - avm_mem_ind_op_b, - avm_mem_ind_op_c, - avm_mem_last, - avm_mem_lastAccess, - avm_mem_one_min_inv, - avm_mem_op_a, - avm_mem_op_b, - avm_mem_op_c, - avm_mem_r_in_tag, - avm_mem_rw, - avm_mem_sel_mov, - avm_mem_sub_clk, - avm_mem_tag, - avm_mem_tag_err, - avm_mem_val, - avm_mem_w_in_tag, - // perm_main_alu, - // perm_main_bin, - // perm_main_mem_a, - // perm_main_mem_b, - // perm_main_mem_c, - // perm_main_mem_ind_a, - // perm_main_mem_ind_b, - // perm_main_mem_ind_c, - // lookup_byte_lengths, - // lookup_byte_operations, - // incl_main_tag_err, - // incl_mem_tag_err, - // lookup_byte_lengths_counts, - // lookup_byte_operations_counts, - // incl_main_tag_err_counts, - // incl_mem_tag_err_counts - }; - }; - - RefVector get_sorted_polynomials() { return {}; }; }; template class AllEntities { @@ -1192,7 +1044,6 @@ class AvmFlavor { */ using ExtendedEdges = ProverUnivariates; - // TODO: add derived entities + witness entities /** * @brief A container for the witness commitments. * diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index d456d6844a3..0bd67e09fa3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -373,8 +373,6 @@ void AvmProver::execute_log_derivative_inverse_round() */ void AvmProver::execute_relation_check_rounds() { - // TODO: check prover polynomials are set here - using Sumcheck = SumcheckProver; auto sumcheck = Sumcheck(key->circuit_size, transcript); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 882ffbec552..75b85125615 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -259,12 +259,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) // Calculate the alpha and beta challenges - log derivative inverse round auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); - auto beta_sqr = beta * beta; - auto beta_cube = beta_sqr * beta; relation_parameters.beta = beta; relation_parameters.gamma = gamm; - relation_parameters.beta_sqr = beta_sqr; - relation_parameters.beta_cube = beta_cube; // Permutations commitments.perm_main_alu = transcript->template receive_from_prover(commitment_labels.perm_main_alu); diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index b6884a49c20..05ad9ba6540 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -1,7 +1,5 @@ #include "avm_common.test.hpp" #include "barretenberg/vm/generated/avm_flavor.hpp" -#include -#include namespace tests_avm { /** diff --git a/docs/package.json b/docs/package.json index 53e11c4e588..67a53d63e89 100644 --- a/docs/package.json +++ b/docs/package.json @@ -20,10 +20,10 @@ "write-heading-ids": "docusaurus write-heading-ids" }, "dependencies": { - "@docusaurus/core": "^3.2.0", - "@docusaurus/plugin-ideal-image": "^3.2.0", - "@docusaurus/preset-classic": "^3.2.0", - "@docusaurus/theme-mermaid": "^3.2.0", + "@docusaurus/core": "^2.4.1", + "@docusaurus/plugin-ideal-image": "^2.4.1", + "@docusaurus/preset-classic": "^2.4.1", + "@docusaurus/theme-mermaid": "^2.4.1", "@mdx-js/react": "^1.6.22", "axios": "^1.4.0", "clsx": "^1.1.1", @@ -32,7 +32,7 @@ "react": "^17.0.2", "react-dom": "^17.0.2", "react-player": "^2.12.0", - "rehype-katex": "^7.0.0", + "rehype-katex": "5", "remark-math": "3" }, "devDependencies": { From 65c3159dc14e1f2898d544b17720e5458918af57 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 8 Apr 2024 18:22:45 +0000 Subject: [PATCH 07/40] chore: from powdr codegen --- .../relations/generated/avm/avm_alu.hpp | 74 ++--- .../vm/generated/avm_circuit_builder.hpp | 2 - .../barretenberg/vm/generated/avm_flavor.hpp | 48 +-- .../barretenberg/vm/generated/avm_prover.cpp | 297 +++++++++--------- .../vm/generated/avm_verifier.cpp | 8 +- 5 files changed, 198 insertions(+), 231 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp index ef98385518f..136480de014 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_alu.hpp @@ -181,18 +181,18 @@ template class avm_aluImpl { { Avm_DECLARE_VIEWS(9); - auto tmp = - (((avm_alu_op_add + avm_alu_op_sub) * - ((((((((((avm_alu_u8_r0 + (avm_alu_u8_r1 * FF(256))) + (avm_alu_u16_r0 * FF(65536))) + - (avm_alu_u16_r1 * FF(4294967296UL))) + - (avm_alu_u16_r2 * FF(281474976710656UL))) + - (avm_alu_u16_r3 * FF(uint256_t{ 0, 1, 0, 0 }))) + - (avm_alu_u16_r4 * FF(uint256_t{ 0, 65536, 0, 0 }))) + - (avm_alu_u16_r5 * FF(uint256_t{ 0, 4294967296, 0, 0 }))) + - (avm_alu_u16_r6 * FF(uint256_t{ 0, 281474976710656, 0, 0 }))) - - avm_alu_ia) + - (avm_alu_ff_tag * avm_alu_ic))) + - ((avm_alu_op_add - avm_alu_op_sub) * ((avm_alu_cf * FF(uint256_t{ 0, 0, 1, 0 })) - avm_alu_ib))); + auto tmp = (((avm_alu_op_add + avm_alu_op_sub) * + ((((((((((avm_alu_u8_r0 + (avm_alu_u8_r1 * FF(256))) + (avm_alu_u16_r0 * FF(65536))) + + (avm_alu_u16_r1 * FF(4294967296UL))) + + (avm_alu_u16_r2 * FF(281474976710656UL))) + + (avm_alu_u16_r3 * FF(uint256_t{ 0UL, 1UL, 0UL, 0UL }))) + + (avm_alu_u16_r4 * FF(uint256_t{ 0UL, 65536UL, 0UL, 0UL }))) + + (avm_alu_u16_r5 * FF(uint256_t{ 0UL, 4294967296UL, 0UL, 0UL }))) + + (avm_alu_u16_r6 * FF(uint256_t{ 0UL, 281474976710656UL, 0UL, 0UL }))) - + avm_alu_ia) + + (avm_alu_ff_tag * avm_alu_ic))) + + ((avm_alu_op_add - avm_alu_op_sub) * + ((avm_alu_cf * FF(uint256_t{ 0UL, 0UL, 1UL, 0UL })) - avm_alu_ib))); tmp *= scaling_factor; std::get<9>(evals) += tmp; } @@ -213,10 +213,10 @@ template class avm_aluImpl { ((((((((avm_alu_u8_r0 + (avm_alu_u8_r1 * FF(256))) + (avm_alu_u16_r0 * FF(65536))) + (avm_alu_u16_r1 * FF(4294967296UL))) + (avm_alu_u16_r2 * FF(281474976710656UL))) + - (avm_alu_u16_r3 * FF(uint256_t{ 0, 1, 0, 0 }))) + - (avm_alu_u16_r4 * FF(uint256_t{ 0, 65536, 0, 0 }))) + - (avm_alu_u16_r5 * FF(uint256_t{ 0, 4294967296, 0, 0 }))) + - (avm_alu_u16_r6 * FF(uint256_t{ 0, 281474976710656, 0, 0 }))))) + + (avm_alu_u16_r3 * FF(uint256_t{ 0UL, 1UL, 0UL, 0UL }))) + + (avm_alu_u16_r4 * FF(uint256_t{ 0UL, 65536UL, 0UL, 0UL }))) + + (avm_alu_u16_r5 * FF(uint256_t{ 0UL, 4294967296UL, 0UL, 0UL }))) + + (avm_alu_u16_r6 * FF(uint256_t{ 0UL, 281474976710656UL, 0UL, 0UL }))))) + (avm_alu_ff_tag * avm_alu_ia)) - avm_alu_ic)) + ((avm_alu_ff_tag * (avm_alu_op_add - avm_alu_op_sub)) * avm_alu_ib)); @@ -239,10 +239,10 @@ template class avm_aluImpl { (((((((((avm_alu_u8_r0 + (avm_alu_u8_r1 * FF(256))) + (avm_alu_u16_r0 * FF(65536))) + (avm_alu_u16_r1 * FF(4294967296UL))) + (avm_alu_u16_r2 * FF(281474976710656UL))) + - (avm_alu_u16_r3 * FF(uint256_t{ 0, 1, 0, 0 }))) + - (avm_alu_u16_r4 * FF(uint256_t{ 0, 65536, 0, 0 }))) + - (avm_alu_u16_r5 * FF(uint256_t{ 0, 4294967296, 0, 0 }))) + - (avm_alu_u16_r6 * FF(uint256_t{ 0, 281474976710656, 0, 0 }))) - + (avm_alu_u16_r3 * FF(uint256_t{ 0UL, 1UL, 0UL, 0UL }))) + + (avm_alu_u16_r4 * FF(uint256_t{ 0UL, 65536UL, 0UL, 0UL }))) + + (avm_alu_u16_r5 * FF(uint256_t{ 0UL, 4294967296UL, 0UL, 0UL }))) + + (avm_alu_u16_r6 * FF(uint256_t{ 0UL, 281474976710656UL, 0UL, 0UL }))) - (avm_alu_ia * avm_alu_ib))); tmp *= scaling_factor; std::get<12>(evals) += tmp; @@ -272,7 +272,7 @@ template class avm_aluImpl { (avm_alu_u16_r3 * FF(281474976710656UL))) + ((((avm_alu_u16_r4 + (avm_alu_u16_r5 * FF(65536))) + (avm_alu_u16_r6 * FF(4294967296UL))) + (avm_alu_u16_r7 * FF(281474976710656UL))) * - FF(uint256_t{ 0, 1, 0, 0 }))) - + FF(uint256_t{ 0UL, 1UL, 0UL, 0UL }))) - avm_alu_ia)); tmp *= scaling_factor; std::get<14>(evals) += tmp; @@ -288,7 +288,7 @@ template class avm_aluImpl { ((((avm_alu_u16_r4_shift + (avm_alu_u16_r5_shift * FF(65536))) + (avm_alu_u16_r6_shift * FF(4294967296UL))) + (avm_alu_u16_r7_shift * FF(281474976710656UL))) * - FF(uint256_t{ 0, 1, 0, 0 }))) - + FF(uint256_t{ 0UL, 1UL, 0UL, 0UL }))) - avm_alu_ib)); tmp *= scaling_factor; std::get<15>(evals) += tmp; @@ -297,19 +297,19 @@ template class avm_aluImpl { { Avm_DECLARE_VIEWS(16); - auto tmp = - ((avm_alu_u128_tag * avm_alu_op_mul) * - ((((avm_alu_ia * (((avm_alu_u16_r0_shift + (avm_alu_u16_r1_shift * FF(65536))) + - (avm_alu_u16_r2_shift * FF(4294967296UL))) + - (avm_alu_u16_r3_shift * FF(281474976710656UL)))) + - (((((avm_alu_u16_r0 + (avm_alu_u16_r1 * FF(65536))) + (avm_alu_u16_r2 * FF(4294967296UL))) + - (avm_alu_u16_r3 * FF(281474976710656UL))) * - (((avm_alu_u16_r4_shift + (avm_alu_u16_r5_shift * FF(65536))) + - (avm_alu_u16_r6_shift * FF(4294967296UL))) + - (avm_alu_u16_r7_shift * FF(281474976710656UL)))) * - FF(uint256_t{ 0, 1, 0, 0 }))) - - (((avm_alu_cf * FF(uint256_t{ 0, 1, 0, 0 })) + avm_alu_u64_r0) * FF(uint256_t{ 0, 0, 1, 0 }))) - - avm_alu_ic)); + auto tmp = ((avm_alu_u128_tag * avm_alu_op_mul) * + ((((avm_alu_ia * (((avm_alu_u16_r0_shift + (avm_alu_u16_r1_shift * FF(65536))) + + (avm_alu_u16_r2_shift * FF(4294967296UL))) + + (avm_alu_u16_r3_shift * FF(281474976710656UL)))) + + (((((avm_alu_u16_r0 + (avm_alu_u16_r1 * FF(65536))) + (avm_alu_u16_r2 * FF(4294967296UL))) + + (avm_alu_u16_r3 * FF(281474976710656UL))) * + (((avm_alu_u16_r4_shift + (avm_alu_u16_r5_shift * FF(65536))) + + (avm_alu_u16_r6_shift * FF(4294967296UL))) + + (avm_alu_u16_r7_shift * FF(281474976710656UL)))) * + FF(uint256_t{ 0UL, 1UL, 0UL, 0UL }))) - + (((avm_alu_cf * FF(uint256_t{ 0UL, 1UL, 0UL, 0UL })) + avm_alu_u64_r0) * + FF(uint256_t{ 0UL, 0UL, 1UL, 0UL }))) - + avm_alu_ic)); tmp *= scaling_factor; std::get<16>(evals) += tmp; } @@ -328,8 +328,8 @@ template class avm_aluImpl { auto tmp = (avm_alu_op_not * ((avm_alu_ia + avm_alu_ic) - ((((((avm_alu_u8_tag * FF(256)) + (avm_alu_u16_tag * FF(65536))) + (avm_alu_u32_tag * FF(4294967296UL))) + - (avm_alu_u64_tag * FF(uint256_t{ 0, 1, 0, 0 }))) + - (avm_alu_u128_tag * FF(uint256_t{ 0, 0, 1, 0 }))) - + (avm_alu_u64_tag * FF(uint256_t{ 0UL, 1UL, 0UL, 0UL }))) + + (avm_alu_u128_tag * FF(uint256_t{ 0UL, 0UL, 1UL, 0UL }))) - FF(1)))); tmp *= scaling_factor; std::get<18>(evals) += tmp; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 2498a690654..bca60d09b08 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -344,8 +344,6 @@ class AvmCircuitBuilder { polys.avm_mem_tag_err[i] = rows[i].avm_mem_tag_err; polys.avm_mem_val[i] = rows[i].avm_mem_val; polys.avm_mem_w_in_tag[i] = rows[i].avm_mem_w_in_tag; - polys.perm_main_alu[i] = rows[i].perm_main_alu; - polys.lookup_byte_lengths_counts[i] = rows[i].lookup_byte_lengths_counts; polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; polys.incl_main_tag_err_counts[i] = rows[i].incl_main_tag_err_counts; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index c2c664e1b4a..3d1905ed69d 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -64,10 +64,10 @@ class AvmFlavor { perm_main_mem_ind_a_relation, perm_main_mem_ind_b_relation, perm_main_mem_ind_c_relation, - incl_main_tag_err_relation, - incl_mem_tag_err_relation, lookup_byte_lengths_relation, - lookup_byte_operations_relation>; + lookup_byte_operations_relation, + incl_main_tag_err_relation, + incl_mem_tag_err_relation>; using Relations = std::tuple, Avm_vm::avm_binary, @@ -81,10 +81,10 @@ class AvmFlavor { perm_main_mem_ind_a_relation, perm_main_mem_ind_b_relation, perm_main_mem_ind_c_relation, - incl_main_tag_err_relation, - incl_mem_tag_err_relation, lookup_byte_lengths_relation, - lookup_byte_operations_relation>; + lookup_byte_operations_relation, + incl_main_tag_err_relation, + incl_mem_tag_err_relation>; static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); @@ -917,9 +917,6 @@ class AvmFlavor { avm_mem_val }; }; - // The plookup wires that store plookup read data. - std::array get_table_column_wires() { return {}; }; - void compute_logderivative_inverses(const RelationParameters& relation_parameters) { ProverPolynomials prover_polynomials = ProverPolynomials(*this); @@ -940,35 +937,18 @@ class AvmFlavor { prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( - prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( - prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); } }; - class VerificationKey : public VerificationKey_, VerifierCommitmentKey> { - public: - VerificationKey() = default; - VerificationKey(const size_t circuit_size, const size_t num_public_inputs) - : VerificationKey_(circuit_size, num_public_inputs) - {} - - VerificationKey(ProvingKey& proving_key) - { - this->pcs_verification_key = std::make_shared(); - this->circuit_size = proving_key.circuit_size; - this->log_circuit_size = numeric::get_msb(this->circuit_size); - - for (auto [polynomial, commitment] : zip_view(proving_key.get_precomputed_polynomials(), this->get_all())) { - commitment = proving_key.commitment_key->commit(polynomial); - } - } - }; + using VerificationKey = VerificationKey_, VerifierCommitmentKey>; using FoldedPolynomials = AllEntities>; @@ -991,7 +971,6 @@ class AvmFlavor { ProverPolynomials& operator=(ProverPolynomials&& o) noexcept = default; ~ProverPolynomials() = default; - // NOTE: copied from goblin ultra ProverPolynomials(ProvingKey& proving_key) { for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key.get_all())) { @@ -1339,8 +1318,6 @@ class AvmFlavor { Commitment avm_mem_tag_err; Commitment avm_mem_val; Commitment avm_mem_w_in_tag; - - // Perm inverses Commitment perm_main_alu; Commitment perm_main_bin; Commitment perm_main_mem_a; @@ -1349,13 +1326,10 @@ class AvmFlavor { Commitment perm_main_mem_ind_a; Commitment perm_main_mem_ind_b; Commitment perm_main_mem_ind_c; - // Lookup inverses Commitment lookup_byte_lengths; Commitment lookup_byte_operations; Commitment incl_main_tag_err; Commitment incl_mem_tag_err; - - // Lookup counts Commitment lookup_byte_lengths_counts; Commitment lookup_byte_operations_counts; Commitment incl_main_tag_err_counts; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index 0bd67e09fa3..fff24045c48 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -51,14 +51,14 @@ void AvmProver::execute_preamble_round() } /** - * @brief Compute commitments to the first three wires + * @brief Compute commitments to all of the witness wires (apart from the logderivative inverse wires) * */ void AvmProver::execute_wire_commitments_round() { - auto labels = commitment_labels; - + // Commit to all polynomials (apart from logderivative inverse polynomials, which are committed to in the later + // logderivative phase) witness_commitments.avm_alu_alu_sel = commitment_key->commit(key->avm_alu_alu_sel); witness_commitments.avm_alu_cf = commitment_key->commit(key->avm_alu_cf); witness_commitments.avm_alu_clk = commitment_key->commit(key->avm_alu_clk); @@ -182,161 +182,165 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_mem_tag_err = commitment_key->commit(key->avm_mem_tag_err); witness_commitments.avm_mem_val = commitment_key->commit(key->avm_mem_val); witness_commitments.avm_mem_w_in_tag = commitment_key->commit(key->avm_mem_w_in_tag); - - // Lookup counts witness_commitments.lookup_byte_lengths_counts = commitment_key->commit(key->lookup_byte_lengths_counts); witness_commitments.lookup_byte_operations_counts = commitment_key->commit(key->lookup_byte_operations_counts); witness_commitments.incl_main_tag_err_counts = commitment_key->commit(key->incl_main_tag_err_counts); witness_commitments.incl_mem_tag_err_counts = commitment_key->commit(key->incl_mem_tag_err_counts); - // print some of the commitments to check they have values - - // Send all witness commitments to the verifier - transcript->send_to_verifier(labels.avm_alu_alu_sel, witness_commitments.avm_alu_alu_sel); - transcript->send_to_verifier(labels.avm_alu_cf, witness_commitments.avm_alu_cf); - transcript->send_to_verifier(labels.avm_alu_clk, witness_commitments.avm_alu_clk); - transcript->send_to_verifier(labels.avm_alu_ff_tag, witness_commitments.avm_alu_ff_tag); - transcript->send_to_verifier(labels.avm_alu_ia, witness_commitments.avm_alu_ia); - transcript->send_to_verifier(labels.avm_alu_ib, witness_commitments.avm_alu_ib); - transcript->send_to_verifier(labels.avm_alu_ic, witness_commitments.avm_alu_ic); - transcript->send_to_verifier(labels.avm_alu_in_tag, witness_commitments.avm_alu_in_tag); - transcript->send_to_verifier(labels.avm_alu_op_add, witness_commitments.avm_alu_op_add); - transcript->send_to_verifier(labels.avm_alu_op_div, witness_commitments.avm_alu_op_div); - transcript->send_to_verifier(labels.avm_alu_op_eq, witness_commitments.avm_alu_op_eq); - transcript->send_to_verifier(labels.avm_alu_op_eq_diff_inv, witness_commitments.avm_alu_op_eq_diff_inv); - transcript->send_to_verifier(labels.avm_alu_op_mul, witness_commitments.avm_alu_op_mul); - transcript->send_to_verifier(labels.avm_alu_op_not, witness_commitments.avm_alu_op_not); - transcript->send_to_verifier(labels.avm_alu_op_sub, witness_commitments.avm_alu_op_sub); - transcript->send_to_verifier(labels.avm_alu_u128_tag, witness_commitments.avm_alu_u128_tag); - transcript->send_to_verifier(labels.avm_alu_u16_r0, witness_commitments.avm_alu_u16_r0); - transcript->send_to_verifier(labels.avm_alu_u16_r1, witness_commitments.avm_alu_u16_r1); - transcript->send_to_verifier(labels.avm_alu_u16_r10, witness_commitments.avm_alu_u16_r10); - transcript->send_to_verifier(labels.avm_alu_u16_r11, witness_commitments.avm_alu_u16_r11); - transcript->send_to_verifier(labels.avm_alu_u16_r12, witness_commitments.avm_alu_u16_r12); - transcript->send_to_verifier(labels.avm_alu_u16_r13, witness_commitments.avm_alu_u16_r13); - transcript->send_to_verifier(labels.avm_alu_u16_r14, witness_commitments.avm_alu_u16_r14); - transcript->send_to_verifier(labels.avm_alu_u16_r2, witness_commitments.avm_alu_u16_r2); - transcript->send_to_verifier(labels.avm_alu_u16_r3, witness_commitments.avm_alu_u16_r3); - transcript->send_to_verifier(labels.avm_alu_u16_r4, witness_commitments.avm_alu_u16_r4); - transcript->send_to_verifier(labels.avm_alu_u16_r5, witness_commitments.avm_alu_u16_r5); - transcript->send_to_verifier(labels.avm_alu_u16_r6, witness_commitments.avm_alu_u16_r6); - transcript->send_to_verifier(labels.avm_alu_u16_r7, witness_commitments.avm_alu_u16_r7); - transcript->send_to_verifier(labels.avm_alu_u16_r8, witness_commitments.avm_alu_u16_r8); - transcript->send_to_verifier(labels.avm_alu_u16_r9, witness_commitments.avm_alu_u16_r9); - transcript->send_to_verifier(labels.avm_alu_u16_tag, witness_commitments.avm_alu_u16_tag); - transcript->send_to_verifier(labels.avm_alu_u32_tag, witness_commitments.avm_alu_u32_tag); - transcript->send_to_verifier(labels.avm_alu_u64_r0, witness_commitments.avm_alu_u64_r0); - transcript->send_to_verifier(labels.avm_alu_u64_tag, witness_commitments.avm_alu_u64_tag); - transcript->send_to_verifier(labels.avm_alu_u8_r0, witness_commitments.avm_alu_u8_r0); - transcript->send_to_verifier(labels.avm_alu_u8_r1, witness_commitments.avm_alu_u8_r1); - transcript->send_to_verifier(labels.avm_alu_u8_tag, witness_commitments.avm_alu_u8_tag); - transcript->send_to_verifier(labels.avm_binary_acc_ia, witness_commitments.avm_binary_acc_ia); - transcript->send_to_verifier(labels.avm_binary_acc_ib, witness_commitments.avm_binary_acc_ib); - transcript->send_to_verifier(labels.avm_binary_acc_ic, witness_commitments.avm_binary_acc_ic); - transcript->send_to_verifier(labels.avm_binary_bin_sel, witness_commitments.avm_binary_bin_sel); - transcript->send_to_verifier(labels.avm_binary_clk, witness_commitments.avm_binary_clk); - transcript->send_to_verifier(labels.avm_binary_ia_bytes, witness_commitments.avm_binary_ia_bytes); - transcript->send_to_verifier(labels.avm_binary_ib_bytes, witness_commitments.avm_binary_ib_bytes); - transcript->send_to_verifier(labels.avm_binary_ic_bytes, witness_commitments.avm_binary_ic_bytes); - transcript->send_to_verifier(labels.avm_binary_in_tag, witness_commitments.avm_binary_in_tag); - transcript->send_to_verifier(labels.avm_binary_mem_tag_ctr, witness_commitments.avm_binary_mem_tag_ctr); - transcript->send_to_verifier(labels.avm_binary_mem_tag_ctr_inv, witness_commitments.avm_binary_mem_tag_ctr_inv); - transcript->send_to_verifier(labels.avm_binary_op_id, witness_commitments.avm_binary_op_id); - transcript->send_to_verifier(labels.avm_binary_start, witness_commitments.avm_binary_start); - transcript->send_to_verifier(labels.avm_byte_lookup_bin_sel, witness_commitments.avm_byte_lookup_bin_sel); - transcript->send_to_verifier(labels.avm_byte_lookup_table_byte_lengths, + // Send all commitments to the verifier + transcript->send_to_verifier(commitment_labels.avm_alu_alu_sel, witness_commitments.avm_alu_alu_sel); + transcript->send_to_verifier(commitment_labels.avm_alu_cf, witness_commitments.avm_alu_cf); + transcript->send_to_verifier(commitment_labels.avm_alu_clk, witness_commitments.avm_alu_clk); + transcript->send_to_verifier(commitment_labels.avm_alu_ff_tag, witness_commitments.avm_alu_ff_tag); + transcript->send_to_verifier(commitment_labels.avm_alu_ia, witness_commitments.avm_alu_ia); + transcript->send_to_verifier(commitment_labels.avm_alu_ib, witness_commitments.avm_alu_ib); + transcript->send_to_verifier(commitment_labels.avm_alu_ic, witness_commitments.avm_alu_ic); + transcript->send_to_verifier(commitment_labels.avm_alu_in_tag, witness_commitments.avm_alu_in_tag); + transcript->send_to_verifier(commitment_labels.avm_alu_op_add, witness_commitments.avm_alu_op_add); + transcript->send_to_verifier(commitment_labels.avm_alu_op_div, witness_commitments.avm_alu_op_div); + transcript->send_to_verifier(commitment_labels.avm_alu_op_eq, witness_commitments.avm_alu_op_eq); + transcript->send_to_verifier(commitment_labels.avm_alu_op_eq_diff_inv, witness_commitments.avm_alu_op_eq_diff_inv); + transcript->send_to_verifier(commitment_labels.avm_alu_op_mul, witness_commitments.avm_alu_op_mul); + transcript->send_to_verifier(commitment_labels.avm_alu_op_not, witness_commitments.avm_alu_op_not); + transcript->send_to_verifier(commitment_labels.avm_alu_op_sub, witness_commitments.avm_alu_op_sub); + transcript->send_to_verifier(commitment_labels.avm_alu_u128_tag, witness_commitments.avm_alu_u128_tag); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r0, witness_commitments.avm_alu_u16_r0); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r1, witness_commitments.avm_alu_u16_r1); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r10, witness_commitments.avm_alu_u16_r10); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r11, witness_commitments.avm_alu_u16_r11); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r12, witness_commitments.avm_alu_u16_r12); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r13, witness_commitments.avm_alu_u16_r13); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r14, witness_commitments.avm_alu_u16_r14); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r2, witness_commitments.avm_alu_u16_r2); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r3, witness_commitments.avm_alu_u16_r3); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r4, witness_commitments.avm_alu_u16_r4); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r5, witness_commitments.avm_alu_u16_r5); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r6, witness_commitments.avm_alu_u16_r6); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r7, witness_commitments.avm_alu_u16_r7); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r8, witness_commitments.avm_alu_u16_r8); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_r9, witness_commitments.avm_alu_u16_r9); + transcript->send_to_verifier(commitment_labels.avm_alu_u16_tag, witness_commitments.avm_alu_u16_tag); + transcript->send_to_verifier(commitment_labels.avm_alu_u32_tag, witness_commitments.avm_alu_u32_tag); + transcript->send_to_verifier(commitment_labels.avm_alu_u64_r0, witness_commitments.avm_alu_u64_r0); + transcript->send_to_verifier(commitment_labels.avm_alu_u64_tag, witness_commitments.avm_alu_u64_tag); + transcript->send_to_verifier(commitment_labels.avm_alu_u8_r0, witness_commitments.avm_alu_u8_r0); + transcript->send_to_verifier(commitment_labels.avm_alu_u8_r1, witness_commitments.avm_alu_u8_r1); + transcript->send_to_verifier(commitment_labels.avm_alu_u8_tag, witness_commitments.avm_alu_u8_tag); + transcript->send_to_verifier(commitment_labels.avm_binary_acc_ia, witness_commitments.avm_binary_acc_ia); + transcript->send_to_verifier(commitment_labels.avm_binary_acc_ib, witness_commitments.avm_binary_acc_ib); + transcript->send_to_verifier(commitment_labels.avm_binary_acc_ic, witness_commitments.avm_binary_acc_ic); + transcript->send_to_verifier(commitment_labels.avm_binary_bin_sel, witness_commitments.avm_binary_bin_sel); + transcript->send_to_verifier(commitment_labels.avm_binary_clk, witness_commitments.avm_binary_clk); + transcript->send_to_verifier(commitment_labels.avm_binary_ia_bytes, witness_commitments.avm_binary_ia_bytes); + transcript->send_to_verifier(commitment_labels.avm_binary_ib_bytes, witness_commitments.avm_binary_ib_bytes); + transcript->send_to_verifier(commitment_labels.avm_binary_ic_bytes, witness_commitments.avm_binary_ic_bytes); + transcript->send_to_verifier(commitment_labels.avm_binary_in_tag, witness_commitments.avm_binary_in_tag); + transcript->send_to_verifier(commitment_labels.avm_binary_mem_tag_ctr, witness_commitments.avm_binary_mem_tag_ctr); + transcript->send_to_verifier(commitment_labels.avm_binary_mem_tag_ctr_inv, + witness_commitments.avm_binary_mem_tag_ctr_inv); + transcript->send_to_verifier(commitment_labels.avm_binary_op_id, witness_commitments.avm_binary_op_id); + transcript->send_to_verifier(commitment_labels.avm_binary_start, witness_commitments.avm_binary_start); + transcript->send_to_verifier(commitment_labels.avm_byte_lookup_bin_sel, + witness_commitments.avm_byte_lookup_bin_sel); + transcript->send_to_verifier(commitment_labels.avm_byte_lookup_table_byte_lengths, witness_commitments.avm_byte_lookup_table_byte_lengths); - transcript->send_to_verifier(labels.avm_byte_lookup_table_in_tags, + transcript->send_to_verifier(commitment_labels.avm_byte_lookup_table_in_tags, witness_commitments.avm_byte_lookup_table_in_tags); - transcript->send_to_verifier(labels.avm_byte_lookup_table_input_a, + transcript->send_to_verifier(commitment_labels.avm_byte_lookup_table_input_a, witness_commitments.avm_byte_lookup_table_input_a); - transcript->send_to_verifier(labels.avm_byte_lookup_table_input_b, + transcript->send_to_verifier(commitment_labels.avm_byte_lookup_table_input_b, witness_commitments.avm_byte_lookup_table_input_b); - transcript->send_to_verifier(labels.avm_byte_lookup_table_op_id, witness_commitments.avm_byte_lookup_table_op_id); - transcript->send_to_verifier(labels.avm_byte_lookup_table_output, witness_commitments.avm_byte_lookup_table_output); - transcript->send_to_verifier(labels.avm_main_alu_sel, witness_commitments.avm_main_alu_sel); - transcript->send_to_verifier(labels.avm_main_bin_op_id, witness_commitments.avm_main_bin_op_id); - transcript->send_to_verifier(labels.avm_main_bin_sel, witness_commitments.avm_main_bin_sel); - transcript->send_to_verifier(labels.avm_main_ia, witness_commitments.avm_main_ia); - transcript->send_to_verifier(labels.avm_main_ib, witness_commitments.avm_main_ib); - transcript->send_to_verifier(labels.avm_main_ic, witness_commitments.avm_main_ic); - transcript->send_to_verifier(labels.avm_main_ind_a, witness_commitments.avm_main_ind_a); - transcript->send_to_verifier(labels.avm_main_ind_b, witness_commitments.avm_main_ind_b); - transcript->send_to_verifier(labels.avm_main_ind_c, witness_commitments.avm_main_ind_c); - transcript->send_to_verifier(labels.avm_main_ind_op_a, witness_commitments.avm_main_ind_op_a); - transcript->send_to_verifier(labels.avm_main_ind_op_b, witness_commitments.avm_main_ind_op_b); - transcript->send_to_verifier(labels.avm_main_ind_op_c, witness_commitments.avm_main_ind_op_c); - transcript->send_to_verifier(labels.avm_main_internal_return_ptr, witness_commitments.avm_main_internal_return_ptr); - transcript->send_to_verifier(labels.avm_main_inv, witness_commitments.avm_main_inv); - transcript->send_to_verifier(labels.avm_main_last, witness_commitments.avm_main_last); - transcript->send_to_verifier(labels.avm_main_mem_idx_a, witness_commitments.avm_main_mem_idx_a); - transcript->send_to_verifier(labels.avm_main_mem_idx_b, witness_commitments.avm_main_mem_idx_b); - transcript->send_to_verifier(labels.avm_main_mem_idx_c, witness_commitments.avm_main_mem_idx_c); - transcript->send_to_verifier(labels.avm_main_mem_op_a, witness_commitments.avm_main_mem_op_a); - transcript->send_to_verifier(labels.avm_main_mem_op_b, witness_commitments.avm_main_mem_op_b); - transcript->send_to_verifier(labels.avm_main_mem_op_c, witness_commitments.avm_main_mem_op_c); - transcript->send_to_verifier(labels.avm_main_op_err, witness_commitments.avm_main_op_err); - transcript->send_to_verifier(labels.avm_main_pc, witness_commitments.avm_main_pc); - transcript->send_to_verifier(labels.avm_main_r_in_tag, witness_commitments.avm_main_r_in_tag); - transcript->send_to_verifier(labels.avm_main_rwa, witness_commitments.avm_main_rwa); - transcript->send_to_verifier(labels.avm_main_rwb, witness_commitments.avm_main_rwb); - transcript->send_to_verifier(labels.avm_main_rwc, witness_commitments.avm_main_rwc); - transcript->send_to_verifier(labels.avm_main_sel_halt, witness_commitments.avm_main_sel_halt); - transcript->send_to_verifier(labels.avm_main_sel_internal_call, witness_commitments.avm_main_sel_internal_call); - transcript->send_to_verifier(labels.avm_main_sel_internal_return, witness_commitments.avm_main_sel_internal_return); - transcript->send_to_verifier(labels.avm_main_sel_jump, witness_commitments.avm_main_sel_jump); - transcript->send_to_verifier(labels.avm_main_sel_mov, witness_commitments.avm_main_sel_mov); - transcript->send_to_verifier(labels.avm_main_sel_op_add, witness_commitments.avm_main_sel_op_add); - transcript->send_to_verifier(labels.avm_main_sel_op_and, witness_commitments.avm_main_sel_op_and); - transcript->send_to_verifier(labels.avm_main_sel_op_div, witness_commitments.avm_main_sel_op_div); - transcript->send_to_verifier(labels.avm_main_sel_op_eq, witness_commitments.avm_main_sel_op_eq); - transcript->send_to_verifier(labels.avm_main_sel_op_mul, witness_commitments.avm_main_sel_op_mul); - transcript->send_to_verifier(labels.avm_main_sel_op_not, witness_commitments.avm_main_sel_op_not); - transcript->send_to_verifier(labels.avm_main_sel_op_or, witness_commitments.avm_main_sel_op_or); - transcript->send_to_verifier(labels.avm_main_sel_op_sub, witness_commitments.avm_main_sel_op_sub); - transcript->send_to_verifier(labels.avm_main_sel_op_xor, witness_commitments.avm_main_sel_op_xor); - transcript->send_to_verifier(labels.avm_main_sel_rng_16, witness_commitments.avm_main_sel_rng_16); - transcript->send_to_verifier(labels.avm_main_sel_rng_8, witness_commitments.avm_main_sel_rng_8); - transcript->send_to_verifier(labels.avm_main_tag_err, witness_commitments.avm_main_tag_err); - transcript->send_to_verifier(labels.avm_main_w_in_tag, witness_commitments.avm_main_w_in_tag); - transcript->send_to_verifier(labels.avm_mem_addr, witness_commitments.avm_mem_addr); - transcript->send_to_verifier(labels.avm_mem_clk, witness_commitments.avm_mem_clk); - transcript->send_to_verifier(labels.avm_mem_ind_op_a, witness_commitments.avm_mem_ind_op_a); - transcript->send_to_verifier(labels.avm_mem_ind_op_b, witness_commitments.avm_mem_ind_op_b); - transcript->send_to_verifier(labels.avm_mem_ind_op_c, witness_commitments.avm_mem_ind_op_c); - transcript->send_to_verifier(labels.avm_mem_last, witness_commitments.avm_mem_last); - transcript->send_to_verifier(labels.avm_mem_lastAccess, witness_commitments.avm_mem_lastAccess); - transcript->send_to_verifier(labels.avm_mem_one_min_inv, witness_commitments.avm_mem_one_min_inv); - transcript->send_to_verifier(labels.avm_mem_op_a, witness_commitments.avm_mem_op_a); - transcript->send_to_verifier(labels.avm_mem_op_b, witness_commitments.avm_mem_op_b); - transcript->send_to_verifier(labels.avm_mem_op_c, witness_commitments.avm_mem_op_c); - transcript->send_to_verifier(labels.avm_mem_r_in_tag, witness_commitments.avm_mem_r_in_tag); - transcript->send_to_verifier(labels.avm_mem_rw, witness_commitments.avm_mem_rw); - transcript->send_to_verifier(labels.avm_mem_sel_mov, witness_commitments.avm_mem_sel_mov); - transcript->send_to_verifier(labels.avm_mem_sub_clk, witness_commitments.avm_mem_sub_clk); - transcript->send_to_verifier(labels.avm_mem_tag, witness_commitments.avm_mem_tag); - transcript->send_to_verifier(labels.avm_mem_tag_err, witness_commitments.avm_mem_tag_err); - transcript->send_to_verifier(labels.avm_mem_val, witness_commitments.avm_mem_val); - transcript->send_to_verifier(labels.avm_mem_w_in_tag, witness_commitments.avm_mem_w_in_tag); - - // Lookup counts - transcript->send_to_verifier(labels.lookup_byte_lengths_counts, witness_commitments.lookup_byte_lengths_counts); - transcript->send_to_verifier(labels.lookup_byte_operations_counts, + transcript->send_to_verifier(commitment_labels.avm_byte_lookup_table_op_id, + witness_commitments.avm_byte_lookup_table_op_id); + transcript->send_to_verifier(commitment_labels.avm_byte_lookup_table_output, + witness_commitments.avm_byte_lookup_table_output); + transcript->send_to_verifier(commitment_labels.avm_main_alu_sel, witness_commitments.avm_main_alu_sel); + transcript->send_to_verifier(commitment_labels.avm_main_bin_op_id, witness_commitments.avm_main_bin_op_id); + transcript->send_to_verifier(commitment_labels.avm_main_bin_sel, witness_commitments.avm_main_bin_sel); + transcript->send_to_verifier(commitment_labels.avm_main_ia, witness_commitments.avm_main_ia); + transcript->send_to_verifier(commitment_labels.avm_main_ib, witness_commitments.avm_main_ib); + transcript->send_to_verifier(commitment_labels.avm_main_ic, witness_commitments.avm_main_ic); + transcript->send_to_verifier(commitment_labels.avm_main_ind_a, witness_commitments.avm_main_ind_a); + transcript->send_to_verifier(commitment_labels.avm_main_ind_b, witness_commitments.avm_main_ind_b); + transcript->send_to_verifier(commitment_labels.avm_main_ind_c, witness_commitments.avm_main_ind_c); + transcript->send_to_verifier(commitment_labels.avm_main_ind_op_a, witness_commitments.avm_main_ind_op_a); + transcript->send_to_verifier(commitment_labels.avm_main_ind_op_b, witness_commitments.avm_main_ind_op_b); + transcript->send_to_verifier(commitment_labels.avm_main_ind_op_c, witness_commitments.avm_main_ind_op_c); + transcript->send_to_verifier(commitment_labels.avm_main_internal_return_ptr, + witness_commitments.avm_main_internal_return_ptr); + transcript->send_to_verifier(commitment_labels.avm_main_inv, witness_commitments.avm_main_inv); + transcript->send_to_verifier(commitment_labels.avm_main_last, witness_commitments.avm_main_last); + transcript->send_to_verifier(commitment_labels.avm_main_mem_idx_a, witness_commitments.avm_main_mem_idx_a); + transcript->send_to_verifier(commitment_labels.avm_main_mem_idx_b, witness_commitments.avm_main_mem_idx_b); + transcript->send_to_verifier(commitment_labels.avm_main_mem_idx_c, witness_commitments.avm_main_mem_idx_c); + transcript->send_to_verifier(commitment_labels.avm_main_mem_op_a, witness_commitments.avm_main_mem_op_a); + transcript->send_to_verifier(commitment_labels.avm_main_mem_op_b, witness_commitments.avm_main_mem_op_b); + transcript->send_to_verifier(commitment_labels.avm_main_mem_op_c, witness_commitments.avm_main_mem_op_c); + transcript->send_to_verifier(commitment_labels.avm_main_op_err, witness_commitments.avm_main_op_err); + transcript->send_to_verifier(commitment_labels.avm_main_pc, witness_commitments.avm_main_pc); + transcript->send_to_verifier(commitment_labels.avm_main_r_in_tag, witness_commitments.avm_main_r_in_tag); + transcript->send_to_verifier(commitment_labels.avm_main_rwa, witness_commitments.avm_main_rwa); + transcript->send_to_verifier(commitment_labels.avm_main_rwb, witness_commitments.avm_main_rwb); + transcript->send_to_verifier(commitment_labels.avm_main_rwc, witness_commitments.avm_main_rwc); + transcript->send_to_verifier(commitment_labels.avm_main_sel_halt, witness_commitments.avm_main_sel_halt); + transcript->send_to_verifier(commitment_labels.avm_main_sel_internal_call, + witness_commitments.avm_main_sel_internal_call); + transcript->send_to_verifier(commitment_labels.avm_main_sel_internal_return, + witness_commitments.avm_main_sel_internal_return); + transcript->send_to_verifier(commitment_labels.avm_main_sel_jump, witness_commitments.avm_main_sel_jump); + transcript->send_to_verifier(commitment_labels.avm_main_sel_mov, witness_commitments.avm_main_sel_mov); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_add, witness_commitments.avm_main_sel_op_add); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_and, witness_commitments.avm_main_sel_op_and); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_div, witness_commitments.avm_main_sel_op_div); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_eq, witness_commitments.avm_main_sel_op_eq); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_mul, witness_commitments.avm_main_sel_op_mul); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_not, witness_commitments.avm_main_sel_op_not); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_or, witness_commitments.avm_main_sel_op_or); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_sub, witness_commitments.avm_main_sel_op_sub); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_xor, witness_commitments.avm_main_sel_op_xor); + transcript->send_to_verifier(commitment_labels.avm_main_sel_rng_16, witness_commitments.avm_main_sel_rng_16); + transcript->send_to_verifier(commitment_labels.avm_main_sel_rng_8, witness_commitments.avm_main_sel_rng_8); + transcript->send_to_verifier(commitment_labels.avm_main_tag_err, witness_commitments.avm_main_tag_err); + transcript->send_to_verifier(commitment_labels.avm_main_w_in_tag, witness_commitments.avm_main_w_in_tag); + transcript->send_to_verifier(commitment_labels.avm_mem_addr, witness_commitments.avm_mem_addr); + transcript->send_to_verifier(commitment_labels.avm_mem_clk, witness_commitments.avm_mem_clk); + transcript->send_to_verifier(commitment_labels.avm_mem_ind_op_a, witness_commitments.avm_mem_ind_op_a); + transcript->send_to_verifier(commitment_labels.avm_mem_ind_op_b, witness_commitments.avm_mem_ind_op_b); + transcript->send_to_verifier(commitment_labels.avm_mem_ind_op_c, witness_commitments.avm_mem_ind_op_c); + transcript->send_to_verifier(commitment_labels.avm_mem_last, witness_commitments.avm_mem_last); + transcript->send_to_verifier(commitment_labels.avm_mem_lastAccess, witness_commitments.avm_mem_lastAccess); + transcript->send_to_verifier(commitment_labels.avm_mem_one_min_inv, witness_commitments.avm_mem_one_min_inv); + transcript->send_to_verifier(commitment_labels.avm_mem_op_a, witness_commitments.avm_mem_op_a); + transcript->send_to_verifier(commitment_labels.avm_mem_op_b, witness_commitments.avm_mem_op_b); + transcript->send_to_verifier(commitment_labels.avm_mem_op_c, witness_commitments.avm_mem_op_c); + transcript->send_to_verifier(commitment_labels.avm_mem_r_in_tag, witness_commitments.avm_mem_r_in_tag); + transcript->send_to_verifier(commitment_labels.avm_mem_rw, witness_commitments.avm_mem_rw); + transcript->send_to_verifier(commitment_labels.avm_mem_sel_mov, witness_commitments.avm_mem_sel_mov); + transcript->send_to_verifier(commitment_labels.avm_mem_sub_clk, witness_commitments.avm_mem_sub_clk); + transcript->send_to_verifier(commitment_labels.avm_mem_tag, witness_commitments.avm_mem_tag); + transcript->send_to_verifier(commitment_labels.avm_mem_tag_err, witness_commitments.avm_mem_tag_err); + transcript->send_to_verifier(commitment_labels.avm_mem_val, witness_commitments.avm_mem_val); + transcript->send_to_verifier(commitment_labels.avm_mem_w_in_tag, witness_commitments.avm_mem_w_in_tag); + transcript->send_to_verifier(commitment_labels.lookup_byte_lengths_counts, + witness_commitments.lookup_byte_lengths_counts); + transcript->send_to_verifier(commitment_labels.lookup_byte_operations_counts, witness_commitments.lookup_byte_operations_counts); - transcript->send_to_verifier(labels.incl_main_tag_err_counts, witness_commitments.incl_main_tag_err_counts); - transcript->send_to_verifier(labels.incl_mem_tag_err_counts, witness_commitments.incl_mem_tag_err_counts); + transcript->send_to_verifier(commitment_labels.incl_main_tag_err_counts, + witness_commitments.incl_main_tag_err_counts); + transcript->send_to_verifier(commitment_labels.incl_mem_tag_err_counts, + witness_commitments.incl_mem_tag_err_counts); } void AvmProver::execute_log_derivative_inverse_round() { - auto [beta, gamma] = transcript->template get_challenges("beta", "gamma"); + auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); relation_parameters.beta = beta; - relation_parameters.gamma = gamma; + relation_parameters.gamma = gamm; key->compute_logderivative_inverses(relation_parameters); - // Permutations + // Commit to all logderivative inverse polynomials witness_commitments.perm_main_alu = commitment_key->commit(key->perm_main_alu); witness_commitments.perm_main_bin = commitment_key->commit(key->perm_main_bin); witness_commitments.perm_main_mem_a = commitment_key->commit(key->perm_main_mem_a); @@ -345,26 +349,24 @@ void AvmProver::execute_log_derivative_inverse_round() witness_commitments.perm_main_mem_ind_a = commitment_key->commit(key->perm_main_mem_ind_a); witness_commitments.perm_main_mem_ind_b = commitment_key->commit(key->perm_main_mem_ind_b); witness_commitments.perm_main_mem_ind_c = commitment_key->commit(key->perm_main_mem_ind_c); - // Lookups - witness_commitments.incl_main_tag_err = commitment_key->commit(key->incl_main_tag_err); - witness_commitments.incl_mem_tag_err = commitment_key->commit(key->incl_mem_tag_err); witness_commitments.lookup_byte_lengths = commitment_key->commit(key->lookup_byte_lengths); witness_commitments.lookup_byte_operations = commitment_key->commit(key->lookup_byte_operations); + witness_commitments.incl_main_tag_err = commitment_key->commit(key->incl_main_tag_err); + witness_commitments.incl_mem_tag_err = commitment_key->commit(key->incl_mem_tag_err); - // Perms + // Send all commitments to the verifier transcript->send_to_verifier(commitment_labels.perm_main_alu, witness_commitments.perm_main_alu); transcript->send_to_verifier(commitment_labels.perm_main_bin, witness_commitments.perm_main_bin); transcript->send_to_verifier(commitment_labels.perm_main_mem_a, witness_commitments.perm_main_mem_a); transcript->send_to_verifier(commitment_labels.perm_main_mem_b, witness_commitments.perm_main_mem_b); - transcript->send_to_verifier(commitment_labels.perm_main_mem_c, witness_commitments.perm_main_mem_b); + transcript->send_to_verifier(commitment_labels.perm_main_mem_c, witness_commitments.perm_main_mem_c); transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_a, witness_commitments.perm_main_mem_ind_a); transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_b, witness_commitments.perm_main_mem_ind_b); transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_c, witness_commitments.perm_main_mem_ind_c); - // Lookups - transcript->send_to_verifier(commitment_labels.incl_main_tag_err, witness_commitments.incl_main_tag_err); - transcript->send_to_verifier(commitment_labels.incl_mem_tag_err, witness_commitments.incl_mem_tag_err); transcript->send_to_verifier(commitment_labels.lookup_byte_lengths, witness_commitments.lookup_byte_lengths); transcript->send_to_verifier(commitment_labels.lookup_byte_operations, witness_commitments.lookup_byte_operations); + transcript->send_to_verifier(commitment_labels.incl_main_tag_err, witness_commitments.incl_main_tag_err); + transcript->send_to_verifier(commitment_labels.incl_mem_tag_err, witness_commitments.incl_mem_tag_err); } /** @@ -417,7 +419,6 @@ HonkProof& AvmProver::construct_proof() execute_wire_commitments_round(); // Compute sorted list accumulator and commitment - // Fiat-Shamir: bbeta & gamma execute_log_derivative_inverse_round(); // Fiat-Shamir: alpha diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 75b85125615..854a39893ec 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -246,8 +246,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) commitments.avm_mem_val = transcript->template receive_from_prover(commitment_labels.avm_mem_val); commitments.avm_mem_w_in_tag = transcript->template receive_from_prover(commitment_labels.avm_mem_w_in_tag); - - // Lookup counts commitments.lookup_byte_lengths_counts = transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths_counts); commitments.lookup_byte_operations_counts = @@ -257,12 +255,11 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) commitments.incl_mem_tag_err_counts = transcript->template receive_from_prover(commitment_labels.incl_mem_tag_err_counts); - // Calculate the alpha and beta challenges - log derivative inverse round auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); relation_parameters.beta = beta; relation_parameters.gamma = gamm; - // Permutations + // Get commitments to inverses commitments.perm_main_alu = transcript->template receive_from_prover(commitment_labels.perm_main_alu); commitments.perm_main_bin = transcript->template receive_from_prover(commitment_labels.perm_main_bin); commitments.perm_main_mem_a = @@ -277,8 +274,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_b); commitments.perm_main_mem_ind_c = transcript->template receive_from_prover(commitment_labels.perm_main_mem_ind_c); - - // Lookups commitments.lookup_byte_lengths = transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths); commitments.lookup_byte_operations = @@ -304,7 +299,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) // If Sumcheck did not verify, return false if (sumcheck_verified.has_value() && !sumcheck_verified.value()) { - info("Sumcheck did not verify"); return false; } From 61d10f6abde00af37d86f3ba88058555836b4118 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 11 Apr 2024 11:52:33 +0000 Subject: [PATCH 08/40] temp --- barretenberg/cpp/pil/spike/README.md | 3 + barretenberg/cpp/pil/spike/spike.pil | 6 + .../barretenberg/crypto/poseidon2/c_bind.hpp | 1 + .../generated/spike/declare_views.hpp | 6 + .../vm/generated/spike_circuit_builder.hpp | 78 +++++ .../vm/generated/spike_composer.cpp | 86 ++++++ .../vm/generated/spike_composer.hpp | 69 +++++ .../vm/generated/spike_flavor.hpp | 289 ++++++++++++++++++ .../vm/generated/spike_prover.cpp | 160 ++++++++++ .../vm/generated/spike_prover.hpp | 66 ++++ .../vm/generated/spike_verifier.cpp | 128 ++++++++ .../vm/generated/spike_verifier.hpp | 36 +++ .../src/barretenberg/vm/tests/spike.test.cpp | 48 +++ 13 files changed, 976 insertions(+) create mode 100644 barretenberg/cpp/pil/spike/README.md create mode 100644 barretenberg/cpp/pil/spike/spike.pil create mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/generated/spike_composer.cpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/generated/spike_composer.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp diff --git a/barretenberg/cpp/pil/spike/README.md b/barretenberg/cpp/pil/spike/README.md new file mode 100644 index 00000000000..69e4f55ac79 --- /dev/null +++ b/barretenberg/cpp/pil/spike/README.md @@ -0,0 +1,3 @@ +## Spike machine + +A spike machine for testing new PIL functionality \ No newline at end of file diff --git a/barretenberg/cpp/pil/spike/spike.pil b/barretenberg/cpp/pil/spike/spike.pil new file mode 100644 index 00000000000..27b4d9355f9 --- /dev/null +++ b/barretenberg/cpp/pil/spike/spike.pil @@ -0,0 +1,6 @@ + +namespace Spike(1); + +pol constant y; +pol commit x; +pol public kernel_inputs; \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/crypto/poseidon2/c_bind.hpp b/barretenberg/cpp/src/barretenberg/crypto/poseidon2/c_bind.hpp index e113b523dd1..7fafe6c867f 100644 --- a/barretenberg/cpp/src/barretenberg/crypto/poseidon2/c_bind.hpp +++ b/barretenberg/cpp/src/barretenberg/crypto/poseidon2/c_bind.hpp @@ -8,5 +8,6 @@ extern "C" { using namespace bb; WASM_EXPORT void poseidon_hash(fr::vec_in_buf inputs_buffer, fr::out_buf output); +WASM_EXPORT void poseidon2_permutation(fr::vec_in_buf in_state, fr::out_buf out_state); WASM_EXPORT void poseidon_hashes(fr::vec_in_buf inputs_buffer, fr::out_buf output); } \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp new file mode 100644 index 00000000000..08ed2f368be --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp @@ -0,0 +1,6 @@ + +#define Spike_DECLARE_VIEWS(index) \ + using Accumulator = typename std::tuple_element::type; \ + using View = typename Accumulator::View; \ + [[maybe_unused]] auto Spike_kernel_inputs__is_public = View(new_term.Spike_kernel_inputs__is_public); \ + [[maybe_unused]] auto Spike_x = View(new_term.Spike_x); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp new file mode 100644 index 00000000000..0e36810ca80 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp @@ -0,0 +1,78 @@ + + +// AUTOGENERATED FILE +#pragma once + +#include "barretenberg/common/constexpr_utils.hpp" +#include "barretenberg/common/throw_or_abort.hpp" +#include "barretenberg/ecc/curves/bn254/fr.hpp" +#include "barretenberg/honk/proof_system/logderivative_library.hpp" +#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp" +#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" +#include "barretenberg/stdlib_circuit_builders/circuit_builder_base.hpp" + +#include "barretenberg/vm/generated/spike_flavor.hpp" + +namespace bb { + +template struct SpikeFullRow { + FF Spike_first; + FF Spike_kernel_inputs__is_public{}; + FF Spike_x{}; +}; + +class SpikeCircuitBuilder { + public: + using Flavor = bb::SpikeFlavor; + using FF = Flavor::FF; + using Row = SpikeFullRow; + + // TODO: template + using Polynomial = Flavor::Polynomial; + using ProverPolynomials = Flavor::ProverPolynomials; + + static constexpr size_t num_fixed_columns = 2; + static constexpr size_t num_polys = 2; + std::vector rows; + + void set_trace(std::vector&& trace) { rows = std::move(trace); } + + ProverPolynomials compute_polynomials() + { + const auto num_rows = get_circuit_subgroup_size(); + ProverPolynomials polys; + + // Allocate mem for each column + for (auto& poly : polys.get_all()) { + poly = Polynomial(num_rows); + } + + for (size_t i = 0; i < rows.size(); i++) { + polys.Spike_first[i] = rows[i].Spike_first; + polys.Spike_kernel_inputs__is_public[i] = rows[i].Spike_kernel_inputs__is_public; + polys.Spike_x[i] = rows[i].Spike_x; + } + + return polys; + } + + [[maybe_unused]] bool check_circuit() + { + // There are no relations, so check circuit does nothing + // auto polys = compute_polynomials(); + // const size_t num_rows = polys.get_polynomial_size(); + + return true; + } + + [[nodiscard]] size_t get_num_gates() const { return rows.size(); } + + [[nodiscard]] size_t get_circuit_subgroup_size() const + { + const size_t num_rows = get_num_gates(); + const auto num_rows_log2 = static_cast(numeric::get_msb64(num_rows)); + size_t num_rows_pow2 = 1UL << (num_rows_log2 + (1UL << num_rows_log2 == num_rows ? 0 : 1)); + return num_rows_pow2; + } +}; +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_composer.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_composer.cpp new file mode 100644 index 00000000000..9745b6accda --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_composer.cpp @@ -0,0 +1,86 @@ + + +#include "./spike_composer.hpp" +#include "barretenberg/plonk_honk_shared/composer/composer_lib.hpp" +#include "barretenberg/plonk_honk_shared/composer/permutation_lib.hpp" +#include "barretenberg/vm/generated/spike_circuit_builder.hpp" +#include "barretenberg/vm/generated/spike_verifier.hpp" + +namespace bb { + +using Flavor = SpikeFlavor; +void SpikeComposer::compute_witness(CircuitConstructor& circuit) +{ + if (computed_witness) { + return; + } + + auto polynomials = circuit.compute_polynomials(); + + for (auto [key_poly, prover_poly] : zip_view(proving_key->get_all(), polynomials.get_unshifted())) { + ASSERT(flavor_get_label(*proving_key, key_poly) == flavor_get_label(polynomials, prover_poly)); + key_poly = prover_poly; + } + + computed_witness = true; +} + +SpikeProver SpikeComposer::create_prover(CircuitConstructor& circuit_constructor) +{ + compute_proving_key(circuit_constructor); + compute_witness(circuit_constructor); + compute_commitment_key(circuit_constructor.get_circuit_subgroup_size()); + + SpikeProver output_state(proving_key, proving_key->commitment_key); + + return output_state; +} + +SpikeVerifier SpikeComposer::create_verifier(CircuitConstructor& circuit_constructor) +{ + auto verification_key = compute_verification_key(circuit_constructor); + + SpikeVerifier output_state(verification_key); + + auto pcs_verification_key = std::make_unique(); + + output_state.pcs_verification_key = std::move(pcs_verification_key); + + return output_state; +} + +std::shared_ptr SpikeComposer::compute_proving_key(CircuitConstructor& circuit_constructor) +{ + if (proving_key) { + return proving_key; + } + + // Initialize proving_key + { + const size_t subgroup_size = circuit_constructor.get_circuit_subgroup_size(); + proving_key = std::make_shared(subgroup_size, 0); + } + + proving_key->contains_recursive_proof = false; + + return proving_key; +} + +std::shared_ptr SpikeComposer::compute_verification_key( + CircuitConstructor& circuit_constructor) +{ + if (verification_key) { + return verification_key; + } + + if (!proving_key) { + compute_proving_key(circuit_constructor); + } + + verification_key = + std::make_shared(proving_key->circuit_size, proving_key->num_public_inputs); + + return verification_key; +} + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_composer.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_composer.hpp new file mode 100644 index 00000000000..10ddf7dbd93 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_composer.hpp @@ -0,0 +1,69 @@ + + +#pragma once + +#include "barretenberg/plonk_honk_shared/composer/composer_lib.hpp" +#include "barretenberg/srs/global_crs.hpp" +#include "barretenberg/vm/generated/spike_circuit_builder.hpp" +#include "barretenberg/vm/generated/spike_prover.hpp" +#include "barretenberg/vm/generated/spike_verifier.hpp" + +namespace bb { +class SpikeComposer { + public: + using Flavor = SpikeFlavor; + using CircuitConstructor = SpikeCircuitBuilder; + using ProvingKey = Flavor::ProvingKey; + using VerificationKey = Flavor::VerificationKey; + using PCS = Flavor::PCS; + using CommitmentKey = Flavor::CommitmentKey; + using VerifierCommitmentKey = Flavor::VerifierCommitmentKey; + + // TODO: which of these will we really need + static constexpr std::string_view NAME_STRING = "Spike"; + static constexpr size_t NUM_RESERVED_GATES = 0; + static constexpr size_t NUM_WIRES = Flavor::NUM_WIRES; + + std::shared_ptr proving_key; + std::shared_ptr verification_key; + + // The crs_factory holds the path to the srs and exposes methods to extract the srs elements + std::shared_ptr> crs_factory_; + + // The commitment key is passed to the prover but also used herein to compute the verfication key commitments + std::shared_ptr commitment_key; + + std::vector recursive_proof_public_input_indices; + bool contains_recursive_proof = false; + bool computed_witness = false; + + SpikeComposer() { crs_factory_ = bb::srs::get_bn254_crs_factory(); } + + SpikeComposer(std::shared_ptr p_key, std::shared_ptr v_key) + : proving_key(std::move(p_key)) + , verification_key(std::move(v_key)) + {} + + SpikeComposer(SpikeComposer&& other) noexcept = default; + SpikeComposer(SpikeComposer const& other) noexcept = default; + SpikeComposer& operator=(SpikeComposer&& other) noexcept = default; + SpikeComposer& operator=(SpikeComposer const& other) noexcept = default; + ~SpikeComposer() = default; + + std::shared_ptr compute_proving_key(CircuitConstructor& circuit_constructor); + std::shared_ptr compute_verification_key(CircuitConstructor& circuit_constructor); + + void compute_witness(CircuitConstructor& circuit_constructor); + + SpikeProver create_prover(CircuitConstructor& circuit_constructor); + SpikeVerifier create_verifier(CircuitConstructor& circuit_constructor); + + void add_table_column_selector_poly_to_proving_key(bb::polynomial& small, const std::string& tag); + + void compute_commitment_key(size_t circuit_size) + { + proving_key->commitment_key = std::make_shared(circuit_size); + }; +}; + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp new file mode 100644 index 00000000000..f238d047cac --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp @@ -0,0 +1,289 @@ + + +#pragma once +#include "barretenberg/commitment_schemes/kzg/kzg.hpp" +#include "barretenberg/ecc/curves/bn254/g1.hpp" +#include "barretenberg/flavor/relation_definitions.hpp" +#include "barretenberg/polynomials/barycentric.hpp" +#include "barretenberg/polynomials/univariate.hpp" + +#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" + +#include "barretenberg/flavor/flavor.hpp" +#include "barretenberg/flavor/flavor_macros.hpp" +#include "barretenberg/polynomials/evaluation_domain.hpp" +#include "barretenberg/polynomials/polynomial.hpp" +// TODO: had to include below to make it compile +#include "barretenberg/relations/relation_parameters.hpp" +#include "barretenberg/transcript/transcript.hpp" + +namespace bb { + +class SpikeFlavor { + public: + using Curve = curve::BN254; + using G1 = Curve::Group; + using PCS = KZG; + + using FF = G1::subgroup_field; + using Polynomial = bb::Polynomial; + using PolynomialHandle = std::span; + using GroupElement = G1::element; + using Commitment = G1::affine_element; + using CommitmentHandle = G1::affine_element; + using CommitmentKey = bb::CommitmentKey; + using VerifierCommitmentKey = bb::VerifierCommitmentKey; + using RelationSeparator = FF; + + // NEW! + using PublicInputColumns = std::map>; + + static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 0; + static constexpr size_t NUM_WITNESS_ENTITIES = 2; + static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES; + // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for + // the unshifted and one for the shifted + static constexpr size_t NUM_ALL_ENTITIES = 2; + + using Relations = std::tuple<>; + + static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); + + // BATCHED_RELATION_PARTIAL_LENGTH = algebraic degree of sumcheck relation *after* multiplying by the `pow_zeta` + // random polynomial e.g. For \sum(x) [A(x) * B(x) + C(x)] * PowZeta(X), relation length = 2 and random relation + // length = 3 + static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH = MAX_PARTIAL_RELATION_LENGTH + 1; + static constexpr size_t NUM_RELATIONS = std::tuple_size_v; + + template + using ProtogalaxyTupleOfTuplesOfUnivariates = + decltype(create_protogalaxy_tuple_of_tuples_of_univariates()); + using SumcheckTupleOfTuplesOfUnivariates = decltype(create_sumcheck_tuple_of_tuples_of_univariates()); + using TupleOfArraysOfValues = decltype(create_tuple_of_arrays_of_values()); + + static constexpr bool has_zero_row = true; + + private: + template class PrecomputedEntities : public PrecomputedEntitiesBase { + public: + using DataType = DataType_; + + DEFINE_FLAVOR_MEMBERS(DataType, Spike_first) + + RefVector get_selectors() { return {}; }; + RefVector get_sigma_polynomials() { return {}; }; + RefVector get_id_polynomials() { return {}; }; + RefVector get_table_polynomials() { return {}; }; + }; + + template class WitnessEntities { + public: + DEFINE_FLAVOR_MEMBERS(DataType, Spike_kernel_inputs__is_public, Spike_x) + + RefVector get_wires() { return { Spike_kernel_inputs__is_public, Spike_x }; }; + }; + + template class AllEntities { + public: + DEFINE_FLAVOR_MEMBERS(DataType, Spike_first, Spike_kernel_inputs__is_public, Spike_x) + + RefVector get_wires() { return { Spike_first, Spike_kernel_inputs__is_public, Spike_x }; }; + RefVector get_unshifted() { return { Spike_first, Spike_kernel_inputs__is_public, Spike_x }; }; + RefVector get_to_be_shifted() { return {}; }; + RefVector get_shifted() { return {}; }; + }; + + public: + class ProvingKey : public ProvingKey_, WitnessEntities, CommitmentKey> { + public: + // Expose constructors on the base class + using Base = ProvingKey_, WitnessEntities, CommitmentKey>; + using Base::Base; + + RefVector get_to_be_shifted() { return {}; }; + + void compute_logderivative_inverses(const RelationParameters& relation_parameters) + { + ProverPolynomials prover_polynomials = ProverPolynomials(*this); + // TODO: also required this when there were no inverses + // Maybe codegen should be selective over which is created + void(relation_parameters.beta); + } + }; + + using VerificationKey = VerificationKey_, VerifierCommitmentKey>; + + using FoldedPolynomials = AllEntities>; + + class AllValues : public AllEntities { + public: + using Base = AllEntities; + using Base::Base; + }; + + /** + * @brief A container for the prover polynomials handles. + */ + class ProverPolynomials : public AllEntities { + public: + // Define all operations as default, except copy construction/assignment + ProverPolynomials() = default; + ProverPolynomials& operator=(const ProverPolynomials&) = delete; + ProverPolynomials(const ProverPolynomials& o) = delete; + ProverPolynomials(ProverPolynomials&& o) noexcept = default; + ProverPolynomials& operator=(ProverPolynomials&& o) noexcept = default; + ~ProverPolynomials() = default; + + ProverPolynomials(ProvingKey& proving_key) + { + for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key.get_all())) { + ASSERT(flavor_get_label(*this, prover_poly) == flavor_get_label(proving_key, key_poly)); + prover_poly = key_poly.share(); + } + for (auto [prover_poly, key_poly] : zip_view(this->get_shifted(), proving_key.get_to_be_shifted())) { + ASSERT(flavor_get_label(*this, prover_poly) == (flavor_get_label(proving_key, key_poly) + "_shift")); + prover_poly = key_poly.shifted(); + } + } + + [[nodiscard]] size_t get_polynomial_size() const { return Spike_kernel_inputs__is_public.size(); } + /** + * @brief Returns the evaluations of all prover polynomials at one point on the boolean hypercube, which + * represents one row in the execution trace. + */ + [[nodiscard]] AllValues get_row(size_t row_idx) const + { + AllValues result; + for (auto [result_field, polynomial] : zip_view(result.get_all(), this->get_all())) { + result_field = polynomial[row_idx]; + } + return result; + } + }; + + using RowPolynomials = AllEntities; + + class PartiallyEvaluatedMultivariates : public AllEntities { + public: + PartiallyEvaluatedMultivariates() = default; + PartiallyEvaluatedMultivariates(const size_t circuit_size) + { + // Storage is only needed after the first partial evaluation, hence polynomials of size (n / 2) + for (auto& poly : get_all()) { + poly = Polynomial(circuit_size / 2); + } + } + }; + + /** + * @brief A container for univariates used during Protogalaxy folding and sumcheck. + * @details During folding and sumcheck, the prover evaluates the relations on these univariates. + */ + template using ProverUnivariates = AllEntities>; + + /** + * @brief A container for univariates produced during the hot loop in sumcheck. + */ + using ExtendedEdges = ProverUnivariates; + + /** + * @brief A container for the witness commitments. + * + */ + using WitnessCommitments = WitnessEntities; + + class CommitmentLabels : public AllEntities { + private: + using Base = AllEntities; + + public: + CommitmentLabels() + : AllEntities() + { + Base::Spike_first = "SPIKE_FIRST"; + Base::Spike_kernel_inputs__is_public = "SPIKE_KERNEL_INPUTS__IS_PUBLIC"; + Base::Spike_x = "SPIKE_X"; + }; + }; + + class VerifierCommitments : public AllEntities { + private: + using Base = AllEntities; + + public: + VerifierCommitments(const std::shared_ptr& verification_key) + { + Spike_first = verification_key->Spike_first; + } + }; + + class Transcript : public NativeTranscript { + public: + uint32_t circuit_size; + + Commitment Spike_kernel_inputs__is_public; + Commitment Spike_x; + + std::vector> sumcheck_univariates; + std::array sumcheck_evaluations; + std::vector zm_cq_comms; + Commitment zm_cq_comm; + Commitment zm_pi_comm; + + Transcript() = default; + + Transcript(const std::vector& proof) + : NativeTranscript(proof) + {} + + void deserialize_full_transcript() + { + size_t num_frs_read = 0; + circuit_size = deserialize_from_buffer(proof_data, num_frs_read); + size_t log_n = numeric::get_msb(circuit_size); + + Spike_kernel_inputs__is_public = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + Spike_x = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + + for (size_t i = 0; i < log_n; ++i) { + sumcheck_univariates.emplace_back( + deserialize_from_buffer>(Transcript::proof_data, + num_frs_read)); + } + sumcheck_evaluations = + deserialize_from_buffer>(Transcript::proof_data, num_frs_read); + for (size_t i = 0; i < log_n; ++i) { + zm_cq_comms.push_back(deserialize_from_buffer(proof_data, num_frs_read)); + } + zm_cq_comm = deserialize_from_buffer(proof_data, num_frs_read); + zm_pi_comm = deserialize_from_buffer(proof_data, num_frs_read); + } + + void serialize_full_transcript() + { + size_t old_proof_length = proof_data.size(); + Transcript::proof_data.clear(); + size_t log_n = numeric::get_msb(circuit_size); + + serialize_to_buffer(circuit_size, Transcript::proof_data); + + serialize_to_buffer(Spike_kernel_inputs__is_public, Transcript::proof_data); + serialize_to_buffer(Spike_x, Transcript::proof_data); + + for (size_t i = 0; i < log_n; ++i) { + serialize_to_buffer(sumcheck_univariates[i], Transcript::proof_data); + } + serialize_to_buffer(sumcheck_evaluations, Transcript::proof_data); + for (size_t i = 0; i < log_n; ++i) { + serialize_to_buffer(zm_cq_comms[i], proof_data); + } + serialize_to_buffer(zm_cq_comm, proof_data); + serialize_to_buffer(zm_pi_comm, proof_data); + + // sanity check to make sure we generate the same length of proof as before. + ASSERT(proof_data.size() == old_proof_length); + } + }; +}; + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp new file mode 100644 index 00000000000..f5b8a45c8d2 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp @@ -0,0 +1,160 @@ + + +#include "spike_prover.hpp" +#include "barretenberg/commitment_schemes/claim.hpp" +#include "barretenberg/commitment_schemes/commitment_key.hpp" +#include "barretenberg/honk/proof_system/logderivative_library.hpp" +#include "barretenberg/honk/proof_system/permutation_library.hpp" +#include "barretenberg/plonk_honk_shared/library/grand_product_library.hpp" +#include "barretenberg/polynomials/polynomial.hpp" +#include "barretenberg/relations/lookup_relation.hpp" +#include "barretenberg/relations/permutation_relation.hpp" +#include "barretenberg/sumcheck/sumcheck.hpp" + +namespace bb { + +using Flavor = SpikeFlavor; +using FF = Flavor::FF; + +/** + * Create SpikeProver from proving key, witness and manifest. + * + * @param input_key Proving key. + * @param input_manifest Input manifest + * + * @tparam settings Settings class. + * */ +SpikeProver::SpikeProver(std::shared_ptr input_key, + std::shared_ptr commitment_key) + : key(input_key) + , commitment_key(commitment_key) +{ + for (auto [prover_poly, key_poly] : zip_view(prover_polynomials.get_unshifted(), key->get_all())) { + ASSERT(bb::flavor_get_label(prover_polynomials, prover_poly) == bb::flavor_get_label(*key, key_poly)); + prover_poly = key_poly.share(); + } + for (auto [prover_poly, key_poly] : zip_view(prover_polynomials.get_shifted(), key->get_to_be_shifted())) { + ASSERT(bb::flavor_get_label(prover_polynomials, prover_poly) == + bb::flavor_get_label(*key, key_poly) + "_shift"); + prover_poly = key_poly.shifted(); + } +} + +/** + * @brief Add circuit size, public input size, and public inputs to transcript + * + */ +// void SpikeProver::execute_preamble_round(SpikeProver::PublicInputColumns public_inputs) +// TODO(md): as we are sending the commitment to the verifier, we do NOT need to send the public inputs to the verifier +// one by one. We only do so in this case in preparation for when we stop sending the commitment +void SpikeProver::execute_preamble_round(std::vector public_inputs) +{ + const auto circuit_size = static_cast(key->circuit_size); + + transcript->send_to_verifier("circuit_size", circuit_size); + + // send all of the public inputs to the prover - this wont work + for (size_t i = 0; i < public_inputs.size(); ++i) { + auto public_input_i = public_inputs[i]; + // TODO: + transcript->send_to_verifier("public_input_" + std::to_string(i), public_input_i); + } +} + +/** + * @brief Compute commitments to all of the witness wires (apart from the logderivative inverse wires) + * + */ +void SpikeProver::execute_wire_commitments_round() +{ + + // Commit to all polynomials (apart from logderivative inverse polynomials, which are committed to in the later + // logderivative phase) + witness_commitments.Spike_kernel_inputs__is_public = commitment_key->commit(key->Spike_kernel_inputs__is_public); + witness_commitments.Spike_x = commitment_key->commit(key->Spike_x); + + // Send all commitments to the verifier + // transcript->send_to_verifier(commitment_labels.Spike_kernel_inputs__is_public, + // witness_commitments.Spike_kernel_inputs__is_public); + transcript->send_to_verifier(commitment_labels.Spike_x, witness_commitments.Spike_x); +} + +void SpikeProver::execute_log_derivative_inverse_round() +{ + + auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); + relation_parameters.beta = beta; + relation_parameters.gamma = gamm; + + key->compute_logderivative_inverses(relation_parameters); + + // Commit to all logderivative inverse polynomials + + // Send all commitments to the verifier +} + +/** + * @brief Run Sumcheck resulting in u = (u_1,...,u_d) challenges and all evaluations at u being calculated. + * + */ +void SpikeProver::execute_relation_check_rounds() +{ + using Sumcheck = SumcheckProver; + + auto sumcheck = Sumcheck(key->circuit_size, transcript); + + FF alpha = transcript->template get_challenge("Sumcheck:alpha"); + std::vector gate_challenges(numeric::get_msb(key->circuit_size)); + + for (size_t idx = 0; idx < gate_challenges.size(); idx++) { + gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); + } + sumcheck_output = sumcheck.prove(prover_polynomials, relation_parameters, alpha, gate_challenges); +} + +/** + * @brief Execute the ZeroMorph protocol to prove the multilinear evaluations produced by Sumcheck + * @details See https://hackmd.io/dlf9xEwhTQyE3hiGbq4FsA?view for a complete description of the unrolled protocol. + * + * */ +void SpikeProver::execute_zeromorph_rounds() +{ + ZeroMorph::prove(prover_polynomials.get_unshifted(), + prover_polynomials.get_to_be_shifted(), + sumcheck_output.claimed_evaluations.get_unshifted(), + sumcheck_output.claimed_evaluations.get_shifted(), + sumcheck_output.challenge, + commitment_key, + transcript); +} + +HonkProof& SpikeProver::export_proof() +{ + proof = transcript->proof_data; + return proof; +} + +// TODO: maybe the public inputs can be sent in the circuit builder? +HonkProof& SpikeProver::construct_proof(std::vector public_inputs) +{ + // Add circuit size public input size and public inputs to transcript. + execute_preamble_round(public_inputs); + + // Compute wire commitments + execute_wire_commitments_round(); + + // Compute sorted list accumulator and commitment + execute_log_derivative_inverse_round(); + + // Fiat-Shamir: alpha + // Run sumcheck subprotocol. + execute_relation_check_rounds(); + + // Fiat-Shamir: rho, y, x, z + // Execute Zeromorph multilinear PCS + execute_zeromorph_rounds(); + + return export_proof(); +} + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.hpp new file mode 100644 index 00000000000..943160ed715 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.hpp @@ -0,0 +1,66 @@ + + +#pragma once +#include "barretenberg/commitment_schemes/zeromorph/zeromorph.hpp" +#include "barretenberg/plonk/proof_system/types/proof.hpp" +#include "barretenberg/relations/relation_parameters.hpp" +#include "barretenberg/sumcheck/sumcheck_output.hpp" +#include "barretenberg/transcript/transcript.hpp" + +#include "barretenberg/vm/generated/spike_flavor.hpp" + +namespace bb { + +class SpikeProver { + + using Flavor = SpikeFlavor; + using PCS = Flavor::PCS; + using PCSCommitmentKey = Flavor::CommitmentKey; + using ProvingKey = Flavor::ProvingKey; + using Polynomial = Flavor::Polynomial; + using ProverPolynomials = Flavor::ProverPolynomials; + using CommitmentLabels = Flavor::CommitmentLabels; + using Transcript = Flavor::Transcript; + + public: + using FF = Flavor::FF; + using PublicInputColumns = Flavor::PublicInputColumns; + + explicit SpikeProver(std::shared_ptr input_key, std::shared_ptr commitment_key); + + void execute_preamble_round(std::vector public_inputs); + void execute_wire_commitments_round(); + void execute_log_derivative_inverse_round(); + void execute_relation_check_rounds(); + void execute_zeromorph_rounds(); + + HonkProof& export_proof(); + HonkProof& construct_proof(std::vector public_inputs); + + std::shared_ptr transcript = std::make_shared(); + + std::vector public_inputs; + + bb::RelationParameters relation_parameters; + + std::shared_ptr key; + + // Container for spans of all polynomials required by the prover (i.e. all multivariates evaluated by Sumcheck). + ProverPolynomials prover_polynomials; + + CommitmentLabels commitment_labels; + typename Flavor::WitnessCommitments witness_commitments; + + Polynomial quotient_W; + + SumcheckOutput sumcheck_output; + + std::shared_ptr commitment_key; + + using ZeroMorph = ZeroMorphProver_; + + private: + HonkProof proof; +}; + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp new file mode 100644 index 00000000000..992a26e25c3 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp @@ -0,0 +1,128 @@ + + +#include "./spike_verifier.hpp" +#include "barretenberg/commitment_schemes/zeromorph/zeromorph.hpp" +#include "barretenberg/numeric/bitop/get_msb.hpp" +#include "barretenberg/polynomials/polynomial.hpp" +#include "barretenberg/transcript/transcript.hpp" +#include "barretenberg/vm/generated/spike_flavor.hpp" + +namespace bb { +SpikeVerifier::SpikeVerifier(std::shared_ptr verifier_key) + : key(verifier_key) +{} + +SpikeVerifier::SpikeVerifier(SpikeVerifier&& other) noexcept + : key(std::move(other.key)) + , pcs_verification_key(std::move(other.pcs_verification_key)) +{} + +SpikeVerifier& SpikeVerifier::operator=(SpikeVerifier&& other) noexcept +{ + key = other.key; + pcs_verification_key = (std::move(other.pcs_verification_key)); + commitments.clear(); + return *this; +} + +using FF = SpikeVerifier::FF; + +// Evaluations are the evaluations of the polynomial over the boolean hypercube +// The multivariate challenge is the challenge in each variable of the polynomial +// This challenge is generated during the sumcheck protocol +// +// TODO: Using the current evaluate_mle implementation is inefficient +FF evaluate_public_input_column(std::vector evals, std::vector challenges) +{ + Polynomial polynomial(evals); + return polynomial.evaluate_mle(challenges); +} + +/** + * @brief This function verifies an Spike Honk proof for given program settings. + * + */ +// bool SpikeVerifier::verify_proof(const HonkProof& proof, PublicInputColumns public_inputs) +bool SpikeVerifier::verify_proof(const HonkProof& proof, std::vector public_inputs) +{ + using Flavor = SpikeFlavor; + using FF = Flavor::FF; + using Commitment = Flavor::Commitment; + // using PCS = Flavor::PCS; + // using ZeroMorph = ZeroMorphVerifier_; + using VerifierCommitments = Flavor::VerifierCommitments; + using CommitmentLabels = Flavor::CommitmentLabels; + + RelationParameters relation_parameters; + + transcript = std::make_shared(proof); + + VerifierCommitments commitments{ key }; + CommitmentLabels commitment_labels; + + const auto circuit_size = transcript->template receive_from_prover("circuit_size"); + + if (circuit_size != key->circuit_size) { + return false; + } + + // Get commitments to VM wires + commitments.Spike_kernel_inputs__is_public = + transcript->template receive_from_prover(commitment_labels.Spike_kernel_inputs__is_public); + commitments.Spike_x = transcript->template receive_from_prover(commitment_labels.Spike_x); + + auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); + relation_parameters.beta = beta; + relation_parameters.gamma = gamm; + + // Get commitments to inverses + + // Execute Sumcheck Verifier + const size_t log_circuit_size = numeric::get_msb(circuit_size); + auto sumcheck = SumcheckVerifier(log_circuit_size, transcript); + + FF alpha = transcript->template get_challenge("Sumcheck:alpha"); + + auto gate_challenges = std::vector(log_circuit_size); + for (size_t idx = 0; idx < log_circuit_size; idx++) { + gate_challenges[idx] = transcript->template get_challenge("Sumcheck:gate_challenge_" + std::to_string(idx)); + } + + auto [multivariate_challenge, claimed_evaluations, sumcheck_verified] = + sumcheck.verify(relation_parameters, alpha, gate_challenges); + + // If Sumcheck did not verify, return false + if (sumcheck_verified.has_value() && !sumcheck_verified.value()) { + return false; + } + + // Compute the public inputs evaluations, and verify that they match the claimed evaluations + // This is performed later in the verifier such that we can use the same evalutaions that are computed + // during sumcheck and confirmed during zeromorph + // A more optimal implementation would avoid the prover having to compute the commitment to the public inputs + // and compute them at a different challenge earlier in the program + // This would require a change in our zeromorph implementation where it assumes all evaluations were made + // at the same challenge point. + // TODO: document this design choice in a github issue + + info("sumcheck claimed evaluations", claimed_evaluations); + + FF public_column_evaluation = evaluate_public_input_column(public_inputs, multivariate_challenge); + info("public column evaluation: ", public_column_evaluation); + + // Execute ZeroMorph rounds. See https://hackmd.io/dlf9xEwhTQyE3hiGbq4FsA?view for a complete description of the + // unrolled protocol. + // NOTE: temporarily disabled - facing integration issues + // auto pairing_points = ZeroMorph::verify(commitments.get_unshifted(), + // commitments.get_to_be_shifted(), + // claimed_evaluations.get_unshifted(), + // claimed_evaluations.get_shifted(), + // multivariate_challenge, + // transcript); + + // auto verified = pcs_verification_key->pairing_check(pairing_points[0], pairing_points[1]); + // return sumcheck_verified.value() && verified; + return sumcheck_verified.value(); +} + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp new file mode 100644 index 00000000000..c683c3ae173 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp @@ -0,0 +1,36 @@ + + +#pragma once +#include "barretenberg/plonk/proof_system/types/proof.hpp" +#include "barretenberg/sumcheck/sumcheck.hpp" +#include "barretenberg/vm/generated/spike_flavor.hpp" + +namespace bb { +class SpikeVerifier { + using Flavor = SpikeFlavor; + using Commitment = Flavor::Commitment; + using VerificationKey = Flavor::VerificationKey; + using VerifierCommitmentKey = Flavor::VerifierCommitmentKey; + using Transcript = Flavor::Transcript; + + public: + using FF = Flavor::FF; + using PublicInputColumns = Flavor::PublicInputColumns; + + explicit SpikeVerifier(std::shared_ptr verifier_key = nullptr); + SpikeVerifier(SpikeVerifier&& other) noexcept; + SpikeVerifier(const SpikeVerifier& other) = delete; + + SpikeVerifier& operator=(const SpikeVerifier& other) = delete; + SpikeVerifier& operator=(SpikeVerifier&& other) noexcept; + + // bool verify_proof(const HonkProof& proof, PublicInputColumns public_inputs = {}); + bool verify_proof(const HonkProof& proof, std::vector public_inputs = {}); + + std::shared_ptr key; + std::map commitments; + std::shared_ptr pcs_verification_key; + std::shared_ptr transcript; +}; + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp new file mode 100644 index 00000000000..afe03226fd1 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp @@ -0,0 +1,48 @@ +#include "barretenberg/crypto/generators/generator_data.hpp" +#include "barretenberg/numeric/random/engine.hpp" +#include "barretenberg/numeric/uint256/uint256.hpp" +#include "barretenberg/vm/generated/spike_circuit_builder.hpp" +#include "barretenberg/vm/generated/spike_flavor.hpp" + +// Proofs +#include "barretenberg/vm/generated/spike_composer.hpp" +#include "barretenberg/vm/generated/spike_prover.hpp" +#include "barretenberg/vm/generated/spike_verifier.hpp" + +#include + +using namespace bb; +namespace { +auto& engine = numeric::get_debug_randomness(); +} + +// Test file for testing public inputs evaluations are the same in the verifier and in sumcheck + +TEST(SpikeVerifierColumnsCircuitBuilder, VerificationSuccess) +{ + // using FF = SpikeFlavor::FF; + using Builder = SpikeCircuitBuilder; + using Row = Builder::Row; + Builder circuit_builder; + + const size_t circuit_size = 16; + std::vector rows; + + // Add to the public input column that is increasing + for (size_t i = 0; i < circuit_size; i++) { + Row row{ .Spike_kernel_inputs__is_public = i }; + rows.push_back(row); + } + + circuit_builder.set_trace(std::move(rows)); + + // Create a prover and verifier + auto composer = SpikeComposer(); + auto prover = composer.create_prover(circuit_builder); + HonkProof proof = prover.construct_proof(); + + auto verifier = composer.create_verifier(circuit_builder); + bool verified = verifier.verify_proof(proof); + + info("verified: ", verified); +} \ No newline at end of file From 7e84550641d609ff166b2b4dde2522c636b09763 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 11 Apr 2024 15:56:55 +0000 Subject: [PATCH 09/40] feat: bb support for public input columns --- barretenberg/cpp/pil/spike/spike.pil | 8 ++-- .../generated/spike/declare_views.hpp | 1 + .../relations/generated/spike/spike.hpp | 48 +++++++++++++++++++ .../vm/generated/spike_circuit_builder.hpp | 44 ++++++++++++++--- .../vm/generated/spike_flavor.hpp | 22 ++------- .../vm/generated/spike_prover.cpp | 36 +++----------- .../vm/generated/spike_prover.hpp | 8 ++-- .../vm/generated/spike_verifier.cpp | 14 ++---- .../vm/generated/spike_verifier.hpp | 2 +- .../src/barretenberg/vm/tests/spike.test.cpp | 28 +++++++++-- 10 files changed, 136 insertions(+), 75 deletions(-) create mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/spike/spike.hpp diff --git a/barretenberg/cpp/pil/spike/spike.pil b/barretenberg/cpp/pil/spike/spike.pil index 27b4d9355f9..1361c446923 100644 --- a/barretenberg/cpp/pil/spike/spike.pil +++ b/barretenberg/cpp/pil/spike/spike.pil @@ -1,6 +1,8 @@ -namespace Spike(1); +namespace Spike(16); -pol constant y; +pol constant first = [1] + [0]*; pol commit x; -pol public kernel_inputs; \ No newline at end of file +pol public kernel_inputs; + +x - first = 0; \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp index 08ed2f368be..290d0a4077e 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp @@ -2,5 +2,6 @@ #define Spike_DECLARE_VIEWS(index) \ using Accumulator = typename std::tuple_element::type; \ using View = typename Accumulator::View; \ + [[maybe_unused]] auto Spike_first = View(new_term.Spike_first); \ [[maybe_unused]] auto Spike_kernel_inputs__is_public = View(new_term.Spike_kernel_inputs__is_public); \ [[maybe_unused]] auto Spike_x = View(new_term.Spike_x); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/spike/spike.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/spike/spike.hpp new file mode 100644 index 00000000000..2a99922e200 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/spike/spike.hpp @@ -0,0 +1,48 @@ + +#pragma once +#include "../../relation_parameters.hpp" +#include "../../relation_types.hpp" +#include "./declare_views.hpp" + +namespace bb::Spike_vm { + +template struct SpikeRow { + FF Spike_first{}; + FF Spike_x{}; +}; + +inline std::string get_relation_label_spike(int index) +{ + switch (index) {} + return std::to_string(index); +} + +template class spikeImpl { + public: + using FF = FF_; + + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 2, + }; + + template + void static accumulate(ContainerOverSubrelations& evals, + const AllEntities& new_term, + [[maybe_unused]] const RelationParameters&, + [[maybe_unused]] const FF& scaling_factor) + { + + // Contribution 0 + { + Spike_DECLARE_VIEWS(0); + + auto tmp = (Spike_x - Spike_first); + tmp *= scaling_factor; + std::get<0>(evals) += tmp; + } + } +}; + +template using spike = Relation>; + +} // namespace bb::Spike_vm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp index 0e36810ca80..b274ddd8f29 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp @@ -11,12 +11,13 @@ #include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp" #include "barretenberg/stdlib_circuit_builders/circuit_builder_base.hpp" +#include "barretenberg/relations/generated/spike/spike.hpp" #include "barretenberg/vm/generated/spike_flavor.hpp" namespace bb { template struct SpikeFullRow { - FF Spike_first; + FF Spike_first{}; FF Spike_kernel_inputs__is_public{}; FF Spike_x{}; }; @@ -31,8 +32,8 @@ class SpikeCircuitBuilder { using Polynomial = Flavor::Polynomial; using ProverPolynomials = Flavor::ProverPolynomials; - static constexpr size_t num_fixed_columns = 2; - static constexpr size_t num_polys = 2; + static constexpr size_t num_fixed_columns = 3; + static constexpr size_t num_polys = 3; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -58,9 +59,40 @@ class SpikeCircuitBuilder { [[maybe_unused]] bool check_circuit() { - // There are no relations, so check circuit does nothing - // auto polys = compute_polynomials(); - // const size_t num_rows = polys.get_polynomial_size(); + + auto polys = compute_polynomials(); + const size_t num_rows = polys.get_polynomial_size(); + + const auto evaluate_relation = [&](const std::string& relation_name, + std::string (*debug_label)(int)) { + typename Relation::SumcheckArrayOfValuesOverSubrelations result; + for (auto& r : result) { + r = 0; + } + constexpr size_t NUM_SUBRELATIONS = result.size(); + + for (size_t i = 0; i < num_rows; ++i) { + Relation::accumulate(result, polys.get_row(i), {}, 1); + + bool x = true; + for (size_t j = 0; j < NUM_SUBRELATIONS; ++j) { + if (result[j] != 0) { + std::string row_name = debug_label(static_cast(j)); + throw_or_abort( + format("Relation ", relation_name, ", subrelation index ", row_name, " failed at row ", i)); + x = false; + } + } + if (!x) { + return false; + } + } + return true; + }; + + if (!evaluate_relation.template operator()>("spike", Spike_vm::get_relation_label_spike)) { + return false; + } return true; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp index f238d047cac..f716b4c9c00 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp @@ -13,8 +13,7 @@ #include "barretenberg/flavor/flavor_macros.hpp" #include "barretenberg/polynomials/evaluation_domain.hpp" #include "barretenberg/polynomials/polynomial.hpp" -// TODO: had to include below to make it compile -#include "barretenberg/relations/relation_parameters.hpp" +#include "barretenberg/relations/generated/spike/spike.hpp" #include "barretenberg/transcript/transcript.hpp" namespace bb { @@ -35,17 +34,14 @@ class SpikeFlavor { using VerifierCommitmentKey = bb::VerifierCommitmentKey; using RelationSeparator = FF; - // NEW! - using PublicInputColumns = std::map>; - - static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 0; + static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 1; static constexpr size_t NUM_WITNESS_ENTITIES = 2; static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES; // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for // the unshifted and one for the shifted - static constexpr size_t NUM_ALL_ENTITIES = 2; + static constexpr size_t NUM_ALL_ENTITIES = 3; - using Relations = std::tuple<>; + using Relations = std::tuple>; static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length(); @@ -70,7 +66,7 @@ class SpikeFlavor { DEFINE_FLAVOR_MEMBERS(DataType, Spike_first) - RefVector get_selectors() { return {}; }; + RefVector get_selectors() { return { Spike_first }; }; RefVector get_sigma_polynomials() { return {}; }; RefVector get_id_polynomials() { return {}; }; RefVector get_table_polynomials() { return {}; }; @@ -101,14 +97,6 @@ class SpikeFlavor { using Base::Base; RefVector get_to_be_shifted() { return {}; }; - - void compute_logderivative_inverses(const RelationParameters& relation_parameters) - { - ProverPolynomials prover_polynomials = ProverPolynomials(*this); - // TODO: also required this when there were no inverses - // Maybe codegen should be selective over which is created - void(relation_parameters.beta); - } }; using VerificationKey = VerificationKey_, VerifierCommitmentKey>; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp index f5b8a45c8d2..bc0759df84a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp @@ -44,21 +44,11 @@ SpikeProver::SpikeProver(std::shared_ptr input_key, * @brief Add circuit size, public input size, and public inputs to transcript * */ -// void SpikeProver::execute_preamble_round(SpikeProver::PublicInputColumns public_inputs) -// TODO(md): as we are sending the commitment to the verifier, we do NOT need to send the public inputs to the verifier -// one by one. We only do so in this case in preparation for when we stop sending the commitment -void SpikeProver::execute_preamble_round(std::vector public_inputs) +void SpikeProver::execute_preamble_round() { const auto circuit_size = static_cast(key->circuit_size); transcript->send_to_verifier("circuit_size", circuit_size); - - // send all of the public inputs to the prover - this wont work - for (size_t i = 0; i < public_inputs.size(); ++i) { - auto public_input_i = public_inputs[i]; - // TODO: - transcript->send_to_verifier("public_input_" + std::to_string(i), public_input_i); - } } /** @@ -74,24 +64,12 @@ void SpikeProver::execute_wire_commitments_round() witness_commitments.Spike_x = commitment_key->commit(key->Spike_x); // Send all commitments to the verifier - // transcript->send_to_verifier(commitment_labels.Spike_kernel_inputs__is_public, - // witness_commitments.Spike_kernel_inputs__is_public); + transcript->send_to_verifier(commitment_labels.Spike_kernel_inputs__is_public, + witness_commitments.Spike_kernel_inputs__is_public); transcript->send_to_verifier(commitment_labels.Spike_x, witness_commitments.Spike_x); } -void SpikeProver::execute_log_derivative_inverse_round() -{ - - auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); - relation_parameters.beta = beta; - relation_parameters.gamma = gamm; - - key->compute_logderivative_inverses(relation_parameters); - - // Commit to all logderivative inverse polynomials - - // Send all commitments to the verifier -} +void SpikeProver::execute_log_derivative_inverse_round() {} /** * @brief Run Sumcheck resulting in u = (u_1,...,u_d) challenges and all evaluations at u being calculated. @@ -134,17 +112,15 @@ HonkProof& SpikeProver::export_proof() return proof; } -// TODO: maybe the public inputs can be sent in the circuit builder? -HonkProof& SpikeProver::construct_proof(std::vector public_inputs) +HonkProof& SpikeProver::construct_proof() { // Add circuit size public input size and public inputs to transcript. - execute_preamble_round(public_inputs); + execute_preamble_round(); // Compute wire commitments execute_wire_commitments_round(); // Compute sorted list accumulator and commitment - execute_log_derivative_inverse_round(); // Fiat-Shamir: alpha // Run sumcheck subprotocol. diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.hpp index 943160ed715..e80b92f384f 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.hpp @@ -14,6 +14,7 @@ namespace bb { class SpikeProver { using Flavor = SpikeFlavor; + using FF = Flavor::FF; using PCS = Flavor::PCS; using PCSCommitmentKey = Flavor::CommitmentKey; using ProvingKey = Flavor::ProvingKey; @@ -23,19 +24,16 @@ class SpikeProver { using Transcript = Flavor::Transcript; public: - using FF = Flavor::FF; - using PublicInputColumns = Flavor::PublicInputColumns; - explicit SpikeProver(std::shared_ptr input_key, std::shared_ptr commitment_key); - void execute_preamble_round(std::vector public_inputs); + void execute_preamble_round(); void execute_wire_commitments_round(); void execute_log_derivative_inverse_round(); void execute_relation_check_rounds(); void execute_zeromorph_rounds(); HonkProof& export_proof(); - HonkProof& construct_proof(std::vector public_inputs); + HonkProof& construct_proof(); std::shared_ptr transcript = std::make_shared(); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp index 992a26e25c3..6ca0e15eaa1 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp @@ -32,9 +32,9 @@ using FF = SpikeVerifier::FF; // This challenge is generated during the sumcheck protocol // // TODO: Using the current evaluate_mle implementation is inefficient -FF evaluate_public_input_column(std::vector evals, std::vector challenges) +FF evaluate_public_input_column(std::vector points, std::vector challenges) { - Polynomial polynomial(evals); + Polynomial polynomial(points); return polynomial.evaluate_mle(challenges); } @@ -71,10 +71,6 @@ bool SpikeVerifier::verify_proof(const HonkProof& proof, std::vector public_ transcript->template receive_from_prover(commitment_labels.Spike_kernel_inputs__is_public); commitments.Spike_x = transcript->template receive_from_prover(commitment_labels.Spike_x); - auto [beta, gamm] = transcript->template get_challenges("beta", "gamma"); - relation_parameters.beta = beta; - relation_parameters.gamma = gamm; - // Get commitments to inverses // Execute Sumcheck Verifier @@ -105,10 +101,10 @@ bool SpikeVerifier::verify_proof(const HonkProof& proof, std::vector public_ // at the same challenge point. // TODO: document this design choice in a github issue - info("sumcheck claimed evaluations", claimed_evaluations); - FF public_column_evaluation = evaluate_public_input_column(public_inputs, multivariate_challenge); - info("public column evaluation: ", public_column_evaluation); + if (public_column_evaluation != claimed_evaluations.Spike_kernel_inputs__is_public) { + return false; + } // Execute ZeroMorph rounds. See https://hackmd.io/dlf9xEwhTQyE3hiGbq4FsA?view for a complete description of the // unrolled protocol. diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp index c683c3ae173..8dc10538321 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp @@ -15,7 +15,7 @@ class SpikeVerifier { public: using FF = Flavor::FF; - using PublicInputColumns = Flavor::PublicInputColumns; + // using PublicInputColumns = Flavor::PublicInputColumns; explicit SpikeVerifier(std::shared_ptr verifier_key = nullptr); SpikeVerifier(SpikeVerifier&& other) noexcept; diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp index afe03226fd1..987164b35f7 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp @@ -16,22 +16,33 @@ namespace { auto& engine = numeric::get_debug_randomness(); } +class SpikeVerifierColumnsCircuitBuilderTests : public ::testing::Test { + protected: + // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test. + void SetUp() override { srs::init_crs_factory("../srs_db/ignition"); }; +}; + // Test file for testing public inputs evaluations are the same in the verifier and in sumcheck -TEST(SpikeVerifierColumnsCircuitBuilder, VerificationSuccess) +TEST(SpikeVerifierColumnsCircuitBuilderTests, VerificationSuccess) { - // using FF = SpikeFlavor::FF; + using FF = SpikeFlavor::FF; using Builder = SpikeCircuitBuilder; using Row = Builder::Row; Builder circuit_builder; + srs::init_crs_factory("../srs_db/ignition"); + const size_t circuit_size = 16; std::vector rows; + std::vector public_inputs; // Add to the public input column that is increasing for (size_t i = 0; i < circuit_size; i++) { + // Make sure the external and trace public inputs are the same Row row{ .Spike_kernel_inputs__is_public = i }; rows.push_back(row); + public_inputs.emplace_back(i); } circuit_builder.set_trace(std::move(rows)); @@ -42,7 +53,16 @@ TEST(SpikeVerifierColumnsCircuitBuilder, VerificationSuccess) HonkProof proof = prover.construct_proof(); auto verifier = composer.create_verifier(circuit_builder); - bool verified = verifier.verify_proof(proof); + bool verified = verifier.verify_proof(proof, public_inputs); + + ASSERT_TRUE(verified); - info("verified: ", verified); + // Assert that the same proof fails with different public inputs + std::vector failure_public_inputs; + for (size_t i = 0; i < circuit_size; i++) { + // Make sure the external and trace public inputs are NOT same + failure_public_inputs.emplace_back(i + 1); + } + bool verification_failure = verifier.verify_proof(proof, failure_public_inputs); + ASSERT_FALSE(verification_failure); } \ No newline at end of file From f38773f35c48c69838e3c26c08c315be59c6f230 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 11 Apr 2024 16:18:51 +0000 Subject: [PATCH 10/40] merge fixy --- .../vm/tests/avm_arithmetic.test.cpp | 228 ------------------ .../vm/tests/avm_bitwise.test.cpp | 16 -- .../vm/tests/avm_control_flow.test.cpp | 16 -- .../vm/tests/avm_indirect_mem.test.cpp | 12 - .../vm/tests/avm_mem_opcodes.test.cpp | 19 -- .../barretenberg/vm/tests/avm_memory.test.cpp | 8 - 6 files changed, 299 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp index 6079d8e745a..d0dceddcb1a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp @@ -334,11 +334,7 @@ TEST_F(AvmArithmeticTestsFF, addition) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over finite field type. @@ -358,11 +354,7 @@ TEST_F(AvmArithmeticTestsFF, subtraction) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); avm_trace::log_avm_trace(trace, 0, 10); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic multiplication over finite field type. @@ -382,11 +374,7 @@ TEST_F(AvmArithmeticTestsFF, multiplication) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on multiplication by zero over finite field type. @@ -406,11 +394,7 @@ TEST_F(AvmArithmeticTestsFF, multiplicationByZero) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic division over finite field type. @@ -433,11 +417,7 @@ TEST_F(AvmArithmeticTestsFF, division) EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); EXPECT_EQ(row->avm_main_rwc, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on division with zero numerator over finite field type. @@ -460,11 +440,7 @@ TEST_F(AvmArithmeticTestsFF, divisionNumeratorZero) EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); EXPECT_EQ(row->avm_main_rwc, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on division by zero over finite field type. @@ -489,11 +465,7 @@ TEST_F(AvmArithmeticTestsFF, divisionByZeroError) EXPECT_EQ(row->avm_main_rwc, FF(1)); EXPECT_EQ(row->avm_main_op_err, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on division of zero by zero over finite field type. @@ -516,11 +488,7 @@ TEST_F(AvmArithmeticTestsFF, divisionZeroByZeroError) EXPECT_EQ(row->avm_main_rwc, FF(1)); EXPECT_EQ(row->avm_main_op_err, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Testing an execution of the different arithmetic opcodes over finite field @@ -545,11 +513,7 @@ TEST_F(AvmArithmeticTestsFF, mixedOperationsWithError) trace_builder.halt(); auto trace = trace_builder.finalize(); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test of equality on FF elements @@ -567,11 +531,7 @@ TEST_F(AvmArithmeticTestsFF, equality) EXPECT_EQ(alu_row.avm_alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); // Expect 0 as inv of (q-1) - (q-1) -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test correct non-equality of FF elements @@ -588,11 +548,7 @@ TEST_F(AvmArithmeticTestsFF, nonEquality) EXPECT_EQ(alu_row.avm_alu_ff_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-1).invert()); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } /****************************************************************************** @@ -617,11 +573,7 @@ TEST_F(AvmArithmeticTestsU8, addition) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(91)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic addition over u8 type with carry. @@ -643,11 +595,7 @@ TEST_F(AvmArithmeticTestsU8, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(3)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over u8 type. @@ -668,11 +616,7 @@ TEST_F(AvmArithmeticTestsU8, subtraction) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(133)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on subtraction over u8 type with carry. @@ -702,11 +646,7 @@ TEST_F(AvmArithmeticTestsU8, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic multiplication over u8 type. @@ -729,11 +669,7 @@ TEST_F(AvmArithmeticTestsU8, multiplication) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(195)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on multiplication over u8 type with overflow. @@ -757,11 +693,7 @@ TEST_F(AvmArithmeticTestsU8, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(208)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(132)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test of equality on u8 elements @@ -774,11 +706,7 @@ TEST_F(AvmArithmeticTestsU8, equality) EXPECT_EQ(alu_row.avm_alu_u8_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test correct non-equality of U8 elements @@ -791,11 +719,7 @@ TEST_F(AvmArithmeticTestsU8, nonEquality) EXPECT_EQ(alu_row.avm_alu_u8_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-116).invert()); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } /****************************************************************************** @@ -821,11 +745,7 @@ TEST_F(AvmArithmeticTestsU16, addition) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0xDC)); // 34780 = 0x87DC EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0x87)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic addition over u16 type with carry. @@ -847,11 +767,7 @@ TEST_F(AvmArithmeticTestsU16, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(17)); EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over u16 type. @@ -874,11 +790,7 @@ TEST_F(AvmArithmeticTestsU16, subtraction) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0x79)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over u16 type with carry. @@ -908,11 +820,7 @@ TEST_F(AvmArithmeticTestsU16, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic multiplication over u16 type. @@ -937,11 +845,7 @@ TEST_F(AvmArithmeticTestsU16, multiplication) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(0xBF)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on multiplication over u16 type with overflow. @@ -967,11 +871,7 @@ TEST_F(AvmArithmeticTestsU16, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(8)); EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test of equality on U16 elements @@ -984,11 +884,7 @@ TEST_F(AvmArithmeticTestsU16, equality) EXPECT_EQ(alu_row.avm_alu_u16_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test correct non-equality of U16 elements @@ -1001,11 +897,7 @@ TEST_F(AvmArithmeticTestsU16, nonEquality) EXPECT_EQ(alu_row.avm_alu_u16_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(-14'300).invert()); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } /****************************************************************************** @@ -1032,11 +924,7 @@ TEST_F(AvmArithmeticTestsU32, addition) EXPECT_EQ(alu_row.avm_alu_u8_r1, FF((2234567891LLU >> 8) & UINT8_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(2234567891LLU >> 16)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic addition over u32 type with carry. @@ -1058,11 +946,7 @@ TEST_F(AvmArithmeticTestsU32, additionCarry) EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(231)); // 999 = 3 * 256 + 231 EXPECT_EQ(alu_row.avm_alu_u8_r1, FF(3)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over u32 type. @@ -1088,11 +972,7 @@ TEST_F(AvmArithmeticTestsU32, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r0, FF(0x69F)); EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over u32 type with carry. @@ -1124,11 +1004,7 @@ TEST_F(AvmArithmeticTestsU32, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic multiplication over u32 type. @@ -1157,11 +1033,7 @@ TEST_F(AvmArithmeticTestsU32, multiplication) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on multiplication over u32 type with overflow. @@ -1190,11 +1062,7 @@ TEST_F(AvmArithmeticTestsU32, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(71)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test of equality on U32 elements @@ -1208,11 +1076,7 @@ TEST_F(AvmArithmeticTestsU32, equality) EXPECT_EQ(alu_row.avm_alu_u32_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test correct non-equality of U32 elements @@ -1226,11 +1090,7 @@ TEST_F(AvmArithmeticTestsU32, nonEquality) EXPECT_EQ(alu_row.avm_alu_u32_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(1).invert()); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } /****************************************************************************** @@ -1264,11 +1124,7 @@ TEST_F(AvmArithmeticTestsU64, addition) EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(0x3684)); EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0x24)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic addition over u64 type with carry. @@ -1296,11 +1152,7 @@ TEST_F(AvmArithmeticTestsU64, additionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r1, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(UINT16_MAX)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over u64 type. @@ -1331,11 +1183,7 @@ TEST_F(AvmArithmeticTestsU64, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0X23)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over u64 type with carry. @@ -1368,11 +1216,7 @@ TEST_F(AvmArithmeticTestsU64, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r4, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic multiplication over u64 type. @@ -1401,11 +1245,7 @@ TEST_F(AvmArithmeticTestsU64, multiplication) EXPECT_EQ(alu_row.avm_alu_u16_r2, FF(0x7B5)); EXPECT_EQ(alu_row.avm_alu_u16_r3, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on multiplication over u64 type with overflow. @@ -1440,11 +1280,7 @@ TEST_F(AvmArithmeticTestsU64, multiplicationOverflow) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(UINT16_MAX)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(UINT16_MAX)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } TEST_F(AvmArithmeticTestsU64, equality) @@ -1457,11 +1293,7 @@ TEST_F(AvmArithmeticTestsU64, equality) EXPECT_EQ(alu_row.avm_alu_u64_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test correct non-equality of U64 elements @@ -1475,11 +1307,7 @@ TEST_F(AvmArithmeticTestsU64, nonEquality) EXPECT_EQ(alu_row.avm_alu_u64_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0x510000).invert()); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } /****************************************************************************** @@ -1522,11 +1350,7 @@ TEST_F(AvmArithmeticTestsU128, addition) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0x4444)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0x8888)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic addition over u128 type with carry. @@ -1566,11 +1390,7 @@ TEST_F(AvmArithmeticTestsU128, additionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0xFFFF)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0xFFFF)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over u128 type. @@ -1612,11 +1432,7 @@ TEST_F(AvmArithmeticTestsU128, subtraction) EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r7, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic subtraction over u128 type with carry. @@ -1656,11 +1472,7 @@ TEST_F(AvmArithmeticTestsU128, subtractionCarry) EXPECT_EQ(alu_row.avm_alu_u16_r5, FF(0)); EXPECT_EQ(alu_row.avm_alu_u16_r6, FF(0x2222)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on basic multiplication over u128 type. @@ -1694,11 +1506,7 @@ TEST_F(AvmArithmeticTestsU128, multiplication) EXPECT_EQ(alu_row_second.avm_alu_u16_r1, FF(0x762C)); EXPECT_EQ(alu_row_second.avm_alu_u16_r2, FF(0xF92C)); EXPECT_EQ(alu_row_second.avm_alu_u16_r3, FF(0x1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test on multiplication over u128 type with overflow. @@ -1758,11 +1566,7 @@ TEST_F(AvmArithmeticTestsU128, multiplicationOverflow) EXPECT_EQ(alu_row_first.avm_alu_u64_r0, FF{ UINT64_MAX - 6 }); // 2^64 - 7 EXPECT_EQ(alu_row_first.avm_alu_cf, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } TEST_F(AvmArithmeticTestsU128, equality) @@ -1782,11 +1586,7 @@ TEST_F(AvmArithmeticTestsU128, equality) EXPECT_EQ(alu_row.avm_alu_u128_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Test correct non-equality of U128 elements @@ -1808,11 +1608,7 @@ TEST_F(AvmArithmeticTestsU128, nonEquality) EXPECT_EQ(alu_row.avm_alu_u128_tag, FF(1)); EXPECT_EQ(alu_row.avm_alu_op_eq_diff_inv, FF(0xdeadbeefLLU << 32).invert()); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } /****************************************************************************** @@ -2032,11 +1828,7 @@ TEST_F(AvmArithmeticNegativeTestsFF, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(4); -<<<<<<< HEAD - EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); -======= EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "OUTPUT_U8"); ->>>>>>> master } // Tests a situation for field elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2104,11 +1896,7 @@ TEST_F(AvmArithmeticNegativeTestsU8, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(3); -<<<<<<< HEAD - EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); -======= EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "OUTPUT_U8"); ->>>>>>> master } // Tests a situation for U8 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2175,11 +1963,7 @@ TEST_F(AvmArithmeticNegativeTestsU16, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(5); -<<<<<<< HEAD - EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); -======= EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "OUTPUT_U8"); ->>>>>>> master } // Tests a situation for U16 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2246,11 +2030,7 @@ TEST_F(AvmArithmeticNegativeTestsU32, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(6); -<<<<<<< HEAD - EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); -======= EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "OUTPUT_U8"); ->>>>>>> master } // Tests a situation for U32 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2324,11 +2104,7 @@ TEST_F(AvmArithmeticNegativeTestsU64, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(2); -<<<<<<< HEAD - EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); -======= EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "OUTPUT_U8"); ->>>>>>> master } // Tests a situation for U64 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; @@ -2427,11 +2203,7 @@ TEST_F(AvmArithmeticNegativeTestsU128, eqOutputWrongTag) ASSERT_TRUE(row != trace.end()); row->avm_main_w_in_tag = FF(4); -<<<<<<< HEAD - EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "EQ_OUTPUT_U8"); -======= EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "OUTPUT_U8"); ->>>>>>> master } // Tests a situation for U128 elements the (a-b)^1 is incorrect. i.e. (a-b) * (a-b)^1 != 1 for (a-b) != 0; diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp index c3ea2ad02ff..ce4e07e8f2c 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp @@ -355,11 +355,7 @@ TEST_P(AvmBitwiseTestsNot, ParamTest) FF ff_a = FF(uint256_t::from_uint128(a)); FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_op_not(trace, ff_a, ff_output, FF(0), FF(1), mem_tag); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, @@ -381,11 +377,7 @@ TEST_P(AvmBitwiseTestsAnd, AllAndTest) FF ff_output = FF(uint256_t::from_uint128(output)); // EXPECT_EQ(1, 2) << "a ^ b " << (a ^ b) << '\n'; common_validate_bit_op(trace, 0, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsAnd, @@ -406,11 +398,7 @@ TEST_P(AvmBitwiseTestsOr, AllOrTest) FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_bit_op(trace, 1, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsOr, @@ -431,11 +419,7 @@ TEST_P(AvmBitwiseTestsXor, AllXorTest) FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_bit_op(trace, 2, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp index 31ae527db14..5e7631bebfc 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_control_flow.test.cpp @@ -54,11 +54,7 @@ TEST_F(AvmControlFlowTests, simpleCall) EXPECT_EQ(halt_row->avm_main_pc, FF(CALL_ADDRESS)); EXPECT_EQ(halt_row->avm_main_internal_return_ptr, FF(AvmTraceBuilder::CALLSTACK_OFFSET + 1)); } -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } TEST_F(AvmControlFlowTests, simpleJump) @@ -91,11 +87,7 @@ TEST_F(AvmControlFlowTests, simpleJump) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avm_main_pc, FF(JUMP_ADDRESS)); } -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } TEST_F(AvmControlFlowTests, simpleCallAndReturn) @@ -145,11 +137,7 @@ TEST_F(AvmControlFlowTests, simpleCallAndReturn) EXPECT_EQ(halt_row->avm_main_pc, FF(RETURN_ADDRESS)); } -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } TEST_F(AvmControlFlowTests, multipleCallsAndReturns) @@ -292,10 +280,6 @@ TEST_F(AvmControlFlowTests, multipleCallsAndReturns) EXPECT_TRUE(halt_row != trace.end()); EXPECT_EQ(halt_row->avm_main_pc, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } } // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp index 1b6e55da9e3..9d2696a6dd3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_indirect_mem.test.cpp @@ -63,11 +63,7 @@ TEST_F(AvmIndirectMemTests, allIndirectAdd) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Testing a subtraction operation with direct input operands a, b, and an indirect @@ -113,11 +109,7 @@ TEST_F(AvmIndirectMemTests, indirectOutputSub) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Testing a multiplication operation with indirect input operand a, @@ -163,11 +155,7 @@ TEST_F(AvmIndirectMemTests, indirectInputAMul) EXPECT_EQ(row->avm_main_mem_op_b, FF(1)); EXPECT_EQ(row->avm_main_mem_op_c, FF(1)); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp index 08f63ac7062..b02ee50d2ec 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_mem_opcodes.test.cpp @@ -221,9 +221,6 @@ class AvmMemOpcodeTests : public ::testing::Test { Field(&Row::avm_mem_ind_op_c, 1))); } -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); } @@ -320,7 +317,6 @@ class AvmMemOpcodeTests : public ::testing::Test { Field("skip_check_tag", &Row::avm_mem_skip_check_tag, 1), Field("op_d", &Row::avm_mem_op_d, 1), Field("ind_op_d", &Row::avm_mem_ind_op_d, 0))); ->>>>>>> master } }; @@ -395,11 +391,7 @@ TEST_F(AvmMemOpcodeTests, indirectMovInvalidAddressTag) Field(&Row::avm_mem_r_in_tag, static_cast(AvmMemoryTag::U32)), Field(&Row::avm_mem_ind_op_c, 1))); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } /****************************************************************************** @@ -637,11 +629,7 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputValue) compute_mov_indices(false); trace.at(main_idx).avm_main_ic = 233; -<<<<<<< HEAD - EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE"); -======= EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_A"); ->>>>>>> master } TEST_F(AvmMemOpcodeNegativeTests, indMovWrongOutputValue) @@ -650,11 +638,7 @@ TEST_F(AvmMemOpcodeNegativeTests, indMovWrongOutputValue) compute_mov_indices(true); trace.at(main_idx).avm_main_ic = 8733; -<<<<<<< HEAD - EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE"); -======= EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "MOV_SAME_VALUE_A"); ->>>>>>> master } // We want to test that the output tag for MOV cannot be altered. @@ -739,8 +723,6 @@ TEST_F(AvmMemOpcodeNegativeTests, movWrongOutputTagMainTraceRead) trace.at(mem_c_idx).avm_mem_w_in_tag = tag_u64; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_C"); -<<<<<<< HEAD -======= } /****************************************************************************** @@ -800,7 +782,6 @@ TEST_F(AvmMemOpcodeNegativeTests, cmovBSkipCheckAbuseDisableSelMovB) trace.at(mem_b_idx).avm_mem_sel_mov_b = 0; EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace)), "PERM_MAIN_MEM_B"); ->>>>>>> master } } // namespace tests_avm diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp index ce53c70aec6..0b365104e16 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_memory.test.cpp @@ -69,11 +69,7 @@ TEST_F(AvmMemoryTests, mismatchedTagAddOperation) EXPECT_EQ(row->avm_mem_r_in_tag, FF(static_cast(AvmMemoryTag::U8))); EXPECT_EQ(row->avm_mem_tag, FF(static_cast(AvmMemoryTag::FF))); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Testing an equality operation with a mismatched memory tag. @@ -116,11 +112,7 @@ TEST_F(AvmMemoryTests, mismatchedTagEqOperation) EXPECT_EQ(row->avm_mem_r_in_tag, FF(static_cast(AvmMemoryTag::U32))); EXPECT_EQ(row->avm_mem_tag, FF(static_cast(AvmMemoryTag::U16))); -<<<<<<< HEAD - validate_trace_check_circuit(std::move(trace)); -======= validate_trace(std::move(trace)); ->>>>>>> master } // Testing violation that m_lastAccess is a delimiter for two different addresses From a4262dc8e17864f53e12ebed8086491bb44b5f99 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 11 Apr 2024 16:46:18 +0000 Subject: [PATCH 11/40] chore: test structure --- .../src/barretenberg/vm/tests/spike.test.cpp | 37 +++++++++++-------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp index 987164b35f7..53bf8e31bbf 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp @@ -16,17 +16,18 @@ namespace { auto& engine = numeric::get_debug_randomness(); } -class SpikeVerifierColumnsCircuitBuilderTests : public ::testing::Test { +class SpikePublicColumnsTests : public ::testing::Test { protected: // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test. void SetUp() override { srs::init_crs_factory("../srs_db/ignition"); }; }; // Test file for testing public inputs evaluations are the same in the verifier and in sumcheck - -TEST(SpikeVerifierColumnsCircuitBuilderTests, VerificationSuccess) +// +// The first test runs the verification with the same public inputs in the verifier and in the prover, prover inputs are +// set in the below function The second failure test runs the verification with the different public inputs +bool verify_spike_with_public_with_public_inputs(std::vector verifier_public__inputs) { - using FF = SpikeFlavor::FF; using Builder = SpikeCircuitBuilder; using Row = Builder::Row; Builder circuit_builder; @@ -35,14 +36,12 @@ TEST(SpikeVerifierColumnsCircuitBuilderTests, VerificationSuccess) const size_t circuit_size = 16; std::vector rows; - std::vector public_inputs; // Add to the public input column that is increasing for (size_t i = 0; i < circuit_size; i++) { // Make sure the external and trace public inputs are the same - Row row{ .Spike_kernel_inputs__is_public = i }; + Row row{ .Spike_kernel_inputs__is_public = i + 1 }; rows.push_back(row); - public_inputs.emplace_back(i); } circuit_builder.set_trace(std::move(rows)); @@ -53,16 +52,22 @@ TEST(SpikeVerifierColumnsCircuitBuilderTests, VerificationSuccess) HonkProof proof = prover.construct_proof(); auto verifier = composer.create_verifier(circuit_builder); - bool verified = verifier.verify_proof(proof, public_inputs); + return verifier.verify_proof(proof, verifier_public__inputs); +} + +TEST(SpikePublicColumnsTests, VerificationSuccess) +{ + std::vector public_inputs = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; + bool verified = verify_spike_with_public_with_public_inputs(public_inputs); ASSERT_TRUE(verified); +} - // Assert that the same proof fails with different public inputs - std::vector failure_public_inputs; - for (size_t i = 0; i < circuit_size; i++) { - // Make sure the external and trace public inputs are NOT same - failure_public_inputs.emplace_back(i + 1); - } - bool verification_failure = verifier.verify_proof(proof, failure_public_inputs); - ASSERT_FALSE(verification_failure); +TEST(SpikePublicColumnsTests, VerificationFailure) +{ + std::vector public_inputs = { + 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160 + }; + bool verified = verify_spike_with_public_with_public_inputs(public_inputs); + ASSERT_FALSE(verified); } \ No newline at end of file From cf4bb86ff21eee5aad919487386ed0eb0aa9222a Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 11 Apr 2024 16:48:13 +0000 Subject: [PATCH 12/40] =?UTF-8?q?=F0=9F=A7=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- barretenberg/cpp/src/barretenberg/crypto/poseidon2/c_bind.hpp | 1 - 1 file changed, 1 deletion(-) diff --git a/barretenberg/cpp/src/barretenberg/crypto/poseidon2/c_bind.hpp b/barretenberg/cpp/src/barretenberg/crypto/poseidon2/c_bind.hpp index 7fafe6c867f..e113b523dd1 100644 --- a/barretenberg/cpp/src/barretenberg/crypto/poseidon2/c_bind.hpp +++ b/barretenberg/cpp/src/barretenberg/crypto/poseidon2/c_bind.hpp @@ -8,6 +8,5 @@ extern "C" { using namespace bb; WASM_EXPORT void poseidon_hash(fr::vec_in_buf inputs_buffer, fr::out_buf output); -WASM_EXPORT void poseidon2_permutation(fr::vec_in_buf in_state, fr::out_buf out_state); WASM_EXPORT void poseidon_hashes(fr::vec_in_buf inputs_buffer, fr::out_buf output); } \ No newline at end of file From 12a978985a05beb6699d3a3242de368cda50ef9c Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 12 Apr 2024 12:15:00 +0000 Subject: [PATCH 13/40] use pilgen --- .../generated/spike/declare_views.hpp | 2 +- .../vm/generated/spike_circuit_builder.hpp | 4 +-- .../vm/generated/spike_flavor.hpp | 20 ++++++------- .../vm/generated/spike_prover.cpp | 5 ++-- .../vm/generated/spike_verifier.cpp | 30 +++++-------------- .../vm/generated/spike_verifier.hpp | 7 ++--- .../src/barretenberg/vm/tests/spike.test.cpp | 2 +- 7 files changed, 26 insertions(+), 44 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp index 290d0a4077e..df901e8d155 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/spike/declare_views.hpp @@ -3,5 +3,5 @@ using Accumulator = typename std::tuple_element::type; \ using View = typename Accumulator::View; \ [[maybe_unused]] auto Spike_first = View(new_term.Spike_first); \ - [[maybe_unused]] auto Spike_kernel_inputs__is_public = View(new_term.Spike_kernel_inputs__is_public); \ + [[maybe_unused]] auto Spike_kernel_inputs = View(new_term.Spike_kernel_inputs); \ [[maybe_unused]] auto Spike_x = View(new_term.Spike_x); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp index b274ddd8f29..255ceed71c8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_circuit_builder.hpp @@ -18,7 +18,7 @@ namespace bb { template struct SpikeFullRow { FF Spike_first{}; - FF Spike_kernel_inputs__is_public{}; + FF Spike_kernel_inputs{}; FF Spike_x{}; }; @@ -50,7 +50,7 @@ class SpikeCircuitBuilder { for (size_t i = 0; i < rows.size(); i++) { polys.Spike_first[i] = rows[i].Spike_first; - polys.Spike_kernel_inputs__is_public[i] = rows[i].Spike_kernel_inputs__is_public; + polys.Spike_kernel_inputs[i] = rows[i].Spike_kernel_inputs; polys.Spike_x[i] = rows[i].Spike_x; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp index f716b4c9c00..994ca15d548 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp @@ -74,17 +74,17 @@ class SpikeFlavor { template class WitnessEntities { public: - DEFINE_FLAVOR_MEMBERS(DataType, Spike_kernel_inputs__is_public, Spike_x) + DEFINE_FLAVOR_MEMBERS(DataType, Spike_kernel_inputs, Spike_x) - RefVector get_wires() { return { Spike_kernel_inputs__is_public, Spike_x }; }; + RefVector get_wires() { return { Spike_kernel_inputs, Spike_x }; }; }; template class AllEntities { public: - DEFINE_FLAVOR_MEMBERS(DataType, Spike_first, Spike_kernel_inputs__is_public, Spike_x) + DEFINE_FLAVOR_MEMBERS(DataType, Spike_first, Spike_kernel_inputs, Spike_x) - RefVector get_wires() { return { Spike_first, Spike_kernel_inputs__is_public, Spike_x }; }; - RefVector get_unshifted() { return { Spike_first, Spike_kernel_inputs__is_public, Spike_x }; }; + RefVector get_wires() { return { Spike_first, Spike_kernel_inputs, Spike_x }; }; + RefVector get_unshifted() { return { Spike_first, Spike_kernel_inputs, Spike_x }; }; RefVector get_to_be_shifted() { return {}; }; RefVector get_shifted() { return {}; }; }; @@ -134,7 +134,7 @@ class SpikeFlavor { } } - [[nodiscard]] size_t get_polynomial_size() const { return Spike_kernel_inputs__is_public.size(); } + [[nodiscard]] size_t get_polynomial_size() const { return Spike_kernel_inputs.size(); } /** * @brief Returns the evaluations of all prover polynomials at one point on the boolean hypercube, which * represents one row in the execution trace. @@ -189,7 +189,7 @@ class SpikeFlavor { : AllEntities() { Base::Spike_first = "SPIKE_FIRST"; - Base::Spike_kernel_inputs__is_public = "SPIKE_KERNEL_INPUTS__IS_PUBLIC"; + Base::Spike_kernel_inputs = "SPIKE_KERNEL_INPUTS"; Base::Spike_x = "SPIKE_X"; }; }; @@ -209,7 +209,7 @@ class SpikeFlavor { public: uint32_t circuit_size; - Commitment Spike_kernel_inputs__is_public; + Commitment Spike_kernel_inputs; Commitment Spike_x; std::vector> sumcheck_univariates; @@ -230,7 +230,7 @@ class SpikeFlavor { circuit_size = deserialize_from_buffer(proof_data, num_frs_read); size_t log_n = numeric::get_msb(circuit_size); - Spike_kernel_inputs__is_public = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + Spike_kernel_inputs = deserialize_from_buffer(Transcript::proof_data, num_frs_read); Spike_x = deserialize_from_buffer(Transcript::proof_data, num_frs_read); for (size_t i = 0; i < log_n; ++i) { @@ -255,7 +255,7 @@ class SpikeFlavor { serialize_to_buffer(circuit_size, Transcript::proof_data); - serialize_to_buffer(Spike_kernel_inputs__is_public, Transcript::proof_data); + serialize_to_buffer(Spike_kernel_inputs, Transcript::proof_data); serialize_to_buffer(Spike_x, Transcript::proof_data); for (size_t i = 0; i < log_n; ++i) { diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp index bc0759df84a..1f2925eecd1 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_prover.cpp @@ -60,12 +60,11 @@ void SpikeProver::execute_wire_commitments_round() // Commit to all polynomials (apart from logderivative inverse polynomials, which are committed to in the later // logderivative phase) - witness_commitments.Spike_kernel_inputs__is_public = commitment_key->commit(key->Spike_kernel_inputs__is_public); + witness_commitments.Spike_kernel_inputs = commitment_key->commit(key->Spike_kernel_inputs); witness_commitments.Spike_x = commitment_key->commit(key->Spike_x); // Send all commitments to the verifier - transcript->send_to_verifier(commitment_labels.Spike_kernel_inputs__is_public, - witness_commitments.Spike_kernel_inputs__is_public); + transcript->send_to_verifier(commitment_labels.Spike_kernel_inputs, witness_commitments.Spike_kernel_inputs); transcript->send_to_verifier(commitment_labels.Spike_x, witness_commitments.Spike_x); } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp index 6ca0e15eaa1..52660b91ed9 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp @@ -5,9 +5,9 @@ #include "barretenberg/numeric/bitop/get_msb.hpp" #include "barretenberg/polynomials/polynomial.hpp" #include "barretenberg/transcript/transcript.hpp" -#include "barretenberg/vm/generated/spike_flavor.hpp" namespace bb { + SpikeVerifier::SpikeVerifier(std::shared_ptr verifier_key) : key(verifier_key) {} @@ -25,14 +25,10 @@ SpikeVerifier& SpikeVerifier::operator=(SpikeVerifier&& other) noexcept return *this; } -using FF = SpikeVerifier::FF; +using FF = SpikeFlavor::FF; -// Evaluations are the evaluations of the polynomial over the boolean hypercube -// The multivariate challenge is the challenge in each variable of the polynomial -// This challenge is generated during the sumcheck protocol -// -// TODO: Using the current evaluate_mle implementation is inefficient -FF evaluate_public_input_column(std::vector points, std::vector challenges) +// Evaluate the given public input column over the multivariate challenge points +[[maybe_unused]] FF evaluate_public_input_column(std::vector points, std::vector challenges) { Polynomial polynomial(points); return polynomial.evaluate_mle(challenges); @@ -42,8 +38,7 @@ FF evaluate_public_input_column(std::vector points, std::vector challeng * @brief This function verifies an Spike Honk proof for given program settings. * */ -// bool SpikeVerifier::verify_proof(const HonkProof& proof, PublicInputColumns public_inputs) -bool SpikeVerifier::verify_proof(const HonkProof& proof, std::vector public_inputs) +bool SpikeVerifier::verify_proof(const HonkProof& proof, const std::vector& public_inputs) { using Flavor = SpikeFlavor; using FF = Flavor::FF; @@ -67,8 +62,8 @@ bool SpikeVerifier::verify_proof(const HonkProof& proof, std::vector public_ } // Get commitments to VM wires - commitments.Spike_kernel_inputs__is_public = - transcript->template receive_from_prover(commitment_labels.Spike_kernel_inputs__is_public); + commitments.Spike_kernel_inputs = + transcript->template receive_from_prover(commitment_labels.Spike_kernel_inputs); commitments.Spike_x = transcript->template receive_from_prover(commitment_labels.Spike_x); // Get commitments to inverses @@ -92,17 +87,8 @@ bool SpikeVerifier::verify_proof(const HonkProof& proof, std::vector public_ return false; } - // Compute the public inputs evaluations, and verify that they match the claimed evaluations - // This is performed later in the verifier such that we can use the same evalutaions that are computed - // during sumcheck and confirmed during zeromorph - // A more optimal implementation would avoid the prover having to compute the commitment to the public inputs - // and compute them at a different challenge earlier in the program - // This would require a change in our zeromorph implementation where it assumes all evaluations were made - // at the same challenge point. - // TODO: document this design choice in a github issue - FF public_column_evaluation = evaluate_public_input_column(public_inputs, multivariate_challenge); - if (public_column_evaluation != claimed_evaluations.Spike_kernel_inputs__is_public) { + if (public_column_evaluation != claimed_evaluations.Spike_kernel_inputs) { return false; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp index 8dc10538321..c4fb767455a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.hpp @@ -8,15 +8,13 @@ namespace bb { class SpikeVerifier { using Flavor = SpikeFlavor; + using FF = Flavor::FF; using Commitment = Flavor::Commitment; using VerificationKey = Flavor::VerificationKey; using VerifierCommitmentKey = Flavor::VerifierCommitmentKey; using Transcript = Flavor::Transcript; public: - using FF = Flavor::FF; - // using PublicInputColumns = Flavor::PublicInputColumns; - explicit SpikeVerifier(std::shared_ptr verifier_key = nullptr); SpikeVerifier(SpikeVerifier&& other) noexcept; SpikeVerifier(const SpikeVerifier& other) = delete; @@ -24,8 +22,7 @@ class SpikeVerifier { SpikeVerifier& operator=(const SpikeVerifier& other) = delete; SpikeVerifier& operator=(SpikeVerifier&& other) noexcept; - // bool verify_proof(const HonkProof& proof, PublicInputColumns public_inputs = {}); - bool verify_proof(const HonkProof& proof, std::vector public_inputs = {}); + bool verify_proof(const HonkProof& proof, const std::vector& public_inputs); std::shared_ptr key; std::map commitments; diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp index 53bf8e31bbf..1b30f1f4a6c 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp @@ -40,7 +40,7 @@ bool verify_spike_with_public_with_public_inputs(std::vector ve // Add to the public input column that is increasing for (size_t i = 0; i < circuit_size; i++) { // Make sure the external and trace public inputs are the same - Row row{ .Spike_kernel_inputs__is_public = i + 1 }; + Row row{ .Spike_kernel_inputs = i + 1 }; rows.push_back(row); } From b0f8041b422b333bc19e203ca8e9df5e98b0a9f5 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 12 Apr 2024 17:27:00 +0000 Subject: [PATCH 14/40] feat: example caller and address opcode --- barretenberg/cpp/pil/avm/avm_environment.pil | 16 ++ barretenberg/cpp/pil/avm/avm_main.pil | 16 +- barretenberg/cpp/scripts/compile_avm.sh | 23 +++ .../generated/avm/avm_environment.hpp | 67 +++++++ .../relations/generated/avm/declare_views.hpp | 7 + .../generated/avm/lookup_into_environment.hpp | 171 ++++++++++++++++++ .../vm/avm_trace/avm_environment_trace.cpp | 38 ++++ .../vm/avm_trace/avm_environment_trace.hpp | 36 ++++ .../vm/avm_trace/avm_execution.cpp | 4 +- .../barretenberg/vm/avm_trace/avm_trace.cpp | 81 ++++++++- .../barretenberg/vm/avm_trace/avm_trace.hpp | 8 +- .../vm/generated/avm_circuit_builder.hpp | 27 ++- .../barretenberg/vm/generated/avm_flavor.hpp | 77 +++++++- .../barretenberg/vm/generated/avm_prover.cpp | 23 +++ .../vm/generated/avm_verifier.cpp | 32 +++- .../vm/generated/avm_verifier.hpp | 2 +- .../vm/generated/spike_verifier.cpp | 3 +- .../vm/tests/avm_environment.test.cpp | 45 +++++ .../barretenberg/vm/tests/helpers.test.cpp | 8 +- .../barretenberg/vm/tests/helpers.test.hpp | 5 +- 20 files changed, 670 insertions(+), 19 deletions(-) create mode 100644 barretenberg/cpp/pil/avm/avm_environment.pil create mode 100755 barretenberg/cpp/scripts/compile_avm.sh create mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_environment.hpp create mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.cpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/tests/avm_environment.test.cpp diff --git a/barretenberg/cpp/pil/avm/avm_environment.pil b/barretenberg/cpp/pil/avm/avm_environment.pil new file mode 100644 index 00000000000..7b4e506f446 --- /dev/null +++ b/barretenberg/cpp/pil/avm/avm_environment.pil @@ -0,0 +1,16 @@ + +namespace avm_environment(256); + + // The general pattern for environment lookups is as follows: + // - If we are performing an environment lookup, then we set q_environment_lookup + // - We can toggle what index in the + pol commit environment_selector; + pol commit q_environment_lookup; + + // Note we are currently using arbitrary opcodes for each + // For this demo, caller is stored at index 0 + #[SENDER_ENVIRONMENT] + q_environment_lookup * avm_main.sel_op_sender * (environment_selector) = 0; + + #[ADDRESS_ENVIRONMENT] + q_environment_lookup * avm_main.sel_op_address * (environment_selector - 1) = 0; diff --git a/barretenberg/cpp/pil/avm/avm_main.pil b/barretenberg/cpp/pil/avm/avm_main.pil index ecc18fe6d83..4c26ce18364 100644 --- a/barretenberg/cpp/pil/avm/avm_main.pil +++ b/barretenberg/cpp/pil/avm/avm_main.pil @@ -2,8 +2,22 @@ include "avm_mem.pil"; include "avm_alu.pil"; include "avm_binary.pil"; +include "avm_environment.pil"; namespace avm_main(256); + //===== PUBLIC INPUTS ========================================================= + pol public kernel_inputs; + + // Envrionment lookup selector opcodes + // NOTE: we start with an arbitrary subset of operations - just these two for now + // CALLER + pol commit sel_op_sender; + // ADDRESS + pol commit sel_op_address; + + #[LOOKUP_INTO_ENVIRONMENT] + // TODO: FIX not having the trailing is_public breaking compilation :( + avm_environment.q_environment_lookup { ia, avm_environment.environment_selector } in avm_environment.q_environment_lookup { kernel_inputs__is_public, clk }; //===== CONSTANT POLYNOMIALS ================================================== pol constant clk(i) { i }; @@ -58,7 +72,7 @@ namespace avm_main(256); pol commit sel_op_lt; // LTE pol commit sel_op_lte; - + // Helper selector to characterize an ALU chiplet selector pol commit alu_sel; diff --git a/barretenberg/cpp/scripts/compile_avm.sh b/barretenberg/cpp/scripts/compile_avm.sh new file mode 100755 index 00000000000..01f422e229f --- /dev/null +++ b/barretenberg/cpp/scripts/compile_avm.sh @@ -0,0 +1,23 @@ +#!/bin/bash +use_zsh_alias() { + # Run Zsh command, source .zshrc, and then execute the alias + zsh -i -c "$1" +} + +# Compile +use_zsh_alias "bb_pil pil/avm/avm_main.pil --name Avm" + +# Format generated folders +root_dir="src" + +# Find all directories named 'generate' under the specified root directory +find "$root_dir" -type d -name 'generate' | while read dir_path; do + echo "Processing directory: $dir_path" + + # Find all C/C++ source files in these directories and format them + find "$dir_path" -type f \( -iname '*.hpp' -o -iname '*.cpp' \) -exec clang-format -i {} + +done + + +# Build vm tests +cmake --build --preset clang16 --target vm_tests \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_environment.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_environment.hpp new file mode 100644 index 00000000000..1b0cdc54004 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_environment.hpp @@ -0,0 +1,67 @@ + +#pragma once +#include "../../relation_parameters.hpp" +#include "../../relation_types.hpp" +#include "./declare_views.hpp" + +namespace bb::Avm_vm { + +template struct Avm_environmentRow { + FF avm_environment_environment_selector{}; + FF avm_environment_q_environment_lookup{}; + FF avm_main_sel_op_address{}; + FF avm_main_sel_op_sender{}; +}; + +inline std::string get_relation_label_avm_environment(int index) +{ + switch (index) { + case 0: + return "SENDER_ENVIRONMENT"; + + case 1: + return "ADDRESS_ENVIRONMENT"; + } + return std::to_string(index); +} + +template class avm_environmentImpl { + public: + using FF = FF_; + + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 4, + 4, + }; + + template + void static accumulate(ContainerOverSubrelations& evals, + const AllEntities& new_term, + [[maybe_unused]] const RelationParameters&, + [[maybe_unused]] const FF& scaling_factor) + { + + // Contribution 0 + { + Avm_DECLARE_VIEWS(0); + + auto tmp = ((avm_environment_q_environment_lookup * avm_main_sel_op_sender) * + avm_environment_environment_selector); + tmp *= scaling_factor; + std::get<0>(evals) += tmp; + } + // Contribution 1 + { + Avm_DECLARE_VIEWS(1); + + auto tmp = ((avm_environment_q_environment_lookup * avm_main_sel_op_address) * + (avm_environment_environment_selector - FF(1))); + tmp *= scaling_factor; + std::get<1>(evals) += tmp; + } + } +}; + +template using avm_environment = Relation>; + +} // namespace bb::Avm_vm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp index 05c47520ab4..cceb994f764 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -80,6 +80,8 @@ [[maybe_unused]] auto avm_byte_lookup_table_input_b = View(new_term.avm_byte_lookup_table_input_b); \ [[maybe_unused]] auto avm_byte_lookup_table_op_id = View(new_term.avm_byte_lookup_table_op_id); \ [[maybe_unused]] auto avm_byte_lookup_table_output = View(new_term.avm_byte_lookup_table_output); \ + [[maybe_unused]] auto avm_environment_environment_selector = View(new_term.avm_environment_environment_selector); \ + [[maybe_unused]] auto avm_environment_q_environment_lookup = View(new_term.avm_environment_q_environment_lookup); \ [[maybe_unused]] auto avm_main_alu_sel = View(new_term.avm_main_alu_sel); \ [[maybe_unused]] auto avm_main_bin_op_id = View(new_term.avm_main_bin_op_id); \ [[maybe_unused]] auto avm_main_bin_sel = View(new_term.avm_main_bin_sel); \ @@ -98,6 +100,7 @@ [[maybe_unused]] auto avm_main_ind_op_d = View(new_term.avm_main_ind_op_d); \ [[maybe_unused]] auto avm_main_internal_return_ptr = View(new_term.avm_main_internal_return_ptr); \ [[maybe_unused]] auto avm_main_inv = View(new_term.avm_main_inv); \ + [[maybe_unused]] auto avm_main_kernel_inputs__is_public = View(new_term.avm_main_kernel_inputs__is_public); \ [[maybe_unused]] auto avm_main_last = View(new_term.avm_main_last); \ [[maybe_unused]] auto avm_main_mem_idx_a = View(new_term.avm_main_mem_idx_a); \ [[maybe_unused]] auto avm_main_mem_idx_b = View(new_term.avm_main_mem_idx_b); \ @@ -123,6 +126,7 @@ [[maybe_unused]] auto avm_main_sel_mov_a = View(new_term.avm_main_sel_mov_a); \ [[maybe_unused]] auto avm_main_sel_mov_b = View(new_term.avm_main_sel_mov_b); \ [[maybe_unused]] auto avm_main_sel_op_add = View(new_term.avm_main_sel_op_add); \ + [[maybe_unused]] auto avm_main_sel_op_address = View(new_term.avm_main_sel_op_address); \ [[maybe_unused]] auto avm_main_sel_op_and = View(new_term.avm_main_sel_op_and); \ [[maybe_unused]] auto avm_main_sel_op_div = View(new_term.avm_main_sel_op_div); \ [[maybe_unused]] auto avm_main_sel_op_eq = View(new_term.avm_main_sel_op_eq); \ @@ -131,6 +135,7 @@ [[maybe_unused]] auto avm_main_sel_op_mul = View(new_term.avm_main_sel_op_mul); \ [[maybe_unused]] auto avm_main_sel_op_not = View(new_term.avm_main_sel_op_not); \ [[maybe_unused]] auto avm_main_sel_op_or = View(new_term.avm_main_sel_op_or); \ + [[maybe_unused]] auto avm_main_sel_op_sender = View(new_term.avm_main_sel_op_sender); \ [[maybe_unused]] auto avm_main_sel_op_sub = View(new_term.avm_main_sel_op_sub); \ [[maybe_unused]] auto avm_main_sel_op_xor = View(new_term.avm_main_sel_op_xor); \ [[maybe_unused]] auto avm_main_sel_rng_16 = View(new_term.avm_main_sel_rng_16); \ @@ -173,6 +178,7 @@ [[maybe_unused]] auto perm_main_mem_ind_d = View(new_term.perm_main_mem_ind_d); \ [[maybe_unused]] auto lookup_byte_lengths = View(new_term.lookup_byte_lengths); \ [[maybe_unused]] auto lookup_byte_operations = View(new_term.lookup_byte_operations); \ + [[maybe_unused]] auto lookup_into_environment = View(new_term.lookup_into_environment); \ [[maybe_unused]] auto incl_main_tag_err = View(new_term.incl_main_tag_err); \ [[maybe_unused]] auto incl_mem_tag_err = View(new_term.incl_mem_tag_err); \ [[maybe_unused]] auto lookup_u8_0 = View(new_term.lookup_u8_0); \ @@ -194,6 +200,7 @@ [[maybe_unused]] auto lookup_u16_14 = View(new_term.lookup_u16_14); \ [[maybe_unused]] auto lookup_byte_lengths_counts = View(new_term.lookup_byte_lengths_counts); \ [[maybe_unused]] auto lookup_byte_operations_counts = View(new_term.lookup_byte_operations_counts); \ + [[maybe_unused]] auto lookup_into_environment_counts = View(new_term.lookup_into_environment_counts); \ [[maybe_unused]] auto incl_main_tag_err_counts = View(new_term.incl_main_tag_err_counts); \ [[maybe_unused]] auto incl_mem_tag_err_counts = View(new_term.incl_mem_tag_err_counts); \ [[maybe_unused]] auto lookup_u8_0_counts = View(new_term.lookup_u8_0_counts); \ diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp new file mode 100644 index 00000000000..4239be52ada --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp @@ -0,0 +1,171 @@ + + +#pragma once + +#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp" + +#include +#include + +namespace bb { + +/** + * @brief This class contains an example of how to set LookupSettings classes used by the + * GenericLookupRelationImpl class to specify a scaled lookup + * + * @details To create your own lookup: + * 1) Create a copy of this class and rename it + * 2) Update all the values with the ones needed for your lookup + * 3) Update "DECLARE_LOOKUP_IMPLEMENTATIONS_FOR_ALL_SETTINGS" and "DEFINE_LOOKUP_IMPLEMENTATIONS_FOR_ALL_SETTINGS" to + * include the new settings + * 4) Add the relation with the chosen settings to Relations in the flavor (for example,"` + * using Relations = std::tuple>;)` + * + */ +class lookup_into_environment_lookup_settings { + public: + /** + * @brief The number of read terms (how many lookups we perform) in each row + * + */ + static constexpr size_t READ_TERMS = 1; + /** + * @brief The number of write terms (how many additions to the lookup table we make) in each row + * + */ + static constexpr size_t WRITE_TERMS = 1; + + /** + * @brief The type of READ_TERM used for each read index (basic and scaled) + * + */ + static constexpr size_t READ_TERM_TYPES[READ_TERMS] = { 0 }; + + /** + * @brief They type of WRITE_TERM used for each write index + * + */ + static constexpr size_t WRITE_TERM_TYPES[WRITE_TERMS] = { 0 }; + + /** + * @brief How many values represent a single lookup object. This value is used by the automatic read term + * implementation in the relation in case the lookup is a basic or scaled tuple and in the write term if it's a + * basic tuple + * + */ + static constexpr size_t LOOKUP_TUPLE_SIZE = 2; + + /** + * @brief The polynomial degree of the relation telling us if the inverse polynomial value needs to be computed + * + */ + static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4; + + /** + * @brief The degree of the read term if implemented arbitrarily. This value is not used by basic and scaled read + * terms, but will cause compilation error if not defined + * + */ + static constexpr size_t READ_TERM_DEGREE = 0; + + /** + * @brief The degree of the write term if implemented arbitrarily. This value is not used by the basic write + * term, but will cause compilation error if not defined + * + */ + + static constexpr size_t WRITE_TERM_DEGREE = 0; + + /** + * @brief If this method returns true on a row of values, then the inverse polynomial exists at this index. + * Otherwise the value needs to be set to zero. + * + * @details If this is true then the lookup takes place in this row + * + */ + + template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) + { + return (in.avm_environment_q_environment_lookup == 1 || in.avm_environment_q_environment_lookup == 1); + } + + /** + * @brief Subprocedure for computing the value deciding if the inverse polynomial value needs to be checked in this + * row + * + * @tparam Accumulator Type specified by the lookup relation + * @tparam AllEntities Values/Univariates of all entities row + * @param in Value/Univariate of all entities at row/edge + * @return Accumulator + */ + + template + static inline auto compute_inverse_exists(const AllEntities& in) + { + using View = typename Accumulator::View; + const auto is_operation = View(in.avm_environment_q_environment_lookup); + const auto is_table_entry = View(in.avm_environment_q_environment_lookup); + return (is_operation + is_table_entry - is_operation * is_table_entry); + } + + /** + * @brief Get all the entities for the lookup when need to update them + * + * @details The generic structure of this tuple is described in ./generic_lookup_relation.hpp . The following is + description for the current case: + The entities are returned as a tuple of references in the following order (this is for ): + * - The entity/polynomial used to store the product of the inverse values + * - The entity/polynomial that specifies how many times the lookup table entry at this row has been looked up + * - READ_TERMS entities/polynomials that enable individual lookup operations + * - The entity/polynomial that enables adding an entry to the lookup table in this row + * - LOOKUP_TUPLE_SIZE entities/polynomials representing the basic tuple being looked up as the first read term + * - LOOKUP_TUPLE_SIZE entities/polynomials representing the previous accumulators in the second read term + (scaled tuple) + * - LOOKUP_TUPLE_SIZE entities/polynomials representing the shifts in the second read term (scaled tuple) + * - LOOKUP_TUPLE_SIZE entities/polynomials representing the current accumulators in the second read term + (scaled tuple) + * - LOOKUP_TUPLE_SIZE entities/polynomials representing basic tuples added to the table + * + * @return All the entities needed for the lookup + */ + + template static inline auto get_const_entities(const AllEntities& in) + { + + return std::forward_as_tuple(in.lookup_into_environment, + in.lookup_into_environment_counts, + in.avm_environment_q_environment_lookup, + in.avm_environment_q_environment_lookup, + in.avm_main_ia, + in.avm_environment_environment_selector, + in.avm_main_kernel_inputs__is_public, + in.avm_main_clk); + } + + /** + * @brief Get all the entities for the lookup when we only need to read them + * @details Same as in get_const_entities, but nonconst + * + * @return All the entities needed for the lookup + */ + + template static inline auto get_nonconst_entities(AllEntities& in) + { + + return std::forward_as_tuple(in.lookup_into_environment, + in.lookup_into_environment_counts, + in.avm_environment_q_environment_lookup, + in.avm_environment_q_environment_lookup, + in.avm_main_ia, + in.avm_environment_environment_selector, + in.avm_main_kernel_inputs__is_public, + in.avm_main_clk); + } +}; + +template +using lookup_into_environment_relation = GenericLookupRelation; +template using lookup_into_environment = GenericLookup; + +} // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.cpp new file mode 100644 index 00000000000..f89233755d1 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.cpp @@ -0,0 +1,38 @@ +#include "avm_environment_trace.hpp" +#include "barretenberg/vm/avm_trace/avm_common.hpp" +#include "barretenberg/vm/avm_trace/avm_trace.hpp" +#include + +namespace bb::avm_trace { + +AvmEnvironmentTraceBuilder::AvmEnvironmentTraceBuilder(std::vector kernel_inputs) + : kernel_inputs(kernel_inputs) +{} + +void AvmEnvironmentTraceBuilder::reset() +{ + environment_selector_counter.clear(); +} + +FF AvmEnvironmentTraceBuilder::op_sender() +{ + // We want to be able to get the return value from the public inputs column + // Get the return value, this will be places in ia + // We read from the public inputs that were provided to the kernel + FF result = kernel_inputs[SENDER_SELECTOR]; + environment_selector_counter[SENDER_SELECTOR]++; + + return result; +} + +FF AvmEnvironmentTraceBuilder::op_address() +{ + // We want to be able to get the return value from the public inputs column + // Get the return value, this will be places in ia + // We read from the public inputs that were provided to the kernel + FF result = kernel_inputs[ADDRESS_SELECTOR]; + environment_selector_counter[ADDRESS_SELECTOR]++; + + return result; +} +} // namespace bb::avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.hpp new file mode 100644 index 00000000000..e587fbdea19 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.hpp @@ -0,0 +1,36 @@ +#pragma once + +#include "avm_common.hpp" +#include "barretenberg/numeric/uint128/uint128.hpp" +#include +#include + +inline const uint32_t SENDER_SELECTOR = 0; +inline const uint32_t ADDRESS_SELECTOR = 1; + +namespace bb::avm_trace { +class AvmEnvironmentTraceBuilder { + public: + struct EnvironmentTraceEntry { + // TODO: could be u8? + uint32_t environment_selector = 0; + bool q_environment_lookup = false; + }; + + std::vector kernel_inputs; + + // Counts the number of accesses into each SELECTOR for the environment selector lookups; + std::unordered_map environment_selector_counter; + + // TODO: should i have access to the kernel_inputs here -> so they can be directly looked up? + AvmEnvironmentTraceBuilder(std::vector kernel_inputs); + + void reset(); + + FF op_sender(); + FF op_address(); + + private: + std::vector environment_trace; +}; +} // namespace bb::avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp index 1e018d647d6..f08e94a2a69 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp @@ -72,7 +72,9 @@ bool Execution::verify(AvmFlavor::VerificationKey vk, HonkProof const& proof) // crs_factory_); // output_state.pcs_verification_key = std::move(pcs_verification_key); - return verifier.verify_proof(proof); + // TODO: pass in above + std::vector public_inputs = {}; + return verifier.verify_proof(proof, public_inputs); } /** diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp index a9e27af4127..de8f895c79e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -14,6 +14,7 @@ #include "avm_helper.hpp" #include "avm_mem_trace.hpp" #include "avm_trace.hpp" +#include "barretenberg/vm/avm_trace/avm_environment_trace.hpp" namespace bb::avm_trace { @@ -21,7 +22,9 @@ namespace bb::avm_trace { * @brief Constructor of a trace builder of AVM. Only serves to set the capacity of the * underlying traces. */ -AvmTraceBuilder::AvmTraceBuilder() +AvmTraceBuilder::AvmTraceBuilder(std::vector kernel_inputs) + // NOTE: we initialise the environment builder here as it requires public inputs + : env_trace_builder(kernel_inputs) { main_trace.reserve(AVM_TRACE_SIZE); } @@ -36,6 +39,7 @@ void AvmTraceBuilder::reset() mem_trace_builder.reset(); alu_trace_builder.reset(); bin_trace_builder.reset(); + env_trace_builder.reset(); } AvmTraceBuilder::IndirectThreeResolution AvmTraceBuilder::resolve_ind_three( @@ -942,6 +946,64 @@ void AvmTraceBuilder::op_cmov( }); } +void AvmTraceBuilder::op_sender(uint32_t dst_offset) +{ + auto const clk = static_cast(main_trace.size()); + + // Get the value of op sender from the mem trace + FF ia_value = env_trace_builder.op_sender(); + info("after op sender in env trace"); + + // TODO: the tag of sender should be a field element no? + AvmMemoryTag tag = AvmMemoryTag::U32; + mem_trace_builder.write_into_memory(clk, IntermRegister::IA, dst_offset, ia_value, AvmMemoryTag::U0, tag); + + // TODO: must i constrain r in tag to be the type of the write operation in pil? + // .avm_main_r_in_tag = FF(static_cast(in_tag)), + main_trace.push_back(Row{ + .avm_main_clk = clk, + .avm_environment_environment_selector = SENDER_SELECTOR, + .avm_environment_q_environment_lookup = 1, + .avm_main_ia = ia_value, + .avm_main_ind_a = 0, + .avm_main_internal_return_ptr = internal_return_ptr, + .avm_main_mem_idx_a = dst_offset, + .avm_main_mem_op_a = 1, + .avm_main_pc = pc++, + .avm_main_rwa = 1, + .avm_main_sel_op_sender = 1, + .avm_main_w_in_tag = static_cast(tag), + }); +} + +void AvmTraceBuilder::op_address(uint32_t dst_offset) +{ + auto const clk = static_cast(main_trace.size()); + + // Get the value of op sender from the mem trace + FF ia_value = env_trace_builder.op_address(); + + // TODO: the tag of sender should be a field element no? + AvmMemoryTag tag = AvmMemoryTag::U32; + mem_trace_builder.write_into_memory(clk, IntermRegister::IA, dst_offset, ia_value, AvmMemoryTag::U0, tag); + + // TODO: must i constrain r in tag to be the type of the write operation in pil? + // .avm_main_r_in_tag = FF(static_cast(in_tag)), + main_trace.push_back(Row{ + .avm_main_clk = clk, + .avm_environment_environment_selector = ADDRESS_SELECTOR, + .avm_environment_q_environment_lookup = 1, + .avm_main_ia = ia_value, + .avm_main_ind_a = 0, + .avm_main_internal_return_ptr = internal_return_ptr, + .avm_main_mem_idx_a = dst_offset, + .avm_main_pc = pc++, + .avm_main_rwa = 1, + .avm_main_sel_op_address = 1, + .avm_main_w_in_tag = static_cast(tag), + }); +} + /** * @brief CALLDATACOPY opcode with direct or indirect memory access, i.e., * direct: M[dst_offset:dst_offset+copy_size] = calldata[cd_offset:cd_offset+copy_size] @@ -1616,6 +1678,21 @@ std::vector AvmTraceBuilder::finalize() bin_trace_builder.byte_length_counter[avm_in_tag + 1]; } } + + // Include env trace table + // Selector columns and lookup counts + // Add all of the lookup counts for the input environment + for (size_t i = 0; i < 2; i++) { + auto& dest = main_trace.at(i); + dest.lookup_into_environment_counts = + FF(env_trace_builder.environment_selector_counter[static_cast(i)]); + } + + // Add public inputs into the kernelcolumns + for (size_t i = 0; i < env_trace_builder.kernel_inputs.size(); i++) { + main_trace.at(i).avm_main_kernel_inputs__is_public = env_trace_builder.kernel_inputs.at(i); + } + // Adding extra row for the shifted values at the top of the execution trace. Row first_row = Row{ .avm_main_first = FF(1), .avm_mem_lastAccess = FF(1) }; main_trace.insert(main_trace.begin(), first_row); @@ -1626,4 +1703,4 @@ std::vector AvmTraceBuilder::finalize() return trace; } -} // namespace bb::avm_trace +} // namespace bb::avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp index 9918144f5f3..39a3c8b9ba5 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp @@ -10,6 +10,7 @@ #include "barretenberg/common/throw_or_abort.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" +#include "barretenberg/vm/avm_trace/avm_environment_trace.hpp" namespace bb::avm_trace { @@ -22,7 +23,7 @@ class AvmTraceBuilder { public: static const size_t CALLSTACK_OFFSET = 896; // TODO(md): Temporary reserved area 896 - 1024 - AvmTraceBuilder(); + AvmTraceBuilder(std::vector kernel_inputs = {}); std::vector finalize(); void reset(); @@ -72,6 +73,10 @@ class AvmTraceBuilder { // is determined conditionally based on a conditional value determined by cond_offset. void op_cmov(uint8_t indirect, uint32_t a_offset, uint32_t b_offset, uint32_t cond_offset, uint32_t dst_offset); + // TODO + void op_sender(uint32_t dst_offset); + void op_address(uint32_t dst_offset); + // Jump to a given program counter. void jump(uint32_t jmp_dest); @@ -116,6 +121,7 @@ class AvmTraceBuilder { AvmMemTraceBuilder mem_trace_builder; AvmAluTraceBuilder alu_trace_builder; AvmBinaryTraceBuilder bin_trace_builder; + AvmEnvironmentTraceBuilder env_trace_builder; void finalise_mem_trace_lookup_counts(); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 4a163364de3..ea7031a9a17 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -13,12 +13,14 @@ #include "barretenberg/relations/generated/avm/avm_alu.hpp" #include "barretenberg/relations/generated/avm/avm_binary.hpp" +#include "barretenberg/relations/generated/avm/avm_environment.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" #include "barretenberg/relations/generated/avm/avm_mem.hpp" #include "barretenberg/relations/generated/avm/incl_main_tag_err.hpp" #include "barretenberg/relations/generated/avm/incl_mem_tag_err.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_lengths.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_operations.hpp" +#include "barretenberg/relations/generated/avm/lookup_into_environment.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_0.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_1.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_10.hpp" @@ -129,6 +131,8 @@ template struct AvmFullRow { FF avm_byte_lookup_table_input_b{}; FF avm_byte_lookup_table_op_id{}; FF avm_byte_lookup_table_output{}; + FF avm_environment_environment_selector{}; + FF avm_environment_q_environment_lookup{}; FF avm_main_alu_sel{}; FF avm_main_bin_op_id{}; FF avm_main_bin_sel{}; @@ -147,6 +151,7 @@ template struct AvmFullRow { FF avm_main_ind_op_d{}; FF avm_main_internal_return_ptr{}; FF avm_main_inv{}; + FF avm_main_kernel_inputs__is_public{}; FF avm_main_last{}; FF avm_main_mem_idx_a{}; FF avm_main_mem_idx_b{}; @@ -172,6 +177,7 @@ template struct AvmFullRow { FF avm_main_sel_mov_a{}; FF avm_main_sel_mov_b{}; FF avm_main_sel_op_add{}; + FF avm_main_sel_op_address{}; FF avm_main_sel_op_and{}; FF avm_main_sel_op_div{}; FF avm_main_sel_op_eq{}; @@ -180,6 +186,7 @@ template struct AvmFullRow { FF avm_main_sel_op_mul{}; FF avm_main_sel_op_not{}; FF avm_main_sel_op_or{}; + FF avm_main_sel_op_sender{}; FF avm_main_sel_op_sub{}; FF avm_main_sel_op_xor{}; FF avm_main_sel_rng_16{}; @@ -222,6 +229,7 @@ template struct AvmFullRow { FF perm_main_mem_ind_d{}; FF lookup_byte_lengths{}; FF lookup_byte_operations{}; + FF lookup_into_environment{}; FF incl_main_tag_err{}; FF incl_mem_tag_err{}; FF lookup_u8_0{}; @@ -243,6 +251,7 @@ template struct AvmFullRow { FF lookup_u16_14{}; FF lookup_byte_lengths_counts{}; FF lookup_byte_operations_counts{}; + FF lookup_into_environment_counts{}; FF incl_main_tag_err_counts{}; FF incl_mem_tag_err_counts{}; FF lookup_u8_0_counts{}; @@ -309,8 +318,8 @@ class AvmCircuitBuilder { using Polynomial = Flavor::Polynomial; using ProverPolynomials = Flavor::ProverPolynomials; - static constexpr size_t num_fixed_columns = 246; - static constexpr size_t num_polys = 211; + static constexpr size_t num_fixed_columns = 253; + static constexpr size_t num_polys = 218; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -404,6 +413,8 @@ class AvmCircuitBuilder { polys.avm_byte_lookup_table_input_b[i] = rows[i].avm_byte_lookup_table_input_b; polys.avm_byte_lookup_table_op_id[i] = rows[i].avm_byte_lookup_table_op_id; polys.avm_byte_lookup_table_output[i] = rows[i].avm_byte_lookup_table_output; + polys.avm_environment_environment_selector[i] = rows[i].avm_environment_environment_selector; + polys.avm_environment_q_environment_lookup[i] = rows[i].avm_environment_q_environment_lookup; polys.avm_main_alu_sel[i] = rows[i].avm_main_alu_sel; polys.avm_main_bin_op_id[i] = rows[i].avm_main_bin_op_id; polys.avm_main_bin_sel[i] = rows[i].avm_main_bin_sel; @@ -422,6 +433,7 @@ class AvmCircuitBuilder { polys.avm_main_ind_op_d[i] = rows[i].avm_main_ind_op_d; polys.avm_main_internal_return_ptr[i] = rows[i].avm_main_internal_return_ptr; polys.avm_main_inv[i] = rows[i].avm_main_inv; + polys.avm_main_kernel_inputs__is_public[i] = rows[i].avm_main_kernel_inputs__is_public; polys.avm_main_last[i] = rows[i].avm_main_last; polys.avm_main_mem_idx_a[i] = rows[i].avm_main_mem_idx_a; polys.avm_main_mem_idx_b[i] = rows[i].avm_main_mem_idx_b; @@ -447,6 +459,7 @@ class AvmCircuitBuilder { polys.avm_main_sel_mov_a[i] = rows[i].avm_main_sel_mov_a; polys.avm_main_sel_mov_b[i] = rows[i].avm_main_sel_mov_b; polys.avm_main_sel_op_add[i] = rows[i].avm_main_sel_op_add; + polys.avm_main_sel_op_address[i] = rows[i].avm_main_sel_op_address; polys.avm_main_sel_op_and[i] = rows[i].avm_main_sel_op_and; polys.avm_main_sel_op_div[i] = rows[i].avm_main_sel_op_div; polys.avm_main_sel_op_eq[i] = rows[i].avm_main_sel_op_eq; @@ -455,6 +468,7 @@ class AvmCircuitBuilder { polys.avm_main_sel_op_mul[i] = rows[i].avm_main_sel_op_mul; polys.avm_main_sel_op_not[i] = rows[i].avm_main_sel_op_not; polys.avm_main_sel_op_or[i] = rows[i].avm_main_sel_op_or; + polys.avm_main_sel_op_sender[i] = rows[i].avm_main_sel_op_sender; polys.avm_main_sel_op_sub[i] = rows[i].avm_main_sel_op_sub; polys.avm_main_sel_op_xor[i] = rows[i].avm_main_sel_op_xor; polys.avm_main_sel_rng_16[i] = rows[i].avm_main_sel_rng_16; @@ -487,6 +501,7 @@ class AvmCircuitBuilder { polys.avm_mem_w_in_tag[i] = rows[i].avm_mem_w_in_tag; polys.lookup_byte_lengths_counts[i] = rows[i].lookup_byte_lengths_counts; polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; + polys.lookup_into_environment_counts[i] = rows[i].lookup_into_environment_counts; polys.incl_main_tag_err_counts[i] = rows[i].incl_main_tag_err_counts; polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; polys.lookup_u8_0_counts[i] = rows[i].lookup_u8_0_counts; @@ -622,6 +637,10 @@ class AvmCircuitBuilder { Avm_vm::get_relation_label_avm_binary)) { return false; } + if (!evaluate_relation.template operator()>( + "avm_environment", Avm_vm::get_relation_label_avm_environment)) { + return false; + } if (!evaluate_relation.template operator()>("avm_main", Avm_vm::get_relation_label_avm_main)) { return false; @@ -668,6 +687,10 @@ class AvmCircuitBuilder { "LOOKUP_BYTE_OPERATIONS")) { return false; } + if (!evaluate_logderivative.template operator()>( + "LOOKUP_INTO_ENVIRONMENT")) { + return false; + } if (!evaluate_logderivative.template operator()>("INCL_MAIN_TAG_ERR")) { return false; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 4bb786ea4cb..19f294bac4e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -15,12 +15,14 @@ #include "barretenberg/polynomials/polynomial.hpp" #include "barretenberg/relations/generated/avm/avm_alu.hpp" #include "barretenberg/relations/generated/avm/avm_binary.hpp" +#include "barretenberg/relations/generated/avm/avm_environment.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" #include "barretenberg/relations/generated/avm/avm_mem.hpp" #include "barretenberg/relations/generated/avm/incl_main_tag_err.hpp" #include "barretenberg/relations/generated/avm/incl_mem_tag_err.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_lengths.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_operations.hpp" +#include "barretenberg/relations/generated/avm/lookup_into_environment.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_0.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_1.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_10.hpp" @@ -69,11 +71,11 @@ class AvmFlavor { using RelationSeparator = FF; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2; - static constexpr size_t NUM_WITNESS_ENTITIES = 209; + static constexpr size_t NUM_WITNESS_ENTITIES = 216; static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES; // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for // the unshifted and one for the shifted - static constexpr size_t NUM_ALL_ENTITIES = 246; + static constexpr size_t NUM_ALL_ENTITIES = 253; using GrandProductRelations = std::tuple, perm_main_bin_relation, @@ -87,6 +89,7 @@ class AvmFlavor { perm_main_mem_ind_d_relation, lookup_byte_lengths_relation, lookup_byte_operations_relation, + lookup_into_environment_relation, incl_main_tag_err_relation, incl_mem_tag_err_relation, lookup_u8_0_relation, @@ -109,6 +112,7 @@ class AvmFlavor { using Relations = std::tuple, Avm_vm::avm_binary, + Avm_vm::avm_environment, Avm_vm::avm_main, Avm_vm::avm_mem, perm_main_alu_relation, @@ -123,6 +127,7 @@ class AvmFlavor { perm_main_mem_ind_d_relation, lookup_byte_lengths_relation, lookup_byte_operations_relation, + lookup_into_environment_relation, incl_main_tag_err_relation, incl_mem_tag_err_relation, lookup_u8_0_relation, @@ -251,6 +256,8 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, + avm_environment_environment_selector, + avm_environment_q_environment_lookup, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -269,6 +276,7 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, + avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -294,6 +302,7 @@ class AvmFlavor { avm_main_sel_mov_a, avm_main_sel_mov_b, avm_main_sel_op_add, + avm_main_sel_op_address, avm_main_sel_op_and, avm_main_sel_op_div, avm_main_sel_op_eq, @@ -302,6 +311,7 @@ class AvmFlavor { avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_sender, avm_main_sel_op_sub, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -344,6 +354,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, + lookup_into_environment, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -365,6 +376,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, + lookup_into_environment_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -463,6 +475,8 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, + avm_environment_environment_selector, + avm_environment_q_environment_lookup, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -481,6 +495,7 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, + avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -506,6 +521,7 @@ class AvmFlavor { avm_main_sel_mov_a, avm_main_sel_mov_b, avm_main_sel_op_add, + avm_main_sel_op_address, avm_main_sel_op_and, avm_main_sel_op_div, avm_main_sel_op_eq, @@ -514,6 +530,7 @@ class AvmFlavor { avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_sender, avm_main_sel_op_sub, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -556,6 +573,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, + lookup_into_environment, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -577,6 +595,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, + lookup_into_environment_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -680,6 +699,8 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, + avm_environment_environment_selector, + avm_environment_q_environment_lookup, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -698,6 +719,7 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, + avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -723,6 +745,7 @@ class AvmFlavor { avm_main_sel_mov_a, avm_main_sel_mov_b, avm_main_sel_op_add, + avm_main_sel_op_address, avm_main_sel_op_and, avm_main_sel_op_div, avm_main_sel_op_eq, @@ -731,6 +754,7 @@ class AvmFlavor { avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_sender, avm_main_sel_op_sub, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -773,6 +797,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, + lookup_into_environment, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -794,6 +819,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, + lookup_into_environment_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -929,6 +955,8 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, + avm_environment_environment_selector, + avm_environment_q_environment_lookup, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -947,6 +975,7 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, + avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -972,6 +1001,7 @@ class AvmFlavor { avm_main_sel_mov_a, avm_main_sel_mov_b, avm_main_sel_op_add, + avm_main_sel_op_address, avm_main_sel_op_and, avm_main_sel_op_div, avm_main_sel_op_eq, @@ -980,6 +1010,7 @@ class AvmFlavor { avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_sender, avm_main_sel_op_sub, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -1022,6 +1053,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, + lookup_into_environment, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -1043,6 +1075,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, + lookup_into_environment_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -1178,6 +1211,8 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, + avm_environment_environment_selector, + avm_environment_q_environment_lookup, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -1196,6 +1231,7 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, + avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -1221,6 +1257,7 @@ class AvmFlavor { avm_main_sel_mov_a, avm_main_sel_mov_b, avm_main_sel_op_add, + avm_main_sel_op_address, avm_main_sel_op_and, avm_main_sel_op_div, avm_main_sel_op_eq, @@ -1229,6 +1266,7 @@ class AvmFlavor { avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_sender, avm_main_sel_op_sub, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -1271,6 +1309,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, + lookup_into_environment, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -1292,6 +1331,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, + lookup_into_environment_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -1413,6 +1453,8 @@ class AvmFlavor { prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); + bb::compute_logderivative_inverse>( + prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( @@ -1621,6 +1663,8 @@ class AvmFlavor { Base::avm_byte_lookup_table_input_b = "AVM_BYTE_LOOKUP_TABLE_INPUT_B"; Base::avm_byte_lookup_table_op_id = "AVM_BYTE_LOOKUP_TABLE_OP_ID"; Base::avm_byte_lookup_table_output = "AVM_BYTE_LOOKUP_TABLE_OUTPUT"; + Base::avm_environment_environment_selector = "AVM_ENVIRONMENT_ENVIRONMENT_SELECTOR"; + Base::avm_environment_q_environment_lookup = "AVM_ENVIRONMENT_Q_ENVIRONMENT_LOOKUP"; Base::avm_main_alu_sel = "AVM_MAIN_ALU_SEL"; Base::avm_main_bin_op_id = "AVM_MAIN_BIN_OP_ID"; Base::avm_main_bin_sel = "AVM_MAIN_BIN_SEL"; @@ -1639,6 +1683,7 @@ class AvmFlavor { Base::avm_main_ind_op_d = "AVM_MAIN_IND_OP_D"; Base::avm_main_internal_return_ptr = "AVM_MAIN_INTERNAL_RETURN_PTR"; Base::avm_main_inv = "AVM_MAIN_INV"; + Base::avm_main_kernel_inputs__is_public = "AVM_MAIN_KERNEL_INPUTS__IS_PUBLIC"; Base::avm_main_last = "AVM_MAIN_LAST"; Base::avm_main_mem_idx_a = "AVM_MAIN_MEM_IDX_A"; Base::avm_main_mem_idx_b = "AVM_MAIN_MEM_IDX_B"; @@ -1664,6 +1709,7 @@ class AvmFlavor { Base::avm_main_sel_mov_a = "AVM_MAIN_SEL_MOV_A"; Base::avm_main_sel_mov_b = "AVM_MAIN_SEL_MOV_B"; Base::avm_main_sel_op_add = "AVM_MAIN_SEL_OP_ADD"; + Base::avm_main_sel_op_address = "AVM_MAIN_SEL_OP_ADDRESS"; Base::avm_main_sel_op_and = "AVM_MAIN_SEL_OP_AND"; Base::avm_main_sel_op_div = "AVM_MAIN_SEL_OP_DIV"; Base::avm_main_sel_op_eq = "AVM_MAIN_SEL_OP_EQ"; @@ -1672,6 +1718,7 @@ class AvmFlavor { Base::avm_main_sel_op_mul = "AVM_MAIN_SEL_OP_MUL"; Base::avm_main_sel_op_not = "AVM_MAIN_SEL_OP_NOT"; Base::avm_main_sel_op_or = "AVM_MAIN_SEL_OP_OR"; + Base::avm_main_sel_op_sender = "AVM_MAIN_SEL_OP_SENDER"; Base::avm_main_sel_op_sub = "AVM_MAIN_SEL_OP_SUB"; Base::avm_main_sel_op_xor = "AVM_MAIN_SEL_OP_XOR"; Base::avm_main_sel_rng_16 = "AVM_MAIN_SEL_RNG_16"; @@ -1714,6 +1761,7 @@ class AvmFlavor { Base::perm_main_mem_ind_d = "PERM_MAIN_MEM_IND_D"; Base::lookup_byte_lengths = "LOOKUP_BYTE_LENGTHS"; Base::lookup_byte_operations = "LOOKUP_BYTE_OPERATIONS"; + Base::lookup_into_environment = "LOOKUP_INTO_ENVIRONMENT"; Base::incl_main_tag_err = "INCL_MAIN_TAG_ERR"; Base::incl_mem_tag_err = "INCL_MEM_TAG_ERR"; Base::lookup_u8_0 = "LOOKUP_U8_0"; @@ -1735,6 +1783,7 @@ class AvmFlavor { Base::lookup_u16_14 = "LOOKUP_U16_14"; Base::lookup_byte_lengths_counts = "LOOKUP_BYTE_LENGTHS_COUNTS"; Base::lookup_byte_operations_counts = "LOOKUP_BYTE_OPERATIONS_COUNTS"; + Base::lookup_into_environment_counts = "LOOKUP_INTO_ENVIRONMENT_COUNTS"; Base::incl_main_tag_err_counts = "INCL_MAIN_TAG_ERR_COUNTS"; Base::incl_mem_tag_err_counts = "INCL_MEM_TAG_ERR_COUNTS"; Base::lookup_u8_0_counts = "LOOKUP_U8_0_COUNTS"; @@ -1849,6 +1898,8 @@ class AvmFlavor { Commitment avm_byte_lookup_table_input_b; Commitment avm_byte_lookup_table_op_id; Commitment avm_byte_lookup_table_output; + Commitment avm_environment_environment_selector; + Commitment avm_environment_q_environment_lookup; Commitment avm_main_alu_sel; Commitment avm_main_bin_op_id; Commitment avm_main_bin_sel; @@ -1867,6 +1918,7 @@ class AvmFlavor { Commitment avm_main_ind_op_d; Commitment avm_main_internal_return_ptr; Commitment avm_main_inv; + Commitment avm_main_kernel_inputs__is_public; Commitment avm_main_last; Commitment avm_main_mem_idx_a; Commitment avm_main_mem_idx_b; @@ -1892,6 +1944,7 @@ class AvmFlavor { Commitment avm_main_sel_mov_a; Commitment avm_main_sel_mov_b; Commitment avm_main_sel_op_add; + Commitment avm_main_sel_op_address; Commitment avm_main_sel_op_and; Commitment avm_main_sel_op_div; Commitment avm_main_sel_op_eq; @@ -1900,6 +1953,7 @@ class AvmFlavor { Commitment avm_main_sel_op_mul; Commitment avm_main_sel_op_not; Commitment avm_main_sel_op_or; + Commitment avm_main_sel_op_sender; Commitment avm_main_sel_op_sub; Commitment avm_main_sel_op_xor; Commitment avm_main_sel_rng_16; @@ -1942,6 +1996,7 @@ class AvmFlavor { Commitment perm_main_mem_ind_d; Commitment lookup_byte_lengths; Commitment lookup_byte_operations; + Commitment lookup_into_environment; Commitment incl_main_tag_err; Commitment incl_mem_tag_err; Commitment lookup_u8_0; @@ -1963,6 +2018,7 @@ class AvmFlavor { Commitment lookup_u16_14; Commitment lookup_byte_lengths_counts; Commitment lookup_byte_operations_counts; + Commitment lookup_into_environment_counts; Commitment incl_main_tag_err_counts; Commitment incl_mem_tag_err_counts; Commitment lookup_u8_0_counts; @@ -2078,6 +2134,10 @@ class AvmFlavor { avm_byte_lookup_table_input_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_byte_lookup_table_op_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_byte_lookup_table_output = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_environment_environment_selector = + deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_environment_q_environment_lookup = + deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_alu_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_bin_op_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_bin_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2096,6 +2156,8 @@ class AvmFlavor { avm_main_ind_op_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_internal_return_ptr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_inv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_kernel_inputs__is_public = + deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_last = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_mem_idx_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_mem_idx_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2121,6 +2183,7 @@ class AvmFlavor { avm_main_sel_mov_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_mov_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_add = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_address = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_and = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_div = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_eq = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2129,6 +2192,7 @@ class AvmFlavor { avm_main_sel_op_mul = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_not = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_or = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_sender = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_sub = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_xor = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_rng_16 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2171,6 +2235,7 @@ class AvmFlavor { perm_main_mem_ind_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_lengths = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_operations = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + lookup_into_environment = deserialize_from_buffer(Transcript::proof_data, num_frs_read); incl_main_tag_err = deserialize_from_buffer(Transcript::proof_data, num_frs_read); incl_mem_tag_err = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_u8_0 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2192,6 +2257,7 @@ class AvmFlavor { lookup_u16_14 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_lengths_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_operations_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + lookup_into_environment_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); incl_main_tag_err_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); incl_mem_tag_err_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_u8_0_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2310,6 +2376,8 @@ class AvmFlavor { serialize_to_buffer(avm_byte_lookup_table_input_b, Transcript::proof_data); serialize_to_buffer(avm_byte_lookup_table_op_id, Transcript::proof_data); serialize_to_buffer(avm_byte_lookup_table_output, Transcript::proof_data); + serialize_to_buffer(avm_environment_environment_selector, Transcript::proof_data); + serialize_to_buffer(avm_environment_q_environment_lookup, Transcript::proof_data); serialize_to_buffer(avm_main_alu_sel, Transcript::proof_data); serialize_to_buffer(avm_main_bin_op_id, Transcript::proof_data); serialize_to_buffer(avm_main_bin_sel, Transcript::proof_data); @@ -2328,6 +2396,7 @@ class AvmFlavor { serialize_to_buffer(avm_main_ind_op_d, Transcript::proof_data); serialize_to_buffer(avm_main_internal_return_ptr, Transcript::proof_data); serialize_to_buffer(avm_main_inv, Transcript::proof_data); + serialize_to_buffer(avm_main_kernel_inputs__is_public, Transcript::proof_data); serialize_to_buffer(avm_main_last, Transcript::proof_data); serialize_to_buffer(avm_main_mem_idx_a, Transcript::proof_data); serialize_to_buffer(avm_main_mem_idx_b, Transcript::proof_data); @@ -2353,6 +2422,7 @@ class AvmFlavor { serialize_to_buffer(avm_main_sel_mov_a, Transcript::proof_data); serialize_to_buffer(avm_main_sel_mov_b, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_add, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_address, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_and, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_div, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_eq, Transcript::proof_data); @@ -2361,6 +2431,7 @@ class AvmFlavor { serialize_to_buffer(avm_main_sel_op_mul, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_not, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_or, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_sender, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_sub, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_xor, Transcript::proof_data); serialize_to_buffer(avm_main_sel_rng_16, Transcript::proof_data); @@ -2403,6 +2474,7 @@ class AvmFlavor { serialize_to_buffer(perm_main_mem_ind_d, Transcript::proof_data); serialize_to_buffer(lookup_byte_lengths, Transcript::proof_data); serialize_to_buffer(lookup_byte_operations, Transcript::proof_data); + serialize_to_buffer(lookup_into_environment, Transcript::proof_data); serialize_to_buffer(incl_main_tag_err, Transcript::proof_data); serialize_to_buffer(incl_mem_tag_err, Transcript::proof_data); serialize_to_buffer(lookup_u8_0, Transcript::proof_data); @@ -2424,6 +2496,7 @@ class AvmFlavor { serialize_to_buffer(lookup_u16_14, Transcript::proof_data); serialize_to_buffer(lookup_byte_lengths_counts, Transcript::proof_data); serialize_to_buffer(lookup_byte_operations_counts, Transcript::proof_data); + serialize_to_buffer(lookup_into_environment_counts, Transcript::proof_data); serialize_to_buffer(incl_main_tag_err_counts, Transcript::proof_data); serialize_to_buffer(incl_mem_tag_err_counts, Transcript::proof_data); serialize_to_buffer(lookup_u8_0_counts, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index 5c1cde78567..7b516b15f3d 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -136,6 +136,10 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_byte_lookup_table_input_b = commitment_key->commit(key->avm_byte_lookup_table_input_b); witness_commitments.avm_byte_lookup_table_op_id = commitment_key->commit(key->avm_byte_lookup_table_op_id); witness_commitments.avm_byte_lookup_table_output = commitment_key->commit(key->avm_byte_lookup_table_output); + witness_commitments.avm_environment_environment_selector = + commitment_key->commit(key->avm_environment_environment_selector); + witness_commitments.avm_environment_q_environment_lookup = + commitment_key->commit(key->avm_environment_q_environment_lookup); witness_commitments.avm_main_alu_sel = commitment_key->commit(key->avm_main_alu_sel); witness_commitments.avm_main_bin_op_id = commitment_key->commit(key->avm_main_bin_op_id); witness_commitments.avm_main_bin_sel = commitment_key->commit(key->avm_main_bin_sel); @@ -154,6 +158,8 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_ind_op_d = commitment_key->commit(key->avm_main_ind_op_d); witness_commitments.avm_main_internal_return_ptr = commitment_key->commit(key->avm_main_internal_return_ptr); witness_commitments.avm_main_inv = commitment_key->commit(key->avm_main_inv); + witness_commitments.avm_main_kernel_inputs__is_public = + commitment_key->commit(key->avm_main_kernel_inputs__is_public); witness_commitments.avm_main_last = commitment_key->commit(key->avm_main_last); witness_commitments.avm_main_mem_idx_a = commitment_key->commit(key->avm_main_mem_idx_a); witness_commitments.avm_main_mem_idx_b = commitment_key->commit(key->avm_main_mem_idx_b); @@ -179,6 +185,7 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_sel_mov_a = commitment_key->commit(key->avm_main_sel_mov_a); witness_commitments.avm_main_sel_mov_b = commitment_key->commit(key->avm_main_sel_mov_b); witness_commitments.avm_main_sel_op_add = commitment_key->commit(key->avm_main_sel_op_add); + witness_commitments.avm_main_sel_op_address = commitment_key->commit(key->avm_main_sel_op_address); witness_commitments.avm_main_sel_op_and = commitment_key->commit(key->avm_main_sel_op_and); witness_commitments.avm_main_sel_op_div = commitment_key->commit(key->avm_main_sel_op_div); witness_commitments.avm_main_sel_op_eq = commitment_key->commit(key->avm_main_sel_op_eq); @@ -187,6 +194,7 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_sel_op_mul = commitment_key->commit(key->avm_main_sel_op_mul); witness_commitments.avm_main_sel_op_not = commitment_key->commit(key->avm_main_sel_op_not); witness_commitments.avm_main_sel_op_or = commitment_key->commit(key->avm_main_sel_op_or); + witness_commitments.avm_main_sel_op_sender = commitment_key->commit(key->avm_main_sel_op_sender); witness_commitments.avm_main_sel_op_sub = commitment_key->commit(key->avm_main_sel_op_sub); witness_commitments.avm_main_sel_op_xor = commitment_key->commit(key->avm_main_sel_op_xor); witness_commitments.avm_main_sel_rng_16 = commitment_key->commit(key->avm_main_sel_rng_16); @@ -219,6 +227,7 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_mem_w_in_tag = commitment_key->commit(key->avm_mem_w_in_tag); witness_commitments.lookup_byte_lengths_counts = commitment_key->commit(key->lookup_byte_lengths_counts); witness_commitments.lookup_byte_operations_counts = commitment_key->commit(key->lookup_byte_operations_counts); + witness_commitments.lookup_into_environment_counts = commitment_key->commit(key->lookup_into_environment_counts); witness_commitments.incl_main_tag_err_counts = commitment_key->commit(key->incl_main_tag_err_counts); witness_commitments.incl_mem_tag_err_counts = commitment_key->commit(key->incl_mem_tag_err_counts); witness_commitments.lookup_u8_0_counts = commitment_key->commit(key->lookup_u8_0_counts); @@ -325,6 +334,10 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_byte_lookup_table_op_id); transcript->send_to_verifier(commitment_labels.avm_byte_lookup_table_output, witness_commitments.avm_byte_lookup_table_output); + transcript->send_to_verifier(commitment_labels.avm_environment_environment_selector, + witness_commitments.avm_environment_environment_selector); + transcript->send_to_verifier(commitment_labels.avm_environment_q_environment_lookup, + witness_commitments.avm_environment_q_environment_lookup); transcript->send_to_verifier(commitment_labels.avm_main_alu_sel, witness_commitments.avm_main_alu_sel); transcript->send_to_verifier(commitment_labels.avm_main_bin_op_id, witness_commitments.avm_main_bin_op_id); transcript->send_to_verifier(commitment_labels.avm_main_bin_sel, witness_commitments.avm_main_bin_sel); @@ -344,6 +357,8 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.avm_main_internal_return_ptr, witness_commitments.avm_main_internal_return_ptr); transcript->send_to_verifier(commitment_labels.avm_main_inv, witness_commitments.avm_main_inv); + transcript->send_to_verifier(commitment_labels.avm_main_kernel_inputs__is_public, + witness_commitments.avm_main_kernel_inputs__is_public); transcript->send_to_verifier(commitment_labels.avm_main_last, witness_commitments.avm_main_last); transcript->send_to_verifier(commitment_labels.avm_main_mem_idx_a, witness_commitments.avm_main_mem_idx_a); transcript->send_to_verifier(commitment_labels.avm_main_mem_idx_b, witness_commitments.avm_main_mem_idx_b); @@ -371,6 +386,8 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.avm_main_sel_mov_a, witness_commitments.avm_main_sel_mov_a); transcript->send_to_verifier(commitment_labels.avm_main_sel_mov_b, witness_commitments.avm_main_sel_mov_b); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_add, witness_commitments.avm_main_sel_op_add); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_address, + witness_commitments.avm_main_sel_op_address); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_and, witness_commitments.avm_main_sel_op_and); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_div, witness_commitments.avm_main_sel_op_div); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_eq, witness_commitments.avm_main_sel_op_eq); @@ -379,6 +396,7 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.avm_main_sel_op_mul, witness_commitments.avm_main_sel_op_mul); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_not, witness_commitments.avm_main_sel_op_not); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_or, witness_commitments.avm_main_sel_op_or); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_sender, witness_commitments.avm_main_sel_op_sender); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_sub, witness_commitments.avm_main_sel_op_sub); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_xor, witness_commitments.avm_main_sel_op_xor); transcript->send_to_verifier(commitment_labels.avm_main_sel_rng_16, witness_commitments.avm_main_sel_rng_16); @@ -413,6 +431,8 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.lookup_byte_lengths_counts); transcript->send_to_verifier(commitment_labels.lookup_byte_operations_counts, witness_commitments.lookup_byte_operations_counts); + transcript->send_to_verifier(commitment_labels.lookup_into_environment_counts, + witness_commitments.lookup_into_environment_counts); transcript->send_to_verifier(commitment_labels.incl_main_tag_err_counts, witness_commitments.incl_main_tag_err_counts); transcript->send_to_verifier(commitment_labels.incl_mem_tag_err_counts, @@ -458,6 +478,7 @@ void AvmProver::execute_log_derivative_inverse_round() witness_commitments.perm_main_mem_ind_d = commitment_key->commit(key->perm_main_mem_ind_d); witness_commitments.lookup_byte_lengths = commitment_key->commit(key->lookup_byte_lengths); witness_commitments.lookup_byte_operations = commitment_key->commit(key->lookup_byte_operations); + witness_commitments.lookup_into_environment = commitment_key->commit(key->lookup_into_environment); witness_commitments.incl_main_tag_err = commitment_key->commit(key->incl_main_tag_err); witness_commitments.incl_mem_tag_err = commitment_key->commit(key->incl_mem_tag_err); witness_commitments.lookup_u8_0 = commitment_key->commit(key->lookup_u8_0); @@ -491,6 +512,8 @@ void AvmProver::execute_log_derivative_inverse_round() transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_d, witness_commitments.perm_main_mem_ind_d); transcript->send_to_verifier(commitment_labels.lookup_byte_lengths, witness_commitments.lookup_byte_lengths); transcript->send_to_verifier(commitment_labels.lookup_byte_operations, witness_commitments.lookup_byte_operations); + transcript->send_to_verifier(commitment_labels.lookup_into_environment, + witness_commitments.lookup_into_environment); transcript->send_to_verifier(commitment_labels.incl_main_tag_err, witness_commitments.incl_main_tag_err); transcript->send_to_verifier(commitment_labels.incl_mem_tag_err, witness_commitments.incl_mem_tag_err); transcript->send_to_verifier(commitment_labels.lookup_u8_0, witness_commitments.lookup_u8_0); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index f1b9bb2e4cd..55aa8163487 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -3,9 +3,11 @@ #include "./avm_verifier.hpp" #include "barretenberg/commitment_schemes/zeromorph/zeromorph.hpp" #include "barretenberg/numeric/bitop/get_msb.hpp" +#include "barretenberg/polynomials/polynomial.hpp" #include "barretenberg/transcript/transcript.hpp" namespace bb { + AvmVerifier::AvmVerifier(std::shared_ptr verifier_key) : key(verifier_key) {} @@ -23,11 +25,20 @@ AvmVerifier& AvmVerifier::operator=(AvmVerifier&& other) noexcept return *this; } +using FF = AvmFlavor::FF; + +// Evaluate the given public input column over the multivariate challenge points +[[maybe_unused]] FF evaluate_public_input_column(std::vector points, std::vector challenges) +{ + Polynomial polynomial(points); + return polynomial.evaluate_mle(challenges); +} + /** * @brief This function verifies an Avm Honk proof for given program settings. * */ -bool AvmVerifier::verify_proof(const HonkProof& proof) +bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& public_inputs) { using Flavor = AvmFlavor; using FF = Flavor::FF; @@ -167,6 +178,10 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.avm_byte_lookup_table_op_id); commitments.avm_byte_lookup_table_output = transcript->template receive_from_prover(commitment_labels.avm_byte_lookup_table_output); + commitments.avm_environment_environment_selector = + transcript->template receive_from_prover(commitment_labels.avm_environment_environment_selector); + commitments.avm_environment_q_environment_lookup = + transcript->template receive_from_prover(commitment_labels.avm_environment_q_environment_lookup); commitments.avm_main_alu_sel = transcript->template receive_from_prover(commitment_labels.avm_main_alu_sel); commitments.avm_main_bin_op_id = @@ -194,6 +209,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) commitments.avm_main_internal_return_ptr = transcript->template receive_from_prover(commitment_labels.avm_main_internal_return_ptr); commitments.avm_main_inv = transcript->template receive_from_prover(commitment_labels.avm_main_inv); + commitments.avm_main_kernel_inputs__is_public = + transcript->template receive_from_prover(commitment_labels.avm_main_kernel_inputs__is_public); commitments.avm_main_last = transcript->template receive_from_prover(commitment_labels.avm_main_last); commitments.avm_main_mem_idx_a = transcript->template receive_from_prover(commitment_labels.avm_main_mem_idx_a); @@ -238,6 +255,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.avm_main_sel_mov_b); commitments.avm_main_sel_op_add = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_add); + commitments.avm_main_sel_op_address = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_address); commitments.avm_main_sel_op_and = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_and); commitments.avm_main_sel_op_div = @@ -254,6 +273,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_not); commitments.avm_main_sel_op_or = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_or); + commitments.avm_main_sel_op_sender = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_sender); commitments.avm_main_sel_op_sub = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_sub); commitments.avm_main_sel_op_xor = @@ -308,6 +329,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths_counts); commitments.lookup_byte_operations_counts = transcript->template receive_from_prover(commitment_labels.lookup_byte_operations_counts); + commitments.lookup_into_environment_counts = + transcript->template receive_from_prover(commitment_labels.lookup_into_environment_counts); commitments.incl_main_tag_err_counts = transcript->template receive_from_prover(commitment_labels.incl_main_tag_err_counts); commitments.incl_mem_tag_err_counts = @@ -374,6 +397,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths); commitments.lookup_byte_operations = transcript->template receive_from_prover(commitment_labels.lookup_byte_operations); + commitments.lookup_into_environment = + transcript->template receive_from_prover(commitment_labels.lookup_into_environment); commitments.incl_main_tag_err = transcript->template receive_from_prover(commitment_labels.incl_main_tag_err); commitments.incl_mem_tag_err = @@ -415,6 +440,11 @@ bool AvmVerifier::verify_proof(const HonkProof& proof) return false; } + FF public_column_evaluation = evaluate_public_input_column(public_inputs, multivariate_challenge); + if (public_column_evaluation != claimed_evaluations.avm_main_kernel_inputs__is_public) { + return false; + } + // Execute ZeroMorph rounds. See https://hackmd.io/dlf9xEwhTQyE3hiGbq4FsA?view for a complete description of the // unrolled protocol. // NOTE: temporarily disabled - facing integration issues diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp index 866eee52b19..4842c5425cd 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp @@ -22,7 +22,7 @@ class AvmVerifier { AvmVerifier& operator=(const AvmVerifier& other) = delete; AvmVerifier& operator=(AvmVerifier&& other) noexcept; - bool verify_proof(const HonkProof& proof); + bool verify_proof(const HonkProof& proof, const std::vector& public_inputs); std::shared_ptr key; std::map commitments; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp index 52660b91ed9..7d18726ff7f 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_verifier.cpp @@ -26,9 +26,8 @@ SpikeVerifier& SpikeVerifier::operator=(SpikeVerifier&& other) noexcept } using FF = SpikeFlavor::FF; - // Evaluate the given public input column over the multivariate challenge points -[[maybe_unused]] FF evaluate_public_input_column(std::vector points, std::vector challenges) +[[maybe_unused]] inline FF evaluate_public_input_column(std::vector points, std::vector challenges) { Polynomial polynomial(points); return polynomial.evaluate_mle(challenges); diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_environment.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_environment.test.cpp new file mode 100644 index 00000000000..0c0c22ee119 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_environment.test.cpp @@ -0,0 +1,45 @@ + +#include "avm_common.test.hpp" + +namespace tests_avm { +using namespace bb::avm_trace; + +class AvmEnvironmentTests : public ::testing::Test { + + protected: + // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test. + void SetUp() override { srs::init_crs_factory("../srs_db/ignition"); }; +}; + +TEST_F(AvmEnvironmentTests, simpleSender) +{ + // We test that the sender opcode is inlcuded at index x in the public inputs + + std::vector kernel_inputs = { FF(1), FF(2) }; + AvmTraceBuilder trace_builder(kernel_inputs); + + // We should return a value of 1 for the sender, as it exists at index 0 + trace_builder.op_sender(42); + trace_builder.halt(); + + auto trace = trace_builder.finalize(); + + validate_trace(std::move(trace), kernel_inputs); +} + +TEST_F(AvmEnvironmentTests, simpleAddress) +{ + // We test that the sender opcode is inlcuded at index x in the public inputs + + std::vector kernel_inputs = { FF(1), FF(2) }; + AvmTraceBuilder trace_builder(kernel_inputs); + + // We should return a value of 1 for the sender, as it exists at index 0 + trace_builder.op_address(42); + trace_builder.halt(); + + auto trace = trace_builder.finalize(); + + validate_trace(std::move(trace), kernel_inputs); +} +} // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index c91374202df..9fc3a284b72 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -7,9 +7,9 @@ namespace tests_avm { * * @param trace The execution trace */ -void validate_trace_check_circuit(std::vector&& trace) +void validate_trace_check_circuit(std::vector&& trace, std::vector public_inputs) { - validate_trace(std::move(trace), false); + validate_trace(std::move(trace), public_inputs, false); }; /** @@ -18,7 +18,7 @@ void validate_trace_check_circuit(std::vector&& trace) * * @param trace The execution trace */ -void validate_trace(std::vector&& trace, bool with_proof) +void validate_trace(std::vector&& trace, std::vector public_inputs, bool with_proof) { auto circuit_builder = AvmCircuitBuilder(); circuit_builder.set_trace(std::move(trace)); @@ -30,7 +30,7 @@ void validate_trace(std::vector&& trace, bool with_proof) auto proof = prover.construct_proof(); auto verifier = composer.create_verifier(circuit_builder); - bool verified = verifier.verify_proof(proof); + bool verified = verifier.verify_proof(proof, public_inputs); EXPECT_TRUE(verified); } diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp index b1f4df3924a..6f85716a371 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp @@ -1,6 +1,7 @@ #pragma once #include "barretenberg/vm/avm_trace/avm_trace.hpp" +#include #define EXPECT_THROW_WITH_MESSAGE(code, expectedMessage) \ try { \ @@ -22,8 +23,8 @@ static const bool ENABLE_PROVING = std::getenv("AVM_TESTS_ENABLE_PROVING") != nu // If the test is expecting a relation to fail, then use validate_trace_check_circuit. // Otherwise, use validate_trace with a single argument. If the proving needs to be // enabled all the time in a given test, use validate_trace with setting with_proof = true. -void validate_trace_check_circuit(std::vector&& trace); -void validate_trace(std::vector&& trace, bool with_proof = ENABLE_PROVING); +void validate_trace_check_circuit(std::vector&& trace, std::vector public_inputs = {}); +void validate_trace(std::vector&& trace, std::vector public_inputs = {}, bool with_proof = ENABLE_PROVING); void mutate_ic_in_trace(std::vector& trace, std::function&& selectRow, FF const& newValue, From d5813a27a876fa70a245e8f91d980306903358c9 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 15 Apr 2024 23:34:28 +0000 Subject: [PATCH 15/40] feat: generalise builder, move after review --- barretenberg/cpp/pil/avm/avm_environment.pil | 16 - barretenberg/cpp/pil/avm/avm_kernel.pil | 42 +++ barretenberg/cpp/pil/avm/avm_main.pil | 54 ++- barretenberg/cpp/pil/avm/constants.pil | 10 + barretenberg/cpp/src/CMakeLists.txt | 3 + .../relations/generated/avm/avm_kernel.hpp | 123 +++++++ .../relations/generated/avm/avm_main.hpp | 338 +++++++++++++----- .../relations/generated/avm/declare_views.hpp | 18 +- .../generated/avm/lookup_into_environment.hpp | 22 +- .../vm/avm_trace/avm_environment_trace.cpp | 38 -- .../vm/avm_trace/avm_environment_trace.hpp | 36 -- .../vm/avm_trace/avm_kernel_trace.cpp | 66 ++++ .../vm/avm_trace/avm_kernel_trace.hpp | 56 +++ .../barretenberg/vm/avm_trace/avm_trace.cpp | 135 ++++--- .../barretenberg/vm/avm_trace/avm_trace.hpp | 14 +- .../barretenberg/vm/avm_trace/constants.hpp | 6 + .../vm/generated/avm_circuit_builder.hpp | 45 ++- .../barretenberg/vm/generated/avm_flavor.hpp | 163 +++++++-- .../barretenberg/vm/generated/avm_prover.cpp | 55 ++- .../vm/generated/avm_verifier.cpp | 36 +- .../vm/tests/avm_environment.test.cpp | 45 --- .../barretenberg/vm/tests/avm_kernel.test.cpp | 66 ++++ .../barretenberg/vm/tests/helpers.test.cpp | 11 +- .../barretenberg/vm/tests/helpers.test.hpp | 7 +- 24 files changed, 1032 insertions(+), 373 deletions(-) delete mode 100644 barretenberg/cpp/pil/avm/avm_environment.pil create mode 100644 barretenberg/cpp/pil/avm/avm_kernel.pil create mode 100644 barretenberg/cpp/pil/avm/constants.pil create mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp delete mode 100644 barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.cpp delete mode 100644 barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/avm_trace/constants.hpp delete mode 100644 barretenberg/cpp/src/barretenberg/vm/tests/avm_environment.test.cpp create mode 100644 barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp diff --git a/barretenberg/cpp/pil/avm/avm_environment.pil b/barretenberg/cpp/pil/avm/avm_environment.pil deleted file mode 100644 index 7b4e506f446..00000000000 --- a/barretenberg/cpp/pil/avm/avm_environment.pil +++ /dev/null @@ -1,16 +0,0 @@ - -namespace avm_environment(256); - - // The general pattern for environment lookups is as follows: - // - If we are performing an environment lookup, then we set q_environment_lookup - // - We can toggle what index in the - pol commit environment_selector; - pol commit q_environment_lookup; - - // Note we are currently using arbitrary opcodes for each - // For this demo, caller is stored at index 0 - #[SENDER_ENVIRONMENT] - q_environment_lookup * avm_main.sel_op_sender * (environment_selector) = 0; - - #[ADDRESS_ENVIRONMENT] - q_environment_lookup * avm_main.sel_op_address * (environment_selector - 1) = 0; diff --git a/barretenberg/cpp/pil/avm/avm_kernel.pil b/barretenberg/cpp/pil/avm/avm_kernel.pil new file mode 100644 index 00000000000..2accc5a5bc9 --- /dev/null +++ b/barretenberg/cpp/pil/avm/avm_kernel.pil @@ -0,0 +1,42 @@ +include "avm_main.pil"; +include "constants.pil"; + +namespace avm_kernel(256); + pol public kernel_inputs; + pol commit kernel_sel; + + // The general pattern for environment lookups is as follows: + // - If we are performing an environment lookup, then we set q_environment_lookup + // - We can toggle what index in the + + // Note we are currently using arbitrary opcodes for each + // For this demo, caller is stored at index 0 + #[SENDER_KERNEL] + avm_main.sel_op_sender * (kernel_sel - constants.SENDER_SELECTOR) = 0; + + #[ADDRESS_KERNEL] + avm_main.sel_op_address * (kernel_sel - constants.ADDRESS_SELECTOR) = 0; + + #[PORTAL_KERNEL] + avm_main.sel_op_portal * (kernel_sel - constants.PORTAL_SELECTOR) = 0; + + #[FUNCTION_KERNEL] + avm_main.sel_op_function_selector * (kernel_sel - constants.FUNCTION_SELECTOR) = 0; + + #[FEE_DA_GAS_KERNEL] + avm_main.sel_op_fee_per_da_gas * (kernel_sel - constants.FEE_PER_DA_GAS_SELECTOR) = 0; + + #[FEE_L1_GAS_KERNEL] + avm_main.sel_op_fee_per_l1_gas * (kernel_sel - constants.FEE_PER_L1_GAS_SELECTOR) = 0; + + #[FEE_L2_GAS_KERNEL] + avm_main.sel_op_fee_per_l2_gas * (kernel_sel - constants.FEE_PER_L2_GAS_SELECTOR) = 0; + + // TODO: temporarily have a column to add the public inputs to a lookup table + // NOTE: WE SHOULD NOT NEED THIS - every thing in the column will be added to the table + // We should be able to have this always be on + pol commit q_public_input_kernel_add_to_table; + + #[LOOKUP_INTO_ENVIRONMENT] + // TODO: FIX not having the trailing is_public breaking compilation :( + avm_main.q_kernel_lookup { avm_main.ia, kernel_sel } in q_public_input_kernel_add_to_table { kernel_inputs__is_public, avm_main.clk }; diff --git a/barretenberg/cpp/pil/avm/avm_main.pil b/barretenberg/cpp/pil/avm/avm_main.pil index 4c26ce18364..ad9275e7e09 100644 --- a/barretenberg/cpp/pil/avm/avm_main.pil +++ b/barretenberg/cpp/pil/avm/avm_main.pil @@ -2,22 +2,30 @@ include "avm_mem.pil"; include "avm_alu.pil"; include "avm_binary.pil"; -include "avm_environment.pil"; +include "avm_kernel.pil"; namespace avm_main(256); - //===== PUBLIC INPUTS ========================================================= - pol public kernel_inputs; + // Kernel lookup selector opcodes + pol commit q_kernel_lookup; - // Envrionment lookup selector opcodes - // NOTE: we start with an arbitrary subset of operations - just these two for now - // CALLER + // CALL CONTEXT pol commit sel_op_sender; - // ADDRESS pol commit sel_op_address; + pol commit sel_op_portal; + pol commit sel_op_function_selector; + + // FEES + pol commit sel_op_fee_per_l1_gas; + pol commit sel_op_fee_per_l2_gas; + pol commit sel_op_fee_per_da_gas; - #[LOOKUP_INTO_ENVIRONMENT] - // TODO: FIX not having the trailing is_public breaking compilation :( - avm_environment.q_environment_lookup { ia, avm_environment.environment_selector } in avm_environment.q_environment_lookup { kernel_inputs__is_public, clk }; + // GLOBALS + pol commit sel_op_chain_id; + pol commit sel_op_version; + pol commit sel_op_block_number; + pol commit sel_op_coinbase; + pol commit sel_op_timestamp; + //===== CONSTANT POLYNOMIALS ================================================== pol constant clk(i) { i }; @@ -135,6 +143,18 @@ namespace avm_main(256); pol commit last; // Relations on type constraints + sel_op_sender * (1 - sel_op_sender) = 0; + sel_op_address * (1 - sel_op_address) = 0; + sel_op_portal * (1 - sel_op_portal) = 0; + sel_op_function_selector * (1 - sel_op_function_selector) = 0; + sel_op_chain_id * (1 - sel_op_chain_id) = 0; + sel_op_version * (1 - sel_op_version) = 0; + sel_op_block_number * (1 - sel_op_block_number) = 0; + sel_op_coinbase * (1 - sel_op_coinbase) = 0; + sel_op_timestamp * (1 - sel_op_timestamp) = 0; + sel_op_fee_per_l1_gas * (1 - sel_op_fee_per_l1_gas) = 0; + sel_op_fee_per_l2_gas * (1 - sel_op_fee_per_l2_gas) = 0; + sel_op_fee_per_da_gas * (1 - sel_op_fee_per_da_gas) = 0; sel_op_add * (1 - sel_op_add) = 0; sel_op_sub * (1 - sel_op_sub) = 0; @@ -222,6 +242,15 @@ namespace avm_main(256); // (ib * inv - 1 + op_div_err) = 0 && op_err * (1 - inv) = 0 // This works in combination with op_div_err * (sel_op_div - 1) = 0; // Drawback is the need to paralllelize the latter. + + //===== KERNEL LOOKUPS ======================================================= + pol KERNEL_SELECTORS = ( + sel_op_sender + sel_op_address + sel_op_portal + sel_op_function_selector + sel_op_chain_id + sel_op_version + + sel_op_block_number + sel_op_coinbase + sel_op_timestamp + sel_op_fee_per_l1_gas + sel_op_fee_per_l2_gas + sel_op_fee_per_da_gas + ); + // Ensure that only one kernel lookup is active when the kernel_sel is active + #[KERNEL_ACTIVE_CHECK] + KERNEL_SELECTORS * (1 - q_kernel_lookup) = 0; //===== CONTROL FLOW ======================================================= //===== JUMP =============================================================== @@ -257,7 +286,10 @@ namespace avm_main(256); //===== CONTROL_FLOW_CONSISTENCY ============================================ pol INTERNAL_CALL_STACK_SELECTORS = (first + sel_internal_call + sel_internal_return + sel_halt); - pol OPCODE_SELECTORS = (sel_op_add + sel_op_sub + sel_op_div + sel_op_mul + sel_op_not + sel_op_eq + sel_op_and + sel_op_or + sel_op_xor); + pol OPCODE_SELECTORS = ( + sel_op_add + sel_op_sub + sel_op_div + sel_op_mul + sel_op_not + sel_op_eq + sel_op_and + sel_op_or + + sel_op_xor + KERNEL_SELECTORS + ); // Program counter must increment if not jumping or returning #[PC_INCREMENT] diff --git a/barretenberg/cpp/pil/avm/constants.pil b/barretenberg/cpp/pil/avm/constants.pil new file mode 100644 index 00000000000..8fac51f5627 --- /dev/null +++ b/barretenberg/cpp/pil/avm/constants.pil @@ -0,0 +1,10 @@ + +namespace constants(256); + + pol SENDER_SELECTOR = 0; + pol ADDRESS_SELECTOR = 1; + pol PORTAL_SELECTOR = 2; + pol FUNCTION_SELECTOR = 3; + pol FEE_PER_DA_GAS_SELECTOR = 9; + pol FEE_PER_L1_GAS_SELECTOR = 11; + pol FEE_PER_L2_GAS_SELECTOR = 13; \ No newline at end of file diff --git a/barretenberg/cpp/src/CMakeLists.txt b/barretenberg/cpp/src/CMakeLists.txt index 57f24f01fdf..0451e2a5c4b 100644 --- a/barretenberg/cpp/src/CMakeLists.txt +++ b/barretenberg/cpp/src/CMakeLists.txt @@ -1,6 +1,9 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) +# Temp, increase this flag to enable vm compilation +set(CMAKE_CXX_FLAGS "-fbracket-depth=512") + # Enable the following warnings project wide. # If any compilation issues arise in the future, they should not be silenced here but rather in the # module's own CMakeLists.txt by adding conditional compilation flags like the following diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp new file mode 100644 index 00000000000..08584b34c04 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp @@ -0,0 +1,123 @@ + +#pragma once +#include "../../relation_parameters.hpp" +#include "../../relation_types.hpp" +#include "./declare_views.hpp" + +namespace bb::Avm_vm { + +template struct Avm_kernelRow { + FF avm_kernel_kernel_sel{}; + FF avm_main_sel_op_address{}; + FF avm_main_sel_op_fee_per_da_gas{}; + FF avm_main_sel_op_fee_per_l1_gas{}; + FF avm_main_sel_op_fee_per_l2_gas{}; + FF avm_main_sel_op_function_selector{}; + FF avm_main_sel_op_portal{}; + FF avm_main_sel_op_sender{}; +}; + +inline std::string get_relation_label_avm_kernel(int index) +{ + switch (index) { + case 0: + return "SENDER_KERNEL"; + + case 1: + return "ADDRESS_KERNEL"; + + case 2: + return "PORTAL_KERNEL"; + + case 3: + return "FUNCTION_KERNEL"; + + case 4: + return "FEE_DA_GAS_KERNEL"; + + case 5: + return "FEE_L1_GAS_KERNEL"; + + case 6: + return "FEE_L2_GAS_KERNEL"; + } + return std::to_string(index); +} + +template class avm_kernelImpl { + public: + using FF = FF_; + + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 3, 3, 3, 3, 3, 3, 3, + }; + + template + void static accumulate(ContainerOverSubrelations& evals, + const AllEntities& new_term, + [[maybe_unused]] const RelationParameters&, + [[maybe_unused]] const FF& scaling_factor) + { + + // Contribution 0 + { + Avm_DECLARE_VIEWS(0); + + auto tmp = (avm_main_sel_op_sender * (avm_kernel_kernel_sel - FF(0))); + tmp *= scaling_factor; + std::get<0>(evals) += tmp; + } + // Contribution 1 + { + Avm_DECLARE_VIEWS(1); + + auto tmp = (avm_main_sel_op_address * (avm_kernel_kernel_sel - FF(1))); + tmp *= scaling_factor; + std::get<1>(evals) += tmp; + } + // Contribution 2 + { + Avm_DECLARE_VIEWS(2); + + auto tmp = (avm_main_sel_op_portal * (avm_kernel_kernel_sel - FF(2))); + tmp *= scaling_factor; + std::get<2>(evals) += tmp; + } + // Contribution 3 + { + Avm_DECLARE_VIEWS(3); + + auto tmp = (avm_main_sel_op_function_selector * (avm_kernel_kernel_sel - FF(3))); + tmp *= scaling_factor; + std::get<3>(evals) += tmp; + } + // Contribution 4 + { + Avm_DECLARE_VIEWS(4); + + auto tmp = (avm_main_sel_op_fee_per_da_gas * (avm_kernel_kernel_sel - FF(9))); + tmp *= scaling_factor; + std::get<4>(evals) += tmp; + } + // Contribution 5 + { + Avm_DECLARE_VIEWS(5); + + auto tmp = (avm_main_sel_op_fee_per_l1_gas * (avm_kernel_kernel_sel - FF(11))); + tmp *= scaling_factor; + std::get<5>(evals) += tmp; + } + // Contribution 6 + { + Avm_DECLARE_VIEWS(6); + + auto tmp = (avm_main_sel_op_fee_per_l2_gas * (avm_kernel_kernel_sel - FF(13))); + tmp *= scaling_factor; + std::get<6>(evals) += tmp; + } + } +}; + +template using avm_kernel = Relation>; + +} // namespace bb::Avm_vm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp index 74e611ac699..354418813c1 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp @@ -32,6 +32,7 @@ template struct Avm_mainRow { FF avm_main_op_err{}; FF avm_main_pc{}; FF avm_main_pc_shift{}; + FF avm_main_q_kernel_lookup{}; FF avm_main_r_in_tag{}; FF avm_main_rwa{}; FF avm_main_rwb{}; @@ -46,15 +47,27 @@ template struct Avm_mainRow { FF avm_main_sel_mov_a{}; FF avm_main_sel_mov_b{}; FF avm_main_sel_op_add{}; + FF avm_main_sel_op_address{}; FF avm_main_sel_op_and{}; + FF avm_main_sel_op_block_number{}; + FF avm_main_sel_op_chain_id{}; + FF avm_main_sel_op_coinbase{}; FF avm_main_sel_op_div{}; FF avm_main_sel_op_eq{}; + FF avm_main_sel_op_fee_per_da_gas{}; + FF avm_main_sel_op_fee_per_l1_gas{}; + FF avm_main_sel_op_fee_per_l2_gas{}; + FF avm_main_sel_op_function_selector{}; FF avm_main_sel_op_lt{}; FF avm_main_sel_op_lte{}; FF avm_main_sel_op_mul{}; FF avm_main_sel_op_not{}; FF avm_main_sel_op_or{}; + FF avm_main_sel_op_portal{}; + FF avm_main_sel_op_sender{}; FF avm_main_sel_op_sub{}; + FF avm_main_sel_op_timestamp{}; + FF avm_main_sel_op_version{}; FF avm_main_sel_op_xor{}; FF avm_main_tag_err{}; FF avm_main_w_in_tag{}; @@ -63,52 +76,55 @@ template struct Avm_mainRow { inline std::string get_relation_label_avm_main(int index) { switch (index) { - case 32: + case 44: return "OUTPUT_U8"; - case 33: + case 45: return "SUBOP_DIVISION_FF"; - case 34: + case 46: return "SUBOP_DIVISION_ZERO_ERR1"; - case 35: + case 47: return "SUBOP_DIVISION_ZERO_ERR2"; - case 36: + case 48: return "SUBOP_ERROR_RELEVANT_OP"; - case 38: + case 49: + return "KERNEL_ACTIVE_CHECK"; + + case 51: return "RETURN_POINTER_INCREMENT"; - case 44: + case 57: return "RETURN_POINTER_DECREMENT"; - case 49: + case 62: return "PC_INCREMENT"; - case 50: + case 63: return "INTERNAL_RETURN_POINTER_CONSISTENCY"; - case 51: + case 64: return "CMOV_CONDITION_RES_1"; - case 52: + case 65: return "CMOV_CONDITION_RES_2"; - case 55: + case 68: return "MOV_SAME_VALUE_A"; - case 56: + case 69: return "MOV_SAME_VALUE_B"; - case 57: + case 70: return "MOV_MAIN_SAME_TAG"; - case 59: + case 72: return "BIN_SEL_1"; - case 60: + case 73: return "BIN_SEL_2"; } return std::to_string(index); @@ -118,9 +134,9 @@ template class avm_mainImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 2, + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 2, }; template @@ -134,7 +150,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(0); - auto tmp = (avm_main_sel_op_add * (-avm_main_sel_op_add + FF(1))); + auto tmp = (avm_main_sel_op_sender * (-avm_main_sel_op_sender + FF(1))); tmp *= scaling_factor; std::get<0>(evals) += tmp; } @@ -142,7 +158,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(1); - auto tmp = (avm_main_sel_op_sub * (-avm_main_sel_op_sub + FF(1))); + auto tmp = (avm_main_sel_op_address * (-avm_main_sel_op_address + FF(1))); tmp *= scaling_factor; std::get<1>(evals) += tmp; } @@ -150,7 +166,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(2); - auto tmp = (avm_main_sel_op_mul * (-avm_main_sel_op_mul + FF(1))); + auto tmp = (avm_main_sel_op_portal * (-avm_main_sel_op_portal + FF(1))); tmp *= scaling_factor; std::get<2>(evals) += tmp; } @@ -158,7 +174,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(3); - auto tmp = (avm_main_sel_op_div * (-avm_main_sel_op_div + FF(1))); + auto tmp = (avm_main_sel_op_function_selector * (-avm_main_sel_op_function_selector + FF(1))); tmp *= scaling_factor; std::get<3>(evals) += tmp; } @@ -166,7 +182,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(4); - auto tmp = (avm_main_sel_op_not * (-avm_main_sel_op_not + FF(1))); + auto tmp = (avm_main_sel_op_chain_id * (-avm_main_sel_op_chain_id + FF(1))); tmp *= scaling_factor; std::get<4>(evals) += tmp; } @@ -174,7 +190,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(5); - auto tmp = (avm_main_sel_op_eq * (-avm_main_sel_op_eq + FF(1))); + auto tmp = (avm_main_sel_op_version * (-avm_main_sel_op_version + FF(1))); tmp *= scaling_factor; std::get<5>(evals) += tmp; } @@ -182,7 +198,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(6); - auto tmp = (avm_main_sel_op_and * (-avm_main_sel_op_and + FF(1))); + auto tmp = (avm_main_sel_op_block_number * (-avm_main_sel_op_block_number + FF(1))); tmp *= scaling_factor; std::get<6>(evals) += tmp; } @@ -190,7 +206,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(7); - auto tmp = (avm_main_sel_op_or * (-avm_main_sel_op_or + FF(1))); + auto tmp = (avm_main_sel_op_coinbase * (-avm_main_sel_op_coinbase + FF(1))); tmp *= scaling_factor; std::get<7>(evals) += tmp; } @@ -198,7 +214,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(8); - auto tmp = (avm_main_sel_op_xor * (-avm_main_sel_op_xor + FF(1))); + auto tmp = (avm_main_sel_op_timestamp * (-avm_main_sel_op_timestamp + FF(1))); tmp *= scaling_factor; std::get<8>(evals) += tmp; } @@ -206,7 +222,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(9); - auto tmp = (avm_main_sel_op_lt * (-avm_main_sel_op_lt + FF(1))); + auto tmp = (avm_main_sel_op_fee_per_l1_gas * (-avm_main_sel_op_fee_per_l1_gas + FF(1))); tmp *= scaling_factor; std::get<9>(evals) += tmp; } @@ -214,7 +230,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(10); - auto tmp = (avm_main_sel_op_lte * (-avm_main_sel_op_lte + FF(1))); + auto tmp = (avm_main_sel_op_fee_per_l2_gas * (-avm_main_sel_op_fee_per_l2_gas + FF(1))); tmp *= scaling_factor; std::get<10>(evals) += tmp; } @@ -222,7 +238,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(11); - auto tmp = (avm_main_sel_internal_call * (-avm_main_sel_internal_call + FF(1))); + auto tmp = (avm_main_sel_op_fee_per_da_gas * (-avm_main_sel_op_fee_per_da_gas + FF(1))); tmp *= scaling_factor; std::get<11>(evals) += tmp; } @@ -230,7 +246,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(12); - auto tmp = (avm_main_sel_internal_return * (-avm_main_sel_internal_return + FF(1))); + auto tmp = (avm_main_sel_op_add * (-avm_main_sel_op_add + FF(1))); tmp *= scaling_factor; std::get<12>(evals) += tmp; } @@ -238,7 +254,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(13); - auto tmp = (avm_main_sel_jump * (-avm_main_sel_jump + FF(1))); + auto tmp = (avm_main_sel_op_sub * (-avm_main_sel_op_sub + FF(1))); tmp *= scaling_factor; std::get<13>(evals) += tmp; } @@ -246,7 +262,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(14); - auto tmp = (avm_main_sel_halt * (-avm_main_sel_halt + FF(1))); + auto tmp = (avm_main_sel_op_mul * (-avm_main_sel_op_mul + FF(1))); tmp *= scaling_factor; std::get<14>(evals) += tmp; } @@ -254,7 +270,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(15); - auto tmp = (avm_main_sel_mov * (-avm_main_sel_mov + FF(1))); + auto tmp = (avm_main_sel_op_div * (-avm_main_sel_op_div + FF(1))); tmp *= scaling_factor; std::get<15>(evals) += tmp; } @@ -262,7 +278,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(16); - auto tmp = (avm_main_sel_cmov * (-avm_main_sel_cmov + FF(1))); + auto tmp = (avm_main_sel_op_not * (-avm_main_sel_op_not + FF(1))); tmp *= scaling_factor; std::get<16>(evals) += tmp; } @@ -270,7 +286,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(17); - auto tmp = (avm_main_op_err * (-avm_main_op_err + FF(1))); + auto tmp = (avm_main_sel_op_eq * (-avm_main_sel_op_eq + FF(1))); tmp *= scaling_factor; std::get<17>(evals) += tmp; } @@ -278,7 +294,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(18); - auto tmp = (avm_main_tag_err * (-avm_main_tag_err + FF(1))); + auto tmp = (avm_main_sel_op_and * (-avm_main_sel_op_and + FF(1))); tmp *= scaling_factor; std::get<18>(evals) += tmp; } @@ -286,7 +302,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(19); - auto tmp = (avm_main_id_zero * (-avm_main_id_zero + FF(1))); + auto tmp = (avm_main_sel_op_or * (-avm_main_sel_op_or + FF(1))); tmp *= scaling_factor; std::get<19>(evals) += tmp; } @@ -294,7 +310,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(20); - auto tmp = (avm_main_mem_op_a * (-avm_main_mem_op_a + FF(1))); + auto tmp = (avm_main_sel_op_xor * (-avm_main_sel_op_xor + FF(1))); tmp *= scaling_factor; std::get<20>(evals) += tmp; } @@ -302,7 +318,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(21); - auto tmp = (avm_main_mem_op_b * (-avm_main_mem_op_b + FF(1))); + auto tmp = (avm_main_sel_op_lt * (-avm_main_sel_op_lt + FF(1))); tmp *= scaling_factor; std::get<21>(evals) += tmp; } @@ -310,7 +326,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(22); - auto tmp = (avm_main_mem_op_c * (-avm_main_mem_op_c + FF(1))); + auto tmp = (avm_main_sel_op_lte * (-avm_main_sel_op_lte + FF(1))); tmp *= scaling_factor; std::get<22>(evals) += tmp; } @@ -318,7 +334,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(23); - auto tmp = (avm_main_mem_op_d * (-avm_main_mem_op_d + FF(1))); + auto tmp = (avm_main_sel_internal_call * (-avm_main_sel_internal_call + FF(1))); tmp *= scaling_factor; std::get<23>(evals) += tmp; } @@ -326,7 +342,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(24); - auto tmp = (avm_main_rwa * (-avm_main_rwa + FF(1))); + auto tmp = (avm_main_sel_internal_return * (-avm_main_sel_internal_return + FF(1))); tmp *= scaling_factor; std::get<24>(evals) += tmp; } @@ -334,7 +350,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(25); - auto tmp = (avm_main_rwb * (-avm_main_rwb + FF(1))); + auto tmp = (avm_main_sel_jump * (-avm_main_sel_jump + FF(1))); tmp *= scaling_factor; std::get<25>(evals) += tmp; } @@ -342,7 +358,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(26); - auto tmp = (avm_main_rwc * (-avm_main_rwc + FF(1))); + auto tmp = (avm_main_sel_halt * (-avm_main_sel_halt + FF(1))); tmp *= scaling_factor; std::get<26>(evals) += tmp; } @@ -350,7 +366,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(27); - auto tmp = (avm_main_rwd * (-avm_main_rwd + FF(1))); + auto tmp = (avm_main_sel_mov * (-avm_main_sel_mov + FF(1))); tmp *= scaling_factor; std::get<27>(evals) += tmp; } @@ -358,7 +374,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(28); - auto tmp = (avm_main_ind_op_a * (-avm_main_ind_op_a + FF(1))); + auto tmp = (avm_main_sel_cmov * (-avm_main_sel_cmov + FF(1))); tmp *= scaling_factor; std::get<28>(evals) += tmp; } @@ -366,7 +382,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(29); - auto tmp = (avm_main_ind_op_b * (-avm_main_ind_op_b + FF(1))); + auto tmp = (avm_main_op_err * (-avm_main_op_err + FF(1))); tmp *= scaling_factor; std::get<29>(evals) += tmp; } @@ -374,7 +390,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(30); - auto tmp = (avm_main_ind_op_c * (-avm_main_ind_op_c + FF(1))); + auto tmp = (avm_main_tag_err * (-avm_main_tag_err + FF(1))); tmp *= scaling_factor; std::get<30>(evals) += tmp; } @@ -382,7 +398,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(31); - auto tmp = (avm_main_ind_op_d * (-avm_main_ind_op_d + FF(1))); + auto tmp = (avm_main_id_zero * (-avm_main_id_zero + FF(1))); tmp *= scaling_factor; std::get<31>(evals) += tmp; } @@ -390,8 +406,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(32); - auto tmp = - (((avm_main_sel_op_eq + avm_main_sel_op_lte) + avm_main_sel_op_lt) * (avm_main_w_in_tag - FF(1))); + auto tmp = (avm_main_mem_op_a * (-avm_main_mem_op_a + FF(1))); tmp *= scaling_factor; std::get<32>(evals) += tmp; } @@ -399,8 +414,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(33); - auto tmp = - ((avm_main_sel_op_div * (-avm_main_op_err + FF(1))) * ((avm_main_ic * avm_main_ib) - avm_main_ia)); + auto tmp = (avm_main_mem_op_b * (-avm_main_mem_op_b + FF(1))); tmp *= scaling_factor; std::get<33>(evals) += tmp; } @@ -408,7 +422,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(34); - auto tmp = (avm_main_sel_op_div * (((avm_main_ib * avm_main_inv) - FF(1)) + avm_main_op_err)); + auto tmp = (avm_main_mem_op_c * (-avm_main_mem_op_c + FF(1))); tmp *= scaling_factor; std::get<34>(evals) += tmp; } @@ -416,7 +430,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(35); - auto tmp = ((avm_main_sel_op_div * avm_main_op_err) * (-avm_main_inv + FF(1))); + auto tmp = (avm_main_mem_op_d * (-avm_main_mem_op_d + FF(1))); tmp *= scaling_factor; std::get<35>(evals) += tmp; } @@ -424,7 +438,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(36); - auto tmp = (avm_main_op_err * (avm_main_sel_op_div - FF(1))); + auto tmp = (avm_main_rwa * (-avm_main_rwa + FF(1))); tmp *= scaling_factor; std::get<36>(evals) += tmp; } @@ -432,7 +446,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(37); - auto tmp = (avm_main_sel_jump * (avm_main_pc_shift - avm_main_ia)); + auto tmp = (avm_main_rwb * (-avm_main_rwb + FF(1))); tmp *= scaling_factor; std::get<37>(evals) += tmp; } @@ -440,8 +454,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(38); - auto tmp = (avm_main_sel_internal_call * - (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr + FF(1)))); + auto tmp = (avm_main_rwc * (-avm_main_rwc + FF(1))); tmp *= scaling_factor; std::get<38>(evals) += tmp; } @@ -449,7 +462,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(39); - auto tmp = (avm_main_sel_internal_call * (avm_main_internal_return_ptr - avm_main_mem_idx_b)); + auto tmp = (avm_main_rwd * (-avm_main_rwd + FF(1))); tmp *= scaling_factor; std::get<39>(evals) += tmp; } @@ -457,7 +470,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(40); - auto tmp = (avm_main_sel_internal_call * (avm_main_pc_shift - avm_main_ia)); + auto tmp = (avm_main_ind_op_a * (-avm_main_ind_op_a + FF(1))); tmp *= scaling_factor; std::get<40>(evals) += tmp; } @@ -465,7 +478,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(41); - auto tmp = (avm_main_sel_internal_call * ((avm_main_pc + FF(1)) - avm_main_ib)); + auto tmp = (avm_main_ind_op_b * (-avm_main_ind_op_b + FF(1))); tmp *= scaling_factor; std::get<41>(evals) += tmp; } @@ -473,7 +486,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(42); - auto tmp = (avm_main_sel_internal_call * (avm_main_rwb - FF(1))); + auto tmp = (avm_main_ind_op_c * (-avm_main_ind_op_c + FF(1))); tmp *= scaling_factor; std::get<42>(evals) += tmp; } @@ -481,7 +494,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(43); - auto tmp = (avm_main_sel_internal_call * (avm_main_mem_op_b - FF(1))); + auto tmp = (avm_main_ind_op_d * (-avm_main_ind_op_d + FF(1))); tmp *= scaling_factor; std::get<43>(evals) += tmp; } @@ -489,8 +502,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(44); - auto tmp = (avm_main_sel_internal_return * - (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr - FF(1)))); + auto tmp = + (((avm_main_sel_op_eq + avm_main_sel_op_lte) + avm_main_sel_op_lt) * (avm_main_w_in_tag - FF(1))); tmp *= scaling_factor; std::get<44>(evals) += tmp; } @@ -498,7 +511,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(45); - auto tmp = (avm_main_sel_internal_return * ((avm_main_internal_return_ptr - FF(1)) - avm_main_mem_idx_a)); + auto tmp = + ((avm_main_sel_op_div * (-avm_main_op_err + FF(1))) * ((avm_main_ic * avm_main_ib) - avm_main_ia)); tmp *= scaling_factor; std::get<45>(evals) += tmp; } @@ -506,7 +520,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(46); - auto tmp = (avm_main_sel_internal_return * (avm_main_pc_shift - avm_main_ia)); + auto tmp = (avm_main_sel_op_div * (((avm_main_ib * avm_main_inv) - FF(1)) + avm_main_op_err)); tmp *= scaling_factor; std::get<46>(evals) += tmp; } @@ -514,7 +528,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(47); - auto tmp = (avm_main_sel_internal_return * avm_main_rwa); + auto tmp = ((avm_main_sel_op_div * avm_main_op_err) * (-avm_main_inv + FF(1))); tmp *= scaling_factor; std::get<47>(evals) += tmp; } @@ -522,7 +536,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(48); - auto tmp = (avm_main_sel_internal_return * (avm_main_mem_op_a - FF(1))); + auto tmp = (avm_main_op_err * (avm_main_sel_op_div - FF(1))); tmp *= scaling_factor; std::get<48>(evals) += tmp; } @@ -530,15 +544,17 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(49); - auto tmp = - ((((-avm_main_first + FF(1)) * (-avm_main_sel_halt + FF(1))) * - ((((((((avm_main_sel_op_add + avm_main_sel_op_sub) + avm_main_sel_op_div) + avm_main_sel_op_mul) + - avm_main_sel_op_not) + - avm_main_sel_op_eq) + - avm_main_sel_op_and) + - avm_main_sel_op_or) + - avm_main_sel_op_xor)) * - (avm_main_pc_shift - (avm_main_pc + FF(1)))); + auto tmp = ((((((((((((avm_main_sel_op_sender + avm_main_sel_op_address) + avm_main_sel_op_portal) + + avm_main_sel_op_function_selector) + + avm_main_sel_op_chain_id) + + avm_main_sel_op_version) + + avm_main_sel_op_block_number) + + avm_main_sel_op_coinbase) + + avm_main_sel_op_timestamp) + + avm_main_sel_op_fee_per_l1_gas) + + avm_main_sel_op_fee_per_l2_gas) + + avm_main_sel_op_fee_per_da_gas) * + (-avm_main_q_kernel_lookup + FF(1))); tmp *= scaling_factor; std::get<49>(evals) += tmp; } @@ -546,10 +562,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(50); - auto tmp = ((-(((avm_main_first + avm_main_sel_internal_call) + avm_main_sel_internal_return) + - avm_main_sel_halt) + - FF(1)) * - (avm_main_internal_return_ptr_shift - avm_main_internal_return_ptr)); + auto tmp = (avm_main_sel_jump * (avm_main_pc_shift - avm_main_ia)); tmp *= scaling_factor; std::get<50>(evals) += tmp; } @@ -557,7 +570,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(51); - auto tmp = (avm_main_sel_cmov * (((avm_main_id * avm_main_inv) - FF(1)) + avm_main_id_zero)); + auto tmp = (avm_main_sel_internal_call * + (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr + FF(1)))); tmp *= scaling_factor; std::get<51>(evals) += tmp; } @@ -565,7 +579,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(52); - auto tmp = ((avm_main_sel_cmov * avm_main_id_zero) * (-avm_main_inv + FF(1))); + auto tmp = (avm_main_sel_internal_call * (avm_main_internal_return_ptr - avm_main_mem_idx_b)); tmp *= scaling_factor; std::get<52>(evals) += tmp; } @@ -573,7 +587,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(53); - auto tmp = (avm_main_sel_mov_a - (avm_main_sel_mov + (avm_main_sel_cmov * (-avm_main_id_zero + FF(1))))); + auto tmp = (avm_main_sel_internal_call * (avm_main_pc_shift - avm_main_ia)); tmp *= scaling_factor; std::get<53>(evals) += tmp; } @@ -581,7 +595,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(54); - auto tmp = (avm_main_sel_mov_b - (avm_main_sel_cmov * avm_main_id_zero)); + auto tmp = (avm_main_sel_internal_call * ((avm_main_pc + FF(1)) - avm_main_ib)); tmp *= scaling_factor; std::get<54>(evals) += tmp; } @@ -589,7 +603,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(55); - auto tmp = (avm_main_sel_mov_a * (avm_main_ia - avm_main_ic)); + auto tmp = (avm_main_sel_internal_call * (avm_main_rwb - FF(1))); tmp *= scaling_factor; std::get<55>(evals) += tmp; } @@ -597,7 +611,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(56); - auto tmp = (avm_main_sel_mov_b * (avm_main_ib - avm_main_ic)); + auto tmp = (avm_main_sel_internal_call * (avm_main_mem_op_b - FF(1))); tmp *= scaling_factor; std::get<56>(evals) += tmp; } @@ -605,7 +619,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(57); - auto tmp = ((avm_main_sel_mov + avm_main_sel_cmov) * (avm_main_r_in_tag - avm_main_w_in_tag)); + auto tmp = (avm_main_sel_internal_return * + (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr - FF(1)))); tmp *= scaling_factor; std::get<57>(evals) += tmp; } @@ -613,6 +628,131 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(58); + auto tmp = (avm_main_sel_internal_return * ((avm_main_internal_return_ptr - FF(1)) - avm_main_mem_idx_a)); + tmp *= scaling_factor; + std::get<58>(evals) += tmp; + } + // Contribution 59 + { + Avm_DECLARE_VIEWS(59); + + auto tmp = (avm_main_sel_internal_return * (avm_main_pc_shift - avm_main_ia)); + tmp *= scaling_factor; + std::get<59>(evals) += tmp; + } + // Contribution 60 + { + Avm_DECLARE_VIEWS(60); + + auto tmp = (avm_main_sel_internal_return * avm_main_rwa); + tmp *= scaling_factor; + std::get<60>(evals) += tmp; + } + // Contribution 61 + { + Avm_DECLARE_VIEWS(61); + + auto tmp = (avm_main_sel_internal_return * (avm_main_mem_op_a - FF(1))); + tmp *= scaling_factor; + std::get<61>(evals) += tmp; + } + // Contribution 62 + { + Avm_DECLARE_VIEWS(62); + + auto tmp = + ((((-avm_main_first + FF(1)) * (-avm_main_sel_halt + FF(1))) * + (((((((((avm_main_sel_op_add + avm_main_sel_op_sub) + avm_main_sel_op_div) + avm_main_sel_op_mul) + + avm_main_sel_op_not) + + avm_main_sel_op_eq) + + avm_main_sel_op_and) + + avm_main_sel_op_or) + + avm_main_sel_op_xor) + + (((((((((((avm_main_sel_op_sender + avm_main_sel_op_address) + avm_main_sel_op_portal) + + avm_main_sel_op_function_selector) + + avm_main_sel_op_chain_id) + + avm_main_sel_op_version) + + avm_main_sel_op_block_number) + + avm_main_sel_op_coinbase) + + avm_main_sel_op_timestamp) + + avm_main_sel_op_fee_per_l1_gas) + + avm_main_sel_op_fee_per_l2_gas) + + avm_main_sel_op_fee_per_da_gas))) * + (avm_main_pc_shift - (avm_main_pc + FF(1)))); + tmp *= scaling_factor; + std::get<62>(evals) += tmp; + } + // Contribution 63 + { + Avm_DECLARE_VIEWS(63); + + auto tmp = ((-(((avm_main_first + avm_main_sel_internal_call) + avm_main_sel_internal_return) + + avm_main_sel_halt) + + FF(1)) * + (avm_main_internal_return_ptr_shift - avm_main_internal_return_ptr)); + tmp *= scaling_factor; + std::get<63>(evals) += tmp; + } + // Contribution 64 + { + Avm_DECLARE_VIEWS(64); + + auto tmp = (avm_main_sel_cmov * (((avm_main_id * avm_main_inv) - FF(1)) + avm_main_id_zero)); + tmp *= scaling_factor; + std::get<64>(evals) += tmp; + } + // Contribution 65 + { + Avm_DECLARE_VIEWS(65); + + auto tmp = ((avm_main_sel_cmov * avm_main_id_zero) * (-avm_main_inv + FF(1))); + tmp *= scaling_factor; + std::get<65>(evals) += tmp; + } + // Contribution 66 + { + Avm_DECLARE_VIEWS(66); + + auto tmp = (avm_main_sel_mov_a - (avm_main_sel_mov + (avm_main_sel_cmov * (-avm_main_id_zero + FF(1))))); + tmp *= scaling_factor; + std::get<66>(evals) += tmp; + } + // Contribution 67 + { + Avm_DECLARE_VIEWS(67); + + auto tmp = (avm_main_sel_mov_b - (avm_main_sel_cmov * avm_main_id_zero)); + tmp *= scaling_factor; + std::get<67>(evals) += tmp; + } + // Contribution 68 + { + Avm_DECLARE_VIEWS(68); + + auto tmp = (avm_main_sel_mov_a * (avm_main_ia - avm_main_ic)); + tmp *= scaling_factor; + std::get<68>(evals) += tmp; + } + // Contribution 69 + { + Avm_DECLARE_VIEWS(69); + + auto tmp = (avm_main_sel_mov_b * (avm_main_ib - avm_main_ic)); + tmp *= scaling_factor; + std::get<69>(evals) += tmp; + } + // Contribution 70 + { + Avm_DECLARE_VIEWS(70); + + auto tmp = ((avm_main_sel_mov + avm_main_sel_cmov) * (avm_main_r_in_tag - avm_main_w_in_tag)); + tmp *= scaling_factor; + std::get<70>(evals) += tmp; + } + // Contribution 71 + { + Avm_DECLARE_VIEWS(71); + auto tmp = (avm_main_alu_sel - (((((((avm_main_sel_op_add + avm_main_sel_op_sub) + avm_main_sel_op_mul) + avm_main_sel_op_not) + @@ -621,23 +761,23 @@ template class avm_mainImpl { avm_main_sel_op_lte) * (-avm_main_tag_err + FF(1)))); tmp *= scaling_factor; - std::get<58>(evals) += tmp; + std::get<71>(evals) += tmp; } - // Contribution 59 + // Contribution 72 { - Avm_DECLARE_VIEWS(59); + Avm_DECLARE_VIEWS(72); auto tmp = (avm_main_bin_op_id - (avm_main_sel_op_or + (avm_main_sel_op_xor * FF(2)))); tmp *= scaling_factor; - std::get<59>(evals) += tmp; + std::get<72>(evals) += tmp; } - // Contribution 60 + // Contribution 73 { - Avm_DECLARE_VIEWS(60); + Avm_DECLARE_VIEWS(73); auto tmp = (avm_main_bin_sel - ((avm_main_sel_op_and + avm_main_sel_op_or) + avm_main_sel_op_xor)); tmp *= scaling_factor; - std::get<60>(evals) += tmp; + std::get<73>(evals) += tmp; } } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp index cceb994f764..878b865bb6a 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -80,8 +80,10 @@ [[maybe_unused]] auto avm_byte_lookup_table_input_b = View(new_term.avm_byte_lookup_table_input_b); \ [[maybe_unused]] auto avm_byte_lookup_table_op_id = View(new_term.avm_byte_lookup_table_op_id); \ [[maybe_unused]] auto avm_byte_lookup_table_output = View(new_term.avm_byte_lookup_table_output); \ - [[maybe_unused]] auto avm_environment_environment_selector = View(new_term.avm_environment_environment_selector); \ - [[maybe_unused]] auto avm_environment_q_environment_lookup = View(new_term.avm_environment_q_environment_lookup); \ + [[maybe_unused]] auto avm_kernel_kernel_inputs__is_public = View(new_term.avm_kernel_kernel_inputs__is_public); \ + [[maybe_unused]] auto avm_kernel_kernel_sel = View(new_term.avm_kernel_kernel_sel); \ + [[maybe_unused]] auto avm_kernel_q_public_input_kernel_add_to_table = \ + View(new_term.avm_kernel_q_public_input_kernel_add_to_table); \ [[maybe_unused]] auto avm_main_alu_sel = View(new_term.avm_main_alu_sel); \ [[maybe_unused]] auto avm_main_bin_op_id = View(new_term.avm_main_bin_op_id); \ [[maybe_unused]] auto avm_main_bin_sel = View(new_term.avm_main_bin_sel); \ @@ -100,7 +102,6 @@ [[maybe_unused]] auto avm_main_ind_op_d = View(new_term.avm_main_ind_op_d); \ [[maybe_unused]] auto avm_main_internal_return_ptr = View(new_term.avm_main_internal_return_ptr); \ [[maybe_unused]] auto avm_main_inv = View(new_term.avm_main_inv); \ - [[maybe_unused]] auto avm_main_kernel_inputs__is_public = View(new_term.avm_main_kernel_inputs__is_public); \ [[maybe_unused]] auto avm_main_last = View(new_term.avm_main_last); \ [[maybe_unused]] auto avm_main_mem_idx_a = View(new_term.avm_main_mem_idx_a); \ [[maybe_unused]] auto avm_main_mem_idx_b = View(new_term.avm_main_mem_idx_b); \ @@ -112,6 +113,7 @@ [[maybe_unused]] auto avm_main_mem_op_d = View(new_term.avm_main_mem_op_d); \ [[maybe_unused]] auto avm_main_op_err = View(new_term.avm_main_op_err); \ [[maybe_unused]] auto avm_main_pc = View(new_term.avm_main_pc); \ + [[maybe_unused]] auto avm_main_q_kernel_lookup = View(new_term.avm_main_q_kernel_lookup); \ [[maybe_unused]] auto avm_main_r_in_tag = View(new_term.avm_main_r_in_tag); \ [[maybe_unused]] auto avm_main_rwa = View(new_term.avm_main_rwa); \ [[maybe_unused]] auto avm_main_rwb = View(new_term.avm_main_rwb); \ @@ -128,15 +130,25 @@ [[maybe_unused]] auto avm_main_sel_op_add = View(new_term.avm_main_sel_op_add); \ [[maybe_unused]] auto avm_main_sel_op_address = View(new_term.avm_main_sel_op_address); \ [[maybe_unused]] auto avm_main_sel_op_and = View(new_term.avm_main_sel_op_and); \ + [[maybe_unused]] auto avm_main_sel_op_block_number = View(new_term.avm_main_sel_op_block_number); \ + [[maybe_unused]] auto avm_main_sel_op_chain_id = View(new_term.avm_main_sel_op_chain_id); \ + [[maybe_unused]] auto avm_main_sel_op_coinbase = View(new_term.avm_main_sel_op_coinbase); \ [[maybe_unused]] auto avm_main_sel_op_div = View(new_term.avm_main_sel_op_div); \ [[maybe_unused]] auto avm_main_sel_op_eq = View(new_term.avm_main_sel_op_eq); \ + [[maybe_unused]] auto avm_main_sel_op_fee_per_da_gas = View(new_term.avm_main_sel_op_fee_per_da_gas); \ + [[maybe_unused]] auto avm_main_sel_op_fee_per_l1_gas = View(new_term.avm_main_sel_op_fee_per_l1_gas); \ + [[maybe_unused]] auto avm_main_sel_op_fee_per_l2_gas = View(new_term.avm_main_sel_op_fee_per_l2_gas); \ + [[maybe_unused]] auto avm_main_sel_op_function_selector = View(new_term.avm_main_sel_op_function_selector); \ [[maybe_unused]] auto avm_main_sel_op_lt = View(new_term.avm_main_sel_op_lt); \ [[maybe_unused]] auto avm_main_sel_op_lte = View(new_term.avm_main_sel_op_lte); \ [[maybe_unused]] auto avm_main_sel_op_mul = View(new_term.avm_main_sel_op_mul); \ [[maybe_unused]] auto avm_main_sel_op_not = View(new_term.avm_main_sel_op_not); \ [[maybe_unused]] auto avm_main_sel_op_or = View(new_term.avm_main_sel_op_or); \ + [[maybe_unused]] auto avm_main_sel_op_portal = View(new_term.avm_main_sel_op_portal); \ [[maybe_unused]] auto avm_main_sel_op_sender = View(new_term.avm_main_sel_op_sender); \ [[maybe_unused]] auto avm_main_sel_op_sub = View(new_term.avm_main_sel_op_sub); \ + [[maybe_unused]] auto avm_main_sel_op_timestamp = View(new_term.avm_main_sel_op_timestamp); \ + [[maybe_unused]] auto avm_main_sel_op_version = View(new_term.avm_main_sel_op_version); \ [[maybe_unused]] auto avm_main_sel_op_xor = View(new_term.avm_main_sel_op_xor); \ [[maybe_unused]] auto avm_main_sel_rng_16 = View(new_term.avm_main_sel_rng_16); \ [[maybe_unused]] auto avm_main_sel_rng_8 = View(new_term.avm_main_sel_rng_8); \ diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp index 4239be52ada..d0607647895 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp @@ -87,7 +87,7 @@ class lookup_into_environment_lookup_settings { template static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in) { - return (in.avm_environment_q_environment_lookup == 1 || in.avm_environment_q_environment_lookup == 1); + return (in.avm_main_q_kernel_lookup == 1 || in.avm_kernel_q_public_input_kernel_add_to_table == 1); } /** @@ -104,8 +104,8 @@ class lookup_into_environment_lookup_settings { static inline auto compute_inverse_exists(const AllEntities& in) { using View = typename Accumulator::View; - const auto is_operation = View(in.avm_environment_q_environment_lookup); - const auto is_table_entry = View(in.avm_environment_q_environment_lookup); + const auto is_operation = View(in.avm_main_q_kernel_lookup); + const auto is_table_entry = View(in.avm_kernel_q_public_input_kernel_add_to_table); return (is_operation + is_table_entry - is_operation * is_table_entry); } @@ -135,11 +135,11 @@ class lookup_into_environment_lookup_settings { return std::forward_as_tuple(in.lookup_into_environment, in.lookup_into_environment_counts, - in.avm_environment_q_environment_lookup, - in.avm_environment_q_environment_lookup, + in.avm_main_q_kernel_lookup, + in.avm_kernel_q_public_input_kernel_add_to_table, in.avm_main_ia, - in.avm_environment_environment_selector, - in.avm_main_kernel_inputs__is_public, + in.avm_kernel_kernel_sel, + in.avm_kernel_kernel_inputs__is_public, in.avm_main_clk); } @@ -155,11 +155,11 @@ class lookup_into_environment_lookup_settings { return std::forward_as_tuple(in.lookup_into_environment, in.lookup_into_environment_counts, - in.avm_environment_q_environment_lookup, - in.avm_environment_q_environment_lookup, + in.avm_main_q_kernel_lookup, + in.avm_kernel_q_public_input_kernel_add_to_table, in.avm_main_ia, - in.avm_environment_environment_selector, - in.avm_main_kernel_inputs__is_public, + in.avm_kernel_kernel_sel, + in.avm_kernel_kernel_inputs__is_public, in.avm_main_clk); } }; diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.cpp deleted file mode 100644 index f89233755d1..00000000000 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.cpp +++ /dev/null @@ -1,38 +0,0 @@ -#include "avm_environment_trace.hpp" -#include "barretenberg/vm/avm_trace/avm_common.hpp" -#include "barretenberg/vm/avm_trace/avm_trace.hpp" -#include - -namespace bb::avm_trace { - -AvmEnvironmentTraceBuilder::AvmEnvironmentTraceBuilder(std::vector kernel_inputs) - : kernel_inputs(kernel_inputs) -{} - -void AvmEnvironmentTraceBuilder::reset() -{ - environment_selector_counter.clear(); -} - -FF AvmEnvironmentTraceBuilder::op_sender() -{ - // We want to be able to get the return value from the public inputs column - // Get the return value, this will be places in ia - // We read from the public inputs that were provided to the kernel - FF result = kernel_inputs[SENDER_SELECTOR]; - environment_selector_counter[SENDER_SELECTOR]++; - - return result; -} - -FF AvmEnvironmentTraceBuilder::op_address() -{ - // We want to be able to get the return value from the public inputs column - // Get the return value, this will be places in ia - // We read from the public inputs that were provided to the kernel - FF result = kernel_inputs[ADDRESS_SELECTOR]; - environment_selector_counter[ADDRESS_SELECTOR]++; - - return result; -} -} // namespace bb::avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.hpp deleted file mode 100644 index e587fbdea19..00000000000 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_environment_trace.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#pragma once - -#include "avm_common.hpp" -#include "barretenberg/numeric/uint128/uint128.hpp" -#include -#include - -inline const uint32_t SENDER_SELECTOR = 0; -inline const uint32_t ADDRESS_SELECTOR = 1; - -namespace bb::avm_trace { -class AvmEnvironmentTraceBuilder { - public: - struct EnvironmentTraceEntry { - // TODO: could be u8? - uint32_t environment_selector = 0; - bool q_environment_lookup = false; - }; - - std::vector kernel_inputs; - - // Counts the number of accesses into each SELECTOR for the environment selector lookups; - std::unordered_map environment_selector_counter; - - // TODO: should i have access to the kernel_inputs here -> so they can be directly looked up? - AvmEnvironmentTraceBuilder(std::vector kernel_inputs); - - void reset(); - - FF op_sender(); - FF op_address(); - - private: - std::vector environment_trace; -}; -} // namespace bb::avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp new file mode 100644 index 00000000000..981a49fe994 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp @@ -0,0 +1,66 @@ +#include "avm_kernel_trace.hpp" +#include "barretenberg/vm/avm_trace/avm_common.hpp" +#include "barretenberg/vm/avm_trace/avm_trace.hpp" +#include "constants.hpp" +#include + +// For the meantime, we do not fire around the public inputs as a vector or otherwise +// Instead we fire them around as a fixed length array from the kernel, as that is how they will be + +namespace bb::avm_trace { + +AvmKernelTraceBuilder::AvmKernelTraceBuilder(std::array kernel_inputs) + : kernel_inputs(kernel_inputs) +{} + +void AvmKernelTraceBuilder::reset() +{ + kernel_selector_counter.clear(); +} + +FF AvmKernelTraceBuilder::perform_kernel_lookup(uint32_t selector) +{ + FF result = kernel_inputs[selector]; + kernel_selector_counter[selector]++; + return result; +} + +// We want to be able to get the return value from the public inputs column +// Get the return value, this will be places in ia +// We read from the public inputs that were provided to the kernel +FF AvmKernelTraceBuilder::op_sender() +{ + return perform_kernel_lookup(SENDER_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_address() +{ + return perform_kernel_lookup(ADDRESS_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_portal() +{ + return perform_kernel_lookup(PORTAL_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_function() +{ + return perform_kernel_lookup(FUNCTION_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_fee_per_da_gas() +{ + return perform_kernel_lookup(FEE_PER_DA_GAS_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_fee_per_l1_gas() +{ + return perform_kernel_lookup(FEE_PER_L1_GAS_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_fee_per_l2_gas() +{ + return perform_kernel_lookup(FEE_PER_L2_GAS_SELECTOR); +} + +} // namespace bb::avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp new file mode 100644 index 00000000000..a74560927b8 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp @@ -0,0 +1,56 @@ +#pragma once + +#include "avm_common.hpp" +#include "barretenberg/numeric/uint128/uint128.hpp" +#include "constants.hpp" +#include +#include + +inline const uint32_t SENDER_SELECTOR = 0; +inline const uint32_t ADDRESS_SELECTOR = 1; +inline const uint32_t PORTAL_SELECTOR = 2; +inline const uint32_t FUNCTION_SELECTOR = 3; +// TODO: double check that these indexes are correct +inline const uint32_t FEE_PER_DA_GAS_SELECTOR = 9; +inline const uint32_t FEE_PER_L1_GAS_SELECTOR = 11; +inline const uint32_t FEE_PER_L2_GAS_SELECTOR = 13; + +const std::array KERNEL_INPUTS_SELECTORS = { SENDER_SELECTOR, ADDRESS_SELECTOR, + PORTAL_SELECTOR, FUNCTION_SELECTOR, + FEE_PER_DA_GAS_SELECTOR, FEE_PER_L1_GAS_SELECTOR, + FEE_PER_L2_GAS_SELECTOR }; + +namespace bb::avm_trace { + +class AvmKernelTraceBuilder { + public: + struct KernelTraceEntry { + // TODO: could be u8? + uint32_t kernel_selector = 0; + bool q_kernel_lookup = false; + }; + + std::array kernel_inputs{}; + + // Counts the number of accesses into each SELECTOR for the environment selector lookups; + std::unordered_map kernel_selector_counter; + + // TODO: should i have access to the kernel_inputs here -> so they can be directly looked up? + AvmKernelTraceBuilder(std::array kernel_inputs); + + void reset(); + + FF op_sender(); + FF op_address(); + FF op_portal(); + FF op_function(); + FF op_fee_per_da_gas(); + FF op_fee_per_l1_gas(); + FF op_fee_per_l2_gas(); + + private: + std::vector kernel_trace; + + FF perform_kernel_lookup(uint32_t selector); +}; +} // namespace bb::avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp index de8f895c79e..ccb2294c097 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -14,7 +14,7 @@ #include "avm_helper.hpp" #include "avm_mem_trace.hpp" #include "avm_trace.hpp" -#include "barretenberg/vm/avm_trace/avm_environment_trace.hpp" +#include "barretenberg/vm/avm_trace/avm_kernel_trace.hpp" namespace bb::avm_trace { @@ -22,9 +22,9 @@ namespace bb::avm_trace { * @brief Constructor of a trace builder of AVM. Only serves to set the capacity of the * underlying traces. */ -AvmTraceBuilder::AvmTraceBuilder(std::vector kernel_inputs) +AvmTraceBuilder::AvmTraceBuilder(std::array kernel_inputs) // NOTE: we initialise the environment builder here as it requires public inputs - : env_trace_builder(kernel_inputs) + : kernel_trace_builder(kernel_inputs) { main_trace.reserve(AVM_TRACE_SIZE); } @@ -39,7 +39,7 @@ void AvmTraceBuilder::reset() mem_trace_builder.reset(); alu_trace_builder.reset(); bin_trace_builder.reset(); - env_trace_builder.reset(); + kernel_trace_builder.reset(); } AvmTraceBuilder::IndirectThreeResolution AvmTraceBuilder::resolve_ind_three( @@ -946,62 +946,95 @@ void AvmTraceBuilder::op_cmov( }); } -void AvmTraceBuilder::op_sender(uint32_t dst_offset) +// Helper function to add kernel lookup operations into the main trace +Row AvmTraceBuilder::create_kernel_lookup_opcode(uint32_t dst_offset, uint32_t selector, FF value) { auto const clk = static_cast(main_trace.size()); // Get the value of op sender from the mem trace - FF ia_value = env_trace_builder.op_sender(); - info("after op sender in env trace"); - // TODO: the tag of sender should be a field element no? - AvmMemoryTag tag = AvmMemoryTag::U32; - mem_trace_builder.write_into_memory(clk, IntermRegister::IA, dst_offset, ia_value, AvmMemoryTag::U0, tag); + AvmMemoryTag r_tag = AvmMemoryTag::U0; + AvmMemoryTag w_tag = AvmMemoryTag::U32; // THIS WAS U32 + mem_trace_builder.write_into_memory(clk, IntermRegister::IA, dst_offset, value, r_tag, w_tag); // TODO: must i constrain r in tag to be the type of the write operation in pil? // .avm_main_r_in_tag = FF(static_cast(in_tag)), - main_trace.push_back(Row{ + return Row{ .avm_main_clk = clk, - .avm_environment_environment_selector = SENDER_SELECTOR, - .avm_environment_q_environment_lookup = 1, - .avm_main_ia = ia_value, + .avm_kernel_kernel_sel = selector, + .avm_main_ia = value, .avm_main_ind_a = 0, .avm_main_internal_return_ptr = internal_return_ptr, .avm_main_mem_idx_a = dst_offset, .avm_main_mem_op_a = 1, .avm_main_pc = pc++, + .avm_main_q_kernel_lookup = 1, .avm_main_rwa = 1, - .avm_main_sel_op_sender = 1, - .avm_main_w_in_tag = static_cast(tag), - }); + .avm_main_w_in_tag = static_cast(w_tag), + }; +} + +void AvmTraceBuilder::op_sender(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_sender(); + Row row = create_kernel_lookup_opcode(dst_offset, SENDER_SELECTOR, ia_value); + row.avm_main_sel_op_sender = FF(1); + + main_trace.push_back(row); } void AvmTraceBuilder::op_address(uint32_t dst_offset) { - auto const clk = static_cast(main_trace.size()); + FF ia_value = kernel_trace_builder.op_address(); + Row row = create_kernel_lookup_opcode(dst_offset, ADDRESS_SELECTOR, ia_value); + row.avm_main_sel_op_address = FF(1); - // Get the value of op sender from the mem trace - FF ia_value = env_trace_builder.op_address(); + main_trace.push_back(row); +} - // TODO: the tag of sender should be a field element no? - AvmMemoryTag tag = AvmMemoryTag::U32; - mem_trace_builder.write_into_memory(clk, IntermRegister::IA, dst_offset, ia_value, AvmMemoryTag::U0, tag); +void AvmTraceBuilder::op_portal(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_portal(); + Row row = create_kernel_lookup_opcode(dst_offset, PORTAL_SELECTOR, ia_value); + row.avm_main_sel_op_portal = FF(1); - // TODO: must i constrain r in tag to be the type of the write operation in pil? - // .avm_main_r_in_tag = FF(static_cast(in_tag)), - main_trace.push_back(Row{ - .avm_main_clk = clk, - .avm_environment_environment_selector = ADDRESS_SELECTOR, - .avm_environment_q_environment_lookup = 1, - .avm_main_ia = ia_value, - .avm_main_ind_a = 0, - .avm_main_internal_return_ptr = internal_return_ptr, - .avm_main_mem_idx_a = dst_offset, - .avm_main_pc = pc++, - .avm_main_rwa = 1, - .avm_main_sel_op_address = 1, - .avm_main_w_in_tag = static_cast(tag), - }); + main_trace.push_back(row); +} + +void AvmTraceBuilder::op_function(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_function(); + Row row = create_kernel_lookup_opcode(dst_offset, FUNCTION_SELECTOR, ia_value); + row.avm_main_sel_op_function_selector = FF(1); + + main_trace.push_back(row); +} + +void AvmTraceBuilder::op_fee_per_da_gas(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_fee_per_da_gas(); + Row row = create_kernel_lookup_opcode(dst_offset, FEE_PER_DA_GAS_SELECTOR, ia_value); + row.avm_main_sel_op_fee_per_da_gas = FF(1); + + main_trace.push_back(row); +} + +void AvmTraceBuilder::op_fee_per_l1_gas(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_fee_per_l1_gas(); + Row row = create_kernel_lookup_opcode(dst_offset, FEE_PER_L1_GAS_SELECTOR, ia_value); + row.avm_main_sel_op_fee_per_l1_gas = FF(1); + + main_trace.push_back(row); +} + +void AvmTraceBuilder::op_fee_per_l2_gas(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_fee_per_l2_gas(); + Row row = create_kernel_lookup_opcode(dst_offset, FEE_PER_L2_GAS_SELECTOR, ia_value); + row.avm_main_sel_op_fee_per_l2_gas = FF(1); + + main_trace.push_back(row); } /** @@ -1679,18 +1712,32 @@ std::vector AvmTraceBuilder::finalize() } } + // TODO: pub public inputs inside a function? // Include env trace table // Selector columns and lookup counts // Add all of the lookup counts for the input environment - for (size_t i = 0; i < 2; i++) { - auto& dest = main_trace.at(i); + // TODO: this index will have to move with the hardcoded public inputs + + // Add public inputs into the kernel column + // edge case: If the number of public inputs is more than the trace then we pad to its size + if (main_trace.size() < kernel_trace_builder.kernel_inputs.size()) { + auto diff = kernel_trace_builder.kernel_inputs.size() - main_trace.size(); + for (size_t i = 0; i < diff; ++i) { + main_trace.push_back(Row{}); + } + } + auto kernel_inputs_size = std::min(main_trace.size(), kernel_trace_builder.kernel_inputs.size()); + + // We add the lookup counts in the index of the kernel inputs selectors that are active + for (uint32_t selector_index : KERNEL_INPUTS_SELECTORS) { + auto& dest = main_trace.at(selector_index); dest.lookup_into_environment_counts = - FF(env_trace_builder.environment_selector_counter[static_cast(i)]); + FF(kernel_trace_builder.kernel_selector_counter[static_cast(selector_index)]); + dest.avm_kernel_q_public_input_kernel_add_to_table = FF(1); } - // Add public inputs into the kernelcolumns - for (size_t i = 0; i < env_trace_builder.kernel_inputs.size(); i++) { - main_trace.at(i).avm_main_kernel_inputs__is_public = env_trace_builder.kernel_inputs.at(i); + for (size_t i = 0; i < kernel_inputs_size; i++) { + main_trace.at(i).avm_kernel_kernel_inputs__is_public = kernel_trace_builder.kernel_inputs.at(i); } // Adding extra row for the shifted values at the top of the execution trace. diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp index 39a3c8b9ba5..b0a1a6730b1 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp @@ -8,9 +8,10 @@ #include "avm_instructions.hpp" #include "avm_mem_trace.hpp" #include "barretenberg/common/throw_or_abort.hpp" +#include "constants.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" -#include "barretenberg/vm/avm_trace/avm_environment_trace.hpp" +#include "barretenberg/vm/avm_trace/avm_kernel_trace.hpp" namespace bb::avm_trace { @@ -23,7 +24,7 @@ class AvmTraceBuilder { public: static const size_t CALLSTACK_OFFSET = 896; // TODO(md): Temporary reserved area 896 - 1024 - AvmTraceBuilder(std::vector kernel_inputs = {}); + AvmTraceBuilder(std::array kernel_inputs = {}); std::vector finalize(); void reset(); @@ -76,6 +77,11 @@ class AvmTraceBuilder { // TODO void op_sender(uint32_t dst_offset); void op_address(uint32_t dst_offset); + void op_portal(uint32_t dst_offset); + void op_function(uint32_t dst_offset); + void op_fee_per_da_gas(uint32_t dst_offset); + void op_fee_per_l1_gas(uint32_t dst_offset); + void op_fee_per_l2_gas(uint32_t dst_offset); // Jump to a given program counter. void jump(uint32_t jmp_dest); @@ -121,8 +127,10 @@ class AvmTraceBuilder { AvmMemTraceBuilder mem_trace_builder; AvmAluTraceBuilder alu_trace_builder; AvmBinaryTraceBuilder bin_trace_builder; - AvmEnvironmentTraceBuilder env_trace_builder; + AvmKernelTraceBuilder kernel_trace_builder; + // TODO: rename??? + Row create_kernel_lookup_opcode(uint32_t dst_offset, uint32_t selector, FF value); void finalise_mem_trace_lookup_counts(); IndirectThreeResolution resolve_ind_three( diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/constants.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/constants.hpp new file mode 100644 index 00000000000..2bb819bea0c --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/constants.hpp @@ -0,0 +1,6 @@ +#pragma once +#include + +// NOTE(MD): for now we will only include the public inputs that are included in call_context +// With more being added in subsequent prs +inline const std::size_t KERNEL_INPUTS_LENGTH = 18; \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index ea7031a9a17..c638f393e2a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -13,7 +13,7 @@ #include "barretenberg/relations/generated/avm/avm_alu.hpp" #include "barretenberg/relations/generated/avm/avm_binary.hpp" -#include "barretenberg/relations/generated/avm/avm_environment.hpp" +#include "barretenberg/relations/generated/avm/avm_kernel.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" #include "barretenberg/relations/generated/avm/avm_mem.hpp" #include "barretenberg/relations/generated/avm/incl_main_tag_err.hpp" @@ -131,8 +131,9 @@ template struct AvmFullRow { FF avm_byte_lookup_table_input_b{}; FF avm_byte_lookup_table_op_id{}; FF avm_byte_lookup_table_output{}; - FF avm_environment_environment_selector{}; - FF avm_environment_q_environment_lookup{}; + FF avm_kernel_kernel_inputs__is_public{}; + FF avm_kernel_kernel_sel{}; + FF avm_kernel_q_public_input_kernel_add_to_table{}; FF avm_main_alu_sel{}; FF avm_main_bin_op_id{}; FF avm_main_bin_sel{}; @@ -151,7 +152,6 @@ template struct AvmFullRow { FF avm_main_ind_op_d{}; FF avm_main_internal_return_ptr{}; FF avm_main_inv{}; - FF avm_main_kernel_inputs__is_public{}; FF avm_main_last{}; FF avm_main_mem_idx_a{}; FF avm_main_mem_idx_b{}; @@ -163,6 +163,7 @@ template struct AvmFullRow { FF avm_main_mem_op_d{}; FF avm_main_op_err{}; FF avm_main_pc{}; + FF avm_main_q_kernel_lookup{}; FF avm_main_r_in_tag{}; FF avm_main_rwa{}; FF avm_main_rwb{}; @@ -179,15 +180,25 @@ template struct AvmFullRow { FF avm_main_sel_op_add{}; FF avm_main_sel_op_address{}; FF avm_main_sel_op_and{}; + FF avm_main_sel_op_block_number{}; + FF avm_main_sel_op_chain_id{}; + FF avm_main_sel_op_coinbase{}; FF avm_main_sel_op_div{}; FF avm_main_sel_op_eq{}; + FF avm_main_sel_op_fee_per_da_gas{}; + FF avm_main_sel_op_fee_per_l1_gas{}; + FF avm_main_sel_op_fee_per_l2_gas{}; + FF avm_main_sel_op_function_selector{}; FF avm_main_sel_op_lt{}; FF avm_main_sel_op_lte{}; FF avm_main_sel_op_mul{}; FF avm_main_sel_op_not{}; FF avm_main_sel_op_or{}; + FF avm_main_sel_op_portal{}; FF avm_main_sel_op_sender{}; FF avm_main_sel_op_sub{}; + FF avm_main_sel_op_timestamp{}; + FF avm_main_sel_op_version{}; FF avm_main_sel_op_xor{}; FF avm_main_sel_rng_16{}; FF avm_main_sel_rng_8{}; @@ -318,8 +329,8 @@ class AvmCircuitBuilder { using Polynomial = Flavor::Polynomial; using ProverPolynomials = Flavor::ProverPolynomials; - static constexpr size_t num_fixed_columns = 253; - static constexpr size_t num_polys = 218; + static constexpr size_t num_fixed_columns = 264; + static constexpr size_t num_polys = 229; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -413,8 +424,10 @@ class AvmCircuitBuilder { polys.avm_byte_lookup_table_input_b[i] = rows[i].avm_byte_lookup_table_input_b; polys.avm_byte_lookup_table_op_id[i] = rows[i].avm_byte_lookup_table_op_id; polys.avm_byte_lookup_table_output[i] = rows[i].avm_byte_lookup_table_output; - polys.avm_environment_environment_selector[i] = rows[i].avm_environment_environment_selector; - polys.avm_environment_q_environment_lookup[i] = rows[i].avm_environment_q_environment_lookup; + polys.avm_kernel_kernel_inputs__is_public[i] = rows[i].avm_kernel_kernel_inputs__is_public; + polys.avm_kernel_kernel_sel[i] = rows[i].avm_kernel_kernel_sel; + polys.avm_kernel_q_public_input_kernel_add_to_table[i] = + rows[i].avm_kernel_q_public_input_kernel_add_to_table; polys.avm_main_alu_sel[i] = rows[i].avm_main_alu_sel; polys.avm_main_bin_op_id[i] = rows[i].avm_main_bin_op_id; polys.avm_main_bin_sel[i] = rows[i].avm_main_bin_sel; @@ -433,7 +446,6 @@ class AvmCircuitBuilder { polys.avm_main_ind_op_d[i] = rows[i].avm_main_ind_op_d; polys.avm_main_internal_return_ptr[i] = rows[i].avm_main_internal_return_ptr; polys.avm_main_inv[i] = rows[i].avm_main_inv; - polys.avm_main_kernel_inputs__is_public[i] = rows[i].avm_main_kernel_inputs__is_public; polys.avm_main_last[i] = rows[i].avm_main_last; polys.avm_main_mem_idx_a[i] = rows[i].avm_main_mem_idx_a; polys.avm_main_mem_idx_b[i] = rows[i].avm_main_mem_idx_b; @@ -445,6 +457,7 @@ class AvmCircuitBuilder { polys.avm_main_mem_op_d[i] = rows[i].avm_main_mem_op_d; polys.avm_main_op_err[i] = rows[i].avm_main_op_err; polys.avm_main_pc[i] = rows[i].avm_main_pc; + polys.avm_main_q_kernel_lookup[i] = rows[i].avm_main_q_kernel_lookup; polys.avm_main_r_in_tag[i] = rows[i].avm_main_r_in_tag; polys.avm_main_rwa[i] = rows[i].avm_main_rwa; polys.avm_main_rwb[i] = rows[i].avm_main_rwb; @@ -461,15 +474,25 @@ class AvmCircuitBuilder { polys.avm_main_sel_op_add[i] = rows[i].avm_main_sel_op_add; polys.avm_main_sel_op_address[i] = rows[i].avm_main_sel_op_address; polys.avm_main_sel_op_and[i] = rows[i].avm_main_sel_op_and; + polys.avm_main_sel_op_block_number[i] = rows[i].avm_main_sel_op_block_number; + polys.avm_main_sel_op_chain_id[i] = rows[i].avm_main_sel_op_chain_id; + polys.avm_main_sel_op_coinbase[i] = rows[i].avm_main_sel_op_coinbase; polys.avm_main_sel_op_div[i] = rows[i].avm_main_sel_op_div; polys.avm_main_sel_op_eq[i] = rows[i].avm_main_sel_op_eq; + polys.avm_main_sel_op_fee_per_da_gas[i] = rows[i].avm_main_sel_op_fee_per_da_gas; + polys.avm_main_sel_op_fee_per_l1_gas[i] = rows[i].avm_main_sel_op_fee_per_l1_gas; + polys.avm_main_sel_op_fee_per_l2_gas[i] = rows[i].avm_main_sel_op_fee_per_l2_gas; + polys.avm_main_sel_op_function_selector[i] = rows[i].avm_main_sel_op_function_selector; polys.avm_main_sel_op_lt[i] = rows[i].avm_main_sel_op_lt; polys.avm_main_sel_op_lte[i] = rows[i].avm_main_sel_op_lte; polys.avm_main_sel_op_mul[i] = rows[i].avm_main_sel_op_mul; polys.avm_main_sel_op_not[i] = rows[i].avm_main_sel_op_not; polys.avm_main_sel_op_or[i] = rows[i].avm_main_sel_op_or; + polys.avm_main_sel_op_portal[i] = rows[i].avm_main_sel_op_portal; polys.avm_main_sel_op_sender[i] = rows[i].avm_main_sel_op_sender; polys.avm_main_sel_op_sub[i] = rows[i].avm_main_sel_op_sub; + polys.avm_main_sel_op_timestamp[i] = rows[i].avm_main_sel_op_timestamp; + polys.avm_main_sel_op_version[i] = rows[i].avm_main_sel_op_version; polys.avm_main_sel_op_xor[i] = rows[i].avm_main_sel_op_xor; polys.avm_main_sel_rng_16[i] = rows[i].avm_main_sel_rng_16; polys.avm_main_sel_rng_8[i] = rows[i].avm_main_sel_rng_8; @@ -637,8 +660,8 @@ class AvmCircuitBuilder { Avm_vm::get_relation_label_avm_binary)) { return false; } - if (!evaluate_relation.template operator()>( - "avm_environment", Avm_vm::get_relation_label_avm_environment)) { + if (!evaluate_relation.template operator()>("avm_kernel", + Avm_vm::get_relation_label_avm_kernel)) { return false; } if (!evaluate_relation.template operator()>("avm_main", diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 19f294bac4e..e3bc13fd72b 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -15,7 +15,7 @@ #include "barretenberg/polynomials/polynomial.hpp" #include "barretenberg/relations/generated/avm/avm_alu.hpp" #include "barretenberg/relations/generated/avm/avm_binary.hpp" -#include "barretenberg/relations/generated/avm/avm_environment.hpp" +#include "barretenberg/relations/generated/avm/avm_kernel.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" #include "barretenberg/relations/generated/avm/avm_mem.hpp" #include "barretenberg/relations/generated/avm/incl_main_tag_err.hpp" @@ -71,11 +71,11 @@ class AvmFlavor { using RelationSeparator = FF; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2; - static constexpr size_t NUM_WITNESS_ENTITIES = 216; + static constexpr size_t NUM_WITNESS_ENTITIES = 227; static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES; // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for // the unshifted and one for the shifted - static constexpr size_t NUM_ALL_ENTITIES = 253; + static constexpr size_t NUM_ALL_ENTITIES = 264; using GrandProductRelations = std::tuple, perm_main_bin_relation, @@ -112,7 +112,7 @@ class AvmFlavor { using Relations = std::tuple, Avm_vm::avm_binary, - Avm_vm::avm_environment, + Avm_vm::avm_kernel, Avm_vm::avm_main, Avm_vm::avm_mem, perm_main_alu_relation, @@ -256,8 +256,9 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, - avm_environment_environment_selector, - avm_environment_q_environment_lookup, + avm_kernel_kernel_inputs__is_public, + avm_kernel_kernel_sel, + avm_kernel_q_public_input_kernel_add_to_table, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -276,7 +277,6 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, - avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -288,6 +288,7 @@ class AvmFlavor { avm_main_mem_op_d, avm_main_op_err, avm_main_pc, + avm_main_q_kernel_lookup, avm_main_r_in_tag, avm_main_rwa, avm_main_rwb, @@ -304,15 +305,25 @@ class AvmFlavor { avm_main_sel_op_add, avm_main_sel_op_address, avm_main_sel_op_and, + avm_main_sel_op_block_number, + avm_main_sel_op_chain_id, + avm_main_sel_op_coinbase, avm_main_sel_op_div, avm_main_sel_op_eq, + avm_main_sel_op_fee_per_da_gas, + avm_main_sel_op_fee_per_l1_gas, + avm_main_sel_op_fee_per_l2_gas, + avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_portal, avm_main_sel_op_sender, avm_main_sel_op_sub, + avm_main_sel_op_timestamp, + avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, avm_main_sel_rng_8, @@ -475,8 +486,9 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, - avm_environment_environment_selector, - avm_environment_q_environment_lookup, + avm_kernel_kernel_inputs__is_public, + avm_kernel_kernel_sel, + avm_kernel_q_public_input_kernel_add_to_table, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -495,7 +507,6 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, - avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -507,6 +518,7 @@ class AvmFlavor { avm_main_mem_op_d, avm_main_op_err, avm_main_pc, + avm_main_q_kernel_lookup, avm_main_r_in_tag, avm_main_rwa, avm_main_rwb, @@ -523,15 +535,25 @@ class AvmFlavor { avm_main_sel_op_add, avm_main_sel_op_address, avm_main_sel_op_and, + avm_main_sel_op_block_number, + avm_main_sel_op_chain_id, + avm_main_sel_op_coinbase, avm_main_sel_op_div, avm_main_sel_op_eq, + avm_main_sel_op_fee_per_da_gas, + avm_main_sel_op_fee_per_l1_gas, + avm_main_sel_op_fee_per_l2_gas, + avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_portal, avm_main_sel_op_sender, avm_main_sel_op_sub, + avm_main_sel_op_timestamp, + avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, avm_main_sel_rng_8, @@ -699,8 +721,9 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, - avm_environment_environment_selector, - avm_environment_q_environment_lookup, + avm_kernel_kernel_inputs__is_public, + avm_kernel_kernel_sel, + avm_kernel_q_public_input_kernel_add_to_table, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -719,7 +742,6 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, - avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -731,6 +753,7 @@ class AvmFlavor { avm_main_mem_op_d, avm_main_op_err, avm_main_pc, + avm_main_q_kernel_lookup, avm_main_r_in_tag, avm_main_rwa, avm_main_rwb, @@ -747,15 +770,25 @@ class AvmFlavor { avm_main_sel_op_add, avm_main_sel_op_address, avm_main_sel_op_and, + avm_main_sel_op_block_number, + avm_main_sel_op_chain_id, + avm_main_sel_op_coinbase, avm_main_sel_op_div, avm_main_sel_op_eq, + avm_main_sel_op_fee_per_da_gas, + avm_main_sel_op_fee_per_l1_gas, + avm_main_sel_op_fee_per_l2_gas, + avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_portal, avm_main_sel_op_sender, avm_main_sel_op_sub, + avm_main_sel_op_timestamp, + avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, avm_main_sel_rng_8, @@ -955,8 +988,9 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, - avm_environment_environment_selector, - avm_environment_q_environment_lookup, + avm_kernel_kernel_inputs__is_public, + avm_kernel_kernel_sel, + avm_kernel_q_public_input_kernel_add_to_table, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -975,7 +1009,6 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, - avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -987,6 +1020,7 @@ class AvmFlavor { avm_main_mem_op_d, avm_main_op_err, avm_main_pc, + avm_main_q_kernel_lookup, avm_main_r_in_tag, avm_main_rwa, avm_main_rwb, @@ -1003,15 +1037,25 @@ class AvmFlavor { avm_main_sel_op_add, avm_main_sel_op_address, avm_main_sel_op_and, + avm_main_sel_op_block_number, + avm_main_sel_op_chain_id, + avm_main_sel_op_coinbase, avm_main_sel_op_div, avm_main_sel_op_eq, + avm_main_sel_op_fee_per_da_gas, + avm_main_sel_op_fee_per_l1_gas, + avm_main_sel_op_fee_per_l2_gas, + avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_portal, avm_main_sel_op_sender, avm_main_sel_op_sub, + avm_main_sel_op_timestamp, + avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, avm_main_sel_rng_8, @@ -1211,8 +1255,9 @@ class AvmFlavor { avm_byte_lookup_table_input_b, avm_byte_lookup_table_op_id, avm_byte_lookup_table_output, - avm_environment_environment_selector, - avm_environment_q_environment_lookup, + avm_kernel_kernel_inputs__is_public, + avm_kernel_kernel_sel, + avm_kernel_q_public_input_kernel_add_to_table, avm_main_alu_sel, avm_main_bin_op_id, avm_main_bin_sel, @@ -1231,7 +1276,6 @@ class AvmFlavor { avm_main_ind_op_d, avm_main_internal_return_ptr, avm_main_inv, - avm_main_kernel_inputs__is_public, avm_main_last, avm_main_mem_idx_a, avm_main_mem_idx_b, @@ -1243,6 +1287,7 @@ class AvmFlavor { avm_main_mem_op_d, avm_main_op_err, avm_main_pc, + avm_main_q_kernel_lookup, avm_main_r_in_tag, avm_main_rwa, avm_main_rwb, @@ -1259,15 +1304,25 @@ class AvmFlavor { avm_main_sel_op_add, avm_main_sel_op_address, avm_main_sel_op_and, + avm_main_sel_op_block_number, + avm_main_sel_op_chain_id, + avm_main_sel_op_coinbase, avm_main_sel_op_div, avm_main_sel_op_eq, + avm_main_sel_op_fee_per_da_gas, + avm_main_sel_op_fee_per_l1_gas, + avm_main_sel_op_fee_per_l2_gas, + avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, avm_main_sel_op_not, avm_main_sel_op_or, + avm_main_sel_op_portal, avm_main_sel_op_sender, avm_main_sel_op_sub, + avm_main_sel_op_timestamp, + avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, avm_main_sel_rng_8, @@ -1663,8 +1718,9 @@ class AvmFlavor { Base::avm_byte_lookup_table_input_b = "AVM_BYTE_LOOKUP_TABLE_INPUT_B"; Base::avm_byte_lookup_table_op_id = "AVM_BYTE_LOOKUP_TABLE_OP_ID"; Base::avm_byte_lookup_table_output = "AVM_BYTE_LOOKUP_TABLE_OUTPUT"; - Base::avm_environment_environment_selector = "AVM_ENVIRONMENT_ENVIRONMENT_SELECTOR"; - Base::avm_environment_q_environment_lookup = "AVM_ENVIRONMENT_Q_ENVIRONMENT_LOOKUP"; + Base::avm_kernel_kernel_inputs__is_public = "AVM_KERNEL_KERNEL_INPUTS__IS_PUBLIC"; + Base::avm_kernel_kernel_sel = "AVM_KERNEL_KERNEL_SEL"; + Base::avm_kernel_q_public_input_kernel_add_to_table = "AVM_KERNEL_Q_PUBLIC_INPUT_KERNEL_ADD_TO_TABLE"; Base::avm_main_alu_sel = "AVM_MAIN_ALU_SEL"; Base::avm_main_bin_op_id = "AVM_MAIN_BIN_OP_ID"; Base::avm_main_bin_sel = "AVM_MAIN_BIN_SEL"; @@ -1683,7 +1739,6 @@ class AvmFlavor { Base::avm_main_ind_op_d = "AVM_MAIN_IND_OP_D"; Base::avm_main_internal_return_ptr = "AVM_MAIN_INTERNAL_RETURN_PTR"; Base::avm_main_inv = "AVM_MAIN_INV"; - Base::avm_main_kernel_inputs__is_public = "AVM_MAIN_KERNEL_INPUTS__IS_PUBLIC"; Base::avm_main_last = "AVM_MAIN_LAST"; Base::avm_main_mem_idx_a = "AVM_MAIN_MEM_IDX_A"; Base::avm_main_mem_idx_b = "AVM_MAIN_MEM_IDX_B"; @@ -1695,6 +1750,7 @@ class AvmFlavor { Base::avm_main_mem_op_d = "AVM_MAIN_MEM_OP_D"; Base::avm_main_op_err = "AVM_MAIN_OP_ERR"; Base::avm_main_pc = "AVM_MAIN_PC"; + Base::avm_main_q_kernel_lookup = "AVM_MAIN_Q_KERNEL_LOOKUP"; Base::avm_main_r_in_tag = "AVM_MAIN_R_IN_TAG"; Base::avm_main_rwa = "AVM_MAIN_RWA"; Base::avm_main_rwb = "AVM_MAIN_RWB"; @@ -1711,15 +1767,25 @@ class AvmFlavor { Base::avm_main_sel_op_add = "AVM_MAIN_SEL_OP_ADD"; Base::avm_main_sel_op_address = "AVM_MAIN_SEL_OP_ADDRESS"; Base::avm_main_sel_op_and = "AVM_MAIN_SEL_OP_AND"; + Base::avm_main_sel_op_block_number = "AVM_MAIN_SEL_OP_BLOCK_NUMBER"; + Base::avm_main_sel_op_chain_id = "AVM_MAIN_SEL_OP_CHAIN_ID"; + Base::avm_main_sel_op_coinbase = "AVM_MAIN_SEL_OP_COINBASE"; Base::avm_main_sel_op_div = "AVM_MAIN_SEL_OP_DIV"; Base::avm_main_sel_op_eq = "AVM_MAIN_SEL_OP_EQ"; + Base::avm_main_sel_op_fee_per_da_gas = "AVM_MAIN_SEL_OP_FEE_PER_DA_GAS"; + Base::avm_main_sel_op_fee_per_l1_gas = "AVM_MAIN_SEL_OP_FEE_PER_L1_GAS"; + Base::avm_main_sel_op_fee_per_l2_gas = "AVM_MAIN_SEL_OP_FEE_PER_L2_GAS"; + Base::avm_main_sel_op_function_selector = "AVM_MAIN_SEL_OP_FUNCTION_SELECTOR"; Base::avm_main_sel_op_lt = "AVM_MAIN_SEL_OP_LT"; Base::avm_main_sel_op_lte = "AVM_MAIN_SEL_OP_LTE"; Base::avm_main_sel_op_mul = "AVM_MAIN_SEL_OP_MUL"; Base::avm_main_sel_op_not = "AVM_MAIN_SEL_OP_NOT"; Base::avm_main_sel_op_or = "AVM_MAIN_SEL_OP_OR"; + Base::avm_main_sel_op_portal = "AVM_MAIN_SEL_OP_PORTAL"; Base::avm_main_sel_op_sender = "AVM_MAIN_SEL_OP_SENDER"; Base::avm_main_sel_op_sub = "AVM_MAIN_SEL_OP_SUB"; + Base::avm_main_sel_op_timestamp = "AVM_MAIN_SEL_OP_TIMESTAMP"; + Base::avm_main_sel_op_version = "AVM_MAIN_SEL_OP_VERSION"; Base::avm_main_sel_op_xor = "AVM_MAIN_SEL_OP_XOR"; Base::avm_main_sel_rng_16 = "AVM_MAIN_SEL_RNG_16"; Base::avm_main_sel_rng_8 = "AVM_MAIN_SEL_RNG_8"; @@ -1898,8 +1964,9 @@ class AvmFlavor { Commitment avm_byte_lookup_table_input_b; Commitment avm_byte_lookup_table_op_id; Commitment avm_byte_lookup_table_output; - Commitment avm_environment_environment_selector; - Commitment avm_environment_q_environment_lookup; + Commitment avm_kernel_kernel_inputs__is_public; + Commitment avm_kernel_kernel_sel; + Commitment avm_kernel_q_public_input_kernel_add_to_table; Commitment avm_main_alu_sel; Commitment avm_main_bin_op_id; Commitment avm_main_bin_sel; @@ -1918,7 +1985,6 @@ class AvmFlavor { Commitment avm_main_ind_op_d; Commitment avm_main_internal_return_ptr; Commitment avm_main_inv; - Commitment avm_main_kernel_inputs__is_public; Commitment avm_main_last; Commitment avm_main_mem_idx_a; Commitment avm_main_mem_idx_b; @@ -1930,6 +1996,7 @@ class AvmFlavor { Commitment avm_main_mem_op_d; Commitment avm_main_op_err; Commitment avm_main_pc; + Commitment avm_main_q_kernel_lookup; Commitment avm_main_r_in_tag; Commitment avm_main_rwa; Commitment avm_main_rwb; @@ -1946,15 +2013,25 @@ class AvmFlavor { Commitment avm_main_sel_op_add; Commitment avm_main_sel_op_address; Commitment avm_main_sel_op_and; + Commitment avm_main_sel_op_block_number; + Commitment avm_main_sel_op_chain_id; + Commitment avm_main_sel_op_coinbase; Commitment avm_main_sel_op_div; Commitment avm_main_sel_op_eq; + Commitment avm_main_sel_op_fee_per_da_gas; + Commitment avm_main_sel_op_fee_per_l1_gas; + Commitment avm_main_sel_op_fee_per_l2_gas; + Commitment avm_main_sel_op_function_selector; Commitment avm_main_sel_op_lt; Commitment avm_main_sel_op_lte; Commitment avm_main_sel_op_mul; Commitment avm_main_sel_op_not; Commitment avm_main_sel_op_or; + Commitment avm_main_sel_op_portal; Commitment avm_main_sel_op_sender; Commitment avm_main_sel_op_sub; + Commitment avm_main_sel_op_timestamp; + Commitment avm_main_sel_op_version; Commitment avm_main_sel_op_xor; Commitment avm_main_sel_rng_16; Commitment avm_main_sel_rng_8; @@ -2134,9 +2211,10 @@ class AvmFlavor { avm_byte_lookup_table_input_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_byte_lookup_table_op_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_byte_lookup_table_output = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - avm_environment_environment_selector = + avm_kernel_kernel_inputs__is_public = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - avm_environment_q_environment_lookup = + avm_kernel_kernel_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_kernel_q_public_input_kernel_add_to_table = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_alu_sel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_bin_op_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2156,8 +2234,6 @@ class AvmFlavor { avm_main_ind_op_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_internal_return_ptr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_inv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - avm_main_kernel_inputs__is_public = - deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_last = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_mem_idx_a = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_mem_idx_b = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2169,6 +2245,7 @@ class AvmFlavor { avm_main_mem_op_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_op_err = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_pc = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_q_kernel_lookup = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_r_in_tag = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_rwa = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_rwb = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2185,15 +2262,26 @@ class AvmFlavor { avm_main_sel_op_add = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_address = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_and = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_block_number = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_chain_id = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_coinbase = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_div = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_eq = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_fee_per_da_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_fee_per_l1_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_fee_per_l2_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_function_selector = + deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_lt = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_lte = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_mul = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_not = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_or = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_portal = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_sender = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_sub = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_timestamp = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_version = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_xor = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_rng_16 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_rng_8 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2376,8 +2464,9 @@ class AvmFlavor { serialize_to_buffer(avm_byte_lookup_table_input_b, Transcript::proof_data); serialize_to_buffer(avm_byte_lookup_table_op_id, Transcript::proof_data); serialize_to_buffer(avm_byte_lookup_table_output, Transcript::proof_data); - serialize_to_buffer(avm_environment_environment_selector, Transcript::proof_data); - serialize_to_buffer(avm_environment_q_environment_lookup, Transcript::proof_data); + serialize_to_buffer(avm_kernel_kernel_inputs__is_public, Transcript::proof_data); + serialize_to_buffer(avm_kernel_kernel_sel, Transcript::proof_data); + serialize_to_buffer(avm_kernel_q_public_input_kernel_add_to_table, Transcript::proof_data); serialize_to_buffer(avm_main_alu_sel, Transcript::proof_data); serialize_to_buffer(avm_main_bin_op_id, Transcript::proof_data); serialize_to_buffer(avm_main_bin_sel, Transcript::proof_data); @@ -2396,7 +2485,6 @@ class AvmFlavor { serialize_to_buffer(avm_main_ind_op_d, Transcript::proof_data); serialize_to_buffer(avm_main_internal_return_ptr, Transcript::proof_data); serialize_to_buffer(avm_main_inv, Transcript::proof_data); - serialize_to_buffer(avm_main_kernel_inputs__is_public, Transcript::proof_data); serialize_to_buffer(avm_main_last, Transcript::proof_data); serialize_to_buffer(avm_main_mem_idx_a, Transcript::proof_data); serialize_to_buffer(avm_main_mem_idx_b, Transcript::proof_data); @@ -2408,6 +2496,7 @@ class AvmFlavor { serialize_to_buffer(avm_main_mem_op_d, Transcript::proof_data); serialize_to_buffer(avm_main_op_err, Transcript::proof_data); serialize_to_buffer(avm_main_pc, Transcript::proof_data); + serialize_to_buffer(avm_main_q_kernel_lookup, Transcript::proof_data); serialize_to_buffer(avm_main_r_in_tag, Transcript::proof_data); serialize_to_buffer(avm_main_rwa, Transcript::proof_data); serialize_to_buffer(avm_main_rwb, Transcript::proof_data); @@ -2424,15 +2513,25 @@ class AvmFlavor { serialize_to_buffer(avm_main_sel_op_add, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_address, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_and, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_block_number, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_chain_id, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_coinbase, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_div, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_eq, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_fee_per_da_gas, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_fee_per_l1_gas, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_fee_per_l2_gas, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_function_selector, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_lt, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_lte, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_mul, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_not, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_or, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_portal, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_sender, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_sub, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_timestamp, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_version, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_xor, Transcript::proof_data); serialize_to_buffer(avm_main_sel_rng_16, Transcript::proof_data); serialize_to_buffer(avm_main_sel_rng_8, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index 7b516b15f3d..f27a70d0486 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -136,10 +136,11 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_byte_lookup_table_input_b = commitment_key->commit(key->avm_byte_lookup_table_input_b); witness_commitments.avm_byte_lookup_table_op_id = commitment_key->commit(key->avm_byte_lookup_table_op_id); witness_commitments.avm_byte_lookup_table_output = commitment_key->commit(key->avm_byte_lookup_table_output); - witness_commitments.avm_environment_environment_selector = - commitment_key->commit(key->avm_environment_environment_selector); - witness_commitments.avm_environment_q_environment_lookup = - commitment_key->commit(key->avm_environment_q_environment_lookup); + witness_commitments.avm_kernel_kernel_inputs__is_public = + commitment_key->commit(key->avm_kernel_kernel_inputs__is_public); + witness_commitments.avm_kernel_kernel_sel = commitment_key->commit(key->avm_kernel_kernel_sel); + witness_commitments.avm_kernel_q_public_input_kernel_add_to_table = + commitment_key->commit(key->avm_kernel_q_public_input_kernel_add_to_table); witness_commitments.avm_main_alu_sel = commitment_key->commit(key->avm_main_alu_sel); witness_commitments.avm_main_bin_op_id = commitment_key->commit(key->avm_main_bin_op_id); witness_commitments.avm_main_bin_sel = commitment_key->commit(key->avm_main_bin_sel); @@ -158,8 +159,6 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_ind_op_d = commitment_key->commit(key->avm_main_ind_op_d); witness_commitments.avm_main_internal_return_ptr = commitment_key->commit(key->avm_main_internal_return_ptr); witness_commitments.avm_main_inv = commitment_key->commit(key->avm_main_inv); - witness_commitments.avm_main_kernel_inputs__is_public = - commitment_key->commit(key->avm_main_kernel_inputs__is_public); witness_commitments.avm_main_last = commitment_key->commit(key->avm_main_last); witness_commitments.avm_main_mem_idx_a = commitment_key->commit(key->avm_main_mem_idx_a); witness_commitments.avm_main_mem_idx_b = commitment_key->commit(key->avm_main_mem_idx_b); @@ -171,6 +170,7 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_mem_op_d = commitment_key->commit(key->avm_main_mem_op_d); witness_commitments.avm_main_op_err = commitment_key->commit(key->avm_main_op_err); witness_commitments.avm_main_pc = commitment_key->commit(key->avm_main_pc); + witness_commitments.avm_main_q_kernel_lookup = commitment_key->commit(key->avm_main_q_kernel_lookup); witness_commitments.avm_main_r_in_tag = commitment_key->commit(key->avm_main_r_in_tag); witness_commitments.avm_main_rwa = commitment_key->commit(key->avm_main_rwa); witness_commitments.avm_main_rwb = commitment_key->commit(key->avm_main_rwb); @@ -187,15 +187,26 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_sel_op_add = commitment_key->commit(key->avm_main_sel_op_add); witness_commitments.avm_main_sel_op_address = commitment_key->commit(key->avm_main_sel_op_address); witness_commitments.avm_main_sel_op_and = commitment_key->commit(key->avm_main_sel_op_and); + witness_commitments.avm_main_sel_op_block_number = commitment_key->commit(key->avm_main_sel_op_block_number); + witness_commitments.avm_main_sel_op_chain_id = commitment_key->commit(key->avm_main_sel_op_chain_id); + witness_commitments.avm_main_sel_op_coinbase = commitment_key->commit(key->avm_main_sel_op_coinbase); witness_commitments.avm_main_sel_op_div = commitment_key->commit(key->avm_main_sel_op_div); witness_commitments.avm_main_sel_op_eq = commitment_key->commit(key->avm_main_sel_op_eq); + witness_commitments.avm_main_sel_op_fee_per_da_gas = commitment_key->commit(key->avm_main_sel_op_fee_per_da_gas); + witness_commitments.avm_main_sel_op_fee_per_l1_gas = commitment_key->commit(key->avm_main_sel_op_fee_per_l1_gas); + witness_commitments.avm_main_sel_op_fee_per_l2_gas = commitment_key->commit(key->avm_main_sel_op_fee_per_l2_gas); + witness_commitments.avm_main_sel_op_function_selector = + commitment_key->commit(key->avm_main_sel_op_function_selector); witness_commitments.avm_main_sel_op_lt = commitment_key->commit(key->avm_main_sel_op_lt); witness_commitments.avm_main_sel_op_lte = commitment_key->commit(key->avm_main_sel_op_lte); witness_commitments.avm_main_sel_op_mul = commitment_key->commit(key->avm_main_sel_op_mul); witness_commitments.avm_main_sel_op_not = commitment_key->commit(key->avm_main_sel_op_not); witness_commitments.avm_main_sel_op_or = commitment_key->commit(key->avm_main_sel_op_or); + witness_commitments.avm_main_sel_op_portal = commitment_key->commit(key->avm_main_sel_op_portal); witness_commitments.avm_main_sel_op_sender = commitment_key->commit(key->avm_main_sel_op_sender); witness_commitments.avm_main_sel_op_sub = commitment_key->commit(key->avm_main_sel_op_sub); + witness_commitments.avm_main_sel_op_timestamp = commitment_key->commit(key->avm_main_sel_op_timestamp); + witness_commitments.avm_main_sel_op_version = commitment_key->commit(key->avm_main_sel_op_version); witness_commitments.avm_main_sel_op_xor = commitment_key->commit(key->avm_main_sel_op_xor); witness_commitments.avm_main_sel_rng_16 = commitment_key->commit(key->avm_main_sel_rng_16); witness_commitments.avm_main_sel_rng_8 = commitment_key->commit(key->avm_main_sel_rng_8); @@ -334,10 +345,11 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_byte_lookup_table_op_id); transcript->send_to_verifier(commitment_labels.avm_byte_lookup_table_output, witness_commitments.avm_byte_lookup_table_output); - transcript->send_to_verifier(commitment_labels.avm_environment_environment_selector, - witness_commitments.avm_environment_environment_selector); - transcript->send_to_verifier(commitment_labels.avm_environment_q_environment_lookup, - witness_commitments.avm_environment_q_environment_lookup); + transcript->send_to_verifier(commitment_labels.avm_kernel_kernel_inputs__is_public, + witness_commitments.avm_kernel_kernel_inputs__is_public); + transcript->send_to_verifier(commitment_labels.avm_kernel_kernel_sel, witness_commitments.avm_kernel_kernel_sel); + transcript->send_to_verifier(commitment_labels.avm_kernel_q_public_input_kernel_add_to_table, + witness_commitments.avm_kernel_q_public_input_kernel_add_to_table); transcript->send_to_verifier(commitment_labels.avm_main_alu_sel, witness_commitments.avm_main_alu_sel); transcript->send_to_verifier(commitment_labels.avm_main_bin_op_id, witness_commitments.avm_main_bin_op_id); transcript->send_to_verifier(commitment_labels.avm_main_bin_sel, witness_commitments.avm_main_bin_sel); @@ -357,8 +369,6 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.avm_main_internal_return_ptr, witness_commitments.avm_main_internal_return_ptr); transcript->send_to_verifier(commitment_labels.avm_main_inv, witness_commitments.avm_main_inv); - transcript->send_to_verifier(commitment_labels.avm_main_kernel_inputs__is_public, - witness_commitments.avm_main_kernel_inputs__is_public); transcript->send_to_verifier(commitment_labels.avm_main_last, witness_commitments.avm_main_last); transcript->send_to_verifier(commitment_labels.avm_main_mem_idx_a, witness_commitments.avm_main_mem_idx_a); transcript->send_to_verifier(commitment_labels.avm_main_mem_idx_b, witness_commitments.avm_main_mem_idx_b); @@ -370,6 +380,8 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.avm_main_mem_op_d, witness_commitments.avm_main_mem_op_d); transcript->send_to_verifier(commitment_labels.avm_main_op_err, witness_commitments.avm_main_op_err); transcript->send_to_verifier(commitment_labels.avm_main_pc, witness_commitments.avm_main_pc); + transcript->send_to_verifier(commitment_labels.avm_main_q_kernel_lookup, + witness_commitments.avm_main_q_kernel_lookup); transcript->send_to_verifier(commitment_labels.avm_main_r_in_tag, witness_commitments.avm_main_r_in_tag); transcript->send_to_verifier(commitment_labels.avm_main_rwa, witness_commitments.avm_main_rwa); transcript->send_to_verifier(commitment_labels.avm_main_rwb, witness_commitments.avm_main_rwb); @@ -389,15 +401,34 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.avm_main_sel_op_address, witness_commitments.avm_main_sel_op_address); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_and, witness_commitments.avm_main_sel_op_and); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_block_number, + witness_commitments.avm_main_sel_op_block_number); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_chain_id, + witness_commitments.avm_main_sel_op_chain_id); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_coinbase, + witness_commitments.avm_main_sel_op_coinbase); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_div, witness_commitments.avm_main_sel_op_div); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_eq, witness_commitments.avm_main_sel_op_eq); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_fee_per_da_gas, + witness_commitments.avm_main_sel_op_fee_per_da_gas); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_fee_per_l1_gas, + witness_commitments.avm_main_sel_op_fee_per_l1_gas); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_fee_per_l2_gas, + witness_commitments.avm_main_sel_op_fee_per_l2_gas); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_function_selector, + witness_commitments.avm_main_sel_op_function_selector); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_lt, witness_commitments.avm_main_sel_op_lt); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_lte, witness_commitments.avm_main_sel_op_lte); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_mul, witness_commitments.avm_main_sel_op_mul); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_not, witness_commitments.avm_main_sel_op_not); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_or, witness_commitments.avm_main_sel_op_or); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_portal, witness_commitments.avm_main_sel_op_portal); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_sender, witness_commitments.avm_main_sel_op_sender); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_sub, witness_commitments.avm_main_sel_op_sub); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_timestamp, + witness_commitments.avm_main_sel_op_timestamp); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_version, + witness_commitments.avm_main_sel_op_version); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_xor, witness_commitments.avm_main_sel_op_xor); transcript->send_to_verifier(commitment_labels.avm_main_sel_rng_16, witness_commitments.avm_main_sel_rng_16); transcript->send_to_verifier(commitment_labels.avm_main_sel_rng_8, witness_commitments.avm_main_sel_rng_8); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 55aa8163487..bc32029d4c6 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -178,10 +178,12 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu transcript->template receive_from_prover(commitment_labels.avm_byte_lookup_table_op_id); commitments.avm_byte_lookup_table_output = transcript->template receive_from_prover(commitment_labels.avm_byte_lookup_table_output); - commitments.avm_environment_environment_selector = - transcript->template receive_from_prover(commitment_labels.avm_environment_environment_selector); - commitments.avm_environment_q_environment_lookup = - transcript->template receive_from_prover(commitment_labels.avm_environment_q_environment_lookup); + commitments.avm_kernel_kernel_inputs__is_public = + transcript->template receive_from_prover(commitment_labels.avm_kernel_kernel_inputs__is_public); + commitments.avm_kernel_kernel_sel = + transcript->template receive_from_prover(commitment_labels.avm_kernel_kernel_sel); + commitments.avm_kernel_q_public_input_kernel_add_to_table = transcript->template receive_from_prover( + commitment_labels.avm_kernel_q_public_input_kernel_add_to_table); commitments.avm_main_alu_sel = transcript->template receive_from_prover(commitment_labels.avm_main_alu_sel); commitments.avm_main_bin_op_id = @@ -209,8 +211,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu commitments.avm_main_internal_return_ptr = transcript->template receive_from_prover(commitment_labels.avm_main_internal_return_ptr); commitments.avm_main_inv = transcript->template receive_from_prover(commitment_labels.avm_main_inv); - commitments.avm_main_kernel_inputs__is_public = - transcript->template receive_from_prover(commitment_labels.avm_main_kernel_inputs__is_public); commitments.avm_main_last = transcript->template receive_from_prover(commitment_labels.avm_main_last); commitments.avm_main_mem_idx_a = transcript->template receive_from_prover(commitment_labels.avm_main_mem_idx_a); @@ -231,6 +231,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu commitments.avm_main_op_err = transcript->template receive_from_prover(commitment_labels.avm_main_op_err); commitments.avm_main_pc = transcript->template receive_from_prover(commitment_labels.avm_main_pc); + commitments.avm_main_q_kernel_lookup = + transcript->template receive_from_prover(commitment_labels.avm_main_q_kernel_lookup); commitments.avm_main_r_in_tag = transcript->template receive_from_prover(commitment_labels.avm_main_r_in_tag); commitments.avm_main_rwa = transcript->template receive_from_prover(commitment_labels.avm_main_rwa); @@ -259,10 +261,24 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_address); commitments.avm_main_sel_op_and = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_and); + commitments.avm_main_sel_op_block_number = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_block_number); + commitments.avm_main_sel_op_chain_id = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_chain_id); + commitments.avm_main_sel_op_coinbase = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_coinbase); commitments.avm_main_sel_op_div = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_div); commitments.avm_main_sel_op_eq = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_eq); + commitments.avm_main_sel_op_fee_per_da_gas = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_fee_per_da_gas); + commitments.avm_main_sel_op_fee_per_l1_gas = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_fee_per_l1_gas); + commitments.avm_main_sel_op_fee_per_l2_gas = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_fee_per_l2_gas); + commitments.avm_main_sel_op_function_selector = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_function_selector); commitments.avm_main_sel_op_lt = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_lt); commitments.avm_main_sel_op_lte = @@ -273,10 +289,16 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_not); commitments.avm_main_sel_op_or = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_or); + commitments.avm_main_sel_op_portal = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_portal); commitments.avm_main_sel_op_sender = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_sender); commitments.avm_main_sel_op_sub = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_sub); + commitments.avm_main_sel_op_timestamp = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_timestamp); + commitments.avm_main_sel_op_version = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_version); commitments.avm_main_sel_op_xor = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_xor); commitments.avm_main_sel_rng_16 = @@ -441,7 +463,7 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu } FF public_column_evaluation = evaluate_public_input_column(public_inputs, multivariate_challenge); - if (public_column_evaluation != claimed_evaluations.avm_main_kernel_inputs__is_public) { + if (public_column_evaluation != claimed_evaluations.avm_kernel_kernel_inputs__is_public) { return false; } diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_environment.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_environment.test.cpp deleted file mode 100644 index 0c0c22ee119..00000000000 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_environment.test.cpp +++ /dev/null @@ -1,45 +0,0 @@ - -#include "avm_common.test.hpp" - -namespace tests_avm { -using namespace bb::avm_trace; - -class AvmEnvironmentTests : public ::testing::Test { - - protected: - // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test. - void SetUp() override { srs::init_crs_factory("../srs_db/ignition"); }; -}; - -TEST_F(AvmEnvironmentTests, simpleSender) -{ - // We test that the sender opcode is inlcuded at index x in the public inputs - - std::vector kernel_inputs = { FF(1), FF(2) }; - AvmTraceBuilder trace_builder(kernel_inputs); - - // We should return a value of 1 for the sender, as it exists at index 0 - trace_builder.op_sender(42); - trace_builder.halt(); - - auto trace = trace_builder.finalize(); - - validate_trace(std::move(trace), kernel_inputs); -} - -TEST_F(AvmEnvironmentTests, simpleAddress) -{ - // We test that the sender opcode is inlcuded at index x in the public inputs - - std::vector kernel_inputs = { FF(1), FF(2) }; - AvmTraceBuilder trace_builder(kernel_inputs); - - // We should return a value of 1 for the sender, as it exists at index 0 - trace_builder.op_address(42); - trace_builder.halt(); - - auto trace = trace_builder.finalize(); - - validate_trace(std::move(trace), kernel_inputs); -} -} // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp new file mode 100644 index 00000000000..034ac5879a2 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -0,0 +1,66 @@ + +#include "avm_common.test.hpp" +#include "barretenberg/vm/avm_trace/constants.hpp" + +namespace tests_avm { +using namespace bb::avm_trace; + +class AvmEnvironmentTests : public ::testing::Test { + + protected: + // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test. + void SetUp() override { srs::init_crs_factory("../srs_db/ignition"); }; +}; + +using KernelInputs = std::array; +KernelInputs get_kernel_inputs() +{ + std::array kernel_inputs; + for (size_t i = 0; i < KERNEL_INPUTS_LENGTH; i++) { + kernel_inputs[i] = FF(i + 1); + } + return kernel_inputs; +} + +// Template helper function to apply boilerplate around the kernel lookup tests +template void test_kernel_lookup(Func apply_opcodes) +{ + KernelInputs kernel_inputs = get_kernel_inputs(); + AvmTraceBuilder trace_builder(kernel_inputs); + + // We should return a value of 1 for the sender, as it exists at index 0 + apply_opcodes(trace_builder); + + trace_builder.halt(); + + auto trace = trace_builder.finalize(); + + validate_trace(std::move(trace), kernel_inputs); +} + +TEST_F(AvmEnvironmentTests, simpleSender) +{ + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [](AvmTraceBuilder& trace_builder) { trace_builder.op_sender(42); }; + test_kernel_lookup(apply_opcodes); +} + +TEST_F(AvmEnvironmentTests, simpleAddress) +{ + auto apply_opcodes = [](AvmTraceBuilder& trace_builder) { trace_builder.op_address(42); }; + test_kernel_lookup(apply_opcodes); +} + +TEST_F(AvmEnvironmentTests, simplePortal) +{ + auto apply_opcodes = [](AvmTraceBuilder& trace_builder) { trace_builder.op_portal(42); }; + test_kernel_lookup(apply_opcodes); +} + +TEST_F(AvmEnvironmentTests, simpleFunction) +{ + auto apply_opcodes = [](AvmTraceBuilder& trace_builder) { trace_builder.op_function(42); }; + test_kernel_lookup(apply_opcodes); +} + +} // namespace tests_avm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 9fc3a284b72..90a3bfeaa09 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -7,7 +7,7 @@ namespace tests_avm { * * @param trace The execution trace */ -void validate_trace_check_circuit(std::vector&& trace, std::vector public_inputs) +void validate_trace_check_circuit(std::vector&& trace, std::array public_inputs) { validate_trace(std::move(trace), public_inputs, false); }; @@ -18,7 +18,7 @@ void validate_trace_check_circuit(std::vector&& trace, std::vector publ * * @param trace The execution trace */ -void validate_trace(std::vector&& trace, std::vector public_inputs, bool with_proof) +void validate_trace(std::vector&& trace, std::array public_inputs, bool with_proof) { auto circuit_builder = AvmCircuitBuilder(); circuit_builder.set_trace(std::move(trace)); @@ -30,7 +30,12 @@ void validate_trace(std::vector&& trace, std::vector public_inputs, boo auto proof = prover.construct_proof(); auto verifier = composer.create_verifier(circuit_builder); - bool verified = verifier.verify_proof(proof, public_inputs); + + // TODO: hacky copy for now, maybe change the verify proof type? + std::vector pub_inputs; + std::copy(public_inputs.begin(), public_inputs.end(), pub_inputs.data()); + + bool verified = verifier.verify_proof(proof, pub_inputs); EXPECT_TRUE(verified); } diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp index 6f85716a371..5c08b9e21f6 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.hpp @@ -1,6 +1,7 @@ #pragma once #include "barretenberg/vm/avm_trace/avm_trace.hpp" +#include "barretenberg/vm/avm_trace/constants.hpp" #include #define EXPECT_THROW_WITH_MESSAGE(code, expectedMessage) \ @@ -23,8 +24,10 @@ static const bool ENABLE_PROVING = std::getenv("AVM_TESTS_ENABLE_PROVING") != nu // If the test is expecting a relation to fail, then use validate_trace_check_circuit. // Otherwise, use validate_trace with a single argument. If the proving needs to be // enabled all the time in a given test, use validate_trace with setting with_proof = true. -void validate_trace_check_circuit(std::vector&& trace, std::vector public_inputs = {}); -void validate_trace(std::vector&& trace, std::vector public_inputs = {}, bool with_proof = ENABLE_PROVING); +void validate_trace_check_circuit(std::vector&& trace, std::array kernel_inputs = {}); +void validate_trace(std::vector&& trace, + std::array kernel_inputs = {}, + bool with_proof = ENABLE_PROVING); void mutate_ic_in_trace(std::vector& trace, std::function&& selectRow, FF const& newValue, From 59b221c09c96575b004e925913757853cea5e5f6 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 18 Apr 2024 00:44:29 +0000 Subject: [PATCH 16/40] fix: add tests for all call context opcodes --- barretenberg/cpp/pil/avm/avm_kernel.pil | 2 +- .../relations/generated/avm/declare_views.hpp | 4 +- ...environment.hpp => lookup_into_kernel.hpp} | 14 +- .../barretenberg/vm/avm_trace/avm_trace.cpp | 11 +- .../vm/generated/avm_circuit_builder.hpp | 11 +- .../barretenberg/vm/generated/avm_flavor.hpp | 44 ++--- .../barretenberg/vm/generated/avm_prover.cpp | 11 +- .../vm/generated/avm_verifier.cpp | 8 +- .../barretenberg/vm/tests/avm_kernel.test.cpp | 166 ++++++++++++++++-- 9 files changed, 206 insertions(+), 65 deletions(-) rename barretenberg/cpp/src/barretenberg/relations/generated/avm/{lookup_into_environment.hpp => lookup_into_kernel.hpp} (92%) diff --git a/barretenberg/cpp/pil/avm/avm_kernel.pil b/barretenberg/cpp/pil/avm/avm_kernel.pil index 2accc5a5bc9..275a4123c6c 100644 --- a/barretenberg/cpp/pil/avm/avm_kernel.pil +++ b/barretenberg/cpp/pil/avm/avm_kernel.pil @@ -37,6 +37,6 @@ namespace avm_kernel(256); // We should be able to have this always be on pol commit q_public_input_kernel_add_to_table; - #[LOOKUP_INTO_ENVIRONMENT] + #[LOOKUP_INTO_KERNEL] // TODO: FIX not having the trailing is_public breaking compilation :( avm_main.q_kernel_lookup { avm_main.ia, kernel_sel } in q_public_input_kernel_add_to_table { kernel_inputs__is_public, avm_main.clk }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp index 878b865bb6a..8be7584550b 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -190,7 +190,7 @@ [[maybe_unused]] auto perm_main_mem_ind_d = View(new_term.perm_main_mem_ind_d); \ [[maybe_unused]] auto lookup_byte_lengths = View(new_term.lookup_byte_lengths); \ [[maybe_unused]] auto lookup_byte_operations = View(new_term.lookup_byte_operations); \ - [[maybe_unused]] auto lookup_into_environment = View(new_term.lookup_into_environment); \ + [[maybe_unused]] auto lookup_into_kernel = View(new_term.lookup_into_kernel); \ [[maybe_unused]] auto incl_main_tag_err = View(new_term.incl_main_tag_err); \ [[maybe_unused]] auto incl_mem_tag_err = View(new_term.incl_mem_tag_err); \ [[maybe_unused]] auto lookup_u8_0 = View(new_term.lookup_u8_0); \ @@ -212,7 +212,7 @@ [[maybe_unused]] auto lookup_u16_14 = View(new_term.lookup_u16_14); \ [[maybe_unused]] auto lookup_byte_lengths_counts = View(new_term.lookup_byte_lengths_counts); \ [[maybe_unused]] auto lookup_byte_operations_counts = View(new_term.lookup_byte_operations_counts); \ - [[maybe_unused]] auto lookup_into_environment_counts = View(new_term.lookup_into_environment_counts); \ + [[maybe_unused]] auto lookup_into_kernel_counts = View(new_term.lookup_into_kernel_counts); \ [[maybe_unused]] auto incl_main_tag_err_counts = View(new_term.incl_main_tag_err_counts); \ [[maybe_unused]] auto incl_mem_tag_err_counts = View(new_term.incl_mem_tag_err_counts); \ [[maybe_unused]] auto lookup_u8_0_counts = View(new_term.lookup_u8_0_counts); \ diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_kernel.hpp similarity index 92% rename from barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp rename to barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_kernel.hpp index d0607647895..ac4eae2c174 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_environment.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/lookup_into_kernel.hpp @@ -23,7 +23,7 @@ namespace bb { * FF>>;)` * */ -class lookup_into_environment_lookup_settings { +class lookup_into_kernel_lookup_settings { public: /** * @brief The number of read terms (how many lookups we perform) in each row @@ -133,8 +133,8 @@ class lookup_into_environment_lookup_settings { template static inline auto get_const_entities(const AllEntities& in) { - return std::forward_as_tuple(in.lookup_into_environment, - in.lookup_into_environment_counts, + return std::forward_as_tuple(in.lookup_into_kernel, + in.lookup_into_kernel_counts, in.avm_main_q_kernel_lookup, in.avm_kernel_q_public_input_kernel_add_to_table, in.avm_main_ia, @@ -153,8 +153,8 @@ class lookup_into_environment_lookup_settings { template static inline auto get_nonconst_entities(AllEntities& in) { - return std::forward_as_tuple(in.lookup_into_environment, - in.lookup_into_environment_counts, + return std::forward_as_tuple(in.lookup_into_kernel, + in.lookup_into_kernel_counts, in.avm_main_q_kernel_lookup, in.avm_kernel_q_public_input_kernel_add_to_table, in.avm_main_ia, @@ -165,7 +165,7 @@ class lookup_into_environment_lookup_settings { }; template -using lookup_into_environment_relation = GenericLookupRelation; -template using lookup_into_environment = GenericLookup; +using lookup_into_kernel_relation = GenericLookupRelation; +template using lookup_into_kernel = GenericLookup; } // namespace bb diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp index ccb2294c097..10d6b60e0c1 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -1720,10 +1720,13 @@ std::vector AvmTraceBuilder::finalize() // Add public inputs into the kernel column // edge case: If the number of public inputs is more than the trace then we pad to its size - if (main_trace.size() < kernel_trace_builder.kernel_inputs.size()) { - auto diff = kernel_trace_builder.kernel_inputs.size() - main_trace.size(); + size_t initial_size = main_trace.size(); + size_t number_of_kernel_inputs = kernel_trace_builder.kernel_inputs.size(); + if (initial_size < number_of_kernel_inputs) { + auto diff = number_of_kernel_inputs - initial_size; for (size_t i = 0; i < diff; ++i) { - main_trace.push_back(Row{}); + // We need clk to increment for kernel lookups to remain valid + main_trace.push_back(Row{ .avm_main_clk = initial_size + i }); } } auto kernel_inputs_size = std::min(main_trace.size(), kernel_trace_builder.kernel_inputs.size()); @@ -1731,7 +1734,7 @@ std::vector AvmTraceBuilder::finalize() // We add the lookup counts in the index of the kernel inputs selectors that are active for (uint32_t selector_index : KERNEL_INPUTS_SELECTORS) { auto& dest = main_trace.at(selector_index); - dest.lookup_into_environment_counts = + dest.lookup_into_kernel_counts = FF(kernel_trace_builder.kernel_selector_counter[static_cast(selector_index)]); dest.avm_kernel_q_public_input_kernel_add_to_table = FF(1); } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index c638f393e2a..9773b648d9b 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -20,7 +20,7 @@ #include "barretenberg/relations/generated/avm/incl_mem_tag_err.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_lengths.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_operations.hpp" -#include "barretenberg/relations/generated/avm/lookup_into_environment.hpp" +#include "barretenberg/relations/generated/avm/lookup_into_kernel.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_0.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_1.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_10.hpp" @@ -240,7 +240,7 @@ template struct AvmFullRow { FF perm_main_mem_ind_d{}; FF lookup_byte_lengths{}; FF lookup_byte_operations{}; - FF lookup_into_environment{}; + FF lookup_into_kernel{}; FF incl_main_tag_err{}; FF incl_mem_tag_err{}; FF lookup_u8_0{}; @@ -262,7 +262,7 @@ template struct AvmFullRow { FF lookup_u16_14{}; FF lookup_byte_lengths_counts{}; FF lookup_byte_operations_counts{}; - FF lookup_into_environment_counts{}; + FF lookup_into_kernel_counts{}; FF incl_main_tag_err_counts{}; FF incl_mem_tag_err_counts{}; FF lookup_u8_0_counts{}; @@ -524,7 +524,7 @@ class AvmCircuitBuilder { polys.avm_mem_w_in_tag[i] = rows[i].avm_mem_w_in_tag; polys.lookup_byte_lengths_counts[i] = rows[i].lookup_byte_lengths_counts; polys.lookup_byte_operations_counts[i] = rows[i].lookup_byte_operations_counts; - polys.lookup_into_environment_counts[i] = rows[i].lookup_into_environment_counts; + polys.lookup_into_kernel_counts[i] = rows[i].lookup_into_kernel_counts; polys.incl_main_tag_err_counts[i] = rows[i].incl_main_tag_err_counts; polys.incl_mem_tag_err_counts[i] = rows[i].incl_mem_tag_err_counts; polys.lookup_u8_0_counts[i] = rows[i].lookup_u8_0_counts; @@ -710,8 +710,7 @@ class AvmCircuitBuilder { "LOOKUP_BYTE_OPERATIONS")) { return false; } - if (!evaluate_logderivative.template operator()>( - "LOOKUP_INTO_ENVIRONMENT")) { + if (!evaluate_logderivative.template operator()>("LOOKUP_INTO_KERNEL")) { return false; } if (!evaluate_logderivative.template operator()>("INCL_MAIN_TAG_ERR")) { diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index e3bc13fd72b..dceb4fa6072 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -22,7 +22,7 @@ #include "barretenberg/relations/generated/avm/incl_mem_tag_err.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_lengths.hpp" #include "barretenberg/relations/generated/avm/lookup_byte_operations.hpp" -#include "barretenberg/relations/generated/avm/lookup_into_environment.hpp" +#include "barretenberg/relations/generated/avm/lookup_into_kernel.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_0.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_1.hpp" #include "barretenberg/relations/generated/avm/lookup_u16_10.hpp" @@ -89,7 +89,7 @@ class AvmFlavor { perm_main_mem_ind_d_relation, lookup_byte_lengths_relation, lookup_byte_operations_relation, - lookup_into_environment_relation, + lookup_into_kernel_relation, incl_main_tag_err_relation, incl_mem_tag_err_relation, lookup_u8_0_relation, @@ -127,7 +127,7 @@ class AvmFlavor { perm_main_mem_ind_d_relation, lookup_byte_lengths_relation, lookup_byte_operations_relation, - lookup_into_environment_relation, + lookup_into_kernel_relation, incl_main_tag_err_relation, incl_mem_tag_err_relation, lookup_u8_0_relation, @@ -365,7 +365,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, - lookup_into_environment, + lookup_into_kernel, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -387,7 +387,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, - lookup_into_environment_counts, + lookup_into_kernel_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -595,7 +595,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, - lookup_into_environment, + lookup_into_kernel, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -617,7 +617,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, - lookup_into_environment_counts, + lookup_into_kernel_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -830,7 +830,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, - lookup_into_environment, + lookup_into_kernel, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -852,7 +852,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, - lookup_into_environment_counts, + lookup_into_kernel_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -1097,7 +1097,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, - lookup_into_environment, + lookup_into_kernel, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -1119,7 +1119,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, - lookup_into_environment_counts, + lookup_into_kernel_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -1364,7 +1364,7 @@ class AvmFlavor { perm_main_mem_ind_d, lookup_byte_lengths, lookup_byte_operations, - lookup_into_environment, + lookup_into_kernel, incl_main_tag_err, incl_mem_tag_err, lookup_u8_0, @@ -1386,7 +1386,7 @@ class AvmFlavor { lookup_u16_14, lookup_byte_lengths_counts, lookup_byte_operations_counts, - lookup_into_environment_counts, + lookup_into_kernel_counts, incl_main_tag_err_counts, incl_mem_tag_err_counts, lookup_u8_0_counts, @@ -1508,7 +1508,7 @@ class AvmFlavor { prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); - bb::compute_logderivative_inverse>( + bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); bb::compute_logderivative_inverse>( prover_polynomials, relation_parameters, this->circuit_size); @@ -1827,7 +1827,7 @@ class AvmFlavor { Base::perm_main_mem_ind_d = "PERM_MAIN_MEM_IND_D"; Base::lookup_byte_lengths = "LOOKUP_BYTE_LENGTHS"; Base::lookup_byte_operations = "LOOKUP_BYTE_OPERATIONS"; - Base::lookup_into_environment = "LOOKUP_INTO_ENVIRONMENT"; + Base::lookup_into_kernel = "LOOKUP_INTO_KERNEL"; Base::incl_main_tag_err = "INCL_MAIN_TAG_ERR"; Base::incl_mem_tag_err = "INCL_MEM_TAG_ERR"; Base::lookup_u8_0 = "LOOKUP_U8_0"; @@ -1849,7 +1849,7 @@ class AvmFlavor { Base::lookup_u16_14 = "LOOKUP_U16_14"; Base::lookup_byte_lengths_counts = "LOOKUP_BYTE_LENGTHS_COUNTS"; Base::lookup_byte_operations_counts = "LOOKUP_BYTE_OPERATIONS_COUNTS"; - Base::lookup_into_environment_counts = "LOOKUP_INTO_ENVIRONMENT_COUNTS"; + Base::lookup_into_kernel_counts = "LOOKUP_INTO_KERNEL_COUNTS"; Base::incl_main_tag_err_counts = "INCL_MAIN_TAG_ERR_COUNTS"; Base::incl_mem_tag_err_counts = "INCL_MEM_TAG_ERR_COUNTS"; Base::lookup_u8_0_counts = "LOOKUP_U8_0_COUNTS"; @@ -2073,7 +2073,7 @@ class AvmFlavor { Commitment perm_main_mem_ind_d; Commitment lookup_byte_lengths; Commitment lookup_byte_operations; - Commitment lookup_into_environment; + Commitment lookup_into_kernel; Commitment incl_main_tag_err; Commitment incl_mem_tag_err; Commitment lookup_u8_0; @@ -2095,7 +2095,7 @@ class AvmFlavor { Commitment lookup_u16_14; Commitment lookup_byte_lengths_counts; Commitment lookup_byte_operations_counts; - Commitment lookup_into_environment_counts; + Commitment lookup_into_kernel_counts; Commitment incl_main_tag_err_counts; Commitment incl_mem_tag_err_counts; Commitment lookup_u8_0_counts; @@ -2323,7 +2323,7 @@ class AvmFlavor { perm_main_mem_ind_d = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_lengths = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_operations = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - lookup_into_environment = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + lookup_into_kernel = deserialize_from_buffer(Transcript::proof_data, num_frs_read); incl_main_tag_err = deserialize_from_buffer(Transcript::proof_data, num_frs_read); incl_mem_tag_err = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_u8_0 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2345,7 +2345,7 @@ class AvmFlavor { lookup_u16_14 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_lengths_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_byte_operations_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - lookup_into_environment_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + lookup_into_kernel_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); incl_main_tag_err_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); incl_mem_tag_err_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); lookup_u8_0_counts = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2573,7 +2573,7 @@ class AvmFlavor { serialize_to_buffer(perm_main_mem_ind_d, Transcript::proof_data); serialize_to_buffer(lookup_byte_lengths, Transcript::proof_data); serialize_to_buffer(lookup_byte_operations, Transcript::proof_data); - serialize_to_buffer(lookup_into_environment, Transcript::proof_data); + serialize_to_buffer(lookup_into_kernel, Transcript::proof_data); serialize_to_buffer(incl_main_tag_err, Transcript::proof_data); serialize_to_buffer(incl_mem_tag_err, Transcript::proof_data); serialize_to_buffer(lookup_u8_0, Transcript::proof_data); @@ -2595,7 +2595,7 @@ class AvmFlavor { serialize_to_buffer(lookup_u16_14, Transcript::proof_data); serialize_to_buffer(lookup_byte_lengths_counts, Transcript::proof_data); serialize_to_buffer(lookup_byte_operations_counts, Transcript::proof_data); - serialize_to_buffer(lookup_into_environment_counts, Transcript::proof_data); + serialize_to_buffer(lookup_into_kernel_counts, Transcript::proof_data); serialize_to_buffer(incl_main_tag_err_counts, Transcript::proof_data); serialize_to_buffer(incl_mem_tag_err_counts, Transcript::proof_data); serialize_to_buffer(lookup_u8_0_counts, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index f27a70d0486..1f049a6d954 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -238,7 +238,7 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_mem_w_in_tag = commitment_key->commit(key->avm_mem_w_in_tag); witness_commitments.lookup_byte_lengths_counts = commitment_key->commit(key->lookup_byte_lengths_counts); witness_commitments.lookup_byte_operations_counts = commitment_key->commit(key->lookup_byte_operations_counts); - witness_commitments.lookup_into_environment_counts = commitment_key->commit(key->lookup_into_environment_counts); + witness_commitments.lookup_into_kernel_counts = commitment_key->commit(key->lookup_into_kernel_counts); witness_commitments.incl_main_tag_err_counts = commitment_key->commit(key->incl_main_tag_err_counts); witness_commitments.incl_mem_tag_err_counts = commitment_key->commit(key->incl_mem_tag_err_counts); witness_commitments.lookup_u8_0_counts = commitment_key->commit(key->lookup_u8_0_counts); @@ -462,8 +462,8 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.lookup_byte_lengths_counts); transcript->send_to_verifier(commitment_labels.lookup_byte_operations_counts, witness_commitments.lookup_byte_operations_counts); - transcript->send_to_verifier(commitment_labels.lookup_into_environment_counts, - witness_commitments.lookup_into_environment_counts); + transcript->send_to_verifier(commitment_labels.lookup_into_kernel_counts, + witness_commitments.lookup_into_kernel_counts); transcript->send_to_verifier(commitment_labels.incl_main_tag_err_counts, witness_commitments.incl_main_tag_err_counts); transcript->send_to_verifier(commitment_labels.incl_mem_tag_err_counts, @@ -509,7 +509,7 @@ void AvmProver::execute_log_derivative_inverse_round() witness_commitments.perm_main_mem_ind_d = commitment_key->commit(key->perm_main_mem_ind_d); witness_commitments.lookup_byte_lengths = commitment_key->commit(key->lookup_byte_lengths); witness_commitments.lookup_byte_operations = commitment_key->commit(key->lookup_byte_operations); - witness_commitments.lookup_into_environment = commitment_key->commit(key->lookup_into_environment); + witness_commitments.lookup_into_kernel = commitment_key->commit(key->lookup_into_kernel); witness_commitments.incl_main_tag_err = commitment_key->commit(key->incl_main_tag_err); witness_commitments.incl_mem_tag_err = commitment_key->commit(key->incl_mem_tag_err); witness_commitments.lookup_u8_0 = commitment_key->commit(key->lookup_u8_0); @@ -543,8 +543,7 @@ void AvmProver::execute_log_derivative_inverse_round() transcript->send_to_verifier(commitment_labels.perm_main_mem_ind_d, witness_commitments.perm_main_mem_ind_d); transcript->send_to_verifier(commitment_labels.lookup_byte_lengths, witness_commitments.lookup_byte_lengths); transcript->send_to_verifier(commitment_labels.lookup_byte_operations, witness_commitments.lookup_byte_operations); - transcript->send_to_verifier(commitment_labels.lookup_into_environment, - witness_commitments.lookup_into_environment); + transcript->send_to_verifier(commitment_labels.lookup_into_kernel, witness_commitments.lookup_into_kernel); transcript->send_to_verifier(commitment_labels.incl_main_tag_err, witness_commitments.incl_main_tag_err); transcript->send_to_verifier(commitment_labels.incl_mem_tag_err, witness_commitments.incl_mem_tag_err); transcript->send_to_verifier(commitment_labels.lookup_u8_0, witness_commitments.lookup_u8_0); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index bc32029d4c6..db7d9d3428d 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -351,8 +351,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths_counts); commitments.lookup_byte_operations_counts = transcript->template receive_from_prover(commitment_labels.lookup_byte_operations_counts); - commitments.lookup_into_environment_counts = - transcript->template receive_from_prover(commitment_labels.lookup_into_environment_counts); + commitments.lookup_into_kernel_counts = + transcript->template receive_from_prover(commitment_labels.lookup_into_kernel_counts); commitments.incl_main_tag_err_counts = transcript->template receive_from_prover(commitment_labels.incl_main_tag_err_counts); commitments.incl_mem_tag_err_counts = @@ -419,8 +419,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu transcript->template receive_from_prover(commitment_labels.lookup_byte_lengths); commitments.lookup_byte_operations = transcript->template receive_from_prover(commitment_labels.lookup_byte_operations); - commitments.lookup_into_environment = - transcript->template receive_from_prover(commitment_labels.lookup_into_environment); + commitments.lookup_into_kernel = + transcript->template receive_from_prover(commitment_labels.lookup_into_kernel); commitments.incl_main_tag_err = transcript->template receive_from_prover(commitment_labels.incl_main_tag_err); commitments.incl_mem_tag_err = diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp index 034ac5879a2..0093cd6954d 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -1,5 +1,6 @@ #include "avm_common.test.hpp" +#include "barretenberg/vm/avm_trace/avm_kernel_trace.hpp" #include "barretenberg/vm/avm_trace/constants.hpp" namespace tests_avm { @@ -23,7 +24,8 @@ KernelInputs get_kernel_inputs() } // Template helper function to apply boilerplate around the kernel lookup tests -template void test_kernel_lookup(Func apply_opcodes) +template +void test_kernel_lookup(OpcodesFunc apply_opcodes, CheckFunc check_trace) { KernelInputs kernel_inputs = get_kernel_inputs(); AvmTraceBuilder trace_builder(kernel_inputs); @@ -35,32 +37,170 @@ template void test_kernel_lookup(Func apply_opcodes) auto trace = trace_builder.finalize(); + check_trace(trace); + validate_trace(std::move(trace), kernel_inputs); } -TEST_F(AvmEnvironmentTests, simpleSender) +/* + * Helper function to assert row values for a kernel lookup opcode + */ +void expect_row(std::vector::const_iterator row, FF selector, FF ia, FF mem_idx_a) +{ + // Checks dependent on the opcode + EXPECT_EQ(row->avm_kernel_kernel_sel, selector); + EXPECT_EQ(row->avm_main_ia, ia); + EXPECT_EQ(row->avm_main_mem_idx_a, mem_idx_a); + + // Checks that are fixed for kernel inputs + EXPECT_EQ(row->avm_main_rwa, FF(1)); + EXPECT_EQ(row->avm_main_ind_a, FF(0)); + EXPECT_EQ(row->avm_mem_op_a, FF(1)); + // TODO: below should really be a field element for each type + EXPECT_EQ(row->avm_main_w_in_tag, static_cast(AvmMemoryTag::U32)); + EXPECT_EQ(row->avm_main_q_kernel_lookup, FF(1)); +} + +TEST_F(AvmEnvironmentTests, kernelSender) { + uint32_t dst_offset = 42; // We test that the sender opcode is inlcuded at index x in the public inputs - auto apply_opcodes = [](AvmTraceBuilder& trace_builder) { trace_builder.op_sender(42); }; - test_kernel_lookup(apply_opcodes); + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_sender(dst_offset); }; + auto checks = [=](const std::vector& trace) { + // When the sender selector is active, we should expect all of the memory operations to write in the expected + // registers + std::vector::const_iterator sender_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_sender == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row(sender_row, + /*kernel_sel=*/SENDER_SELECTOR, + /*ia=*/SENDER_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + test_kernel_lookup(apply_opcodes, checks); +} + +TEST_F(AvmEnvironmentTests, kernelAddress) +{ + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_address(dst_offset); }; + auto checks = [=](const std::vector& trace) { + // When the sender selector is active, we should expect all of the memory operations to write in the expected + // registers + std::vector::const_iterator address_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_address == FF(1); }); + EXPECT_TRUE(address_row != trace.end()); + + expect_row(address_row, + /*kernel_sel=*/ADDRESS_SELECTOR, + /*ia=*/ADDRESS_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmEnvironmentTests, simpleAddress) +TEST_F(AvmEnvironmentTests, kernelPortal) { - auto apply_opcodes = [](AvmTraceBuilder& trace_builder) { trace_builder.op_address(42); }; - test_kernel_lookup(apply_opcodes); + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_portal(dst_offset); }; + auto checks = [=](const std::vector& trace) { + // When the sender selector is active, we should expect all of the memory operations to write in the expected + // registers + std::vector::const_iterator portal_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_portal == FF(1); }); + EXPECT_TRUE(portal_row != trace.end()); + + expect_row(portal_row, + /*kernel_sel=*/PORTAL_SELECTOR, + /*ia=*/PORTAL_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); +} + +TEST_F(AvmEnvironmentTests, kernelFunction) +{ + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_function(dst_offset); }; + auto checks = [=](const std::vector& trace) { + // When the sender selector is active, we should expect all of the memory operations to write in the expected + // registers + std::vector::const_iterator function_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_function_selector == FF(1); }); + EXPECT_TRUE(function_row != trace.end()); + + expect_row(function_row, + /*kernel_sel=*/FUNCTION_SELECTOR, + /*ia=*/FUNCTION_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmEnvironmentTests, simplePortal) +TEST_F(AvmEnvironmentTests, kernelFeePerDa) { - auto apply_opcodes = [](AvmTraceBuilder& trace_builder) { trace_builder.op_portal(42); }; - test_kernel_lookup(apply_opcodes); + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_da_gas(dst_offset); }; + auto checks = [=](const std::vector& trace) { + // When the sender selector is active, we should expect all of the memory operations to write in the expected + // registers + std::vector::const_iterator fee_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_da_gas == FF(1); }); + EXPECT_TRUE(fee_row != trace.end()); + + expect_row(fee_row, + /*kernel_sel=*/FEE_PER_DA_GAS_SELECTOR, + /*ia=*/FEE_PER_DA_GAS_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmEnvironmentTests, simpleFunction) +TEST_F(AvmEnvironmentTests, kernelFeePerL1) { - auto apply_opcodes = [](AvmTraceBuilder& trace_builder) { trace_builder.op_function(42); }; - test_kernel_lookup(apply_opcodes); + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l1_gas(dst_offset); }; + auto checks = [=](const std::vector& trace) { + // When the sender selector is active, we should expect all of the memory operations to write in the expected + // registers + std::vector::const_iterator fee_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l1_gas == FF(1); }); + EXPECT_TRUE(fee_row != trace.end()); + + expect_row(fee_row, + /*kernel_sel=*/FEE_PER_L1_GAS_SELECTOR, + /*ia=*/FEE_PER_L1_GAS_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); +} + +TEST_F(AvmEnvironmentTests, kernelFeePerL2) +{ + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l2_gas(dst_offset); }; + auto checks = [=](const std::vector& trace) { + // When the sender selector is active, we should expect all of the memory operations to write in the expected + // registers + std::vector::const_iterator fee_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l2_gas == FF(1); }); + EXPECT_TRUE(fee_row != trace.end()); + + expect_row(fee_row, + /*kernel_sel=*/FEE_PER_L2_GAS_SELECTOR, + /*ia=*/FEE_PER_L2_GAS_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); } } // namespace tests_avm \ No newline at end of file From c934c61ade7c0c8e2a33f171ece1ba2c79d9a8b5 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 18 Apr 2024 02:40:41 +0000 Subject: [PATCH 17/40] chore: update pil comments --- barretenberg/cpp/pil/avm/avm_kernel.pil | 12 +++++------- barretenberg/cpp/pil/avm/constants.pil | 3 ++- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_kernel.pil b/barretenberg/cpp/pil/avm/avm_kernel.pil index 275a4123c6c..3e2a553f5f3 100644 --- a/barretenberg/cpp/pil/avm/avm_kernel.pil +++ b/barretenberg/cpp/pil/avm/avm_kernel.pil @@ -6,11 +6,10 @@ namespace avm_kernel(256); pol commit kernel_sel; // The general pattern for environment lookups is as follows: - // - If we are performing an environment lookup, then we set q_environment_lookup - // - We can toggle what index in the + // Each kernel opcode related to some fixed positions in the `public kernel_inputs` polynomial + // We can lookup into a fixed index of this polynomial by including constraints that force the value + // of kernel_sel to the value relevant to the given opcode that is active - // Note we are currently using arbitrary opcodes for each - // For this demo, caller is stored at index 0 #[SENDER_KERNEL] avm_main.sel_op_sender * (kernel_sel - constants.SENDER_SELECTOR) = 0; @@ -32,9 +31,8 @@ namespace avm_kernel(256); #[FEE_L2_GAS_KERNEL] avm_main.sel_op_fee_per_l2_gas * (kernel_sel - constants.FEE_PER_L2_GAS_SELECTOR) = 0; - // TODO: temporarily have a column to add the public inputs to a lookup table - // NOTE: WE SHOULD NOT NEED THIS - every thing in the column will be added to the table - // We should be able to have this always be on + // Note: in the future, with some codegen adjustments, this column will not be needed + // as we can just add every entry in the public kernel_inputs to the lookup table pol commit q_public_input_kernel_add_to_table; #[LOOKUP_INTO_KERNEL] diff --git a/barretenberg/cpp/pil/avm/constants.pil b/barretenberg/cpp/pil/avm/constants.pil index 8fac51f5627..ec162e4408d 100644 --- a/barretenberg/cpp/pil/avm/constants.pil +++ b/barretenberg/cpp/pil/avm/constants.pil @@ -1,6 +1,7 @@ +// NOTE: the constants in this file line up to the indexes of values in the +// `PublicKernelInputs.nr` object namespace constants(256); - pol SENDER_SELECTOR = 0; pol ADDRESS_SELECTOR = 1; pol PORTAL_SELECTOR = 2; From a8ceaf8da07935974b152ac564a32435319e7fb1 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 18 Apr 2024 02:41:22 +0000 Subject: [PATCH 18/40] fix: remove redundant comment --- .../src/barretenberg/vm/tests/avm_kernel.test.cpp | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp index 0093cd6954d..3db91e499d2 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -67,8 +67,6 @@ TEST_F(AvmEnvironmentTests, kernelSender) // We test that the sender opcode is inlcuded at index x in the public inputs auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_sender(dst_offset); }; auto checks = [=](const std::vector& trace) { - // When the sender selector is active, we should expect all of the memory operations to write in the expected - // registers std::vector::const_iterator sender_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_sender == FF(1); }); EXPECT_TRUE(sender_row != trace.end()); @@ -88,8 +86,6 @@ TEST_F(AvmEnvironmentTests, kernelAddress) uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_address(dst_offset); }; auto checks = [=](const std::vector& trace) { - // When the sender selector is active, we should expect all of the memory operations to write in the expected - // registers std::vector::const_iterator address_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_address == FF(1); }); EXPECT_TRUE(address_row != trace.end()); @@ -108,8 +104,6 @@ TEST_F(AvmEnvironmentTests, kernelPortal) uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_portal(dst_offset); }; auto checks = [=](const std::vector& trace) { - // When the sender selector is active, we should expect all of the memory operations to write in the expected - // registers std::vector::const_iterator portal_row = std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_portal == FF(1); }); EXPECT_TRUE(portal_row != trace.end()); @@ -128,8 +122,6 @@ TEST_F(AvmEnvironmentTests, kernelFunction) uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_function(dst_offset); }; auto checks = [=](const std::vector& trace) { - // When the sender selector is active, we should expect all of the memory operations to write in the expected - // registers std::vector::const_iterator function_row = std::ranges::find_if( trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_function_selector == FF(1); }); EXPECT_TRUE(function_row != trace.end()); @@ -148,8 +140,6 @@ TEST_F(AvmEnvironmentTests, kernelFeePerDa) uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_da_gas(dst_offset); }; auto checks = [=](const std::vector& trace) { - // When the sender selector is active, we should expect all of the memory operations to write in the expected - // registers std::vector::const_iterator fee_row = std::ranges::find_if( trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_da_gas == FF(1); }); EXPECT_TRUE(fee_row != trace.end()); @@ -168,8 +158,6 @@ TEST_F(AvmEnvironmentTests, kernelFeePerL1) uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l1_gas(dst_offset); }; auto checks = [=](const std::vector& trace) { - // When the sender selector is active, we should expect all of the memory operations to write in the expected - // registers std::vector::const_iterator fee_row = std::ranges::find_if( trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l1_gas == FF(1); }); EXPECT_TRUE(fee_row != trace.end()); @@ -188,8 +176,6 @@ TEST_F(AvmEnvironmentTests, kernelFeePerL2) uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l2_gas(dst_offset); }; auto checks = [=](const std::vector& trace) { - // When the sender selector is active, we should expect all of the memory operations to write in the expected - // registers std::vector::const_iterator fee_row = std::ranges::find_if( trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l2_gas == FF(1); }); EXPECT_TRUE(fee_row != trace.end()); From af343db9768ac1afb238035935d1dda2c32273fe Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Sun, 21 Apr 2024 23:43:16 +0000 Subject: [PATCH 19/40] fix: some negative tests --- .../barretenberg/vm/tests/avm_kernel.test.cpp | 205 +++++++++++++++++- 1 file changed, 197 insertions(+), 8 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp index 3db91e499d2..546e200d457 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -6,13 +6,16 @@ namespace tests_avm { using namespace bb::avm_trace; -class AvmEnvironmentTests : public ::testing::Test { +class AvmKernelTests : public ::testing::Test { protected: // TODO(640): The Standard Honk on Grumpkin test suite fails unless the SRS is initialised for every test. void SetUp() override { srs::init_crs_factory("../srs_db/ignition"); }; }; +class AvmKernelPositiveTests : public ::testing::Test {}; +class AvmKernelNegativeTests : public ::testing::Test {}; + using KernelInputs = std::array; KernelInputs get_kernel_inputs() { @@ -61,7 +64,7 @@ void expect_row(std::vector::const_iterator row, FF selector, FF ia, FF mem EXPECT_EQ(row->avm_main_q_kernel_lookup, FF(1)); } -TEST_F(AvmEnvironmentTests, kernelSender) +TEST_F(AvmKernelPositiveTests, kernelSender) { uint32_t dst_offset = 42; // We test that the sender opcode is inlcuded at index x in the public inputs @@ -81,7 +84,7 @@ TEST_F(AvmEnvironmentTests, kernelSender) test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmEnvironmentTests, kernelAddress) +TEST_F(AvmKernelPositiveTests, kernelAddress) { uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_address(dst_offset); }; @@ -99,7 +102,7 @@ TEST_F(AvmEnvironmentTests, kernelAddress) test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmEnvironmentTests, kernelPortal) +TEST_F(AvmKernelPositiveTests, kernelPortal) { uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_portal(dst_offset); }; @@ -117,7 +120,7 @@ TEST_F(AvmEnvironmentTests, kernelPortal) test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmEnvironmentTests, kernelFunction) +TEST_F(AvmKernelPositiveTests, kernelFunction) { uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_function(dst_offset); }; @@ -135,7 +138,7 @@ TEST_F(AvmEnvironmentTests, kernelFunction) test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmEnvironmentTests, kernelFeePerDa) +TEST_F(AvmKernelPositiveTests, kernelFeePerDa) { uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_da_gas(dst_offset); }; @@ -153,7 +156,7 @@ TEST_F(AvmEnvironmentTests, kernelFeePerDa) test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmEnvironmentTests, kernelFeePerL1) +TEST_F(AvmKernelPositiveTests, kernelFeePerL1) { uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l1_gas(dst_offset); }; @@ -171,7 +174,7 @@ TEST_F(AvmEnvironmentTests, kernelFeePerL1) test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmEnvironmentTests, kernelFeePerL2) +TEST_F(AvmKernelPositiveTests, kernelFeePerL2) { uint32_t dst_offset = 42; auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l2_gas(dst_offset); }; @@ -189,4 +192,190 @@ TEST_F(AvmEnvironmentTests, kernelFeePerL2) test_kernel_lookup(apply_opcodes, checks); } +/** + * Negative Tests + */ + +// Template helper function to apply boilerplate +template +void negative_test_incorrect_ia_kernel_lookup(OpcodesFunc apply_opcodes, + CheckFunc check_trace, + FF incorrect_ia, + auto expected_message) +{ + KernelInputs kernel_inputs = get_kernel_inputs(); + AvmTraceBuilder trace_builder(kernel_inputs); + + // We should return a value of 1 for the sender, as it exists at index 0 + apply_opcodes(trace_builder); + + trace_builder.halt(); + + auto trace = trace_builder.finalize(); + + // Change IA to be a value not in the lookup + // Change the first row, as that will be where each of the opcodes are in the test + auto& ta = trace.at(1); + + ta.avm_main_ia = incorrect_ia; + + check_trace(trace); + + EXPECT_THROW_WITH_MESSAGE(validate_trace_check_circuit(std::move(trace), kernel_inputs), expected_message); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaSender) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_sender(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_sender == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/SENDER_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaAddress) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_address(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_address == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/ADDRESS_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaPortal) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_portal(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_portal == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/PORTAL_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaFunction) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_function(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_function_selector == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/FUNCTION_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaDaGas) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_da_gas(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_da_gas == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/FEE_PER_DA_GAS_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaD1Gas) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l1_gas(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l1_gas == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/FEE_PER_L1_GAS_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIal2Gas) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l2_gas(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l2_gas == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/FEE_PER_L2_GAS_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + } // namespace tests_avm \ No newline at end of file From 9388ecc34306a397bfd9118ec20c38ed229efd29 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Mon, 29 Apr 2024 18:52:10 +0000 Subject: [PATCH 20/40] temp --- .../circuits.js/src/structs/public_circuit_public_inputs.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts b/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts index df93a84cd24..8c188cf4e72 100644 --- a/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts +++ b/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts @@ -38,6 +38,7 @@ import { SideEffect, SideEffectLinkedToNoteHash } from './side_effects.js'; /** * Public inputs to a public circuit. */ +// UH: SideEffect and ReadRequest are the same type? export class PublicCircuitPublicInputs { constructor( /** From 859a3dfbb52df90ee86e912b78c4265023c3c426 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Tue, 7 May 2024 19:05:58 +0000 Subject: [PATCH 21/40] chore: remove l1 gas - no longer exists --- barretenberg/cpp/pil/avm/constants.pil | 1 - .../relations/generated/avm/avm_kernel.hpp | 3 - .../relations/generated/avm/avm_main.hpp | 81 +++++++++++++++++-- .../vm/avm_trace/avm_kernel_trace.cpp | 5 -- .../vm/avm_trace/avm_kernel_trace.hpp | 5 +- .../barretenberg/vm/avm_trace/avm_trace.cpp | 9 --- .../barretenberg/vm/avm_trace/avm_trace.hpp | 1 - .../vm/generated/avm_circuit_builder.hpp | 5 -- .../barretenberg/vm/generated/avm_flavor.hpp | 2 - .../barretenberg/vm/tests/avm_kernel.test.cpp | 40 --------- .../src/barretenberg/vm/tests/spike.test.cpp | 2 +- 11 files changed, 76 insertions(+), 78 deletions(-) diff --git a/barretenberg/cpp/pil/avm/constants.pil b/barretenberg/cpp/pil/avm/constants.pil index ec162e4408d..8feb8c3ca85 100644 --- a/barretenberg/cpp/pil/avm/constants.pil +++ b/barretenberg/cpp/pil/avm/constants.pil @@ -7,5 +7,4 @@ namespace constants(256); pol PORTAL_SELECTOR = 2; pol FUNCTION_SELECTOR = 3; pol FEE_PER_DA_GAS_SELECTOR = 9; - pol FEE_PER_L1_GAS_SELECTOR = 11; pol FEE_PER_L2_GAS_SELECTOR = 13; \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp index 08584b34c04..fc6819de643 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp @@ -36,9 +36,6 @@ inline std::string get_relation_label_avm_kernel(int index) return "FEE_DA_GAS_KERNEL"; case 5: - return "FEE_L1_GAS_KERNEL"; - - case 6: return "FEE_L2_GAS_KERNEL"; } return std::to_string(index); diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp index 6a6055bafdb..f175c25dd45 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp @@ -7,6 +7,7 @@ namespace bb::Avm_vm { template struct Avm_mainRow { + FF avm_kernel_kernel_sel{}; FF avm_main_alu_in_tag{}; FF avm_main_alu_sel{}; FF avm_main_bin_op_id{}; @@ -133,9 +134,27 @@ inline std::string get_relation_label_avm_main(int index) return "MOV_MAIN_SAME_TAG"; case 80: - return "BIN_SEL_1"; + return "SENDER_KERNEL"; case 81: + return "ADDRESS_KERNEL"; + + case 82: + return "PORTAL_KERNEL"; + + case 83: + return "FUNCTION_KERNEL"; + + case 84: + return "FEE_DA_GAS_KERNEL"; + + case 85: + return "FEE_L2_GAS_KERNEL"; + + case 86: + return "BIN_SEL_1"; + + case 87: return "BIN_SEL_2"; } return std::to_string(index); @@ -145,10 +164,10 @@ template class avm_mainImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 4, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, }; template @@ -857,7 +876,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(80); - auto tmp = (avm_main_bin_op_id - (avm_main_sel_op_or + (avm_main_sel_op_xor * FF(2)))); + auto tmp = (avm_main_sel_op_sender * (avm_kernel_kernel_sel - FF(0))); tmp *= scaling_factor; std::get<80>(evals) += tmp; } @@ -865,10 +884,58 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(81); - auto tmp = (avm_main_bin_sel - ((avm_main_sel_op_and + avm_main_sel_op_or) + avm_main_sel_op_xor)); + auto tmp = (avm_main_sel_op_address * (avm_kernel_kernel_sel - FF(1))); tmp *= scaling_factor; std::get<81>(evals) += tmp; } + // Contribution 82 + { + Avm_DECLARE_VIEWS(82); + + auto tmp = (avm_main_sel_op_portal * (avm_kernel_kernel_sel - FF(2))); + tmp *= scaling_factor; + std::get<82>(evals) += tmp; + } + // Contribution 83 + { + Avm_DECLARE_VIEWS(83); + + auto tmp = (avm_main_sel_op_function_selector * (avm_kernel_kernel_sel - FF(3))); + tmp *= scaling_factor; + std::get<83>(evals) += tmp; + } + // Contribution 84 + { + Avm_DECLARE_VIEWS(84); + + auto tmp = (avm_main_sel_op_fee_per_da_gas * (avm_kernel_kernel_sel - FF(9))); + tmp *= scaling_factor; + std::get<84>(evals) += tmp; + } + // Contribution 85 + { + Avm_DECLARE_VIEWS(85); + + auto tmp = (avm_main_sel_op_fee_per_l2_gas * (avm_kernel_kernel_sel - FF(13))); + tmp *= scaling_factor; + std::get<85>(evals) += tmp; + } + // Contribution 86 + { + Avm_DECLARE_VIEWS(86); + + auto tmp = (avm_main_bin_op_id - (avm_main_sel_op_or + (avm_main_sel_op_xor * FF(2)))); + tmp *= scaling_factor; + std::get<86>(evals) += tmp; + } + // Contribution 87 + { + Avm_DECLARE_VIEWS(87); + + auto tmp = (avm_main_bin_sel - ((avm_main_sel_op_and + avm_main_sel_op_or) + avm_main_sel_op_xor)); + tmp *= scaling_factor; + std::get<87>(evals) += tmp; + } } }; diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp index 981a49fe994..4257dc00ab4 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp @@ -53,11 +53,6 @@ FF AvmKernelTraceBuilder::op_fee_per_da_gas() return perform_kernel_lookup(FEE_PER_DA_GAS_SELECTOR); } -FF AvmKernelTraceBuilder::op_fee_per_l1_gas() -{ - return perform_kernel_lookup(FEE_PER_L1_GAS_SELECTOR); -} - FF AvmKernelTraceBuilder::op_fee_per_l2_gas() { return perform_kernel_lookup(FEE_PER_L2_GAS_SELECTOR); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp index a74560927b8..1b63f2171a6 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp @@ -12,13 +12,11 @@ inline const uint32_t PORTAL_SELECTOR = 2; inline const uint32_t FUNCTION_SELECTOR = 3; // TODO: double check that these indexes are correct inline const uint32_t FEE_PER_DA_GAS_SELECTOR = 9; -inline const uint32_t FEE_PER_L1_GAS_SELECTOR = 11; inline const uint32_t FEE_PER_L2_GAS_SELECTOR = 13; const std::array KERNEL_INPUTS_SELECTORS = { SENDER_SELECTOR, ADDRESS_SELECTOR, PORTAL_SELECTOR, FUNCTION_SELECTOR, - FEE_PER_DA_GAS_SELECTOR, FEE_PER_L1_GAS_SELECTOR, - FEE_PER_L2_GAS_SELECTOR }; + FEE_PER_DA_GAS_SELECTOR, FEE_PER_L2_GAS_SELECTOR }; namespace bb::avm_trace { @@ -45,7 +43,6 @@ class AvmKernelTraceBuilder { FF op_portal(); FF op_function(); FF op_fee_per_da_gas(); - FF op_fee_per_l1_gas(); FF op_fee_per_l2_gas(); private: diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp index f144926b677..0469efd4994 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -1129,15 +1129,6 @@ void AvmTraceBuilder::op_fee_per_da_gas(uint32_t dst_offset) main_trace.push_back(row); } -void AvmTraceBuilder::op_fee_per_l1_gas(uint32_t dst_offset) -{ - FF ia_value = kernel_trace_builder.op_fee_per_l1_gas(); - Row row = create_kernel_lookup_opcode(dst_offset, FEE_PER_L1_GAS_SELECTOR, ia_value); - row.avm_main_sel_op_fee_per_l1_gas = FF(1); - - main_trace.push_back(row); -} - void AvmTraceBuilder::op_fee_per_l2_gas(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_fee_per_l2_gas(); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp index 4b89e660c5a..ed5d79c5f30 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp @@ -86,7 +86,6 @@ class AvmTraceBuilder { void op_portal(uint32_t dst_offset); void op_function(uint32_t dst_offset); void op_fee_per_da_gas(uint32_t dst_offset); - void op_fee_per_l1_gas(uint32_t dst_offset); void op_fee_per_l2_gas(uint32_t dst_offset); // Cast an element pointed by the address a_offset into type specified by dst_tag and // store the result in address given by dst_offset. diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index d5a8ea609e6..901ee9df14a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -13,7 +13,6 @@ #include "barretenberg/relations/generated/avm/avm_alu.hpp" #include "barretenberg/relations/generated/avm/avm_binary.hpp" -#include "barretenberg/relations/generated/avm/avm_kernel.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" #include "barretenberg/relations/generated/avm/avm_mem.hpp" #include "barretenberg/relations/generated/avm/incl_main_tag_err.hpp" @@ -728,10 +727,6 @@ class AvmCircuitBuilder { Avm_vm::get_relation_label_avm_binary)) { return false; } - if (!evaluate_relation.template operator()>("avm_kernel", - Avm_vm::get_relation_label_avm_kernel)) { - return false; - } if (!evaluate_relation.template operator()>("avm_main", Avm_vm::get_relation_label_avm_main)) { return false; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 48e0a3f2b55..aa5ea70c6d0 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -15,7 +15,6 @@ #include "barretenberg/polynomials/polynomial.hpp" #include "barretenberg/relations/generated/avm/avm_alu.hpp" #include "barretenberg/relations/generated/avm/avm_binary.hpp" -#include "barretenberg/relations/generated/avm/avm_kernel.hpp" #include "barretenberg/relations/generated/avm/avm_main.hpp" #include "barretenberg/relations/generated/avm/avm_mem.hpp" #include "barretenberg/relations/generated/avm/incl_main_tag_err.hpp" @@ -120,7 +119,6 @@ class AvmFlavor { using Relations = std::tuple, Avm_vm::avm_binary, - Avm_vm::avm_kernel, Avm_vm::avm_main, Avm_vm::avm_mem, perm_main_alu_relation, diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp index 546e200d457..da89a0145c5 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -156,24 +156,6 @@ TEST_F(AvmKernelPositiveTests, kernelFeePerDa) test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmKernelPositiveTests, kernelFeePerL1) -{ - uint32_t dst_offset = 42; - auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l1_gas(dst_offset); }; - auto checks = [=](const std::vector& trace) { - std::vector::const_iterator fee_row = std::ranges::find_if( - trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l1_gas == FF(1); }); - EXPECT_TRUE(fee_row != trace.end()); - - expect_row(fee_row, - /*kernel_sel=*/FEE_PER_L1_GAS_SELECTOR, - /*ia=*/FEE_PER_L1_GAS_SELECTOR + - 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); - }; - test_kernel_lookup(apply_opcodes, checks); -} - TEST_F(AvmKernelPositiveTests, kernelFeePerL2) { uint32_t dst_offset = 42; @@ -334,28 +316,6 @@ TEST_F(AvmKernelNegativeTests, incorrectIaDaGas) negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); } -TEST_F(AvmKernelNegativeTests, incorrectIaD1Gas) -{ - uint32_t dst_offset = 42; - FF incorrect_ia = FF(69); - - // We test that the sender opcode is inlcuded at index x in the public inputs - auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l1_gas(dst_offset); }; - auto checks = [=](const std::vector& trace) { - std::vector::const_iterator sender_row = std::ranges::find_if( - trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l1_gas == FF(1); }); - EXPECT_TRUE(sender_row != trace.end()); - - expect_row( - sender_row, - /*kernel_sel=*/FEE_PER_L1_GAS_SELECTOR, - /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); - }; - - negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); -} - TEST_F(AvmKernelNegativeTests, incorrectIal2Gas) { uint32_t dst_offset = 42; diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp index 1b30f1f4a6c..53bf8e31bbf 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/spike.test.cpp @@ -40,7 +40,7 @@ bool verify_spike_with_public_with_public_inputs(std::vector ve // Add to the public input column that is increasing for (size_t i = 0; i < circuit_size; i++) { // Make sure the external and trace public inputs are the same - Row row{ .Spike_kernel_inputs = i + 1 }; + Row row{ .Spike_kernel_inputs__is_public = i + 1 }; rows.push_back(row); } From b4a47b364846bd8a09e06fd2f4d6ecd33e9fb470 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Tue, 7 May 2024 19:06:24 +0000 Subject: [PATCH 22/40] chore: rearrange where relations live, based on review --- barretenberg/cpp/pil/avm/avm_kernel.pil | 30 ------------------------- barretenberg/cpp/pil/avm/avm_main.pil | 29 ++++++++++++++++++++++++ 2 files changed, 29 insertions(+), 30 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_kernel.pil b/barretenberg/cpp/pil/avm/avm_kernel.pil index 3e2a553f5f3..2339ff5715e 100644 --- a/barretenberg/cpp/pil/avm/avm_kernel.pil +++ b/barretenberg/cpp/pil/avm/avm_kernel.pil @@ -5,36 +5,6 @@ namespace avm_kernel(256); pol public kernel_inputs; pol commit kernel_sel; - // The general pattern for environment lookups is as follows: - // Each kernel opcode related to some fixed positions in the `public kernel_inputs` polynomial - // We can lookup into a fixed index of this polynomial by including constraints that force the value - // of kernel_sel to the value relevant to the given opcode that is active - - #[SENDER_KERNEL] - avm_main.sel_op_sender * (kernel_sel - constants.SENDER_SELECTOR) = 0; - - #[ADDRESS_KERNEL] - avm_main.sel_op_address * (kernel_sel - constants.ADDRESS_SELECTOR) = 0; - - #[PORTAL_KERNEL] - avm_main.sel_op_portal * (kernel_sel - constants.PORTAL_SELECTOR) = 0; - - #[FUNCTION_KERNEL] - avm_main.sel_op_function_selector * (kernel_sel - constants.FUNCTION_SELECTOR) = 0; - - #[FEE_DA_GAS_KERNEL] - avm_main.sel_op_fee_per_da_gas * (kernel_sel - constants.FEE_PER_DA_GAS_SELECTOR) = 0; - - #[FEE_L1_GAS_KERNEL] - avm_main.sel_op_fee_per_l1_gas * (kernel_sel - constants.FEE_PER_L1_GAS_SELECTOR) = 0; - - #[FEE_L2_GAS_KERNEL] - avm_main.sel_op_fee_per_l2_gas * (kernel_sel - constants.FEE_PER_L2_GAS_SELECTOR) = 0; - // Note: in the future, with some codegen adjustments, this column will not be needed // as we can just add every entry in the public kernel_inputs to the lookup table pol commit q_public_input_kernel_add_to_table; - - #[LOOKUP_INTO_KERNEL] - // TODO: FIX not having the trailing is_public breaking compilation :( - avm_main.q_kernel_lookup { avm_main.ia, kernel_sel } in q_public_input_kernel_add_to_table { kernel_inputs__is_public, avm_main.clk }; diff --git a/barretenberg/cpp/pil/avm/avm_main.pil b/barretenberg/cpp/pil/avm/avm_main.pil index 69e4fec55b3..7acf4f2b5d4 100644 --- a/barretenberg/cpp/pil/avm/avm_main.pil +++ b/barretenberg/cpp/pil/avm/avm_main.pil @@ -372,6 +372,35 @@ namespace avm_main(256); ALU_R_TAG_SEL * (alu_in_tag - r_in_tag) = 0; ALU_W_TAG_SEL * (alu_in_tag - w_in_tag) = 0; + + //===== KERNEL INPUTS CONSTRAINTS =========================================== + // The general pattern for environment lookups is as follows: + // Each kernel opcode related to some fixed positions in the `public kernel_inputs` polynomial + // We can lookup into a fixed index of this polynomial by including constraints that force the value + // of kernel_sel to the value relevant to the given opcode that is active + + #[SENDER_KERNEL] + sel_op_sender * (avm_kernel.kernel_sel - constants.SENDER_SELECTOR) = 0; + + #[ADDRESS_KERNEL] + sel_op_address * (avm_kernel.kernel_sel - constants.ADDRESS_SELECTOR) = 0; + + #[PORTAL_KERNEL] + sel_op_portal * (avm_kernel.kernel_sel - constants.PORTAL_SELECTOR) = 0; + + #[FUNCTION_KERNEL] + sel_op_function_selector * (avm_kernel.kernel_sel - constants.FUNCTION_SELECTOR) = 0; + + #[FEE_DA_GAS_KERNEL] + sel_op_fee_per_da_gas * (avm_kernel.kernel_sel - constants.FEE_PER_DA_GAS_SELECTOR) = 0; + + #[FEE_L2_GAS_KERNEL] + sel_op_fee_per_l2_gas * (avm_kernel.kernel_sel - constants.FEE_PER_L2_GAS_SELECTOR) = 0; + + #[LOOKUP_INTO_KERNEL] + // TODO: FIX not having the trailing is_public breaking compilation :( + q_kernel_lookup { avm_main.ia, avm_kernel.kernel_sel } in avm_kernel.q_public_input_kernel_add_to_table { avm_kernel.kernel_inputs__is_public, clk }; + //====== Inter-table Constraints ============================================ #[INCL_MAIN_TAG_ERR] avm_mem.tag_err {avm_mem.clk} in tag_err {clk}; From faac5b1a66377f429b122615f9cfb6e30088efcc Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Tue, 7 May 2024 19:09:44 +0000 Subject: [PATCH 23/40] chore: update codegen --- .../src/barretenberg/vm/generated/avm_flavor.hpp | 1 + .../src/barretenberg/vm/generated/avm_verifier.cpp | 2 ++ .../src/barretenberg/vm/generated/spike_flavor.hpp | 13 +++++++++++-- 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index 08c3cffd783..1c4a3f71cf1 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -1765,6 +1765,7 @@ class AvmFlavor { * @details During folding and sumcheck, the prover evaluates the relations on these univariates. */ template using ProverUnivariates = AllEntities>; + /** * @brief A container for univariates used during Protogalaxy folding and sumcheck with some of the computation * optmistically ignored diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 89f357cc400..58de8829d38 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -3,9 +3,11 @@ #include "./avm_verifier.hpp" #include "barretenberg/commitment_schemes/zeromorph/zeromorph.hpp" #include "barretenberg/numeric/bitop/get_msb.hpp" +#include "barretenberg/polynomials/polynomial.hpp" #include "barretenberg/transcript/transcript.hpp" namespace bb { + AvmVerifier::AvmVerifier(std::shared_ptr verifier_key) : key(verifier_key) {} diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp index 994ca15d548..b841904764d 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/spike_flavor.hpp @@ -90,10 +90,11 @@ class SpikeFlavor { }; public: - class ProvingKey : public ProvingKey_, WitnessEntities, CommitmentKey> { + class ProvingKey + : public ProvingKeyAvm_, WitnessEntities, CommitmentKey> { public: // Expose constructors on the base class - using Base = ProvingKey_, WitnessEntities, CommitmentKey>; + using Base = ProvingKeyAvm_, WitnessEntities, CommitmentKey>; using Base::Base; RefVector get_to_be_shifted() { return {}; }; @@ -169,6 +170,14 @@ class SpikeFlavor { */ template using ProverUnivariates = AllEntities>; + /** + * @brief A container for univariates used during Protogalaxy folding and sumcheck with some of the computation + * optmistically ignored + * @details During folding and sumcheck, the prover evaluates the relations on these univariates. + */ + template + using OptimisedProverUnivariates = AllEntities>; + /** * @brief A container for univariates produced during the hot loop in sumcheck. */ From 4bb42b821cc0bf980ea18446096949d07030d54d Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Wed, 8 May 2024 18:40:26 +0000 Subject: [PATCH 24/40] feat: add cpp constants gen to calculate kernel offsets --- barretenberg/cpp/pil/avm/constants.pil | 24 ++- .../vm/avm_trace/aztec_constants.hpp | 141 ++++++++++++++++++ .../barretenberg/vm/avm_trace/constants.hpp | 4 +- .../src/core/libraries/ConstantsGen.sol | 57 ++----- .../crates/types/src/constants.nr | 1 + yarn-project/circuits.js/src/constants.gen.ts | 2 + .../circuits.js/src/scripts/constants.in.ts | 39 +++++ 7 files changed, 222 insertions(+), 46 deletions(-) create mode 100644 barretenberg/cpp/src/barretenberg/vm/avm_trace/aztec_constants.hpp diff --git a/barretenberg/cpp/pil/avm/constants.pil b/barretenberg/cpp/pil/avm/constants.pil index 8feb8c3ca85..609b6d827e3 100644 --- a/barretenberg/cpp/pil/avm/constants.pil +++ b/barretenberg/cpp/pil/avm/constants.pil @@ -2,9 +2,29 @@ // NOTE: the constants in this file line up to the indexes of values in the // `PublicKernelInputs.nr` object namespace constants(256); + // From Public Context Inputs pol SENDER_SELECTOR = 0; pol ADDRESS_SELECTOR = 1; pol PORTAL_SELECTOR = 2; pol FUNCTION_SELECTOR = 3; - pol FEE_PER_DA_GAS_SELECTOR = 9; - pol FEE_PER_L2_GAS_SELECTOR = 13; \ No newline at end of file + + // NOTE: constant expression evaluation does not seem to be supported yet in pil + // pol START_GLOBAL_VARIABLES = CALL_CONTEXT_LENGTH + HEADER_LENGTH = 6 + 22 = 28 + + // Global Variables + pol CHAIN_ID_SELECTOR = 28; + pol VERSION_SELECTOR = 29; + pol BLOCK_NUMBER_SELECTOR = 30; + pol TIMESTAMP_SELECTOR = 31; + pol COINBASE_SELECTOR = 32; + + pol END_GLOBAL_VARIABLES = 28 + 8; // We only use the first 5 of 8 global variables for now + + pol START_SIDE_EFFECT_COUNTER = 36; + + // Gas + pol FEE_PER_DA_GAS_SELECTOR = 37; + pol FEE_PER_L2_GAS_SELECTOR = 38; + + pol TRANSACTION_FEE_SELECTOR = 39; + diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/aztec_constants.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/aztec_constants.hpp new file mode 100644 index 00000000000..060d6776cb1 --- /dev/null +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/aztec_constants.hpp @@ -0,0 +1,141 @@ +// GENERATED FILE - DO NOT EDIT, RUN yarn remake-constants in circuits.js +#pragma once +#include + +const size_t ARGS_LENGTH = 16; +const size_t MAX_NEW_NOTE_HASHES_PER_CALL = 16; +const size_t MAX_NEW_NULLIFIERS_PER_CALL = 16; +const size_t MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL = 4; +const size_t MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL = 16; +const size_t MAX_NEW_L2_TO_L1_MSGS_PER_CALL = 2; +const size_t MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL = 16; +const size_t MAX_PUBLIC_DATA_READS_PER_CALL = 16; +const size_t MAX_NOTE_HASH_READ_REQUESTS_PER_CALL = 32; +const size_t MAX_NULLIFIER_READ_REQUESTS_PER_CALL = 2; +const size_t MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL = 2; +const size_t MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL = 1; +const size_t MAX_ENCRYPTED_LOGS_PER_CALL = 4; +const size_t MAX_UNENCRYPTED_LOGS_PER_CALL = 4; +const size_t MAX_NEW_NOTE_HASHES_PER_TX = 64; +const size_t MAX_NEW_NULLIFIERS_PER_TX = 64; +const size_t MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX = 8; +const size_t MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX = 32; +const size_t MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX = 32; +const size_t MAX_PUBLIC_DATA_READS_PER_TX = 32; +const size_t MAX_NEW_L2_TO_L1_MSGS_PER_TX = 2; +const size_t MAX_NOTE_HASH_READ_REQUESTS_PER_TX = 128; +const size_t MAX_NULLIFIER_READ_REQUESTS_PER_TX = 8; +const size_t MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX = 8; +const size_t MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX = 4; +const size_t MAX_ENCRYPTED_LOGS_PER_TX = 8; +const size_t MAX_UNENCRYPTED_LOGS_PER_TX = 8; +const size_t NUM_ENCRYPTED_LOGS_HASHES_PER_TX = 1; +const size_t NUM_UNENCRYPTED_LOGS_HASHES_PER_TX = 1; +const size_t MAX_PUBLIC_DATA_HINTS = 64; +const size_t NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP = 16; +const size_t VK_TREE_HEIGHT = 3; +const size_t FUNCTION_TREE_HEIGHT = 5; +const size_t NOTE_HASH_TREE_HEIGHT = 32; +const size_t PUBLIC_DATA_TREE_HEIGHT = 40; +const size_t NULLIFIER_TREE_HEIGHT = 20; +const size_t L1_TO_L2_MSG_TREE_HEIGHT = 16; +const size_t ROLLUP_VK_TREE_HEIGHT = 8; +const size_t ARTIFACT_FUNCTION_TREE_MAX_HEIGHT = 5; +const size_t NULLIFIER_TREE_ID = 0; +const size_t NOTE_HASH_TREE_ID = 1; +const size_t PUBLIC_DATA_TREE_ID = 2; +const size_t L1_TO_L2_MESSAGE_TREE_ID = 3; +const size_t ARCHIVE_TREE_ID = 4; +const size_t NOTE_HASH_SUBTREE_HEIGHT = 6; +const size_t NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH = 26; +const size_t NULLIFIER_SUBTREE_HEIGHT = 6; +const size_t PUBLIC_DATA_SUBTREE_HEIGHT = 5; +const size_t ARCHIVE_HEIGHT = 16; +const size_t NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH = 14; +const size_t PUBLIC_DATA_SUBTREE_SIBLING_PATH_LENGTH = 35; +const size_t L1_TO_L2_MSG_SUBTREE_HEIGHT = 4; +const size_t L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH = 12; +const size_t FUNCTION_SELECTOR_NUM_BYTES = 4; +const size_t ARGS_HASH_CHUNK_LENGTH = 64; +const size_t ARGS_HASH_CHUNK_COUNT = 64; +const size_t MAX_ARGS_LENGTH = ARGS_HASH_CHUNK_COUNT * ARGS_HASH_CHUNK_LENGTH; +const size_t INITIAL_L2_BLOCK_NUM = 1; +const size_t BLOB_SIZE_IN_BYTES = 31 * 4096; +const size_t NESTED_CALL_L2_GAS_BUFFER = 20000; +const size_t MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS = 16200; +const size_t MAX_PACKED_BYTECODE_SIZE_PER_PRIVATE_FUNCTION_IN_FIELDS = 3000; +const size_t MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS = 3000; +const size_t REGISTERER_PRIVATE_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS = 19; +const size_t REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS = 12; +const size_t DEFAULT_MAX_FEE_PER_GAS = 10; +const size_t DEFAULT_INCLUSION_FEE = 0; +const size_t DA_BYTES_PER_FIELD = 32; +const size_t DA_GAS_PER_BYTE = 16; +const size_t FIXED_DA_GAS = 512; +const size_t AZTEC_ADDRESS_LENGTH = 1; +const size_t GAS_FEES_LENGTH = 2; +const size_t GAS_LENGTH = 2; +const size_t GAS_SETTINGS_LENGTH = GAS_LENGTH * 2 + GAS_FEES_LENGTH + /* inclusion_fee */ 1; +const size_t CALL_CONTEXT_LENGTH = 6; +const size_t CONTENT_COMMITMENT_LENGTH = 4; +const size_t CONTRACT_INSTANCE_LENGTH = 5; +const size_t CONTRACT_STORAGE_READ_LENGTH = 2; +const size_t CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH = 2; +const size_t ETH_ADDRESS_LENGTH = 1; +const size_t FUNCTION_DATA_LENGTH = 2; +const size_t FUNCTION_LEAF_PREIMAGE_LENGTH = 5; +const size_t GLOBAL_VARIABLES_LENGTH = 6 + GAS_FEES_LENGTH; +const size_t APPEND_ONLY_TREE_SNAPSHOT_LENGTH = 2; +const size_t L1_TO_L2_MESSAGE_LENGTH = 6; +const size_t L2_TO_L1_MESSAGE_LENGTH = 2; +const size_t MAX_BLOCK_NUMBER_LENGTH = 2; +const size_t NULLIFIER_KEY_VALIDATION_REQUEST_LENGTH = 3; +const size_t NULLIFIER_KEY_VALIDATION_REQUEST_CONTEXT_LENGTH = 4; +const size_t PARTIAL_STATE_REFERENCE_LENGTH = 6; +const size_t READ_REQUEST_LENGTH = 2; +const size_t NOTE_HASH_LENGTH = 2; +const size_t NOTE_HASH_CONTEXT_LENGTH = 3; +const size_t NULLIFIER_LENGTH = 3; +const size_t SIDE_EFFECT_LENGTH = 2; +const size_t STATE_REFERENCE_LENGTH = APPEND_ONLY_TREE_SNAPSHOT_LENGTH + PARTIAL_STATE_REFERENCE_LENGTH; +const size_t TX_CONTEXT_LENGTH = 2 + GAS_SETTINGS_LENGTH; +const size_t TX_REQUEST_LENGTH = 2 + TX_CONTEXT_LENGTH + FUNCTION_DATA_LENGTH; +const size_t HEADER_LENGTH = + APPEND_ONLY_TREE_SNAPSHOT_LENGTH + CONTENT_COMMITMENT_LENGTH + STATE_REFERENCE_LENGTH + GLOBAL_VARIABLES_LENGTH; +const size_t PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = + CALL_CONTEXT_LENGTH + 3 + MAX_BLOCK_NUMBER_LENGTH + (READ_REQUEST_LENGTH * MAX_NOTE_HASH_READ_REQUESTS_PER_CALL) + + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + + (NULLIFIER_KEY_VALIDATION_REQUEST_LENGTH * MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL) + + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + 1 + + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + + (SIDE_EFFECT_LENGTH * MAX_ENCRYPTED_LOGS_PER_CALL) + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 2 + + HEADER_LENGTH + TX_CONTEXT_LENGTH; +const size_t PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = + CALL_CONTEXT_LENGTH + 2 + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + + (READ_REQUEST_LENGTH * MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL) + + (CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH * MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL) + + (CONTRACT_STORAGE_READ_LENGTH * MAX_PUBLIC_DATA_READS_PER_CALL) + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 1 + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + + AZTEC_ADDRESS_LENGTH + /* revert_code */ 1 + 2 * GAS_LENGTH + /* transaction_fee */ 1; +const size_t PRIVATE_CALL_STACK_ITEM_LENGTH = + AZTEC_ADDRESS_LENGTH + FUNCTION_DATA_LENGTH + PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH; +const size_t PUBLIC_CONTEXT_INPUTS_LENGTH = + CALL_CONTEXT_LENGTH + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + GAS_LENGTH + 2; +const size_t ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH = 2 + FUNCTION_DATA_LENGTH + CALL_CONTEXT_LENGTH; +const size_t GET_NOTES_ORACLE_RETURN_LENGTH = 674; +const size_t NOTE_HASHES_NUM_BYTES_PER_BASE_ROLLUP = 2048; +const size_t NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP = 2048; +const size_t PUBLIC_DATA_WRITES_NUM_BYTES_PER_BASE_ROLLUP = 2048; +const size_t CONTRACTS_NUM_BYTES_PER_BASE_ROLLUP = 32; +const size_t CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP = 64; +const size_t CONTRACT_DATA_NUM_BYTES_PER_BASE_ROLLUP_UNPADDED = 52; +const size_t L2_TO_L1_MSGS_NUM_BYTES_PER_BASE_ROLLUP = 64; +const size_t LOGS_HASHES_NUM_BYTES_PER_BASE_ROLLUP = 64; +const size_t NUM_MSGS_PER_BASE_PARITY = 4; +const size_t NUM_BASE_PARITY_PER_ROOT_PARITY = 4; +const size_t RECURSIVE_PROOF_LENGTH = 93; +const size_t NESTED_RECURSIVE_PROOF_LENGTH = 109; +const size_t VERIFICATION_KEY_LENGTH_IN_FIELDS = 114; diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/constants.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/constants.hpp index 2bb819bea0c..6b0acc1c3df 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/constants.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/constants.hpp @@ -1,6 +1,8 @@ #pragma once +#include "aztec_constants.hpp" #include // NOTE(MD): for now we will only include the public inputs that are included in call_context // With more being added in subsequent prs -inline const std::size_t KERNEL_INPUTS_LENGTH = 18; \ No newline at end of file +// KERNEL_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + +inline const std::size_t KERNEL_INPUTS_LENGTH = PUBLIC_CONTEXT_INPUTS_LENGTH; \ No newline at end of file diff --git a/l1-contracts/src/core/libraries/ConstantsGen.sol b/l1-contracts/src/core/libraries/ConstantsGen.sol index 8a9200aaee6..1c6ca490bdd 100644 --- a/l1-contracts/src/core/libraries/ConstantsGen.sol +++ b/l1-contracts/src/core/libraries/ConstantsGen.sol @@ -80,16 +80,11 @@ library Constants { uint256 internal constant MAX_PACKED_BYTECODE_SIZE_PER_UNCONSTRAINED_FUNCTION_IN_FIELDS = 3000; uint256 internal constant REGISTERER_PRIVATE_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS = 19; uint256 internal constant REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_ADDITIONAL_FIELDS = 12; - uint256 internal constant REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE = - 0x6999d1e02b08a447a463563453cb36919c9dd7150336fc7c4d2b52f8; - uint256 internal constant REGISTERER_PRIVATE_FUNCTION_BROADCASTED_MAGIC_VALUE = - 0x1b70e95fde0b70adc30496b90a327af6a5e383e028e7a43211a07bcd; - uint256 internal constant REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_MAGIC_VALUE = - 0xe7af816635466f128568edb04c9fa024f6c87fb9010fdbffa68b3d99; - uint256 internal constant DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE = - 0x85864497636cf755ae7bde03f267ce01a520981c21c3682aaf82a631; - uint256 internal constant DEPLOYER_CONTRACT_ADDRESS = - 0x0097949bb96834550868230a1b6cc242d1f662f7c52946245e4e73da1b8b2165; + uint256 internal constant REGISTERER_CONTRACT_CLASS_REGISTERED_MAGIC_VALUE = 0x6999d1e02b08a447a463563453cb36919c9dd7150336fc7c4d2b52f8; + uint256 internal constant REGISTERER_PRIVATE_FUNCTION_BROADCASTED_MAGIC_VALUE = 0x1b70e95fde0b70adc30496b90a327af6a5e383e028e7a43211a07bcd; + uint256 internal constant REGISTERER_UNCONSTRAINED_FUNCTION_BROADCASTED_MAGIC_VALUE = 0xe7af816635466f128568edb04c9fa024f6c87fb9010fdbffa68b3d99; + uint256 internal constant DEPLOYER_CONTRACT_INSTANCE_DEPLOYED_MAGIC_VALUE = 0x85864497636cf755ae7bde03f267ce01a520981c21c3682aaf82a631; + uint256 internal constant DEPLOYER_CONTRACT_ADDRESS = 0x0097949bb96834550868230a1b6cc242d1f662f7c52946245e4e73da1b8b2165; uint256 internal constant DEFAULT_GAS_LIMIT = 1_000_000_000; uint256 internal constant DEFAULT_TEARDOWN_GAS_LIMIT = 100_000_000; uint256 internal constant DEFAULT_MAX_FEE_PER_GAS = 10; @@ -97,13 +92,11 @@ library Constants { uint256 internal constant DA_BYTES_PER_FIELD = 32; uint256 internal constant DA_GAS_PER_BYTE = 16; uint256 internal constant FIXED_DA_GAS = 512; - uint256 internal constant CANONICAL_KEY_REGISTRY_ADDRESS = - 0x1585e564a60e6ec974bc151b62705292ebfc75c33341986a47fd9749cedb567e; + uint256 internal constant CANONICAL_KEY_REGISTRY_ADDRESS = 0x1585e564a60e6ec974bc151b62705292ebfc75c33341986a47fd9749cedb567e; uint256 internal constant AZTEC_ADDRESS_LENGTH = 1; uint256 internal constant GAS_FEES_LENGTH = 2; uint256 internal constant GAS_LENGTH = 2; - uint256 internal constant GAS_SETTINGS_LENGTH = - GAS_LENGTH * 2 + GAS_FEES_LENGTH /* inclusion_fee */ + 1; + uint256 internal constant GAS_SETTINGS_LENGTH = GAS_LENGTH * 2 + GAS_FEES_LENGTH + /* inclusion_fee */ 1; uint256 internal constant CALL_CONTEXT_LENGTH = 6; uint256 internal constant CONTENT_COMMITMENT_LENGTH = 4; uint256 internal constant CONTRACT_INSTANCE_LENGTH = 5; @@ -125,37 +118,15 @@ library Constants { uint256 internal constant NOTE_HASH_CONTEXT_LENGTH = 3; uint256 internal constant NULLIFIER_LENGTH = 3; uint256 internal constant SIDE_EFFECT_LENGTH = 2; - uint256 internal constant STATE_REFERENCE_LENGTH = - APPEND_ONLY_TREE_SNAPSHOT_LENGTH + PARTIAL_STATE_REFERENCE_LENGTH; + uint256 internal constant STATE_REFERENCE_LENGTH = APPEND_ONLY_TREE_SNAPSHOT_LENGTH + PARTIAL_STATE_REFERENCE_LENGTH; uint256 internal constant TX_CONTEXT_LENGTH = 2 + GAS_SETTINGS_LENGTH; uint256 internal constant TX_REQUEST_LENGTH = 2 + TX_CONTEXT_LENGTH + FUNCTION_DATA_LENGTH; - uint256 internal constant HEADER_LENGTH = APPEND_ONLY_TREE_SNAPSHOT_LENGTH - + CONTENT_COMMITMENT_LENGTH + STATE_REFERENCE_LENGTH + GLOBAL_VARIABLES_LENGTH; - uint256 internal constant PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 3 - + MAX_BLOCK_NUMBER_LENGTH + (READ_REQUEST_LENGTH * MAX_NOTE_HASH_READ_REQUESTS_PER_CALL) - + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) - + (NULLIFIER_KEY_VALIDATION_REQUEST_LENGTH * MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL) - + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) - + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL - + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + 1 - + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 - + (SIDE_EFFECT_LENGTH * MAX_ENCRYPTED_LOGS_PER_CALL) - + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 2 + HEADER_LENGTH + TX_CONTEXT_LENGTH; - uint256 internal constant PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 2 - + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) - + (READ_REQUEST_LENGTH * MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL) - + (CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH * MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL) - + (CONTRACT_STORAGE_READ_LENGTH * MAX_PUBLIC_DATA_READS_PER_CALL) - + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) - + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) - + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 - + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 1 + HEADER_LENGTH - + GLOBAL_VARIABLES_LENGTH + AZTEC_ADDRESS_LENGTH /* revert_code */ + 1 + 2 * GAS_LENGTH /* transaction_fee */ - + 1; - uint256 internal constant PRIVATE_CALL_STACK_ITEM_LENGTH = - AZTEC_ADDRESS_LENGTH + FUNCTION_DATA_LENGTH + PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH; - uint256 internal constant ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH = - 2 + FUNCTION_DATA_LENGTH + CALL_CONTEXT_LENGTH; + uint256 internal constant HEADER_LENGTH = APPEND_ONLY_TREE_SNAPSHOT_LENGTH + CONTENT_COMMITMENT_LENGTH + STATE_REFERENCE_LENGTH + GLOBAL_VARIABLES_LENGTH; + uint256 internal constant PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 3 + MAX_BLOCK_NUMBER_LENGTH + (READ_REQUEST_LENGTH * MAX_NOTE_HASH_READ_REQUESTS_PER_CALL) + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + (NULLIFIER_KEY_VALIDATION_REQUEST_LENGTH * MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL) + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + 1 + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + (SIDE_EFFECT_LENGTH * MAX_ENCRYPTED_LOGS_PER_CALL) + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 2 + HEADER_LENGTH + TX_CONTEXT_LENGTH; + uint256 internal constant PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 2 + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + (READ_REQUEST_LENGTH * MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL) + (CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH * MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL) + (CONTRACT_STORAGE_READ_LENGTH * MAX_PUBLIC_DATA_READS_PER_CALL) + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 1 + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + AZTEC_ADDRESS_LENGTH + /* revert_code */ 1 + 2 * GAS_LENGTH + /* transaction_fee */ 1; + uint256 internal constant PRIVATE_CALL_STACK_ITEM_LENGTH = AZTEC_ADDRESS_LENGTH + FUNCTION_DATA_LENGTH + PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH; + uint256 internal constant PUBLIC_CONTEXT_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + GAS_LENGTH + 2; + uint256 internal constant ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH = 2 + FUNCTION_DATA_LENGTH + CALL_CONTEXT_LENGTH; uint256 internal constant GET_NOTES_ORACLE_RETURN_LENGTH = 674; uint256 internal constant NOTE_HASHES_NUM_BYTES_PER_BASE_ROLLUP = 2048; uint256 internal constant NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP = 2048; diff --git a/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr b/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr index ad82df9c822..42e091455cf 100644 --- a/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr +++ b/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr @@ -172,6 +172,7 @@ global HEADER_LENGTH: u64 = APPEND_ONLY_TREE_SNAPSHOT_LENGTH + CONTENT_COMMITMEN global PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH: u64 = CALL_CONTEXT_LENGTH + 3 + MAX_BLOCK_NUMBER_LENGTH + (READ_REQUEST_LENGTH * MAX_NOTE_HASH_READ_REQUESTS_PER_CALL) + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + (NULLIFIER_KEY_VALIDATION_REQUEST_LENGTH * MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL) + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + 1 + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + (SIDE_EFFECT_LENGTH * MAX_ENCRYPTED_LOGS_PER_CALL) + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 2 + HEADER_LENGTH + TX_CONTEXT_LENGTH; global PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH: u64 = CALL_CONTEXT_LENGTH + 2 + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + (READ_REQUEST_LENGTH * MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL) + (CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH * MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL) + (CONTRACT_STORAGE_READ_LENGTH * MAX_PUBLIC_DATA_READS_PER_CALL) + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 1 + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + AZTEC_ADDRESS_LENGTH + /* revert_code */ 1 + 2 * GAS_LENGTH + /* transaction_fee */ 1; global PRIVATE_CALL_STACK_ITEM_LENGTH: u64 = AZTEC_ADDRESS_LENGTH + FUNCTION_DATA_LENGTH + PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH; +global PUBLIC_CONTEXT_INPUTS_LENGTH: u64 = CALL_CONTEXT_LENGTH + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + GAS_LENGTH + 2; global ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH: u64 = 2 + FUNCTION_DATA_LENGTH + CALL_CONTEXT_LENGTH; global GET_NOTES_ORACLE_RETURN_LENGTH: u64 = 674; diff --git a/yarn-project/circuits.js/src/constants.gen.ts b/yarn-project/circuits.js/src/constants.gen.ts index 70d3975bfea..b36146a8505 100644 --- a/yarn-project/circuits.js/src/constants.gen.ts +++ b/yarn-project/circuits.js/src/constants.gen.ts @@ -154,6 +154,8 @@ export const PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = /* transaction_fee */ 1; export const PRIVATE_CALL_STACK_ITEM_LENGTH = AZTEC_ADDRESS_LENGTH + FUNCTION_DATA_LENGTH + PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH; +export const PUBLIC_CONTEXT_INPUTS_LENGTH = + CALL_CONTEXT_LENGTH + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + GAS_LENGTH + 2; export const ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH = 2 + FUNCTION_DATA_LENGTH + CALL_CONTEXT_LENGTH; export const GET_NOTES_ORACLE_RETURN_LENGTH = 674; export const NOTE_HASHES_NUM_BYTES_PER_BASE_ROLLUP = 2048; diff --git a/yarn-project/circuits.js/src/scripts/constants.in.ts b/yarn-project/circuits.js/src/scripts/constants.in.ts index 33ede0eded4..96f59872d29 100644 --- a/yarn-project/circuits.js/src/scripts/constants.in.ts +++ b/yarn-project/circuits.js/src/scripts/constants.in.ts @@ -4,6 +4,7 @@ import { fileURLToPath } from 'url'; const NOIR_CONSTANTS_FILE = '../../../../noir-projects/noir-protocol-circuits/crates/types/src/constants.nr'; const TS_CONSTANTS_FILE = '../constants.gen.ts'; +const CPP_AZTEC_CONSTANTS_FILE = '../../../../barretenberg/cpp/src/barretenberg/vm/avm_trace/aztec_constants.hpp'; const SOLIDITY_CONSTANTS_FILE = '../../../../l1-contracts/src/core/libraries/ConstantsGen.sol'; /** @@ -34,6 +35,25 @@ function processConstantsTS(constants: { [key: string]: string }): string { return code.join('\n'); } +/** + * Processes a collection of constants and generates code to export them as cpp constants. + * Required to ensure consistency between the constants used in pil and used in the vm witness generator. + * + * @param constants - An object containing key-value pairs representing constants. + * @returns A string containing code that exports the constants as cpp constants. + */ +function processConstantsCpp(constants: { [key: string]: string }): string { + const code: string[] = []; + Object.entries(constants).forEach(([key, value]) => { + // We exclude large numbers + if (!(value.startsWith("0x") || value.includes("0_0")) ) { + code.push(`const size_t ${key} = ${value};`); + }; + + }); + return code.join('\n'); +} + /** * Processes an enum and generates code to export it as a TypeScript enum. * @@ -83,6 +103,21 @@ function generateTypescriptConstants({ constants, generatorIndexEnum }: ParsedCo fs.writeFileSync(targetPath, result); } +/** + * Generate the constants file in C++. + */ +function generateCppConstants({ constants }: ParsedContent, targetPath: string) { + const resultCpp: string = `// GENERATED FILE - DO NOT EDIT, RUN yarn remake-constants in circuits.js +#pragma once +#include + +${processConstantsCpp(constants)} +\n`; + + fs.writeFileSync(targetPath, resultCpp); +} + + /** * Generate the constants file in Solidity. */ @@ -155,6 +190,10 @@ function main(): void { const tsTargetPath = join(__dirname, TS_CONSTANTS_FILE); generateTypescriptConstants(parsedContent, tsTargetPath); + // Cpp + const cppTargetPath = join(__dirname, CPP_AZTEC_CONSTANTS_FILE); + generateCppConstants(parsedContent, cppTargetPath) + // Solidity const solidityTargetPath = join(__dirname, SOLIDITY_CONSTANTS_FILE); fs.mkdirSync(dirname(solidityTargetPath), { recursive: true }); From bccfd67014e9df164d4e5a7516eb6a351c9553e5 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Wed, 8 May 2024 18:40:43 +0000 Subject: [PATCH 25/40] feat: add global variable opcodes --- barretenberg/cpp/pil/avm/avm_main.pil | 28 +- .../relations/generated/avm/avm_main.hpp | 104 +++++-- .../relations/generated/avm/declare_views.hpp | 2 +- .../vm/avm_trace/avm_kernel_trace.cpp | 35 ++- .../vm/avm_trace/avm_kernel_trace.hpp | 42 ++- .../barretenberg/vm/avm_trace/avm_trace.cpp | 91 +++--- .../barretenberg/vm/avm_trace/avm_trace.hpp | 15 +- .../vm/generated/avm_circuit_builder.hpp | 4 +- .../barretenberg/vm/generated/avm_flavor.hpp | 18 +- .../barretenberg/vm/generated/avm_prover.cpp | 6 +- .../vm/generated/avm_verifier.cpp | 6 +- .../barretenberg/vm/tests/avm_kernel.test.cpp | 258 ++++++++++++++++-- 12 files changed, 490 insertions(+), 119 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_main.pil b/barretenberg/cpp/pil/avm/avm_main.pil index 7acf4f2b5d4..eaf6f09accc 100644 --- a/barretenberg/cpp/pil/avm/avm_main.pil +++ b/barretenberg/cpp/pil/avm/avm_main.pil @@ -15,9 +15,9 @@ namespace avm_main(256); pol commit sel_op_function_selector; // FEES - pol commit sel_op_fee_per_l1_gas; pol commit sel_op_fee_per_l2_gas; pol commit sel_op_fee_per_da_gas; + pol commit sel_op_transaction_fee; // GLOBALS pol commit sel_op_chain_id; @@ -26,7 +26,6 @@ namespace avm_main(256); pol commit sel_op_coinbase; pol commit sel_op_timestamp; - //===== CONSTANT POLYNOMIALS ================================================== pol constant clk(i) { i }; pol constant first = [1] + [0]*; // Used mostly to toggle off the first row consisting @@ -166,9 +165,9 @@ namespace avm_main(256); sel_op_block_number * (1 - sel_op_block_number) = 0; sel_op_coinbase * (1 - sel_op_coinbase) = 0; sel_op_timestamp * (1 - sel_op_timestamp) = 0; - sel_op_fee_per_l1_gas * (1 - sel_op_fee_per_l1_gas) = 0; sel_op_fee_per_l2_gas * (1 - sel_op_fee_per_l2_gas) = 0; sel_op_fee_per_da_gas * (1 - sel_op_fee_per_da_gas) = 0; + sel_op_transaction_fee * (1 - sel_op_transaction_fee) = 0; sel_op_add * (1 - sel_op_add) = 0; sel_op_sub * (1 - sel_op_sub) = 0; @@ -273,7 +272,7 @@ namespace avm_main(256); //===== KERNEL LOOKUPS ======================================================= pol KERNEL_SELECTORS = ( sel_op_sender + sel_op_address + sel_op_portal + sel_op_function_selector + sel_op_chain_id + sel_op_version + - sel_op_block_number + sel_op_coinbase + sel_op_timestamp + sel_op_fee_per_l1_gas + sel_op_fee_per_l2_gas + sel_op_fee_per_da_gas + sel_op_block_number + sel_op_coinbase + sel_op_timestamp + sel_op_fee_per_l2_gas + sel_op_fee_per_da_gas + sel_op_transaction_fee ); // Ensure that only one kernel lookup is active when the kernel_sel is active #[KERNEL_ACTIVE_CHECK] @@ -379,6 +378,7 @@ namespace avm_main(256); // We can lookup into a fixed index of this polynomial by including constraints that force the value // of kernel_sel to the value relevant to the given opcode that is active + // CALL CONTEXT #[SENDER_KERNEL] sel_op_sender * (avm_kernel.kernel_sel - constants.SENDER_SELECTOR) = 0; @@ -391,12 +391,32 @@ namespace avm_main(256); #[FUNCTION_KERNEL] sel_op_function_selector * (avm_kernel.kernel_sel - constants.FUNCTION_SELECTOR) = 0; + // FEES #[FEE_DA_GAS_KERNEL] sel_op_fee_per_da_gas * (avm_kernel.kernel_sel - constants.FEE_PER_DA_GAS_SELECTOR) = 0; #[FEE_L2_GAS_KERNEL] sel_op_fee_per_l2_gas * (avm_kernel.kernel_sel - constants.FEE_PER_L2_GAS_SELECTOR) = 0; + #[FEE_TRANSACTION_FEE_KERNEL] + sel_op_transaction_fee * (avm_kernel.kernel_sel - constants.TRANSACTION_FEE_SELECTOR) = 0; + + // GLOBALS + #[CHAIN_ID_KERNEL] + sel_op_chain_id * (avm_kernel.kernel_sel - constants.CHAIN_ID_SELECTOR) = 0; + + #[VERSION_KERNEL] + sel_op_version * (avm_kernel.kernel_sel - constants.VERSION_SELECTOR) = 0; + + #[CHAIN_ID_KERNEL] + sel_op_block_number * (avm_kernel.kernel_sel - constants.BLOCK_NUMBER_SELECTOR) = 0; + + #[CHAIN_ID_KERNEL] + sel_op_coinbase * (avm_kernel.kernel_sel - constants.COINBASE_SELECTOR) = 0; + + #[CHAIN_ID_KERNEL] + sel_op_timestamp * (avm_kernel.kernel_sel - constants.TIMESTAMP_SELECTOR) = 0; + #[LOOKUP_INTO_KERNEL] // TODO: FIX not having the trailing is_public breaking compilation :( q_kernel_lookup { avm_main.ia, avm_kernel.kernel_sel } in avm_kernel.q_public_input_kernel_add_to_table { avm_kernel.kernel_inputs__is_public, clk }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp index f175c25dd45..5eaee5b8ab7 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp @@ -59,7 +59,6 @@ template struct Avm_mainRow { FF avm_main_sel_op_eq{}; FF avm_main_sel_op_fdiv{}; FF avm_main_sel_op_fee_per_da_gas{}; - FF avm_main_sel_op_fee_per_l1_gas{}; FF avm_main_sel_op_fee_per_l2_gas{}; FF avm_main_sel_op_function_selector{}; FF avm_main_sel_op_lt{}; @@ -73,6 +72,7 @@ template struct Avm_mainRow { FF avm_main_sel_op_shr{}; FF avm_main_sel_op_sub{}; FF avm_main_sel_op_timestamp{}; + FF avm_main_sel_op_transaction_fee{}; FF avm_main_sel_op_version{}; FF avm_main_sel_op_xor{}; FF avm_main_tag_err{}; @@ -152,9 +152,27 @@ inline std::string get_relation_label_avm_main(int index) return "FEE_L2_GAS_KERNEL"; case 86: - return "BIN_SEL_1"; + return "FEE_TRANSACTION_FEE_KERNEL"; case 87: + return "CHAIN_ID_KERNEL"; + + case 88: + return "VERSION_KERNEL"; + + case 89: + return "CHAIN_ID_KERNEL"; + + case 90: + return "CHAIN_ID_KERNEL"; + + case 91: + return "CHAIN_ID_KERNEL"; + + case 92: + return "BIN_SEL_1"; + + case 93: return "BIN_SEL_2"; } return std::to_string(index); @@ -164,10 +182,10 @@ template class avm_mainImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, }; template @@ -253,7 +271,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(9); - auto tmp = (avm_main_sel_op_fee_per_l1_gas * (-avm_main_sel_op_fee_per_l1_gas + FF(1))); + auto tmp = (avm_main_sel_op_fee_per_l2_gas * (-avm_main_sel_op_fee_per_l2_gas + FF(1))); tmp *= scaling_factor; std::get<9>(evals) += tmp; } @@ -261,7 +279,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(10); - auto tmp = (avm_main_sel_op_fee_per_l2_gas * (-avm_main_sel_op_fee_per_l2_gas + FF(1))); + auto tmp = (avm_main_sel_op_fee_per_da_gas * (-avm_main_sel_op_fee_per_da_gas + FF(1))); tmp *= scaling_factor; std::get<10>(evals) += tmp; } @@ -269,7 +287,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(11); - auto tmp = (avm_main_sel_op_fee_per_da_gas * (-avm_main_sel_op_fee_per_da_gas + FF(1))); + auto tmp = (avm_main_sel_op_transaction_fee * (-avm_main_sel_op_transaction_fee + FF(1))); tmp *= scaling_factor; std::get<11>(evals) += tmp; } @@ -630,9 +648,9 @@ template class avm_mainImpl { avm_main_sel_op_block_number) + avm_main_sel_op_coinbase) + avm_main_sel_op_timestamp) + - avm_main_sel_op_fee_per_l1_gas) + - avm_main_sel_op_fee_per_l2_gas) + - avm_main_sel_op_fee_per_da_gas) * + avm_main_sel_op_fee_per_l2_gas) + + avm_main_sel_op_fee_per_da_gas) + + avm_main_sel_op_transaction_fee) * (-avm_main_q_kernel_lookup + FF(1))); tmp *= scaling_factor; std::get<55>(evals) += tmp; @@ -756,9 +774,9 @@ template class avm_mainImpl { avm_main_sel_op_block_number) + avm_main_sel_op_coinbase) + avm_main_sel_op_timestamp) + - avm_main_sel_op_fee_per_l1_gas) + - avm_main_sel_op_fee_per_l2_gas) + - avm_main_sel_op_fee_per_da_gas))) * + avm_main_sel_op_fee_per_l2_gas) + + avm_main_sel_op_fee_per_da_gas) + + avm_main_sel_op_transaction_fee))) * (avm_main_pc_shift - (avm_main_pc + FF(1)))); tmp *= scaling_factor; std::get<68>(evals) += tmp; @@ -908,7 +926,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(84); - auto tmp = (avm_main_sel_op_fee_per_da_gas * (avm_kernel_kernel_sel - FF(9))); + auto tmp = (avm_main_sel_op_fee_per_da_gas * (avm_kernel_kernel_sel - FF(37))); tmp *= scaling_factor; std::get<84>(evals) += tmp; } @@ -916,7 +934,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(85); - auto tmp = (avm_main_sel_op_fee_per_l2_gas * (avm_kernel_kernel_sel - FF(13))); + auto tmp = (avm_main_sel_op_fee_per_l2_gas * (avm_kernel_kernel_sel - FF(38))); tmp *= scaling_factor; std::get<85>(evals) += tmp; } @@ -924,7 +942,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(86); - auto tmp = (avm_main_bin_op_id - (avm_main_sel_op_or + (avm_main_sel_op_xor * FF(2)))); + auto tmp = (avm_main_sel_op_transaction_fee * (avm_kernel_kernel_sel - FF(39))); tmp *= scaling_factor; std::get<86>(evals) += tmp; } @@ -932,10 +950,58 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(87); - auto tmp = (avm_main_bin_sel - ((avm_main_sel_op_and + avm_main_sel_op_or) + avm_main_sel_op_xor)); + auto tmp = (avm_main_sel_op_chain_id * (avm_kernel_kernel_sel - FF(28))); tmp *= scaling_factor; std::get<87>(evals) += tmp; } + // Contribution 88 + { + Avm_DECLARE_VIEWS(88); + + auto tmp = (avm_main_sel_op_version * (avm_kernel_kernel_sel - FF(29))); + tmp *= scaling_factor; + std::get<88>(evals) += tmp; + } + // Contribution 89 + { + Avm_DECLARE_VIEWS(89); + + auto tmp = (avm_main_sel_op_block_number * (avm_kernel_kernel_sel - FF(30))); + tmp *= scaling_factor; + std::get<89>(evals) += tmp; + } + // Contribution 90 + { + Avm_DECLARE_VIEWS(90); + + auto tmp = (avm_main_sel_op_coinbase * (avm_kernel_kernel_sel - FF(32))); + tmp *= scaling_factor; + std::get<90>(evals) += tmp; + } + // Contribution 91 + { + Avm_DECLARE_VIEWS(91); + + auto tmp = (avm_main_sel_op_timestamp * (avm_kernel_kernel_sel - FF(31))); + tmp *= scaling_factor; + std::get<91>(evals) += tmp; + } + // Contribution 92 + { + Avm_DECLARE_VIEWS(92); + + auto tmp = (avm_main_bin_op_id - (avm_main_sel_op_or + (avm_main_sel_op_xor * FF(2)))); + tmp *= scaling_factor; + std::get<92>(evals) += tmp; + } + // Contribution 93 + { + Avm_DECLARE_VIEWS(93); + + auto tmp = (avm_main_bin_sel - ((avm_main_sel_op_and + avm_main_sel_op_or) + avm_main_sel_op_xor)); + tmp *= scaling_factor; + std::get<93>(evals) += tmp; + } } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp index d7ada6a7df5..5dd981b0996 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -148,7 +148,6 @@ [[maybe_unused]] auto avm_main_sel_op_eq = View(new_term.avm_main_sel_op_eq); \ [[maybe_unused]] auto avm_main_sel_op_fdiv = View(new_term.avm_main_sel_op_fdiv); \ [[maybe_unused]] auto avm_main_sel_op_fee_per_da_gas = View(new_term.avm_main_sel_op_fee_per_da_gas); \ - [[maybe_unused]] auto avm_main_sel_op_fee_per_l1_gas = View(new_term.avm_main_sel_op_fee_per_l1_gas); \ [[maybe_unused]] auto avm_main_sel_op_fee_per_l2_gas = View(new_term.avm_main_sel_op_fee_per_l2_gas); \ [[maybe_unused]] auto avm_main_sel_op_function_selector = View(new_term.avm_main_sel_op_function_selector); \ [[maybe_unused]] auto avm_main_sel_op_lt = View(new_term.avm_main_sel_op_lt); \ @@ -162,6 +161,7 @@ [[maybe_unused]] auto avm_main_sel_op_shr = View(new_term.avm_main_sel_op_shr); \ [[maybe_unused]] auto avm_main_sel_op_sub = View(new_term.avm_main_sel_op_sub); \ [[maybe_unused]] auto avm_main_sel_op_timestamp = View(new_term.avm_main_sel_op_timestamp); \ + [[maybe_unused]] auto avm_main_sel_op_transaction_fee = View(new_term.avm_main_sel_op_transaction_fee); \ [[maybe_unused]] auto avm_main_sel_op_version = View(new_term.avm_main_sel_op_version); \ [[maybe_unused]] auto avm_main_sel_op_xor = View(new_term.avm_main_sel_op_xor); \ [[maybe_unused]] auto avm_main_sel_rng_16 = View(new_term.avm_main_sel_rng_16); \ diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp index 4257dc00ab4..7df78488b35 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.cpp @@ -43,11 +43,6 @@ FF AvmKernelTraceBuilder::op_portal() return perform_kernel_lookup(PORTAL_SELECTOR); } -FF AvmKernelTraceBuilder::op_function() -{ - return perform_kernel_lookup(FUNCTION_SELECTOR); -} - FF AvmKernelTraceBuilder::op_fee_per_da_gas() { return perform_kernel_lookup(FEE_PER_DA_GAS_SELECTOR); @@ -58,4 +53,34 @@ FF AvmKernelTraceBuilder::op_fee_per_l2_gas() return perform_kernel_lookup(FEE_PER_L2_GAS_SELECTOR); } +FF AvmKernelTraceBuilder::op_transaction_fee() +{ + return perform_kernel_lookup(TRANSACTION_FEE_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_chain_id() +{ + return perform_kernel_lookup(CHAIN_ID_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_version() +{ + return perform_kernel_lookup(VERSION_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_block_number() +{ + return perform_kernel_lookup(BLOCK_NUMBER_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_coinbase() +{ + return perform_kernel_lookup(COINBASE_SELECTOR); +} + +FF AvmKernelTraceBuilder::op_timestamp() +{ + return perform_kernel_lookup(TIMESTAMP_SELECTOR); +} + } // namespace bb::avm_trace \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp index 1b63f2171a6..dd06765131b 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_kernel_trace.hpp @@ -9,21 +9,33 @@ inline const uint32_t SENDER_SELECTOR = 0; inline const uint32_t ADDRESS_SELECTOR = 1; inline const uint32_t PORTAL_SELECTOR = 2; -inline const uint32_t FUNCTION_SELECTOR = 3; -// TODO: double check that these indexes are correct -inline const uint32_t FEE_PER_DA_GAS_SELECTOR = 9; -inline const uint32_t FEE_PER_L2_GAS_SELECTOR = 13; -const std::array KERNEL_INPUTS_SELECTORS = { SENDER_SELECTOR, ADDRESS_SELECTOR, - PORTAL_SELECTOR, FUNCTION_SELECTOR, - FEE_PER_DA_GAS_SELECTOR, FEE_PER_L2_GAS_SELECTOR }; +inline const uint32_t START_GLOBAL_VARIABLES = CALL_CONTEXT_LENGTH + HEADER_LENGTH; + +inline const uint32_t CHAIN_ID_SELECTOR = START_GLOBAL_VARIABLES; +inline const uint32_t VERSION_SELECTOR = START_GLOBAL_VARIABLES + 1; +inline const uint32_t BLOCK_NUMBER_SELECTOR = START_GLOBAL_VARIABLES + 2; +inline const uint32_t TIMESTAMP_SELECTOR = START_GLOBAL_VARIABLES + 3; +inline const uint32_t COINBASE_SELECTOR = START_GLOBAL_VARIABLES + 4; + +inline const uint32_t END_GLOBAL_VARIABLES = START_GLOBAL_VARIABLES + GLOBAL_VARIABLES_LENGTH; +inline const uint32_t START_SIDE_EFFECT_COUNTER = END_GLOBAL_VARIABLES; + +inline const uint32_t FEE_PER_DA_GAS_SELECTOR = START_SIDE_EFFECT_COUNTER + 1; +inline const uint32_t FEE_PER_L2_GAS_SELECTOR = FEE_PER_DA_GAS_SELECTOR + 1; +inline const uint32_t TRANSACTION_FEE_SELECTOR = FEE_PER_L2_GAS_SELECTOR + 1; + +const std::array KERNEL_INPUTS_SELECTORS = { + SENDER_SELECTOR, ADDRESS_SELECTOR, PORTAL_SELECTOR, FEE_PER_DA_GAS_SELECTOR, + FEE_PER_L2_GAS_SELECTOR, TRANSACTION_FEE_SELECTOR, CHAIN_ID_SELECTOR, VERSION_SELECTOR, + BLOCK_NUMBER_SELECTOR, COINBASE_SELECTOR, TIMESTAMP_SELECTOR +}; namespace bb::avm_trace { class AvmKernelTraceBuilder { public: struct KernelTraceEntry { - // TODO: could be u8? uint32_t kernel_selector = 0; bool q_kernel_lookup = false; }; @@ -33,17 +45,27 @@ class AvmKernelTraceBuilder { // Counts the number of accesses into each SELECTOR for the environment selector lookups; std::unordered_map kernel_selector_counter; - // TODO: should i have access to the kernel_inputs here -> so they can be directly looked up? + // Constructor receives copy of kernel_inputs from the main trace builder AvmKernelTraceBuilder(std::array kernel_inputs); void reset(); + // Context FF op_sender(); FF op_address(); FF op_portal(); - FF op_function(); + + // Fees FF op_fee_per_da_gas(); FF op_fee_per_l2_gas(); + FF op_transaction_fee(); + + // Globals + FF op_chain_id(); + FF op_version(); + FF op_block_number(); + FF op_coinbase(); + FF op_timestamp(); private: std::vector kernel_trace; diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp index 0469efd4994..f69c9789621 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -15,6 +15,7 @@ #include "avm_mem_trace.hpp" #include "avm_trace.hpp" #include "barretenberg/vm/avm_trace/avm_kernel_trace.hpp" +#include "barretenberg/vm/avm_trace/aztec_constants.hpp" namespace bb::avm_trace { @@ -1111,15 +1112,6 @@ void AvmTraceBuilder::op_portal(uint32_t dst_offset) main_trace.push_back(row); } -void AvmTraceBuilder::op_function(uint32_t dst_offset) -{ - FF ia_value = kernel_trace_builder.op_function(); - Row row = create_kernel_lookup_opcode(dst_offset, FUNCTION_SELECTOR, ia_value); - row.avm_main_sel_op_function_selector = FF(1); - - main_trace.push_back(row); -} - void AvmTraceBuilder::op_fee_per_da_gas(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_fee_per_da_gas(); @@ -1138,6 +1130,60 @@ void AvmTraceBuilder::op_fee_per_l2_gas(uint32_t dst_offset) main_trace.push_back(row); } +void AvmTraceBuilder::op_transaction_fee(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_transaction_fee(); + Row row = create_kernel_lookup_opcode(dst_offset, TRANSACTION_FEE_SELECTOR, ia_value); + row.avm_main_sel_op_transaction_fee = FF(1); + + main_trace.push_back(row); +} + +void AvmTraceBuilder::op_chain_id(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_chain_id(); + Row row = create_kernel_lookup_opcode(dst_offset, CHAIN_ID_SELECTOR, ia_value); + row.avm_main_sel_op_chain_id = FF(1); + + main_trace.push_back(row); +} + +void AvmTraceBuilder::op_version(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_version(); + Row row = create_kernel_lookup_opcode(dst_offset, VERSION_SELECTOR, ia_value); + row.avm_main_sel_op_version = FF(1); + + main_trace.push_back(row); +} + +void AvmTraceBuilder::op_block_number(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_block_number(); + Row row = create_kernel_lookup_opcode(dst_offset, BLOCK_NUMBER_SELECTOR, ia_value); + row.avm_main_sel_op_block_number = FF(1); + + main_trace.push_back(row); +} + +void AvmTraceBuilder::op_coinbase(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_coinbase(); + Row row = create_kernel_lookup_opcode(dst_offset, COINBASE_SELECTOR, ia_value); + row.avm_main_sel_op_coinbase = FF(1); + + main_trace.push_back(row); +} + +void AvmTraceBuilder::op_timestamp(uint32_t dst_offset) +{ + FF ia_value = kernel_trace_builder.op_timestamp(); + Row row = create_kernel_lookup_opcode(dst_offset, TIMESTAMP_SELECTOR, ia_value); + row.avm_main_sel_op_timestamp = FF(1); + + main_trace.push_back(row); +} + /** * @brief Cast an element pointed by the address a_offset into type specified by dst_tag and store the result in address given by dst_offset. @@ -1613,9 +1659,8 @@ std::vector AvmTraceBuilder::finalize() // long) size_t const lookup_table_size = bin_trace_size > 0 ? 3 * (1 << 16) : 0; size_t const range_check_size = range_check_required ? UINT16_MAX + 1 : 0; - std::vector trace_sizes = { - mem_trace_size, main_trace_size, alu_trace_size, lookup_table_size, range_check_size - }; + std::vector trace_sizes = { mem_trace_size, main_trace_size, alu_trace_size, + lookup_table_size, range_check_size, KERNEL_INPUTS_LENGTH }; auto trace_size = std::max_element(trace_sizes.begin(), trace_sizes.end()); // We only need to pad with zeroes to the size to the largest trace here, pow_2 padding is handled in the @@ -1950,24 +1995,8 @@ std::vector AvmTraceBuilder::finalize() } } - // TODO: pub public inputs inside a function? - // Include env trace table - // Selector columns and lookup counts - // Add all of the lookup counts for the input environment - // TODO: this index will have to move with the hardcoded public inputs - - // Add public inputs into the kernel column - // edge case: If the number of public inputs is more than the trace then we pad to its size - size_t initial_size = main_trace.size(); - size_t number_of_kernel_inputs = kernel_trace_builder.kernel_inputs.size(); - if (initial_size < number_of_kernel_inputs) { - auto diff = number_of_kernel_inputs - initial_size; - for (size_t i = 0; i < diff; ++i) { - // We need clk to increment for kernel lookups to remain valid - main_trace.push_back(Row{ .avm_main_clk = initial_size + i }); - } - } - auto kernel_inputs_size = std::min(main_trace.size(), kernel_trace_builder.kernel_inputs.size()); + // 1. Calculate the lookup counts for each environment access + // 2. Add public inputs into the kernel column // We add the lookup counts in the index of the kernel inputs selectors that are active for (uint32_t selector_index : KERNEL_INPUTS_SELECTORS) { @@ -1977,7 +2006,7 @@ std::vector AvmTraceBuilder::finalize() dest.avm_kernel_q_public_input_kernel_add_to_table = FF(1); } - for (size_t i = 0; i < kernel_inputs_size; i++) { + for (size_t i = 0; i < KERNEL_INPUTS_LENGTH; i++) { main_trace.at(i).avm_kernel_kernel_inputs__is_public = kernel_trace_builder.kernel_inputs.at(i); } diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp index ed5d79c5f30..a0f8a3aca49 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp @@ -80,13 +80,23 @@ class AvmTraceBuilder { // is determined conditionally based on a conditional value determined by cond_offset. void op_cmov(uint8_t indirect, uint32_t a_offset, uint32_t b_offset, uint32_t cond_offset, uint32_t dst_offset); - // TODO + // Call Context void op_sender(uint32_t dst_offset); void op_address(uint32_t dst_offset); void op_portal(uint32_t dst_offset); - void op_function(uint32_t dst_offset); + + // Fees void op_fee_per_da_gas(uint32_t dst_offset); void op_fee_per_l2_gas(uint32_t dst_offset); + void op_transaction_fee(uint32_t dst_offset); + + // Globals + void op_chain_id(uint32_t dst_offset); + void op_version(uint32_t dst_offset); + void op_block_number(uint32_t dst_offset); + void op_coinbase(uint32_t dst_offset); + void op_timestamp(uint32_t dst_offset); + // Cast an element pointed by the address a_offset into type specified by dst_tag and // store the result in address given by dst_offset. void op_cast(uint8_t indirect, uint32_t a_offset, uint32_t dst_offset, AvmMemoryTag dst_tag); @@ -137,7 +147,6 @@ class AvmTraceBuilder { AvmBinaryTraceBuilder bin_trace_builder; AvmKernelTraceBuilder kernel_trace_builder; - // TODO: rename??? Row create_kernel_lookup_opcode(uint32_t dst_offset, uint32_t selector, FF value); void finalise_mem_trace_lookup_counts(); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 901ee9df14a..041bd98f8e1 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -201,7 +201,6 @@ template struct AvmFullRow { FF avm_main_sel_op_eq{}; FF avm_main_sel_op_fdiv{}; FF avm_main_sel_op_fee_per_da_gas{}; - FF avm_main_sel_op_fee_per_l1_gas{}; FF avm_main_sel_op_fee_per_l2_gas{}; FF avm_main_sel_op_function_selector{}; FF avm_main_sel_op_lt{}; @@ -215,6 +214,7 @@ template struct AvmFullRow { FF avm_main_sel_op_shr{}; FF avm_main_sel_op_sub{}; FF avm_main_sel_op_timestamp{}; + FF avm_main_sel_op_transaction_fee{}; FF avm_main_sel_op_version{}; FF avm_main_sel_op_xor{}; FF avm_main_sel_rng_16{}; @@ -529,7 +529,6 @@ class AvmCircuitBuilder { polys.avm_main_sel_op_eq[i] = rows[i].avm_main_sel_op_eq; polys.avm_main_sel_op_fdiv[i] = rows[i].avm_main_sel_op_fdiv; polys.avm_main_sel_op_fee_per_da_gas[i] = rows[i].avm_main_sel_op_fee_per_da_gas; - polys.avm_main_sel_op_fee_per_l1_gas[i] = rows[i].avm_main_sel_op_fee_per_l1_gas; polys.avm_main_sel_op_fee_per_l2_gas[i] = rows[i].avm_main_sel_op_fee_per_l2_gas; polys.avm_main_sel_op_function_selector[i] = rows[i].avm_main_sel_op_function_selector; polys.avm_main_sel_op_lt[i] = rows[i].avm_main_sel_op_lt; @@ -543,6 +542,7 @@ class AvmCircuitBuilder { polys.avm_main_sel_op_shr[i] = rows[i].avm_main_sel_op_shr; polys.avm_main_sel_op_sub[i] = rows[i].avm_main_sel_op_sub; polys.avm_main_sel_op_timestamp[i] = rows[i].avm_main_sel_op_timestamp; + polys.avm_main_sel_op_transaction_fee[i] = rows[i].avm_main_sel_op_transaction_fee; polys.avm_main_sel_op_version[i] = rows[i].avm_main_sel_op_version; polys.avm_main_sel_op_xor[i] = rows[i].avm_main_sel_op_xor; polys.avm_main_sel_rng_16[i] = rows[i].avm_main_sel_rng_16; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index aa5ea70c6d0..2df042e654b 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -333,7 +333,6 @@ class AvmFlavor { avm_main_sel_op_eq, avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, - avm_main_sel_op_fee_per_l1_gas, avm_main_sel_op_fee_per_l2_gas, avm_main_sel_op_function_selector, avm_main_sel_op_lt, @@ -347,6 +346,7 @@ class AvmFlavor { avm_main_sel_op_shr, avm_main_sel_op_sub, avm_main_sel_op_timestamp, + avm_main_sel_op_transaction_fee, avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -590,7 +590,6 @@ class AvmFlavor { avm_main_sel_op_eq, avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, - avm_main_sel_op_fee_per_l1_gas, avm_main_sel_op_fee_per_l2_gas, avm_main_sel_op_function_selector, avm_main_sel_op_lt, @@ -604,6 +603,7 @@ class AvmFlavor { avm_main_sel_op_shr, avm_main_sel_op_sub, avm_main_sel_op_timestamp, + avm_main_sel_op_transaction_fee, avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -852,7 +852,6 @@ class AvmFlavor { avm_main_sel_op_eq, avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, - avm_main_sel_op_fee_per_l1_gas, avm_main_sel_op_fee_per_l2_gas, avm_main_sel_op_function_selector, avm_main_sel_op_lt, @@ -866,6 +865,7 @@ class AvmFlavor { avm_main_sel_op_shr, avm_main_sel_op_sub, avm_main_sel_op_timestamp, + avm_main_sel_op_transaction_fee, avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -1153,7 +1153,6 @@ class AvmFlavor { avm_main_sel_op_eq, avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, - avm_main_sel_op_fee_per_l1_gas, avm_main_sel_op_fee_per_l2_gas, avm_main_sel_op_function_selector, avm_main_sel_op_lt, @@ -1167,6 +1166,7 @@ class AvmFlavor { avm_main_sel_op_shr, avm_main_sel_op_sub, avm_main_sel_op_timestamp, + avm_main_sel_op_transaction_fee, avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -1454,7 +1454,6 @@ class AvmFlavor { avm_main_sel_op_eq, avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, - avm_main_sel_op_fee_per_l1_gas, avm_main_sel_op_fee_per_l2_gas, avm_main_sel_op_function_selector, avm_main_sel_op_lt, @@ -1468,6 +1467,7 @@ class AvmFlavor { avm_main_sel_op_shr, avm_main_sel_op_sub, avm_main_sel_op_timestamp, + avm_main_sel_op_transaction_fee, avm_main_sel_op_version, avm_main_sel_op_xor, avm_main_sel_rng_16, @@ -2033,7 +2033,6 @@ class AvmFlavor { Base::avm_main_sel_op_eq = "AVM_MAIN_SEL_OP_EQ"; Base::avm_main_sel_op_fdiv = "AVM_MAIN_SEL_OP_FDIV"; Base::avm_main_sel_op_fee_per_da_gas = "AVM_MAIN_SEL_OP_FEE_PER_DA_GAS"; - Base::avm_main_sel_op_fee_per_l1_gas = "AVM_MAIN_SEL_OP_FEE_PER_L1_GAS"; Base::avm_main_sel_op_fee_per_l2_gas = "AVM_MAIN_SEL_OP_FEE_PER_L2_GAS"; Base::avm_main_sel_op_function_selector = "AVM_MAIN_SEL_OP_FUNCTION_SELECTOR"; Base::avm_main_sel_op_lt = "AVM_MAIN_SEL_OP_LT"; @@ -2047,6 +2046,7 @@ class AvmFlavor { Base::avm_main_sel_op_shr = "AVM_MAIN_SEL_OP_SHR"; Base::avm_main_sel_op_sub = "AVM_MAIN_SEL_OP_SUB"; Base::avm_main_sel_op_timestamp = "AVM_MAIN_SEL_OP_TIMESTAMP"; + Base::avm_main_sel_op_transaction_fee = "AVM_MAIN_SEL_OP_TRANSACTION_FEE"; Base::avm_main_sel_op_version = "AVM_MAIN_SEL_OP_VERSION"; Base::avm_main_sel_op_xor = "AVM_MAIN_SEL_OP_XOR"; Base::avm_main_sel_rng_16 = "AVM_MAIN_SEL_RNG_16"; @@ -2306,7 +2306,6 @@ class AvmFlavor { Commitment avm_main_sel_op_eq; Commitment avm_main_sel_op_fdiv; Commitment avm_main_sel_op_fee_per_da_gas; - Commitment avm_main_sel_op_fee_per_l1_gas; Commitment avm_main_sel_op_fee_per_l2_gas; Commitment avm_main_sel_op_function_selector; Commitment avm_main_sel_op_lt; @@ -2320,6 +2319,7 @@ class AvmFlavor { Commitment avm_main_sel_op_shr; Commitment avm_main_sel_op_sub; Commitment avm_main_sel_op_timestamp; + Commitment avm_main_sel_op_transaction_fee; Commitment avm_main_sel_op_version; Commitment avm_main_sel_op_xor; Commitment avm_main_sel_rng_16; @@ -2582,7 +2582,6 @@ class AvmFlavor { avm_main_sel_op_eq = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_fdiv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_fee_per_da_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - avm_main_sel_op_fee_per_l1_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_fee_per_l2_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_function_selector = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2597,6 +2596,7 @@ class AvmFlavor { avm_main_sel_op_shr = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_sub = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_timestamp = deserialize_from_buffer(Transcript::proof_data, num_frs_read); + avm_main_sel_op_transaction_fee = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_version = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_xor = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_rng_16 = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -2860,7 +2860,6 @@ class AvmFlavor { serialize_to_buffer(avm_main_sel_op_eq, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_fdiv, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_fee_per_da_gas, Transcript::proof_data); - serialize_to_buffer(avm_main_sel_op_fee_per_l1_gas, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_fee_per_l2_gas, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_function_selector, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_lt, Transcript::proof_data); @@ -2874,6 +2873,7 @@ class AvmFlavor { serialize_to_buffer(avm_main_sel_op_shr, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_sub, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_timestamp, Transcript::proof_data); + serialize_to_buffer(avm_main_sel_op_transaction_fee, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_version, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_xor, Transcript::proof_data); serialize_to_buffer(avm_main_sel_rng_16, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index c688a190e94..9c485d13d12 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -205,7 +205,6 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_sel_op_eq = commitment_key->commit(key->avm_main_sel_op_eq); witness_commitments.avm_main_sel_op_fdiv = commitment_key->commit(key->avm_main_sel_op_fdiv); witness_commitments.avm_main_sel_op_fee_per_da_gas = commitment_key->commit(key->avm_main_sel_op_fee_per_da_gas); - witness_commitments.avm_main_sel_op_fee_per_l1_gas = commitment_key->commit(key->avm_main_sel_op_fee_per_l1_gas); witness_commitments.avm_main_sel_op_fee_per_l2_gas = commitment_key->commit(key->avm_main_sel_op_fee_per_l2_gas); witness_commitments.avm_main_sel_op_function_selector = commitment_key->commit(key->avm_main_sel_op_function_selector); @@ -220,6 +219,7 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_sel_op_shr = commitment_key->commit(key->avm_main_sel_op_shr); witness_commitments.avm_main_sel_op_sub = commitment_key->commit(key->avm_main_sel_op_sub); witness_commitments.avm_main_sel_op_timestamp = commitment_key->commit(key->avm_main_sel_op_timestamp); + witness_commitments.avm_main_sel_op_transaction_fee = commitment_key->commit(key->avm_main_sel_op_transaction_fee); witness_commitments.avm_main_sel_op_version = commitment_key->commit(key->avm_main_sel_op_version); witness_commitments.avm_main_sel_op_xor = commitment_key->commit(key->avm_main_sel_op_xor); witness_commitments.avm_main_sel_rng_16 = commitment_key->commit(key->avm_main_sel_rng_16); @@ -448,8 +448,6 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.avm_main_sel_op_fdiv, witness_commitments.avm_main_sel_op_fdiv); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_fee_per_da_gas, witness_commitments.avm_main_sel_op_fee_per_da_gas); - transcript->send_to_verifier(commitment_labels.avm_main_sel_op_fee_per_l1_gas, - witness_commitments.avm_main_sel_op_fee_per_l1_gas); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_fee_per_l2_gas, witness_commitments.avm_main_sel_op_fee_per_l2_gas); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_function_selector, @@ -466,6 +464,8 @@ void AvmProver::execute_wire_commitments_round() transcript->send_to_verifier(commitment_labels.avm_main_sel_op_sub, witness_commitments.avm_main_sel_op_sub); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_timestamp, witness_commitments.avm_main_sel_op_timestamp); + transcript->send_to_verifier(commitment_labels.avm_main_sel_op_transaction_fee, + witness_commitments.avm_main_sel_op_transaction_fee); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_version, witness_commitments.avm_main_sel_op_version); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_xor, witness_commitments.avm_main_sel_op_xor); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 51d79b68e89..1681e99397d 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -28,7 +28,7 @@ AvmVerifier& AvmVerifier::operator=(AvmVerifier&& other) noexcept using FF = AvmFlavor::FF; // Evaluate the given public input column over the multivariate challenge points -[[maybe_unused]] inline FF evaluate_public_input_column(std::vector points, std::vector challenges) +[[maybe_unused]] FF evaluate_public_input_column(std::vector points, std::vector challenges) { Polynomial polynomial(points); return polynomial.evaluate_mle(challenges); @@ -295,8 +295,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_fdiv); commitments.avm_main_sel_op_fee_per_da_gas = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_fee_per_da_gas); - commitments.avm_main_sel_op_fee_per_l1_gas = - transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_fee_per_l1_gas); commitments.avm_main_sel_op_fee_per_l2_gas = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_fee_per_l2_gas); commitments.avm_main_sel_op_function_selector = @@ -323,6 +321,8 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_sub); commitments.avm_main_sel_op_timestamp = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_timestamp); + commitments.avm_main_sel_op_transaction_fee = + transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_transaction_fee); commitments.avm_main_sel_op_version = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_version); commitments.avm_main_sel_op_xor = diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp index da89a0145c5..29492d95990 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -67,7 +67,7 @@ void expect_row(std::vector::const_iterator row, FF selector, FF ia, FF mem TEST_F(AvmKernelPositiveTests, kernelSender) { uint32_t dst_offset = 42; - // We test that the sender opcode is inlcuded at index x in the public inputs + // We test that the sender opcode is included at index 0 in the public inputs auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_sender(dst_offset); }; auto checks = [=](const std::vector& trace) { std::vector::const_iterator sender_row = @@ -120,49 +120,49 @@ TEST_F(AvmKernelPositiveTests, kernelPortal) test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmKernelPositiveTests, kernelFunction) +TEST_F(AvmKernelPositiveTests, kernelFeePerDa) { uint32_t dst_offset = 42; - auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_function(dst_offset); }; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_da_gas(dst_offset); }; auto checks = [=](const std::vector& trace) { - std::vector::const_iterator function_row = std::ranges::find_if( - trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_function_selector == FF(1); }); - EXPECT_TRUE(function_row != trace.end()); + std::vector::const_iterator fee_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_da_gas == FF(1); }); + EXPECT_TRUE(fee_row != trace.end()); - expect_row(function_row, - /*kernel_sel=*/FUNCTION_SELECTOR, - /*ia=*/FUNCTION_SELECTOR + + expect_row(fee_row, + /*kernel_sel=*/FEE_PER_DA_GAS_SELECTOR, + /*ia=*/FEE_PER_DA_GAS_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*mem_idx_a*/ dst_offset); }; test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmKernelPositiveTests, kernelFeePerDa) +TEST_F(AvmKernelPositiveTests, kernelFeePerL2) { uint32_t dst_offset = 42; - auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_da_gas(dst_offset); }; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l2_gas(dst_offset); }; auto checks = [=](const std::vector& trace) { std::vector::const_iterator fee_row = std::ranges::find_if( - trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_da_gas == FF(1); }); + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l2_gas == FF(1); }); EXPECT_TRUE(fee_row != trace.end()); expect_row(fee_row, - /*kernel_sel=*/FEE_PER_DA_GAS_SELECTOR, - /*ia=*/FEE_PER_DA_GAS_SELECTOR + + /*kernel_sel=*/FEE_PER_L2_GAS_SELECTOR, + /*ia=*/FEE_PER_L2_GAS_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*mem_idx_a*/ dst_offset); }; test_kernel_lookup(apply_opcodes, checks); } -TEST_F(AvmKernelPositiveTests, kernelFeePerL2) +TEST_F(AvmKernelPositiveTests, kernelTransactionFee) { uint32_t dst_offset = 42; - auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l2_gas(dst_offset); }; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_transaction_fee(dst_offset); }; auto checks = [=](const std::vector& trace) { std::vector::const_iterator fee_row = std::ranges::find_if( - trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l2_gas == FF(1); }); + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_transaction_fee == FF(1); }); EXPECT_TRUE(fee_row != trace.end()); expect_row(fee_row, @@ -174,6 +174,96 @@ TEST_F(AvmKernelPositiveTests, kernelFeePerL2) test_kernel_lookup(apply_opcodes, checks); } +TEST_F(AvmKernelPositiveTests, kernelChainId) +{ + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_chain_id(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator fee_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_chain_id == FF(1); }); + EXPECT_TRUE(fee_row != trace.end()); + + expect_row(fee_row, + /*kernel_sel=*/CHAIN_ID_SELECTOR, + /*ia=*/CHAIN_ID_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); +} + +TEST_F(AvmKernelPositiveTests, kernelVersion) +{ + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_version(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator fee_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_version == FF(1); }); + EXPECT_TRUE(fee_row != trace.end()); + + expect_row(fee_row, + /*kernel_sel=*/VERSION_SELECTOR, + /*ia=*/VERSION_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); +} + +TEST_F(AvmKernelPositiveTests, kernelBlockNumber) +{ + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_block_number(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator fee_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_block_number == FF(1); }); + EXPECT_TRUE(fee_row != trace.end()); + + expect_row(fee_row, + /*kernel_sel=*/BLOCK_NUMBER_SELECTOR, + /*ia=*/BLOCK_NUMBER_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); +} + +TEST_F(AvmKernelPositiveTests, kernelCoinbase) +{ + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_coinbase(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator fee_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_coinbase == FF(1); }); + EXPECT_TRUE(fee_row != trace.end()); + + expect_row(fee_row, + /*kernel_sel=*/COINBASE_SELECTOR, + /*ia=*/COINBASE_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); +} + +TEST_F(AvmKernelPositiveTests, kernelTimestamp) +{ + uint32_t dst_offset = 42; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_timestamp(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator fee_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_timestamp == FF(1); }); + EXPECT_TRUE(fee_row != trace.end()); + + expect_row(fee_row, + /*kernel_sel=*/TIMESTAMP_SELECTOR, + /*ia=*/TIMESTAMP_SELECTOR + + 1, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + test_kernel_lookup(apply_opcodes, checks); +} + /** * Negative Tests */ @@ -272,21 +362,21 @@ TEST_F(AvmKernelNegativeTests, incorrectIaPortal) negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); } -TEST_F(AvmKernelNegativeTests, incorrectIaFunction) +TEST_F(AvmKernelNegativeTests, incorrectIaDaGas) { uint32_t dst_offset = 42; FF incorrect_ia = FF(69); // We test that the sender opcode is inlcuded at index x in the public inputs - auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_function(dst_offset); }; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_da_gas(dst_offset); }; auto checks = [=](const std::vector& trace) { std::vector::const_iterator sender_row = std::ranges::find_if( - trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_function_selector == FF(1); }); + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_da_gas == FF(1); }); EXPECT_TRUE(sender_row != trace.end()); expect_row( sender_row, - /*kernel_sel=*/FUNCTION_SELECTOR, + /*kernel_sel=*/FEE_PER_DA_GAS_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*mem_idx_a*/ dst_offset); }; @@ -294,21 +384,21 @@ TEST_F(AvmKernelNegativeTests, incorrectIaFunction) negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); } -TEST_F(AvmKernelNegativeTests, incorrectIaDaGas) +TEST_F(AvmKernelNegativeTests, incorrectIal2Gas) { uint32_t dst_offset = 42; FF incorrect_ia = FF(69); // We test that the sender opcode is inlcuded at index x in the public inputs - auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_da_gas(dst_offset); }; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l2_gas(dst_offset); }; auto checks = [=](const std::vector& trace) { std::vector::const_iterator sender_row = std::ranges::find_if( - trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_da_gas == FF(1); }); + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l2_gas == FF(1); }); EXPECT_TRUE(sender_row != trace.end()); expect_row( sender_row, - /*kernel_sel=*/FEE_PER_DA_GAS_SELECTOR, + /*kernel_sel=*/FEE_PER_L2_GAS_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*mem_idx_a*/ dst_offset); }; @@ -316,21 +406,131 @@ TEST_F(AvmKernelNegativeTests, incorrectIaDaGas) negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); } -TEST_F(AvmKernelNegativeTests, incorrectIal2Gas) +TEST_F(AvmKernelNegativeTests, incorrectIaTransactionFee) { uint32_t dst_offset = 42; FF incorrect_ia = FF(69); // We test that the sender opcode is inlcuded at index x in the public inputs - auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_fee_per_l2_gas(dst_offset); }; + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_transaction_fee(dst_offset); }; auto checks = [=](const std::vector& trace) { std::vector::const_iterator sender_row = std::ranges::find_if( - trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_fee_per_l2_gas == FF(1); }); + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_transaction_fee == FF(1); }); EXPECT_TRUE(sender_row != trace.end()); expect_row( sender_row, - /*kernel_sel=*/FEE_PER_L2_GAS_SELECTOR, + /*kernel_sel=*/TRANSACTION_FEE_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaChainId) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_chain_id(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_chain_id == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/CHAIN_ID_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaVersion) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_version(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_chain_id == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/VERSION_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaBlockNumber) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_block_number(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_chain_id == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/BLOCK_NUMBER_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaTimestamp) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_timestamp(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_chain_id == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/TIMESTAMP_SELECTOR, + /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 + /*mem_idx_a*/ dst_offset); + }; + + negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); +} + +TEST_F(AvmKernelNegativeTests, incorrectIaCoinbase) +{ + uint32_t dst_offset = 42; + FF incorrect_ia = FF(69); + + // We test that the sender opcode is inlcuded at index x in the public inputs + auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_coinbase(dst_offset); }; + auto checks = [=](const std::vector& trace) { + std::vector::const_iterator sender_row = + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_coinbase == FF(1); }); + EXPECT_TRUE(sender_row != trace.end()); + + expect_row( + sender_row, + /*kernel_sel=*/COINBASE_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 /*mem_idx_a*/ dst_offset); }; From 2a74110f7ec2499381afae06f672335125faba78 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Wed, 8 May 2024 18:41:38 +0000 Subject: [PATCH 26/40] fix: transaction fee selector test --- .../cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp index 29492d95990..e12298c9a29 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -166,8 +166,8 @@ TEST_F(AvmKernelPositiveTests, kernelTransactionFee) EXPECT_TRUE(fee_row != trace.end()); expect_row(fee_row, - /*kernel_sel=*/FEE_PER_L2_GAS_SELECTOR, - /*ia=*/FEE_PER_L2_GAS_SELECTOR + + /*kernel_sel=*/TRANSCTION_FEE_SELECTOR, + /*ia=*/TRANSCTION_FEE_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 /*mem_idx_a*/ dst_offset); }; From 1285ccfeb6976065d07caa696cf56e5c975881ce Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Wed, 8 May 2024 19:13:34 +0000 Subject: [PATCH 27/40] fix: update tags to line up with kernel --- .../barretenberg/vm/avm_trace/avm_trace.cpp | 27 +++---- .../barretenberg/vm/avm_trace/avm_trace.hpp | 2 +- .../barretenberg/vm/tests/avm_kernel.test.cpp | 75 ++++++++++++------- 3 files changed, 62 insertions(+), 42 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp index f69c9789621..dab26ee521f 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -1058,14 +1058,11 @@ void AvmTraceBuilder::op_cmov( } // Helper function to add kernel lookup operations into the main trace -Row AvmTraceBuilder::create_kernel_lookup_opcode(uint32_t dst_offset, uint32_t selector, FF value) +Row AvmTraceBuilder::create_kernel_lookup_opcode(uint32_t dst_offset, uint32_t selector, FF value, AvmMemoryTag w_tag) { auto const clk = static_cast(main_trace.size()); - // Get the value of op sender from the mem trace - // TODO: the tag of sender should be a field element no? AvmMemoryTag r_tag = AvmMemoryTag::U0; - AvmMemoryTag w_tag = AvmMemoryTag::U32; // THIS WAS U32 mem_trace_builder.write_into_memory(clk, IntermRegister::IA, dst_offset, value, r_tag, w_tag); // TODO: must i constrain r in tag to be the type of the write operation in pil? @@ -1088,7 +1085,7 @@ Row AvmTraceBuilder::create_kernel_lookup_opcode(uint32_t dst_offset, uint32_t s void AvmTraceBuilder::op_sender(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_sender(); - Row row = create_kernel_lookup_opcode(dst_offset, SENDER_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, SENDER_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_sender = FF(1); main_trace.push_back(row); @@ -1097,7 +1094,7 @@ void AvmTraceBuilder::op_sender(uint32_t dst_offset) void AvmTraceBuilder::op_address(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_address(); - Row row = create_kernel_lookup_opcode(dst_offset, ADDRESS_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, ADDRESS_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_address = FF(1); main_trace.push_back(row); @@ -1106,7 +1103,7 @@ void AvmTraceBuilder::op_address(uint32_t dst_offset) void AvmTraceBuilder::op_portal(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_portal(); - Row row = create_kernel_lookup_opcode(dst_offset, PORTAL_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, PORTAL_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_portal = FF(1); main_trace.push_back(row); @@ -1115,7 +1112,7 @@ void AvmTraceBuilder::op_portal(uint32_t dst_offset) void AvmTraceBuilder::op_fee_per_da_gas(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_fee_per_da_gas(); - Row row = create_kernel_lookup_opcode(dst_offset, FEE_PER_DA_GAS_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, FEE_PER_DA_GAS_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_fee_per_da_gas = FF(1); main_trace.push_back(row); @@ -1124,7 +1121,7 @@ void AvmTraceBuilder::op_fee_per_da_gas(uint32_t dst_offset) void AvmTraceBuilder::op_fee_per_l2_gas(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_fee_per_l2_gas(); - Row row = create_kernel_lookup_opcode(dst_offset, FEE_PER_L2_GAS_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, FEE_PER_L2_GAS_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_fee_per_l2_gas = FF(1); main_trace.push_back(row); @@ -1133,7 +1130,7 @@ void AvmTraceBuilder::op_fee_per_l2_gas(uint32_t dst_offset) void AvmTraceBuilder::op_transaction_fee(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_transaction_fee(); - Row row = create_kernel_lookup_opcode(dst_offset, TRANSACTION_FEE_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, TRANSACTION_FEE_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_transaction_fee = FF(1); main_trace.push_back(row); @@ -1142,7 +1139,7 @@ void AvmTraceBuilder::op_transaction_fee(uint32_t dst_offset) void AvmTraceBuilder::op_chain_id(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_chain_id(); - Row row = create_kernel_lookup_opcode(dst_offset, CHAIN_ID_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, CHAIN_ID_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_chain_id = FF(1); main_trace.push_back(row); @@ -1151,7 +1148,7 @@ void AvmTraceBuilder::op_chain_id(uint32_t dst_offset) void AvmTraceBuilder::op_version(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_version(); - Row row = create_kernel_lookup_opcode(dst_offset, VERSION_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, VERSION_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_version = FF(1); main_trace.push_back(row); @@ -1160,7 +1157,7 @@ void AvmTraceBuilder::op_version(uint32_t dst_offset) void AvmTraceBuilder::op_block_number(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_block_number(); - Row row = create_kernel_lookup_opcode(dst_offset, BLOCK_NUMBER_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, BLOCK_NUMBER_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_block_number = FF(1); main_trace.push_back(row); @@ -1169,7 +1166,7 @@ void AvmTraceBuilder::op_block_number(uint32_t dst_offset) void AvmTraceBuilder::op_coinbase(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_coinbase(); - Row row = create_kernel_lookup_opcode(dst_offset, COINBASE_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, COINBASE_SELECTOR, ia_value, AvmMemoryTag::FF); row.avm_main_sel_op_coinbase = FF(1); main_trace.push_back(row); @@ -1178,7 +1175,7 @@ void AvmTraceBuilder::op_coinbase(uint32_t dst_offset) void AvmTraceBuilder::op_timestamp(uint32_t dst_offset) { FF ia_value = kernel_trace_builder.op_timestamp(); - Row row = create_kernel_lookup_opcode(dst_offset, TIMESTAMP_SELECTOR, ia_value); + Row row = create_kernel_lookup_opcode(dst_offset, TIMESTAMP_SELECTOR, ia_value, AvmMemoryTag::U64); row.avm_main_sel_op_timestamp = FF(1); main_trace.push_back(row); diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp index a0f8a3aca49..ad5aa3d429e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.hpp @@ -147,7 +147,7 @@ class AvmTraceBuilder { AvmBinaryTraceBuilder bin_trace_builder; AvmKernelTraceBuilder kernel_trace_builder; - Row create_kernel_lookup_opcode(uint32_t dst_offset, uint32_t selector, FF value); + Row create_kernel_lookup_opcode(uint32_t dst_offset, uint32_t selector, FF value, AvmMemoryTag w_tag); void finalise_mem_trace_lookup_counts(); IndirectThreeResolution resolve_ind_three( diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp index e12298c9a29..ac6db2841bb 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -1,5 +1,6 @@ #include "avm_common.test.hpp" +#include "barretenberg/vm/avm_trace/avm_common.hpp" #include "barretenberg/vm/avm_trace/avm_kernel_trace.hpp" #include "barretenberg/vm/avm_trace/constants.hpp" @@ -48,7 +49,7 @@ void test_kernel_lookup(OpcodesFunc apply_opcodes, CheckFunc check_trace) /* * Helper function to assert row values for a kernel lookup opcode */ -void expect_row(std::vector::const_iterator row, FF selector, FF ia, FF mem_idx_a) +void expect_row(std::vector::const_iterator row, FF selector, FF ia, FF mem_idx_a, AvmMemoryTag w_in_tag) { // Checks dependent on the opcode EXPECT_EQ(row->avm_kernel_kernel_sel, selector); @@ -60,7 +61,7 @@ void expect_row(std::vector::const_iterator row, FF selector, FF ia, FF mem EXPECT_EQ(row->avm_main_ind_a, FF(0)); EXPECT_EQ(row->avm_mem_op_a, FF(1)); // TODO: below should really be a field element for each type - EXPECT_EQ(row->avm_main_w_in_tag, static_cast(AvmMemoryTag::U32)); + EXPECT_EQ(row->avm_main_w_in_tag, static_cast(w_in_tag)); EXPECT_EQ(row->avm_main_q_kernel_lookup, FF(1)); } @@ -78,7 +79,8 @@ TEST_F(AvmKernelPositiveTests, kernelSender) /*kernel_sel=*/SENDER_SELECTOR, /*ia=*/SENDER_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); @@ -97,7 +99,8 @@ TEST_F(AvmKernelPositiveTests, kernelAddress) /*kernel_sel=*/ADDRESS_SELECTOR, /*ia=*/ADDRESS_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); } @@ -115,7 +118,8 @@ TEST_F(AvmKernelPositiveTests, kernelPortal) /*kernel_sel=*/PORTAL_SELECTOR, /*ia=*/PORTAL_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); } @@ -133,7 +137,8 @@ TEST_F(AvmKernelPositiveTests, kernelFeePerDa) /*kernel_sel=*/FEE_PER_DA_GAS_SELECTOR, /*ia=*/FEE_PER_DA_GAS_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); } @@ -151,7 +156,8 @@ TEST_F(AvmKernelPositiveTests, kernelFeePerL2) /*kernel_sel=*/FEE_PER_L2_GAS_SELECTOR, /*ia=*/FEE_PER_L2_GAS_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); } @@ -166,10 +172,11 @@ TEST_F(AvmKernelPositiveTests, kernelTransactionFee) EXPECT_TRUE(fee_row != trace.end()); expect_row(fee_row, - /*kernel_sel=*/TRANSCTION_FEE_SELECTOR, - /*ia=*/TRANSCTION_FEE_SELECTOR + + /*kernel_sel=*/TRANSACTION_FEE_SELECTOR, + /*ia=*/TRANSACTION_FEE_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); } @@ -187,7 +194,8 @@ TEST_F(AvmKernelPositiveTests, kernelChainId) /*kernel_sel=*/CHAIN_ID_SELECTOR, /*ia=*/CHAIN_ID_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); } @@ -205,7 +213,8 @@ TEST_F(AvmKernelPositiveTests, kernelVersion) /*kernel_sel=*/VERSION_SELECTOR, /*ia=*/VERSION_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); } @@ -223,7 +232,8 @@ TEST_F(AvmKernelPositiveTests, kernelBlockNumber) /*kernel_sel=*/BLOCK_NUMBER_SELECTOR, /*ia=*/BLOCK_NUMBER_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); } @@ -241,7 +251,8 @@ TEST_F(AvmKernelPositiveTests, kernelCoinbase) /*kernel_sel=*/COINBASE_SELECTOR, /*ia=*/COINBASE_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a*/ dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; test_kernel_lookup(apply_opcodes, checks); } @@ -259,7 +270,8 @@ TEST_F(AvmKernelPositiveTests, kernelTimestamp) /*kernel_sel=*/TIMESTAMP_SELECTOR, /*ia=*/TIMESTAMP_SELECTOR + 1, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a*/ dst_offset, + /*w_in_tag=*/AvmMemoryTag::U64); }; test_kernel_lookup(apply_opcodes, checks); } @@ -312,7 +324,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaSender) sender_row, /*kernel_sel=*/SENDER_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -334,7 +347,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaAddress) sender_row, /*kernel_sel=*/ADDRESS_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -356,7 +370,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaPortal) sender_row, /*kernel_sel=*/PORTAL_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -378,7 +393,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaDaGas) sender_row, /*kernel_sel=*/FEE_PER_DA_GAS_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -400,7 +416,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIal2Gas) sender_row, /*kernel_sel=*/FEE_PER_L2_GAS_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -422,7 +439,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaTransactionFee) sender_row, /*kernel_sel=*/TRANSACTION_FEE_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -444,7 +462,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaChainId) sender_row, /*kernel_sel=*/CHAIN_ID_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -466,7 +485,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaVersion) sender_row, /*kernel_sel=*/VERSION_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -488,7 +508,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaBlockNumber) sender_row, /*kernel_sel=*/BLOCK_NUMBER_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -510,7 +531,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaTimestamp) sender_row, /*kernel_sel=*/TIMESTAMP_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a*/ dst_offset, + /*w_in_tag=*/AvmMemoryTag::U64); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); @@ -532,7 +554,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaCoinbase) sender_row, /*kernel_sel=*/COINBASE_SELECTOR, /*ia=*/incorrect_ia, // Note the value generated above for public inputs is the same as the index read + 1 - /*mem_idx_a*/ dst_offset); + /*mem_idx_a=*/dst_offset, + /*w_in_tag=*/AvmMemoryTag::FF); }; negative_test_incorrect_ia_kernel_lookup(apply_opcodes, checks, incorrect_ia, "PERM_MAIN_MEM_A"); From e2bcca8b646ac9d39afe5eb5bea8196a37db805f Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Wed, 8 May 2024 20:11:15 +0000 Subject: [PATCH 28/40] feat: parallelise check circuit relations --- .../vm/generated/avm_circuit_builder.hpp | 342 +++++++++++------- 1 file changed, 218 insertions(+), 124 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 041bd98f8e1..64a5933221d 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -3,6 +3,9 @@ // AUTOGENERATED FILE #pragma once +#include +#include + #include "barretenberg/common/constexpr_utils.hpp" #include "barretenberg/common/throw_or_abort.hpp" #include "barretenberg/ecc/curves/bn254/fr.hpp" @@ -719,131 +722,222 @@ class AvmCircuitBuilder { return true; }; - if (!evaluate_relation.template operator()>("avm_alu", - Avm_vm::get_relation_label_avm_alu)) { - return false; - } - if (!evaluate_relation.template operator()>("avm_binary", - Avm_vm::get_relation_label_avm_binary)) { - return false; - } - if (!evaluate_relation.template operator()>("avm_main", - Avm_vm::get_relation_label_avm_main)) { - return false; - } - if (!evaluate_relation.template operator()>("avm_mem", - Avm_vm::get_relation_label_avm_mem)) { - return false; - } + // Evaluate check circuit closures as futures + std::vector> relation_futures; - if (!evaluate_logderivative.template operator()>("PERM_MAIN_ALU")) { - return false; - } - if (!evaluate_logderivative.template operator()>("PERM_MAIN_BIN")) { - return false; - } - if (!evaluate_logderivative.template operator()>("PERM_MAIN_MEM_A")) { - return false; - } - if (!evaluate_logderivative.template operator()>("PERM_MAIN_MEM_B")) { - return false; - } - if (!evaluate_logderivative.template operator()>("PERM_MAIN_MEM_C")) { - return false; - } - if (!evaluate_logderivative.template operator()>("PERM_MAIN_MEM_D")) { - return false; - } - if (!evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_A")) { - return false; - } - if (!evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_B")) { - return false; - } - if (!evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_C")) { - return false; - } - if (!evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_D")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_BYTE_LENGTHS")) { - return false; - } - if (!evaluate_logderivative.template operator()>( - "LOOKUP_BYTE_OPERATIONS")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_INTO_KERNEL")) { - return false; - } - if (!evaluate_logderivative.template operator()>("INCL_MAIN_TAG_ERR")) { - return false; - } - if (!evaluate_logderivative.template operator()>("INCL_MEM_TAG_ERR")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_MEM_RNG_CHK_LO")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_MEM_RNG_CHK_HI")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_POW_2_0")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_POW_2_1")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U8_0")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U8_1")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_0")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_1")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_2")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_3")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_4")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_5")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_6")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_7")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_8")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_9")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_10")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_11")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_12")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_13")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_U16_14")) { - return false; + auto avm_alu = [=]() { + return evaluate_relation.template operator()>("avm_alu", + Avm_vm::get_relation_label_avm_alu); + }; + relation_futures.emplace_back(std::async(std::launch::async, avm_alu)); + + auto avm_binary = [=]() { + return evaluate_relation.template operator()>("avm_binary", + Avm_vm::get_relation_label_avm_binary); + }; + relation_futures.emplace_back(std::async(std::launch::async, avm_binary)); + + auto avm_main = [=]() { + return evaluate_relation.template operator()>("avm_main", + Avm_vm::get_relation_label_avm_main); + }; + relation_futures.emplace_back(std::async(std::launch::async, avm_main)); + + auto avm_mem = [=]() { + return evaluate_relation.template operator()>("avm_mem", + Avm_vm::get_relation_label_avm_mem); + }; + relation_futures.emplace_back(std::async(std::launch::async, avm_mem)); + + auto perm_main_alu = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_ALU"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_alu)); + + auto perm_main_bin = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_BIN"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_bin)); + + auto perm_main_mem_a = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_A"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_a)); + + auto perm_main_mem_b = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_B"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_b)); + + auto perm_main_mem_c = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_C"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_c)); + + auto perm_main_mem_d = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_D"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_d)); + + auto perm_main_mem_ind_a = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_A"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_a)); + + auto perm_main_mem_ind_b = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_B"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_b)); + + auto perm_main_mem_ind_c = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_C"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_c)); + + auto perm_main_mem_ind_d = [=]() { + return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_D"); + }; + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_d)); + + auto lookup_byte_lengths = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_BYTE_LENGTHS"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_lengths)); + + auto lookup_byte_operations = [=]() { + return evaluate_logderivative.template operator()>( + "LOOKUP_BYTE_OPERATIONS"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_operations)); + + auto lookup_into_kernel = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_INTO_KERNEL"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_into_kernel)); + + auto incl_main_tag_err = [=]() { + return evaluate_logderivative.template operator()>("INCL_MAIN_TAG_ERR"); + }; + relation_futures.emplace_back(std::async(std::launch::async, incl_main_tag_err)); + + auto incl_mem_tag_err = [=]() { + return evaluate_logderivative.template operator()>("INCL_MEM_TAG_ERR"); + }; + relation_futures.emplace_back(std::async(std::launch::async, incl_mem_tag_err)); + + auto lookup_mem_rng_chk_lo = [=]() { + return evaluate_logderivative.template operator()>( + "LOOKUP_MEM_RNG_CHK_LO"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_mem_rng_chk_lo)); + + auto lookup_mem_rng_chk_hi = [=]() { + return evaluate_logderivative.template operator()>( + "LOOKUP_MEM_RNG_CHK_HI"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_mem_rng_chk_hi)); + + auto lookup_pow_2_0 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_POW_2_0"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_pow_2_0)); + + auto lookup_pow_2_1 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_POW_2_1"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_pow_2_1)); + + auto lookup_u8_0 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U8_0"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u8_0)); + + auto lookup_u8_1 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U8_1"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u8_1)); + + auto lookup_u16_0 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_0"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_0)); + + auto lookup_u16_1 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_1"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_1)); + + auto lookup_u16_2 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_2"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_2)); + + auto lookup_u16_3 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_3"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_3)); + + auto lookup_u16_4 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_4"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_4)); + + auto lookup_u16_5 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_5"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_5)); + + auto lookup_u16_6 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_6"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_6)); + + auto lookup_u16_7 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_7"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_7)); + + auto lookup_u16_8 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_8"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_8)); + + auto lookup_u16_9 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_9"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_9)); + + auto lookup_u16_10 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_10"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_10)); + + auto lookup_u16_11 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_11"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_11)); + + auto lookup_u16_12 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_12"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_12)); + + auto lookup_u16_13 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_13"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_13)); + + auto lookup_u16_14 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_U16_14"); + }; + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_14)); + + // Wait for lookup evaluations to complete + for (auto& future : relation_futures) { + int result = future.get(); + if (!result) { + return false; + } } return true; From 7bff191677c0d500ce6b0743debc162333b778f0 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Wed, 8 May 2024 20:18:49 +0000 Subject: [PATCH 29/40] fix: forge fmt after constant gen --- .../src/core/libraries/ConstantsGen.sol | 44 +++++++++++++++---- 1 file changed, 35 insertions(+), 9 deletions(-) diff --git a/l1-contracts/src/core/libraries/ConstantsGen.sol b/l1-contracts/src/core/libraries/ConstantsGen.sol index 79001cb1708..5e06927b60a 100644 --- a/l1-contracts/src/core/libraries/ConstantsGen.sol +++ b/l1-contracts/src/core/libraries/ConstantsGen.sol @@ -97,11 +97,13 @@ library Constants { uint256 internal constant DA_BYTES_PER_FIELD = 32; uint256 internal constant DA_GAS_PER_BYTE = 16; uint256 internal constant FIXED_DA_GAS = 512; - uint256 internal constant CANONICAL_KEY_REGISTRY_ADDRESS = 0x1585e564a60e6ec974bc151b62705292ebfc75c33341986a47fd9749cedb567e; + uint256 internal constant CANONICAL_KEY_REGISTRY_ADDRESS = + 0x1585e564a60e6ec974bc151b62705292ebfc75c33341986a47fd9749cedb567e; uint256 internal constant AZTEC_ADDRESS_LENGTH = 1; uint256 internal constant GAS_FEES_LENGTH = 2; uint256 internal constant GAS_LENGTH = 2; - uint256 internal constant GAS_SETTINGS_LENGTH = GAS_LENGTH * 2 + GAS_FEES_LENGTH + /* inclusion_fee */ 1; + uint256 internal constant GAS_SETTINGS_LENGTH = + GAS_LENGTH * 2 + GAS_FEES_LENGTH /* inclusion_fee */ + 1; uint256 internal constant CALL_CONTEXT_LENGTH = 6; uint256 internal constant CONTENT_COMMITMENT_LENGTH = 4; uint256 internal constant CONTRACT_INSTANCE_LENGTH = 5; @@ -126,15 +128,39 @@ library Constants { uint256 internal constant NULLIFIER_LENGTH = 3; uint256 internal constant SCOPED_NULLIFIER_LENGTH = NULLIFIER_LENGTH + 1; uint256 internal constant SIDE_EFFECT_LENGTH = 2; - uint256 internal constant STATE_REFERENCE_LENGTH = APPEND_ONLY_TREE_SNAPSHOT_LENGTH + PARTIAL_STATE_REFERENCE_LENGTH; + uint256 internal constant STATE_REFERENCE_LENGTH = + APPEND_ONLY_TREE_SNAPSHOT_LENGTH + PARTIAL_STATE_REFERENCE_LENGTH; uint256 internal constant TX_CONTEXT_LENGTH = 2 + GAS_SETTINGS_LENGTH; uint256 internal constant TX_REQUEST_LENGTH = 2 + TX_CONTEXT_LENGTH + FUNCTION_DATA_LENGTH; - uint256 internal constant HEADER_LENGTH = APPEND_ONLY_TREE_SNAPSHOT_LENGTH + CONTENT_COMMITMENT_LENGTH + STATE_REFERENCE_LENGTH + GLOBAL_VARIABLES_LENGTH; - uint256 internal constant PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 3 + MAX_BLOCK_NUMBER_LENGTH + (READ_REQUEST_LENGTH * MAX_NOTE_HASH_READ_REQUESTS_PER_CALL) + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + (NULLIFIER_KEY_VALIDATION_REQUEST_LENGTH * MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL) + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + 1 + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + (SIDE_EFFECT_LENGTH * MAX_ENCRYPTED_LOGS_PER_CALL) + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 2 + HEADER_LENGTH + TX_CONTEXT_LENGTH; - uint256 internal constant PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 2 + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + (READ_REQUEST_LENGTH * MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL) + (CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH * MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL) + (CONTRACT_STORAGE_READ_LENGTH * MAX_PUBLIC_DATA_READS_PER_CALL) + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 1 + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + AZTEC_ADDRESS_LENGTH + /* revert_code */ 1 + 2 * GAS_LENGTH + /* transaction_fee */ 1; - uint256 internal constant PRIVATE_CALL_STACK_ITEM_LENGTH = AZTEC_ADDRESS_LENGTH + FUNCTION_DATA_LENGTH + PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH; - uint256 internal constant PUBLIC_CONTEXT_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + GAS_LENGTH + 2; - uint256 internal constant ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH = 2 + FUNCTION_DATA_LENGTH + CALL_CONTEXT_LENGTH; + uint256 internal constant HEADER_LENGTH = APPEND_ONLY_TREE_SNAPSHOT_LENGTH + + CONTENT_COMMITMENT_LENGTH + STATE_REFERENCE_LENGTH + GLOBAL_VARIABLES_LENGTH; + uint256 internal constant PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 3 + + MAX_BLOCK_NUMBER_LENGTH + (READ_REQUEST_LENGTH * MAX_NOTE_HASH_READ_REQUESTS_PER_CALL) + + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + + (NULLIFIER_KEY_VALIDATION_REQUEST_LENGTH * MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_CALL) + + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL + + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + 1 + + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + + (SIDE_EFFECT_LENGTH * MAX_ENCRYPTED_LOGS_PER_CALL) + + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 2 + HEADER_LENGTH + TX_CONTEXT_LENGTH; + uint256 internal constant PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 2 + + (READ_REQUEST_LENGTH * MAX_NULLIFIER_READ_REQUESTS_PER_CALL) + + (READ_REQUEST_LENGTH * MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_CALL) + + (CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH * MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL) + + (CONTRACT_STORAGE_READ_LENGTH * MAX_PUBLIC_DATA_READS_PER_CALL) + + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + (NOTE_HASH_LENGTH * MAX_NEW_NOTE_HASHES_PER_CALL) + + (NULLIFIER_LENGTH * MAX_NEW_NULLIFIERS_PER_CALL) + + (L2_TO_L1_MESSAGE_LENGTH * MAX_NEW_L2_TO_L1_MSGS_PER_CALL) + 2 + + (SIDE_EFFECT_LENGTH * MAX_UNENCRYPTED_LOGS_PER_CALL) + 1 + HEADER_LENGTH + + GLOBAL_VARIABLES_LENGTH + AZTEC_ADDRESS_LENGTH /* revert_code */ + 1 + 2 * GAS_LENGTH /* transaction_fee */ + + 1; + uint256 internal constant PRIVATE_CALL_STACK_ITEM_LENGTH = + AZTEC_ADDRESS_LENGTH + FUNCTION_DATA_LENGTH + PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH; + uint256 internal constant PUBLIC_CONTEXT_INPUTS_LENGTH = + CALL_CONTEXT_LENGTH + HEADER_LENGTH + GLOBAL_VARIABLES_LENGTH + GAS_LENGTH + 2; + uint256 internal constant ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_LENGTH = + 2 + FUNCTION_DATA_LENGTH + CALL_CONTEXT_LENGTH; uint256 internal constant GET_NOTES_ORACLE_RETURN_LENGTH = 674; uint256 internal constant NOTE_HASHES_NUM_BYTES_PER_BASE_ROLLUP = 2048; uint256 internal constant NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP = 2048; From 115f17cd8799c704aa1b6739e06dbab68c060af5 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Wed, 8 May 2024 20:37:58 +0000 Subject: [PATCH 30/40] fix: no futures for wasm builds --- .../vm/generated/avm_circuit_builder.hpp | 212 ++++++++++++++---- 1 file changed, 172 insertions(+), 40 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index 64a5933221d..d21f4e6f89c 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -3,7 +3,10 @@ // AUTOGENERATED FILE #pragma once +#ifndef __wasm__ #include +#endif + #include #include "barretenberg/common/constexpr_utils.hpp" @@ -723,215 +726,219 @@ class AvmCircuitBuilder { }; // Evaluate check circuit closures as futures +#ifndef __wasm__ std::vector> relation_futures; +#endif auto avm_alu = [=]() { return evaluate_relation.template operator()>("avm_alu", Avm_vm::get_relation_label_avm_alu); }; - relation_futures.emplace_back(std::async(std::launch::async, avm_alu)); auto avm_binary = [=]() { return evaluate_relation.template operator()>("avm_binary", Avm_vm::get_relation_label_avm_binary); }; - relation_futures.emplace_back(std::async(std::launch::async, avm_binary)); auto avm_main = [=]() { return evaluate_relation.template operator()>("avm_main", Avm_vm::get_relation_label_avm_main); }; - relation_futures.emplace_back(std::async(std::launch::async, avm_main)); auto avm_mem = [=]() { return evaluate_relation.template operator()>("avm_mem", Avm_vm::get_relation_label_avm_mem); }; - relation_futures.emplace_back(std::async(std::launch::async, avm_mem)); auto perm_main_alu = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_ALU"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_alu)); auto perm_main_bin = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_BIN"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_bin)); auto perm_main_mem_a = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_A"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_a)); auto perm_main_mem_b = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_B"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_b)); auto perm_main_mem_c = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_C"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_c)); auto perm_main_mem_d = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_D"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_d)); auto perm_main_mem_ind_a = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_A"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_a)); auto perm_main_mem_ind_b = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_B"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_b)); auto perm_main_mem_ind_c = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_C"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_c)); auto perm_main_mem_ind_d = [=]() { return evaluate_logderivative.template operator()>("PERM_MAIN_MEM_IND_D"); }; - relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_d)); auto lookup_byte_lengths = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_BYTE_LENGTHS"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_lengths)); auto lookup_byte_operations = [=]() { return evaluate_logderivative.template operator()>( "LOOKUP_BYTE_OPERATIONS"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_operations)); auto lookup_into_kernel = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_INTO_KERNEL"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_into_kernel)); auto incl_main_tag_err = [=]() { return evaluate_logderivative.template operator()>("INCL_MAIN_TAG_ERR"); }; - relation_futures.emplace_back(std::async(std::launch::async, incl_main_tag_err)); auto incl_mem_tag_err = [=]() { return evaluate_logderivative.template operator()>("INCL_MEM_TAG_ERR"); }; - relation_futures.emplace_back(std::async(std::launch::async, incl_mem_tag_err)); auto lookup_mem_rng_chk_lo = [=]() { return evaluate_logderivative.template operator()>( "LOOKUP_MEM_RNG_CHK_LO"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_mem_rng_chk_lo)); auto lookup_mem_rng_chk_hi = [=]() { return evaluate_logderivative.template operator()>( "LOOKUP_MEM_RNG_CHK_HI"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_mem_rng_chk_hi)); auto lookup_pow_2_0 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_POW_2_0"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_pow_2_0)); auto lookup_pow_2_1 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_POW_2_1"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_pow_2_1)); auto lookup_u8_0 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U8_0"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u8_0)); auto lookup_u8_1 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U8_1"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u8_1)); auto lookup_u16_0 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_0"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_0)); auto lookup_u16_1 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_1"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_1)); auto lookup_u16_2 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_2"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_2)); auto lookup_u16_3 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_3"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_3)); auto lookup_u16_4 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_4"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_4)); auto lookup_u16_5 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_5"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_5)); auto lookup_u16_6 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_6"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_6)); auto lookup_u16_7 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_7"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_7)); auto lookup_u16_8 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_8"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_8)); auto lookup_u16_9 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_9"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_9)); auto lookup_u16_10 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_10"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_10)); auto lookup_u16_11 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_11"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_11)); auto lookup_u16_12 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_12"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_12)); auto lookup_u16_13 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_13"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_13)); auto lookup_u16_14 = [=]() { return evaluate_logderivative.template operator()>("LOOKUP_U16_14"); }; - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_14)); +#ifndef __wasm__ + relation_futures.emplace_back(std::async(std::launch::async, avm_alu)); + relation_futures.emplace_back(std::async(std::launch::async, avm_binary)); + relation_futures.emplace_back(std::async(std::launch::async, avm_main)); + relation_futures.emplace_back(std::async(std::launch::async, avm_mem)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_alu)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_bin)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_a)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_b)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_c)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_d)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_a)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_b)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_c)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_d)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_lengths)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_operations)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_into_kernel)); + relation_futures.emplace_back(std::async(std::launch::async, incl_main_tag_err)); + relation_futures.emplace_back(std::async(std::launch::async, incl_mem_tag_err)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_mem_rng_chk_lo)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_mem_rng_chk_hi)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_pow_2_0)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_pow_2_1)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u8_0)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u8_1)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_0)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_1)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_2)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_3)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_4)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_5)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_6)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_7)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_8)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_9)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_10)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_11)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_13)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_12)); + + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_14)); // Wait for lookup evaluations to complete for (auto& future : relation_futures) { int result = future.get(); @@ -939,6 +946,131 @@ class AvmCircuitBuilder { return false; } } +#else + if (!avm_alu()) { + return false; + }; + if (!avm_binary()) { + return false; + }; + if (!avm_main()) { + return false; + }; + if (!avm_mem()) { + return false; + }; + if (!perm_main_alu()) { + return false; + }; + if (!perm_main_bin()) { + return false; + }; + if (!perm_main_mem_a()) { + return false; + }; + if (!perm_main_mem_b()) { + return false; + }; + if (!perm_main_mem_c()) { + return false; + }; + if (!perm_main_mem_d()) { + return false; + }; + if (!perm_main_mem_ind_a()) { + return false; + }; + if (!perm_main_mem_ind_b()) { + return false; + }; + if (!perm_main_mem_ind_c()) { + return false; + }; + if (!perm_main_mem_ind_d()) { + return false; + }; + if (!lookup_byte_lengths()) { + return false; + }; + if (!lookup_byte_operations()) { + return false; + }; + if (!lookup_into_kernel()) { + return false; + }; + if (!incl_main_tag_err()) { + return false; + }; + if (!incl_mem_tag_err()) { + return false; + }; + if (!lookup_mem_rng_chk_lo()) { + return false; + }; + if (!lookup_mem_rng_chk_hi()) { + return false; + }; + if (!lookup_pow_2_0()) { + return false; + }; + if (!lookup_pow_2_1()) { + return false; + }; + if (!lookup_u8_0()) { + return false; + }; + if (!lookup_u8_1()) { + return false; + }; + if (!lookup_u16_0()) { + return false; + }; + if (!lookup_u16_1()) { + return false; + }; + if (!lookup_u16_2()) { + return false; + }; + if (!lookup_u16_3()) { + return false; + }; + if (!lookup_u16_4()) { + return false; + }; + if (!lookup_u16_5()) { + return false; + }; + if (!lookup_u16_6()) { + return false; + }; + if (!lookup_u16_7()) { + return false; + }; + if (!lookup_u16_8()) { + return false; + }; + if (!lookup_u16_9()) { + return false; + }; + if (!lookup_u16_10()) { + return false; + }; + if (!lookup_u16_11()) { + return false; + }; + if (!lookup_u16_13()) { + return false; + }; + if (!lookup_u16_12()) { + return false; + }; + if (!lookup_u16_13()) { + return false; + }; + if (!lookup_u16_14()) { + return false; + }; +#endif return true; } From de663f159fc1170d8708152f1265020653d91eda Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 9 May 2024 16:36:54 +0000 Subject: [PATCH 31/40] feat: fix segfaults in parallel circuit checking --- .../barretenberg/vm/avm_trace/avm_common.hpp | 1 + .../vm/avm_trace/avm_execution.cpp | 4 ++-- .../vm/generated/avm_circuit_builder.hpp | 8 +++----- .../vm/generated/avm_verifier.cpp | 19 +++++++++++++++---- .../vm/generated/avm_verifier.hpp | 3 ++- .../vm/tests/avm_bitwise.test.cpp | 5 ++++- .../barretenberg/vm/tests/helpers.test.cpp | 7 ++----- 7 files changed, 29 insertions(+), 18 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_common.hpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_common.hpp index e3c4e90d01b..1dd2eac108a 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_common.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_common.hpp @@ -2,6 +2,7 @@ #include "barretenberg/stdlib_circuit_builders/circuit_builder_base.hpp" #include "barretenberg/vm/generated/avm_circuit_builder.hpp" +#include "constants.hpp" #include namespace bb::avm_trace { diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp index 0617412f333..d99ef0e2454 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp @@ -55,8 +55,8 @@ bool Execution::verify(AvmFlavor::VerificationKey vk, HonkProof const& proof) // crs_factory_); // output_state.pcs_verification_key = std::move(pcs_verification_key); - // TODO: pass in above - std::vector public_inputs = {}; + // TODO: We hardcode public inputs for now + std::array public_inputs = {}; return verifier.verify_proof(proof, public_inputs); } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index d21f4e6f89c..0d7c7f4b2b3 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -725,11 +725,6 @@ class AvmCircuitBuilder { return true; }; - // Evaluate check circuit closures as futures -#ifndef __wasm__ - std::vector> relation_futures; -#endif - auto avm_alu = [=]() { return evaluate_relation.template operator()>("avm_alu", Avm_vm::get_relation_label_avm_alu); @@ -898,6 +893,9 @@ class AvmCircuitBuilder { }; #ifndef __wasm__ + // Evaluate check circuit closures as futures + std::vector> relation_futures; + relation_futures.emplace_back(std::async(std::launch::async, avm_alu)); relation_futures.emplace_back(std::async(std::launch::async, avm_binary)); relation_futures.emplace_back(std::async(std::launch::async, avm_main)); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 1681e99397d..e77d159c1e6 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -5,6 +5,7 @@ #include "barretenberg/numeric/bitop/get_msb.hpp" #include "barretenberg/polynomials/polynomial.hpp" #include "barretenberg/transcript/transcript.hpp" +#include "barretenberg/vm/avm_trace/constants.hpp" namespace bb { @@ -28,9 +29,16 @@ AvmVerifier& AvmVerifier::operator=(AvmVerifier&& other) noexcept using FF = AvmFlavor::FF; // Evaluate the given public input column over the multivariate challenge points -[[maybe_unused]] FF evaluate_public_input_column(std::vector points, std::vector challenges) +[[maybe_unused]] FF evaluate_public_input_column(std::array points, + const size_t circuit_size, + std::vector challenges) { - Polynomial polynomial(points); + // TODO: we pad the points to the circuit size in order to get the correct evaluation + // This is not efficient, and will not be valid in production + std::vector new_points(circuit_size, 0); + std::copy(points.begin(), points.end(), new_points.data()); + + Polynomial polynomial(new_points); return polynomial.evaluate_mle(challenges); } @@ -38,7 +46,7 @@ using FF = AvmFlavor::FF; * @brief This function verifies an Avm Honk proof for given program settings. * */ -bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& public_inputs) +bool AvmVerifier::verify_proof(const HonkProof& proof, const std::array& public_inputs) { using Flavor = AvmFlavor; using FF = Flavor::FF; @@ -492,6 +500,7 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu commitments.lookup_u16_13 = transcript->template receive_from_prover(commitment_labels.lookup_u16_13); commitments.lookup_u16_14 = transcript->template receive_from_prover(commitment_labels.lookup_u16_14); + info("sumcheck verify start"); // Execute Sumcheck Verifier const size_t log_circuit_size = numeric::get_msb(circuit_size); auto sumcheck = SumcheckVerifier(log_circuit_size, transcript); @@ -508,11 +517,13 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu // If Sumcheck did not verify, return false if (sumcheck_verified.has_value() && !sumcheck_verified.value()) { + info("sumcheck failed"); return false; } - FF public_column_evaluation = evaluate_public_input_column(public_inputs, multivariate_challenge); + FF public_column_evaluation = evaluate_public_input_column(public_inputs, circuit_size, multivariate_challenge); if (public_column_evaluation != claimed_evaluations.avm_kernel_kernel_inputs__is_public) { + info("public inputs column evaluation failed"); return false; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp index 4842c5425cd..ac6ac02cdcb 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp @@ -3,6 +3,7 @@ #pragma once #include "barretenberg/plonk/proof_system/types/proof.hpp" #include "barretenberg/sumcheck/sumcheck.hpp" +#include "barretenberg/vm/avm_trace/constants.hpp" #include "barretenberg/vm/generated/avm_flavor.hpp" namespace bb { @@ -22,7 +23,7 @@ class AvmVerifier { AvmVerifier& operator=(const AvmVerifier& other) = delete; AvmVerifier& operator=(AvmVerifier&& other) noexcept; - bool verify_proof(const HonkProof& proof, const std::vector& public_inputs); + bool verify_proof(const HonkProof& proof, const std::array& public_inputs); std::shared_ptr key; std::map commitments; diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp index 3259a74383c..f63c259ff76 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp @@ -488,6 +488,9 @@ INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, TEST_P(AvmBitwiseTestsAnd, AllAndTest) { + std::array kernel_inputs = {}; + AvmTraceBuilder trace_builder(kernel_inputs); + const auto [operands, mem_tag] = GetParam(); const auto [a, b, output] = operands; trace_builder.op_set(0, a, 0, mem_tag); @@ -500,7 +503,7 @@ TEST_P(AvmBitwiseTestsAnd, AllAndTest) FF ff_b = FF(uint256_t::from_uint128(b)); FF ff_output = FF(uint256_t::from_uint128(output)); common_validate_bit_op(trace, 0, ff_a, ff_b, ff_output, FF(0), FF(1), FF(2), mem_tag); - validate_trace(std::move(trace), {}, true); + validate_trace(std::move(trace), kernel_inputs, true); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsAnd, diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 07b40fbe25c..f5fbaf91166 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -1,4 +1,5 @@ #include "avm_common.test.hpp" +#include "barretenberg/vm/avm_trace/constants.hpp" #include "barretenberg/vm/generated/avm_flavor.hpp" namespace tests_avm { @@ -31,11 +32,7 @@ void validate_trace(std::vector&& trace, std::array pub_inputs; - std::copy(public_inputs.begin(), public_inputs.end(), pub_inputs.data()); - - bool verified = verifier.verify_proof(proof, pub_inputs); + bool verified = verifier.verify_proof(proof, public_inputs); EXPECT_TRUE(verified); } From c910000d3f975eab8ad8facd03c76e08f25a3fc9 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 9 May 2024 16:42:03 +0000 Subject: [PATCH 32/40] fix: missed log --- barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index e77d159c1e6..ad4ca704aed 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -500,7 +500,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::arraytemplate receive_from_prover(commitment_labels.lookup_u16_13); commitments.lookup_u16_14 = transcript->template receive_from_prover(commitment_labels.lookup_u16_14); - info("sumcheck verify start"); // Execute Sumcheck Verifier const size_t log_circuit_size = numeric::get_msb(circuit_size); auto sumcheck = SumcheckVerifier(log_circuit_size, transcript); From fd728c70f98ad02524a38ab840014caf67afa0f5 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 9 May 2024 16:43:53 +0000 Subject: [PATCH 33/40] fix: incorrect kernel tests --- .../cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp index ac6db2841bb..8628b02ecdb 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_kernel.test.cpp @@ -478,7 +478,7 @@ TEST_F(AvmKernelNegativeTests, incorrectIaVersion) auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_version(dst_offset); }; auto checks = [=](const std::vector& trace) { std::vector::const_iterator sender_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_chain_id == FF(1); }); + std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_version == FF(1); }); EXPECT_TRUE(sender_row != trace.end()); expect_row( @@ -500,8 +500,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaBlockNumber) // We test that the sender opcode is inlcuded at index x in the public inputs auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_block_number(dst_offset); }; auto checks = [=](const std::vector& trace) { - std::vector::const_iterator sender_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_chain_id == FF(1); }); + std::vector::const_iterator sender_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_block_number == FF(1); }); EXPECT_TRUE(sender_row != trace.end()); expect_row( @@ -523,8 +523,8 @@ TEST_F(AvmKernelNegativeTests, incorrectIaTimestamp) // We test that the sender opcode is inlcuded at index x in the public inputs auto apply_opcodes = [=](AvmTraceBuilder& trace_builder) { trace_builder.op_timestamp(dst_offset); }; auto checks = [=](const std::vector& trace) { - std::vector::const_iterator sender_row = - std::ranges::find_if(trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_chain_id == FF(1); }); + std::vector::const_iterator sender_row = std::ranges::find_if( + trace.begin(), trace.end(), [](Row r) { return r.avm_main_sel_op_timestamp == FF(1); }); EXPECT_TRUE(sender_row != trace.end()); expect_row( From ecdf742c59bb8879e017b890194bc64ccb9d02da Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 9 May 2024 16:56:11 +0000 Subject: [PATCH 34/40] =?UTF-8?q?=F0=9F=A7=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp | 2 -- .../circuits.js/src/structs/public_circuit_public_inputs.ts | 1 - 2 files changed, 3 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp index dab26ee521f..9e27824ec23 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_trace.cpp @@ -1065,8 +1065,6 @@ Row AvmTraceBuilder::create_kernel_lookup_opcode(uint32_t dst_offset, uint32_t s AvmMemoryTag r_tag = AvmMemoryTag::U0; mem_trace_builder.write_into_memory(clk, IntermRegister::IA, dst_offset, value, r_tag, w_tag); - // TODO: must i constrain r in tag to be the type of the write operation in pil? - // .avm_main_r_in_tag = FF(static_cast(in_tag)), return Row{ .avm_main_clk = clk, .avm_kernel_kernel_sel = selector, diff --git a/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts b/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts index 007fc16b87a..77b4f05483c 100644 --- a/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts +++ b/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts @@ -42,7 +42,6 @@ import { SideEffect } from './side_effects.js'; /** * Public inputs to a public circuit. */ -// UH: SideEffect and ReadRequest are the same type? export class PublicCircuitPublicInputs { constructor( /** From d6aeda869cd01f62d4964dc9b1f8313ee48c1400 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 9 May 2024 17:39:41 +0000 Subject: [PATCH 35/40] feat: use codegen, vector public inputs - pubs now misaligned --- .../relations/generated/avm/avm_main.hpp | 21 +- .../vm/avm_trace/avm_execution.cpp | 2 +- .../vm/generated/avm_circuit_builder.hpp | 346 ++++++++++-------- .../barretenberg/vm/generated/avm_flavor.hpp | 8 +- .../vm/generated/avm_verifier.cpp | 9 +- .../vm/generated/avm_verifier.hpp | 3 +- .../vm/tests/avm_arithmetic.test.cpp | 2 +- .../vm/tests/avm_bitwise.test.cpp | 2 +- .../barretenberg/vm/tests/helpers.test.cpp | 14 +- 9 files changed, 222 insertions(+), 185 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp index d99ff41f473..4135688eabc 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp @@ -182,9 +182,10 @@ template class avm_mainImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 3, 3, 2, + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, }; template @@ -502,8 +503,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(38); - auto tmp = ((avm_main_sel_op_fdiv + avm_main_sel_op_div) * - (((avm_main_ib * avm_main_inv) - FF(1)) + avm_main_op_err)); + auto tmp = (avm_main_mem_op_c * (-avm_main_mem_op_c + FF(1))); tmp *= scaling_factor; std::get<38>(evals) += tmp; } @@ -511,7 +511,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(39); - auto tmp = (((avm_main_sel_op_fdiv + avm_main_sel_op_div) * avm_main_op_err) * (-avm_main_inv + FF(1))); + auto tmp = (avm_main_mem_op_d * (-avm_main_mem_op_d + FF(1))); tmp *= scaling_factor; std::get<39>(evals) += tmp; } @@ -535,7 +535,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(42); - auto tmp = (avm_main_op_err * ((avm_main_sel_op_fdiv + avm_main_sel_op_div) - FF(1))); + auto tmp = (avm_main_rwc * (-avm_main_rwc + FF(1))); tmp *= scaling_factor; std::get<42>(evals) += tmp; } @@ -601,7 +601,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(50); - auto tmp = (avm_main_sel_op_fdiv * (((avm_main_ib * avm_main_inv) - FF(1)) + avm_main_op_err)); + auto tmp = ((avm_main_sel_op_fdiv + avm_main_sel_op_div) * + (((avm_main_ib * avm_main_inv) - FF(1)) + avm_main_op_err)); tmp *= scaling_factor; std::get<50>(evals) += tmp; } @@ -609,7 +610,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(51); - auto tmp = ((avm_main_sel_op_fdiv * avm_main_op_err) * (-avm_main_inv + FF(1))); + auto tmp = (((avm_main_sel_op_fdiv + avm_main_sel_op_div) * avm_main_op_err) * (-avm_main_inv + FF(1))); tmp *= scaling_factor; std::get<51>(evals) += tmp; } @@ -633,7 +634,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(54); - auto tmp = (avm_main_op_err * (avm_main_sel_op_fdiv - FF(1))); + auto tmp = (avm_main_op_err * ((avm_main_sel_op_fdiv + avm_main_sel_op_div) - FF(1))); tmp *= scaling_factor; std::get<54>(evals) += tmp; } diff --git a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp index 117cbe91481..0ebf977df75 100644 --- a/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/avm_trace/avm_execution.cpp @@ -56,7 +56,7 @@ bool Execution::verify(AvmFlavor::VerificationKey vk, HonkProof const& proof) // output_state.pcs_verification_key = std::move(pcs_verification_key); // TODO: We hardcode public inputs for now - std::array public_inputs = {}; + std::vector public_inputs = {}; return verifier.verify_proof(proof, public_inputs); } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index c5aa5e39fb7..fa4c5ce0fad 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -3,12 +3,11 @@ // AUTOGENERATED FILE #pragma once +#include #ifndef __wasm__ #include #endif -#include - #include "barretenberg/common/constexpr_utils.hpp" #include "barretenberg/common/throw_or_abort.hpp" #include "barretenberg/ecc/curves/bn254/fr.hpp" @@ -424,8 +423,8 @@ class AvmCircuitBuilder { using Polynomial = Flavor::Polynomial; using ProverPolynomials = Flavor::ProverPolynomials; - static constexpr size_t num_fixed_columns = 324; - static constexpr size_t num_polys = 272; + static constexpr size_t num_fixed_columns = 342; + static constexpr size_t num_polys = 290; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -813,6 +812,9 @@ class AvmCircuitBuilder { return true; }; + // Evaluate check circuit closures as futures + std::vector> relation_futures; + auto avm_alu = [=]() { return evaluate_relation.template operator()>("avm_alu", Avm_vm::get_relation_label_avm_alu); @@ -980,51 +982,136 @@ class AvmCircuitBuilder { return evaluate_logderivative.template operator()>("LOOKUP_U16_14"); }; + auto lookup_div_u16_0 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_0"); + }; + + auto lookup_div_u16_1 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_1"); + }; + + auto lookup_div_u16_2 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_2"); + }; + + auto lookup_div_u16_3 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_3"); + }; + + auto lookup_div_u16_4 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_4"); + }; + + auto lookup_div_u16_5 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_5"); + }; + + auto lookup_div_u16_6 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_6"); + }; + + auto lookup_div_u16_7 = [=]() { + return evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_7"); + }; + #ifndef __wasm__ - // Evaluate check circuit closures as futures - std::vector> relation_futures; relation_futures.emplace_back(std::async(std::launch::async, avm_alu)); + relation_futures.emplace_back(std::async(std::launch::async, avm_binary)); + relation_futures.emplace_back(std::async(std::launch::async, avm_main)); + relation_futures.emplace_back(std::async(std::launch::async, avm_mem)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_alu)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_bin)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_a)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_b)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_c)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_d)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_a)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_b)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_c)); + relation_futures.emplace_back(std::async(std::launch::async, perm_main_mem_ind_d)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_lengths)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_byte_operations)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_into_kernel)); + relation_futures.emplace_back(std::async(std::launch::async, incl_main_tag_err)); + relation_futures.emplace_back(std::async(std::launch::async, incl_mem_tag_err)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_mem_rng_chk_lo)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_mem_rng_chk_hi)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_pow_2_0)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_pow_2_1)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u8_0)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u8_1)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_0)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_1)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_2)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_3)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_4)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_5)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_6)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_7)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_8)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_9)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_10)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_11)); - relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_13)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_12)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_13)); + relation_futures.emplace_back(std::async(std::launch::async, lookup_u16_14)); + + relation_futures.emplace_back(std::async(std::launch::async, lookup_div_u16_0)); + + relation_futures.emplace_back(std::async(std::launch::async, lookup_div_u16_1)); + + relation_futures.emplace_back(std::async(std::launch::async, lookup_div_u16_2)); + + relation_futures.emplace_back(std::async(std::launch::async, lookup_div_u16_3)); + + relation_futures.emplace_back(std::async(std::launch::async, lookup_div_u16_4)); + + relation_futures.emplace_back(std::async(std::launch::async, lookup_div_u16_5)); + + relation_futures.emplace_back(std::async(std::launch::async, lookup_div_u16_6)); + + relation_futures.emplace_back(std::async(std::launch::async, lookup_div_u16_7)); + // Wait for lookup evaluations to complete for (auto& future : relation_futures) { int result = future.get(); @@ -1033,155 +1120,104 @@ class AvmCircuitBuilder { } } #else - if (!avm_alu()) { - return false; - }; - if (!avm_binary()) { - return false; - }; - if (!avm_main()) { - return false; - }; - if (!avm_mem()) { - return false; - }; - if (!perm_main_alu()) { - return false; - }; - if (!perm_main_bin()) { - return false; - }; - if (!perm_main_mem_a()) { - return false; - }; - if (!perm_main_mem_b()) { - return false; - }; - if (!perm_main_mem_c()) { - return false; - }; - if (!perm_main_mem_d()) { - return false; - }; - if (!perm_main_mem_ind_a()) { - return false; - }; - if (!perm_main_mem_ind_b()) { - return false; - }; - if (!perm_main_mem_ind_c()) { - return false; - }; - if (!perm_main_mem_ind_d()) { - return false; - }; - if (!lookup_byte_lengths()) { - return false; - }; - if (!lookup_byte_operations()) { - return false; - }; - if (!lookup_into_kernel()) { - return false; - }; - if (!incl_main_tag_err()) { - return false; - }; - if (!incl_mem_tag_err()) { - return false; - }; - if (!lookup_mem_rng_chk_lo()) { - return false; - }; - if (!lookup_mem_rng_chk_hi()) { - return false; - }; - if (!lookup_pow_2_0()) { - return false; - }; - if (!lookup_pow_2_1()) { - return false; - }; - if (!lookup_u8_0()) { - return false; - }; - if (!lookup_u8_1()) { - return false; - }; - if (!lookup_u16_0()) { - return false; - }; - if (!lookup_u16_1()) { - return false; - }; - if (!lookup_u16_2()) { - return false; - }; - if (!lookup_u16_3()) { - return false; - }; - if (!lookup_u16_4()) { - return false; - }; - if (!lookup_u16_5()) { - return false; - }; - if (!lookup_u16_6()) { - return false; - }; - if (!lookup_u16_7()) { - return false; - }; - if (!lookup_u16_8()) { - return false; - }; - if (!lookup_u16_9()) { - return false; - }; - if (!lookup_u16_10()) { - return false; - }; - if (!lookup_u16_11()) { - return false; - }; - if (!lookup_u16_13()) { - return false; - }; - if (!lookup_u16_12()) { - return false; - }; - if (!lookup_u16_13()) { - return false; - }; - if (!lookup_u16_14()) { - return false; - }; -#endif - if (!evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_0")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_1")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_2")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_3")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_4")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_5")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_6")) { - return false; - } - if (!evaluate_logderivative.template operator()>("LOOKUP_DIV_U16_7")) { - return false; - } + avm_alu(); + + avm_binary(); + + avm_main(); + + avm_mem(); + + perm_main_alu(); + + perm_main_bin(); + + perm_main_mem_a(); + + perm_main_mem_b(); + + perm_main_mem_c(); + + perm_main_mem_d(); + + perm_main_mem_ind_a(); + + perm_main_mem_ind_b(); + + perm_main_mem_ind_c(); + + perm_main_mem_ind_d(); + + lookup_byte_lengths(); + + lookup_byte_operations(); + + lookup_into_kernel(); + + incl_main_tag_err(); + + incl_mem_tag_err(); + + lookup_mem_rng_chk_lo(); + + lookup_mem_rng_chk_hi(); + + lookup_pow_2_0(); + + lookup_pow_2_1(); + + lookup_u8_0(); + + lookup_u8_1(); + + lookup_u16_0(); + + lookup_u16_1(); + + lookup_u16_2(); + + lookup_u16_3(); + + lookup_u16_4(); + + lookup_u16_5(); + + lookup_u16_6(); + + lookup_u16_7(); + + lookup_u16_8(); + + lookup_u16_9(); + + lookup_u16_10(); + + lookup_u16_11(); + + lookup_u16_12(); + + lookup_u16_13(); + + lookup_u16_14(); + + lookup_div_u16_0(); + + lookup_div_u16_1(); + + lookup_div_u16_2(); + + lookup_div_u16_3(); + + lookup_div_u16_4(); + + lookup_div_u16_5(); + + lookup_div_u16_6(); + + lookup_div_u16_7(); + +#endif return true; } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index d870193414e..c177d5c3cf2 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -82,11 +82,11 @@ class AvmFlavor { using RelationSeparator = FF; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2; - static constexpr size_t NUM_WITNESS_ENTITIES = 270; + static constexpr size_t NUM_WITNESS_ENTITIES = 288; static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES; - // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one - // for the unshifted and one for the shifted - static constexpr size_t NUM_ALL_ENTITIES = 324; + // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for + // the unshifted and one for the shifted + static constexpr size_t NUM_ALL_ENTITIES = 342; using GrandProductRelations = std::tuple, perm_main_bin_relation, diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index d22bbf8b78d..04790ec0628 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -5,7 +5,6 @@ #include "barretenberg/numeric/bitop/get_msb.hpp" #include "barretenberg/polynomials/polynomial.hpp" #include "barretenberg/transcript/transcript.hpp" -#include "barretenberg/vm/avm_trace/constants.hpp" namespace bb { @@ -29,7 +28,7 @@ AvmVerifier& AvmVerifier::operator=(AvmVerifier&& other) noexcept using FF = AvmFlavor::FF; // Evaluate the given public input column over the multivariate challenge points -[[maybe_unused]] FF evaluate_public_input_column(std::array points, +[[maybe_unused]] FF evaluate_public_input_column(std::vector points, const size_t circuit_size, std::vector challenges) { @@ -38,7 +37,7 @@ using FF = AvmFlavor::FF; std::vector new_points(circuit_size, 0); std::copy(points.begin(), points.end(), new_points.data()); - Polynomial polynomial(new_points); + Polynomial polynomial(points); return polynomial.evaluate_mle(challenges); } @@ -46,7 +45,7 @@ using FF = AvmFlavor::FF; * @brief This function verifies an Avm Honk proof for given program settings. * */ -bool AvmVerifier::verify_proof(const HonkProof& proof, const std::array& public_inputs) +bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& public_inputs) { using Flavor = AvmFlavor; using FF = Flavor::FF; @@ -584,13 +583,11 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::array& public_inputs); + bool verify_proof(const HonkProof& proof, const std::vector& public_inputs); std::shared_ptr key; std::map commitments; diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp index 9912e3d8a3f..ca6ce95391f 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_arithmetic.test.cpp @@ -377,7 +377,7 @@ TEST_F(AvmArithmeticTestsFF, addition) EXPECT_EQ(alu_row.avm_alu_cf, FF(0)); EXPECT_EQ(alu_row.avm_alu_u8_r0, FF(0)); - validate_trace(std::move(trace), true); + validate_trace(std::move(trace), {}, true); } // Test on basic subtraction over finite field type. diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp index c57b61b865f..dffedfa9d11 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/avm_bitwise.test.cpp @@ -488,7 +488,7 @@ TEST_P(AvmBitwiseTestsAnd, AllAndTest) auto trace = trace_builder.finalize(); common_validate_bit_op(trace, 0, a, b, output, FF(0), FF(1), FF(2), mem_tag); - validate_trace(std::move(trace), {} true); + validate_trace(std::move(trace), {}, true); } INSTANTIATE_TEST_SUITE_P(AvmBitwiseTests, AvmBitwiseTestsAnd, diff --git a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp index 80b100bab83..5f5cac0afeb 100644 --- a/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/tests/helpers.test.cpp @@ -38,13 +38,17 @@ void validate_trace(std::vector&& trace, std::array public_inputs_as_vec(KERNEL_INPUTS_LENGTH); + std::copy(public_inputs.begin(), public_inputs.end(), public_inputs_as_vec.data()); + + bool verified = verifier.verify_proof(proof, public_inputs_as_vec); EXPECT_TRUE(verified); } From ea48aca542f46f5ca8744a84227efd7dc0994973 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Thu, 9 May 2024 17:43:48 +0000 Subject: [PATCH 36/40] fix: update codegen --- .../barretenberg/vm/generated/avm_circuit_builder.hpp | 6 +++--- .../cpp/src/barretenberg/vm/generated/avm_verifier.cpp | 9 +++++---- .../cpp/src/barretenberg/vm/generated/avm_verifier.hpp | 1 + 3 files changed, 9 insertions(+), 7 deletions(-) diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index fa4c5ce0fad..d601a4de519 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -812,9 +812,6 @@ class AvmCircuitBuilder { return true; }; - // Evaluate check circuit closures as futures - std::vector> relation_futures; - auto avm_alu = [=]() { return evaluate_relation.template operator()>("avm_alu", Avm_vm::get_relation_label_avm_alu); @@ -1016,6 +1013,9 @@ class AvmCircuitBuilder { #ifndef __wasm__ + // Evaluate check circuit closures as futures + std::vector> relation_futures; + relation_futures.emplace_back(std::async(std::launch::async, avm_alu)); relation_futures.emplace_back(std::async(std::launch::async, avm_binary)); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index 04790ec0628..af14f03224c 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -28,16 +28,17 @@ AvmVerifier& AvmVerifier::operator=(AvmVerifier&& other) noexcept using FF = AvmFlavor::FF; // Evaluate the given public input column over the multivariate challenge points -[[maybe_unused]] FF evaluate_public_input_column(std::vector points, - const size_t circuit_size, - std::vector challenges) +[[maybe_unused]] inline FF evaluate_public_input_column(std::vector points, + const size_t circuit_size, + std::vector challenges) { + // TODO: we pad the points to the circuit size in order to get the correct evaluation // This is not efficient, and will not be valid in production std::vector new_points(circuit_size, 0); std::copy(points.begin(), points.end(), new_points.data()); - Polynomial polynomial(points); + Polynomial polynomial(new_points); return polynomial.evaluate_mle(challenges); } diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp index 4842c5425cd..6a1a09e82b8 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.hpp @@ -3,6 +3,7 @@ #pragma once #include "barretenberg/plonk/proof_system/types/proof.hpp" #include "barretenberg/sumcheck/sumcheck.hpp" +#include "barretenberg/vm/avm_trace/constants.hpp" #include "barretenberg/vm/generated/avm_flavor.hpp" namespace bb { From e1e2cb85ce5be81dc40039ae517941edb3196442 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 10 May 2024 10:42:53 +0000 Subject: [PATCH 37/40] fix: remove legacy codegen files --- .../generated/avm/avm_environment.hpp | 67 ---------- .../relations/generated/avm/avm_kernel.hpp | 120 ------------------ 2 files changed, 187 deletions(-) delete mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_environment.hpp delete mode 100644 barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_environment.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_environment.hpp deleted file mode 100644 index 1b0cdc54004..00000000000 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_environment.hpp +++ /dev/null @@ -1,67 +0,0 @@ - -#pragma once -#include "../../relation_parameters.hpp" -#include "../../relation_types.hpp" -#include "./declare_views.hpp" - -namespace bb::Avm_vm { - -template struct Avm_environmentRow { - FF avm_environment_environment_selector{}; - FF avm_environment_q_environment_lookup{}; - FF avm_main_sel_op_address{}; - FF avm_main_sel_op_sender{}; -}; - -inline std::string get_relation_label_avm_environment(int index) -{ - switch (index) { - case 0: - return "SENDER_ENVIRONMENT"; - - case 1: - return "ADDRESS_ENVIRONMENT"; - } - return std::to_string(index); -} - -template class avm_environmentImpl { - public: - using FF = FF_; - - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 4, - 4, - }; - - template - void static accumulate(ContainerOverSubrelations& evals, - const AllEntities& new_term, - [[maybe_unused]] const RelationParameters&, - [[maybe_unused]] const FF& scaling_factor) - { - - // Contribution 0 - { - Avm_DECLARE_VIEWS(0); - - auto tmp = ((avm_environment_q_environment_lookup * avm_main_sel_op_sender) * - avm_environment_environment_selector); - tmp *= scaling_factor; - std::get<0>(evals) += tmp; - } - // Contribution 1 - { - Avm_DECLARE_VIEWS(1); - - auto tmp = ((avm_environment_q_environment_lookup * avm_main_sel_op_address) * - (avm_environment_environment_selector - FF(1))); - tmp *= scaling_factor; - std::get<1>(evals) += tmp; - } - } -}; - -template using avm_environment = Relation>; - -} // namespace bb::Avm_vm \ No newline at end of file diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp deleted file mode 100644 index fc6819de643..00000000000 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_kernel.hpp +++ /dev/null @@ -1,120 +0,0 @@ - -#pragma once -#include "../../relation_parameters.hpp" -#include "../../relation_types.hpp" -#include "./declare_views.hpp" - -namespace bb::Avm_vm { - -template struct Avm_kernelRow { - FF avm_kernel_kernel_sel{}; - FF avm_main_sel_op_address{}; - FF avm_main_sel_op_fee_per_da_gas{}; - FF avm_main_sel_op_fee_per_l1_gas{}; - FF avm_main_sel_op_fee_per_l2_gas{}; - FF avm_main_sel_op_function_selector{}; - FF avm_main_sel_op_portal{}; - FF avm_main_sel_op_sender{}; -}; - -inline std::string get_relation_label_avm_kernel(int index) -{ - switch (index) { - case 0: - return "SENDER_KERNEL"; - - case 1: - return "ADDRESS_KERNEL"; - - case 2: - return "PORTAL_KERNEL"; - - case 3: - return "FUNCTION_KERNEL"; - - case 4: - return "FEE_DA_GAS_KERNEL"; - - case 5: - return "FEE_L2_GAS_KERNEL"; - } - return std::to_string(index); -} - -template class avm_kernelImpl { - public: - using FF = FF_; - - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, - }; - - template - void static accumulate(ContainerOverSubrelations& evals, - const AllEntities& new_term, - [[maybe_unused]] const RelationParameters&, - [[maybe_unused]] const FF& scaling_factor) - { - - // Contribution 0 - { - Avm_DECLARE_VIEWS(0); - - auto tmp = (avm_main_sel_op_sender * (avm_kernel_kernel_sel - FF(0))); - tmp *= scaling_factor; - std::get<0>(evals) += tmp; - } - // Contribution 1 - { - Avm_DECLARE_VIEWS(1); - - auto tmp = (avm_main_sel_op_address * (avm_kernel_kernel_sel - FF(1))); - tmp *= scaling_factor; - std::get<1>(evals) += tmp; - } - // Contribution 2 - { - Avm_DECLARE_VIEWS(2); - - auto tmp = (avm_main_sel_op_portal * (avm_kernel_kernel_sel - FF(2))); - tmp *= scaling_factor; - std::get<2>(evals) += tmp; - } - // Contribution 3 - { - Avm_DECLARE_VIEWS(3); - - auto tmp = (avm_main_sel_op_function_selector * (avm_kernel_kernel_sel - FF(3))); - tmp *= scaling_factor; - std::get<3>(evals) += tmp; - } - // Contribution 4 - { - Avm_DECLARE_VIEWS(4); - - auto tmp = (avm_main_sel_op_fee_per_da_gas * (avm_kernel_kernel_sel - FF(9))); - tmp *= scaling_factor; - std::get<4>(evals) += tmp; - } - // Contribution 5 - { - Avm_DECLARE_VIEWS(5); - - auto tmp = (avm_main_sel_op_fee_per_l1_gas * (avm_kernel_kernel_sel - FF(11))); - tmp *= scaling_factor; - std::get<5>(evals) += tmp; - } - // Contribution 6 - { - Avm_DECLARE_VIEWS(6); - - auto tmp = (avm_main_sel_op_fee_per_l2_gas * (avm_kernel_kernel_sel - FF(13))); - tmp *= scaling_factor; - std::get<6>(evals) += tmp; - } - } -}; - -template using avm_kernel = Relation>; - -} // namespace bb::Avm_vm \ No newline at end of file From bee84aa1212e3050187e29fad03c62cf631227a2 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 10 May 2024 12:50:12 +0000 Subject: [PATCH 38/40] fix: relation tags + removal of function opcode --- barretenberg/cpp/pil/avm/avm_main.pil | 15 +- .../relations/generated/avm/avm_main.hpp | 326 ++++++++---------- .../relations/generated/avm/declare_views.hpp | 1 - .../vm/generated/avm_circuit_builder.hpp | 6 +- .../barretenberg/vm/generated/avm_flavor.hpp | 14 +- .../barretenberg/vm/generated/avm_prover.cpp | 4 - .../vm/generated/avm_verifier.cpp | 2 - 7 files changed, 161 insertions(+), 207 deletions(-) diff --git a/barretenberg/cpp/pil/avm/avm_main.pil b/barretenberg/cpp/pil/avm/avm_main.pil index 2dd1569ea7c..2ead092ce20 100644 --- a/barretenberg/cpp/pil/avm/avm_main.pil +++ b/barretenberg/cpp/pil/avm/avm_main.pil @@ -12,7 +12,6 @@ namespace avm_main(256); pol commit sel_op_sender; pol commit sel_op_address; pol commit sel_op_portal; - pol commit sel_op_function_selector; // FEES pol commit sel_op_fee_per_l2_gas; @@ -159,7 +158,6 @@ namespace avm_main(256); sel_op_sender * (1 - sel_op_sender) = 0; sel_op_address * (1 - sel_op_address) = 0; sel_op_portal * (1 - sel_op_portal) = 0; - sel_op_function_selector * (1 - sel_op_function_selector) = 0; sel_op_chain_id * (1 - sel_op_chain_id) = 0; sel_op_version * (1 - sel_op_version) = 0; sel_op_block_number * (1 - sel_op_block_number) = 0; @@ -272,8 +270,8 @@ namespace avm_main(256); //===== KERNEL LOOKUPS ======================================================= pol KERNEL_SELECTORS = ( - sel_op_sender + sel_op_address + sel_op_portal + sel_op_function_selector + sel_op_chain_id + sel_op_version + - sel_op_block_number + sel_op_coinbase + sel_op_timestamp + sel_op_fee_per_l2_gas + sel_op_fee_per_da_gas + sel_op_transaction_fee + sel_op_sender + sel_op_address + sel_op_portal + sel_op_chain_id + sel_op_version + sel_op_block_number + + sel_op_coinbase + sel_op_timestamp + sel_op_fee_per_l2_gas + sel_op_fee_per_da_gas + sel_op_transaction_fee ); // Ensure that only one kernel lookup is active when the kernel_sel is active #[KERNEL_ACTIVE_CHECK] @@ -389,9 +387,6 @@ namespace avm_main(256); #[PORTAL_KERNEL] sel_op_portal * (avm_kernel.kernel_sel - constants.PORTAL_SELECTOR) = 0; - #[FUNCTION_KERNEL] - sel_op_function_selector * (avm_kernel.kernel_sel - constants.FUNCTION_SELECTOR) = 0; - // FEES #[FEE_DA_GAS_KERNEL] sel_op_fee_per_da_gas * (avm_kernel.kernel_sel - constants.FEE_PER_DA_GAS_SELECTOR) = 0; @@ -409,13 +404,13 @@ namespace avm_main(256); #[VERSION_KERNEL] sel_op_version * (avm_kernel.kernel_sel - constants.VERSION_SELECTOR) = 0; - #[CHAIN_ID_KERNEL] + #[BLOCK_NUMBER_KERNEL] sel_op_block_number * (avm_kernel.kernel_sel - constants.BLOCK_NUMBER_SELECTOR) = 0; - #[CHAIN_ID_KERNEL] + #[COINBASE_KERNEL] sel_op_coinbase * (avm_kernel.kernel_sel - constants.COINBASE_SELECTOR) = 0; - #[CHAIN_ID_KERNEL] + #[TIMESTAMP_KERNEL] sel_op_timestamp * (avm_kernel.kernel_sel - constants.TIMESTAMP_SELECTOR) = 0; #[LOOKUP_INTO_KERNEL] diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp index 4135688eabc..d5c60d139de 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/avm_main.hpp @@ -60,7 +60,6 @@ template struct Avm_mainRow { FF avm_main_sel_op_fdiv{}; FF avm_main_sel_op_fee_per_da_gas{}; FF avm_main_sel_op_fee_per_l2_gas{}; - FF avm_main_sel_op_function_selector{}; FF avm_main_sel_op_lt{}; FF avm_main_sel_op_lte{}; FF avm_main_sel_op_mul{}; @@ -82,97 +81,94 @@ template struct Avm_mainRow { inline std::string get_relation_label_avm_main(int index) { switch (index) { - case 48: + case 47: return "OUTPUT_U8"; - case 49: + case 48: return "SUBOP_FDIV"; - case 50: + case 49: return "SUBOP_FDIV_ZERO_ERR1"; - case 51: + case 50: return "SUBOP_FDIV_ZERO_ERR2"; - case 52: + case 51: return "SUBOP_FDIV_R_IN_TAG_FF"; - case 53: + case 52: return "SUBOP_FDIV_W_IN_TAG_FF"; - case 54: + case 53: return "SUBOP_ERROR_RELEVANT_OP"; - case 55: + case 54: return "KERNEL_ACTIVE_CHECK"; - case 57: + case 56: return "RETURN_POINTER_INCREMENT"; - case 63: + case 62: return "RETURN_POINTER_DECREMENT"; - case 68: + case 67: return "PC_INCREMENT"; - case 69: + case 68: return "INTERNAL_RETURN_POINTER_CONSISTENCY"; - case 70: + case 69: return "CMOV_CONDITION_RES_1"; - case 71: + case 70: return "CMOV_CONDITION_RES_2"; - case 74: + case 73: return "MOV_SAME_VALUE_A"; - case 75: + case 74: return "MOV_SAME_VALUE_B"; - case 76: + case 75: return "MOV_MAIN_SAME_TAG"; - case 80: + case 79: return "SENDER_KERNEL"; - case 81: + case 80: return "ADDRESS_KERNEL"; - case 82: + case 81: return "PORTAL_KERNEL"; + case 82: + return "FEE_DA_GAS_KERNEL"; + case 83: - return "FUNCTION_KERNEL"; + return "FEE_L2_GAS_KERNEL"; case 84: - return "FEE_DA_GAS_KERNEL"; + return "FEE_TRANSACTION_FEE_KERNEL"; case 85: - return "FEE_L2_GAS_KERNEL"; + return "CHAIN_ID_KERNEL"; case 86: - return "FEE_TRANSACTION_FEE_KERNEL"; + return "VERSION_KERNEL"; case 87: - return "CHAIN_ID_KERNEL"; + return "BLOCK_NUMBER_KERNEL"; case 88: - return "VERSION_KERNEL"; + return "COINBASE_KERNEL"; case 89: - return "CHAIN_ID_KERNEL"; + return "TIMESTAMP_KERNEL"; case 90: - return "CHAIN_ID_KERNEL"; - - case 91: - return "CHAIN_ID_KERNEL"; - - case 92: return "BIN_SEL_1"; - case 93: + case 91: return "BIN_SEL_2"; } return std::to_string(index); @@ -182,10 +178,10 @@ template class avm_mainImpl { public: using FF = FF_; - static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, + static constexpr std::array SUBRELATION_PARTIAL_LENGTHS{ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 5, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, }; template @@ -223,7 +219,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(3); - auto tmp = (avm_main_sel_op_function_selector * (-avm_main_sel_op_function_selector + FF(1))); + auto tmp = (avm_main_sel_op_chain_id * (-avm_main_sel_op_chain_id + FF(1))); tmp *= scaling_factor; std::get<3>(evals) += tmp; } @@ -231,7 +227,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(4); - auto tmp = (avm_main_sel_op_chain_id * (-avm_main_sel_op_chain_id + FF(1))); + auto tmp = (avm_main_sel_op_version * (-avm_main_sel_op_version + FF(1))); tmp *= scaling_factor; std::get<4>(evals) += tmp; } @@ -239,7 +235,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(5); - auto tmp = (avm_main_sel_op_version * (-avm_main_sel_op_version + FF(1))); + auto tmp = (avm_main_sel_op_block_number * (-avm_main_sel_op_block_number + FF(1))); tmp *= scaling_factor; std::get<5>(evals) += tmp; } @@ -247,7 +243,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(6); - auto tmp = (avm_main_sel_op_block_number * (-avm_main_sel_op_block_number + FF(1))); + auto tmp = (avm_main_sel_op_coinbase * (-avm_main_sel_op_coinbase + FF(1))); tmp *= scaling_factor; std::get<6>(evals) += tmp; } @@ -255,7 +251,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(7); - auto tmp = (avm_main_sel_op_coinbase * (-avm_main_sel_op_coinbase + FF(1))); + auto tmp = (avm_main_sel_op_timestamp * (-avm_main_sel_op_timestamp + FF(1))); tmp *= scaling_factor; std::get<7>(evals) += tmp; } @@ -263,7 +259,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(8); - auto tmp = (avm_main_sel_op_timestamp * (-avm_main_sel_op_timestamp + FF(1))); + auto tmp = (avm_main_sel_op_fee_per_l2_gas * (-avm_main_sel_op_fee_per_l2_gas + FF(1))); tmp *= scaling_factor; std::get<8>(evals) += tmp; } @@ -271,7 +267,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(9); - auto tmp = (avm_main_sel_op_fee_per_l2_gas * (-avm_main_sel_op_fee_per_l2_gas + FF(1))); + auto tmp = (avm_main_sel_op_fee_per_da_gas * (-avm_main_sel_op_fee_per_da_gas + FF(1))); tmp *= scaling_factor; std::get<9>(evals) += tmp; } @@ -279,7 +275,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(10); - auto tmp = (avm_main_sel_op_fee_per_da_gas * (-avm_main_sel_op_fee_per_da_gas + FF(1))); + auto tmp = (avm_main_sel_op_transaction_fee * (-avm_main_sel_op_transaction_fee + FF(1))); tmp *= scaling_factor; std::get<10>(evals) += tmp; } @@ -287,7 +283,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(11); - auto tmp = (avm_main_sel_op_transaction_fee * (-avm_main_sel_op_transaction_fee + FF(1))); + auto tmp = (avm_main_sel_op_add * (-avm_main_sel_op_add + FF(1))); tmp *= scaling_factor; std::get<11>(evals) += tmp; } @@ -295,7 +291,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(12); - auto tmp = (avm_main_sel_op_add * (-avm_main_sel_op_add + FF(1))); + auto tmp = (avm_main_sel_op_sub * (-avm_main_sel_op_sub + FF(1))); tmp *= scaling_factor; std::get<12>(evals) += tmp; } @@ -303,7 +299,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(13); - auto tmp = (avm_main_sel_op_sub * (-avm_main_sel_op_sub + FF(1))); + auto tmp = (avm_main_sel_op_mul * (-avm_main_sel_op_mul + FF(1))); tmp *= scaling_factor; std::get<13>(evals) += tmp; } @@ -311,7 +307,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(14); - auto tmp = (avm_main_sel_op_mul * (-avm_main_sel_op_mul + FF(1))); + auto tmp = (avm_main_sel_op_div * (-avm_main_sel_op_div + FF(1))); tmp *= scaling_factor; std::get<14>(evals) += tmp; } @@ -319,7 +315,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(15); - auto tmp = (avm_main_sel_op_div * (-avm_main_sel_op_div + FF(1))); + auto tmp = (avm_main_sel_op_fdiv * (-avm_main_sel_op_fdiv + FF(1))); tmp *= scaling_factor; std::get<15>(evals) += tmp; } @@ -327,7 +323,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(16); - auto tmp = (avm_main_sel_op_fdiv * (-avm_main_sel_op_fdiv + FF(1))); + auto tmp = (avm_main_sel_op_not * (-avm_main_sel_op_not + FF(1))); tmp *= scaling_factor; std::get<16>(evals) += tmp; } @@ -335,7 +331,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(17); - auto tmp = (avm_main_sel_op_not * (-avm_main_sel_op_not + FF(1))); + auto tmp = (avm_main_sel_op_eq * (-avm_main_sel_op_eq + FF(1))); tmp *= scaling_factor; std::get<17>(evals) += tmp; } @@ -343,7 +339,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(18); - auto tmp = (avm_main_sel_op_eq * (-avm_main_sel_op_eq + FF(1))); + auto tmp = (avm_main_sel_op_and * (-avm_main_sel_op_and + FF(1))); tmp *= scaling_factor; std::get<18>(evals) += tmp; } @@ -351,7 +347,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(19); - auto tmp = (avm_main_sel_op_and * (-avm_main_sel_op_and + FF(1))); + auto tmp = (avm_main_sel_op_or * (-avm_main_sel_op_or + FF(1))); tmp *= scaling_factor; std::get<19>(evals) += tmp; } @@ -359,7 +355,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(20); - auto tmp = (avm_main_sel_op_or * (-avm_main_sel_op_or + FF(1))); + auto tmp = (avm_main_sel_op_xor * (-avm_main_sel_op_xor + FF(1))); tmp *= scaling_factor; std::get<20>(evals) += tmp; } @@ -367,7 +363,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(21); - auto tmp = (avm_main_sel_op_xor * (-avm_main_sel_op_xor + FF(1))); + auto tmp = (avm_main_sel_op_cast * (-avm_main_sel_op_cast + FF(1))); tmp *= scaling_factor; std::get<21>(evals) += tmp; } @@ -375,7 +371,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(22); - auto tmp = (avm_main_sel_op_cast * (-avm_main_sel_op_cast + FF(1))); + auto tmp = (avm_main_sel_op_lt * (-avm_main_sel_op_lt + FF(1))); tmp *= scaling_factor; std::get<22>(evals) += tmp; } @@ -383,7 +379,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(23); - auto tmp = (avm_main_sel_op_lt * (-avm_main_sel_op_lt + FF(1))); + auto tmp = (avm_main_sel_op_lte * (-avm_main_sel_op_lte + FF(1))); tmp *= scaling_factor; std::get<23>(evals) += tmp; } @@ -391,7 +387,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(24); - auto tmp = (avm_main_sel_op_lte * (-avm_main_sel_op_lte + FF(1))); + auto tmp = (avm_main_sel_op_shl * (-avm_main_sel_op_shl + FF(1))); tmp *= scaling_factor; std::get<24>(evals) += tmp; } @@ -399,7 +395,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(25); - auto tmp = (avm_main_sel_op_shl * (-avm_main_sel_op_shl + FF(1))); + auto tmp = (avm_main_sel_op_shr * (-avm_main_sel_op_shr + FF(1))); tmp *= scaling_factor; std::get<25>(evals) += tmp; } @@ -407,7 +403,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(26); - auto tmp = (avm_main_sel_op_shr * (-avm_main_sel_op_shr + FF(1))); + auto tmp = (avm_main_sel_internal_call * (-avm_main_sel_internal_call + FF(1))); tmp *= scaling_factor; std::get<26>(evals) += tmp; } @@ -415,7 +411,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(27); - auto tmp = (avm_main_sel_internal_call * (-avm_main_sel_internal_call + FF(1))); + auto tmp = (avm_main_sel_internal_return * (-avm_main_sel_internal_return + FF(1))); tmp *= scaling_factor; std::get<27>(evals) += tmp; } @@ -423,7 +419,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(28); - auto tmp = (avm_main_sel_internal_return * (-avm_main_sel_internal_return + FF(1))); + auto tmp = (avm_main_sel_jump * (-avm_main_sel_jump + FF(1))); tmp *= scaling_factor; std::get<28>(evals) += tmp; } @@ -431,7 +427,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(29); - auto tmp = (avm_main_sel_jump * (-avm_main_sel_jump + FF(1))); + auto tmp = (avm_main_sel_halt * (-avm_main_sel_halt + FF(1))); tmp *= scaling_factor; std::get<29>(evals) += tmp; } @@ -439,7 +435,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(30); - auto tmp = (avm_main_sel_halt * (-avm_main_sel_halt + FF(1))); + auto tmp = (avm_main_sel_mov * (-avm_main_sel_mov + FF(1))); tmp *= scaling_factor; std::get<30>(evals) += tmp; } @@ -447,7 +443,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(31); - auto tmp = (avm_main_sel_mov * (-avm_main_sel_mov + FF(1))); + auto tmp = (avm_main_sel_cmov * (-avm_main_sel_cmov + FF(1))); tmp *= scaling_factor; std::get<31>(evals) += tmp; } @@ -455,7 +451,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(32); - auto tmp = (avm_main_sel_cmov * (-avm_main_sel_cmov + FF(1))); + auto tmp = (avm_main_op_err * (-avm_main_op_err + FF(1))); tmp *= scaling_factor; std::get<32>(evals) += tmp; } @@ -463,7 +459,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(33); - auto tmp = (avm_main_op_err * (-avm_main_op_err + FF(1))); + auto tmp = (avm_main_tag_err * (-avm_main_tag_err + FF(1))); tmp *= scaling_factor; std::get<33>(evals) += tmp; } @@ -471,7 +467,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(34); - auto tmp = (avm_main_tag_err * (-avm_main_tag_err + FF(1))); + auto tmp = (avm_main_id_zero * (-avm_main_id_zero + FF(1))); tmp *= scaling_factor; std::get<34>(evals) += tmp; } @@ -479,7 +475,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(35); - auto tmp = (avm_main_id_zero * (-avm_main_id_zero + FF(1))); + auto tmp = (avm_main_mem_op_a * (-avm_main_mem_op_a + FF(1))); tmp *= scaling_factor; std::get<35>(evals) += tmp; } @@ -487,7 +483,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(36); - auto tmp = (avm_main_mem_op_a * (-avm_main_mem_op_a + FF(1))); + auto tmp = (avm_main_mem_op_b * (-avm_main_mem_op_b + FF(1))); tmp *= scaling_factor; std::get<36>(evals) += tmp; } @@ -495,7 +491,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(37); - auto tmp = (avm_main_mem_op_b * (-avm_main_mem_op_b + FF(1))); + auto tmp = (avm_main_mem_op_c * (-avm_main_mem_op_c + FF(1))); tmp *= scaling_factor; std::get<37>(evals) += tmp; } @@ -503,7 +499,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(38); - auto tmp = (avm_main_mem_op_c * (-avm_main_mem_op_c + FF(1))); + auto tmp = (avm_main_mem_op_d * (-avm_main_mem_op_d + FF(1))); tmp *= scaling_factor; std::get<38>(evals) += tmp; } @@ -511,7 +507,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(39); - auto tmp = (avm_main_mem_op_d * (-avm_main_mem_op_d + FF(1))); + auto tmp = (avm_main_rwa * (-avm_main_rwa + FF(1))); tmp *= scaling_factor; std::get<39>(evals) += tmp; } @@ -519,7 +515,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(40); - auto tmp = (avm_main_rwa * (-avm_main_rwa + FF(1))); + auto tmp = (avm_main_rwb * (-avm_main_rwb + FF(1))); tmp *= scaling_factor; std::get<40>(evals) += tmp; } @@ -527,7 +523,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(41); - auto tmp = (avm_main_rwb * (-avm_main_rwb + FF(1))); + auto tmp = (avm_main_rwc * (-avm_main_rwc + FF(1))); tmp *= scaling_factor; std::get<41>(evals) += tmp; } @@ -535,7 +531,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(42); - auto tmp = (avm_main_rwc * (-avm_main_rwc + FF(1))); + auto tmp = (avm_main_rwd * (-avm_main_rwd + FF(1))); tmp *= scaling_factor; std::get<42>(evals) += tmp; } @@ -543,7 +539,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(43); - auto tmp = (avm_main_rwd * (-avm_main_rwd + FF(1))); + auto tmp = (avm_main_ind_op_a * (-avm_main_ind_op_a + FF(1))); tmp *= scaling_factor; std::get<43>(evals) += tmp; } @@ -551,7 +547,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(44); - auto tmp = (avm_main_ind_op_a * (-avm_main_ind_op_a + FF(1))); + auto tmp = (avm_main_ind_op_b * (-avm_main_ind_op_b + FF(1))); tmp *= scaling_factor; std::get<44>(evals) += tmp; } @@ -559,7 +555,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(45); - auto tmp = (avm_main_ind_op_b * (-avm_main_ind_op_b + FF(1))); + auto tmp = (avm_main_ind_op_c * (-avm_main_ind_op_c + FF(1))); tmp *= scaling_factor; std::get<45>(evals) += tmp; } @@ -567,7 +563,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(46); - auto tmp = (avm_main_ind_op_c * (-avm_main_ind_op_c + FF(1))); + auto tmp = (avm_main_ind_op_d * (-avm_main_ind_op_d + FF(1))); tmp *= scaling_factor; std::get<46>(evals) += tmp; } @@ -575,7 +571,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(47); - auto tmp = (avm_main_ind_op_d * (-avm_main_ind_op_d + FF(1))); + auto tmp = + (((avm_main_sel_op_eq + avm_main_sel_op_lte) + avm_main_sel_op_lt) * (avm_main_w_in_tag - FF(1))); tmp *= scaling_factor; std::get<47>(evals) += tmp; } @@ -584,7 +581,7 @@ template class avm_mainImpl { Avm_DECLARE_VIEWS(48); auto tmp = - (((avm_main_sel_op_eq + avm_main_sel_op_lte) + avm_main_sel_op_lt) * (avm_main_w_in_tag - FF(1))); + ((avm_main_sel_op_fdiv * (-avm_main_op_err + FF(1))) * ((avm_main_ic * avm_main_ib) - avm_main_ia)); tmp *= scaling_factor; std::get<48>(evals) += tmp; } @@ -592,8 +589,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(49); - auto tmp = - ((avm_main_sel_op_fdiv * (-avm_main_op_err + FF(1))) * ((avm_main_ic * avm_main_ib) - avm_main_ia)); + auto tmp = ((avm_main_sel_op_fdiv + avm_main_sel_op_div) * + (((avm_main_ib * avm_main_inv) - FF(1)) + avm_main_op_err)); tmp *= scaling_factor; std::get<49>(evals) += tmp; } @@ -601,8 +598,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(50); - auto tmp = ((avm_main_sel_op_fdiv + avm_main_sel_op_div) * - (((avm_main_ib * avm_main_inv) - FF(1)) + avm_main_op_err)); + auto tmp = (((avm_main_sel_op_fdiv + avm_main_sel_op_div) * avm_main_op_err) * (-avm_main_inv + FF(1))); tmp *= scaling_factor; std::get<50>(evals) += tmp; } @@ -610,7 +606,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(51); - auto tmp = (((avm_main_sel_op_fdiv + avm_main_sel_op_div) * avm_main_op_err) * (-avm_main_inv + FF(1))); + auto tmp = (avm_main_sel_op_fdiv * (avm_main_r_in_tag - FF(6))); tmp *= scaling_factor; std::get<51>(evals) += tmp; } @@ -618,7 +614,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(52); - auto tmp = (avm_main_sel_op_fdiv * (avm_main_r_in_tag - FF(6))); + auto tmp = (avm_main_sel_op_fdiv * (avm_main_w_in_tag - FF(6))); tmp *= scaling_factor; std::get<52>(evals) += tmp; } @@ -626,7 +622,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(53); - auto tmp = (avm_main_sel_op_fdiv * (avm_main_w_in_tag - FF(6))); + auto tmp = (avm_main_op_err * ((avm_main_sel_op_fdiv + avm_main_sel_op_div) - FF(1))); tmp *= scaling_factor; std::get<53>(evals) += tmp; } @@ -634,16 +630,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(54); - auto tmp = (avm_main_op_err * ((avm_main_sel_op_fdiv + avm_main_sel_op_div) - FF(1))); - tmp *= scaling_factor; - std::get<54>(evals) += tmp; - } - // Contribution 55 - { - Avm_DECLARE_VIEWS(55); - - auto tmp = ((((((((((((avm_main_sel_op_sender + avm_main_sel_op_address) + avm_main_sel_op_portal) + - avm_main_sel_op_function_selector) + + auto tmp = (((((((((((avm_main_sel_op_sender + avm_main_sel_op_address) + avm_main_sel_op_portal) + avm_main_sel_op_chain_id) + avm_main_sel_op_version) + avm_main_sel_op_block_number) + @@ -654,13 +641,22 @@ template class avm_mainImpl { avm_main_sel_op_transaction_fee) * (-avm_main_q_kernel_lookup + FF(1))); tmp *= scaling_factor; + std::get<54>(evals) += tmp; + } + // Contribution 55 + { + Avm_DECLARE_VIEWS(55); + + auto tmp = (avm_main_sel_jump * (avm_main_pc_shift - avm_main_ia)); + tmp *= scaling_factor; std::get<55>(evals) += tmp; } // Contribution 56 { Avm_DECLARE_VIEWS(56); - auto tmp = (avm_main_sel_jump * (avm_main_pc_shift - avm_main_ia)); + auto tmp = (avm_main_sel_internal_call * + (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr + FF(1)))); tmp *= scaling_factor; std::get<56>(evals) += tmp; } @@ -668,8 +664,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(57); - auto tmp = (avm_main_sel_internal_call * - (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr + FF(1)))); + auto tmp = (avm_main_sel_internal_call * (avm_main_internal_return_ptr - avm_main_mem_idx_b)); tmp *= scaling_factor; std::get<57>(evals) += tmp; } @@ -677,7 +672,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(58); - auto tmp = (avm_main_sel_internal_call * (avm_main_internal_return_ptr - avm_main_mem_idx_b)); + auto tmp = (avm_main_sel_internal_call * (avm_main_pc_shift - avm_main_ia)); tmp *= scaling_factor; std::get<58>(evals) += tmp; } @@ -685,7 +680,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(59); - auto tmp = (avm_main_sel_internal_call * (avm_main_pc_shift - avm_main_ia)); + auto tmp = (avm_main_sel_internal_call * ((avm_main_pc + FF(1)) - avm_main_ib)); tmp *= scaling_factor; std::get<59>(evals) += tmp; } @@ -693,7 +688,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(60); - auto tmp = (avm_main_sel_internal_call * ((avm_main_pc + FF(1)) - avm_main_ib)); + auto tmp = (avm_main_sel_internal_call * (avm_main_rwb - FF(1))); tmp *= scaling_factor; std::get<60>(evals) += tmp; } @@ -701,7 +696,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(61); - auto tmp = (avm_main_sel_internal_call * (avm_main_rwb - FF(1))); + auto tmp = (avm_main_sel_internal_call * (avm_main_mem_op_b - FF(1))); tmp *= scaling_factor; std::get<61>(evals) += tmp; } @@ -709,7 +704,8 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(62); - auto tmp = (avm_main_sel_internal_call * (avm_main_mem_op_b - FF(1))); + auto tmp = (avm_main_sel_internal_return * + (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr - FF(1)))); tmp *= scaling_factor; std::get<62>(evals) += tmp; } @@ -717,8 +713,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(63); - auto tmp = (avm_main_sel_internal_return * - (avm_main_internal_return_ptr_shift - (avm_main_internal_return_ptr - FF(1)))); + auto tmp = (avm_main_sel_internal_return * ((avm_main_internal_return_ptr - FF(1)) - avm_main_mem_idx_a)); tmp *= scaling_factor; std::get<63>(evals) += tmp; } @@ -726,7 +721,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(64); - auto tmp = (avm_main_sel_internal_return * ((avm_main_internal_return_ptr - FF(1)) - avm_main_mem_idx_a)); + auto tmp = (avm_main_sel_internal_return * (avm_main_pc_shift - avm_main_ia)); tmp *= scaling_factor; std::get<64>(evals) += tmp; } @@ -734,7 +729,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(65); - auto tmp = (avm_main_sel_internal_return * (avm_main_pc_shift - avm_main_ia)); + auto tmp = (avm_main_sel_internal_return * avm_main_rwa); tmp *= scaling_factor; std::get<65>(evals) += tmp; } @@ -742,7 +737,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(66); - auto tmp = (avm_main_sel_internal_return * avm_main_rwa); + auto tmp = (avm_main_sel_internal_return * (avm_main_mem_op_a - FF(1))); tmp *= scaling_factor; std::get<66>(evals) += tmp; } @@ -750,14 +745,6 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(67); - auto tmp = (avm_main_sel_internal_return * (avm_main_mem_op_a - FF(1))); - tmp *= scaling_factor; - std::get<67>(evals) += tmp; - } - // Contribution 68 - { - Avm_DECLARE_VIEWS(68); - auto tmp = ((((-avm_main_first + FF(1)) * (-avm_main_sel_halt + FF(1))) * (((((((((((avm_main_sel_op_add + avm_main_sel_op_sub) + avm_main_sel_op_div) + avm_main_sel_op_fdiv) + @@ -768,8 +755,7 @@ template class avm_mainImpl { avm_main_sel_op_or) + avm_main_sel_op_xor) + avm_main_sel_op_cast) + - (((((((((((avm_main_sel_op_sender + avm_main_sel_op_address) + avm_main_sel_op_portal) + - avm_main_sel_op_function_selector) + + ((((((((((avm_main_sel_op_sender + avm_main_sel_op_address) + avm_main_sel_op_portal) + avm_main_sel_op_chain_id) + avm_main_sel_op_version) + avm_main_sel_op_block_number) + @@ -780,24 +766,32 @@ template class avm_mainImpl { avm_main_sel_op_transaction_fee))) * (avm_main_pc_shift - (avm_main_pc + FF(1)))); tmp *= scaling_factor; - std::get<68>(evals) += tmp; + std::get<67>(evals) += tmp; } - // Contribution 69 + // Contribution 68 { - Avm_DECLARE_VIEWS(69); + Avm_DECLARE_VIEWS(68); auto tmp = ((-(((avm_main_first + avm_main_sel_internal_call) + avm_main_sel_internal_return) + avm_main_sel_halt) + FF(1)) * (avm_main_internal_return_ptr_shift - avm_main_internal_return_ptr)); tmp *= scaling_factor; + std::get<68>(evals) += tmp; + } + // Contribution 69 + { + Avm_DECLARE_VIEWS(69); + + auto tmp = (avm_main_sel_cmov * (((avm_main_id * avm_main_inv) - FF(1)) + avm_main_id_zero)); + tmp *= scaling_factor; std::get<69>(evals) += tmp; } // Contribution 70 { Avm_DECLARE_VIEWS(70); - auto tmp = (avm_main_sel_cmov * (((avm_main_id * avm_main_inv) - FF(1)) + avm_main_id_zero)); + auto tmp = ((avm_main_sel_cmov * avm_main_id_zero) * (-avm_main_inv + FF(1))); tmp *= scaling_factor; std::get<70>(evals) += tmp; } @@ -805,7 +799,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(71); - auto tmp = ((avm_main_sel_cmov * avm_main_id_zero) * (-avm_main_inv + FF(1))); + auto tmp = (avm_main_sel_mov_a - (avm_main_sel_mov + (avm_main_sel_cmov * (-avm_main_id_zero + FF(1))))); tmp *= scaling_factor; std::get<71>(evals) += tmp; } @@ -813,7 +807,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(72); - auto tmp = (avm_main_sel_mov_a - (avm_main_sel_mov + (avm_main_sel_cmov * (-avm_main_id_zero + FF(1))))); + auto tmp = (avm_main_sel_mov_b - (avm_main_sel_cmov * avm_main_id_zero)); tmp *= scaling_factor; std::get<72>(evals) += tmp; } @@ -821,7 +815,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(73); - auto tmp = (avm_main_sel_mov_b - (avm_main_sel_cmov * avm_main_id_zero)); + auto tmp = (avm_main_sel_mov_a * (avm_main_ia - avm_main_ic)); tmp *= scaling_factor; std::get<73>(evals) += tmp; } @@ -829,7 +823,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(74); - auto tmp = (avm_main_sel_mov_a * (avm_main_ia - avm_main_ic)); + auto tmp = (avm_main_sel_mov_b * (avm_main_ib - avm_main_ic)); tmp *= scaling_factor; std::get<74>(evals) += tmp; } @@ -837,7 +831,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(75); - auto tmp = (avm_main_sel_mov_b * (avm_main_ib - avm_main_ic)); + auto tmp = ((avm_main_sel_mov + avm_main_sel_cmov) * (avm_main_r_in_tag - avm_main_w_in_tag)); tmp *= scaling_factor; std::get<75>(evals) += tmp; } @@ -845,14 +839,6 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(76); - auto tmp = ((avm_main_sel_mov + avm_main_sel_cmov) * (avm_main_r_in_tag - avm_main_w_in_tag)); - tmp *= scaling_factor; - std::get<76>(evals) += tmp; - } - // Contribution 77 - { - Avm_DECLARE_VIEWS(77); - auto tmp = (avm_main_alu_sel - ((((((((((((avm_main_sel_op_add + avm_main_sel_op_sub) + avm_main_sel_op_mul) + avm_main_sel_op_div) + @@ -866,11 +852,11 @@ template class avm_mainImpl { (-avm_main_tag_err + FF(1))) * (-avm_main_op_err + FF(1)))); tmp *= scaling_factor; - std::get<77>(evals) += tmp; + std::get<76>(evals) += tmp; } - // Contribution 78 + // Contribution 77 { - Avm_DECLARE_VIEWS(78); + Avm_DECLARE_VIEWS(77); auto tmp = ((((((((((avm_main_sel_op_add + avm_main_sel_op_sub) + avm_main_sel_op_mul) + avm_main_sel_op_div) + @@ -882,13 +868,21 @@ template class avm_mainImpl { avm_main_sel_op_shl) * (avm_main_alu_in_tag - avm_main_r_in_tag)); tmp *= scaling_factor; + std::get<77>(evals) += tmp; + } + // Contribution 78 + { + Avm_DECLARE_VIEWS(78); + + auto tmp = (avm_main_sel_op_cast * (avm_main_alu_in_tag - avm_main_w_in_tag)); + tmp *= scaling_factor; std::get<78>(evals) += tmp; } // Contribution 79 { Avm_DECLARE_VIEWS(79); - auto tmp = (avm_main_sel_op_cast * (avm_main_alu_in_tag - avm_main_w_in_tag)); + auto tmp = (avm_main_sel_op_sender * (avm_kernel_kernel_sel - FF(0))); tmp *= scaling_factor; std::get<79>(evals) += tmp; } @@ -896,7 +890,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(80); - auto tmp = (avm_main_sel_op_sender * (avm_kernel_kernel_sel - FF(0))); + auto tmp = (avm_main_sel_op_address * (avm_kernel_kernel_sel - FF(1))); tmp *= scaling_factor; std::get<80>(evals) += tmp; } @@ -904,7 +898,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(81); - auto tmp = (avm_main_sel_op_address * (avm_kernel_kernel_sel - FF(1))); + auto tmp = (avm_main_sel_op_portal * (avm_kernel_kernel_sel - FF(2))); tmp *= scaling_factor; std::get<81>(evals) += tmp; } @@ -912,7 +906,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(82); - auto tmp = (avm_main_sel_op_portal * (avm_kernel_kernel_sel - FF(2))); + auto tmp = (avm_main_sel_op_fee_per_da_gas * (avm_kernel_kernel_sel - FF(37))); tmp *= scaling_factor; std::get<82>(evals) += tmp; } @@ -920,7 +914,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(83); - auto tmp = (avm_main_sel_op_function_selector * (avm_kernel_kernel_sel - FF(3))); + auto tmp = (avm_main_sel_op_fee_per_l2_gas * (avm_kernel_kernel_sel - FF(38))); tmp *= scaling_factor; std::get<83>(evals) += tmp; } @@ -928,7 +922,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(84); - auto tmp = (avm_main_sel_op_fee_per_da_gas * (avm_kernel_kernel_sel - FF(37))); + auto tmp = (avm_main_sel_op_transaction_fee * (avm_kernel_kernel_sel - FF(39))); tmp *= scaling_factor; std::get<84>(evals) += tmp; } @@ -936,7 +930,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(85); - auto tmp = (avm_main_sel_op_fee_per_l2_gas * (avm_kernel_kernel_sel - FF(38))); + auto tmp = (avm_main_sel_op_chain_id * (avm_kernel_kernel_sel - FF(28))); tmp *= scaling_factor; std::get<85>(evals) += tmp; } @@ -944,7 +938,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(86); - auto tmp = (avm_main_sel_op_transaction_fee * (avm_kernel_kernel_sel - FF(39))); + auto tmp = (avm_main_sel_op_version * (avm_kernel_kernel_sel - FF(29))); tmp *= scaling_factor; std::get<86>(evals) += tmp; } @@ -952,7 +946,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(87); - auto tmp = (avm_main_sel_op_chain_id * (avm_kernel_kernel_sel - FF(28))); + auto tmp = (avm_main_sel_op_block_number * (avm_kernel_kernel_sel - FF(30))); tmp *= scaling_factor; std::get<87>(evals) += tmp; } @@ -960,7 +954,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(88); - auto tmp = (avm_main_sel_op_version * (avm_kernel_kernel_sel - FF(29))); + auto tmp = (avm_main_sel_op_coinbase * (avm_kernel_kernel_sel - FF(32))); tmp *= scaling_factor; std::get<88>(evals) += tmp; } @@ -968,7 +962,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(89); - auto tmp = (avm_main_sel_op_block_number * (avm_kernel_kernel_sel - FF(30))); + auto tmp = (avm_main_sel_op_timestamp * (avm_kernel_kernel_sel - FF(31))); tmp *= scaling_factor; std::get<89>(evals) += tmp; } @@ -976,7 +970,7 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(90); - auto tmp = (avm_main_sel_op_coinbase * (avm_kernel_kernel_sel - FF(32))); + auto tmp = (avm_main_bin_op_id - (avm_main_sel_op_or + (avm_main_sel_op_xor * FF(2)))); tmp *= scaling_factor; std::get<90>(evals) += tmp; } @@ -984,25 +978,9 @@ template class avm_mainImpl { { Avm_DECLARE_VIEWS(91); - auto tmp = (avm_main_sel_op_timestamp * (avm_kernel_kernel_sel - FF(31))); - tmp *= scaling_factor; - std::get<91>(evals) += tmp; - } - // Contribution 92 - { - Avm_DECLARE_VIEWS(92); - - auto tmp = (avm_main_bin_op_id - (avm_main_sel_op_or + (avm_main_sel_op_xor * FF(2)))); - tmp *= scaling_factor; - std::get<92>(evals) += tmp; - } - // Contribution 93 - { - Avm_DECLARE_VIEWS(93); - auto tmp = (avm_main_bin_sel - ((avm_main_sel_op_and + avm_main_sel_op_or) + avm_main_sel_op_xor)); tmp *= scaling_factor; - std::get<93>(evals) += tmp; + std::get<91>(evals) += tmp; } } }; diff --git a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp index ac23edf051d..04ed0e23448 100644 --- a/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp +++ b/barretenberg/cpp/src/barretenberg/relations/generated/avm/declare_views.hpp @@ -167,7 +167,6 @@ [[maybe_unused]] auto avm_main_sel_op_fdiv = View(new_term.avm_main_sel_op_fdiv); \ [[maybe_unused]] auto avm_main_sel_op_fee_per_da_gas = View(new_term.avm_main_sel_op_fee_per_da_gas); \ [[maybe_unused]] auto avm_main_sel_op_fee_per_l2_gas = View(new_term.avm_main_sel_op_fee_per_l2_gas); \ - [[maybe_unused]] auto avm_main_sel_op_function_selector = View(new_term.avm_main_sel_op_function_selector); \ [[maybe_unused]] auto avm_main_sel_op_lt = View(new_term.avm_main_sel_op_lt); \ [[maybe_unused]] auto avm_main_sel_op_lte = View(new_term.avm_main_sel_op_lte); \ [[maybe_unused]] auto avm_main_sel_op_mul = View(new_term.avm_main_sel_op_mul); \ diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp index d601a4de519..fe495ae8c09 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_circuit_builder.hpp @@ -233,7 +233,6 @@ template struct AvmFullRow { FF avm_main_sel_op_fdiv{}; FF avm_main_sel_op_fee_per_da_gas{}; FF avm_main_sel_op_fee_per_l2_gas{}; - FF avm_main_sel_op_function_selector{}; FF avm_main_sel_op_lt{}; FF avm_main_sel_op_lte{}; FF avm_main_sel_op_mul{}; @@ -423,8 +422,8 @@ class AvmCircuitBuilder { using Polynomial = Flavor::Polynomial; using ProverPolynomials = Flavor::ProverPolynomials; - static constexpr size_t num_fixed_columns = 342; - static constexpr size_t num_polys = 290; + static constexpr size_t num_fixed_columns = 341; + static constexpr size_t num_polys = 289; std::vector rows; void set_trace(std::vector&& trace) { rows = std::move(trace); } @@ -605,7 +604,6 @@ class AvmCircuitBuilder { polys.avm_main_sel_op_fdiv[i] = rows[i].avm_main_sel_op_fdiv; polys.avm_main_sel_op_fee_per_da_gas[i] = rows[i].avm_main_sel_op_fee_per_da_gas; polys.avm_main_sel_op_fee_per_l2_gas[i] = rows[i].avm_main_sel_op_fee_per_l2_gas; - polys.avm_main_sel_op_function_selector[i] = rows[i].avm_main_sel_op_function_selector; polys.avm_main_sel_op_lt[i] = rows[i].avm_main_sel_op_lt; polys.avm_main_sel_op_lte[i] = rows[i].avm_main_sel_op_lte; polys.avm_main_sel_op_mul[i] = rows[i].avm_main_sel_op_mul; diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp index c177d5c3cf2..bf208bc727e 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_flavor.hpp @@ -82,11 +82,11 @@ class AvmFlavor { using RelationSeparator = FF; static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 2; - static constexpr size_t NUM_WITNESS_ENTITIES = 288; + static constexpr size_t NUM_WITNESS_ENTITIES = 287; static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES; // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for // the unshifted and one for the shifted - static constexpr size_t NUM_ALL_ENTITIES = 342; + static constexpr size_t NUM_ALL_ENTITIES = 341; using GrandProductRelations = std::tuple, perm_main_bin_relation, @@ -376,7 +376,6 @@ class AvmFlavor { avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, avm_main_sel_op_fee_per_l2_gas, - avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, @@ -667,7 +666,6 @@ class AvmFlavor { avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, avm_main_sel_op_fee_per_l2_gas, - avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, @@ -963,7 +961,6 @@ class AvmFlavor { avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, avm_main_sel_op_fee_per_l2_gas, - avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, @@ -1308,7 +1305,6 @@ class AvmFlavor { avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, avm_main_sel_op_fee_per_l2_gas, - avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, @@ -1653,7 +1649,6 @@ class AvmFlavor { avm_main_sel_op_fdiv, avm_main_sel_op_fee_per_da_gas, avm_main_sel_op_fee_per_l2_gas, - avm_main_sel_op_function_selector, avm_main_sel_op_lt, avm_main_sel_op_lte, avm_main_sel_op_mul, @@ -2312,7 +2307,6 @@ class AvmFlavor { Base::avm_main_sel_op_fdiv = "AVM_MAIN_SEL_OP_FDIV"; Base::avm_main_sel_op_fee_per_da_gas = "AVM_MAIN_SEL_OP_FEE_PER_DA_GAS"; Base::avm_main_sel_op_fee_per_l2_gas = "AVM_MAIN_SEL_OP_FEE_PER_L2_GAS"; - Base::avm_main_sel_op_function_selector = "AVM_MAIN_SEL_OP_FUNCTION_SELECTOR"; Base::avm_main_sel_op_lt = "AVM_MAIN_SEL_OP_LT"; Base::avm_main_sel_op_lte = "AVM_MAIN_SEL_OP_LTE"; Base::avm_main_sel_op_mul = "AVM_MAIN_SEL_OP_MUL"; @@ -2619,7 +2613,6 @@ class AvmFlavor { Commitment avm_main_sel_op_fdiv; Commitment avm_main_sel_op_fee_per_da_gas; Commitment avm_main_sel_op_fee_per_l2_gas; - Commitment avm_main_sel_op_function_selector; Commitment avm_main_sel_op_lt; Commitment avm_main_sel_op_lte; Commitment avm_main_sel_op_mul; @@ -2929,8 +2922,6 @@ class AvmFlavor { avm_main_sel_op_fdiv = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_fee_per_da_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_fee_per_l2_gas = deserialize_from_buffer(Transcript::proof_data, num_frs_read); - avm_main_sel_op_function_selector = - deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_lt = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_lte = deserialize_from_buffer(Transcript::proof_data, num_frs_read); avm_main_sel_op_mul = deserialize_from_buffer(Transcript::proof_data, num_frs_read); @@ -3241,7 +3232,6 @@ class AvmFlavor { serialize_to_buffer(avm_main_sel_op_fdiv, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_fee_per_da_gas, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_fee_per_l2_gas, Transcript::proof_data); - serialize_to_buffer(avm_main_sel_op_function_selector, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_lt, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_lte, Transcript::proof_data); serialize_to_buffer(avm_main_sel_op_mul, Transcript::proof_data); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp index 6a7ac6aae24..6f5fd5a27fd 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_prover.cpp @@ -224,8 +224,6 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_sel_op_fdiv = commitment_key->commit(key->avm_main_sel_op_fdiv); witness_commitments.avm_main_sel_op_fee_per_da_gas = commitment_key->commit(key->avm_main_sel_op_fee_per_da_gas); witness_commitments.avm_main_sel_op_fee_per_l2_gas = commitment_key->commit(key->avm_main_sel_op_fee_per_l2_gas); - witness_commitments.avm_main_sel_op_function_selector = - commitment_key->commit(key->avm_main_sel_op_function_selector); witness_commitments.avm_main_sel_op_lt = commitment_key->commit(key->avm_main_sel_op_lt); witness_commitments.avm_main_sel_op_lte = commitment_key->commit(key->avm_main_sel_op_lte); witness_commitments.avm_main_sel_op_mul = commitment_key->commit(key->avm_main_sel_op_mul); @@ -497,8 +495,6 @@ void AvmProver::execute_wire_commitments_round() witness_commitments.avm_main_sel_op_fee_per_da_gas); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_fee_per_l2_gas, witness_commitments.avm_main_sel_op_fee_per_l2_gas); - transcript->send_to_verifier(commitment_labels.avm_main_sel_op_function_selector, - witness_commitments.avm_main_sel_op_function_selector); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_lt, witness_commitments.avm_main_sel_op_lt); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_lte, witness_commitments.avm_main_sel_op_lte); transcript->send_to_verifier(commitment_labels.avm_main_sel_op_mul, witness_commitments.avm_main_sel_op_mul); diff --git a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp index af14f03224c..75984868e88 100644 --- a/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp +++ b/barretenberg/cpp/src/barretenberg/vm/generated/avm_verifier.cpp @@ -341,8 +341,6 @@ bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector& pu transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_fee_per_da_gas); commitments.avm_main_sel_op_fee_per_l2_gas = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_fee_per_l2_gas); - commitments.avm_main_sel_op_function_selector = - transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_function_selector); commitments.avm_main_sel_op_lt = transcript->template receive_from_prover(commitment_labels.avm_main_sel_op_lt); commitments.avm_main_sel_op_lte = From 449f3da0ba63ea7910fa86862c96af2680311be2 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 10 May 2024 13:23:05 +0000 Subject: [PATCH 39/40] fmt fix --- barretenberg/cpp/pil/avm/constants.pil | 1 - yarn-project/circuits.js/src/scripts/constants.in.ts | 8 +++----- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/barretenberg/cpp/pil/avm/constants.pil b/barretenberg/cpp/pil/avm/constants.pil index 609b6d827e3..d5985545280 100644 --- a/barretenberg/cpp/pil/avm/constants.pil +++ b/barretenberg/cpp/pil/avm/constants.pil @@ -6,7 +6,6 @@ namespace constants(256); pol SENDER_SELECTOR = 0; pol ADDRESS_SELECTOR = 1; pol PORTAL_SELECTOR = 2; - pol FUNCTION_SELECTOR = 3; // NOTE: constant expression evaluation does not seem to be supported yet in pil // pol START_GLOBAL_VARIABLES = CALL_CONTEXT_LENGTH + HEADER_LENGTH = 6 + 22 = 28 diff --git a/yarn-project/circuits.js/src/scripts/constants.in.ts b/yarn-project/circuits.js/src/scripts/constants.in.ts index 96f59872d29..e5f969e228b 100644 --- a/yarn-project/circuits.js/src/scripts/constants.in.ts +++ b/yarn-project/circuits.js/src/scripts/constants.in.ts @@ -46,10 +46,9 @@ function processConstantsCpp(constants: { [key: string]: string }): string { const code: string[] = []; Object.entries(constants).forEach(([key, value]) => { // We exclude large numbers - if (!(value.startsWith("0x") || value.includes("0_0")) ) { + if (!(value.startsWith('0x') || value.includes('0_0'))) { code.push(`const size_t ${key} = ${value};`); - }; - + } }); return code.join('\n'); } @@ -117,7 +116,6 @@ ${processConstantsCpp(constants)} fs.writeFileSync(targetPath, resultCpp); } - /** * Generate the constants file in Solidity. */ @@ -192,7 +190,7 @@ function main(): void { // Cpp const cppTargetPath = join(__dirname, CPP_AZTEC_CONSTANTS_FILE); - generateCppConstants(parsedContent, cppTargetPath) + generateCppConstants(parsedContent, cppTargetPath); // Solidity const solidityTargetPath = join(__dirname, SOLIDITY_CONSTANTS_FILE); From 3cf29f3d03b598fe5400ef01b83af4a6ee1dbd56 Mon Sep 17 00:00:00 2001 From: Maddiaa0 <47148561+Maddiaa0@users.noreply.github.com> Date: Fri, 10 May 2024 16:02:02 +0000 Subject: [PATCH 40/40] fix: remove template brackets limit: --- barretenberg/cpp/src/CMakeLists.txt | 3 --- 1 file changed, 3 deletions(-) diff --git a/barretenberg/cpp/src/CMakeLists.txt b/barretenberg/cpp/src/CMakeLists.txt index b41f03b5528..a9809f12c61 100644 --- a/barretenberg/cpp/src/CMakeLists.txt +++ b/barretenberg/cpp/src/CMakeLists.txt @@ -1,9 +1,6 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) -# Temp, increase this flag to enable vm compilation -set(CMAKE_CXX_FLAGS "-fbracket-depth=512") - # Enable the following warnings project wide. # If any compilation issues arise in the future, they should not be silenced here but rather in the # module's own CMakeLists.txt by adding conditional compilation flags like the following