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

Block constructors to builders conversion in unit tests (#3841)

Browse source 
* Block constructors to builders conversion in unit tests

* Formatting fix
This commit is contained in:
JerzyStanislawski 2022-07-08 15:56:55 +02:00 • committed by GitHub
commit 86f1178e1e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
26 changed files with 7704 additions and 1933 deletions
Download patch file Download diff file Expand all files Collapse all files

187
nano/core_test/block.cpp
View file

@ -25,20 +25,36 @@ TEST (ed25519, signing)
TEST (transaction_block, empty)
{
nano::keypair key1;
nano::send_block block (0, 1, 13, key1.prv, key1.pub, 2);
auto hash (block.hash ());
ASSERT_FALSE (nano::validate_message (key1.pub, hash, block.signature));
block.signature.bytes[32] ^= 0x1;
ASSERT_TRUE (nano::validate_message (key1.pub, hash, block.signature));
nano::block_builder builder;
auto block = builder
.send ()
.previous (0)
.destination (1)
.balance (13)
.sign (key1.prv, key1.pub)
.work (2)
.build ();
auto hash (block->hash ());
ASSERT_FALSE (nano::validate_message (key1.pub, hash, block->signature));
block->signature.bytes[32] ^= 0x1;
ASSERT_TRUE (nano::validate_message (key1.pub, hash, block->signature));
}
TEST (block, send_serialize)
{
nano::send_block block1 (0, 1, 2, nano::keypair ().prv, 4, 5);
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (0)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build ();
std::vector<uint8_t> bytes;
{
nano::vectorstream stream1 (bytes);
block1.serialize (stream1);
block1->serialize (stream1);
}
auto data (bytes.data ());
auto size (bytes.size ());
@ -48,14 +64,22 @@ TEST (block, send_serialize)
bool error (false);
nano::send_block block2 (error, stream2);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (block, send_serialize_json)
{
nano::send_block block1 (0, 1, 2, nano::keypair ().prv, 4, 5);
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (0)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build ();
std::string string1;
block1.serialize_json (string1);
block1->serialize_json (string1);
ASSERT_NE (0, string1.size ());
boost::property_tree::ptree tree1;
std::stringstream istream (string1);
@ -63,30 +87,44 @@ TEST (block, send_serialize_json)
bool error (false);
nano::send_block block2 (error, tree1);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (block, receive_serialize)
{
nano::receive_block block1 (0, 1, nano::keypair ().prv, 3, 4);
nano::block_builder builder;
auto block1 = builder
.receive ()
.previous (0)
.source (1)
.sign (nano::keypair ().prv, 3)
.work (4)
.build ();
nano::keypair key1;
std::vector<uint8_t> bytes;
{
nano::vectorstream stream1 (bytes);
block1.serialize (stream1);
block1->serialize (stream1);
}
nano::bufferstream stream2 (bytes.data (), bytes.size ());
bool error (false);
nano::receive_block block2 (error, stream2);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (block, receive_serialize_json)
{
nano::receive_block block1 (0, 1, nano::keypair ().prv, 3, 4);
nano::block_builder builder;
auto block1 = builder
.receive ()
.previous (0)
.source (1)
.sign (nano::keypair ().prv, 3)
.work (4)
.build ();
std::string string1;
block1.serialize_json (string1);
block1->serialize_json (string1);
ASSERT_NE (0, string1.size ());
boost::property_tree::ptree tree1;
std::stringstream istream (string1);
@ -94,14 +132,22 @@ TEST (block, receive_serialize_json)
bool error (false);
nano::receive_block block2 (error, tree1);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (block, open_serialize_json)
{
nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0);
nano::block_builder builder;
auto block1 = builder
.open ()
.source (0)
.representative (1)
.account (0)
.sign (nano::keypair ().prv, 0)
.work (0)
.build ();
std::string string1;
block1.serialize_json (string1);
block1->serialize_json (string1);
ASSERT_NE (0, string1.size ());
boost::property_tree::ptree tree1;
std::stringstream istream (string1);
@ -109,14 +155,21 @@ TEST (block, open_serialize_json)
bool error (false);
nano::open_block block2 (error, tree1);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (block, change_serialize_json)
{
nano::change_block block1 (0, 1, nano::keypair ().prv, 3, 4);
nano::block_builder builder;
auto block1 = builder
.change ()
.previous (0)
.representative (1)
.sign (nano::keypair ().prv, 3)
.work (4)
.build ();
std::string string1;
block1.serialize_json (string1);
block1->serialize_json (string1);
ASSERT_NE (0, string1.size ());
boost::property_tree::ptree tree1;
std::stringstream istream (string1);
@ -124,7 +177,7 @@ TEST (block, change_serialize_json)
bool error (false);
nano::change_block block2 (error, tree1);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (uint512_union, parse_zero)
@ -196,65 +249,95 @@ TEST (uint512_union, parse_error_overflow)
TEST (send_block, deserialize)
{
nano::send_block block1 (0, 1, 2, nano::keypair ().prv, 4, 5);
ASSERT_EQ (block1.hash (), block1.hash ());
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (0)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build ();
ASSERT_EQ (block1->hash (), block1->hash ());
std::vector<uint8_t> bytes;
{
nano::vectorstream stream1 (bytes);
block1.serialize (stream1);
block1->serialize (stream1);
}
ASSERT_EQ (nano::send_block::size, bytes.size ());
nano::bufferstream stream2 (bytes.data (), bytes.size ());
bool error (false);
nano::send_block block2 (error, stream2);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (receive_block, deserialize)
{
nano::receive_block block1 (0, 1, nano::keypair ().prv, 3, 4);
ASSERT_EQ (block1.hash (), block1.hash ());
block1.hashables.previous = 2;
block1.hashables.source = 4;
nano::block_builder builder;
auto block1 = builder
.receive ()
.previous (0)
.source (1)
.sign (nano::keypair ().prv, 3)
.work (4)
.build ();
ASSERT_EQ (block1->hash (), block1->hash ());
block1->hashables.previous = 2;
block1->hashables.source = 4;
std::vector<uint8_t> bytes;
{
nano::vectorstream stream1 (bytes);
block1.serialize (stream1);
block1->serialize (stream1);
}
ASSERT_EQ (nano::receive_block::size, bytes.size ());
nano::bufferstream stream2 (bytes.data (), bytes.size ());
bool error (false);
nano::receive_block block2 (error, stream2);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (open_block, deserialize)
{
nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0);
ASSERT_EQ (block1.hash (), block1.hash ());
nano::block_builder builder;
auto block1 = builder
.open ()
.source (0)
.representative (1)
.account (0)
.sign (nano::keypair ().prv, 0)
.work (0)
.build ();
ASSERT_EQ (block1->hash (), block1->hash ());
std::vector<uint8_t> bytes;
{
nano::vectorstream stream (bytes);
block1.serialize (stream);
block1->serialize (stream);
}
ASSERT_EQ (nano::open_block::size, bytes.size ());
nano::bufferstream stream (bytes.data (), bytes.size ());
bool error (false);
nano::open_block block2 (error, stream);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (change_block, deserialize)
{
nano::change_block block1 (1, 2, nano::keypair ().prv, 4, 5);
ASSERT_EQ (block1.hash (), block1.hash ());
nano::block_builder builder;
auto block1 = builder
.change ()
.previous (1)
.representative (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build ();
ASSERT_EQ (block1->hash (), block1->hash ());
std::vector<uint8_t> bytes;
{
nano::vectorstream stream1 (bytes);
block1.serialize (stream1);
block1->serialize (stream1);
}
ASSERT_EQ (nano::change_block::size, bytes.size ());
auto data (bytes.data ());
@ -265,7 +348,7 @@ TEST (change_block, deserialize)
bool error (false);
nano::change_block block2 (error, stream2);
ASSERT_FALSE (error);
ASSERT_EQ (block1, block2);
ASSERT_EQ (*block1, block2);
}
TEST (frontier_req, serialization)
@ -292,7 +375,15 @@ TEST (block, publish_req_serialization)
{
nano::keypair key1;
nano::keypair key2;
auto block (std::make_shared<nano::send_block> (0, key2.pub, 200, nano::keypair ().prv, 2, 3));
nano::block_builder builder;
auto block = builder
.send ()
.previous (0)
.destination (key2.pub)
.balance (200)
.sign (nano::keypair ().prv, 2)
.work (3)
.build_shared ();
nano::publish req{ nano::dev::network_params.network, block };
std::vector<uint8_t> bytes;
{
@ -311,8 +402,16 @@ TEST (block, publish_req_serialization)
TEST (block, difficulty)
{
nano::send_block block (0, 1, 2, nano::keypair ().prv, 4, 5);
ASSERT_EQ (nano::dev::network_params.work.difficulty (block), nano::dev::network_params.work.difficulty (block.work_version (), block.root (), block.block_work ()));
nano::block_builder builder;
auto block = builder
.send ()
.previous (0)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build ();
ASSERT_EQ (nano::dev::network_params.work.difficulty (*block), nano::dev::network_params.work.difficulty (block->work_version (), block->root (), block->block_work ()));
}
TEST (state_block, serialization)

1129
nano/core_test/block_store.cpp
View file

File diff suppressed because it is too large Load diff

212
nano/core_test/bootstrap.cpp
View file

@ -55,14 +55,22 @@ TEST (bulk_pull, end_not_owned)
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100));
nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis_key.pub));
nano::open_block open (0, 1, 2, nano::keypair ().prv, 4, 5);
open.hashables.account = key2.pub;
open.hashables.representative = key2.pub;
open.hashables.source = latest;
open.refresh ();
open.signature = nano::sign_message (key2.prv, key2.pub, open.hash ());
system.nodes[0]->work_generate_blocking (open);
ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code);
nano::block_builder builder;
auto open = builder
.open ()
.source (0)
.representative (1)
.account (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build ();
open->hashables.account = key2.pub;
open->hashables.representative = key2.pub;
open->hashables.source = latest;
open->refresh ();
open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ());
system.nodes[0]->work_generate_blocking (*open);
ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*open).code);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = key2.pub;
@ -140,9 +148,23 @@ TEST (bulk_pull, count_limit)
nano::system system (1);
auto node0 (system.nodes[0]);
auto send1 (std::make_shared<nano::send_block> (node0->latest (nano::dev::genesis_key.pub), nano::dev::genesis_key.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (node0->latest (nano::dev::genesis_key.pub))));
nano::block_builder builder;
auto send1 = builder
.send ()
.previous (node0->latest (nano::dev::genesis_key.pub))
.destination (nano::dev::genesis_key.pub)
.balance (1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub)))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*send1).code);
auto receive1 (std::make_shared<nano::receive_block> (send1->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
auto receive1 = builder
.receive ()
.previous (send1->hash ())
.source (send1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node0, nano::socket::endpoint_type_t::server), node0));
@ -320,13 +342,41 @@ TEST (bootstrap_processor, pull_diamond)
node_flags.disable_bootstrap_bulk_push_client = true;
auto node0 (system.add_node (config, node_flags));
nano::keypair key;
auto send1 (std::make_shared<nano::send_block> (node0->latest (nano::dev::genesis_key.pub), key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (node0->latest (nano::dev::genesis_key.pub))));
nano::block_builder builder;
auto send1 = builder
.send ()
.previous (node0->latest (nano::dev::genesis_key.pub))
.destination (key.pub)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub)))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*send1).code);
auto open (std::make_shared<nano::open_block> (send1->hash (), 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
auto open = builder
.open ()
.source (send1->hash ())
.representative (1)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*open).code);
auto send2 (std::make_shared<nano::send_block> (open->hash (), nano::dev::genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ())));
auto send2 = builder
.send ()
.previous (open->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (std::numeric_limits<nano::uint128_t>::max () - 100)
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*send2).code);
auto receive (std::make_shared<nano::receive_block> (send1->hash (), send2->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
auto receive = builder
.receive ()
.previous (send1->hash ())
.source (send2->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*receive).code);
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work));
ASSERT_FALSE (node1->init_error ());
@ -394,13 +444,41 @@ TEST (bootstrap_processor, DISABLED_push_diamond)
auto wallet1 (node1->wallets.create (100));
wallet1->insert_adhoc (nano::dev::genesis_key.prv);
wallet1->insert_adhoc (key.prv);
auto send1 (std::make_shared<nano::send_block> (node0->latest (nano::dev::genesis_key.pub), key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (node0->latest (nano::dev::genesis_key.pub))));
nano::block_builder builder;
auto send1 = builder
.send ()
.previous (node0->latest (nano::dev::genesis_key.pub))
.destination (key.pub)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub)))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto open (std::make_shared<nano::open_block> (send1->hash (), 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
auto open = builder
.open ()
.source (send1->hash ())
.representative (1)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
auto send2 (std::make_shared<nano::send_block> (open->hash (), nano::dev::genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ())));
auto send2 = builder
.send ()
.previous (open->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (std::numeric_limits<nano::uint128_t>::max () - 100)
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code);
auto receive (std::make_shared<nano::receive_block> (send1->hash (), send2->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
auto receive = builder
.receive ()
.previous (send1->hash ())
.source (send2->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code);
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_TIMELY (10s, node0->balance (nano::dev::genesis_key.pub) == 100);
@ -426,17 +504,45 @@ TEST (bootstrap_processor, DISABLED_push_diamond_pruning)
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::unique_path (), config, system.work, node_flags, 1));
ASSERT_FALSE (node1->init_error ());
auto latest (node0->latest (nano::dev::genesis_key.pub));
auto send1 (std::make_shared<nano::send_block> (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)));
nano::block_builder builder;
auto send1 = builder
.send ()
.previous (latest)
.destination (key.pub)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto open (std::make_shared<nano::open_block> (send1->hash (), 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
auto open = builder
.open ()
.source (send1->hash ())
.representative (1)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
// 1st bootstrap
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_TIMELY (10s, node0->balance (key.pub) == nano::dev::constants.genesis_amount);
// Process more blocks & prune old
auto send2 (std::make_shared<nano::send_block> (open->hash (), nano::dev::genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ())));
auto send2 = builder
.send ()
.previous (open->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (std::numeric_limits<nano::uint128_t>::max () - 100)
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code);
auto receive (std::make_shared<nano::receive_block> (send1->hash (), send2->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
auto receive = builder
.receive ()
.previous (send1->hash ())
.source (send2->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code);
{
auto transaction (node1->store.tx_begin_write ());
@ -879,9 +985,10 @@ TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link)
nano::keypair key;
// Generating test chain
nano::state_block_builder builder;
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
@ -892,7 +999,7 @@ TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link)
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto send2 = builder
.make_block ()
.state ()
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev::genesis_key.pub)
@ -902,10 +1009,17 @@ TEST (bootstrap_processor, DISABLED_lazy_unclear_state_link)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code);
auto open (std::make_shared<nano::open_block> (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
auto open = builder
.open ()
.source (send1->hash ())
.representative (key.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
auto receive = builder
.make_block ()
.state ()
.account (key.pub)
.previous (open->hash ())
.representative (key.pub)
@ -940,9 +1054,10 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
nano::keypair key, key2;
// Generating test chain
nano::state_block_builder builder;
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
@ -952,10 +1067,17 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto open (std::make_shared<nano::open_block> (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
auto open = builder
.open ()
.source (send1->hash ())
.representative (key.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
auto send2 = builder
.make_block ()
.state ()
.account (key.pub)
.previous (open->hash ())
.representative (key.pub)
@ -990,9 +1112,10 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations)
nano::keypair key1, key2;
// Generating test chain
nano::state_block_builder builder;
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
@ -1003,7 +1126,7 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations)
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto send2 = builder
.make_block ()
.state ()
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev::genesis_key.pub)
@ -1013,10 +1136,17 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code);
auto open (std::make_shared<nano::open_block> (send1->hash (), key1.pub, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)));
auto open = builder
.open ()
.source (send1->hash ())
.representative (key1.pub)
.account (key1.pub)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
auto state_open = builder
.make_block ()
.state ()
.account (key2.pub)
.previous (0)
.representative (key2.pub)
@ -1053,9 +1183,10 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
nano::keypair key1, key2;
// Generating test chain
nano::state_block_builder builder;
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
@ -1066,7 +1197,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
.build_shared ();
node1->process_active (send1);
auto send2 = builder
.make_block ()
.state ()
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev::genesis_key.pub)
@ -1076,10 +1207,17 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
node1->process_active (send2);
auto open (std::make_shared<nano::open_block> (send1->hash (), key1.pub, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)));
auto open = builder
.open ()
.source (send1->hash ())
.representative (key1.pub)
.account (key1.pub)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
node1->process_active (open);
auto state_open = builder
.make_block ()
.state ()
.account (key2.pub)
.previous (0)
.representative (key2.pub)

1134
nano/core_test/confirmation_height.cpp
View file

File diff suppressed because it is too large Load diff

30
nano/core_test/confirmation_solicitor.cpp
View file

@ -28,7 +28,15 @@ TEST (confirmation_solicitor, batches)
ASSERT_EQ (channel1, representatives.front ().channel);
ASSERT_EQ (nano::dev::genesis_key.pub, representatives.front ().account);
ASSERT_TIMELY (3s, node2.network.size () == 1);
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (nano::keypair ().pub)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
send->sideband_set ({});
{
nano::lock_guard<nano::mutex> guard (node2.active.mutex);
@ -71,7 +79,15 @@ TEST (confirmation_solicitor, different_hash)
ASSERT_EQ (channel1, representatives.front ().channel);
ASSERT_EQ (nano::dev::genesis_key.pub, representatives.front ().account);
ASSERT_TIMELY (3s, node2.network.size () == 1);
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (nano::keypair ().pub)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
send->sideband_set ({});
auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
// Add a vote for something else, not the winner
@ -107,7 +123,15 @@ TEST (confirmation_solicitor, bypass_max_requests_cap)
ASSERT_EQ (max_representatives + 1, representatives.size ());
solicitor.prepare (representatives);
ASSERT_TIMELY (3s, node2.network.size () == 1);
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (nano::keypair ().pub)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
send->sideband_set ({});
auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
// Add a vote for something else, not the winner

64
nano/core_test/conflicts.cpp
View file

@ -13,7 +13,15 @@ TEST (conflicts, start_stop)
nano::system system (1);
auto & node1 (*system.nodes[0]);
nano::keypair key1;
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
nano::block_builder builder;
auto send1 = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (key1.pub)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1.work_generate_blocking (*send1);
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
ASSERT_EQ (0, node1.active.size ());
@ -30,12 +38,27 @@ TEST (conflicts, add_existing)
nano::system system{ 1 };
auto & node1 = *system.nodes[0];
nano::keypair key1;
auto send1 = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
nano::block_builder builder;
auto send1 = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (key1.pub)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1.work_generate_blocking (*send1);
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
nano::keypair key2;
auto send2 = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
auto send2 = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (key2.pub)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1.work_generate_blocking (*send2);
send2->sideband_set ({});
node1.block_processor.add (send2);
@ -146,7 +169,17 @@ TEST (vote_uniquer, vbh_one)
nano::block_uniquer block_uniquer;
nano::vote_uniquer uniquer (block_uniquer);
nano::keypair key;
auto block (std::make_shared<nano::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0));
nano::block_builder builder;
auto block = builder
.state ()
.account (0)
.previous (0)
.representative (0)
.balance (0)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
std::vector<nano::block_hash> hashes;
hashes.push_back (block->hash ());
auto vote1 (std::make_shared<nano::vote> (key.pub, key.prv, 0, 0, hashes));
@ -160,10 +193,29 @@ TEST (vote_uniquer, vbh_two)
nano::block_uniquer block_uniquer;
nano::vote_uniquer uniquer (block_uniquer);
nano::keypair key;
auto block1 (std::make_shared<nano::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0));
nano::block_builder builder;
auto block1 = builder
.state ()
.account (0)
.previous (0)
.representative (0)
.balance (0)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
std::vector<nano::block_hash> hashes1;
hashes1.push_back (block1->hash ());
auto block2 (std::make_shared<nano::state_block> (1, 0, 0, 0, 0, key.prv, key.pub, 0));
auto block2 = builder
.state ()
.account (1)
.previous (0)
.representative (0)
.balance (0)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
std::vector<nano::block_hash> hashes2;
hashes2.push_back (block2->hash ());
auto vote1 (std::make_shared<nano::vote> (key.pub, key.prv, 0, 0, hashes1));

297
nano/core_test/frontiers_confirmation.cpp
View file

@ -20,51 +20,157 @@ TEST (frontiers_confirmation, prioritize_frontiers)
nano::keypair key2;
nano::keypair key3;
nano::keypair key4;
nano::block_builder builder;
nano::block_hash latest1 (node->latest (nano::dev::genesis_key.pub));
// Send different numbers of blocks all accounts
nano::send_block send1 (latest1, key1.pub, node->config.online_weight_minimum.number () + 10000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1));
nano::send_block send2 (send1.hash (), key1.pub, node->config.online_weight_minimum.number () + 8500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
nano::send_block send3 (send2.hash (), key1.pub, node->config.online_weight_minimum.number () + 8000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ()));
nano::send_block send4 (send3.hash (), key2.pub, node->config.online_weight_minimum.number () + 7500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ()));
nano::send_block send5 (send4.hash (), key3.pub, node->config.online_weight_minimum.number () + 6500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send4.hash ()));
nano::send_block send6 (send5.hash (), key4.pub, node->config.online_weight_minimum.number () + 6000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5.hash ()));
auto send1 = builder
.send ()
.previous (latest1)
.destination (key1.pub)
.balance (node->config.online_weight_minimum.number () + 10000)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest1))
.build ();
auto send2 = builder
.send ()
.previous (send1->hash ())
.destination (key1.pub)
.balance (node->config.online_weight_minimum.number () + 8500)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build ();
auto send3 = builder
.send ()
.previous (send2->hash ())
.destination (key1.pub)
.balance (node->config.online_weight_minimum.number () + 8000)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ()))
.build ();
auto send4 = builder
.send ()
.previous (send3->hash ())
.destination (key2.pub)
.balance (node->config.online_weight_minimum.number () + 7500)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send3->hash ()))
.build ();
auto send5 = builder
.send ()
.previous (send4->hash ())
.destination (key3.pub)
.balance (node->config.online_weight_minimum.number () + 6500)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send4->hash ()))
.build ();
auto send6 = builder
.send ()
.previous (send5->hash ())
.destination (key4.pub)
.balance (node->config.online_weight_minimum.number () + 6000)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send5->hash ()))
.build ();
// Open all accounts and add other sends to get different uncemented counts (as well as some which are the same)
nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
nano::send_block send7 (open1.hash (), nano::dev::genesis_key.pub, 500, key1.prv, key1.pub, *system.work.generate (open1.hash ()));
auto open1 = builder
.open ()
.source (send1->hash ())
.representative (nano::dev::genesis->account ())
.account (key1.pub)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build ();
auto send7 = builder
.send ()
.previous (open1->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (500)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (open1->hash ()))
.build ();
nano::open_block open2 (send4.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
auto open2 = builder
.open ()
.source (send4->hash ())
.representative (nano::dev::genesis->account ())
.account (key2.pub)
.sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub))
.build ();
nano::open_block open3 (send5.hash (), nano::dev::genesis->account (), key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub));
nano::send_block send8 (open3.hash (), nano::dev::genesis_key.pub, 500, key3.prv, key3.pub, *system.work.generate (open3.hash ()));
nano::send_block send9 (send8.hash (), nano::dev::genesis_key.pub, 200, key3.prv, key3.pub, *system.work.generate (send8.hash ()));
auto open3 = builder
.open ()
.source (send5->hash ())
.representative (nano::dev::genesis->account ())
.account (key3.pub)
.sign (key3.prv, key3.pub)
.work (*system.work.generate (key3.pub))
.build ();
auto send8 = builder
.send ()
.previous (open3->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (500)
.sign (key3.prv, key3.pub)
.work (*system.work.generate (open3->hash ()))
.build ();
auto send9 = builder
.send ()
.previous (send8->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (200)
.sign (key3.prv, key3.pub)
.work (*system.work.generate (send8->hash ()))
.build ();
nano::open_block open4 (send6.hash (), nano::dev::genesis->account (), key4.pub, key4.prv, key4.pub, *system.work.generate (key4.pub));
nano::send_block send10 (open4.hash (), nano::dev::genesis_key.pub, 500, key4.prv, key4.pub, *system.work.generate (open4.hash ()));
nano::send_block send11 (send10.hash (), nano::dev::genesis_key.pub, 200, key4.prv, key4.pub, *system.work.generate (send10.hash ()));
auto open4 = builder
.open ()
.source (send6->hash ())
.representative (nano::dev::genesis->account ())
.account (key4.pub)
.sign (key4.prv, key4.pub)
.work (*system.work.generate (key4.pub))
.build ();
auto send10 = builder
.send ()
.previous (open4->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (500)
.sign (key4.prv, key4.pub)
.work (*system.work.generate (open4->hash ()))
.build ();
auto send11 = builder
.send ()
.previous (send10->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (200)
.sign (key4.prv, key4.pub)
.work (*system.work.generate (send10->hash ()))
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send3).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send4).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send5).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send6).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send5).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send6).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send7).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send7).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open3).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send8).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send9).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open3).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send8).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send9).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open4).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send10).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send11).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open4).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send10).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send11).code);
}
auto transaction = node->store.tx_begin_read ();
@ -111,20 +217,62 @@ TEST (frontiers_confirmation, prioritize_frontiers)
}
// Check that accounts which already exist have their order modified when the uncemented count changes.
nano::send_block send12 (send9.hash (), nano::dev::genesis_key.pub, 100, key3.prv, key3.pub, *system.work.generate (send9.hash ()));
nano::send_block send13 (send12.hash (), nano::dev::genesis_key.pub, 90, key3.prv, key3.pub, *system.work.generate (send12.hash ()));
nano::send_block send14 (send13.hash (), nano::dev::genesis_key.pub, 80, key3.prv, key3.pub, *system.work.generate (send13.hash ()));
nano::send_block send15 (send14.hash (), nano::dev::genesis_key.pub, 70, key3.prv, key3.pub, *system.work.generate (send14.hash ()));
nano::send_block send16 (send15.hash (), nano::dev::genesis_key.pub, 60, key3.prv, key3.pub, *system.work.generate (send15.hash ()));
nano::send_block send17 (send16.hash (), nano::dev::genesis_key.pub, 50, key3.prv, key3.pub, *system.work.generate (send16.hash ()));
auto send12 = builder
.send ()
.previous (send9->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (100)
.sign (key3.prv, key3.pub)
.work (*system.work.generate (send9->hash ()))
.build ();
auto send13 = builder
.send ()
.previous (send12->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (90)
.sign (key3.prv, key3.pub)
.work (*system.work.generate (send12->hash ()))
.build ();
auto send14 = builder
.send ()
.previous (send13->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (80)
.sign (key3.prv, key3.pub)
.work (*system.work.generate (send13->hash ()))
.build ();
auto send15 = builder
.send ()
.previous (send14->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (70)
.sign (key3.prv, key3.pub)
.work (*system.work.generate (send14->hash ()))
.build ();
auto send16 = builder
.send ()
.previous (send15->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (60)
.sign (key3.prv, key3.pub)
.work (*system.work.generate (send15->hash ()))
.build ();
auto send17 = builder
.send ()
.previous (send16->hash ())
.destination (nano::dev::genesis_key.pub)
.balance (50)
.sign (key3.prv, key3.pub)
.work (*system.work.generate (send16->hash ()))
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send12).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send13).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send14).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send15).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send16).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send17).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send12).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send13).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send14).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send15).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send16).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send17).code);
}
transaction.refresh ();
node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1));
@ -135,7 +283,7 @@ TEST (frontiers_confirmation, prioritize_frontiers)
// Check that the active transactions roots contains the frontiers
ASSERT_TIMELY (10s, node->active.size () == num_accounts);
std::array<nano::qualified_root, num_accounts> frontiers{ send17.qualified_root (), send6.qualified_root (), send7.qualified_root (), open2.qualified_root (), send11.qualified_root () };
std::array<nano::qualified_root, num_accounts> frontiers{ send17->qualified_root (), send6->qualified_root (), send7->qualified_root (), open2->qualified_root (), send11->qualified_root () };
for (auto & frontier : frontiers)
{
ASSERT_TRUE (node->active.active (frontier));
@ -161,10 +309,25 @@ TEST (frontiers_confirmation, prioritize_frontiers_max_optimistic_elections)
auto transaction = node->store.tx_begin_write ();
auto latest = node->latest (nano::dev::genesis->account ());
nano::keypair key;
nano::send_block send (latest, key.pub, node->config.online_weight_minimum.number () + 10000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
nano::open_block open (send.hash (), nano::dev::genesis->account (), key.pub, key.prv, key.pub, *system.work.generate (key.pub));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code);
nano::block_builder builder;
auto send = builder
.send ()
.previous (latest)
.destination (key.pub)
.balance (node->config.online_weight_minimum.number () + 10000)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
auto open = builder
.open ()
.source (send->hash ())
.representative (nano::dev::genesis->account ())
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
}
{
@ -211,6 +374,7 @@ TEST (frontiers_confirmation, expired_optimistic_elections_removal)
TEST (frontiers_confirmation, mode)
{
nano::keypair key;
nano::block_builder builder;
nano::node_flags node_flags;
// Always mode
{
@ -218,10 +382,19 @@ TEST (frontiers_confirmation, mode)
nano::node_config node_config (nano::get_available_port (), system.logging);
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::always;
auto node = system.add_node (node_config, node_flags);
nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ()));
auto send = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (nano::dev::genesis->hash ()))
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
}
ASSERT_TIMELY (5s, node->active.size () == 1);
}
@ -231,10 +404,19 @@ TEST (frontiers_confirmation, mode)
nano::node_config node_config (nano::get_available_port (), system.logging);
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::automatic;
auto node = system.add_node (node_config, node_flags);
nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ()));
auto send = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (nano::dev::genesis->hash ()))
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
}
ASSERT_TIMELY (5s, node->active.size () == 1);
}
@ -244,10 +426,19 @@ TEST (frontiers_confirmation, mode)
nano::node_config node_config (nano::get_available_port (), system.logging);
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config, node_flags);
nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ()));
auto send = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (nano::dev::genesis->hash ()))
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
}
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
std::this_thread::sleep_for (std::chrono::seconds (1));

77
nano/core_test/gap_cache.cpp
View file

@ -9,7 +9,15 @@ TEST (gap_cache, add_new)
{
nano::system system (1);
nano::gap_cache cache (*system.nodes[0]);
auto block1 (std::make_shared<nano::send_block> (0, 1, 2, nano::keypair ().prv, 4, 5));
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (0)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
cache.add (block1->hash ());
}
@ -17,7 +25,15 @@ TEST (gap_cache, add_existing)
{
nano::system system (1);
nano::gap_cache cache (*system.nodes[0]);
auto block1 (std::make_shared<nano::send_block> (0, 1, 2, nano::keypair ().prv, 4, 5));
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (0)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
cache.add (block1->hash ());
nano::unique_lock<nano::mutex> lock (cache.mutex);
auto existing1 (cache.blocks.get<1> ().find (block1->hash ()));
@ -37,7 +53,15 @@ TEST (gap_cache, comparison)
{
nano::system system (1);
nano::gap_cache cache (*system.nodes[0]);
auto block1 (std::make_shared<nano::send_block> (1, 0, 2, nano::keypair ().prv, 4, 5));
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (1)
.destination (0)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
cache.add (block1->hash ());
nano::unique_lock<nano::mutex> lock (cache.mutex);
auto existing1 (cache.blocks.get<1> ().find (block1->hash ()));
@ -45,7 +69,14 @@ TEST (gap_cache, comparison)
auto arrival (existing1->arrival);
lock.unlock ();
ASSERT_TIMELY (20s, std::chrono::steady_clock::now () != arrival);
auto block3 (std::make_shared<nano::send_block> (0, 42, 1, nano::keypair ().prv, 3, 4));
auto block3 = builder
.send ()
.previous (0)
.destination (42)
.balance (1)
.sign (nano::keypair ().prv, 3)
.work (4)
.build_shared ();
cache.add (block3->hash ());
ASSERT_EQ (2, cache.size ());
lock.lock ();
@ -67,7 +98,15 @@ TEST (gap_cache, gap_bootstrap)
auto & node2 (*system.nodes[1]);
nano::block_hash latest (node1.latest (nano::dev::genesis_key.pub));
nano::keypair key;
auto send (std::make_shared<nano::send_block> (latest, key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)));
nano::block_builder builder;
auto send = builder
.send ()
.previous (latest)
.destination (key.pub)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1.process (*send).code);
ASSERT_EQ (nano::dev::constants.genesis_amount - 100, node1.balance (nano::dev::genesis->account ()));
ASSERT_EQ (nano::dev::constants.genesis_amount, node2.balance (nano::dev::genesis->account ()));
@ -91,9 +130,31 @@ TEST (gap_cache, two_dependencies)
nano::system system (1);
auto & node1 (*system.nodes[0]);
nano::keypair key;
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
auto send2 (std::make_shared<nano::send_block> (send1->hash (), key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
auto open (std::make_shared<nano::open_block> (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
nano::block_builder builder;
auto send1 = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (key.pub)
.balance (1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto send2 = builder
.send ()
.previous (send1->hash ())
.destination (key.pub)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
auto open = builder
.open ()
.source (send1->hash ())
.representative (key.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (0, node1.gap_cache.size ());
node1.block_processor.add (send2);
node1.block_processor.flush ();

3988
nano/core_test/ledger.cpp
View file

File diff suppressed because it is too large Load diff

76
nano/core_test/message.cpp
View file

@ -45,7 +45,16 @@ TEST (message, keepalive_deserialize)
TEST (message, publish_serialization)
{
nano::publish publish{ nano::dev::network_params.network, std::make_shared<nano::send_block> (0, 1, 2, nano::keypair ().prv, 4, 5) };
nano::block_builder builder;
auto block = builder
.send ()
.previous (0)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
nano::publish publish{ nano::dev::network_params.network, block };
ASSERT_EQ (nano::block_type::send, publish.header.block_type ());
std::vector<uint8_t> bytes;
{
@ -79,8 +88,18 @@ TEST (message, confirm_ack_hash_serialization)
nano::keypair key1;
nano::block_hash previous;
nano::random_pool::generate_block (previous.bytes.data (), previous.bytes.size ());
nano::state_block block (key1.pub, previous, key1.pub, 2, 4, key1.prv, key1.pub, 5);
hashes.push_back (block.hash ());
nano::block_builder builder;
auto block = builder
.state ()
.account (key1.pub)
.previous (previous)
.representative (key1.pub)
.balance (2)
.link (4)
.sign (key1.prv, key1.pub)
.work (5)
.build ();
hashes.push_back (block->hash ());
}
nano::keypair representative1;
auto vote (std::make_shared<nano::vote> (representative1.pub, representative1.prv, 0, 0, hashes));
@ -106,7 +125,15 @@ TEST (message, confirm_req_serialization)
{
nano::keypair key1;
nano::keypair key2;
auto block (std::make_shared<nano::send_block> (0, key2.pub, 200, nano::keypair ().prv, 2, 3));
nano::block_builder builder;
auto block = builder
.send ()
.previous (0)
.destination (key2.pub)
.balance (200)
.sign (nano::keypair ().prv, 2)
.work (3)
.build_shared ();
nano::confirm_req req{ nano::dev::network_params.network, block };
std::vector<uint8_t> bytes;
{
@ -126,8 +153,16 @@ TEST (message, confirm_req_hash_serialization)
{
nano::keypair key1;
nano::keypair key2;
nano::send_block block (1, key2.pub, 200, nano::keypair ().prv, 2, 3);
nano::confirm_req req{ nano::dev::network_params.network, block.hash (), block.root () };
nano::block_builder builder;
auto block = builder
.send ()
.previous (1)
.destination (key2.pub)
.balance (200)
.sign (nano::keypair ().prv, 2)
.work (3)
.build ();
nano::confirm_req req{ nano::dev::network_params.network, block->hash (), block->root () };
std::vector<uint8_t> bytes;
{
nano::vectorstream stream (bytes);
@ -149,17 +184,36 @@ TEST (message, confirm_req_hash_batch_serialization)
nano::keypair key;
nano::keypair representative;
std::vector<std::pair<nano::block_hash, nano::root>> roots_hashes;
nano::state_block open (key.pub, 0, representative.pub, 2, 4, key.prv, key.pub, 5);
roots_hashes.push_back (std::make_pair (open.hash (), open.root ()));
nano::block_builder builder;
auto open = builder
.state ()
.account (key.pub)
.previous (0)
.representative (representative.pub)
.balance (2)
.link (4)
.sign (key.prv, key.pub)
.work (5)
.build ();
roots_hashes.push_back (std::make_pair (open->hash (), open->root ()));
for (auto i (roots_hashes.size ()); i < 7; i++)
{
nano::keypair key1;
nano::block_hash previous;
nano::random_pool::generate_block (previous.bytes.data (), previous.bytes.size ());
nano::state_block block (key1.pub, previous, representative.pub, 2, 4, key1.prv, key1.pub, 5);
roots_hashes.push_back (std::make_pair (block.hash (), block.root ()));
auto block = builder
.state ()
.account (key1.pub)
.previous (previous)
.representative (representative.pub)
.balance (2)
.link (4)
.sign (key1.prv, key1.pub)
.work (5)
.build ();
roots_hashes.push_back (std::make_pair (block->hash (), block->root ()));
}
roots_hashes.push_back (std::make_pair (open.hash (), open.root ()));
roots_hashes.push_back (std::make_pair (open->hash (), open->root ()));
nano::confirm_req req{ nano::dev::network_params.network, roots_hashes };
std::vector<uint8_t> bytes;
{

42
nano/core_test/message_parser.cpp
View file

@ -68,7 +68,15 @@ TEST (message_parser, exact_confirm_ack_size)
nano::block_uniquer block_uniquer;
nano::vote_uniquer vote_uniquer (block_uniquer);
nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, nano::dev::network_params.network);
auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))));
nano::block_builder builder;
auto block = builder
.send ()
.previous (1)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (*system.work.generate (nano::root (1)))
.build_shared ();
auto vote (std::make_shared<nano::vote> (0, nano::keypair ().prv, 0, 0, std::vector<nano::block_hash>{ block->hash () }));
nano::confirm_ack message{ nano::dev::network_params.network, vote };
std::vector<uint8_t> bytes;
@ -102,7 +110,15 @@ TEST (message_parser, exact_confirm_req_size)
nano::block_uniquer block_uniquer;
nano::vote_uniquer vote_uniquer (block_uniquer);
nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, nano::dev::network_params.network);
auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))));
nano::block_builder builder;
auto block = builder
.send ()
.previous (1)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (*system.work.generate (nano::root (1)))
.build_shared ();
nano::confirm_req message{ nano::dev::network_params.network, block };
std::vector<uint8_t> bytes;
{
@ -135,8 +151,16 @@ TEST (message_parser, exact_confirm_req_hash_size)
nano::block_uniquer block_uniquer;
nano::vote_uniquer vote_uniquer (block_uniquer);
nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, nano::dev::network_params.network);
nano::send_block block (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)));
nano::confirm_req message{ nano::dev::network_params.network, block.hash (), block.root () };
nano::block_builder builder;
auto block = builder
.send ()
.previous (1)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (*system.work.generate (nano::root (1)))
.build ();
nano::confirm_req message{ nano::dev::network_params.network, block->hash (), block->root () };
std::vector<uint8_t> bytes;
{
nano::vectorstream stream (bytes);
@ -168,7 +192,15 @@ TEST (message_parser, exact_publish_size)
nano::block_uniquer block_uniquer;
nano::vote_uniquer vote_uniquer (block_uniquer);
nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, nano::dev::network_params.network);
auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))));
nano::block_builder builder;
auto block = builder
.send ()
.previous (1)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (*system.work.generate (nano::root (1)))
.build_shared ();
nano::publish message{ nano::dev::network_params.network, block };
std::vector<uint8_t> bytes;
{

125
nano/core_test/network.cpp
View file

@ -220,7 +220,15 @@ TEST (network, send_discarded_publish)
nano::system system (2);
auto & node1 (*system.nodes[0]);
auto & node2 (*system.nodes[1]);
auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))));
nano::block_builder builder;
auto block = builder
.send ()
.previous (1)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (*system.work.generate (nano::root (1)))
.build_shared ();
{
auto transaction (node1.store.tx_begin_read ());
node1.network.flood_block (block);
@ -238,7 +246,15 @@ TEST (network, send_invalid_publish)
nano::system system (2);
auto & node1 (*system.nodes[0]);
auto & node2 (*system.nodes[1]);
auto block (std::make_shared<nano::send_block> (1, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::root (1))));
nano::block_builder builder;
auto block = builder
.send ()
.previous (1)
.destination (1)
.balance (20)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::root (1)))
.build_shared ();
{
auto transaction (node1.store.tx_begin_read ());
node1.network.flood_block (block);
@ -270,9 +286,17 @@ TEST (network, send_valid_confirm_ack)
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
system.wallet (1)->insert_adhoc (key2.prv);
nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub));
nano::send_block block2 (latest1, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1));
nano::block_builder builder;
auto block2 = builder
.send ()
.previous (latest1)
.destination (key2.pub)
.balance (50)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest1))
.build ();
nano::block_hash latest2 (node2.latest (nano::dev::genesis_key.pub));
node1.process_active (std::make_shared<nano::send_block> (block2));
node1.process_active (std::make_shared<nano::send_block> (*block2));
// Keep polling until latest block changes
ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) != latest2);
// Make sure the balance has decreased after processing the block.
@ -301,10 +325,18 @@ TEST (network, send_valid_publish)
nano::keypair key2;
system.wallet (1)->insert_adhoc (key2.prv);
nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub));
nano::send_block block2 (latest1, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1));
auto hash2 (block2.hash ());
nano::block_builder builder;
auto block2 = builder
.send ()
.previous (latest1)
.destination (key2.pub)
.balance (50)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest1))
.build ();
auto hash2 (block2->hash ());
nano::block_hash latest2 (node2.latest (nano::dev::genesis_key.pub));
node2.process_active (std::make_shared<nano::send_block> (block2));
node2.process_active (std::make_shared<nano::send_block> (*block2));
ASSERT_TIMELY (10s, node1.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
ASSERT_NE (hash2, latest2);
ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) != latest2);
@ -319,7 +351,15 @@ TEST (network, send_insufficient_work_udp)
node_flags.disable_udp = false;
auto & node1 = *system.add_node (node_flags);
auto & node2 = *system.add_node (node_flags);
auto block (std::make_shared<nano::send_block> (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
nano::block_builder builder;
auto block = builder
.send ()
.previous (0)
.destination (1)
.balance (20)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
nano::publish publish{ nano::dev::network_params.network, block };
nano::transport::channel_udp channel (node1.network.udp_channels, node2.network.endpoint (), node1.network_params.network.protocol_version);
channel.send (publish, [] (boost::system::error_code const & ec, size_t size) {});
@ -334,7 +374,15 @@ TEST (network, send_insufficient_work)
auto & node1 = *system.nodes[0];
auto & node2 = *system.nodes[1];
// Block zero work
auto block1 (std::make_shared<nano::send_block> (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (0)
.destination (1)
.balance (20)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
nano::publish publish1{ nano::dev::network_params.network, block1 };
auto tcp_channel (node1.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node2.network.endpoint ())));
tcp_channel->send (publish1, [] (boost::system::error_code const & ec, size_t size) {});
@ -342,20 +390,43 @@ TEST (network, send_insufficient_work)
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
// Legacy block work between epoch_2_recieve & epoch_1
auto block2 (std::make_shared<nano::send_block> (block1->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1)));
auto block2 = builder
.send ()
.previous (block1->hash ())
.destination (1)
.balance (20)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))
.build_shared ();
nano::publish publish2{ nano::dev::network_params.network, block2 };
tcp_channel->send (publish2, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 1);
ASSERT_EQ (2, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
// Legacy block work epoch_1
auto block3 (std::make_shared<nano::send_block> (block2->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.work.epoch_2)));
auto block3 = builder
.send ()
.previous (block2->hash ())
.destination (1)
.balance (20)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (block2->hash (), node1.network_params.work.epoch_2))
.build_shared ();
nano::publish publish3{ nano::dev::network_params.network, block3 };
tcp_channel->send (publish3, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_EQ (0, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
// State block work epoch_2_recieve
auto block4 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, block1->hash (), nano::dev::genesis_key.pub, 20, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1)));
auto block4 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (block1->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (20)
.link (1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))
.build_shared ();
nano::publish publish4{ nano::dev::network_params.network, block4 };
tcp_channel->send (publish4, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
@ -367,7 +438,15 @@ TEST (receivable_processor, confirm_insufficient_pos)
{
nano::system system (1);
auto & node1 (*system.nodes[0]);
auto block1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (0)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1.work_generate_blocking (*block1);
ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code);
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
@ -381,7 +460,15 @@ TEST (receivable_processor, confirm_sufficient_pos)
{
nano::system system (1);
auto & node1 (*system.nodes[0]);
auto block1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (0)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1.work_generate_blocking (*block1);
ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code);
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
@ -410,7 +497,15 @@ TEST (receivable_processor, send_with_receive)
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub));
system.wallet (1)->insert_adhoc (key2.prv);
auto block1 (std::make_shared<nano::send_block> (latest1, key2.pub, amount - node1.config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1)));
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (latest1)
.destination (key2.pub)
.balance (amount - node1.config.receive_minimum.number ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest1))
.build_shared ();
ASSERT_EQ (amount, node1.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (0, node1.balance (key2.pub));
ASSERT_EQ (amount, node2.balance (nano::dev::genesis_key.pub));

38
nano/core_test/node.cpp
View file

@ -1140,10 +1140,20 @@ TEST (node, fork_no_vote_quorum)
ASSERT_EQ (node1.config.receive_minimum.number (), node1.weight (key1));
ASSERT_EQ (node1.config.receive_minimum.number (), node2.weight (key1));
ASSERT_EQ (node1.config.receive_minimum.number (), node3.weight (key1));
nano::state_block send1 (nano::dev::genesis_key.pub, block->hash (), nano::dev::genesis_key.pub, (nano::dev::constants.genesis_amount / 4) - (node1.config.receive_minimum.number () * 2), key1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (block->hash ()));
ASSERT_EQ (nano::process_result::progress, node1.process (send1).code);
ASSERT_EQ (nano::process_result::progress, node2.process (send1).code);
ASSERT_EQ (nano::process_result::progress, node3.process (send1).code);
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (block->hash ())
.representative (nano::dev::genesis_key.pub)
.balance ((nano::dev::constants.genesis_amount / 4) - (node1.config.receive_minimum.number () * 2))
.link (key1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (block->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
ASSERT_EQ (nano::process_result::progress, node2.process (*send1).code);
ASSERT_EQ (nano::process_result::progress, node3.process (*send1).code);
auto key2 (system.wallet (2)->deterministic_insert ());
auto send2 = nano::send_block_builder ()
.previous (block->hash ())
@ -1166,9 +1176,9 @@ TEST (node, fork_no_vote_quorum)
ASSERT_NE (nullptr, channel);
channel->send_buffer (nano::shared_const_buffer (std::move (buffer)));
ASSERT_TIMELY (10s, node3.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::in) >= 3);
ASSERT_TRUE (node1.latest (nano::dev::genesis_key.pub) == send1.hash ());
ASSERT_TRUE (node2.latest (nano::dev::genesis_key.pub) == send1.hash ());
ASSERT_TRUE (node3.latest (nano::dev::genesis_key.pub) == send1.hash ());
ASSERT_TRUE (node1.latest (nano::dev::genesis_key.pub) == send1->hash ());
ASSERT_TRUE (node2.latest (nano::dev::genesis_key.pub) == send1->hash ());
ASSERT_TRUE (node3.latest (nano::dev::genesis_key.pub) == send1->hash ());
}
// Disabled because it sometimes takes way too long (but still eventually finishes)
@ -1508,16 +1518,24 @@ TEST (node, DISABLED_bootstrap_no_publish)
auto node1 (system1.nodes[0]);
nano::keypair key0;
// node0 knows about send0 but node1 doesn't.
nano::send_block send0 (node0->latest (nano::dev::genesis_key.pub), key0.pub, 500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
nano::block_builder builder;
auto send0 = builder
.send ()
.previous (node0->latest (nano::dev::genesis_key.pub))
.destination (key0.pub)
.balance (500)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build ();
{
auto transaction (node0->store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, send0).code);
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *send0).code);
}
ASSERT_FALSE (node1->bootstrap_initiator.in_progress ());
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_TRUE (node1->active.empty ());
system1.deadline_set (10s);
while (node1->block (send0.hash ()) == nullptr)
while (node1->block (send0->hash ()) == nullptr)
{
// Poll until the TCP connection is torn down and in_progress goes false
system0.poll ();

60
nano/core_test/prioritization.cpp
View file

@ -32,27 +32,77 @@ nano::keypair & key3 ()
}
std::shared_ptr<nano::state_block> & blockzero ()
{
static std::shared_ptr<nano::state_block> result = std::make_shared<nano::state_block> (keyzero ().pub, 0, keyzero ().pub, 0, 0, keyzero ().prv, keyzero ().pub, 0);
nano::block_builder builder;
static auto result = builder
.state ()
.account (keyzero ().pub)
.previous (0)
.representative (keyzero ().pub)
.balance (0)
.link (0)
.sign (keyzero ().prv, keyzero ().pub)
.work (0)
.build_shared ();
return result;
}
std::shared_ptr<nano::state_block> & block0 ()
{
static std::shared_ptr<nano::state_block> result = std::make_shared<nano::state_block> (key0 ().pub, 0, key0 ().pub, nano::Gxrb_ratio, 0, key0 ().prv, key0 ().pub, 0);
nano::block_builder builder;
static auto result = builder
.state ()
.account (key0 ().pub)
.previous (0)
.representative (key0 ().pub)
.balance (nano::Gxrb_ratio)
.link (0)
.sign (key0 ().prv, key0 ().pub)
.work (0)
.build_shared ();
return result;
}
std::shared_ptr<nano::state_block> & block1 ()
{
static std::shared_ptr<nano::state_block> result = std::make_shared<nano::state_block> (key1 ().pub, 0, key1 ().pub, nano::Mxrb_ratio, 0, key1 ().prv, key1 ().pub, 0);
nano::block_builder builder;
static auto result = builder
.state ()
.account (key1 ().pub)
.previous (0)
.representative (key1 ().pub)
.balance (nano::Mxrb_ratio)
.link (0)
.sign (key1 ().prv, key1 ().pub)
.work (0)
.build_shared ();
return result;
}
std::shared_ptr<nano::state_block> & block2 ()
{
static std::shared_ptr<nano::state_block> result = std::make_shared<nano::state_block> (key2 ().pub, 0, key2 ().pub, nano::Gxrb_ratio, 0, key2 ().prv, key2 ().pub, 0);
nano::block_builder builder;
static auto result = builder
.state ()
.account (key2 ().pub)
.previous (0)
.representative (key2 ().pub)
.balance (nano::Gxrb_ratio)
.link (0)
.sign (key2 ().prv, key2 ().pub)
.work (0)
.build_shared ();
return result;
}
std::shared_ptr<nano::state_block> & block3 ()
{
static std::shared_ptr<nano::state_block> result = std::make_shared<nano::state_block> (key3 ().pub, 0, key3 ().pub, nano::Mxrb_ratio, 0, key3 ().prv, key3 ().pub, 0);
nano::block_builder builder;
static auto result = builder
.state ()
.account (key3 ().pub)
.previous (0)
.representative (key3 ().pub)
.balance (nano::Mxrb_ratio)
.link (0)
.sign (key3 ().prv, key3 ().pub)
.work (0)
.build_shared ();
return result;
}

40
nano/core_test/processor_service.cpp
View file

@ -20,9 +20,17 @@ TEST (processor_service, bad_send_signature)
nano::account_info info1;
ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1));
nano::keypair key2;
nano::send_block send (info1.head, nano::dev::genesis_key.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head));
send.signature.bytes[32] ^= 0x1;
ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, send).code);
nano::block_builder builder;
auto send = builder
.send ()
.previous (info1.head)
.destination (nano::dev::genesis_key.pub)
.balance (50)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (info1.head))
.build ();
send->signature.bytes[32] ^= 0x1;
ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, *send).code);
}
TEST (processor_service, bad_receive_signature)
@ -37,12 +45,26 @@ TEST (processor_service, bad_receive_signature)
nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
nano::account_info info1;
ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1));
nano::send_block send (info1.head, nano::dev::genesis_key.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head));
nano::block_hash hash1 (send.hash ());
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
nano::block_builder builder;
auto send = builder
.send ()
.previous (info1.head)
.destination (nano::dev::genesis_key.pub)
.balance (50)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (info1.head))
.build ();
nano::block_hash hash1 (send->hash ());
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
nano::account_info info2;
ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info2));
nano::receive_block receive (hash1, hash1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (hash1));
receive.signature.bytes[32] ^= 0x1;
ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, receive).code);
auto receive = builder
.receive ()
.previous (hash1)
.source (hash1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (hash1))
.build ();
receive->signature.bytes[32] ^= 0x1;
ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, *receive).code);
}

72
nano/core_test/request_aggregator.cpp
View file

@ -14,7 +14,17 @@ TEST (request_aggregator, one)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node (*system.add_node (node_config));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ());
auto channel (node.network.udp_channels.create (node.network.endpoint ()));
@ -190,7 +200,17 @@ TEST (request_aggregator, two_endpoints)
node_config.peering_port = nano::get_available_port ();
auto & node2 (*system.add_node (node_config, node_flags));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 1, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1.work_generate_blocking (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - 1)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ());
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code);
@ -274,7 +294,17 @@ TEST (request_aggregator, channel_lifetime)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node (*system.add_node (node_config));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ());
@ -294,7 +324,17 @@ TEST (request_aggregator, channel_update)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node (*system.add_node (node_config));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ());
@ -322,7 +362,17 @@ TEST (request_aggregator, channel_max_queue)
node_config.max_queued_requests = 1;
auto & node (*system.add_node (node_config));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ());
@ -339,7 +389,17 @@ TEST (request_aggregator, unique)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node (*system.add_node (node_config));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ());

95
nano/core_test/signing.cpp
View file

@ -13,7 +13,17 @@ TEST (signature_checker, empty)
TEST (signature_checker, bulk_single_thread)
{
nano::keypair key;
nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0);
nano::block_builder builder;
auto block = builder
.state ()
.account (key.pub)
.previous (0)
.representative (key.pub)
.balance (0)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build ();
nano::signature_checker checker (0);
std::vector<nano::uint256_union> hashes;
size_t size (1000);
@ -30,11 +40,11 @@ TEST (signature_checker, bulk_single_thread)
verifications.resize (size);
for (auto i (0); i < size; ++i)
{
hashes.push_back (block.hash ());
hashes.push_back (block->hash ());
messages.push_back (hashes.back ().bytes.data ());
lengths.push_back (sizeof (decltype (hashes)::value_type));
pub_keys.push_back (block.hashables.account.bytes.data ());
signatures.push_back (block.signature.bytes.data ());
pub_keys.push_back (block->hashables.account.bytes.data ());
signatures.push_back (block->signature.bytes.data ());
}
nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
checker.verify (check);
@ -48,12 +58,31 @@ TEST (signature_checker, many_multi_threaded)
auto signature_checker_work_func = [&checker] () {
nano::keypair key;
nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0);
auto block_hash = block.hash ();
nano::block_builder builder;
auto block = builder
.state ()
.account (key.pub)
.previous (0)
.representative (key.pub)
.balance (0)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build ();
auto block_hash = block->hash ();
nano::state_block invalid_block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0);
invalid_block.signature.bytes[31] ^= 0x1;
auto invalid_block_hash = block.hash ();
auto invalid_block = builder
.state ()
.account (key.pub)
.previous (0)
.representative (key.pub)
.balance (0)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build ();
invalid_block->signature.bytes[31] ^= 0x1;
auto invalid_block_hash = block->hash ();
constexpr auto num_check_sizes = 18;
constexpr std::array<size_t, num_check_sizes> check_sizes{ 2048, 256, 1024, 1,
@ -84,12 +113,12 @@ TEST (signature_checker, many_multi_threaded)
std::fill (lengths[i].begin (), lengths[i].end (), sizeof (decltype (block_hash)));
pub_keys[i].resize (check_size);
std::fill (pub_keys[i].begin (), pub_keys[i].end (), block.hashables.account.bytes.data ());
pub_keys[i][last_signature_index] = invalid_block.hashables.account.bytes.data ();
std::fill (pub_keys[i].begin (), pub_keys[i].end (), block->hashables.account.bytes.data ());
pub_keys[i][last_signature_index] = invalid_block->hashables.account.bytes.data ();
signatures[i].resize (check_size);
std::fill (signatures[i].begin (), signatures[i].end (), block.signature.bytes.data ());
signatures[i][last_signature_index] = invalid_block.signature.bytes.data ();
std::fill (signatures[i].begin (), signatures[i].end (), block->signature.bytes.data ());
signatures[i][last_signature_index] = invalid_block->signature.bytes.data ();
verifications[i].resize (check_size);
@ -125,11 +154,11 @@ TEST (signature_checker, one)
verifications.resize (size);
for (auto i (0); i < size; ++i)
{
hashes.push_back (block.hash ());
hashes.push_back (block->hash ());
messages.push_back (hashes.back ().bytes.data ());
lengths.push_back (sizeof (decltype (hashes)::value_type));
pub_keys.push_back (block.hashables.account.bytes.data ());
signatures.push_back (block.signature.bytes.data ());
pub_keys.push_back (block->hashables.account.bytes.data ());
signatures.push_back (block->signature.bytes.data ());
}
nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
checker.verify (check);
@ -137,14 +166,24 @@ TEST (signature_checker, one)
};
nano::keypair key;
nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0);
nano::block_builder builder;
auto block = builder
.state ()
.account (key.pub)
.previous (0)
.representative (key.pub)
.balance (0)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build ();
// Make signaure invalid and check result is incorrect
block.signature.bytes[31] ^= 0x1;
block->signature.bytes[31] ^= 0x1;
verify_block (block, 0);
// Make it valid and check for succcess
block.signature.bytes[31] ^= 0x1;
block->signature.bytes[31] ^= 0x1;
verify_block (block, 1);
}
@ -174,7 +213,17 @@ TEST (signature_checker, boundary_checks)
std::vector<unsigned char const *> signatures;
signatures.reserve (max_size);
nano::keypair key;
nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0);
nano::block_builder builder;
auto block = builder
.state ()
.account (key.pub)
.previous (0)
.representative (key.pub)
.balance (0)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build ();
size_t last_size = 0;
for (auto size : sizes)
@ -186,11 +235,11 @@ TEST (signature_checker, boundary_checks)
verifications.resize (size);
for (auto i (0); i < extra_size; ++i)
{
hashes.push_back (block.hash ());
hashes.push_back (block->hash ());
messages.push_back (hashes.back ().bytes.data ());
lengths.push_back (sizeof (decltype (hashes)::value_type));
pub_keys.push_back (block.hashables.account.bytes.data ());
signatures.push_back (block.signature.bytes.data ());
pub_keys.push_back (block->hashables.account.bytes.data ());
signatures.push_back (block->signature.bytes.data ());
}
nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
checker.verify (check);

20
nano/core_test/system.cpp
View file

@ -52,7 +52,15 @@ TEST (system, DISABLED_generate_send_existing)
// Have stake_preserver receive funds after generate_send_existing so it isn't chosen as the destination
{
auto transaction (node1.store.tx_begin_write ());
auto open_block (std::make_shared<nano::open_block> (send_block->hash (), nano::dev::genesis->account (), stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0));
nano::block_builder builder;
auto open_block = builder
.open ()
.source (send_block->hash ())
.representative (nano::dev::genesis->account ())
.account (stake_preserver.pub)
.sign (stake_preserver.prv, stake_preserver.pub)
.work (0)
.build_shared ();
node1.work_generate_blocking (*open_block);
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code);
}
@ -97,7 +105,15 @@ TEST (system, DISABLED_generate_send_new)
auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true));
{
auto transaction (node1.store.tx_begin_write ());
auto open_block (std::make_shared<nano::open_block> (send_block->hash (), nano::dev::genesis->account (), stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0));
nano::block_builder builder;
auto open_block = builder
.open ()
.source (send_block->hash ())
.representative (nano::dev::genesis->account ())
.account (stake_preserver.pub)
.sign (stake_preserver.prv, stake_preserver.pub)
.work (0)
.build_shared ();
node1.work_generate_blocking (*open_block);
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code);
}

10
nano/core_test/unchecked_map.cpp
View file

@ -60,7 +60,15 @@ TEST (block_store, one_bootstrap)
auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants);
nano::unchecked_map unchecked{ *store, false };
ASSERT_TRUE (!store->init_error ());
auto block1 = std::make_shared<nano::send_block> (0, 1, 2, nano::keypair ().prv, 4, 5);
nano::block_builder builder;
auto block1 = builder
.send ()
.previous (0)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
unchecked.put (block1->hash (), nano::unchecked_info{ block1 });
auto check_block_is_listed = [&] (nano::transaction const & transaction_a, nano::block_hash const & block_hash_a) {
return unchecked.get (transaction_a, block_hash_a).size () > 0;

12
nano/core_test/wallet.cpp
View file

@ -1112,8 +1112,16 @@ TEST (wallet, epoch_2_receive_unopened)
auto send1 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1);
// Upgrade unopened account to epoch_2
auto epoch2_unopened = nano::state_block (key.pub, 0, 0, 0, node.network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (key.pub, node.network_params.work.epoch_2));
ASSERT_EQ (nano::process_result::progress, node.process (epoch2_unopened).code);
auto epoch2_unopened = builder
.account (key.pub)
.previous (0)
.representative (0)
.balance (0)
.link (node.network_params.ledger.epochs.link (nano::epoch::epoch_2))
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (key.pub, node.network_params.work.epoch_2))
.build ();
ASSERT_EQ (nano::process_result::progress, node.process (*epoch2_unopened).code);
wallet.insert_adhoc (key.prv, false);

53
nano/core_test/wallets.cpp
View file

@ -97,15 +97,52 @@ TEST (wallets, vote_minimum)
auto & node1 (*system.nodes[0]);
nano::keypair key1;
nano::keypair key2;
nano::state_block send1 (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - node1.config.vote_minimum.number (), key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()));
ASSERT_EQ (nano::process_result::progress, node1.process (send1).code);
nano::state_block open1 (key1.pub, 0, key1.pub, node1.config.vote_minimum.number (), send1.hash (), key1.prv, key1.pub, *system.work.generate (key1.pub));
ASSERT_EQ (nano::process_result::progress, node1.process (open1).code);
nano::block_builder builder;
auto send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (std::numeric_limits<nano::uint128_t>::max () - node1.config.vote_minimum.number ())
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
auto open1 = builder
.state ()
.account (key1.pub)
.previous (0)
.representative (key1.pub)
.balance (node1.config.vote_minimum.number ())
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, node1.process (*open1).code);
// send2 with amount vote_minimum - 1 (not voting representative)
nano::state_block send2 (nano::dev::genesis_key.pub, send1.hash (), nano::dev::genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - 2 * node1.config.vote_minimum.number () + 1, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
ASSERT_EQ (nano::process_result::progress, node1.process (send2).code);
nano::state_block open2 (key2.pub, 0, key2.pub, node1.config.vote_minimum.number () - 1, send2.hash (), key2.prv, key2.pub, *system.work.generate (key2.pub));
ASSERT_EQ (nano::process_result::progress, node1.process (open2).code);
auto send2 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (std::numeric_limits<nano::uint128_t>::max () - 2 * node1.config.vote_minimum.number () + 1)
.link (key2.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code);
auto open2 = builder
.state ()
.account (key2.pub)
.previous (0)
.representative (key2.pub)
.balance (node1.config.vote_minimum.number () - 1)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, node1.process (*open2).code);
auto wallet (node1.wallets.items.begin ()->second);
nano::unique_lock<nano::mutex> representatives_lk (wallet->representatives_mutex);
ASSERT_EQ (0, wallet->representatives.size ());

30
nano/core_test/websocket.cpp
View file

@ -89,7 +89,15 @@ TEST (websocket, confirmation)
{
nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub));
balance -= send_amount;
auto send (std::make_shared<nano::send_block> (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous)));
nano::block_builder builder;
auto send = builder
.send ()
.previous (previous)
.destination (key.pub)
.balance (balance)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
node1->process_active (send);
}
@ -140,7 +148,15 @@ TEST (websocket, stopped_election)
// Create election, then erase it, causing a websocket message to be emitted
nano::keypair key1;
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
nano::block_builder builder;
auto send1 = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (key1.pub)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
nano::publish publish1{ nano::dev::network_params.network, send1 };
auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ()));
node1->network.inbound (publish1, channel1);
@ -287,7 +303,15 @@ TEST (websocket, confirmation_options)
// When filtering options are enabled, legacy blocks are always filtered
{
balance -= send_amount;
auto send (std::make_shared<nano::send_block> (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous)));
nano::block_builder builder;
auto send = builder
.send ()
.previous (previous)
.destination (key.pub)
.balance (balance)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
node1->process_active (send);
previous = send->hash ();
}

29
nano/core_test/work_pool.cpp
View file

@ -16,9 +16,16 @@
TEST (work, one)
{
nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
nano::change_block block (1, 1, nano::keypair ().prv, 3, 4);
block.block_work_set (*pool.generate (block.root ()));
ASSERT_LT (nano::dev::network_params.work.threshold_base (block.work_version ()), nano::dev::network_params.work.difficulty (block));
nano::block_builder builder;
auto block = builder
.change ()
.previous (1)
.representative (1)
.sign (nano::keypair ().prv, 3)
.work (4)
.build ();
block->block_work_set (*pool.generate (block->root ()));
ASSERT_LT (nano::dev::network_params.work.threshold_base (block->work_version ()), nano::dev::network_params.work.difficulty (*block));
}
TEST (work, disabled)
@ -31,10 +38,18 @@ TEST (work, disabled)
TEST (work, validate)
{
nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
nano::send_block send_block (1, 1, 2, nano::keypair ().prv, 4, 6);
ASSERT_LT (nano::dev::network_params.work.difficulty (send_block), nano::dev::network_params.work.threshold_base (send_block.work_version ()));
send_block.block_work_set (*pool.generate (send_block.root ()));
ASSERT_LT (nano::dev::network_params.work.threshold_base (send_block.work_version ()), nano::dev::network_params.work.difficulty (send_block));
nano::block_builder builder;
auto send_block = builder
.send ()
.previous (1)
.destination (1)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (6)
.build ();
ASSERT_LT (nano::dev::network_params.work.difficulty (*send_block), nano::dev::network_params.work.threshold_base (send_block->work_version ()));
send_block->block_work_set (*pool.generate (send_block->root ()));
ASSERT_LT (nano::dev::network_params.work.threshold_base (send_block->work_version ()), nano::dev::network_params.work.difficulty (*send_block));
}
TEST (work, cancel)

12
nano/nano_node/entry.cpp
View file

@ -889,12 +889,20 @@ int main (int argc, char * const * argv)
while (true)
{
nano::keypair key;
nano::block_builder builder;
nano::block_hash latest (0);
auto begin1 (std::chrono::high_resolution_clock::now ());
for (uint64_t balance (0); balance < 1000; ++balance)
{
nano::send_block send (latest, key.pub, balance, key.prv, key.pub, 0);
latest = send.hash ();
auto send = builder
.send ()
.previous (latest)
.destination (key.pub)
.balance (balance)
.sign (key.prv, key.pub)
.work (0)
.build ();
latest = send->hash ();
}
auto end1 (std::chrono::high_resolution_clock::now ());
std::cerr << boost::str (boost::format ("%|1$ 12d|\n") % std::chrono::duration_cast<std::chrono::microseconds> (end1 - begin1).count ());

1318
nano/rpc_test/rpc.cpp
View file

File diff suppressed because it is too large Load diff

487
nano/slow_test/node.cpp
View file

@ -124,21 +124,49 @@ TEST (ledger, deep_account_compute)
nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
nano::keypair key;
auto balance (nano::dev::constants.genesis_amount - 1);
nano::send_block send (nano::dev::genesis->hash (), key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *pool.generate (key.pub));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code);
auto sprevious (send.hash ());
auto rprevious (open.hash ());
nano::block_builder builder;
auto send = builder
.send ()
.previous (nano::dev::genesis->hash ())
.destination (key.pub)
.balance (balance)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
auto open = builder
.open ()
.source (send->hash ())
.representative (nano::dev::genesis_key.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*pool.generate (key.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code);
auto sprevious (send->hash ());
auto rprevious (open->hash ());
for (auto i (0), n (100000); i != n; ++i)
{
balance -= 1;
nano::send_block send (sprevious, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (sprevious));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
sprevious = send.hash ();
nano::receive_block receive (rprevious, send.hash (), key.prv, key.pub, *pool.generate (rprevious));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code);
rprevious = receive.hash ();
auto send = builder
.send ()
.previous (sprevious)
.destination (key.pub)
.balance (balance)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (sprevious))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
sprevious = send->hash ();
auto receive = builder
.receive ()
.previous (rprevious)
.source (send->hash ())
.sign (key.prv, key.pub)
.work (*pool.generate (rprevious))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code);
rprevious = receive->hash ();
if (i % 100 == 0)
{
std::cerr << i << ' ';
@ -227,19 +255,34 @@ TEST (node, fork_storm)
auto previous (system.nodes[0]->latest (nano::dev::genesis_key.pub));
auto balance (system.nodes[0]->balance (nano::dev::genesis_key.pub));
ASSERT_FALSE (previous.is_zero ());
nano::block_builder builder;
for (auto node_j : system.nodes)
{
balance -= 1;
nano::keypair key;
nano::send_block send (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
node_j->work_generate_blocking (send);
previous = send.hash ();
auto send = builder
.send ()
.previous (previous)
.destination (key.pub)
.balance (balance)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build ();
node_j->work_generate_blocking (*send);
previous = send->hash ();
for (auto node_i : system.nodes)
{
auto send_result (node_i->process (send));
auto send_result (node_i->process (*send));
ASSERT_EQ (nano::process_result::progress, send_result.code);
nano::keypair rep;
auto open (std::make_shared<nano::open_block> (previous, rep.pub, key.pub, key.prv, key.pub, 0));
auto open = builder
.open ()
.source (previous)
.representative (rep.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
node_i->work_generate_blocking (*open);
auto open_result (node_i->process (*open));
ASSERT_EQ (nano::process_result::progress, open_result.code);
@ -450,7 +493,15 @@ TEST (store, unchecked_load)
{
nano::system system{ 1 };
auto & node = *system.nodes[0];
std::shared_ptr<nano::block> block = std::make_shared<nano::send_block> (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
nano::block_builder builder;
std::shared_ptr<nano::block> block = builder
.send ()
.previous (0)
.destination (0)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
constexpr auto num_unchecked = 1'000'000;
for (auto i (0); i < num_unchecked; ++i)
{
@ -549,9 +600,19 @@ TEST (node, mass_vote_by_hash)
nano::block_hash previous (nano::dev::genesis->hash ());
nano::keypair key;
std::vector<std::shared_ptr<nano::state_block>> blocks;
nano::block_builder builder;
for (auto i (0); i < 10000; ++i)
{
auto block (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, previous, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - (i + 1) * nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous)));
auto block = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - (i + 1) * nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
previous = block->hash ();
blocks.push_back (block);
}
@ -576,6 +637,7 @@ TEST (confirmation_height, many_accounts_single_confirmation)
node->confirmation_height_processor.batch_write_size = 500;
auto const num_accounts = nano::confirmation_height::unbounded_cutoff * 2 + 50;
nano::keypair last_keypair = nano::dev::genesis_key;
nano::block_builder builder;
auto last_open_hash = node->latest (nano::dev::genesis_key.pub);
{
auto transaction = node->store.tx_begin_write ();
@ -584,11 +646,25 @@ TEST (confirmation_height, many_accounts_single_confirmation)
nano::keypair key;
system.wallet (0)->insert_adhoc (key.prv);
nano::send_block send (last_open_hash, key.pub, node->online_reps.delta (), last_keypair.prv, last_keypair.pub, *system.work.generate (last_open_hash));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
nano::open_block open (send.hash (), last_keypair.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code);
last_open_hash = open.hash ();
auto send = builder
.send ()
.previous (last_open_hash)
.destination (key.pub)
.balance (node->online_reps.delta ())
.sign (last_keypair.prv, last_keypair.pub)
.work (*system.work.generate (last_open_hash))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
auto open = builder
.open ()
.source (send->hash ())
.representative (last_keypair.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
last_open_hash = open->hash ();
last_keypair = key;
}
}
@ -645,6 +721,7 @@ TEST (confirmation_height, many_accounts_many_confirmations)
node->confirmation_height_processor.batch_write_size = 500;
auto const num_accounts = nano::confirmation_height::unbounded_cutoff * 2 + 50;
auto latest_genesis = node->latest (nano::dev::genesis_key.pub);
nano::block_builder builder;
std::vector<std::shared_ptr<nano::open_block>> open_blocks;
{
auto transaction = node->store.tx_begin_write ();
@ -653,12 +730,26 @@ TEST (confirmation_height, many_accounts_many_confirmations)
nano::keypair key;
system.wallet (0)->insert_adhoc (key.prv);
nano::send_block send (latest_genesis, key.pub, node->online_reps.delta (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
auto open = std::make_shared<nano::open_block> (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
auto send = builder
.send ()
.previous (latest_genesis)
.destination (key.pub)
.balance (node->online_reps.delta ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
auto open = builder
.open ()
.source (send->hash ())
.representative (nano::dev::genesis_key.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
open_blocks.push_back (std::move (open));
latest_genesis = send.hash ();
latest_genesis = send->hash ();
}
}
@ -709,45 +800,98 @@ TEST (confirmation_height, long_chains)
node->confirmation_height_processor.batch_write_size = 500;
auto const num_blocks = nano::confirmation_height::unbounded_cutoff * 2 + 50;
nano::block_builder builder;
// First open the other account
nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio + num_blocks + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
auto send = builder
.send ()
.previous (latest)
.destination (key1.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio + num_blocks + 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build ();
auto open = builder
.open ()
.source (send->hash ())
.representative (nano::dev::genesis->account ())
.account (key1.pub)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
}
// Bulk send from genesis account to destination account
auto previous_genesis_chain_hash = send.hash ();
auto previous_destination_chain_hash = open.hash ();
auto previous_genesis_chain_hash = send->hash ();
auto previous_destination_chain_hash = open->hash ();
{
auto transaction = node->store.tx_begin_write ();
for (auto i = num_blocks - 1; i > 0; --i)
{
nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio + i + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
nano::receive_block receive (previous_destination_chain_hash, send.hash (), key1.prv, key1.pub, *system.work.generate (previous_destination_chain_hash));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive).code);
auto send = builder
.send ()
.previous (previous_genesis_chain_hash)
.destination (key1.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio + i + 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous_genesis_chain_hash))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
auto receive = builder
.receive ()
.previous (previous_destination_chain_hash)
.source (send->hash ())
.sign (key1.prv, key1.pub)
.work (*system.work.generate (previous_destination_chain_hash))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive).code);
previous_genesis_chain_hash = send.hash ();
previous_destination_chain_hash = receive.hash ();
previous_genesis_chain_hash = send->hash ();
previous_destination_chain_hash = receive->hash ();
}
}
// Send one from destination to genesis and pocket it
nano::send_block send1 (previous_destination_chain_hash, nano::dev::genesis_key.pub, nano::Gxrb_ratio - 2, key1.prv, key1.pub, *system.work.generate (previous_destination_chain_hash));
auto receive1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, previous_genesis_chain_hash, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio + 1, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash)));
auto send1 = builder
.send ()
.previous (previous_destination_chain_hash)
.destination (nano::dev::genesis_key.pub)
.balance (nano::Gxrb_ratio - 2)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (previous_destination_chain_hash))
.build ();
auto receive1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (previous_genesis_chain_hash)
.representative (nano::dev::genesis->account ())
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio + 1)
.link (send1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous_genesis_chain_hash))
.build_shared ();
// Unpocketed. Send to a non-existing account to prevent auto receives from the wallet adjusting expected confirmation height
nano::keypair key2;
nano::state_block send2 (nano::dev::genesis->account (), receive1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1->hash ()));
auto send2 = builder
.state ()
.account (nano::dev::genesis->account ())
.previous (receive1->hash ())
.representative (nano::dev::genesis->account ())
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.link (key2.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (receive1->hash ()))
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code);
}
// Call block confirm on the existing receive block on the genesis account which will confirm everything underneath on both accounts
@ -799,9 +943,19 @@ TEST (confirmation_height, dynamic_algorithm)
auto const num_blocks = nano::confirmation_height::unbounded_cutoff;
auto latest_genesis = nano::dev::genesis;
std::vector<std::shared_ptr<nano::state_block>> state_blocks;
nano::block_builder builder;
for (auto i = 0; i < num_blocks; ++i)
{
auto send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest_genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - i - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis->hash ())));
auto send = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (latest_genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - i - 1)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis->hash ()))
.build_shared ();
latest_genesis = send;
state_blocks.push_back (send);
}
@ -857,7 +1011,17 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending)
auto add_block_to_genesis_chain = [&] (nano::write_transaction & transaction) {
static int num = 0;
auto send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest_genesis, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - num - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis)));
nano::block_builder builder;
auto send = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (latest_genesis)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - num - 1)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build_shared ();
latest_genesis = send->hash ();
state_blocks.push_back (send);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
@ -928,6 +1092,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
auto latest_genesis = node->latest (nano::dev::genesis_key.pub);
std::vector<nano::keypair> keys;
nano::block_builder builder;
std::vector<std::shared_ptr<nano::open_block>> open_blocks;
{
auto transaction = node->store.tx_begin_write ();
@ -936,12 +1101,26 @@ TEST (confirmation_height, many_accounts_send_receive_self)
nano::keypair key;
keys.emplace_back (key);
nano::send_block send (latest_genesis, key.pub, nano::dev::constants.genesis_amount - 1 - i, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
auto open = std::make_shared<nano::open_block> (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
auto send = builder
.send ()
.previous (latest_genesis)
.destination (key.pub)
.balance (nano::dev::constants.genesis_amount - 1 - i)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
auto open = builder
.open ()
.source (send->hash ())
.representative (nano::dev::genesis_key.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
open_blocks.push_back (std::move (open));
latest_genesis = send.hash ();
latest_genesis = send->hash ();
}
}
@ -968,8 +1147,21 @@ TEST (confirmation_height, many_accounts_send_receive_self)
{
auto open_block = open_blocks[i];
auto & keypair = keys[i];
send_blocks.emplace_back (std::make_shared<nano::send_block> (open_block->hash (), keypair.pub, 1, keypair.prv, keypair.pub, *system.work.generate (open_block->hash ())));
receive_blocks.emplace_back (std::make_shared<nano::receive_block> (send_blocks.back ()->hash (), send_blocks.back ()->hash (), keypair.prv, keypair.pub, *system.work.generate (send_blocks.back ()->hash ())));
send_blocks.emplace_back (builder
.send ()
.previous (open_block->hash ())
.destination (keypair.pub)
.balance (1)
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (open_block->hash ()))
.build_shared ());
receive_blocks.emplace_back (builder
.receive ()
.previous (send_blocks.back ()->hash ())
.source (send_blocks.back ()->hash ())
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (send_blocks.back ()->hash ()))
.build_shared ());
}
// Now send and receive to self
@ -1045,6 +1237,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
std::vector<nano::keypair> keys;
std::vector<std::shared_ptr<nano::open_block>> open_blocks;
nano::block_builder builder;
nano::system system;
{
@ -1056,12 +1249,26 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
{
nano::keypair key;
keys.emplace_back (key);
nano::send_block send (latest_genesis, key.pub, nano::dev::constants.genesis_amount - 1 - i, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (latest_genesis));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
auto open = std::make_shared<nano::open_block> (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *pool.generate (key.pub));
auto send = builder
.send ()
.previous (latest_genesis)
.destination (key.pub)
.balance (nano::dev::constants.genesis_amount - 1 - i)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (latest_genesis))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
auto open = builder
.open ()
.source (send->hash ())
.representative (nano::dev::genesis_key.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*pool.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code);
open_blocks.push_back (std::move (open));
latest_genesis = send.hash ();
latest_genesis = send->hash ();
}
}
@ -1087,8 +1294,21 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
{
auto open_block = open_blocks[i];
auto & keypair = keys[i];
send_blocks.emplace_back (std::make_shared<nano::send_block> (open_block->hash (), keypair.pub, 1, keypair.prv, keypair.pub, *system.work.generate (open_block->hash ())));
receive_blocks.emplace_back (std::make_shared<nano::receive_block> (send_blocks.back ()->hash (), send_blocks.back ()->hash (), keypair.prv, keypair.pub, *system.work.generate (send_blocks.back ()->hash ())));
send_blocks.emplace_back (builder
.send ()
.previous (open_block->hash ())
.destination (keypair.pub)
.balance (1)
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (open_block->hash ()))
.build_shared ());
receive_blocks.emplace_back (builder
.receive ()
.previous (send_blocks.back ()->hash ())
.source (send_blocks.back ()->hash ())
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (send_blocks.back ()->hash ()))
.build_shared ());
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send_blocks.back ()).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive_blocks.back ()).code);
@ -1150,6 +1370,7 @@ TEST (confirmation_height, prioritize_frontiers_overwrite)
node->store.confirmation_height.clear (transaction);
}
nano::block_builder builder;
{
auto transaction = node->store.tx_begin_write ();
for (auto i = num_accounts - 1; i > 0; --i)
@ -1157,11 +1378,25 @@ TEST (confirmation_height, prioritize_frontiers_overwrite)
nano::keypair key;
system.wallet (0)->insert_adhoc (key.prv);
nano::send_block send (last_open_hash, key.pub, nano::Gxrb_ratio - 1, last_keypair.prv, last_keypair.pub, *system.work.generate (last_open_hash));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
nano::open_block open (send.hash (), last_keypair.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code);
last_open_hash = open.hash ();
auto send = builder
.send ()
.previous (last_open_hash)
.destination (key.pub)
.balance (nano::Gxrb_ratio - 1)
.sign (last_keypair.prv, last_keypair.pub)
.work (*system.work.generate (last_open_hash))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
auto open = builder
.open ()
.source (send->hash ())
.representative (last_keypair.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
last_open_hash = open->hash ();
last_keypair = key;
}
}
@ -1182,12 +1417,26 @@ TEST (confirmation_height, prioritize_frontiers_overwrite)
// Add a new frontier with 1 block, it should not be added to the frontier container because it is not higher than any already in the maxed out container
nano::keypair key;
auto latest_genesis = node->latest (nano::dev::genesis_key.pub);
nano::send_block send (latest_genesis, key.pub, nano::Gxrb_ratio - 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis));
nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
auto send = builder
.send ()
.previous (latest_genesis)
.destination (key.pub)
.balance (nano::Gxrb_ratio - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build ();
auto open = builder
.open ()
.source (send->hash ())
.representative (nano::dev::genesis_key.pub)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
}
transaction.refresh ();
node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (60), std::chrono::seconds (60));
@ -1195,12 +1444,25 @@ TEST (confirmation_height, prioritize_frontiers_overwrite)
ASSERT_EQ (node->active.priority_wallet_cementable_frontiers_size (), num_accounts / 2);
// The account now has an extra block (2 in total) so has 1 more uncemented block than the next smallest frontier in the collection.
nano::send_block send1 (send.hash (), key.pub, nano::Gxrb_ratio - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
nano::receive_block receive (open.hash (), send1.hash (), key.prv, key.pub, *system.work.generate (open.hash ()));
auto send1 = builder
.send ()
.previous (send->hash ())
.destination (key.pub)
.balance (nano::Gxrb_ratio - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build ();
auto receive = builder
.receive ()
.previous (open->hash ())
.source (send1->hash ())
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive).code);
}
// Confirm that it gets replaced
@ -1373,18 +1635,47 @@ TEST (telemetry, under_load)
system.wallet (0)->insert_adhoc (key.prv);
auto latest_genesis = node->latest (nano::dev::genesis_key.pub);
auto num_blocks = 150000;
auto send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest_genesis, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - num_blocks, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis)));
nano::block_builder builder;
auto send = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (latest_genesis)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - num_blocks)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build_shared ();
node->process_active (send);
latest_genesis = send->hash ();
auto open (std::make_shared<nano::state_block> (key.pub, 0, key.pub, num_blocks, send->hash (), key.prv, key.pub, *system.work.generate (key.pub)));
auto open = builder
.state ()
.account (key.pub)
.previous (0)
.representative (key.pub)
.balance (num_blocks)
.link (send->hash ())
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
node->process_active (open);
auto latest_key = open->hash ();
auto thread_func = [key1, &system, node, num_blocks] (nano::keypair const & keypair, nano::block_hash const & latest, nano::uint128_t const initial_amount) {
auto latest_l = latest;
nano::block_builder builder;
for (int i = 0; i < num_blocks; ++i)
{
auto send (std::make_shared<nano::state_block> (keypair.pub, latest_l, keypair.pub, initial_amount - i - 1, key1.pub, keypair.prv, keypair.pub, *system.work.generate (latest_l)));
auto send = builder
.state ()
.account (keypair.pub)
.previous (latest_l)
.representative (keypair.pub)
.balance (initial_amount - i - 1)
.link (key1.pub)
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (latest_l))
.build_shared ();
latest_l = send->hash ();
node->process_active (send);
}
@ -1519,11 +1810,21 @@ TEST (telemetry, many_nodes)
// Give all nodes a non-default number of blocks
nano::keypair key;
nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Mxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()));
nano::block_builder builder;
auto send = builder
.state ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::constants.genesis_amount - nano::Mxrb_ratio)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
for (auto node : system.nodes)
{
auto transaction (node->store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
}
// This is the node which will request metrics from all other nodes
@ -1596,6 +1897,7 @@ TEST (signature_checker, mass_boundary_checks)
add_boundary (nano::signature_checker::batch_size * i);
}
nano::block_builder builder;
for (auto num_threads = 0; num_threads < 5; ++num_threads)
{
nano::signature_checker checker (num_threads);
@ -1611,7 +1913,16 @@ TEST (signature_checker, mass_boundary_checks)
std::vector<unsigned char const *> signatures;
signatures.reserve (max_size);
nano::keypair key;
nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0);
auto block = builder
.state ()
.account (key.pub)
.previous (0)
.representative (key.pub)
.balance (0)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build ();
size_t last_size = 0;
for (auto size : sizes)
@ -1623,11 +1934,11 @@ TEST (signature_checker, mass_boundary_checks)
verifications.resize (size);
for (auto i (0); i < extra_size; ++i)
{
hashes.push_back (block.hash ());
hashes.push_back (block->hash ());
messages.push_back (hashes.back ().bytes.data ());
lengths.push_back (sizeof (decltype (hashes)::value_type));
pub_keys.push_back (block.hashables.account.bytes.data ());
signatures.push_back (block.signature.bytes.data ());
pub_keys.push_back (block->hashables.account.bytes.data ());
signatures.push_back (block->signature.bytes.data ());
}
nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data () };
checker.verify (check);
@ -1892,6 +2203,7 @@ TEST (node, wallet_create_block_confirm_conflicts)
for (int i = 0; i < 5; ++i)
{
nano::system system;
nano::block_builder builder;
nano::node_config node_config (nano::get_available_port (), system.logging);
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config);
@ -1904,9 +2216,16 @@ TEST (node, wallet_create_block_confirm_conflicts)
auto transaction = node->store.tx_begin_write ();
for (auto i = num_blocks - 1; i > 0; --i)
{
nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio + i + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
latest = send.hash ();
auto send = builder
.send ()
.previous (latest)
.destination (key1.pub)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio + i + 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
latest = send->hash ();
}
}