fix: rebase cleanup

Author: Maddiaa0

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

@@ -56,12 +56,12 @@ void create_circuit(Builder& builder, acir_format const& constraint_system)
 
     // Add ECDSA K1 constraints
     for (const auto& constraint : constraint_system.ecdsa_k1_constraints) {
-        create_ecdsa_k1_verify_constraints(composer, constraint, false);
+        create_ecdsa_k1_verify_constraints(builder, constraint, false);
     }
 
     // Add ECDSA R1 constraints
     for (const auto& constraint : constraint_system.ecdsa_r1_constraints) {
-        create_ecdsa_r1_verify_constraints(composer, constraint, false);
+        create_ecdsa_r1_verify_constraints(builder, constraint, false);
     }
 
     // Add blake2s constraints
@@ -178,12 +178,12 @@ void create_circuit_with_witness(Builder& builder, acir_format const& constraint
 
     // Add ECDSA k1 constraints
     for (const auto& constraint : constraint_system.ecdsa_k1_constraints) {
-        create_ecdsa_k1_verify_constraints(composer, constraint);
+        create_ecdsa_k1_verify_constraints(builder, constraint);
     }
 
     // Add ECDSA r1 constraints
     for (const auto& constraint : constraint_system.ecdsa_r1_constraints) {
-        create_ecdsa_r1_verify_constraints(composer, constraint);
+        create_ecdsa_r1_verify_constraints(builder, constraint);
     }
 
     // Add blake2s constraints

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

@@ -29,7 +29,8 @@ TEST(acir_format, test_a_single_constraint_no_pub_inputs)
         .logic_constraints = {},
         .range_constraints = {},
         .schnorr_constraints = {},
-        .ecdsa_constraints = {},
+        .ecdsa_k1_constraints = {},
+        .ecdsa_r1_constraints = {},
         .sha256_constraints = {},
         .blake2s_constraints = {},
         .keccak_constraints = {},

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

@@ -83,7 +83,7 @@ witness_ct ecdsa_index_to_witness(Builder& builder, uint32_t index)
     return { &builder, value };
 }
 
-void create_ecdsa_k1_verify_constraints(Composer& composer,
+void create_ecdsa_k1_verify_constraints(Builder& builder,
                                         const EcdsaSecp256k1Constraint& input,
                                         bool has_valid_witness_assignments)
 {

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

@@ -1,6 +1,6 @@
 #pragma once
-#include "barretenberg/dsl/types.hpp"
 #include "barretenberg/crypto/ecdsa/ecdsa.hpp"
+#include "barretenberg/dsl/types.hpp"
 #include <vector>
 
 namespace acir_format {
@@ -27,15 +27,15 @@ struct EcdsaSecp256k1Constraint {
     friend bool operator==(EcdsaSecp256k1Constraint const& lhs, EcdsaSecp256k1Constraint const& rhs) = default;
 };
 
-void create_ecdsa_k1_verify_constraints(Composer& composer,
+void create_ecdsa_k1_verify_constraints(Builder& builder,
                                         const EcdsaSecp256k1Constraint& input,
                                         bool has_valid_witness_assignments = true);
 
 void dummy_ecdsa_constraint(Builder& builder, EcdsaSecp256k1Constraint const& input);
 
-crypto::ecdsa::signature ecdsa_convert_signature(Composer& composer, std::vector<uint32_t> signature);
-witness_ct ecdsa_index_to_witness(Composer& composer, uint32_t index);
-byte_array_ct ecdsa_vector_of_bytes_to_byte_array(Composer& composer, std::vector<uint32_t> vector_of_bytes);
+crypto::ecdsa::signature ecdsa_convert_signature(Builder& builder, std::vector<uint32_t> signature);
+witness_ct ecdsa_index_to_witness(Builder& builder, uint32_t index);
+byte_array_ct ecdsa_vector_of_bytes_to_byte_array(Builder& builder, std::vector<uint32_t> vector_of_bytes);
 
 template <typename B> inline void read(B& buf, EcdsaSecp256k1Constraint& constraint)
 {

cpp/src/barretenberg/dsl/acir_format/ecdsa_secp256k1.test.cpp

@@ -81,9 +81,9 @@ size_t generate_ecdsa_constraint(EcdsaSecp256k1Constraint& ecdsa_constraint, Wit
 
 TEST(ECDSASecp256k1, TestECDSAConstraintSucceed)
 {
-    EcdsaSecp256k1Constraint ecdsa_constraint;
+    EcdsaSecp256k1Constraint ecdsa_k1_constraint;
     WitnessVector witness_values;
-    size_t num_variables = generate_ecdsa_constraint(ecdsa_constraint, witness_values);
+    size_t num_variables = generate_ecdsa_constraint(ecdsa_k1_constraint, witness_values);
     acir_format constraint_system{
         .varnum = static_cast<uint32_t>(num_variables),
         .public_inputs = {},
@@ -106,7 +106,7 @@ TEST(ECDSASecp256k1, TestECDSAConstraintSucceed)
 
     auto builder = create_circuit_with_witness(constraint_system, witness_values);
 
-    EXPECT_EQ(builder.get_variable(ecdsa_constraint.result), 1);
+    EXPECT_EQ(builder.get_variable(ecdsa_k1_constraint.result), 1);
 
     auto composer = Composer();
     auto prover = composer.create_prover(builder);
@@ -121,9 +121,9 @@ TEST(ECDSASecp256k1, TestECDSAConstraintSucceed)
 // even though we are just building the circuit.
 TEST(ECDSASecp256k1, TestECDSACompilesForVerifier)
 {
-    EcdsaSecp256k1Constraint ecdsa_constraint;
+    EcdsaSecp256k1Constraint ecdsa_k1_constraint;
     WitnessVector witness_values;
-    size_t num_variables = generate_ecdsa_constraint(ecdsa_constraint, witness_values);
+    size_t num_variables = generate_ecdsa_constraint(ecdsa_k1_constraint, witness_values);
     acir_format constraint_system{
         .varnum = static_cast<uint32_t>(num_variables),
         .public_inputs = {},
@@ -179,7 +179,7 @@ TEST(ECDSASecp256k1, TestECDSAConstraintFail)
     };
 
     auto builder = create_circuit_with_witness(constraint_system, witness_values);
-    EXPECT_EQ(builder.get_variable(ecdsa_constraint.result), 0);
+    EXPECT_EQ(builder.get_variable(ecdsa_k1_constraint.result), 0);
 
     auto composer = Composer();
     auto prover = composer.create_prover(builder);

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

@@ -1,13 +1,13 @@
 #include "ecdsa_secp256r1.hpp"
-#include "ecdsa_secp256k1.hpp"
 #include "barretenberg/crypto/ecdsa/ecdsa.hpp"
 #include "barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp"
+#include "ecdsa_secp256k1.hpp"
 
 namespace acir_format {
 
 using namespace proof_system::plonk;
 
-secp256r1_ct::g1_ct ecdsa_convert_inputs(Composer* ctx, const secp256r1::g1::affine_element& input)
+secp256r1_ct::g1_ct ecdsa_convert_inputs(Builder* ctx, const secp256r1::g1::affine_element& input)
 {
     uint256_t x_u256(input.x);
     uint256_t y_u256(input.y);
@@ -23,20 +23,20 @@ secp256r1_ct::g1_ct ecdsa_convert_inputs(Composer* ctx, const secp256r1::g1::aff
     return { x, y };
 }
 
-void create_ecdsa_r1_verify_constraints(Composer& composer,
+void create_ecdsa_r1_verify_constraints(Builder& builder,
                                         const EcdsaSecp256r1Constraint& input,
                                         bool has_valid_witness_assignments)
 {
 
     if (has_valid_witness_assignments == false) {
-        dummy_ecdsa_constraint(composer, input);
+        dummy_ecdsa_constraint(builder, input);
     }
 
-    auto new_sig = ecdsa_convert_signature(composer, input.signature);
+    auto new_sig = ecdsa_convert_signature(builder, input.signature);
 
-    auto message = ecdsa_vector_of_bytes_to_byte_array(composer, input.hashed_message);
-    auto pub_key_x_byte_arr = ecdsa_vector_of_bytes_to_byte_array(composer, input.pub_x_indices);
-    auto pub_key_y_byte_arr = ecdsa_vector_of_bytes_to_byte_array(composer, input.pub_y_indices);
+    auto message = ecdsa_vector_of_bytes_to_byte_array(builder, input.hashed_message);
+    auto pub_key_x_byte_arr = ecdsa_vector_of_bytes_to_byte_array(builder, input.pub_x_indices);
+    auto pub_key_y_byte_arr = ecdsa_vector_of_bytes_to_byte_array(builder, input.pub_y_indices);
 
     auto pub_key_x_fq = secp256r1_ct::fq_ct(pub_key_x_byte_arr);
     auto pub_key_y_fq = secp256r1_ct::fq_ct(pub_key_y_byte_arr);
@@ -45,39 +45,39 @@ void create_ecdsa_r1_verify_constraints(Composer& composer,
     std::vector<uint8_t> ss(new_sig.s.begin(), new_sig.s.end());
     uint8_t vv = new_sig.v;
 
-    stdlib::ecdsa::signature<Composer> sig{ stdlib::byte_array<Composer>(&composer, rr),
-                                            stdlib::byte_array<Composer>(&composer, ss),
-                                            stdlib::uint8<Composer>(&composer, vv) };
+    stdlib::ecdsa::signature<Builder> sig{ stdlib::byte_array<Builder>(&builder, rr),
+                                           stdlib::byte_array<Builder>(&builder, ss),
+                                           stdlib::uint8<Builder>(&builder, vv) };
 
     pub_key_x_fq.assert_is_in_field();
     pub_key_y_fq.assert_is_in_field();
     secp256r1_ct::g1_bigfr_ct public_key = secp256r1_ct::g1_bigfr_ct(pub_key_x_fq, pub_key_y_fq);
     for (size_t i = 0; i < 32; ++i) {
-        sig.r[i].assert_equal(field_ct::from_witness_index(&composer, input.signature[i]));
-        sig.s[i].assert_equal(field_ct::from_witness_index(&composer, input.signature[i + 32]));
-        pub_key_x_byte_arr[i].assert_equal(field_ct::from_witness_index(&composer, input.pub_x_indices[i]));
-        pub_key_y_byte_arr[i].assert_equal(field_ct::from_witness_index(&composer, input.pub_y_indices[i]));
+        sig.r[i].assert_equal(field_ct::from_witness_index(&builder, input.signature[i]));
+        sig.s[i].assert_equal(field_ct::from_witness_index(&builder, input.signature[i + 32]));
+        pub_key_x_byte_arr[i].assert_equal(field_ct::from_witness_index(&builder, input.pub_x_indices[i]));
+        pub_key_y_byte_arr[i].assert_equal(field_ct::from_witness_index(&builder, input.pub_y_indices[i]));
     }
     for (size_t i = 0; i < input.hashed_message.size(); ++i) {
-        message[i].assert_equal(field_ct::from_witness_index(&composer, input.hashed_message[i]));
+        message[i].assert_equal(field_ct::from_witness_index(&builder, input.hashed_message[i]));
     }
 
     bool_ct signature_result =
-        stdlib::ecdsa::verify_signature_prehashed_message_noassert<Composer,
+        stdlib::ecdsa::verify_signature_prehashed_message_noassert<Builder,
                                                                    secp256r1_ct,
                                                                    secp256r1_ct::fq_ct,
                                                                    secp256r1_ct::bigfr_ct,
                                                                    secp256r1_ct::g1_bigfr_ct>(message, public_key, sig);
     bool_ct signature_result_normalized = signature_result.normalize();
-    composer.assert_equal(signature_result_normalized.witness_index, input.result);
+    builder.assert_equal(signature_result_normalized.witness_index, input.result);
 }
 
 // Add dummy constraints for ECDSA because when the verifier creates the
 // constraint system, they usually use zeroes for witness values.
 //
 // This does not work for ECDSA as the signature, r, s and public key need
 // to be valid.
-void dummy_ecdsa_constraint(Composer& composer, EcdsaSecp256r1Constraint const& input)
+void dummy_ecdsa_constraint(Builder& builder, EcdsaSecp256r1Constraint const& input)
 {
 
     std::vector<uint32_t> pub_x_indices_;
@@ -110,11 +110,11 @@ void dummy_ecdsa_constraint(Composer& composer, EcdsaSecp256r1Constraint const&
     // We don't use them in a gate, so when we call assert_equal, they will be
     // replaced as if they never existed.
     for (size_t i = 0; i < 32; ++i) {
-        uint32_t m_wit = composer.add_variable(hashed_message[i]);
-        uint32_t x_wit = composer.add_variable(pub_x_value.slice(248 - i * 8, 256 - i * 8));
-        uint32_t y_wit = composer.add_variable(pub_y_value.slice(248 - i * 8, 256 - i * 8));
-        uint32_t r_wit = composer.add_variable(signature.r[i]);
-        uint32_t s_wit = composer.add_variable(signature.s[i]);
+        uint32_t m_wit = builder.add_variable(hashed_message[i]);
+        uint32_t x_wit = builder.add_variable(pub_x_value.slice(248 - i * 8, 256 - i * 8));
+        uint32_t y_wit = builder.add_variable(pub_y_value.slice(248 - i * 8, 256 - i * 8));
+        uint32_t r_wit = builder.add_variable(signature.r[i]);
+        uint32_t s_wit = builder.add_variable(signature.s[i]);
         message_indicies_.emplace_back(m_wit);
         pub_x_indices_.emplace_back(x_wit);
         pub_y_indices_.emplace_back(y_wit);
@@ -124,16 +124,16 @@ void dummy_ecdsa_constraint(Composer& composer, EcdsaSecp256r1Constraint const&
 
     // Call assert_equal(from, to) to replace the value in `to` by the value in `from`
     for (size_t i = 0; i < input.hashed_message.size(); ++i) {
-        composer.assert_equal(message_indicies_[i], input.hashed_message[i]);
+        builder.assert_equal(message_indicies_[i], input.hashed_message[i]);
     }
     for (size_t i = 0; i < input.pub_x_indices.size(); ++i) {
-        composer.assert_equal(pub_x_indices_[i], input.pub_x_indices[i]);
+        builder.assert_equal(pub_x_indices_[i], input.pub_x_indices[i]);
     }
     for (size_t i = 0; i < input.pub_y_indices.size(); ++i) {
-        composer.assert_equal(pub_y_indices_[i], input.pub_y_indices[i]);
+        builder.assert_equal(pub_y_indices_[i], input.pub_y_indices[i]);
     }
     for (size_t i = 0; i < input.signature.size(); ++i) {
-        composer.assert_equal(signature_[i], input.signature[i]);
+        builder.assert_equal(signature_[i], input.signature[i]);
     }
 }
 

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

@@ -1,6 +1,6 @@
 #pragma once
-#include <vector>
 #include "barretenberg/dsl/types.hpp"
+#include <vector>
 
 namespace acir_format {
 
@@ -26,11 +26,11 @@ struct EcdsaSecp256r1Constraint {
     friend bool operator==(EcdsaSecp256r1Constraint const& lhs, EcdsaSecp256r1Constraint const& rhs) = default;
 };
 
-void create_ecdsa_r1_verify_constraints(Composer& composer,
+void create_ecdsa_r1_verify_constraints(Builder& builder,
                                         const EcdsaSecp256r1Constraint& input,
                                         bool has_valid_witness_assignments = true);
 
-void dummy_ecdsa_constraint(Composer& composer, EcdsaSecp256r1Constraint const& input);
+void dummy_ecdsa_constraint(Builder& builder, EcdsaSecp256r1Constraint const& input);
 
 template <typename B> inline void read(B& buf, EcdsaSecp256r1Constraint& constraint)
 {