Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

chore(circuits): merge and root rollup cbind msgpack #2192

Merged
merged 8 commits into from
Sep 12, 2023
Merged

chore(circuits): merge and root rollup cbind msgpack #2192

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
1a8ed2b
2116 - migrate cbind routine for merge rollup to msgpack
jeanmon Sep 8, 2023
22e1a76
2117 - remove unused code in root rollup
jeanmon Sep 11, 2023
2dda3a8
2117 - use msgpack based macro for cbind in root rollups
jeanmon Sep 11, 2023
366cea8
2117 - generate circuits.gen.ts and reconcile data structures
jeanmon Sep 11, 2023
2890683
2117 - activate msgpack cbind method
jeanmon Sep 11, 2023
8661b59
2117 - adapt snapshot for root rollup
jeanmon Sep 11, 2023
46340db
2117 - remove some unused imports in TS
jeanmon Sep 11, 2023
1916038
2117 - address feedback of David
jeanmon Sep 12, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 6 additions & 6 deletions circuits/cpp/src/aztec3/circuits/abis/rollup/root/root_rollup_inputs.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,20 +19,20 @@ template <typename NCT> struct RootRollupInputs {
std::array<PreviousRollupData<NCT>, 2> previous_rollup_data{};

// inputs required to process l1 to l2 messages
std::array<fr, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP> l1_to_l2_messages{};
std::array<fr, L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH> new_l1_to_l2_message_tree_root_sibling_path{};
std::array<fr, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP> new_l1_to_l2_messages{};
std::array<fr, L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH> new_l1_to_l2_messages_tree_root_sibling_path{};

AppendOnlyTreeSnapshot<NCT> start_l1_to_l2_message_tree_snapshot{};
AppendOnlyTreeSnapshot<NCT> start_l1_to_l2_messages_tree_snapshot{};

// inputs required to add the block hash
AppendOnlyTreeSnapshot<NCT> start_historic_blocks_tree_snapshot{};
std::array<fr, HISTORIC_BLOCKS_TREE_HEIGHT> new_historic_blocks_tree_sibling_path{};

// For serialization, update with new fields
MSGPACK_FIELDS(previous_rollup_data,
l1_to_l2_messages,
new_l1_to_l2_message_tree_root_sibling_path,
start_l1_to_l2_message_tree_snapshot,
new_l1_to_l2_messages,
new_l1_to_l2_messages_tree_root_sibling_path,
start_l1_to_l2_messages_tree_snapshot,
start_historic_blocks_tree_snapshot,
new_historic_blocks_tree_sibling_path);
bool operator==(RootRollupInputs<NCT> const&) const = default;
Expand Down
87 changes: 46 additions & 41 deletions circuits/cpp/src/aztec3/circuits/rollup/merge/.test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,46 +28,49 @@ class merge_rollup_tests : public ::testing::Test {
protected:
static void SetUpTestSuite() { barretenberg::srs::init_crs_factory("../barretenberg/cpp/srs_db/ignition"); }

static void run_cbind(MergeRollupInputs& merge_rollup_inputs,
BaseOrMergeRollupPublicInputs& expected_public_inputs,
bool compare_pubins = true)
{
info("Retesting via cbinds....");
std::vector<uint8_t> merge_rollup_inputs_vec;
serialize::write(merge_rollup_inputs_vec, merge_rollup_inputs);

uint8_t const* public_inputs_buf = nullptr;
// info("simulating circuit via cbind");
size_t public_inputs_size = 0;
info("creating proof");
auto* circuit_failure_ptr =
merge_rollup__sim(merge_rollup_inputs_vec.data(), &public_inputs_size, &public_inputs_buf);
ASSERT_TRUE(circuit_failure_ptr == nullptr);
// info("PublicInputs size: ", public_inputs_size);

if (compare_pubins) {
BaseOrMergeRollupPublicInputs public_inputs;
uint8_t const* public_inputs_buf_tmp = public_inputs_buf;
serialize::read(public_inputs_buf_tmp, public_inputs);
ASSERT_EQ(public_inputs.calldata_hash.size(), expected_public_inputs.calldata_hash.size());
for (size_t i = 0; i < public_inputs.calldata_hash.size(); i++) {
ASSERT_EQ(public_inputs.calldata_hash[i], expected_public_inputs.calldata_hash[i]);
}

std::vector<uint8_t> expected_public_inputs_vec;
serialize::write(expected_public_inputs_vec, expected_public_inputs);

ASSERT_EQ(public_inputs_size, expected_public_inputs_vec.size());
// Just compare the first 10 bytes of the serialized public outputs
if (public_inputs_size > 10) {
// for (size_t 0; i < public_inputs_size; i++) {
for (size_t i = 0; i < 10; i++) {
ASSERT_EQ(public_inputs_buf[i], expected_public_inputs_vec[i]);
}
}
}
free((void*)public_inputs_buf);
}
// TODO(1998): uncomment once https://github.com/AztecProtocol/aztec-packages/issues/1998 is solved and
// use new pattern such as call_func_and_wrapper from test_helper.hpp

// static void run_cbind(MergeRollupInputs& merge_rollup_inputs,
// BaseOrMergeRollupPublicInputs& expected_public_inputs,
// bool compare_pubins = true)
// {
// info("Retesting via cbinds....");
// std::vector<uint8_t> merge_rollup_inputs_vec;
// serialize::write(merge_rollup_inputs_vec, merge_rollup_inputs);

// uint8_t const* public_inputs_buf = nullptr;
// // info("simulating circuit via cbind");
// size_t public_inputs_size = 0;
// info("creating proof");
// auto* circuit_failure_ptr =
// merge_rollup__sim(merge_rollup_inputs_vec.data(), &public_inputs_size, &public_inputs_buf);
// ASSERT_TRUE(circuit_failure_ptr == nullptr);
// // info("PublicInputs size: ", public_inputs_size);

// if (compare_pubins) {
// BaseOrMergeRollupPublicInputs public_inputs;
// uint8_t const* public_inputs_buf_tmp = public_inputs_buf;
// serialize::read(public_inputs_buf_tmp, public_inputs);
// ASSERT_EQ(public_inputs.calldata_hash.size(), expected_public_inputs.calldata_hash.size());
// for (size_t i = 0; i < public_inputs.calldata_hash.size(); i++) {
// ASSERT_EQ(public_inputs.calldata_hash[i], expected_public_inputs.calldata_hash[i]);
// }

// std::vector<uint8_t> expected_public_inputs_vec;
// serialize::write(expected_public_inputs_vec, expected_public_inputs);

// ASSERT_EQ(public_inputs_size, expected_public_inputs_vec.size());
// // Just compare the first 10 bytes of the serialized public outputs
// if (public_inputs_size > 10) {
// // for (size_t 0; i < public_inputs_size; i++) {
// for (size_t i = 0; i < 10; i++) {
// ASSERT_EQ(public_inputs_buf[i], expected_public_inputs_vec[i]);
// }
// }
// }
// free((void*)public_inputs_buf);
// }
dbanks12 marked this conversation as resolved.
Show resolved Hide resolved
};

TEST_F(merge_rollup_tests, native_different_rollup_type_fails)
Expand Down Expand Up @@ -299,6 +302,8 @@ TEST_F(merge_rollup_tests, native_merge_cbind)

ASSERT_FALSE(builder.failed());
BaseOrMergeRollupPublicInputs ignored_public_inputs;
run_cbind(inputs, ignored_public_inputs, false);

// TODO(1998): see above
// run_cbind(inputs, ignored_public_inputs, false);
}
} // namespace aztec3::circuits::rollup::merge::native_merge_rollup_circuit
26 changes: 4 additions & 22 deletions circuits/cpp/src/aztec3/circuits/rollup/merge/c_bind.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,32 +9,14 @@
namespace {
using NT = aztec3::utils::types::NativeTypes;
using DummyCircuitBuilder = aztec3::utils::DummyCircuitBuilder;
using aztec3::circuits::abis::BaseOrMergeRollupPublicInputs;
using aztec3::circuits::abis::MergeRollupInputs;
using aztec3::circuits::rollup::merge::merge_rollup_circuit;
} // namespace

// WASM Cbinds
extern "C" {

WASM_EXPORT uint8_t* merge_rollup__sim(uint8_t const* merge_rollup_inputs_buf,
size_t* merge_rollup_public_inputs_size_out,
uint8_t const** merge_rollup_public_inputs_buf)
{
CBIND(merge_rollup__sim, [](MergeRollupInputs<NT> const& merge_rollup_inputs) {
DummyCircuitBuilder builder = DummyCircuitBuilder("merge_rollup__sim");
MergeRollupInputs<NT> merge_rollup_inputs;
serialize::read(merge_rollup_inputs_buf, merge_rollup_inputs);

BaseOrMergeRollupPublicInputs const public_inputs = merge_rollup_circuit(builder, merge_rollup_inputs);

// serialize public inputs to bytes vec
std::vector<uint8_t> public_inputs_vec;
serialize::write(public_inputs_vec, public_inputs);
// copy public inputs to output buffer
auto* raw_public_inputs_buf = (uint8_t*)malloc(public_inputs_vec.size());
memcpy(raw_public_inputs_buf, (void*)public_inputs_vec.data(), public_inputs_vec.size());
*merge_rollup_public_inputs_buf = raw_public_inputs_buf;
*merge_rollup_public_inputs_size_out = public_inputs_vec.size();
return builder.alloc_and_serialize_first_failure();
}
} // extern "C"
auto const& public_inputs = merge_rollup_circuit(builder, merge_rollup_inputs);
return builder.result_or_error(public_inputs);
});
7 changes: 1 addition & 6 deletions circuits/cpp/src/aztec3/circuits/rollup/merge/c_bind.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,9 +5,4 @@
#include <cstddef>
#include <cstdint>

extern "C" {

WASM_EXPORT uint8_t* merge_rollup__sim(uint8_t const* merge_rollup_inputs_buf,
size_t* merge_rollup_public_inputs_size_out,
uint8_t const** merge_rollup_public_inputs_buf);
}
CBIND_DECL(merge_rollup__sim);
113 changes: 53 additions & 60 deletions circuits/cpp/src/aztec3/circuits/rollup/root/.test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -64,64 +64,55 @@ class root_rollup_tests : public ::testing::Test {
protected:
static void SetUpTestSuite() { barretenberg::srs::init_crs_factory("../barretenberg/cpp/srs_db/ignition"); }

static void run_cbind(RootRollupInputs& root_rollup_inputs,
RootRollupPublicInputs& expected_public_inputs,
bool compare_pubins = true)
{
info("Retesting via cbinds....");
// TODO might be able to get rid of proving key buffer
uint8_t const* pk_buf = nullptr;
size_t const pk_size = root_rollup__init_proving_key(&pk_buf);
(void)pk_size;
// info("Proving key size: ", pk_size);

// TODO might be able to get rid of verification key buffer
uint8_t const* vk_buf = nullptr;
size_t const vk_size = root_rollup__init_verification_key(pk_buf, &vk_buf);
(void)vk_size;
// info("Verification key size: ", vk_size);

std::vector<uint8_t> root_rollup_inputs_vec;
serialize::write(root_rollup_inputs_vec, root_rollup_inputs);

// uint8_t const* proof_data;
// size_t proof_data_size;
uint8_t const* public_inputs_buf = nullptr;
size_t public_inputs_size = 0;
// info("simulating circuit via cbind");
uint8_t* const circuit_failure_ptr =
root_rollup__sim(root_rollup_inputs_vec.data(), &public_inputs_size, &public_inputs_buf);
ASSERT_TRUE(circuit_failure_ptr == nullptr);
// info("Proof size: ", proof_data_size);
// info("PublicInputs size: ", public_inputs_size);

if (compare_pubins) {
RootRollupPublicInputs public_inputs;
uint8_t const* public_inputs_buf_tmp = public_inputs_buf;
serialize::read(public_inputs_buf_tmp, public_inputs);
ASSERT_EQ(public_inputs.calldata_hash.size(), expected_public_inputs.calldata_hash.size());
for (size_t i = 0; i < public_inputs.calldata_hash.size(); i++) {
ASSERT_EQ(public_inputs.calldata_hash[i], expected_public_inputs.calldata_hash[i]);
}

std::vector<uint8_t> expected_public_inputs_vec;
serialize::write(expected_public_inputs_vec, expected_public_inputs);

ASSERT_EQ(public_inputs_size, expected_public_inputs_vec.size());
// Just compare the first 10 bytes of the serialized public outputs
if (public_inputs_size > 10) {
// for (size_t 0; i < public_inputs_size; i++) {
for (size_t i = 0; i < 10; i++) {
ASSERT_EQ(public_inputs_buf[i], expected_public_inputs_vec[i]);
}
}
}

free((void*)pk_buf);
free((void*)vk_buf);
// free((void*)proof_data);
free((void*)public_inputs_buf);
}
// TODO(1998): uncomment once https://github.com/AztecProtocol/aztec-packages/issues/1998 is solved and
// use new pattern such as call_func_and_wrapper from test_helper.hpp

// static void run_cbind(RootRollupInputs& root_rollup_inputs,
// RootRollupPublicInputs& expected_public_inputs,
// bool compare_pubins = true)
// {
// info("Retesting via cbinds....");
// // info("Verification key size: ", vk_size);

// std::vector<uint8_t> root_rollup_inputs_vec;
// serialize::write(root_rollup_inputs_vec, root_rollup_inputs);

// // uint8_t const* proof_data;
// // size_t proof_data_size;
// uint8_t const* public_inputs_buf = nullptr;
// size_t public_inputs_size = 0;
// // info("simulating circuit via cbind");
// uint8_t* const circuit_failure_ptr =
// root_rollup__sim(root_rollup_inputs_vec.data(), &public_inputs_size, &public_inputs_buf);
// ASSERT_TRUE(circuit_failure_ptr == nullptr);
// // info("Proof size: ", proof_data_size);
// // info("PublicInputs size: ", public_inputs_size);

// if (compare_pubins) {
// RootRollupPublicInputs public_inputs;
// uint8_t const* public_inputs_buf_tmp = public_inputs_buf;
// serialize::read(public_inputs_buf_tmp, public_inputs);
// ASSERT_EQ(public_inputs.calldata_hash.size(), expected_public_inputs.calldata_hash.size());
// for (size_t i = 0; i < public_inputs.calldata_hash.size(); i++) {
// ASSERT_EQ(public_inputs.calldata_hash[i], expected_public_inputs.calldata_hash[i]);
// }

// std::vector<uint8_t> expected_public_inputs_vec;
// serialize::write(expected_public_inputs_vec, expected_public_inputs);

// ASSERT_EQ(public_inputs_size, expected_public_inputs_vec.size());
// // Just compare the first 10 bytes of the serialized public outputs
// if (public_inputs_size > 10) {
// // for (size_t 0; i < public_inputs_size; i++) {
// for (size_t i = 0; i < 10; i++) {
// ASSERT_EQ(public_inputs_buf[i], expected_public_inputs_vec[i]);
// }
// }
// }

// // free((void*)proof_data);
// free((void*)public_inputs_buf);
// }
dbanks12 marked this conversation as resolved.
Show resolved Hide resolved
};

TEST_F(root_rollup_tests, native_check_block_hashes_empty_blocks)
Expand Down Expand Up @@ -161,7 +152,8 @@ TEST_F(root_rollup_tests, native_check_block_hashes_empty_blocks)

EXPECT_FALSE(builder.failed());

run_cbind(inputs, outputs, true);
// TODO(1998): see above
// run_cbind(inputs, outputs, true);
dbanks12 marked this conversation as resolved.
Show resolved Hide resolved
}

TEST_F(root_rollup_tests, native_root_missing_nullifier_logic)
Expand Down Expand Up @@ -312,7 +304,8 @@ TEST_F(root_rollup_tests, native_root_missing_nullifier_logic)

EXPECT_FALSE(builder.failed());

run_cbind(rootRollupInputs, outputs, true);
// TODO(1998): see above
// run_cbind(rootRollupInputs, outputs, true);
dbanks12 marked this conversation as resolved.
Show resolved Hide resolved
}

} // namespace aztec3::circuits::rollup::root::native_root_rollup_circuit
59 changes: 4 additions & 55 deletions circuits/cpp/src/aztec3/circuits/rollup/root/c_bind.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,59 +19,8 @@ using aztec3::circuits::rollup::native_root_rollup::RootRollupPublicInputs;
} // namespace

// WASM Cbinds
extern "C" {

WASM_EXPORT size_t root_rollup__init_proving_key(uint8_t const** pk_buf)
{
std::vector<uint8_t> pk_vec(42, 0);

auto* raw_buf = (uint8_t*)malloc(pk_vec.size());
memcpy(raw_buf, (void*)pk_vec.data(), pk_vec.size());
*pk_buf = raw_buf;

return pk_vec.size();
}

WASM_EXPORT size_t root_rollup__init_verification_key(uint8_t const* pk_buf, uint8_t const** vk_buf)
{
std::vector<uint8_t> vk_vec(42, 0);
// TODO remove when proving key is used
(void)pk_buf; // unused

auto* raw_buf = (uint8_t*)malloc(vk_vec.size());
memcpy(raw_buf, (void*)vk_vec.data(), vk_vec.size());
*vk_buf = raw_buf;

return vk_vec.size();
}

WASM_EXPORT uint8_t* root_rollup__sim(uint8_t const* root_rollup_inputs_buf,
size_t* root_rollup_public_inputs_size_out,
uint8_t const** root_rollup_public_inputs_buf)
{
RootRollupInputs root_rollup_inputs;
serialize::read(root_rollup_inputs_buf, root_rollup_inputs);

CBIND(root_rollup__sim, [](RootRollupInputs const& root_rollup_inputs) {
DummyCircuitBuilder builder = DummyCircuitBuilder("root_rollup__sim");
RootRollupPublicInputs const public_inputs = root_rollup_circuit(builder, root_rollup_inputs);

// serialize public inputs to bytes vec
std::vector<uint8_t> public_inputs_vec;
serialize::write(public_inputs_vec, public_inputs);
// copy public inputs to output buffer
auto* raw_public_inputs_buf = (uint8_t*)malloc(public_inputs_vec.size());
memcpy(raw_public_inputs_buf, (void*)public_inputs_vec.data(), public_inputs_vec.size());
*root_rollup_public_inputs_buf = raw_public_inputs_buf;
*root_rollup_public_inputs_size_out = public_inputs_vec.size();
return builder.alloc_and_serialize_first_failure();
}

WASM_EXPORT size_t root_rollup__verify_proof(uint8_t const* vk_buf, uint8_t const* proof, uint32_t length)
{
(void)vk_buf; // unused
(void)proof; // unused
(void)length; // unused
return 1U;
}

} // extern "C"
auto const& public_inputs = root_rollup_circuit(builder, root_rollup_inputs);
return builder.result_or_error(public_inputs);
});
10 changes: 1 addition & 9 deletions circuits/cpp/src/aztec3/circuits/rollup/root/c_bind.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,12 +5,4 @@
#include <cstddef>
#include <cstdint>

extern "C" {

WASM_EXPORT size_t root_rollup__init_proving_key(uint8_t const** pk_buf);
WASM_EXPORT size_t root_rollup__init_verification_key(uint8_t const* pk_buf, uint8_t const** vk_buf);
WASM_EXPORT uint8_t* root_rollup__sim(uint8_t const* root_rollup_inputs_buf,
size_t* root_rollup_public_inputs_size_out,
uint8_t const** root_rollup_public_inputs_buf);
WASM_EXPORT size_t root_rollup__verify_proof(uint8_t const* vk_buf, uint8_t const* proof, uint32_t length);
}
CBIND_DECL(root_rollup__sim);
Loading