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

Added marshalling for aggregated proofs. #19

Merged
merged 1 commit into from
Sep 17, 2024
Merged

Added marshalling for aggregated proofs. #19

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
425 changes: 424 additions & 1 deletion crypto3/libs/marshalling/zk/include/nil/crypto3/marshalling/zk/types/commitments/fri.hpp
View file
Open in desktop

Large diffs are not rendered by default.

196 changes: 188 additions & 8 deletions crypto3/libs/marshalling/zk/include/nil/crypto3/marshalling/zk/types/commitments/lpc.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -237,7 +237,7 @@ namespace nil {
// that the precommitment is a merkle tree.
template <typename TTypeBase, typename LPCScheme>
struct precommitment_type<TTypeBase, LPCScheme,
std::enable_if_t<nil::crypto3::zk::is_lpc<LPCScheme> &&
std::enable_if_t<nil::crypto3::zk::is_lpc<LPCScheme> &&
std::is_same<
typename LPCScheme::precommitment_type,
nil::crypto3::containers::merkle_tree<
Expand Down Expand Up @@ -306,7 +306,7 @@ namespace nil {
};

template<typename Endianness, typename LPCScheme>
typename commitment_scheme_state<nil::marshalling::field_type<Endianness>, LPCScheme,
typename commitment_scheme_state<nil::marshalling::field_type<Endianness>, LPCScheme,
std::enable_if_t<nil::crypto3::zk::is_lpc<LPCScheme>>>::type
fill_commitment_scheme(const LPCScheme &scheme) {
using TTypeBase = nil::marshalling::field_type<Endianness>;
Expand Down Expand Up @@ -353,14 +353,14 @@ namespace nil {
filled_batch_fixed_values.value().push_back(
nil::marshalling::types::integral<TTypeBase, std::size_t>(value));
}

return result_type(std::make_tuple(
filled_trees_keys,
filled_trees_values,
fill_commitment_params<Endianness, LPCScheme>(scheme.get_fri_params()),
field_element<TTypeBase, typename LPCScheme::value_type>(scheme.get_etha()),
filled_batch_fixed_keys,
filled_batch_fixed_values,
filled_batch_fixed_values,
fill_commitment_preprocessed_data<Endianness, LPCScheme>(scheme.get_fixed_polys_values()),
fill_polys_evaluator<Endianness, typename LPCScheme::polys_evaluator_type>(
static_cast<typename LPCScheme::polys_evaluator_type>(scheme))
Expand All @@ -370,7 +370,7 @@ namespace nil {
template<typename Endianness, typename LPCScheme>
LPCScheme make_commitment_scheme(
typename commitment_scheme_state<
nil::marshalling::field_type<Endianness>, LPCScheme,
nil::marshalling::field_type<Endianness>, LPCScheme,
std::enable_if_t<nil::crypto3::zk::is_lpc<LPCScheme>>>::type& filled_commitment_scheme
) {
using TTypeBase = typename nil::marshalling::field_type<Endianness>;
Expand All @@ -383,15 +383,15 @@ namespace nil {
BOOST_ASSERT(filled_tree_keys.size() == filled_tree_values.size());

for (std::size_t i = 0; i < filled_tree_keys.size(); i++) {
trees[std::size_t(filled_tree_keys[i].value())] =
trees[std::size_t(filled_tree_keys[i].value())] =
make_merkle_tree<typename LPCScheme::precommitment_type, Endianness>(
filled_tree_values[i]);
}

typename LPCScheme::fri_type::params_type fri_params = make_commitment_params<Endianness, LPCScheme>(
std::get<2>(filled_commitment_scheme.value()));
typename LPCScheme::value_type etha = std::get<3>(filled_commitment_scheme.value()).value();

std::map<std::size_t, bool> batch_fixed;
const auto& batch_fixed_keys = std::get<4>(filled_commitment_scheme.value()).value();
const auto& batch_fixed_values = std::get<5>(filled_commitment_scheme.value()).value();
Expand All @@ -402,7 +402,7 @@ namespace nil {
batch_fixed[std::size_t(batch_fixed_keys[i].value())] = bool(batch_fixed_values[i].value());
}

typename LPCScheme::preprocessed_data_type fixed_polys_values =
typename LPCScheme::preprocessed_data_type fixed_polys_values =
make_commitment_preprocessed_data<Endianness, LPCScheme>(
std::get<6>(filled_commitment_scheme.value()));

Expand All @@ -413,6 +413,186 @@ namespace nil {

return LPCScheme(evaluator, trees, fri_params, etha, batch_fixed, fixed_polys_values);
}

template <typename TTypeBase, typename LPCScheme>
using initial_fri_proof_type = nil::marshalling::types::bundle<
TTypeBase,
std::tuple<
// typename basic_fri::round_proofs_batch_type fri_round_proof;
nil::crypto3::marshalling::types::round_proofs_batch_type<
TTypeBase,
typename LPCScheme::basic_fri>,
// typename basic_fri::commitments_part_of_proof fri_commitments_proof_part;
nil::crypto3::marshalling::types::commitments_part_of_proof_type<
TTypeBase,
typename LPCScheme::basic_fri>
>
>;

template <typename Endianness, typename LPCScheme>
initial_fri_proof_type<nil::marshalling::field_type<Endianness>, LPCScheme>
fill_initial_fri_proof(const typename LPCScheme::fri_proof_type &proof) {
using TTypeBase = nil::marshalling::field_type<Endianness>;

nil::crypto3::marshalling::types::round_proofs_batch_type<
TTypeBase,
typename LPCScheme::basic_fri> filled_round_proofs_batch;
nil::crypto3::marshalling::types::commitments_part_of_proof_type<
TTypeBase,
typename LPCScheme::basic_fri> filled_commitments_part_of_proof;

filled_round_proofs_batch = fill_round_proofs_batch<Endianness, typename LPCScheme::basic_fri>(
proof.fri_round_proof);

filled_commitments_part_of_proof =
fill_commitments_part_of_proof<Endianness, typename LPCScheme::basic_fri>(
proof.fri_commitments_proof_part);

return initial_fri_proof_type<nil::marshalling::field_type<Endianness>, LPCScheme>(
std::make_tuple(filled_round_proofs_batch, filled_commitments_part_of_proof));
}

template <typename Endianness, typename LPCScheme>
typename LPCScheme::fri_proof_type
make_initial_fri_proof(
const initial_fri_proof_type<nil::marshalling::field_type<Endianness>, LPCScheme> &filled_proof
) {
typename LPCScheme::fri_proof_type proof;

proof.fri_round_proof = make_round_proofs_batch<
Endianness, typename LPCScheme::basic_fri>(
std::get<0>(filled_proof.value()));

proof.fri_commitments_proof_part = make_commitments_part_of_proof<
Endianness, typename LPCScheme::basic_fri>(
std::get<1>(filled_proof.value()));

return proof;
}

template<typename TTypeBase, typename LPCScheme>
using inital_eval_proof = nil::marshalling::types::bundle<
TTypeBase,
std::tuple<
// eval_storage_type z;
eval_storage<TTypeBase, typename LPCScheme::eval_storage_type>,
// typename basic_fri::initial_proofs_batch_type initial_fri_proofs;
initial_proofs_batch_type<TTypeBase, typename LPCScheme::basic_fri>
>
>;

template<typename Endianness, typename LPCScheme>
inital_eval_proof<nil::marshalling::field_type<Endianness>, LPCScheme>
fill_initial_eval_proof(
const typename LPCScheme::lpc_proof_type &intial_proof
){
using TTypeBase = nil::marshalling::field_type<Endianness>;

auto filled_z = fill_eval_storage<Endianness, typename LPCScheme::eval_storage_type>(
intial_proof.z);

initial_proofs_batch_type<
nil::marshalling::field_type<Endianness>, typename LPCScheme::basic_fri> filled_fri_proof =
fill_initial_proofs_batch<Endianness, typename LPCScheme::basic_fri>(
intial_proof.initial_fri_proofs
);

return inital_eval_proof<nil::marshalling::field_type<Endianness>, LPCScheme>(
std::tuple(filled_z, filled_fri_proof)
);
}

template<typename Endianness, typename LPCScheme>
typename LPCScheme::lpc_proof_type
make_initial_eval_proof(
const inital_eval_proof<nil::marshalling::field_type<Endianness>, LPCScheme> &filled_proof
) {
typename LPCScheme::lpc_proof_type proof;

proof.z = make_eval_storage<Endianness, typename LPCScheme::eval_storage_type>(
std::get<0>(filled_proof.value()));

proof.initial_fri_proofs = make_initial_proofs_batch<Endianness, typename LPCScheme::basic_fri>(
std::get<1>(filled_proof.value()));

return proof;
}

template<typename TTypeBase, typename LPCScheme>
using aggregated_proof = nil::marshalling::types::bundle<
TTypeBase,
std::tuple<
// fri_proof_type fri_proof;
initial_fri_proof_type<TTypeBase, LPCScheme>,
// std::vector<lpc_proof_type> intial_proofs_per_prover;
nil::marshalling::types::standard_array_list<
TTypeBase,
inital_eval_proof<TTypeBase, LPCScheme>
>,
// typename LPCParams::grinding_type::output_type proof_of_work;
nil::marshalling::types::integral<
TTypeBase, typename LPCScheme::params_type::grinding_type::output_type>
>
>;

template<typename Endianness, typename LPCScheme>
aggregated_proof<nil::marshalling::field_type<Endianness>, LPCScheme>
fill_aggregated_proof(
const typename LPCScheme::aggregated_proof_type &proof,
const typename LPCScheme::fri_type::params_type &fri_params
){
using TTypeBase = nil::marshalling::field_type<Endianness>;

initial_fri_proof_type<TTypeBase, LPCScheme> filled_fri_proof =
fill_initial_fri_proof<Endianness, LPCScheme>(
proof.fri_proof
);

nil::marshalling::types::standard_array_list<
TTypeBase,
inital_eval_proof<TTypeBase, LPCScheme>
> filled_initial_proofs;
for (const auto &initial_proof : proof.intial_proofs_per_prover) {
filled_initial_proofs.value().push_back(
fill_initial_eval_proof<Endianness, LPCScheme>(
initial_proof
)
);
}

return aggregated_proof<nil::marshalling::field_type<Endianness>, LPCScheme>(
std::make_tuple(
filled_fri_proof,
filled_initial_proofs,
nil::marshalling::types::integral<
TTypeBase, typename LPCScheme::params_type::grinding_type::output_type>(
proof.proof_of_work)
)
);
}

template<typename Endianness, typename LPCScheme>
typename LPCScheme::aggregated_proof_type
make_aggregated_proof(
const aggregated_proof<nil::marshalling::field_type<Endianness>, LPCScheme> &filled_proof
) {
typename LPCScheme::aggregated_proof_type proof;

proof.fri_proof = make_initial_fri_proof<Endianness, LPCScheme>(
std::get<0>(filled_proof.value()));

for (const auto &filled_initial_proof : std::get<1>(filled_proof.value()).value()) {
proof.intial_proofs_per_prover.push_back(
make_initial_eval_proof<Endianness, LPCScheme>(
filled_initial_proof
)
);
}

proof.proof_of_work = std::get<2>(filled_proof.value()).value();

return proof;
}
} // namespace types
} // namespace marshalling
} // namespace crypto3
Expand Down
66 changes: 66 additions & 0 deletions crypto3/libs/marshalling/zk/include/nil/crypto3/marshalling/zk/types/placeholder/proof.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -47,6 +47,72 @@ namespace nil {
namespace crypto3 {
namespace marshalling {
namespace types {
template<typename TTypeBase, typename Proof>
using placeholder_partial_evaluation_proof = nil::marshalling::types::bundle<
TTypeBase,
std::tuple<
// batch size integers
nil::marshalling::types::standard_array_list<
TTypeBase,
nil::marshalling::types::integral<TTypeBase, uint8_t>
>,
nil::marshalling::types::standard_array_list<
TTypeBase,
typename commitment<TTypeBase, typename Proof::commitment_scheme_type>::type
>
>
>;

template<typename Endianness, typename Proof>
placeholder_partial_evaluation_proof<nil::marshalling::field_type<Endianness>, Proof>
fill_placeholder_partial_evaluation_proof(
const typename Proof::partial_proof_type &partial_proof) {

using TTypeBase = nil::marshalling::field_type<Endianness>;

// batch size integers
nil::marshalling::types::standard_array_list<
TTypeBase,
nil::marshalling::types::integral<TTypeBase, uint8_t>
> filled_batch_size;
// batch commitments
nil::marshalling::types::standard_array_list<
TTypeBase,
typename commitment<TTypeBase, typename Proof::commitment_scheme_type>::type
> filled_commitments;
for (const auto &[batch_index, commitment] : partial_proof.commitments) {
filled_batch_size.value().push_back(
nil::marshalling::types::integral<TTypeBase, uint8_t>(batch_index));
filled_commitments.value().push_back(
fill_commitment<Endianness, typename Proof::commitment_scheme_type>(commitment));
}

return placeholder_partial_evaluation_proof<TTypeBase, Proof>(std::make_tuple(
filled_batch_size,
filled_commitments
));
}

template<typename Endianness, typename Proof>
typename Proof::partial_proof_type make_placeholder_partial_evaluation_proof(
const placeholder_partial_evaluation_proof<
nil::marshalling::field_type<Endianness>, Proof> &filled_proof
) {
typename Proof::partial_proof_type partial_proof;

// batch size integers
auto filled_batch_size = std::get<0>(filled_proof.value()).value();
auto filled_commitments = std::get<1>(filled_proof.value()).value();

for (std::size_t i = 0; i < filled_batch_size.size(); i++) {
partial_proof.commitments[filled_batch_size[i].value()] =
make_commitment<Endianness, typename Proof::commitment_scheme_type>(
filled_commitments[i]);
}

return partial_proof;
}

// This should be different for different commitment schemes!
template<typename TTypeBase, typename Proof>
using placeholder_evaluation_proof = nil::marshalling::types::bundle<
Expand Down
41 changes: 41 additions & 0 deletions crypto3/libs/marshalling/zk/test/lpc_commitment.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -96,6 +96,33 @@ void test_lpc_proof(typename LPC::proof_type &proof, typename LPC::fri_type::par
BOOST_CHECK(proof == constructed_val_read);
}

template<typename Endianness, typename LPC>
void test_lpc_aggregated_proof(
typename LPC::aggregated_proof_type &proof,
typename LPC::fri_type::params_type fri_params
) {
using TTypeBase = nil::marshalling::field_type<Endianness>;

auto filled_proof =
nil::crypto3::marshalling::types::fill_aggregated_proof<Endianness, LPC>(proof, fri_params);
auto _proof = nil::crypto3::marshalling::types::make_aggregated_proof<Endianness, LPC>(filled_proof);
BOOST_CHECK(proof == _proof);

std::vector<std::uint8_t> cv;
cv.resize(filled_proof.length(), 0x00);
auto write_iter = cv.begin();
auto status = filled_proof.write(write_iter, cv.size());
BOOST_CHECK(status == nil::marshalling::status_type::success);

typename nil::crypto3::marshalling::types::aggregated_proof<TTypeBase, LPC> test_val_read;
auto read_iter = cv.begin();
test_val_read.read(read_iter, cv.size());
BOOST_CHECK(status == nil::marshalling::status_type::success);
typename LPC::aggregated_proof_type constructed_val_read =
nil::crypto3::marshalling::types::make_aggregated_proof<Endianness, LPC>(test_val_read);
BOOST_CHECK(proof == constructed_val_read);
}

// This function will test saving and restoring LPC commitment scheme state to a file/buffer.
template<typename Endianness, typename LPC>
void test_lpc_state_recovery(const LPC& lpc_commitment_scheme) {
Expand Down Expand Up @@ -158,6 +185,20 @@ BOOST_FIXTURE_TEST_CASE(lpc_proof_test, zk::test_tools::random_test_initializer<
test_lpc_proof<Endianness, lpc_scheme_type>(proof, fri_params);
}

BOOST_FIXTURE_TEST_CASE(lpc_aggregated_proof_test, zk::test_tools::random_test_initializer<field_type>) {
typename FRI::params_type fri_params(1, r + 1, lambda, 4);

auto proof = generate_random_lpc_aggregated_proof<LPC>(
final_polynomial_degree, 5,
fri_params.step_list,
lambda,
false,
alg_random_engines.template get_alg_engine<field_type>(),
generic_random_engine
);
test_lpc_aggregated_proof<Endianness, lpc_scheme_type>(proof, fri_params);
}

BOOST_AUTO_TEST_SUITE_END()

BOOST_AUTO_TEST_SUITE(marshalling_real)
Expand Down
Loading
Loading