Minecon724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 2

Remove secure library dependency on lib library (#1867)

Browse source
This commit is contained in:
Wesley Shillingford 2019-03-27 13:43:43 +00:00 • committed by GitHub
commit c45bfae43d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
28 changed files with 338 additions and 313 deletions
Download patch file Download diff file Expand all files Collapse all files

20
nano/core_test/core_test_main.cc
View file

@ -1,10 +1,12 @@
extern void force_nano_test_network ();
#include "gtest/gtest.h"
GTEST_API_ int main(int argc, char **argv) {
printf("Running main() from core_test_main.cc\n");
force_nano_test_network ();
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
namespace nano
{
void force_nano_test_network ();
}
GTEST_API_ int main (int argc, char ** argv)
{
printf ("Running main() from core_test_main.cc\n");
nano::force_nano_test_network ();
testing::InitGoogleTest (&argc, argv);
return RUN_ALL_TESTS ();
}

4
nano/core_test/rpc.cpp
View file

@ -2672,7 +2672,7 @@ TEST (rpc, wallet_frontiers)
TEST (rpc, work_validate)
{
nano::network_params params;
nano::network_constants constants;
nano::system system (24000, 1);
nano::node_init init1;
auto & node1 (*system.nodes[0]);
@ -2709,7 +2709,7 @@ TEST (rpc, work_validate)
ASSERT_EQ ("0", validate_text2);
uint64_t result_difficulty;
ASSERT_FALSE (nano::work_validate (hash, work1, &result_difficulty));
ASSERT_GE (result_difficulty, params.publish_threshold);
ASSERT_GE (result_difficulty, constants.publish_threshold);
request.put ("work", nano::to_string_hex (work1));
request.put ("difficulty", nano::to_string_hex (result_difficulty));
test_response response3 (request, rpc, system.io_ctx);

10
nano/core_test/work_pool.cpp
View file

@ -7,26 +7,26 @@
TEST (work, one)
{
nano::network_params params;
nano::network_constants network_constants;
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::change_block block (1, 1, nano::keypair ().prv, 3, 4);
block.block_work_set (pool.generate (block.root ()));
uint64_t difficulty;
ASSERT_FALSE (nano::work_validate (block, &difficulty));
ASSERT_LT (params.publish_threshold, difficulty);
ASSERT_LT (network_constants.publish_threshold, difficulty);
}
TEST (work, validate)
{
nano::network_params params;
nano::network_constants network_constants;
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::send_block send_block (1, 1, 2, nano::keypair ().prv, 4, 6);
uint64_t difficulty;
ASSERT_TRUE (nano::work_validate (send_block, &difficulty));
ASSERT_LT (difficulty, params.publish_threshold);
ASSERT_LT (difficulty, network_constants.publish_threshold);
send_block.block_work_set (pool.generate (send_block.root ()));
ASSERT_FALSE (nano::work_validate (send_block, &difficulty));
ASSERT_LT (params.publish_threshold, difficulty);
ASSERT_LT (network_constants.publish_threshold, difficulty);
}
TEST (work, cancel)

1
nano/lib/blockbuilders.cpp
View file

@ -1,6 +1,5 @@
#include <crypto/cryptopp/osrng.h>
#include <nano/lib/blockbuilders.hpp>
#include <nano/secure/common.hpp>
#include <unordered_map>
namespace

142
nano/lib/config.cpp
View file

@ -1,147 +1,9 @@
#include <iostream>
#include <limits>
#include <nano/core_test/testutil.hpp>
#include <nano/lib/config.hpp>
nano::nano_networks nano::network_params::active_network = nano::nano_networks::ACTIVE_NETWORK;
namespace
namespace nano
{
char const * test_private_key_data = "34F0A37AAD20F4A260F0A5B3CB3D7FB50673212263E58A380BC10474BB039CE4";
char const * test_public_key_data = "B0311EA55708D6A53C75CDBF88300259C6D018522FE3D4D0A242E431F9E8B6D0"; // xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo
char const * beta_public_key_data = "A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F"; // xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp
char const * live_public_key_data = "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"; // xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3
char const * test_genesis_data = R"%%%({
"type": "open",
"source": "B0311EA55708D6A53C75CDBF88300259C6D018522FE3D4D0A242E431F9E8B6D0",
"representative": "xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo",
"account": "xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo",
"work": "9680625b39d3363d",
"signature": "ECDA914373A2F0CA1296475BAEE40500A7F0A7AD72A5A80C81D7FAB7F6C802B2CC7DB50F5DD0FB25B2EF11761FA7344A158DD5A700B21BD47DE5BD0F63153A02"
})%%%";
char const * beta_genesis_data = R"%%%({
"type": "open",
"source": "A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F",
"representative": "xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp",
"account": "xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp",
"work": "000000000f0aaeeb",
"signature": "A726490E3325E4FA59C1C900D5B6EEBB15FE13D99F49D475B93F0AACC5635929A0614CF3892764A04D1C6732A0D716FFEB254D4154C6F544D11E6630F201450B"
})%%%";
char const * live_genesis_data = R"%%%({
"type": "open",
"source": "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA",
"representative": "xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3",
"account": "xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3",
"work": "62f05417dd3fb691",
"signature": "9F0C933C8ADE004D808EA1985FA746A7E95BA2A38F867640F53EC8F180BDFE9E2C1268DEAD7C2664F356E37ABA362BC58E46DBA03E523A7B5A19E4B6EB12BB02"
})%%%";
}
nano::network_params::network_params () :
network_params (nano::network_params::active_network)
{
}
nano::network_params::network_params (nano::nano_networks network_a) :
current_network (network_a), ledger (*this), voting (*this), node (*this), portmapping (*this), bootstrap (*this)
{
// Local work threshold for rate-limiting publishing blocks. ~5 seconds of work.
uint64_t constexpr publish_test_threshold = 0xff00000000000000;
uint64_t constexpr publish_full_threshold = 0xffffffc000000000;
publish_threshold = is_test_network () ? publish_test_threshold : publish_full_threshold;
unsigned constexpr kdf_full_work = 64 * 1024;
unsigned constexpr kdf_test_work = 8;
kdf_work = is_test_network () ? kdf_test_work : kdf_full_work;
default_node_port = is_live_network () ? 7075 : 54000;
default_rpc_port = is_live_network () ? 7076 : 55000;
request_interval_ms = is_test_network () ? 10 : 16000;
header_magic_number = is_test_network () ? std::array<uint8_t, 2>{ { 'R', 'A' } } : is_beta_network () ? std::array<uint8_t, 2>{ { 'R', 'B' } } : std::array<uint8_t, 2>{ { 'R', 'C' } };
}
nano::ledger_constants::ledger_constants (nano::network_params & params_a) :
ledger_constants (params_a.network ())
{
}
nano::ledger_constants::ledger_constants (nano::nano_networks network_a) :
zero_key ("0"),
test_genesis_key (test_private_key_data),
nano_test_account (test_public_key_data),
nano_beta_account (beta_public_key_data),
nano_live_account (live_public_key_data),
nano_test_genesis (test_genesis_data),
nano_beta_genesis (beta_genesis_data),
nano_live_genesis (live_genesis_data),
genesis_account (network_a == nano::nano_networks::nano_test_network ? nano_test_account : network_a == nano::nano_networks::nano_beta_network ? nano_beta_account : nano_live_account),
genesis_block (network_a == nano::nano_networks::nano_test_network ? nano_test_genesis : network_a == nano::nano_networks::nano_beta_network ? nano_beta_genesis : nano_live_genesis),
genesis_amount (std::numeric_limits<nano::uint128_t>::max ()),
burn_account (0),
not_an_account_m (0)
{
}
nano::account const & nano::ledger_constants::not_an_account ()
{
if (not_an_account_m.is_zero ())
{
// Randomly generating these mean no two nodes will ever have the same sentinel values which protects against some insecure algorithms
nano::random_pool::generate_block (not_an_account_m.bytes.data (), not_an_account_m.bytes.size ());
}
return not_an_account_m;
}
nano::node_constants::node_constants (nano::network_params & params_a)
{
period = params_a.is_test_network () ? std::chrono::seconds (1) : std::chrono::seconds (60);
cutoff = period * 5;
syn_cookie_cutoff = std::chrono::seconds (5);
backup_interval = std::chrono::minutes (5);
search_pending_interval = params_a.is_test_network () ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60);
peer_interval = search_pending_interval;
unchecked_cleaning_interval = std::chrono::hours (2);
process_confirmed_interval = params_a.is_test_network () ? std::chrono::milliseconds (50) : std::chrono::milliseconds (500);
max_weight_samples = params_a.is_live_network () ? 4032 : 864;
weight_period = 5 * 60; // 5 minutes
}
nano::voting_constants::voting_constants (nano::network_params & params_a)
{
max_cache = params_a.is_test_network () ? 2 : 1000;
generator_delay = params_a.is_test_network () ? std::chrono::milliseconds (10) : std::chrono::milliseconds (500);
}
nano::portmapping_constants::portmapping_constants (nano::network_params & params_a)
{
mapping_timeout = params_a.is_test_network () ? 53 : 3593;
check_timeout = params_a.is_test_network () ? 17 : 53;
}
nano::bootstrap_constants::bootstrap_constants (nano::network_params & params_a)
{
lazy_max_pull_blocks = params_a.is_test_network () ? 2 : 512;
}
/** Called by gtest_main to enforce test network */
void force_nano_test_network ()
{
nano::network_params::set_active_network (nano::nano_networks::nano_test_network);
nano::network_constants::set_active_network (nano::nano_networks::nano_test_network);
}
/* Convenience constants for core_test which is always on the test network */
namespace
{
nano::ledger_constants test_constants (nano::nano_networks::nano_test_network);
}
nano::keypair const & nano::zero_key (test_constants.zero_key);
nano::keypair const & nano::test_genesis_key (test_constants.test_genesis_key);
nano::account const & nano::nano_test_account (test_constants.nano_test_account);
std::string const & nano::nano_test_genesis (test_constants.nano_test_genesis);
nano::account const & nano::genesis_account (test_constants.genesis_account);
std::string const & nano::genesis_block (test_constants.genesis_block);
nano::uint128_t const & nano::genesis_amount (test_constants.genesis_amount);
nano::account const & nano::burn_account (test_constants.burn_account);

125
nano/lib/config.hpp
View file

@ -5,14 +5,10 @@
#include <chrono>
#include <nano/lib/errors.hpp>
#include <nano/lib/numbers.hpp>
#include <nano/secure/common.hpp>
#include <string>
namespace nano
{
class ledger_constants;
class network_params;
/**
* Network variants with different genesis blocks and network parameters
* @warning Enum values are used in integral comparisons; do not change.
@ -30,103 +26,38 @@ enum class nano_networks
rai_live_network = 2,
};
/** Genesis keys and ledger constants for network variants */
class ledger_constants
class network_constants
{
public:
ledger_constants (nano::network_params & params_a);
ledger_constants (nano::nano_networks network_a);
nano::keypair zero_key;
nano::keypair test_genesis_key;
nano::account nano_test_account;
nano::account nano_beta_account;
nano::account nano_live_account;
std::string nano_test_genesis;
std::string nano_beta_genesis;
std::string nano_live_genesis;
nano::account genesis_account;
std::string genesis_block;
nano::uint128_t genesis_amount;
nano::account const & not_an_account ();
nano::account burn_account;
network_constants () :
network_constants (network_constants::active_network)
{
}
private:
nano::account not_an_account_m;
};
network_constants (nano_networks network_a) :
current_network (network_a)
{
// Local work threshold for rate-limiting publishing blocks. ~5 seconds of work.
uint64_t constexpr publish_test_threshold = 0xff00000000000000;
uint64_t constexpr publish_full_threshold = 0xffffffc000000000;
publish_threshold = is_test_network () ? publish_test_threshold : publish_full_threshold;
/** Node related constants whose value depends on the active network */
class node_constants
{
public:
node_constants (nano::network_params & params_a);
std::chrono::seconds period;
std::chrono::seconds cutoff;
std::chrono::seconds syn_cookie_cutoff;
std::chrono::minutes backup_interval;
std::chrono::seconds search_pending_interval;
std::chrono::seconds peer_interval;
std::chrono::hours unchecked_cleaning_interval;
std::chrono::milliseconds process_confirmed_interval;
/** The maximum amount of samples for a 2 week period on live or 3 days on beta */
uint64_t max_weight_samples;
uint64_t weight_period;
};
/** Voting related constants whose value depends on the active network */
class voting_constants
{
public:
voting_constants (nano::network_params & params_a);
size_t max_cache;
std::chrono::milliseconds generator_delay;
};
/** Port-mapping related constants whose value depends on the active network */
class portmapping_constants
{
public:
portmapping_constants (nano::network_params & params_a);
// Timeouts are primes so they infrequently happen at the same time
int mapping_timeout;
int check_timeout;
};
/** Bootstrap related constants whose value depends on the active network */
class bootstrap_constants
{
public:
bootstrap_constants (nano::network_params & params_a);
uint64_t lazy_max_pull_blocks;
};
/** Constants whose value depends on the active network */
class network_params
{
public:
/** Populate values based on the current active network */
network_params ();
/** Populate values based on \p network_a */
network_params (nano::nano_networks network_a);
default_node_port = is_live_network () ? 7075 : 54000;
default_rpc_port = is_live_network () ? 7076 : 55000;
default_ipc_port = is_live_network () ? 7077 : 24077;
request_interval_ms = is_test_network () ? 10 : 16000;
}
/** The network this param object represents. This may differ from the global active network; this is needed for certain --debug... commands */
nano::nano_networks current_network;
std::array<uint8_t, 2> header_magic_number;
unsigned request_interval_ms;
nano_networks current_network;
uint64_t publish_threshold;
unsigned kdf_work;
uint16_t default_node_port;
uint16_t default_rpc_port;
ledger_constants ledger;
voting_constants voting;
node_constants node;
portmapping_constants portmapping;
bootstrap_constants bootstrap;
uint16_t default_ipc_port;
unsigned request_interval_ms;
/** Returns the network this object contains values for */
nano::nano_networks network ()
nano_networks network () const
{
return current_network;
}
@ -134,9 +65,9 @@ public:
/**
* Optionally called on startup to override the global active network.
* If not called, the compile-time option will be used.
* @param network The new active network
* @param network_a The new active network
*/
static void set_active_network (nano::nano_networks network_a)
static void set_active_network (nano_networks network_a)
{
active_network = network_a;
}
@ -168,20 +99,19 @@ public:
return err;
}
bool is_live_network ()
bool is_live_network () const
{
return current_network == nano_networks::nano_live_network;
}
bool is_beta_network ()
bool is_beta_network () const
{
return current_network == nano_networks::nano_beta_network;
}
bool is_test_network ()
bool is_test_network () const
{
return current_network == nano_networks::nano_test_network;
}
private:
/** Initial value is ACTIVE_NETWORK compile flag, but can be overridden by a CLI flag */
static nano::nano_networks active_network;
};
@ -190,6 +120,7 @@ inline boost::filesystem::path get_config_path (boost::filesystem::path const &
{
return data_path / "config.json";
}
}
/** Called by gtest_main to enforce test network */
void force_nano_test_network ();
}

4
nano/lib/interface.cpp
View file

@ -116,7 +116,7 @@ char * xrb_sign_transaction (const char * transaction, const xrb_uint256 private
char * xrb_work_transaction (const char * transaction)
{
static nano::network_params network_params;
static nano::network_constants network_constants;
char * result (nullptr);
try
{
@ -128,7 +128,7 @@ char * xrb_work_transaction (const char * transaction)
if (block != nullptr)
{
nano::work_pool pool (boost::thread::hardware_concurrency ());
auto work (pool.generate (block->root (), network_params.publish_threshold));
auto work (pool.generate (block->root (), network_constants.publish_threshold));
block->block_work_set (work);
auto json (block->to_json ());
result = reinterpret_cast<char *> (malloc (json.size () + 1));

12
nano/lib/work.cpp
View file

@ -7,13 +7,13 @@
bool nano::work_validate (nano::block_hash const & root_a, uint64_t work_a, uint64_t * difficulty_a)
{
static nano::network_params network_params;
static nano::network_constants network_constants;
auto value (nano::work_value (root_a, work_a));
if (difficulty_a != nullptr)
{
*difficulty_a = value;
}
return value < network_params.publish_threshold;
return value < network_constants.publish_threshold;
}
bool nano::work_validate (nano::block const & block_a, uint64_t * difficulty_a)
@ -41,7 +41,7 @@ opencl (opencl_a)
static_assert (ATOMIC_INT_LOCK_FREE == 2, "Atomic int needed");
boost::thread::attributes attrs;
nano::thread_attributes::set (attrs);
auto count (network_params.is_test_network () ? 1 : std::min (max_threads_a, std::max (1u, boost::thread::hardware_concurrency ())));
auto count (network_constants.is_test_network () ? 1 : std::min (max_threads_a, std::max (1u, boost::thread::hardware_concurrency ())));
for (auto i (0); i < count; ++i)
{
auto thread (boost::thread (attrs, [this, i]() {
@ -114,7 +114,7 @@ void nano::work_pool::loop (uint64_t thread)
if (ticket == ticket_l)
{
// If the ticket matches what we started with, we're the ones that found the solution
assert (output >= network_params.publish_threshold);
assert (output >= network_constants.publish_threshold);
assert (work_value (current_l.item, work) == output);
// Signal other threads to stop their work next time they check ticket
++ticket;
@ -172,7 +172,7 @@ void nano::work_pool::stop ()
void nano::work_pool::generate (nano::uint256_union const & hash_a, std::function<void(boost::optional<uint64_t> const &)> callback_a)
{
generate (hash_a, callback_a, network_params.publish_threshold);
generate (hash_a, callback_a, network_constants.publish_threshold);
}
void nano::work_pool::generate (nano::uint256_union const & hash_a, std::function<void(boost::optional<uint64_t> const &)> callback_a, uint64_t difficulty_a)
@ -199,7 +199,7 @@ void nano::work_pool::generate (nano::uint256_union const & hash_a, std::functio
uint64_t nano::work_pool::generate (nano::uint256_union const & hash_a)
{
return generate (hash_a, network_params.publish_threshold);
return generate (hash_a, network_constants.publish_threshold);
}
uint64_t nano::work_pool::generate (nano::uint256_union const & hash_a, uint64_t difficulty_a)

2
nano/lib/work.hpp
View file

@ -37,7 +37,7 @@ public:
void generate (nano::uint256_union const &, std::function<void(boost::optional<uint64_t> const &)>, uint64_t);
uint64_t generate (nano::uint256_union const &);
uint64_t generate (nano::uint256_union const &, uint64_t);
nano::network_params network_params;
nano::network_constants network_constants;
std::atomic<int> ticket;
bool done;
std::vector<boost::thread> threads;

10
nano/nano_node/entry.cpp
View file

@ -119,7 +119,7 @@ int main (int argc, char * const * argv)
auto network (vm.find ("network"));
if (network != vm.end ())
{
auto err (nano::network_params::set_active_network (network->second.as<std::string> ()));
auto err (nano::network_constants::set_active_network (network->second.as<std::string> ()));
if (err)
{
std::cerr << err.get_message () << std::endl;
@ -305,7 +305,7 @@ int main (int argc, char * const * argv)
}
else if (vm.count ("debug_opencl"))
{
nano::network_params network_params;
nano::network_constants network_constants;
bool error (false);
nano::opencl_environment environment (error);
if (!error)
@ -352,7 +352,7 @@ int main (int argc, char * const * argv)
result = -1;
}
}
uint64_t difficulty (network_params.publish_threshold);
uint64_t difficulty (network_constants.publish_threshold);
auto difficulty_it = vm.find ("difficulty");
if (difficulty_it != vm.end ())
{
@ -477,7 +477,7 @@ int main (int argc, char * const * argv)
}
else if (vm.count ("debug_profile_process"))
{
nano::network_params::set_active_network (nano::nano_networks::nano_test_network);
nano::network_constants::set_active_network (nano::nano_networks::nano_test_network);
nano::network_params test_params;
nano::block_builder builder;
size_t num_accounts (100000);
@ -589,7 +589,7 @@ int main (int argc, char * const * argv)
}
else if (vm.count ("debug_profile_votes"))
{
nano::network_params::set_active_network (nano::nano_networks::nano_test_network);
nano::network_constants::set_active_network (nano::nano_networks::nano_test_network);
nano::network_params test_params;
nano::block_builder builder;
size_t num_elections (40000);

2
nano/nano_wallet/entry.cpp
View file

@ -332,7 +332,7 @@ int main (int argc, char * const * argv)
auto network (vm.find ("network"));
if (network != vm.end ())
{
auto err (nano::network_params::set_active_network (network->second.as<std::string> ()));
auto err (nano::network_constants::set_active_network (network->second.as<std::string> ()));
if (err)
{
std::cerr << err.get_message () << std::endl;

2
nano/node/bootstrap.cpp
View file

@ -103,7 +103,7 @@ void nano::socket::close ()
void nano::socket::checkup (uint64_t timeout_a)
{
std::weak_ptr<nano::socket> this_w (shared_from_this ());
node->alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (node->network_params.is_test_network () ? 1 : 10), [this_w, timeout_a]() {
node->alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (node->network_params.network.is_test_network () ? 1 : 10), [this_w, timeout_a]() {
if (auto this_l = this_w.lock ())
{
if (this_l->async_start_time != std::numeric_limits<uint64_t>::max () && this_l->async_start_time + timeout_a < static_cast<uint64_t> (std::chrono::steady_clock::now ().time_since_epoch ().count ()))

4
nano/node/common.cpp
View file

@ -207,7 +207,7 @@ status (parse_status::success)
void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, size_t size_a)
{
static nano::network_params network_params;
static nano::network_constants network_constants;
status = parse_status::success;
auto error (false);
if (size_a <= max_safe_udp_message_size)
@ -217,7 +217,7 @@ void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, size_t
nano::message_header header (error, stream);
if (!error)
{
if (network_params.is_beta_network () && header.version_using < nano::protocol_version_reasonable_min)
if (network_constants.is_beta_network () && header.version_using < nano::protocol_version_reasonable_min)
{
status = parse_status::outdated_version;
}

36
nano/node/node.cpp
View file

@ -737,7 +737,7 @@ void nano::vote_processor::vote (std::shared_ptr<nano::vote> vote_a, std::shared
/* Random early delection levels
Always process votes for test network (process = true)
Stop processing with max 144 * 1024 votes */
if (!node.network_params.is_test_network ())
if (!node.network_params.network.is_test_network ())
{
// Level 0 (< 0.1%)
if (votes.size () < 96 * 1024)
@ -1226,9 +1226,9 @@ startup_time (std::chrono::steady_clock::now ())
logger.always_log ("Node ID: ", node_id.pub.to_account ());
}
const uint8_t * weight_buffer = network_params.is_live_network () ? nano_bootstrap_weights_live : nano_bootstrap_weights_beta;
size_t weight_size = network_params.is_live_network () ? nano_bootstrap_weights_live_size : nano_bootstrap_weights_beta_size;
if (network_params.is_live_network () || network_params.is_beta_network ())
const uint8_t * weight_buffer = network_params.network.is_live_network () ? nano_bootstrap_weights_live : nano_bootstrap_weights_beta;
size_t weight_size = network_params.network.is_live_network () ? nano_bootstrap_weights_live_size : nano_bootstrap_weights_beta_size;
if (network_params.network.is_live_network () || network_params.network.is_beta_network ())
{
nano::bufferstream weight_stream ((const uint8_t *)weight_buffer, weight_size);
nano::uint128_union block_height;
@ -1467,7 +1467,7 @@ void nano::gap_cache::vote (std::shared_ptr<nano::vote> vote_a)
{
auto node_l (node.shared ());
auto now (std::chrono::steady_clock::now ());
node.alarm.add (node_l->network_params.is_test_network () ? now + std::chrono::milliseconds (5) : now + std::chrono::seconds (5), [node_l, hash]() {
node.alarm.add (node_l->network_params.network.is_test_network () ? now + std::chrono::milliseconds (5) : now + std::chrono::seconds (5), [node_l, hash]() {
auto transaction (node_l->store.tx_begin_read ());
if (!node_l->store.block_exists (transaction, hash))
{
@ -1591,7 +1591,7 @@ void nano::node::keepalive_preconfigured (std::vector<std::string> const & peers
{
for (auto i (peers_a.begin ()), n (peers_a.end ()); i != n; ++i)
{
keepalive (*i, network_params.default_node_port);
keepalive (*i, network_params.network.default_node_port);
}
}
@ -2099,7 +2099,7 @@ public:
void nano::node::work_generate_blocking (nano::block & block_a)
{
work_generate_blocking (block_a, network_params.publish_threshold);
work_generate_blocking (block_a, network_params.network.publish_threshold);
}
void nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a)
@ -2109,7 +2109,7 @@ void nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficu
void nano::node::work_generate (nano::uint256_union const & hash_a, std::function<void(uint64_t)> callback_a)
{
work_generate (hash_a, callback_a, network_params.publish_threshold);
work_generate (hash_a, callback_a, network_params.network.publish_threshold);
}
void nano::node::work_generate (nano::uint256_union const & hash_a, std::function<void(uint64_t)> callback_a, uint64_t difficulty_a)
@ -2120,7 +2120,7 @@ void nano::node::work_generate (nano::uint256_union const & hash_a, std::functio
uint64_t nano::node::work_generate_blocking (nano::uint256_union const & block_a)
{
return work_generate_blocking (block_a, network_params.publish_threshold);
return work_generate_blocking (block_a, network_params.network.publish_threshold);
}
uint64_t nano::node::work_generate_blocking (nano::uint256_union const & hash_a, uint64_t difficulty_a)
@ -2631,7 +2631,7 @@ nano::election_vote_result nano::election::vote (nano::account rep, uint64_t seq
auto supply (node.online_reps.online_stake ());
auto weight (node.ledger.weight (transaction, rep));
auto should_process (false);
if (node.network_params.is_test_network () || weight > supply / 1000) // 0.1% or above
if (node.network_params.network.is_test_network () || weight > supply / 1000) // 0.1% or above
{
unsigned int cooldown;
if (weight < supply / 100) // 0.1% to 1%
@ -2768,7 +2768,7 @@ void nano::active_transactions::confirm_frontiers (nano::transaction const & tra
~15 minutes for non-representative nodes, 3 minutes for representatives */
int representative_factor = representative ? 3 * 60 : 15 * 60;
// Decrease check time for test network
int test_network_factor = node.network_params.is_test_network () ? 1000 : 1;
int test_network_factor = node.network_params.network.is_test_network () ? 1000 : 1;
if (std::chrono::steady_clock::now () >= next_frontier_check)
{
size_t max_elections (max_broadcast_queue / 4);
@ -2876,7 +2876,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
/* Escalation for long unconfirmed elections
Start new elections for previous block & source
if there are less than 100 active elections */
if (election_l->announcements % announcement_long == 1 && roots_size < 100 && !node.network_params.is_test_network ())
if (election_l->announcements % announcement_long == 1 && roots_size < 100 && !node.network_params.network.is_test_network ())
{
std::shared_ptr<nano::block> previous;
auto previous_hash (election_l->status.winner->previous ());
@ -2949,7 +2949,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
if ((!rep_channels->empty () && node.rep_crawler.total_weight () > node.config.online_weight_minimum.number ()) || roots_size > 5)
{
// broadcast_confirm_req_base modifies reps, so we clone it once to avoid aliasing
if (!node.network_params.is_test_network ())
if (!node.network_params.network.is_test_network ())
{
if (confirm_req_bundle.size () < max_broadcast_queue)
{
@ -2980,7 +2980,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
}
else
{
if (!node.network_params.is_test_network ())
if (!node.network_params.network.is_test_network ())
{
auto deque_l (node.network.udp_channels.random_set (100));
auto vec (std::make_shared<std::vector<std::shared_ptr<nano::transport::channel>>> ());
@ -3020,7 +3020,7 @@ void nano::active_transactions::request_confirm (std::unique_lock<std::mutex> &
node.network.flood_block_batch (rebroadcast_bundle);
}
// Batch confirmation request
if (!node.network_params.is_live_network () && !requests_bundle.empty ())
if (!node.network_params.network.is_live_network () && !requests_bundle.empty ())
{
node.network.broadcast_confirm_req_batch (requests_bundle, 50);
}
@ -3068,7 +3068,7 @@ void nano::active_transactions::request_loop ()
{
request_confirm (lock);
const auto extra_delay (std::min (roots.size (), max_broadcast_queue) * node.network.broadcast_interval_ms * 2);
condition.wait_for (lock, std::chrono::milliseconds (node.network_params.request_interval_ms + extra_delay));
condition.wait_for (lock, std::chrono::milliseconds (node.network_params.network.request_interval_ms + extra_delay));
}
}
@ -3241,9 +3241,9 @@ void nano::active_transactions::adjust_difficulty (nano::block_hash const & hash
uint64_t average (static_cast<uint64_t> (sum / elections_list.size ()));
// Potential overflow check
uint64_t divider (1);
if (elections_list.size () > 1000000 && (average - node.network_params.publish_threshold) > elections_list.size ())
if (elections_list.size () > 1000000 && (average - node.network_params.network.publish_threshold) > elections_list.size ())
{
divider = ((average - node.network_params.publish_threshold) / elections_list.size ()) + 1;
divider = ((average - node.network_params.network.publish_threshold) / elections_list.size ()) + 1;
}
// Set adjusted difficulty
for (auto & item : elections_list)

4
nano/node/nodeconfig.cpp
View file

@ -26,12 +26,12 @@ logging (logging_a)
// which is determined at node startup based on active network.
if (peering_port == 0)
{
peering_port = network_params.default_node_port;
peering_port = network_params.network.default_node_port;
}
const char * epoch_message ("epoch v1 block");
strncpy ((char *)epoch_block_link.bytes.data (), epoch_message, epoch_block_link.bytes.size ());
epoch_block_signer = network_params.ledger.genesis_account;
switch (network_params.network ())
switch (network_params.network.network ())
{
case nano::nano_networks::nano_test_network:
enable_voting = true;

3
nano/node/nodeconfig.hpp
View file

@ -9,6 +9,7 @@
#include <nano/node/logging.hpp>
#include <nano/node/stats.hpp>
#include <nano/node/websocketconfig.hpp>
#include <nano/secure/common.hpp>
#include <vector>
namespace nano
@ -49,7 +50,7 @@ public:
uint16_t callback_port{ 0 };
std::string callback_target;
int lmdb_max_dbs{ 128 };
bool allow_local_peers{ !network_params.is_live_network () }; // disable by default for live network
bool allow_local_peers{ !network_params.network.is_live_network () }; // disable by default for live network
nano::stat_config stat_config;
nano::ipc::ipc_config ipc_config;
nano::uint256_union epoch_block_link;

6
nano/node/portmapping.cpp
View file

@ -20,7 +20,7 @@ void nano::port_mapping::start ()
void nano::port_mapping::refresh_devices ()
{
if (!network_params.is_test_network ())
if (!network_params.network.is_test_network ())
{
std::lock_guard<std::mutex> lock (mutex);
int discover_error = 0;
@ -50,7 +50,7 @@ void nano::port_mapping::refresh_devices ()
void nano::port_mapping::refresh_mapping ()
{
if (!network_params.is_test_network ())
if (!network_params.network.is_test_network ())
{
std::lock_guard<std::mutex> lock (mutex);
auto node_port (std::to_string (node.network.endpoint ().port ()));
@ -80,7 +80,7 @@ void nano::port_mapping::refresh_mapping ()
int nano::port_mapping::check_mapping ()
{
int result (3600);
if (!network_params.is_test_network ())
if (!network_params.network.is_test_network ())
{
// Long discovery time and fast setup/teardown make this impractical for testing
std::lock_guard<std::mutex> lock (mutex);

6
nano/node/rpc.cpp
View file

@ -4253,7 +4253,7 @@ void nano::rpc_handler::work_generate ()
{
rpc_control_impl ();
auto hash (hash_impl ());
uint64_t difficulty (node.network_params.publish_threshold);
uint64_t difficulty (node.network_params.network.publish_threshold);
boost::optional<std::string> difficulty_text (request.get_optional<std::string> ("difficulty"));
if (!ec && difficulty_text.is_initialized ())
{
@ -4352,7 +4352,7 @@ void nano::rpc_handler::work_validate ()
{
auto hash (hash_impl ());
auto work (work_optional_impl ());
uint64_t difficulty (node.network_params.publish_threshold);
uint64_t difficulty (node.network_params.network.publish_threshold);
boost::optional<std::string> difficulty_text (request.get_optional<std::string> ("difficulty"));
if (!ec && difficulty_text.is_initialized ())
{
@ -4468,7 +4468,7 @@ void nano::rpc_connection::read ()
std::promise<size_t> header_available_promise;
std::future<size_t> header_available = header_available_promise.get_future ();
header_parser->body_limit (rpc.config.max_request_size);
if (!node->network_params.is_test_network ())
if (!node->network_params.network.is_test_network ())
{
boost::beast::http::async_read_header (socket, buffer, *header_parser, [this_l, header_parser, &header_available_promise, &header_error](boost::system::error_code const & ec, size_t bytes_transferred) {
size_t header_response_bytes_written = 0;

2
nano/node/rpcconfig.cpp
View file

@ -34,7 +34,7 @@ nano::error nano::rpc_secure_config::deserialize_json (nano::jsonconfig & json)
nano::rpc_config::rpc_config (bool enable_control_a) :
address (boost::asio::ip::address_v6::loopback ()),
port (network_params.default_rpc_port),
port (network_constants.default_rpc_port),
enable_control (enable_control_a),
max_json_depth (20),
enable_sign_hash (false),

3
nano/node/rpcconfig.hpp
View file

@ -2,6 +2,7 @@
#include <boost/asio.hpp>
#include <nano/lib/errors.hpp>
#include <nano/secure/common.hpp>
#include <string>
namespace nano
@ -38,7 +39,7 @@ public:
rpc_config (bool = false);
nano::error serialize_json (nano::jsonconfig &) const;
nano::error deserialize_json (bool & upgraded_a, nano::jsonconfig &);
nano::network_params network_params;
nano::network_constants network_constants;
boost::asio::ip::address_v6 address;
uint16_t port;
bool enable_control;

2
nano/node/transport/udp.cpp
View file

@ -581,7 +581,7 @@ bool nano::transport::udp_channels::not_a_peer (nano::endpoint const & endpoint_
{
result = true;
}
else if (!network_params.is_test_network () && max_ip_connections (endpoint_a))
else if (!network_params.network.is_test_network () && max_ip_connections (endpoint_a))
{
result = true;
}

4
nano/node/wallet.cpp
View file

@ -1335,7 +1335,7 @@ void nano::wallet::work_cache_blocking (nano::account const & account_a, nano::b
* The difficulty parameter is the second parameter for `work_generate_blocking()`,
* currently we don't supply one so we must fetch the default value.
*/
auto difficulty (wallets.node.network_params.publish_threshold);
auto difficulty (wallets.node.network_params.network.publish_threshold);
wallets.node.logger.try_log ("Work generation for ", root_a.to_string (), ", with a difficulty of ", difficulty, " complete: ", (std::chrono::duration_cast<std::chrono::microseconds> (std::chrono::steady_clock::now () - begin).count ()), " us");
}
@ -1662,7 +1662,7 @@ void nano::wallets::ongoing_compute_reps ()
{
compute_reps ();
auto & node_l (node);
auto compute_delay (network_params.is_test_network () ? std::chrono::milliseconds (10) : std::chrono::milliseconds (15 * 60 * 1000)); // Representation drifts quickly on the test network but very slowly on the live network
auto compute_delay (network_params.network.is_test_network () ? std::chrono::milliseconds (10) : std::chrono::milliseconds (15 * 60 * 1000)); // Representation drifts quickly on the test network but very slowly on the live network
node.alarm.add (std::chrono::steady_clock::now () + compute_delay, [&node_l]() {
node_l.wallets.ongoing_compute_reps ();
});

4
nano/qt/qt.cpp
View file

@ -73,11 +73,11 @@ wallet (wallet_a)
{
your_account_label->setStyleSheet ("font-weight: bold;");
std::string network = "Live";
if (wallet.node.network_params.is_beta_network ())
if (wallet.node.network_params.network.is_beta_network ())
{
network = "Beta";
}
else if (wallet.node.network_params.is_test_network ())
else if (wallet.node.network_params.network.is_test_network ())
{
network = "Test";
}

2
nano/qt_system/entry.cpp
View file

@ -6,7 +6,7 @@
int main (int argc, char ** argv)
{
nano::network_params::set_active_network (nano::nano_networks::nano_test_network);
nano::network_constants::set_active_network (nano::nano_networks::nano_test_network);
QApplication application (argc, argv);
QCoreApplication::setOrganizationName ("Nano");
QCoreApplication::setOrganizationDomain ("nano.org");

7
nano/qt_test/entry.cpp
View file

@ -2,11 +2,14 @@
#include <gtest/gtest.h>
QApplication * test_application = nullptr;
extern void force_nano_test_network ();
namespace nano
{
void force_nano_test_network ();
}
int main (int argc, char ** argv)
{
force_nano_test_network ();
nano::force_nano_test_network ();
QApplication application (argc, argv);
test_application = &application;
testing::InitGoogleTest (&argc, argv);

136
nano/secure/common.cpp
View file

@ -1,9 +1,8 @@
#include <nano/secure/common.hpp>
#include <nano/lib/interface.h>
#include <nano/lib/numbers.hpp>
#include <nano/node/common.hpp>
#include <nano/secure/blockstore.hpp>
#include <nano/secure/common.hpp>
#include <nano/secure/versioning.hpp>
#include <boost/endian/conversion.hpp>
@ -11,6 +10,11 @@
#include <queue>
#include <iostream>
#include <limits>
#include <nano/core_test/testutil.hpp>
#include <nano/lib/config.hpp>
#include <crypto/ed25519-donna/ed25519.h>
size_t constexpr nano::send_block::size;
@ -19,6 +23,134 @@ size_t constexpr nano::open_block::size;
size_t constexpr nano::change_block::size;
size_t constexpr nano::state_block::size;
nano::nano_networks nano::network_constants::active_network = nano::nano_networks::ACTIVE_NETWORK;
namespace
{
char const * test_private_key_data = "34F0A37AAD20F4A260F0A5B3CB3D7FB50673212263E58A380BC10474BB039CE4";
char const * test_public_key_data = "B0311EA55708D6A53C75CDBF88300259C6D018522FE3D4D0A242E431F9E8B6D0"; // xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo
char const * beta_public_key_data = "A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F"; // xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp
char const * live_public_key_data = "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA"; // xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3
char const * test_genesis_data = R"%%%({
"type": "open",
"source": "B0311EA55708D6A53C75CDBF88300259C6D018522FE3D4D0A242E431F9E8B6D0",
"representative": "xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo",
"account": "xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo",
"work": "9680625b39d3363d",
"signature": "ECDA914373A2F0CA1296475BAEE40500A7F0A7AD72A5A80C81D7FAB7F6C802B2CC7DB50F5DD0FB25B2EF11761FA7344A158DD5A700B21BD47DE5BD0F63153A02"
})%%%";
char const * beta_genesis_data = R"%%%({
"type": "open",
"source": "A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F",
"representative": "xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp",
"account": "xrb_3betaz86ypbygpqbookmzpnmd5jhh4efmd8arr9a3n4bdmj1zgnzad7xpmfp",
"work": "000000000f0aaeeb",
"signature": "A726490E3325E4FA59C1C900D5B6EEBB15FE13D99F49D475B93F0AACC5635929A0614CF3892764A04D1C6732A0D716FFEB254D4154C6F544D11E6630F201450B"
})%%%";
char const * live_genesis_data = R"%%%({
"type": "open",
"source": "E89208DD038FBB269987689621D52292AE9C35941A7484756ECCED92A65093BA",
"representative": "xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3",
"account": "xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3",
"work": "62f05417dd3fb691",
"signature": "9F0C933C8ADE004D808EA1985FA746A7E95BA2A38F867640F53EC8F180BDFE9E2C1268DEAD7C2664F356E37ABA362BC58E46DBA03E523A7B5A19E4B6EB12BB02"
})%%%";
}
nano::network_params::network_params () :
network_params (network_constants::active_network)
{
}
nano::network_params::network_params (nano::nano_networks network_a) :
network (network_a), ledger (network), voting (network), node (network), portmapping (network), bootstrap (network)
{
unsigned constexpr kdf_full_work = 64 * 1024;
unsigned constexpr kdf_test_work = 8;
kdf_work = network.is_test_network () ? kdf_test_work : kdf_full_work;
header_magic_number = network.is_test_network () ? std::array<uint8_t, 2>{ { 'R', 'A' } } : network.is_beta_network () ? std::array<uint8_t, 2>{ { 'R', 'B' } } : std::array<uint8_t, 2>{ { 'R', 'C' } };
}
nano::ledger_constants::ledger_constants (nano::network_constants & network_constants) :
ledger_constants (network_constants.network ())
{
}
nano::ledger_constants::ledger_constants (nano::nano_networks network_a) :
zero_key ("0"),
test_genesis_key (test_private_key_data),
nano_test_account (test_public_key_data),
nano_beta_account (beta_public_key_data),
nano_live_account (live_public_key_data),
nano_test_genesis (test_genesis_data),
nano_beta_genesis (beta_genesis_data),
nano_live_genesis (live_genesis_data),
genesis_account (network_a == nano::nano_networks::nano_test_network ? nano_test_account : network_a == nano::nano_networks::nano_beta_network ? nano_beta_account : nano_live_account),
genesis_block (network_a == nano::nano_networks::nano_test_network ? nano_test_genesis : network_a == nano::nano_networks::nano_beta_network ? nano_beta_genesis : nano_live_genesis),
genesis_amount (std::numeric_limits<nano::uint128_t>::max ()),
burn_account (0),
not_an_account_m (0)
{
}
nano::account const & nano::ledger_constants::not_an_account ()
{
if (not_an_account_m.is_zero ())
{
// Randomly generating these mean no two nodes will ever have the same sentinel values which protects against some insecure algorithms
nano::random_pool::generate_block (not_an_account_m.bytes.data (), not_an_account_m.bytes.size ());
}
return not_an_account_m;
}
nano::node_constants::node_constants (nano::network_constants & network_constants)
{
period = network_constants.is_test_network () ? std::chrono::seconds (1) : std::chrono::seconds (60);
cutoff = period * 5;
syn_cookie_cutoff = std::chrono::seconds (5);
backup_interval = std::chrono::minutes (5);
search_pending_interval = network_constants.is_test_network () ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60);
peer_interval = search_pending_interval;
unchecked_cleaning_interval = std::chrono::hours (2);
process_confirmed_interval = network_constants.is_test_network () ? std::chrono::milliseconds (50) : std::chrono::milliseconds (500);
max_weight_samples = network_constants.is_live_network () ? 4032 : 864;
weight_period = 5 * 60; // 5 minutes
}
nano::voting_constants::voting_constants (nano::network_constants & network_constants)
{
max_cache = network_constants.is_test_network () ? 2 : 1000;
generator_delay = network_constants.is_test_network () ? std::chrono::milliseconds (10) : std::chrono::milliseconds (500);
}
nano::portmapping_constants::portmapping_constants (nano::network_constants & network_constants)
{
mapping_timeout = network_constants.is_test_network () ? 53 : 3593;
check_timeout = network_constants.is_test_network () ? 17 : 53;
}
nano::bootstrap_constants::bootstrap_constants (nano::network_constants & network_constants)
{
lazy_max_pull_blocks = network_constants.is_test_network () ? 2 : 512;
}
/* Convenience constants for core_test which is always on the test network */
namespace
{
nano::ledger_constants test_constants (nano::nano_networks::nano_test_network);
}
nano::keypair const & nano::zero_key (test_constants.zero_key);
nano::keypair const & nano::test_genesis_key (test_constants.test_genesis_key);
nano::account const & nano::nano_test_account (test_constants.nano_test_account);
std::string const & nano::nano_test_genesis (test_constants.nano_test_genesis);
nano::account const & nano::genesis_account (test_constants.genesis_account);
std::string const & nano::genesis_block (test_constants.genesis_block);
nano::uint128_t const & nano::genesis_amount (test_constants.genesis_amount);
nano::account const & nano::burn_account (test_constants.burn_account);
// Create a new random keypair
nano::keypair::keypair ()
{

94
nano/secure/common.hpp
View file

@ -2,6 +2,8 @@
#include <nano/lib/blockbuilders.hpp>
#include <nano/lib/blocks.hpp>
#include <nano/lib/config.hpp>
#include <nano/lib/numbers.hpp>
#include <nano/lib/utility.hpp>
#include <nano/secure/utility.hpp>
@ -307,4 +309,96 @@ public:
nano::block_hash hash () const;
std::shared_ptr<nano::block> open;
};
class network_params;
/** Genesis keys and ledger constants for network variants */
class ledger_constants
{
public:
ledger_constants (nano::network_constants & network_constants);
ledger_constants (nano::nano_networks network_a);
nano::keypair zero_key;
nano::keypair test_genesis_key;
nano::account nano_test_account;
nano::account nano_beta_account;
nano::account nano_live_account;
std::string nano_test_genesis;
std::string nano_beta_genesis;
std::string nano_live_genesis;
nano::account genesis_account;
std::string genesis_block;
nano::uint128_t genesis_amount;
nano::account const & not_an_account ();
nano::account burn_account;
private:
nano::account not_an_account_m;
};
/** Node related constants whose value depends on the active network */
class node_constants
{
public:
node_constants (nano::network_constants & network_constants);
std::chrono::seconds period;
std::chrono::seconds cutoff;
std::chrono::seconds syn_cookie_cutoff;
std::chrono::minutes backup_interval;
std::chrono::seconds search_pending_interval;
std::chrono::seconds peer_interval;
std::chrono::hours unchecked_cleaning_interval;
std::chrono::milliseconds process_confirmed_interval;
/** The maximum amount of samples for a 2 week period on live or 3 days on beta */
uint64_t max_weight_samples;
uint64_t weight_period;
};
/** Voting related constants whose value depends on the active network */
class voting_constants
{
public:
voting_constants (nano::network_constants & network_constants);
size_t max_cache;
std::chrono::milliseconds generator_delay;
};
/** Port-mapping related constants whose value depends on the active network */
class portmapping_constants
{
public:
portmapping_constants (nano::network_constants & network_constants);
// Timeouts are primes so they infrequently happen at the same time
int mapping_timeout;
int check_timeout;
};
/** Bootstrap related constants whose value depends on the active network */
class bootstrap_constants
{
public:
bootstrap_constants (nano::network_constants & network_constants);
uint64_t lazy_max_pull_blocks;
};
/** Constants whose value depends on the active network */
class network_params
{
public:
/** Populate values based on the current active network */
network_params ();
/** Populate values based on \p network_a */
network_params (nano::nano_networks network_a);
std::array<uint8_t, 2> header_magic_number;
unsigned kdf_work;
network_constants network;
ledger_constants ledger;
voting_constants voting;
node_constants node;
portmapping_constants portmapping;
bootstrap_constants bootstrap;
};
}

4
nano/secure/utility.cpp
View file

@ -7,9 +7,9 @@ static std::vector<boost::filesystem::path> all_unique_paths;
boost::filesystem::path nano::working_path (bool legacy)
{
static nano::network_params network_params;
static nano::network_constants network_constants;
auto result (nano::app_path ());
switch (network_params.network ())
switch (network_constants.network ())
{
case nano::nano_networks::nano_test_network:
if (!legacy)