Git-Mirrors/monero
1
0
Fork 0
mirror of https://github.com/monero-project/monero.git synced 2025-01-23 05:31:06 -05:00
Code Issues Packages Projects Releases Wiki Activity

Rename everything from fcmp* to fcmp_pp

Browse Source
This commit is contained in:
j-berman 2024-08-08 14:10:34 -07:00
parent d72f405cee
commit d4847f649e
28 changed files with 114 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/CMakeLists.txt
View File

@ -89,7 +89,7 @@ add_subdirectory(ringct)
add_subdirectory(checkpoints) add_subdirectory(checkpoints)
add_subdirectory(cryptonote_basic) add_subdirectory(cryptonote_basic)
add_subdirectory(cryptonote_core) add_subdirectory(cryptonote_core)
add_subdirectory(fcmp) add_subdirectory(fcmp_pp)
add_subdirectory(lmdb) add_subdirectory(lmdb)
add_subdirectory(multisig) add_subdirectory(multisig)
add_subdirectory(net) add_subdirectory(net)

2
src/blockchain_db/blockchain_db.cpp
View File

@ -314,7 +314,7 @@ uint64_t BlockchainDB::add_block( const std::pair<block, blobdata>& blck
// When adding a block, we also need to add all the leaf tuples included in // When adding a block, we also need to add all the leaf tuples included in
// the block to a table keeping track of locked leaf tuples. Once those leaf // the block to a table keeping track of locked leaf tuples. Once those leaf
// tuples unlock, we use them to grow the tree. // tuples unlock, we use them to grow the tree.
std::multimap<uint64_t, fcmp::curve_trees::LeafTupleContext> leaf_tuples_by_unlock_block; std::multimap<uint64_t, fcmp_pp::curve_trees::LeafTupleContext> leaf_tuples_by_unlock_block;
// Get miner tx's leaf tuples // Get miner tx's leaf tuples
CHECK_AND_ASSERT_THROW_MES(m_curve_trees != nullptr, "curve trees must be set"); CHECK_AND_ASSERT_THROW_MES(m_curve_trees != nullptr, "curve trees must be set");

8
src/blockchain_db/blockchain_db.h
View File

@ -42,7 +42,7 @@
#include "cryptonote_basic/difficulty.h" #include "cryptonote_basic/difficulty.h"
#include "cryptonote_basic/hardfork.h" #include "cryptonote_basic/hardfork.h"
#include "cryptonote_protocol/enums.h" #include "cryptonote_protocol/enums.h"
#include "fcmp/curve_trees.h" #include "fcmp_pp/curve_trees.h"
/** \file /** \file
* Cryptonote Blockchain Database Interface * Cryptonote Blockchain Database Interface
@ -418,7 +418,7 @@ private:
, const uint64_t& coins_generated , const uint64_t& coins_generated
, uint64_t num_rct_outs , uint64_t num_rct_outs
, const crypto::hash& blk_hash , const crypto::hash& blk_hash
, const std::multimap<uint64_t, fcmp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block , const std::multimap<uint64_t, fcmp_pp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block
) = 0; ) = 0;
/** /**
@ -592,7 +592,7 @@ protected:
HardFork* m_hardfork; HardFork* m_hardfork;
std::shared_ptr<fcmp::curve_trees::CurveTreesV1> m_curve_trees; std::shared_ptr<fcmp_pp::curve_trees::CurveTreesV1> m_curve_trees;
public: public:
@ -1783,7 +1783,7 @@ public:
virtual bool for_all_alt_blocks(std::function<bool(const crypto::hash &blkid, const alt_block_data_t &data, const cryptonote::blobdata_ref *blob)> f, bool include_blob = false) const = 0; virtual bool for_all_alt_blocks(std::function<bool(const crypto::hash &blkid, const alt_block_data_t &data, const cryptonote::blobdata_ref *blob)> f, bool include_blob = false) const = 0;
// TODO: description and make private // TODO: description and make private
virtual void grow_tree(std::vector<fcmp::curve_trees::LeafTupleContext> &&new_leaves) = 0; virtual void grow_tree(std::vector<fcmp_pp::curve_trees::LeafTupleContext> &&new_leaves) = 0;
virtual void trim_tree(const uint64_t trim_n_leaf_tuples) = 0; virtual void trim_tree(const uint64_t trim_n_leaf_tuples) = 0;

64
src/blockchain_db/lmdb/db_lmdb.cpp
View File

@ -798,7 +798,7 @@ estim:
} }
void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t long_term_block_weight, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated, void BlockchainLMDB::add_block(const block& blk, size_t block_weight, uint64_t long_term_block_weight, const difficulty_type& cumulative_difficulty, const uint64_t& coins_generated,
uint64_t num_rct_outs, const crypto::hash& blk_hash, const std::multimap<uint64_t, fcmp::curve_trees::LeafTupleContext> &leaf_tuples_by_unlock_block) uint64_t num_rct_outs, const crypto::hash& blk_hash, const std::multimap<uint64_t, fcmp_pp::curve_trees::LeafTupleContext> &leaf_tuples_by_unlock_block)
{ {
LOG_PRINT_L3("BlockchainLMDB::" << __func__); LOG_PRINT_L3("BlockchainLMDB::" << __func__);
check_open(); check_open();
@ -1344,7 +1344,7 @@ void BlockchainLMDB::remove_spent_key(const crypto::key_image& k_image)
} }
} }
void BlockchainLMDB::grow_tree(std::vector<fcmp::curve_trees::LeafTupleContext> &&new_leaves) void BlockchainLMDB::grow_tree(std::vector<fcmp_pp::curve_trees::LeafTupleContext> &&new_leaves)
{ {
LOG_PRINT_L3("BlockchainLMDB::" << __func__); LOG_PRINT_L3("BlockchainLMDB::" << __func__);
if (new_leaves.empty()) if (new_leaves.empty())
@ -1403,7 +1403,7 @@ void BlockchainLMDB::grow_tree(std::vector<fcmp::curve_trees::LeafTupleContext>
throw0(DB_ERROR(("Growing odd c2 layer, expected even layer idx for c1: " throw0(DB_ERROR(("Growing odd c2 layer, expected even layer idx for c1: "
+ std::to_string(layer_idx)).c_str())); + std::to_string(layer_idx)).c_str()));
this->grow_layer<fcmp::curve_trees::Selene>(m_curve_trees->m_c2, this->grow_layer<fcmp_pp::curve_trees::Selene>(m_curve_trees->m_c2,
c2_extensions, c2_extensions,
c2_idx, c2_idx,
layer_idx); layer_idx);
@ -1416,7 +1416,7 @@ void BlockchainLMDB::grow_tree(std::vector<fcmp::curve_trees::LeafTupleContext>
throw0(DB_ERROR(("Growing even c1 layer, expected odd layer idx for c2: " throw0(DB_ERROR(("Growing even c1 layer, expected odd layer idx for c2: "
+ std::to_string(layer_idx)).c_str())); + std::to_string(layer_idx)).c_str()));
this->grow_layer<fcmp::curve_trees::Helios>(m_curve_trees->m_c1, this->grow_layer<fcmp_pp::curve_trees::Helios>(m_curve_trees->m_c1,
c1_extensions, c1_extensions,
c1_idx, c1_idx,
layer_idx); layer_idx);
@ -1430,7 +1430,7 @@ void BlockchainLMDB::grow_tree(std::vector<fcmp::curve_trees::LeafTupleContext>
template<typename C> template<typename C>
void BlockchainLMDB::grow_layer(const std::unique_ptr<C> &curve, void BlockchainLMDB::grow_layer(const std::unique_ptr<C> &curve,
const std::vector<fcmp::curve_trees::LayerExtension<C>> &layer_extensions, const std::vector<fcmp_pp::curve_trees::LayerExtension<C>> &layer_extensions,
const uint64_t ext_idx, const uint64_t ext_idx,
const uint64_t layer_idx) const uint64_t layer_idx)
{ {
@ -1596,7 +1596,7 @@ void BlockchainLMDB::trim_tree(const uint64_t trim_n_leaf_tuples)
template<typename C> template<typename C>
void BlockchainLMDB::trim_layer(const std::unique_ptr<C> &curve, void BlockchainLMDB::trim_layer(const std::unique_ptr<C> &curve,
const fcmp::curve_trees::LayerReduction<C> &layer_reduction, const fcmp_pp::curve_trees::LayerReduction<C> &layer_reduction,
const uint64_t layer_idx) const uint64_t layer_idx)
{ {
LOG_PRINT_L3("BlockchainLMDB::" << __func__); LOG_PRINT_L3("BlockchainLMDB::" << __func__);
@ -1718,7 +1718,7 @@ std::array<uint8_t, 32UL> BlockchainLMDB::get_tree_root() const
return root; return root;
} }
fcmp::curve_trees::CurveTreesV1::LastHashes BlockchainLMDB::get_tree_last_hashes() const fcmp_pp::curve_trees::CurveTreesV1::LastHashes BlockchainLMDB::get_tree_last_hashes() const
{ {
LOG_PRINT_L3("BlockchainLMDB::" << __func__); LOG_PRINT_L3("BlockchainLMDB::" << __func__);
check_open(); check_open();
@ -1726,7 +1726,7 @@ fcmp::curve_trees::CurveTreesV1::LastHashes BlockchainLMDB::get_tree_last_hashes
TXN_PREFIX_RDONLY(); TXN_PREFIX_RDONLY();
RCURSOR(layers) RCURSOR(layers)
fcmp::curve_trees::CurveTreesV1::LastHashes last_hashes; fcmp_pp::curve_trees::CurveTreesV1::LastHashes last_hashes;
auto &c1_last_hashes = last_hashes.c1_last_hashes; auto &c1_last_hashes = last_hashes.c1_last_hashes;
auto &c2_last_hashes = last_hashes.c2_last_hashes; auto &c2_last_hashes = last_hashes.c2_last_hashes;
@ -1772,8 +1772,8 @@ fcmp::curve_trees::CurveTreesV1::LastHashes BlockchainLMDB::get_tree_last_hashes
return last_hashes; return last_hashes;
} }
fcmp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim BlockchainLMDB::get_last_chunk_children_to_trim( fcmp_pp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim BlockchainLMDB::get_last_chunk_children_to_trim(
const std::vector<fcmp::curve_trees::TrimLayerInstructions> &trim_instructions) const const std::vector<fcmp_pp::curve_trees::TrimLayerInstructions> &trim_instructions) const
{ {
LOG_PRINT_L3("BlockchainLMDB::" << __func__); LOG_PRINT_L3("BlockchainLMDB::" << __func__);
check_open(); check_open();
@ -1783,7 +1783,7 @@ fcmp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim BlockchainLMDB::get_las
TXN_PREFIX_RDONLY(); TXN_PREFIX_RDONLY();
RCURSOR(layers) RCURSOR(layers)
fcmp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim last_chunk_children_to_trim; fcmp_pp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim last_chunk_children_to_trim;
auto &c1_last_children_out = last_chunk_children_to_trim.c1_children; auto &c1_last_children_out = last_chunk_children_to_trim.c1_children;
auto &c2_last_children_out = last_chunk_children_to_trim.c2_children; auto &c2_last_children_out = last_chunk_children_to_trim.c2_children;
@ -1793,17 +1793,17 @@ fcmp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim BlockchainLMDB::get_las
CHECK_AND_ASSERT_THROW_MES(!trim_instructions.empty(), "no instructions"); CHECK_AND_ASSERT_THROW_MES(!trim_instructions.empty(), "no instructions");
const auto &trim_leaf_layer_instructions = trim_instructions[0]; const auto &trim_leaf_layer_instructions = trim_instructions[0];
std::vector<fcmp::curve_trees::Selene::Scalar> leaves_to_trim; std::vector<fcmp_pp::curve_trees::Selene::Scalar> leaves_to_trim;
if (trim_leaf_layer_instructions.end_trim_idx > trim_leaf_layer_instructions.start_trim_idx) if (trim_leaf_layer_instructions.end_trim_idx > trim_leaf_layer_instructions.start_trim_idx)
{ {
leaves_to_trim.reserve(trim_leaf_layer_instructions.end_trim_idx - trim_leaf_layer_instructions.start_trim_idx); leaves_to_trim.reserve(trim_leaf_layer_instructions.end_trim_idx - trim_leaf_layer_instructions.start_trim_idx);
uint64_t idx = trim_leaf_layer_instructions.start_trim_idx; uint64_t idx = trim_leaf_layer_instructions.start_trim_idx;
CHECK_AND_ASSERT_THROW_MES(idx % fcmp::curve_trees::CurveTreesV1::LEAF_TUPLE_SIZE == 0, CHECK_AND_ASSERT_THROW_MES(idx % fcmp_pp::curve_trees::CurveTreesV1::LEAF_TUPLE_SIZE == 0,
"expected divisble by leaf tuple size"); "expected divisble by leaf tuple size");
const uint64_t leaf_tuple_idx = idx / fcmp::curve_trees::CurveTreesV1::LEAF_TUPLE_SIZE; const uint64_t leaf_tuple_idx = idx / fcmp_pp::curve_trees::CurveTreesV1::LEAF_TUPLE_SIZE;
MDB_val_copy<uint64_t> k(leaf_tuple_idx); MDB_val_copy<uint64_t> k(leaf_tuple_idx);
MDB_cursor_op leaf_op = MDB_SET; MDB_cursor_op leaf_op = MDB_SET;
@ -1817,7 +1817,7 @@ fcmp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim BlockchainLMDB::get_las
if (result != MDB_SUCCESS) if (result != MDB_SUCCESS)
throw0(DB_ERROR(lmdb_error("Failed to get leaf: ", result).c_str())); throw0(DB_ERROR(lmdb_error("Failed to get leaf: ", result).c_str()));
const auto preprocessed_leaf_tuple = *(fcmp::curve_trees::PreprocessedLeafTuple *)v.mv_data; const auto preprocessed_leaf_tuple = *(fcmp_pp::curve_trees::PreprocessedLeafTuple *)v.mv_data;
// TODO: parallelize calls to this function // TODO: parallelize calls to this function
auto leaf = m_curve_trees->leaf_tuple(preprocessed_leaf_tuple); auto leaf = m_curve_trees->leaf_tuple(preprocessed_leaf_tuple);
@ -1826,7 +1826,7 @@ fcmp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim BlockchainLMDB::get_las
leaves_to_trim.emplace_back(std::move(leaf.I_x)); leaves_to_trim.emplace_back(std::move(leaf.I_x));
leaves_to_trim.emplace_back(std::move(leaf.C_x)); leaves_to_trim.emplace_back(std::move(leaf.C_x));
idx += fcmp::curve_trees::CurveTreesV1::LEAF_TUPLE_SIZE; idx += fcmp_pp::curve_trees::CurveTreesV1::LEAF_TUPLE_SIZE;
} }
while (idx < trim_leaf_layer_instructions.end_trim_idx); while (idx < trim_leaf_layer_instructions.end_trim_idx);
} }
@ -1841,8 +1841,8 @@ fcmp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim BlockchainLMDB::get_las
{ {
const auto &trim_layer_instructions = trim_instructions[i]; const auto &trim_layer_instructions = trim_instructions[i];
std::vector<fcmp::curve_trees::Helios::Scalar> c1_children; std::vector<fcmp_pp::curve_trees::Helios::Scalar> c1_children;
std::vector<fcmp::curve_trees::Selene::Scalar> c2_children; std::vector<fcmp_pp::curve_trees::Selene::Scalar> c2_children;
if (trim_layer_instructions.end_trim_idx > trim_layer_instructions.start_trim_idx) if (trim_layer_instructions.end_trim_idx > trim_layer_instructions.start_trim_idx)
{ {
@ -1895,8 +1895,8 @@ fcmp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim BlockchainLMDB::get_las
return last_chunk_children_to_trim; return last_chunk_children_to_trim;
} }
fcmp::curve_trees::CurveTreesV1::LastHashes BlockchainLMDB::get_last_hashes_to_trim( fcmp_pp::curve_trees::CurveTreesV1::LastHashes BlockchainLMDB::get_last_hashes_to_trim(
const std::vector<fcmp::curve_trees::TrimLayerInstructions> &trim_instructions) const const std::vector<fcmp_pp::curve_trees::TrimLayerInstructions> &trim_instructions) const
{ {
LOG_PRINT_L3("BlockchainLMDB::" << __func__); LOG_PRINT_L3("BlockchainLMDB::" << __func__);
check_open(); check_open();
@ -1904,7 +1904,7 @@ fcmp::curve_trees::CurveTreesV1::LastHashes BlockchainLMDB::get_last_hashes_to_t
TXN_PREFIX_RDONLY(); TXN_PREFIX_RDONLY();
RCURSOR(layers) RCURSOR(layers)
fcmp::curve_trees::CurveTreesV1::LastHashes last_hashes_out; fcmp_pp::curve_trees::CurveTreesV1::LastHashes last_hashes_out;
// Traverse the tree layer-by-layer starting at the layer closest to leaf layer // Traverse the tree layer-by-layer starting at the layer closest to leaf layer
uint64_t layer_idx = 0; uint64_t layer_idx = 0;
@ -1975,7 +1975,7 @@ bool BlockchainLMDB::audit_tree(const uint64_t expected_n_leaf_tuples) const
while (1) while (1)
{ {
// Get next leaf chunk // Get next leaf chunk
std::vector<fcmp::curve_trees::CurveTreesV1::LeafTuple> leaf_tuples_chunk; std::vector<fcmp_pp::curve_trees::CurveTreesV1::LeafTuple> leaf_tuples_chunk;
leaf_tuples_chunk.reserve(m_curve_trees->m_c2_width); leaf_tuples_chunk.reserve(m_curve_trees->m_c2_width);
// Iterate until chunk is full or we get to the end of all leaves // Iterate until chunk is full or we get to the end of all leaves
@ -1989,7 +1989,7 @@ bool BlockchainLMDB::audit_tree(const uint64_t expected_n_leaf_tuples) const
if (result != MDB_SUCCESS) if (result != MDB_SUCCESS)
throw0(DB_ERROR(lmdb_error("Failed to add leaf: ", result).c_str())); throw0(DB_ERROR(lmdb_error("Failed to add leaf: ", result).c_str()));
const auto preprocessed_leaf_tuple = *(fcmp::curve_trees::PreprocessedLeafTuple *)v.mv_data; const auto preprocessed_leaf_tuple = *(fcmp_pp::curve_trees::PreprocessedLeafTuple *)v.mv_data;
auto leaf = m_curve_trees->leaf_tuple(preprocessed_leaf_tuple); auto leaf = m_curve_trees->leaf_tuple(preprocessed_leaf_tuple);
leaf_tuples_chunk.emplace_back(std::move(leaf)); leaf_tuples_chunk.emplace_back(std::move(leaf));
@ -2022,13 +2022,13 @@ bool BlockchainLMDB::audit_tree(const uint64_t expected_n_leaf_tuples) const
// Get the expected leaf chunk hash // Get the expected leaf chunk hash
const auto leaves = m_curve_trees->flatten_leaves(std::move(leaf_tuples_chunk)); const auto leaves = m_curve_trees->flatten_leaves(std::move(leaf_tuples_chunk));
const fcmp::curve_trees::Selene::Chunk chunk{leaves.data(), leaves.size()}; const fcmp_pp::curve_trees::Selene::Chunk chunk{leaves.data(), leaves.size()};
// Hash the chunk of leaves // Hash the chunk of leaves
for (uint64_t i = 0; i < leaves.size(); ++i) for (uint64_t i = 0; i < leaves.size(); ++i)
MDEBUG("Hashing " << m_curve_trees->m_c2->to_string(leaves[i])); MDEBUG("Hashing " << m_curve_trees->m_c2->to_string(leaves[i]));
const fcmp::curve_trees::Selene::Point chunk_hash = fcmp::curve_trees::get_new_parent(m_curve_trees->m_c2, chunk); const auto chunk_hash = fcmp_pp::curve_trees::get_new_parent(m_curve_trees->m_c2, chunk);
MDEBUG("chunk_hash " << m_curve_trees->m_c2->to_string(chunk_hash) << " , hash init point: " MDEBUG("chunk_hash " << m_curve_trees->m_c2->to_string(chunk_hash) << " , hash init point: "
<< m_curve_trees->m_c2->to_string(m_curve_trees->m_c2->hash_init_point()) << " (" << leaves.size() << " leaves)"); << m_curve_trees->m_c2->to_string(m_curve_trees->m_c2->hash_init_point()) << " (" << leaves.size() << " leaves)");
@ -2173,7 +2173,7 @@ bool BlockchainLMDB::audit_layer(const std::unique_ptr<C_CHILD> &c_child,
for (uint64_t i = 0; i < child_scalars.size(); ++i) for (uint64_t i = 0; i < child_scalars.size(); ++i)
MDEBUG("Hashing " << c_parent->to_string(child_scalars[i])); MDEBUG("Hashing " << c_parent->to_string(child_scalars[i]));
const auto chunk_hash = fcmp::curve_trees::get_new_parent(c_parent, chunk); const auto chunk_hash = fcmp_pp::curve_trees::get_new_parent(c_parent, chunk);
MDEBUG("chunk_hash " << c_parent->to_string(chunk_hash) << " , hash init point: " MDEBUG("chunk_hash " << c_parent->to_string(chunk_hash) << " , hash init point: "
<< c_parent->to_string(c_parent->hash_init_point()) << " (" << child_scalars.size() << " children)"); << c_parent->to_string(c_parent->hash_init_point()) << " (" << child_scalars.size() << " children)");
@ -2194,7 +2194,7 @@ bool BlockchainLMDB::audit_layer(const std::unique_ptr<C_CHILD> &c_child,
chunk_width); chunk_width);
} }
std::vector<fcmp::curve_trees::LeafTupleContext> BlockchainLMDB::get_leaf_tuples_at_unlock_block_id( std::vector<fcmp_pp::curve_trees::LeafTupleContext> BlockchainLMDB::get_leaf_tuples_at_unlock_block_id(
uint64_t block_id) uint64_t block_id)
{ {
LOG_PRINT_L3("BlockchainLMDB::" << __func__); LOG_PRINT_L3("BlockchainLMDB::" << __func__);
@ -2207,7 +2207,7 @@ std::vector<fcmp::curve_trees::LeafTupleContext> BlockchainLMDB::get_leaf_tuples
MDB_val v_tuple; MDB_val v_tuple;
// Get all the locked outputs at the provided block id // Get all the locked outputs at the provided block id
std::vector<fcmp::curve_trees::LeafTupleContext> leaf_tuples; std::vector<fcmp_pp::curve_trees::LeafTupleContext> leaf_tuples;
MDB_cursor_op op = MDB_SET; MDB_cursor_op op = MDB_SET;
while (1) while (1)
@ -2223,8 +2223,8 @@ std::vector<fcmp::curve_trees::LeafTupleContext> BlockchainLMDB::get_leaf_tuples
if (blk_id != block_id) if (blk_id != block_id)
throw0(DB_ERROR(("Blk id " + std::to_string(blk_id) + " not the expected" + std::to_string(block_id)).c_str())); throw0(DB_ERROR(("Blk id " + std::to_string(blk_id) + " not the expected" + std::to_string(block_id)).c_str()));
const auto range_begin = ((const fcmp::curve_trees::LeafTupleContext*)v_tuple.mv_data); const auto range_begin = ((const fcmp_pp::curve_trees::LeafTupleContext*)v_tuple.mv_data);
const auto range_end = range_begin + v_tuple.mv_size / sizeof(fcmp::curve_trees::LeafTupleContext); const auto range_end = range_begin + v_tuple.mv_size / sizeof(fcmp_pp::curve_trees::LeafTupleContext);
auto it = range_begin; auto it = range_begin;
@ -2279,7 +2279,7 @@ BlockchainLMDB::~BlockchainLMDB()
BlockchainLMDB::close(); BlockchainLMDB::close();
} }
BlockchainLMDB::BlockchainLMDB(bool batch_transactions, std::shared_ptr<fcmp::curve_trees::CurveTreesV1> curve_trees): BlockchainDB() BlockchainLMDB::BlockchainLMDB(bool batch_transactions, std::shared_ptr<fcmp_pp::curve_trees::CurveTreesV1> curve_trees): BlockchainDB()
{ {
LOG_PRINT_L3("BlockchainLMDB::" << __func__); LOG_PRINT_L3("BlockchainLMDB::" << __func__);
// initialize folder to something "safe" just in case // initialize folder to something "safe" just in case
@ -6836,7 +6836,7 @@ void BlockchainLMDB::migrate_5_6()
} }
// Convert the output into a leaf tuple context // Convert the output into a leaf tuple context
fcmp::curve_trees::LeafTupleContext tuple_context; fcmp_pp::curve_trees::LeafTupleContext tuple_context;
try try
{ {
tuple_context = m_curve_trees->output_to_leaf_context( tuple_context = m_curve_trees->output_to_leaf_context(

24
src/blockchain_db/lmdb/db_lmdb.h
View File

@ -30,7 +30,7 @@
#include "blockchain_db/blockchain_db.h" #include "blockchain_db/blockchain_db.h"
#include "cryptonote_basic/blobdatatype.h" // for type blobdata #include "cryptonote_basic/blobdatatype.h" // for type blobdata
#include "fcmp/curve_trees.h" #include "fcmp_pp/curve_trees.h"
#include "ringct/rctTypes.h" #include "ringct/rctTypes.h"
#include <boost/thread/tss.hpp> #include <boost/thread/tss.hpp>
@ -194,7 +194,7 @@ struct mdb_txn_safe
class BlockchainLMDB : public BlockchainDB class BlockchainLMDB : public BlockchainDB
{ {
public: public:
BlockchainLMDB(bool batch_transactions=true, std::shared_ptr<fcmp::curve_trees::CurveTreesV1> curve_trees = fcmp::curve_trees::curve_trees_v1()); BlockchainLMDB(bool batch_transactions=true, std::shared_ptr<fcmp_pp::curve_trees::CurveTreesV1> curve_trees = fcmp_pp::curve_trees::curve_trees_v1());
~BlockchainLMDB(); ~BlockchainLMDB();
virtual void open(const std::string& filename, const int mdb_flags=0); virtual void open(const std::string& filename, const int mdb_flags=0);
@ -368,7 +368,7 @@ public:
static int compare_string(const MDB_val *a, const MDB_val *b); static int compare_string(const MDB_val *a, const MDB_val *b);
// make private // make private
virtual void grow_tree(std::vector<fcmp::curve_trees::LeafTupleContext> &&new_leaves); virtual void grow_tree(std::vector<fcmp_pp::curve_trees::LeafTupleContext> &&new_leaves);
virtual void trim_tree(const uint64_t trim_n_leaf_tuples); virtual void trim_tree(const uint64_t trim_n_leaf_tuples);
@ -388,7 +388,7 @@ private:
, const uint64_t& coins_generated , const uint64_t& coins_generated
, uint64_t num_rct_outs , uint64_t num_rct_outs
, const crypto::hash& block_hash , const crypto::hash& block_hash
, const std::multimap<uint64_t, fcmp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block , const std::multimap<uint64_t, fcmp_pp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block
); );
virtual void remove_block(); virtual void remove_block();
@ -420,26 +420,26 @@ private:
template<typename C> template<typename C>
void grow_layer(const std::unique_ptr<C> &curve, void grow_layer(const std::unique_ptr<C> &curve,
const std::vector<fcmp::curve_trees::LayerExtension<C>> &layer_extensions, const std::vector<fcmp_pp::curve_trees::LayerExtension<C>> &layer_extensions,
const uint64_t c_idx, const uint64_t c_idx,
const uint64_t layer_idx); const uint64_t layer_idx);
template<typename C> template<typename C>
void trim_layer(const std::unique_ptr<C> &curve, void trim_layer(const std::unique_ptr<C> &curve,
const fcmp::curve_trees::LayerReduction<C> &layer_reduction, const fcmp_pp::curve_trees::LayerReduction<C> &layer_reduction,
const uint64_t layer_idx); const uint64_t layer_idx);
virtual uint64_t get_num_leaf_tuples() const; virtual uint64_t get_num_leaf_tuples() const;
virtual std::array<uint8_t, 32UL> get_tree_root() const; virtual std::array<uint8_t, 32UL> get_tree_root() const;
fcmp::curve_trees::CurveTreesV1::LastHashes get_tree_last_hashes() const; fcmp_pp::curve_trees::CurveTreesV1::LastHashes get_tree_last_hashes() const;
fcmp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim get_last_chunk_children_to_trim( fcmp_pp::curve_trees::CurveTreesV1::LastChunkChildrenToTrim get_last_chunk_children_to_trim(
const std::vector<fcmp::curve_trees::TrimLayerInstructions> &trim_instructions) const; const std::vector<fcmp_pp::curve_trees::TrimLayerInstructions> &trim_instructions) const;
fcmp::curve_trees::CurveTreesV1::LastHashes get_last_hashes_to_trim( fcmp_pp::curve_trees::CurveTreesV1::LastHashes get_last_hashes_to_trim(
const std::vector<fcmp::curve_trees::TrimLayerInstructions> &trim_instructions) const; const std::vector<fcmp_pp::curve_trees::TrimLayerInstructions> &trim_instructions) const;
template<typename C_CHILD, typename C_PARENT> template<typename C_CHILD, typename C_PARENT>
bool audit_layer(const std::unique_ptr<C_CHILD> &c_child, bool audit_layer(const std::unique_ptr<C_CHILD> &c_child,
@ -449,7 +449,7 @@ private:
const uint64_t child_chunk_idx, const uint64_t child_chunk_idx,
const uint64_t chunk_width) const; const uint64_t chunk_width) const;
std::vector<fcmp::curve_trees::LeafTupleContext> get_leaf_tuples_at_unlock_block_id(uint64_t block_id); std::vector<fcmp_pp::curve_trees::LeafTupleContext> get_leaf_tuples_at_unlock_block_id(uint64_t block_id);
void del_locked_leaf_tuples_at_block_id(uint64_t block_id); void del_locked_leaf_tuples_at_block_id(uint64_t block_id);

4
src/blockchain_db/testdb.h
View File

@ -116,7 +116,7 @@ public:
virtual void add_tx_amount_output_indices(const uint64_t tx_index, const std::vector<uint64_t>& amount_output_indices) override {} virtual void add_tx_amount_output_indices(const uint64_t tx_index, const std::vector<uint64_t>& amount_output_indices) override {}
virtual void add_spent_key(const crypto::key_image& k_image) override {} virtual void add_spent_key(const crypto::key_image& k_image) override {}
virtual void remove_spent_key(const crypto::key_image& k_image) override {} virtual void remove_spent_key(const crypto::key_image& k_image) override {}
virtual void grow_tree(std::vector<fcmp::curve_trees::LeafTupleContext> &&new_leaves) override {}; virtual void grow_tree(std::vector<fcmp_pp::curve_trees::LeafTupleContext> &&new_leaves) override {};
virtual void trim_tree(const uint64_t trim_n_leaf_tuples) override {}; virtual void trim_tree(const uint64_t trim_n_leaf_tuples) override {};
virtual bool audit_tree(const uint64_t expected_n_leaf_tuples) const override { return false; }; virtual bool audit_tree(const uint64_t expected_n_leaf_tuples) const override { return false; };
virtual std::array<uint8_t, 32UL> get_tree_root() const override { return {}; }; virtual std::array<uint8_t, 32UL> get_tree_root() const override { return {}; };
@ -149,7 +149,7 @@ public:
, const uint64_t& coins_generated , const uint64_t& coins_generated
, uint64_t num_rct_outs , uint64_t num_rct_outs
, const crypto::hash& blk_hash , const crypto::hash& blk_hash
, const std::multimap<uint64_t, fcmp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block , const std::multimap<uint64_t, fcmp_pp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block
) override { } ) override { }
virtual cryptonote::block get_block_from_height(const uint64_t& height) const override { return cryptonote::block(); } virtual cryptonote::block get_block_from_height(const uint64_t& height) const override { return cryptonote::block(); }
virtual void set_hard_fork_version(uint64_t height, uint8_t version) override {} virtual void set_hard_fork_version(uint64_t height, uint8_t version) override {}

1
src/blockchain_utilities/CMakeLists.txt
View File

@ -141,6 +141,7 @@ target_link_libraries(blockchain_import
PRIVATE PRIVATE
cryptonote_core cryptonote_core
blockchain_db blockchain_db
fcmp_pp
version version
epee epee
${Boost_FILESYSTEM_LIBRARY} ${Boost_FILESYSTEM_LIBRARY}

6
src/fcmp/CMakeLists.txt → src/fcmp_pp/CMakeLists.txt
View File

@ -32,11 +32,11 @@ set(fcmp_pp_sources
monero_find_all_headers(fcmp_pp_headers "${CMAKE_CURRENT_SOURCE_DIR}") monero_find_all_headers(fcmp_pp_headers "${CMAKE_CURRENT_SOURCE_DIR}")
add_subdirectory(fcmp_rust) add_subdirectory(fcmp_pp_rust)
monero_add_library_with_deps( monero_add_library_with_deps(
NAME fcmp_pp NAME fcmp_pp
DEPENDS fcmp_rust DEPENDS fcmp_pp_rust
SOURCES SOURCES
${fcmp_pp_sources} ${fcmp_pp_sources}
${fcmp_pp_headers}) ${fcmp_pp_headers})
@ -54,6 +54,6 @@ target_link_libraries(fcmp_pp
epee epee
ringct ringct
PRIVATE PRIVATE
${CMAKE_CURRENT_BINARY_DIR}/fcmp_rust/libfcmp_rust.a ${CMAKE_CURRENT_BINARY_DIR}/fcmp_pp_rust/libfcmp_pp_rust.a
${EXTRA_LIBRARIES} ${EXTRA_LIBRARIES}
${EXTRA_RUST_LIBRARIES}) ${EXTRA_RUST_LIBRARIES})

6
src/fcmp/curve_trees.cpp → src/fcmp_pp/curve_trees.cpp
View File

@ -31,7 +31,7 @@
#include "ringct/rctOps.h" #include "ringct/rctOps.h"
namespace fcmp namespace fcmp_pp
{ {
namespace curve_trees namespace curve_trees
{ {
@ -549,7 +549,7 @@ static TrimLayerInstructions get_trim_layer_instructions(
} }
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
template<typename C_CHILD, typename C_PARENT> template<typename C_CHILD, typename C_PARENT>
static typename fcmp::curve_trees::LayerReduction<C_PARENT> get_next_layer_reduction( static typename fcmp_pp::curve_trees::LayerReduction<C_PARENT> get_next_layer_reduction(
const std::unique_ptr<C_CHILD> &c_child, const std::unique_ptr<C_CHILD> &c_child,
const std::unique_ptr<C_PARENT> &c_parent, const std::unique_ptr<C_PARENT> &c_parent,
const TrimLayerInstructions &trim_layer_instructions, const TrimLayerInstructions &trim_layer_instructions,
@ -1028,4 +1028,4 @@ GrowLayerInstructions CurveTrees<C1, C2>::set_next_layer_extension(
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
} //namespace curve_trees } //namespace curve_trees
} //namespace fcmp } //namespace fcmp_pp

4
src/fcmp/curve_trees.h → src/fcmp_pp/curve_trees.h
View File

@ -38,7 +38,7 @@
#include <vector> #include <vector>
namespace fcmp namespace fcmp_pp
{ {
namespace curve_trees namespace curve_trees
{ {
@ -309,4 +309,4 @@ std::shared_ptr<CurveTreesV1> curve_trees_v1(
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
} //namespace curve_trees } //namespace curve_trees
} //namespace fcmp } //namespace fcmp_pp

0
src/fcmp/fcmp_rust/.gitignore → src/fcmp_pp/fcmp_pp_rust/.gitignore vendored
View File

8
src/fcmp/fcmp_rust/CMakeLists.txt → src/fcmp_pp/fcmp_pp_rust/CMakeLists.txt
View File

@ -93,9 +93,9 @@ else ()
set(TARGET_DIR "release") set(TARGET_DIR "release")
endif () endif ()
set(FCMP_PP_RUST_HEADER_DIR "${MONERO_GENERATED_HEADERS_DIR}/fcmp_rust") set(FCMP_PP_RUST_HEADER_DIR "${MONERO_GENERATED_HEADERS_DIR}/fcmp_pp_rust")
set(FCMP_PP_RUST_HEADER "${FCMP_PP_RUST_HEADER_DIR}/fcmp++.h") set(FCMP_PP_RUST_HEADER "${FCMP_PP_RUST_HEADER_DIR}/fcmp++.h")
set(FCMP_PP_RUST_LIB "${CMAKE_CURRENT_BINARY_DIR}/libfcmp_rust.a") set(FCMP_PP_RUST_LIB "${CMAKE_CURRENT_BINARY_DIR}/libfcmp_pp_rust.a")
# Removing OUTPUT files makes sure custom command runs every time # Removing OUTPUT files makes sure custom command runs every time
file(REMOVE_RECURSE "${FCMP_PP_RUST_HEADER_DIR}") file(REMOVE_RECURSE "${FCMP_PP_RUST_HEADER_DIR}")
@ -109,10 +109,10 @@ add_custom_command(
OUTPUT ${FCMP_PP_RUST_LIB} OUTPUT ${FCMP_PP_RUST_LIB}
COMMAND CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR} ${CARGO_CMD} COMMAND CARGO_TARGET_DIR=${CMAKE_CURRENT_BINARY_DIR} ${CARGO_CMD}
COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/fcmp++.h ${FCMP_PP_RUST_HEADER} COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/fcmp++.h ${FCMP_PP_RUST_HEADER}
COMMAND cp ${CMAKE_CURRENT_BINARY_DIR}/${RUST_TARGET}/${TARGET_DIR}/libfcmp_rust.a ${FCMP_PP_RUST_LIB} COMMAND cp ${CMAKE_CURRENT_BINARY_DIR}/${RUST_TARGET}/${TARGET_DIR}/libfcmp_pp_rust.a ${FCMP_PP_RUST_LIB}
COMMAND echo "Finished copying fcmp++ rust targets" COMMAND echo "Finished copying fcmp++ rust targets"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
VERBATIM VERBATIM
) )
add_custom_target(fcmp_rust DEPENDS ${FCMP_PP_RUST_LIB}) add_custom_target(fcmp_pp_rust DEPENDS ${FCMP_PP_RUST_LIB})

2
src/fcmp/fcmp_rust/Cargo.lock → src/fcmp_pp/fcmp_pp_rust/Cargo.lock generated
View File

@ -239,7 +239,7 @@ dependencies = [
] ]
[[package]] [[package]]
name = "fcmp_rust" name = "fcmp_pp_rust"
version = "0.0.0" version = "0.0.0"
dependencies = [ dependencies = [
"ciphersuite", "ciphersuite",

4
src/fcmp/fcmp_rust/Cargo.toml → src/fcmp_pp/fcmp_pp_rust/Cargo.toml
View File

@ -1,10 +1,10 @@
[package] [package]
name = "fcmp_rust" name = "fcmp_pp_rust"
version = "0.0.0" version = "0.0.0"
edition = "2021" edition = "2021"
[lib] [lib]
name = "fcmp_rust" name = "fcmp_pp_rust"
crate-type = ["staticlib"] crate-type = ["staticlib"]
[dependencies] [dependencies]

0
src/fcmp/fcmp_rust/fcmp++.h → src/fcmp_pp/fcmp_pp_rust/fcmp++.h
View File

0
src/fcmp/fcmp_rust/src/lib.rs → src/fcmp_pp/fcmp_pp_rust/src/lib.rs
View File

6
src/fcmp/proof.h → src/fcmp_pp/proof.h
View File

@ -30,16 +30,16 @@
#include <cstdint> #include <cstdint>
namespace fcmp namespace fcmp_pp
{ {
// Byte buffer containing the fcmp++ proof // Byte buffer containing the fcmp++ proof
using FcmpPpProof = std::vector<uint8_t>; using FcmpPpProof = std::vector<uint8_t>;
static inline std::size_t fcmp_pp_len(const std::size_t n_inputs) static inline std::size_t proof_len(const std::size_t n_inputs)
{ {
// TODO: implement // TODO: implement
return n_inputs * 4; return n_inputs * 4;
}; };
}//namespace fcmp }//namespace fcmp_pp

4
src/fcmp/tower_cycle.cpp → src/fcmp_pp/tower_cycle.cpp
View File

@ -29,7 +29,7 @@
#include "string_tools.h" #include "string_tools.h"
#include "tower_cycle.h" #include "tower_cycle.h"
namespace fcmp namespace fcmp_pp
{ {
namespace tower_cycle namespace tower_cycle
{ {
@ -280,4 +280,4 @@ template void extend_scalars_from_cycle_points<Selene, Helios>(const std::unique
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
} //namespace tower_cycle } //namespace tower_cycle
} //namespace fcmp } //namespace fcmp_pp

6
src/fcmp/tower_cycle.h → src/fcmp_pp/tower_cycle.h
View File

@ -29,12 +29,12 @@
#pragma once #pragma once
#include "crypto/crypto.h" #include "crypto/crypto.h"
#include "fcmp_rust/fcmp++.h" #include "fcmp_pp_rust/fcmp++.h"
#include "ringct/rctTypes.h" #include "ringct/rctTypes.h"
#include <string> #include <string>
namespace fcmp namespace fcmp_pp
{ {
namespace tower_cycle namespace tower_cycle
{ {
@ -188,4 +188,4 @@ void extend_scalars_from_cycle_points(const std::unique_ptr<C_POINTS> &curve,
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
}//namespace tower_cycle }//namespace tower_cycle
}//namespace fcmp }//namespace fcmp_pp

6
src/ringct/rctTypes.h
View File

@ -45,7 +45,7 @@ extern "C" {
} }
#include "crypto/generic-ops.h" #include "crypto/generic-ops.h"
#include "crypto/crypto.h" #include "crypto/crypto.h"
#include "fcmp/proof.h" #include "fcmp_pp/proof.h"
#include "hex.h" #include "hex.h"
#include "span.h" #include "span.h"
#include "memwipe.h" #include "memwipe.h"
@ -426,7 +426,7 @@ namespace rct {
std::vector<mgSig> MGs; // simple rct has N, full has 1 std::vector<mgSig> MGs; // simple rct has N, full has 1
std::vector<clsag> CLSAGs; std::vector<clsag> CLSAGs;
keyV pseudoOuts; //C - for simple rct keyV pseudoOuts; //C - for simple rct
fcmp::FcmpPpProof fcmp_pp; fcmp_pp::FcmpPpProof fcmp_pp;
// when changing this function, update cryptonote::get_pruned_transaction_weight // when changing this function, update cryptonote::get_pruned_transaction_weight
template<bool W, template <bool> class Archive> template<bool W, template <bool> class Archive>
@ -503,7 +503,7 @@ namespace rct {
{ {
ar.tag("fcmp_pp"); ar.tag("fcmp_pp");
ar.begin_object(); ar.begin_object();
const std::size_t proof_len = fcmp::fcmp_pp_len(inputs); const std::size_t proof_len = fcmp_pp::proof_len(inputs);
if (!typename Archive<W>::is_saving()) if (!typename Archive<W>::is_saving())
fcmp_pp.resize(proof_len); fcmp_pp.resize(proof_len);
if (fcmp_pp.size() != proof_len) if (fcmp_pp.size() != proof_len)

4
tests/block_weight/block_weight.cpp
View File

@ -32,7 +32,7 @@
#include <math.h> #include <math.h>
#include "cryptonote_core/cryptonote_core.h" #include "cryptonote_core/cryptonote_core.h"
#include "blockchain_db/testdb.h" #include "blockchain_db/testdb.h"
#include "fcmp/curve_trees.h" #include "fcmp_pp/curve_trees.h"
#define LONG_TERM_BLOCK_WEIGHT_WINDOW 5000 #define LONG_TERM_BLOCK_WEIGHT_WINDOW 5000
@ -65,7 +65,7 @@ public:
, const uint64_t& coins_generated , const uint64_t& coins_generated
, uint64_t num_rct_outs , uint64_t num_rct_outs
, const crypto::hash& blk_hash , const crypto::hash& blk_hash
, const std::multimap<uint64_t, fcmp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block , const std::multimap<uint64_t, fcmp_pp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block
) override { ) override {
blocks.push_back({block_weight, long_term_block_weight}); blocks.push_back({block_weight, long_term_block_weight});
} }

2
tests/core_tests/chaingen.cpp
View File

@ -88,7 +88,7 @@ namespace
, const uint64_t& coins_generated , const uint64_t& coins_generated
, uint64_t num_rct_outs , uint64_t num_rct_outs
, const crypto::hash& blk_hash , const crypto::hash& blk_hash
, const std::multimap<uint64_t, fcmp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block , const std::multimap<uint64_t, fcmp_pp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block
) override ) override
{ {
blocks.push_back({blk, blk_hash}); blocks.push_back({blk, blk_hash});

32
tests/unit_tests/curve_trees.cpp
View File

@ -62,7 +62,7 @@ static bool validate_layer(const std::unique_ptr<C> &curve,
for (std::size_t i = 0; i < chunk_size; ++i) for (std::size_t i = 0; i < chunk_size; ++i)
MDEBUG("Hashing " << curve->to_string(chunk_start[i])); MDEBUG("Hashing " << curve->to_string(chunk_start[i]));
const typename C::Point chunk_hash = fcmp::curve_trees::get_new_parent(curve, chunk); const typename C::Point chunk_hash = fcmp_pp::curve_trees::get_new_parent(curve, chunk);
MDEBUG("chunk_start_idx: " << chunk_start_idx << " , chunk_size: " << chunk_size << " , chunk_hash: " << curve->to_string(chunk_hash)); MDEBUG("chunk_start_idx: " << chunk_start_idx << " , chunk_size: " << chunk_size << " , chunk_hash: " << curve->to_string(chunk_hash));
@ -193,7 +193,7 @@ void CurveTreesGlobalTree::extend_tree(const CurveTreesV1::TreeExtension &tree_e
if (use_c2) if (use_c2)
{ {
CHECK_AND_ASSERT_THROW_MES(c2_idx < c2_extensions.size(), "unexpected c2 layer extension"); CHECK_AND_ASSERT_THROW_MES(c2_idx < c2_extensions.size(), "unexpected c2 layer extension");
const fcmp::curve_trees::LayerExtension<Selene> &c2_ext = c2_extensions[c2_idx]; const fcmp_pp::curve_trees::LayerExtension<Selene> &c2_ext = c2_extensions[c2_idx];
CHECK_AND_ASSERT_THROW_MES(!c2_ext.hashes.empty(), "empty c2 layer extension"); CHECK_AND_ASSERT_THROW_MES(!c2_ext.hashes.empty(), "empty c2 layer extension");
@ -226,7 +226,7 @@ void CurveTreesGlobalTree::extend_tree(const CurveTreesV1::TreeExtension &tree_e
else else
{ {
CHECK_AND_ASSERT_THROW_MES(c1_idx < c1_extensions.size(), "unexpected c1 layer extension"); CHECK_AND_ASSERT_THROW_MES(c1_idx < c1_extensions.size(), "unexpected c1 layer extension");
const fcmp::curve_trees::LayerExtension<Helios> &c1_ext = c1_extensions[c1_idx]; const fcmp_pp::curve_trees::LayerExtension<Helios> &c1_ext = c1_extensions[c1_idx];
CHECK_AND_ASSERT_THROW_MES(!c1_ext.hashes.empty(), "empty c1 layer extension"); CHECK_AND_ASSERT_THROW_MES(!c1_ext.hashes.empty(), "empty c1 layer extension");
@ -338,7 +338,7 @@ void CurveTreesGlobalTree::reduce_tree(const CurveTreesV1::TreeReduction &tree_r
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
// TODO: template // TODO: template
CurveTreesV1::LastChunkChildrenToTrim CurveTreesGlobalTree::get_all_last_chunk_children_to_trim( CurveTreesV1::LastChunkChildrenToTrim CurveTreesGlobalTree::get_all_last_chunk_children_to_trim(
const std::vector<fcmp::curve_trees::TrimLayerInstructions> &trim_instructions) const std::vector<fcmp_pp::curve_trees::TrimLayerInstructions> &trim_instructions)
{ {
CurveTreesV1::LastChunkChildrenToTrim all_children_to_trim; CurveTreesV1::LastChunkChildrenToTrim all_children_to_trim;
@ -424,7 +424,7 @@ CurveTreesV1::LastChunkChildrenToTrim CurveTreesGlobalTree::get_all_last_chunk_c
} }
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
CurveTreesV1::LastHashes CurveTreesGlobalTree::get_last_hashes_to_trim( CurveTreesV1::LastHashes CurveTreesGlobalTree::get_last_hashes_to_trim(
const std::vector<fcmp::curve_trees::TrimLayerInstructions> &trim_instructions) const const std::vector<fcmp_pp::curve_trees::TrimLayerInstructions> &trim_instructions) const
{ {
CurveTreesV1::LastHashes last_hashes; CurveTreesV1::LastHashes last_hashes;
CHECK_AND_ASSERT_THROW_MES(!trim_instructions.empty(), "no instructions"); CHECK_AND_ASSERT_THROW_MES(!trim_instructions.empty(), "no instructions");
@ -532,7 +532,7 @@ bool CurveTreesGlobalTree::audit_tree(const std::size_t expected_n_leaf_tuples)
CHECK_AND_ASSERT_MES(!children.empty(), false, "no children at c1_idx " + std::to_string(c1_idx)); CHECK_AND_ASSERT_MES(!children.empty(), false, "no children at c1_idx " + std::to_string(c1_idx));
std::vector<Selene::Scalar> child_scalars; std::vector<Selene::Scalar> child_scalars;
fcmp::tower_cycle::extend_scalars_from_cycle_points<Helios, Selene>(m_curve_trees.m_c1, fcmp_pp::tower_cycle::extend_scalars_from_cycle_points<Helios, Selene>(m_curve_trees.m_c1,
children, children,
child_scalars); child_scalars);
@ -559,7 +559,7 @@ bool CurveTreesGlobalTree::audit_tree(const std::size_t expected_n_leaf_tuples)
CHECK_AND_ASSERT_MES(!children.empty(), false, "no children at c2_idx " + std::to_string(c2_idx)); CHECK_AND_ASSERT_MES(!children.empty(), false, "no children at c2_idx " + std::to_string(c2_idx));
std::vector<Helios::Scalar> child_scalars; std::vector<Helios::Scalar> child_scalars;
fcmp::tower_cycle::extend_scalars_from_cycle_points<Selene, Helios>(m_curve_trees.m_c2, fcmp_pp::tower_cycle::extend_scalars_from_cycle_points<Selene, Helios>(m_curve_trees.m_c2,
children, children,
child_scalars); child_scalars);
@ -660,7 +660,7 @@ void CurveTreesGlobalTree::log_tree_extension(const CurveTreesV1::TreeExtension
{ {
CHECK_AND_ASSERT_THROW_MES(c2_idx < c2_extensions.size(), "unexpected c2 layer"); CHECK_AND_ASSERT_THROW_MES(c2_idx < c2_extensions.size(), "unexpected c2 layer");
const fcmp::curve_trees::LayerExtension<Selene> &c2_layer = c2_extensions[c2_idx]; const fcmp_pp::curve_trees::LayerExtension<Selene> &c2_layer = c2_extensions[c2_idx];
MDEBUG("Selene tree extension start idx: " << c2_layer.start_idx); MDEBUG("Selene tree extension start idx: " << c2_layer.start_idx);
for (std::size_t j = 0; j < c2_layer.hashes.size(); ++j) for (std::size_t j = 0; j < c2_layer.hashes.size(); ++j)
@ -673,7 +673,7 @@ void CurveTreesGlobalTree::log_tree_extension(const CurveTreesV1::TreeExtension
{ {
CHECK_AND_ASSERT_THROW_MES(c1_idx < c1_extensions.size(), "unexpected c1 layer"); CHECK_AND_ASSERT_THROW_MES(c1_idx < c1_extensions.size(), "unexpected c1 layer");
const fcmp::curve_trees::LayerExtension<Helios> &c1_layer = c1_extensions[c1_idx]; const fcmp_pp::curve_trees::LayerExtension<Helios> &c1_layer = c1_extensions[c1_idx];
MDEBUG("Helios tree extension start idx: " << c1_layer.start_idx); MDEBUG("Helios tree extension start idx: " << c1_layer.start_idx);
for (std::size_t j = 0; j < c1_layer.hashes.size(); ++j) for (std::size_t j = 0; j < c1_layer.hashes.size(); ++j)
@ -743,11 +743,11 @@ void CurveTreesGlobalTree::log_tree()
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
// Test helpers // Test helpers
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
static const std::vector<fcmp::curve_trees::LeafTupleContext> generate_random_leaves(const CurveTreesV1 &curve_trees, static const std::vector<fcmp_pp::curve_trees::LeafTupleContext> generate_random_leaves(const CurveTreesV1 &curve_trees,
const std::size_t old_n_leaf_tuples, const std::size_t old_n_leaf_tuples,
const std::size_t new_n_leaf_tuples) const std::size_t new_n_leaf_tuples)
{ {
std::vector<fcmp::curve_trees::LeafTupleContext> tuples; std::vector<fcmp_pp::curve_trees::LeafTupleContext> tuples;
tuples.reserve(new_n_leaf_tuples); tuples.reserve(new_n_leaf_tuples);
for (std::size_t i = 0; i < new_n_leaf_tuples; ++i) for (std::size_t i = 0; i < new_n_leaf_tuples; ++i)
@ -777,7 +777,7 @@ static const Selene::Scalar generate_random_selene_scalar()
rct::key S_x; rct::key S_x;
CHECK_AND_ASSERT_THROW_MES(rct::point_to_wei_x(rct::pk2rct(S), S_x), "failed to convert to wei x"); CHECK_AND_ASSERT_THROW_MES(rct::point_to_wei_x(rct::pk2rct(S), S_x), "failed to convert to wei x");
return fcmp::tower_cycle::selene_scalar_from_bytes(S_x); return fcmp_pp::tower_cycle::selene_scalar_from_bytes(S_x);
} }
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
static bool grow_tree(CurveTreesV1 &curve_trees, static bool grow_tree(CurveTreesV1 &curve_trees,
@ -941,7 +941,7 @@ TEST(curve_trees, grow_tree)
LOG_PRINT_L1("Test grow tree with helios chunk width " << helios_chunk_width LOG_PRINT_L1("Test grow tree with helios chunk width " << helios_chunk_width
<< ", selene chunk width " << selene_chunk_width); << ", selene chunk width " << selene_chunk_width);
const auto curve_trees = fcmp::curve_trees::curve_trees_v1(helios_chunk_width, selene_chunk_width); const auto curve_trees = fcmp_pp::curve_trees::curve_trees_v1(helios_chunk_width, selene_chunk_width);
// Constant for how deep we want the tree // Constant for how deep we want the tree
static const std::size_t TEST_N_LAYERS = 4; static const std::size_t TEST_N_LAYERS = 4;
@ -984,7 +984,7 @@ TEST(curve_trees, trim_tree)
LOG_PRINT_L1("Test trim tree with helios chunk width " << helios_chunk_width LOG_PRINT_L1("Test trim tree with helios chunk width " << helios_chunk_width
<< ", selene chunk width " << selene_chunk_width); << ", selene chunk width " << selene_chunk_width);
const auto curve_trees = fcmp::curve_trees::curve_trees_v1(helios_chunk_width, selene_chunk_width); const auto curve_trees = fcmp_pp::curve_trees::curve_trees_v1(helios_chunk_width, selene_chunk_width);
// Constant for how deep we want the tree // Constant for how deep we want the tree
static const std::size_t TEST_N_LAYERS = 4; static const std::size_t TEST_N_LAYERS = 4;
@ -1028,7 +1028,7 @@ TEST(curve_trees, trim_tree)
// Make sure the result of hash_trim is the same as the equivalent hash_grow excluding the trimmed children // Make sure the result of hash_trim is the same as the equivalent hash_grow excluding the trimmed children
TEST(curve_trees, hash_trim) TEST(curve_trees, hash_trim)
{ {
const auto curve_trees = fcmp::curve_trees::curve_trees_v1(); const auto curve_trees = fcmp_pp::curve_trees::curve_trees_v1();
// 1. Trim 1 // 1. Trim 1
{ {
@ -1183,7 +1183,7 @@ TEST(curve_trees, hash_trim)
//---------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------
TEST(curve_trees, hash_grow) TEST(curve_trees, hash_grow)
{ {
const auto curve_trees = fcmp::curve_trees::curve_trees_v1(); const auto curve_trees = fcmp_pp::curve_trees::curve_trees_v1();
// Start by hashing: {selene_scalar_0, selene_scalar_1} // Start by hashing: {selene_scalar_0, selene_scalar_1}
// Then grow 1: {selene_scalar_0, selene_scalar_1, selene_scalar_2} // Then grow 1: {selene_scalar_0, selene_scalar_1, selene_scalar_2}

14
tests/unit_tests/curve_trees.h
View File

@ -28,12 +28,12 @@
#pragma once #pragma once
#include "fcmp/curve_trees.h" #include "fcmp_pp/curve_trees.h"
#include "fcmp/tower_cycle.h" #include "fcmp_pp/tower_cycle.h"
using Helios = fcmp::curve_trees::Helios; using Helios = fcmp_pp::curve_trees::Helios;
using Selene = fcmp::curve_trees::Selene; using Selene = fcmp_pp::curve_trees::Selene;
using CurveTreesV1 = fcmp::curve_trees::CurveTreesV1; using CurveTreesV1 = fcmp_pp::curve_trees::CurveTreesV1;
// Helper class to read/write a global tree in memory. It's only used in testing because normally the tree isn't kept // Helper class to read/write a global tree in memory. It's only used in testing because normally the tree isn't kept
// in memory (it's stored in the db) // in memory (it's stored in the db)
@ -85,10 +85,10 @@ public:
// - This function is useful to collect all tree data necessary to perform the actual trim operation // - This function is useful to collect all tree data necessary to perform the actual trim operation
// - This function can return elems from each last chunk that will need to be trimmed // - This function can return elems from each last chunk that will need to be trimmed
CurveTreesV1::LastHashes get_last_hashes_to_trim( CurveTreesV1::LastHashes get_last_hashes_to_trim(
const std::vector<fcmp::curve_trees::TrimLayerInstructions> &trim_instructions) const; const std::vector<fcmp_pp::curve_trees::TrimLayerInstructions> &trim_instructions) const;
CurveTreesV1::LastChunkChildrenToTrim get_all_last_chunk_children_to_trim( CurveTreesV1::LastChunkChildrenToTrim get_all_last_chunk_children_to_trim(
const std::vector<fcmp::curve_trees::TrimLayerInstructions> &trim_instructions); const std::vector<fcmp_pp::curve_trees::TrimLayerInstructions> &trim_instructions);
private: private:
CurveTreesV1 &m_curve_trees; CurveTreesV1 &m_curve_trees;

4
tests/unit_tests/hardfork.cpp
View File

@ -35,7 +35,7 @@
#include "cryptonote_basic/cryptonote_format_utils.h" #include "cryptonote_basic/cryptonote_format_utils.h"
#include "cryptonote_basic/hardfork.h" #include "cryptonote_basic/hardfork.h"
#include "blockchain_db/testdb.h" #include "blockchain_db/testdb.h"
#include "fcmp/curve_trees.h" #include "fcmp_pp/curve_trees.h"
using namespace cryptonote; using namespace cryptonote;
@ -55,7 +55,7 @@ public:
, const uint64_t& coins_generated , const uint64_t& coins_generated
, uint64_t num_rct_outs , uint64_t num_rct_outs
, const crypto::hash& blk_hash , const crypto::hash& blk_hash
, const std::multimap<uint64_t, fcmp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block , const std::multimap<uint64_t, fcmp_pp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block
) override { ) override {
blocks.push_back(blk); blocks.push_back(blk);
} }

2
tests/unit_tests/long_term_block_weight.cpp
View File

@ -58,7 +58,7 @@ public:
, const uint64_t& coins_generated , const uint64_t& coins_generated
, uint64_t num_rct_outs , uint64_t num_rct_outs
, const crypto::hash& blk_hash , const crypto::hash& blk_hash
, const std::multimap<uint64_t, fcmp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block , const std::multimap<uint64_t, fcmp_pp::curve_trees::LeafTupleContext>& leaf_tuples_by_unlock_block
) override { ) override {
blocks.push_back({block_weight, long_term_block_weight}); blocks.push_back({block_weight, long_term_block_weight});
} }

8
tests/unit_tests/serialization.cpp
View File

@ -1370,8 +1370,8 @@ TEST(Serialization, tx_fcmp_pp)
tx.rct_signatures.referenceBlock = referenceBlock; tx.rct_signatures.referenceBlock = referenceBlock;
// 1 fcmp++ proof // 1 fcmp++ proof
fcmp::FcmpPpProof fcmp_pp; fcmp_pp::FcmpPpProof fcmp_pp;
const std::size_t proof_len = fcmp::fcmp_pp_len(n_inputs); const std::size_t proof_len = fcmp_pp::proof_len(n_inputs);
fcmp_pp.reserve(proof_len); fcmp_pp.reserve(proof_len);
for (std::size_t i = 0; i < proof_len; ++i) for (std::size_t i = 0; i < proof_len; ++i)
fcmp_pp.push_back(i); fcmp_pp.push_back(i);
@ -1400,7 +1400,7 @@ TEST(Serialization, tx_fcmp_pp)
string blob; string blob;
// Extend fcmp++ proof // Extend fcmp++ proof
ASSERT_TRUE(tx.rct_signatures.p.fcmp_pp.size() == fcmp::fcmp_pp_len(n_inputs)); ASSERT_TRUE(tx.rct_signatures.p.fcmp_pp.size() == fcmp_pp::proof_len(n_inputs));
tx.rct_signatures.p.fcmp_pp.push_back(0x01); tx.rct_signatures.p.fcmp_pp.push_back(0x01);
ASSERT_FALSE(serialization::dump_binary(tx, blob)); ASSERT_FALSE(serialization::dump_binary(tx, blob));
@ -1411,7 +1411,7 @@ TEST(Serialization, tx_fcmp_pp)
transaction tx = make_dummy_fcmp_pp_tx(); transaction tx = make_dummy_fcmp_pp_tx();
// Shorten the fcmp++ proof // Shorten the fcmp++ proof
ASSERT_TRUE(tx.rct_signatures.p.fcmp_pp.size() == fcmp::fcmp_pp_len(n_inputs)); ASSERT_TRUE(tx.rct_signatures.p.fcmp_pp.size() == fcmp_pp::proof_len(n_inputs));
ASSERT_TRUE(tx.rct_signatures.p.fcmp_pp.size() > 1); ASSERT_TRUE(tx.rct_signatures.p.fcmp_pp.size() > 1);
tx.rct_signatures.p.fcmp_pp.pop_back(); tx.rct_signatures.p.fcmp_pp.pop_back();

4
tests/unit_tests/unit_tests_utils.h
View File

@ -34,7 +34,7 @@
#include "blockchain_db/blockchain_db.h" #include "blockchain_db/blockchain_db.h"
#include "blockchain_db/lmdb/db_lmdb.h" #include "blockchain_db/lmdb/db_lmdb.h"
#include "fcmp/curve_trees.h" #include "fcmp_pp/curve_trees.h"
#include "misc_log_ex.h" #include "misc_log_ex.h"
#include <atomic> #include <atomic>
@ -84,7 +84,7 @@ namespace unit_test
remove_files(); remove_files();
} }
void init_new_db(std::shared_ptr<fcmp::curve_trees::CurveTreesV1> curve_trees) void init_new_db(std::shared_ptr<fcmp_pp::curve_trees::CurveTreesV1> curve_trees)
{ {
CHECK_AND_ASSERT_THROW_MES(this->m_db == nullptr, "expected nullptr m_db"); CHECK_AND_ASSERT_THROW_MES(this->m_db == nullptr, "expected nullptr m_db");
this->m_db = new cryptonote::BlockchainLMDB(true/*batch_transactions*/, curve_trees); this->m_db = new cryptonote::BlockchainLMDB(true/*batch_transactions*/, curve_trees);