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

Move representation with balances rather than trying to move it only on receive.

Browse source
This commit is contained in:
clemahieu 2016-04-29 09:59:23 -05:00
commit e24dfe03a0
5 changed files with 66 additions and 103 deletions
Download patch file Download diff file Expand all files Collapse all files

47
rai/core_test/ledger.cpp
View file

@ -154,12 +154,13 @@ TEST (ledger, process_send)
ASSERT_EQ (rai::genesis_amount - 50, pending1.amount.number ());
ASSERT_EQ (0, ledger.account_balance (transaction, key2.pub));
ASSERT_EQ (50, ledger.account_balance (transaction, rai::test_genesis_key.pub));
ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::test_genesis_key.pub));
ASSERT_EQ (50, ledger.weight (transaction, rai::test_genesis_key.pub));
ASSERT_EQ (0, ledger.weight (transaction, key2.pub));
rai::account_info info6;
ASSERT_FALSE (ledger.store.account_get (transaction, rai::test_genesis_key.pub, info6));
ASSERT_EQ (hash1, info6.head);
ledger.rollback (transaction, info6.head);
ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::test_genesis_key.pub));
ASSERT_EQ (rai::test_genesis_key.pub, store.frontier_get (transaction, info1.head));
ASSERT_TRUE (store.frontier_get (transaction, hash1).is_zero ());
rai::account_info info7;
@ -289,11 +290,13 @@ TEST (ledger, rollback_representation)
ASSERT_EQ (1, ledger.weight (transaction, key3.pub));
ASSERT_EQ (rai::genesis_amount - 1, ledger.weight (transaction, key4.pub));
ledger.rollback (transaction, receive1.hash ());
ASSERT_EQ (50, ledger.weight (transaction, key3.pub));
ASSERT_EQ (0, ledger.weight (transaction, key2.pub));
ASSERT_EQ (rai::genesis_amount - 50, ledger.weight (transaction, key4.pub));
ledger.rollback (transaction, open.hash ());
ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key3.pub));
ASSERT_EQ (1, ledger.weight (transaction, key3.pub));
ASSERT_EQ (0, ledger.weight (transaction, key4.pub));
ledger.rollback (transaction, send1.hash ());
ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key3.pub));
ledger.rollback (transaction, change2.hash ());
ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key5.pub));
ASSERT_EQ (0, ledger.weight (transaction, key3.pub));
@ -591,7 +594,7 @@ TEST (ledger, representation)
rai::keypair key2;
rai::send_block block1 (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0);
ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code);
ASSERT_EQ (rai::genesis_amount, store.representation_get (transaction, rai::test_genesis_key.pub));
ASSERT_EQ (rai::genesis_amount - 100, store.representation_get (transaction, rai::test_genesis_key.pub));
rai::keypair key3;
rai::open_block block2 (block1.hash (), key3.pub, key2.pub, key2.prv, key2.pub, 0);
ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block2).code);
@ -600,7 +603,7 @@ TEST (ledger, representation)
ASSERT_EQ (100, store.representation_get (transaction, key3.pub));
rai::send_block block3 (block1.hash (), key2.pub, rai::genesis_amount - 200, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0);
ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block3).code);
ASSERT_EQ (rai::genesis_amount - 100, store.representation_get (transaction, rai::test_genesis_key.pub));
ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub));
ASSERT_EQ (0, store.representation_get (transaction, key2.pub));
ASSERT_EQ (100, store.representation_get (transaction, key3.pub));
rai::receive_block block4 (block2.hash (), block3.hash (), key2.prv, key2.pub, 0);
@ -621,7 +624,7 @@ TEST (ledger, representation)
ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub));
ASSERT_EQ (0, store.representation_get (transaction, key2.pub));
ASSERT_EQ (0, store.representation_get (transaction, key3.pub));
ASSERT_EQ (200, store.representation_get (transaction, key4.pub));
ASSERT_EQ (100, store.representation_get (transaction, key4.pub));
ASSERT_EQ (0, store.representation_get (transaction, key5.pub));
rai::keypair key6;
rai::open_block block7 (block6.hash (), key6.pub, key5.pub, key5.prv, key5.pub, 0);
@ -637,7 +640,7 @@ TEST (ledger, representation)
ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub));
ASSERT_EQ (0, store.representation_get (transaction, key2.pub));
ASSERT_EQ (0, store.representation_get (transaction, key3.pub));
ASSERT_EQ (100, store.representation_get (transaction, key4.pub));
ASSERT_EQ (0, store.representation_get (transaction, key4.pub));
ASSERT_EQ (0, store.representation_get (transaction, key5.pub));
ASSERT_EQ (100, store.representation_get (transaction, key6.pub));
rai::receive_block block9 (block7.hash (), block8.hash (), key5.prv, key5.pub, 0);
@ -717,7 +720,7 @@ TEST (votes, add_one)
auto & node1 (*system.nodes [0]);
rai::genesis genesis;
rai::keypair key1;
rai::send_block send1 (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0);
rai::send_block send1 (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0);
{
rai::transaction transaction (node1.store.environment, nullptr, true);
ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, send1).code);
@ -738,7 +741,7 @@ TEST (votes, add_one)
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false);
auto winner (node1.ledger.winner (transaction, votes1->votes));
ASSERT_EQ (send1, *winner.second);
ASSERT_EQ (rai::genesis_amount, winner.first);
ASSERT_EQ (rai::genesis_amount - 100, winner.first);
}
TEST (votes, add_two)
@ -747,7 +750,7 @@ TEST (votes, add_two)
auto & node1 (*system.nodes [0]);
rai::genesis genesis;
rai::keypair key1;
rai::send_block send1 (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0);
rai::send_block send1 (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0);
{
rai::transaction transaction (node1.store.environment, nullptr, true);
ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, send1).code);
@ -1332,4 +1335,28 @@ TEST (ledger, inactive_supply)
ASSERT_EQ (0, ledger.supply (transaction));
ledger.inactive_supply = 0;
ASSERT_EQ (50, ledger.supply (transaction));
}
TEST (ledger, change_representative_move_representation)
{
bool init (false);
rai::block_store store (init, rai::unique_path ());
ASSERT_TRUE (!init);
rai::ledger ledger (store);
rai::keypair key1;
rai::transaction transaction (store.environment, nullptr, true);
rai::genesis genesis;
genesis.initialize (transaction, store);
auto hash1 (genesis.hash ());
ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::test_genesis_key.pub));
rai::send_block send (hash1, key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0);
ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code);
ASSERT_EQ (0, ledger.weight (transaction, rai::test_genesis_key.pub));
rai::keypair key2;
rai::change_block change (send.hash (), key2.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0);
ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, change).code);
rai::keypair key3;
rai::open_block open (send.hash (), key3.pub, key1.pub, key1.prv, key1.pub, 0);
ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open).code);
ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key3.pub));
}

28
rai/core_test/node.cpp
View file

@ -666,11 +666,11 @@ TEST (node, fork_publish)
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
rai::keypair key1;
rai::genesis genesis;
std::unique_ptr <rai::send_block> send1 (new rai::send_block (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
std::unique_ptr <rai::send_block> send1 (new rai::send_block (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
rai::publish publish1;
publish1.block = std::move (send1);
rai::keypair key2;
std::unique_ptr <rai::send_block> send2 (new rai::send_block (genesis.hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
std::unique_ptr <rai::send_block> send2 (new rai::send_block (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0));
rai::publish publish2;
publish2.block = std::move (send2);
node1.process_message (publish1, node1.network.endpoint ());
@ -703,7 +703,7 @@ TEST (node, fork_publish)
rai::transaction transaction (node1.store.environment, nullptr, false);
auto winner (node1.ledger.winner (transaction, votes1->votes));
ASSERT_EQ (*publish1.block, *winner.second);
ASSERT_EQ (rai::genesis_amount, winner.first);
ASSERT_EQ (rai::genesis_amount - 100, winner.first);
}
ASSERT_TRUE (node0.expired ());
}
@ -717,11 +717,11 @@ TEST (node, fork_keep)
system.wallet (0)->insert_adhoc ( rai::test_genesis_key.prv);
rai::keypair key1;
rai::genesis genesis;
std::unique_ptr <rai::send_block> send1 (new rai::send_block (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
std::unique_ptr <rai::send_block> send1 (new rai::send_block (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
rai::publish publish1;
publish1.block = std::move (send1);
rai::keypair key2;
std::unique_ptr <rai::send_block> send2 (new rai::send_block (genesis.hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
std::unique_ptr <rai::send_block> send2 (new rai::send_block (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
rai::publish publish2;
publish2.block = std::move (send2);
node1.process_message (publish1, node1.network.endpoint ());
@ -757,7 +757,7 @@ TEST (node, fork_keep)
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false);
auto winner (node1.ledger.winner (transaction, votes1->votes));
ASSERT_EQ (*publish1.block, *winner.second);
ASSERT_EQ (rai::genesis_amount, winner.first);
ASSERT_EQ (rai::genesis_amount - 100, winner.first);
ASSERT_TRUE (system.nodes [0]->store.block_exists (transaction, publish1.block->hash ()));
ASSERT_TRUE (system.nodes [1]->store.block_exists (transaction, publish1.block->hash ()));
}
@ -771,11 +771,11 @@ TEST (node, fork_flip)
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
rai::keypair key1;
rai::genesis genesis;
std::unique_ptr <rai::send_block> send1 (new rai::send_block (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
std::unique_ptr <rai::send_block> send1 (new rai::send_block (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
rai::publish publish1;
publish1.block = std::move (send1);
rai::keypair key2;
std::unique_ptr <rai::send_block> send2 (new rai::send_block (genesis.hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
std::unique_ptr <rai::send_block> send2 (new rai::send_block (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
rai::publish publish2;
publish2.block = std::move (send2);
node1.process_message (publish1, node1.network.endpoint ());
@ -814,7 +814,7 @@ TEST (node, fork_flip)
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false);
auto winner (node2.ledger.winner (transaction, votes1->votes));
ASSERT_EQ (*publish1.block, *winner.second);
ASSERT_EQ (rai::genesis_amount, winner.first);
ASSERT_EQ (rai::genesis_amount - 100, winner.first);
ASSERT_TRUE (node1.store.block_exists (transaction, publish1.block->hash ()));
ASSERT_TRUE (node2.store.block_exists (transaction, publish1.block->hash ()));
ASSERT_FALSE (node2.store.block_exists (transaction, publish2.block->hash ()));
@ -829,14 +829,14 @@ TEST (node, fork_multi_flip)
system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv);
rai::keypair key1;
rai::genesis genesis;
std::unique_ptr <rai::send_block> send1 (new rai::send_block (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
std::unique_ptr <rai::send_block> send1 (new rai::send_block (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
rai::publish publish1;
publish1.block = std::move (send1);
rai::keypair key2;
std::unique_ptr <rai::send_block> send2 (new rai::send_block (genesis.hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
std::unique_ptr <rai::send_block> send2 (new rai::send_block (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())));
rai::publish publish2;
publish2.block = std::move (send2);
std::unique_ptr <rai::send_block> send3 (new rai::send_block (publish2.block->hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (publish2.block->hash ())));
std::unique_ptr <rai::send_block> send3 (new rai::send_block (publish2.block->hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (publish2.block->hash ())));
rai::publish publish3;
publish3.block = std::move (send3);
node1.process_message (publish1, node1.network.endpoint ());
@ -878,7 +878,7 @@ TEST (node, fork_multi_flip)
rai::transaction transaction (system.nodes [0]->store.environment, nullptr, false);
auto winner (node1.ledger.winner (transaction, votes1->votes));
ASSERT_EQ (*publish1.block, *winner.second);
ASSERT_EQ (rai::genesis_amount, winner.first);
ASSERT_EQ (rai::genesis_amount - 100, winner.first);
ASSERT_TRUE (node1.store.block_exists (transaction, publish1.block->hash ()));
ASSERT_TRUE (node2.store.block_exists (transaction, publish1.block->hash ()));
ASSERT_FALSE (node2.store.block_exists (transaction, publish2.block->hash ()));
@ -1034,7 +1034,7 @@ TEST (node, fork_no_vote_quorum)
auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key1, node1.config.receive_minimum.number ()));
ASSERT_NE (nullptr, block);
auto iterations (0);
while (node3.balance (key1) != node1.config.receive_minimum.number ())
while (node3.balance (key1) != node1.config.receive_minimum.number () || node2.balance (key1) != node1.config.receive_minimum.number () || node1.balance (key1) != node1.config.receive_minimum.number ())
{
system.poll ();
++iterations;

63
rai/node/node.cpp
View file

@ -1345,69 +1345,6 @@ void rai::node::process_confirmation (rai::block const & block_a, rai::endpoint
});
}
namespace
{
class rollback_visitor : public rai::block_visitor
{
public:
rollback_visitor (rai::ledger & ledger_a) :
ledger (ledger_a)
{
}
void send_block (rai::send_block const & block_a) override
{
auto hash (block_a.hash ());
rai::pending_info pending;
rai::transaction transaction (ledger.store.environment, nullptr, true);
while (ledger.store.pending_get (transaction, hash, pending))
{
ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.destination));
}
rai::account_info info;
ledger.store.account_get (transaction, pending.source, info);
ledger.store.pending_del (transaction, hash);
ledger.change_latest (transaction, pending.source, block_a.hashables.previous, info.rep_block, ledger.balance (transaction, block_a.hashables.previous));
ledger.store.block_del (transaction, hash);
}
void receive_block (rai::receive_block const & block_a) override
{
rai::transaction transaction (ledger.store.environment, nullptr, true);
auto hash (block_a.hash ());
auto representative (ledger.representative (transaction, block_a.hashables.source));
auto amount (ledger.amount (transaction, block_a.hashables.source));
auto destination_account (ledger.account (transaction, hash));
ledger.move_representation (transaction, ledger.representative (transaction, hash), representative, amount);
ledger.change_latest (transaction, destination_account, block_a.hashables.previous, representative, ledger.balance (transaction, block_a.hashables.previous));
ledger.store.block_del (transaction, hash);
ledger.store.pending_put (transaction, block_a.hashables.source, {ledger.account (transaction, block_a.hashables.source), amount, destination_account});
}
void open_block (rai::open_block const & block_a) override
{
rai::transaction transaction (ledger.store.environment, nullptr, true);
auto hash (block_a.hash ());
auto representative (ledger.representative (transaction, block_a.hashables.source));
auto amount (ledger.amount (transaction, block_a.hashables.source));
auto destination_account (ledger.account (transaction, hash));
ledger.move_representation (transaction, ledger.representative (transaction, hash), representative, amount);
ledger.change_latest (transaction, destination_account, 0, representative, 0);
ledger.store.block_del (transaction, hash);
ledger.store.pending_put (transaction, block_a.hashables.source, {ledger.account (transaction, block_a.hashables.source), amount, destination_account});
}
void change_block (rai::change_block const & block_a) override
{
rai::transaction transaction (ledger.store.environment, nullptr, true);
auto representative (ledger.representative (transaction, block_a.hashables.previous));
auto account (ledger.account (transaction, block_a.hashables.previous));
rai::account_info info;
ledger.store.account_get (transaction, account, info);
ledger.move_representation (transaction, block_a.representative (), representative, ledger.balance (transaction, block_a.hashables.previous));
ledger.store.block_del (transaction, block_a.hash ());
ledger.change_latest (transaction, account, block_a.hashables.previous, representative, info.balance);
}
rai::ledger & ledger;
};
}
bool rai::parse_port (std::string const & string_a, uint16_t & port_a)
{
bool result;

29
rai/secure.cpp
View file

@ -2492,6 +2492,7 @@ public:
rai::account_info info;
ledger.store.account_get (transaction, pending.source, info);
ledger.store.pending_del (transaction, hash);
ledger.add_representation (transaction, ledger.representative (transaction, hash), pending.amount.number ());
ledger.change_latest (transaction, pending.source, block_a.hashables.previous, info.rep_block, ledger.balance (transaction, block_a.hashables.previous));
ledger.store.block_del (transaction, hash);
ledger.store.frontier_del (transaction, hash);
@ -2504,7 +2505,7 @@ public:
auto representative (ledger.representative (transaction, block_a.hashables.source));
auto amount (ledger.amount (transaction, block_a.hashables.source));
auto destination_account (ledger.account (transaction, hash));
ledger.move_representation (transaction, ledger.representative (transaction, hash), representative, amount);
ledger.add_representation (transaction, ledger.representative (transaction, hash), 0 - amount);
ledger.change_latest (transaction, destination_account, block_a.hashables.previous, representative, ledger.balance (transaction, block_a.hashables.previous));
ledger.store.block_del (transaction, hash);
ledger.store.pending_put (transaction, block_a.hashables.source, {ledger.account (transaction, block_a.hashables.source), amount, destination_account});
@ -2518,7 +2519,7 @@ public:
auto representative (ledger.representative (transaction, block_a.hashables.source));
auto amount (ledger.amount (transaction, block_a.hashables.source));
auto destination_account (ledger.account (transaction, hash));
ledger.move_representation (transaction, ledger.representative (transaction, hash), representative, amount);
ledger.add_representation (transaction, ledger.representative (transaction, hash), 0 - amount);
ledger.change_latest (transaction, destination_account, 0, representative, 0);
ledger.store.block_del (transaction, hash);
ledger.store.pending_put (transaction, block_a.hashables.source, {ledger.account (transaction, block_a.hashables.source), amount, destination_account});
@ -2531,7 +2532,9 @@ public:
auto account (ledger.account (transaction, block_a.hashables.previous));
rai::account_info info;
ledger.store.account_get (transaction, account, info);
ledger.move_representation (transaction, hash, representative, ledger.balance (transaction, block_a.hashables.previous));
auto balance (ledger.balance (transaction, block_a.hashables.previous));
ledger.add_representation (transaction, representative, balance);
ledger.add_representation (transaction, hash, 0 - balance);
ledger.store.block_del (transaction, hash);
ledger.change_latest (transaction, account, block_a.hashables.previous, representative, info.balance);
ledger.store.frontier_del (transaction, hash);
@ -2682,21 +2685,14 @@ rai::uint128_t rai::ledger::amount (MDB_txn * transaction_a, rai::block_hash con
return amount.result;
}
void rai::ledger::move_representation (MDB_txn * transaction_a, rai::block_hash const & source_a, rai::block_hash const & destination_a, rai::uint128_t const & amount_a)
void rai::ledger::add_representation (MDB_txn * transaction_a, rai::block_hash const & source_a, rai::uint128_t const & amount_a)
{
auto source_block (store.block_get (transaction_a, source_a));
assert (source_block != nullptr);
auto source_rep (source_block->representative ());
assert (!source_rep.is_zero ());
auto destination_block (store.block_get (transaction_a, destination_a));
assert (destination_block != nullptr);
auto destination_rep (destination_block->representative ());
assert (!destination_rep.is_zero ());
auto source_previous (store.representation_get (transaction_a, source_rep));
assert (source_previous >= amount_a);
store.representation_put (transaction_a, source_rep, source_previous - amount_a);
auto destination_previous (store.representation_get (transaction_a, destination_rep));
store.representation_put (transaction_a, destination_rep, destination_previous + amount_a);
store.representation_put (transaction_a, source_rep, source_previous + amount_a);
}
// Return latest block for account
@ -2827,7 +2823,9 @@ void ledger_processor::change_block (rai::change_block const & block_a)
if (result.code == rai::process_result::progress)
{
ledger.store.block_put (transaction, hash, block_a);
ledger.move_representation (transaction, info.rep_block, hash, ledger.balance (transaction, block_a.hashables.previous));
auto balance (ledger.balance (transaction, block_a.hashables.previous));
ledger.add_representation (transaction, hash, balance);
ledger.add_representation (transaction, info.rep_block, 0 - balance);
ledger.change_latest (transaction, account, hash, hash, info.balance);
ledger.store.frontier_del (transaction, block_a.hashables.previous);
ledger.store.frontier_put (transaction, hash, account);
@ -2865,6 +2863,7 @@ void ledger_processor::send_block (rai::send_block const & block_a)
if (result.code == rai::process_result::progress)
{
auto amount (info.balance.number () - block_a.hashables.balance.number ());
ledger.add_representation (transaction, info.rep_block, 0 - amount);
ledger.store.block_put (transaction, hash, block_a);
ledger.change_latest (transaction, account, hash, info.rep_block, block_a.hashables.balance);
ledger.store.pending_put (transaction, hash, {account, amount, block_a.hashables.destination});
@ -2915,7 +2914,7 @@ void ledger_processor::receive_block (rai::receive_block const & block_a)
ledger.store.pending_del (transaction, block_a.hashables.source);
ledger.store.block_put (transaction, hash, block_a);
ledger.change_latest (transaction, pending.destination, hash, info.rep_block, new_balance);
ledger.move_representation (transaction, source_info.rep_block, info.rep_block, pending.amount.number ());
ledger.add_representation (transaction, info.rep_block, pending.amount.number ());
ledger.store.frontier_del (transaction, block_a.hashables.previous);
ledger.store.frontier_put (transaction, hash, pending.destination);
result.account = pending.destination;
@ -2963,7 +2962,7 @@ void ledger_processor::open_block (rai::open_block const & block_a)
ledger.store.pending_del (transaction, block_a.hashables.source);
ledger.store.block_put (transaction, hash, block_a);
ledger.change_latest (transaction, pending.destination, hash, hash, pending.amount.number ());
ledger.move_representation (transaction, source_info.rep_block, hash, pending.amount.number ());
ledger.add_representation (transaction, hash, pending.amount.number ());
ledger.store.frontier_put (transaction, hash, pending.destination);
result.account = pending.destination;
result.amount = pending.amount;

2
rai/secure.hpp
View file

@ -463,7 +463,7 @@ public:
rai::process_return process (MDB_txn *, rai::block const &);
void rollback (MDB_txn *, rai::block_hash const &);
void change_latest (MDB_txn *, rai::account const &, rai::block_hash const &, rai::account const &, rai::uint128_union const &);
void move_representation (MDB_txn *, rai::account const &, rai::account const &, rai::uint128_t const &);
void add_representation (MDB_txn *, rai::account const &, rai::uint128_t const &);
void checksum_update (MDB_txn *, rai::block_hash const &);
rai::checksum checksum (MDB_txn *, rai::account const &, rai::account const &);
void dump_account_chain (rai::account const &);