From 6f437e7be92c3fd62b076cc5816638c8296e896f Mon Sep 17 00:00:00 2001 From: satyakoneru Date: Wed, 12 Feb 2020 09:37:04 +0000 Subject: [PATCH] SON131 - Sidechain bitcoin transaction signature collection --- libraries/app/impacted.cpp | 6 + libraries/chain/CMakeLists.txt | 1 + libraries/chain/db_init.cpp | 5 + libraries/chain/db_notify.cpp | 6 + .../graphene/chain/protocol/operations.hpp | 5 +- .../chain/protocol/sidechain_transaction.hpp | 43 +++ .../include/graphene/chain/protocol/types.hpp | 5 + .../chain/sidechain_transaction_evaluator.hpp | 26 ++ .../chain/sidechain_transaction_object.hpp | 39 +++ .../chain/sidechain_transaction_evaluator.cpp | 83 +++++ tests/tests/sidechain_transaction_tests.cpp | 298 ++++++++++++++++++ 11 files changed, 516 insertions(+), 1 deletion(-) create mode 100644 libraries/chain/include/graphene/chain/protocol/sidechain_transaction.hpp create mode 100644 libraries/chain/include/graphene/chain/sidechain_transaction_evaluator.hpp create mode 100644 libraries/chain/include/graphene/chain/sidechain_transaction_object.hpp create mode 100644 libraries/chain/sidechain_transaction_evaluator.cpp create mode 100644 tests/tests/sidechain_transaction_tests.cpp diff --git a/libraries/app/impacted.cpp b/libraries/app/impacted.cpp index d3e8eb8c..37a78c80 100644 --- a/libraries/app/impacted.cpp +++ b/libraries/app/impacted.cpp @@ -337,6 +337,12 @@ struct get_impacted_account_visitor void operator()( const sidechain_address_delete_operation& op ){ _impacted.insert( op.sidechain_address_account ); } + void operator()( const bitcoin_transaction_send_operation& op ){ + _impacted.insert( op.payer ); + } + void operator()( const bitcoin_transaction_sign_operation& op ){ + _impacted.insert( op.payer ); + } }; void operation_get_impacted_accounts( const operation& op, flat_set& result ) diff --git a/libraries/chain/CMakeLists.txt b/libraries/chain/CMakeLists.txt index c7dd5375..1002bb7f 100644 --- a/libraries/chain/CMakeLists.txt +++ b/libraries/chain/CMakeLists.txt @@ -121,6 +121,7 @@ add_library( graphene_chain son_wallet_transfer_evaluator.cpp sidechain_address_evaluator.cpp + sidechain_transaction_evaluator.cpp ${HEADERS} ${PROTOCOL_HEADERS} diff --git a/libraries/chain/db_init.cpp b/libraries/chain/db_init.cpp index 3d53fce0..ae505b18 100644 --- a/libraries/chain/db_init.cpp +++ b/libraries/chain/db_init.cpp @@ -59,6 +59,7 @@ #include #include #include +#include #include #include @@ -84,6 +85,7 @@ #include #include #include +#include #include @@ -262,6 +264,8 @@ void database::initialize_evaluators() register_evaluator(); register_evaluator(); register_evaluator(); + register_evaluator(); + register_evaluator(); } void database::initialize_indexes() @@ -310,6 +314,7 @@ void database::initialize_indexes() add_index< primary_index >(); add_index< primary_index >(); + add_index< primary_index >(); //Implementation object indexes add_index< primary_index >(); diff --git a/libraries/chain/db_notify.cpp b/libraries/chain/db_notify.cpp index 299cd9d0..a3a64ecb 100644 --- a/libraries/chain/db_notify.cpp +++ b/libraries/chain/db_notify.cpp @@ -324,6 +324,12 @@ struct get_impacted_account_visitor void operator()( const sidechain_address_delete_operation& op ) { _impacted.insert( op.sidechain_address_account ); } + void operator()( const bitcoin_transaction_send_operation& op ) { + _impacted.insert( op.payer ); + } + void operator()( const bitcoin_transaction_sign_operation& op ) { + _impacted.insert( op.payer ); + } }; void operation_get_impacted_accounts( const operation& op, flat_set& result ) diff --git a/libraries/chain/include/graphene/chain/protocol/operations.hpp b/libraries/chain/include/graphene/chain/protocol/operations.hpp index 27980ae2..ef0188c6 100644 --- a/libraries/chain/include/graphene/chain/protocol/operations.hpp +++ b/libraries/chain/include/graphene/chain/protocol/operations.hpp @@ -49,6 +49,7 @@ #include #include #include +#include namespace graphene { namespace chain { @@ -152,7 +153,9 @@ namespace graphene { namespace chain { son_wallet_transfer_process_operation, sidechain_address_add_operation, sidechain_address_update_operation, - sidechain_address_delete_operation + sidechain_address_delete_operation, + bitcoin_transaction_send_operation, + bitcoin_transaction_sign_operation > operation; /// @} // operations group diff --git a/libraries/chain/include/graphene/chain/protocol/sidechain_transaction.hpp b/libraries/chain/include/graphene/chain/protocol/sidechain_transaction.hpp new file mode 100644 index 00000000..e401f406 --- /dev/null +++ b/libraries/chain/include/graphene/chain/protocol/sidechain_transaction.hpp @@ -0,0 +1,43 @@ +#pragma once +#include +#include +#include + +namespace graphene { namespace chain { + + struct bitcoin_transaction_send_operation : public base_operation + { + struct fee_parameters_type { uint64_t fee = 0; }; + + asset fee; + account_id_type payer; + + // TODO: BTC Transaction Structs go here + fc::flat_map> signatures; + + account_id_type fee_payer()const { return payer; } + void validate()const {} + share_type calculate_fee(const fee_parameters_type& k)const { return 0; } + }; + + struct bitcoin_transaction_sign_operation : public base_operation + { + struct fee_parameters_type { uint64_t fee = 0; }; + + asset fee; + account_id_type payer; + proposal_id_type proposal_id; + std::vector signatures; + + account_id_type fee_payer()const { return payer; } + void validate()const {} + share_type calculate_fee( const fee_parameters_type& k )const { return 0; } + }; + +} } // graphene::chain + +FC_REFLECT( graphene::chain::bitcoin_transaction_send_operation::fee_parameters_type, (fee) ) +FC_REFLECT( graphene::chain::bitcoin_transaction_send_operation, (fee)(payer)(signatures) ) + +FC_REFLECT( graphene::chain::bitcoin_transaction_sign_operation::fee_parameters_type, (fee) ) +FC_REFLECT( graphene::chain::bitcoin_transaction_sign_operation, (fee)(payer)(proposal_id)(signatures) ) diff --git a/libraries/chain/include/graphene/chain/protocol/types.hpp b/libraries/chain/include/graphene/chain/protocol/types.hpp index c25c465c..4e145531 100644 --- a/libraries/chain/include/graphene/chain/protocol/types.hpp +++ b/libraries/chain/include/graphene/chain/protocol/types.hpp @@ -150,6 +150,7 @@ namespace graphene { namespace chain { son_wallet_object_type, son_wallet_transfer_object_type, sidechain_address_object_type, + bitcoin_transaction_object_type, OBJECT_TYPE_COUNT ///< Sentry value which contains the number of different object types }; @@ -216,6 +217,7 @@ namespace graphene { namespace chain { class son_wallet_object; class son_wallet_transfer_object; class sidechain_address_object; + class bitcoin_transaction_object; typedef object_id< protocol_ids, account_object_type, account_object> account_id_type; typedef object_id< protocol_ids, asset_object_type, asset_object> asset_id_type; @@ -247,6 +249,7 @@ namespace graphene { namespace chain { typedef object_id< protocol_ids, son_wallet_object_type, son_wallet_object> son_wallet_id_type; typedef object_id< protocol_ids, son_wallet_transfer_object_type, son_wallet_transfer_object> son_wallet_transfer_id_type; typedef object_id< protocol_ids, sidechain_address_object_type, sidechain_address_object> sidechain_address_id_type; + typedef object_id< protocol_ids, bitcoin_transaction_object_type,bitcoin_transaction_object> bitcoin_transaction_id_type; // implementation types class global_property_object; @@ -436,6 +439,7 @@ FC_REFLECT_ENUM( graphene::chain::object_type, (son_wallet_object_type) (son_wallet_transfer_object_type) (sidechain_address_object_type) + (bitcoin_transaction_object_type) (OBJECT_TYPE_COUNT) ) FC_REFLECT_ENUM( graphene::chain::impl_object_type, @@ -512,6 +516,7 @@ FC_REFLECT_TYPENAME( graphene::chain::son_proposal_id_type ) FC_REFLECT_TYPENAME( graphene::chain::son_wallet_id_type ) FC_REFLECT_TYPENAME( graphene::chain::son_wallet_transfer_id_type ) FC_REFLECT_TYPENAME( graphene::chain::sidechain_address_id_type ) +FC_REFLECT_TYPENAME( graphene::chain::bitcoin_transaction_id_type ) FC_REFLECT( graphene::chain::void_t, ) diff --git a/libraries/chain/include/graphene/chain/sidechain_transaction_evaluator.hpp b/libraries/chain/include/graphene/chain/sidechain_transaction_evaluator.hpp new file mode 100644 index 00000000..90390fb0 --- /dev/null +++ b/libraries/chain/include/graphene/chain/sidechain_transaction_evaluator.hpp @@ -0,0 +1,26 @@ +#pragma once +#include +#include + +namespace graphene { namespace chain { + +class bitcoin_transaction_send_evaluator : public evaluator +{ +public: + typedef bitcoin_transaction_send_operation operation_type; + + void_result do_evaluate(const bitcoin_transaction_send_operation& o); + object_id_type do_apply(const bitcoin_transaction_send_operation& o); +}; + +class bitcoin_transaction_sign_evaluator : public evaluator +{ +public: + typedef bitcoin_transaction_sign_operation operation_type; + + void_result do_evaluate(const bitcoin_transaction_sign_operation& o); + object_id_type do_apply(const bitcoin_transaction_sign_operation& o); + void update_proposal( const bitcoin_transaction_sign_operation& o ); +}; + +} } // namespace graphene::chain \ No newline at end of file diff --git a/libraries/chain/include/graphene/chain/sidechain_transaction_object.hpp b/libraries/chain/include/graphene/chain/sidechain_transaction_object.hpp new file mode 100644 index 00000000..95417852 --- /dev/null +++ b/libraries/chain/include/graphene/chain/sidechain_transaction_object.hpp @@ -0,0 +1,39 @@ +#pragma once +#include +#include + +namespace graphene { namespace chain { + using namespace graphene::db; + + /** + * @class bitcoin_transaction_object + * @brief tracks state of bitcoin transaction. + * @ingroup object + */ + class bitcoin_transaction_object : public abstract_object + { + public: + static const uint8_t space_id = protocol_ids; + static const uint8_t type_id = bitcoin_transaction_object_type; + // Bitcoin structs go here. + bool processed = false; + fc::flat_map> signatures; + }; + + struct by_processed; + using bitcoin_transaction_multi_index_type = multi_index_container< + bitcoin_transaction_object, + indexed_by< + ordered_unique< tag, + member + >, + ordered_non_unique< tag, + member + > + > + >; + using bitcoin_transaction_index = generic_index; +} } // graphene::chain + +FC_REFLECT_DERIVED( graphene::chain::bitcoin_transaction_object, (graphene::db::object), + (processed)(signatures) ) diff --git a/libraries/chain/sidechain_transaction_evaluator.cpp b/libraries/chain/sidechain_transaction_evaluator.cpp new file mode 100644 index 00000000..292284ea --- /dev/null +++ b/libraries/chain/sidechain_transaction_evaluator.cpp @@ -0,0 +1,83 @@ +#include + +#include +#include +#include +#include +#include + +namespace graphene { namespace chain { + +void_result bitcoin_transaction_send_evaluator::do_evaluate(const bitcoin_transaction_send_operation& op) +{ try{ + FC_ASSERT(db().head_block_time() >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK"); // can be removed after HF date pass + FC_ASSERT(op.payer == db().get_global_properties().parameters.get_son_btc_account_id(), "Payer should be the son btc account"); + return void_result(); +} FC_CAPTURE_AND_RETHROW( (op) ) } + +object_id_type bitcoin_transaction_send_evaluator::do_apply(const bitcoin_transaction_send_operation& op) +{ try { + const auto& new_bitcoin_transaction_object = db().create( [&]( bitcoin_transaction_object& obj ){ + obj.processed = false; + obj.signatures = op.signatures; + }); + return new_bitcoin_transaction_object.id; +} FC_CAPTURE_AND_RETHROW( (op) ) } + +void_result bitcoin_transaction_sign_evaluator::do_evaluate(const bitcoin_transaction_sign_operation& op) +{ try { + FC_ASSERT(db().head_block_time() >= HARDFORK_SON_TIME, "Not allowed until SON HARDFORK"); // can be removed after HF date pass + const auto& proposal_idx = db().get_index_type().indices().get(); + const auto& proposal_itr = proposal_idx.find( op.proposal_id ); + FC_ASSERT( proposal_idx.end() != proposal_itr, "proposal not found"); + // Checks can this SON approve this proposal + auto can_this_son_approve_this_proposal = [ & ]() { + const auto& sidx = db().get_index_type().indices().get(); + auto son_obj = sidx.find( op.payer ); + if( son_obj == sidx.end() ) { + return false; + } + // TODO: Check if the SON is included in the PW script. + return true; + }; + + FC_ASSERT(can_this_son_approve_this_proposal(), "Invalid approval received"); + return void_result(); +} FC_CAPTURE_AND_RETHROW( (op) ) } + +object_id_type bitcoin_transaction_sign_evaluator::do_apply(const bitcoin_transaction_sign_operation& op) +{ try { + const auto& proposal = op.proposal_id( db() ); + const auto& sidx = db().get_index_type().indices().get(); + auto son_obj = sidx.find( op.payer ); + + db().modify( proposal, [&]( proposal_object& po ) { + auto bitcoin_transaction_send_op = po.proposed_transaction.operations[0].get(); + bitcoin_transaction_send_op.signatures[son_obj->id] = op.signatures; + po.proposed_transaction.operations[0] = bitcoin_transaction_send_op; + }); + + update_proposal( op ); +} FC_CAPTURE_AND_RETHROW( (op) ) } + +void bitcoin_transaction_sign_evaluator::update_proposal( const bitcoin_transaction_sign_operation& op ) +{ + database& d = db(); + proposal_update_operation update_op; + + update_op.fee_paying_account = op.payer; + update_op.proposal = op.proposal_id; + update_op.active_approvals_to_add = { op.payer }; + + bool skip_fee_old = trx_state->skip_fee; + bool skip_fee_schedule_check_old = trx_state->skip_fee_schedule_check; + trx_state->skip_fee = true; + trx_state->skip_fee_schedule_check = true; + + d.apply_operation( *trx_state, update_op ); + + trx_state->skip_fee = skip_fee_old; + trx_state->skip_fee_schedule_check = skip_fee_schedule_check_old; +} + +} } // namespace graphene::chain diff --git a/tests/tests/sidechain_transaction_tests.cpp b/tests/tests/sidechain_transaction_tests.cpp new file mode 100644 index 00000000..8771ca7b --- /dev/null +++ b/tests/tests/sidechain_transaction_tests.cpp @@ -0,0 +1,298 @@ +#include + +#include "../common/database_fixture.hpp" + +#include +#include +#include +#include +#include + +using namespace graphene; +using namespace graphene::chain; +using namespace graphene::chain::test; + +BOOST_FIXTURE_TEST_SUITE(sidechain_transaction_tests, database_fixture) + +BOOST_AUTO_TEST_CASE(bitcoin_transaction_send_test) +{ + + try + { + BOOST_TEST_MESSAGE("bitcoin_transaction_send_test"); + + generate_blocks(HARDFORK_SON_TIME); + generate_block(); + set_expiration(db, trx); + + ACTORS((alice)(bob)); + + upgrade_to_lifetime_member(alice); + upgrade_to_lifetime_member(bob); + + transfer(committee_account, alice_id, asset(500000 * GRAPHENE_BLOCKCHAIN_PRECISION)); + transfer(committee_account, bob_id, asset(500000 * GRAPHENE_BLOCKCHAIN_PRECISION)); + + generate_block(); + set_expiration(db, trx); + + std::string test_url = "https://create_son_test"; + + // create deposit vesting + vesting_balance_id_type deposit_alice; + { + vesting_balance_create_operation op; + op.creator = alice_id; + op.owner = alice_id; + op.amount = asset(500 * GRAPHENE_BLOCKCHAIN_PRECISION); + op.balance_type = vesting_balance_type::son; + op.policy = dormant_vesting_policy_initializer{}; + trx.operations.push_back(op); + sign(trx, alice_private_key); + processed_transaction ptx = PUSH_TX(db, trx, ~0); + trx.clear(); + deposit_alice = ptx.operation_results[0].get(); + } + generate_block(); + set_expiration(db, trx); + + // create payment normal vesting + vesting_balance_id_type payment_alice; + { + vesting_balance_create_operation op; + op.creator = alice_id; + op.owner = alice_id; + op.amount = asset(500 * GRAPHENE_BLOCKCHAIN_PRECISION); + op.balance_type = vesting_balance_type::normal; + trx.operations.push_back(op); + sign(trx, alice_private_key); + processed_transaction ptx = PUSH_TX(db, trx, ~0); + trx.clear(); + payment_alice = ptx.operation_results[0].get(); + } + + generate_block(); + set_expiration(db, trx); + + // alice becomes son + { + flat_map sidechain_public_keys; + sidechain_public_keys[graphene::peerplays_sidechain::sidechain_type::bitcoin] = "bitcoin address"; + + son_create_operation op; + op.owner_account = alice_id; + op.url = test_url; + op.deposit = deposit_alice; + op.pay_vb = payment_alice; + op.signing_key = alice_public_key; + op.sidechain_public_keys = sidechain_public_keys; + trx.operations.push_back(op); + sign(trx, alice_private_key); + PUSH_TX(db, trx, ~0); + trx.clear(); + } + generate_block(); + set_expiration(db, trx); + + // create deposit vesting + vesting_balance_id_type deposit_bob; + { + vesting_balance_create_operation op; + op.creator = bob_id; + op.owner = bob_id; + op.amount = asset(500 * GRAPHENE_BLOCKCHAIN_PRECISION); + op.balance_type = vesting_balance_type::son; + op.policy = dormant_vesting_policy_initializer{}; + trx.operations.push_back(op); + sign(trx, bob_private_key); + processed_transaction ptx = PUSH_TX(db, trx, ~0); + trx.clear(); + deposit_bob = ptx.operation_results[0].get(); + } + generate_block(); + set_expiration(db, trx); + + // create payment normal vesting + vesting_balance_id_type payment_bob; + { + vesting_balance_create_operation op; + op.creator = bob_id; + op.owner = bob_id; + op.amount = asset(500 * GRAPHENE_BLOCKCHAIN_PRECISION); + op.balance_type = vesting_balance_type::normal; + trx.operations.push_back(op); + sign(trx, bob_private_key); + processed_transaction ptx = PUSH_TX(db, trx, ~0); + trx.clear(); + payment_bob = ptx.operation_results[0].get(); + } + generate_block(); + set_expiration(db, trx); + + // bob becomes son + { + flat_map sidechain_public_keys; + sidechain_public_keys[graphene::peerplays_sidechain::sidechain_type::bitcoin] = "bitcoin address"; + + son_create_operation op; + op.owner_account = bob_id; + op.url = test_url; + op.deposit = deposit_bob; + op.pay_vb = payment_bob; + op.signing_key = bob_public_key; + op.sidechain_public_keys = sidechain_public_keys; + trx.operations.push_back(op); + sign(trx, alice_private_key); + PUSH_TX(db, trx, ~0); + trx.clear(); + } + generate_block(); + + generate_block(); + + const auto &son_btc_account = db.create([&](account_object &obj) { + obj.name = "son_btc_account"; + obj.statistics = db.create([&](account_statistics_object &acc_stat) { acc_stat.owner = obj.id; }).id; + obj.membership_expiration_date = time_point_sec::maximum(); + obj.network_fee_percentage = GRAPHENE_DEFAULT_NETWORK_PERCENT_OF_FEE; + obj.lifetime_referrer_fee_percentage = GRAPHENE_100_PERCENT - GRAPHENE_DEFAULT_NETWORK_PERCENT_OF_FEE; + + obj.owner.add_authority(bob_id, 1); + obj.active.add_authority(bob_id, 1); + obj.owner.add_authority(alice_id, 1); + obj.active.add_authority(alice_id, 1); + obj.active.weight_threshold = 2; + obj.owner.weight_threshold = 2; + }); + + db.modify( db.get_global_properties(), [&]( global_property_object& _gpo ) + { + _gpo.parameters.extensions.value.son_btc_account = son_btc_account.get_id(); + if( _gpo.pending_parameters ) + _gpo.pending_parameters->extensions.value.son_btc_account = son_btc_account.get_id(); + }); + + generate_block(); + + const global_property_object &gpo = db.get_global_properties(); + + { + BOOST_TEST_MESSAGE("Send bitcoin_transaction_send_operation"); + + bitcoin_transaction_send_operation send_op; + + send_op.payer = db.get_global_properties().parameters.get_son_btc_account_id(); + + proposal_create_operation proposal_op; + proposal_op.fee_paying_account = alice_id; + proposal_op.proposed_ops.push_back(op_wrapper(send_op)); + uint32_t lifetime = (gpo.parameters.block_interval * gpo.active_witnesses.size()) * 3; + proposal_op.expiration_time = time_point_sec(db.head_block_time().sec_since_epoch() + lifetime); + + trx.operations.push_back(proposal_op); + set_expiration(db, trx); + sign(trx, alice_private_key); + PUSH_TX(db, trx, ~0); + trx.clear(); + } + generate_block(); + + BOOST_TEST_MESSAGE("Check proposal results"); + + const auto &idx = db.get_index_type().indices().get(); + BOOST_REQUIRE(idx.size() == 1); + auto obj = idx.find(proposal_id_type(0)); + BOOST_REQUIRE(obj != idx.end()); + + const auto& btidx = db.get_index_type().indices().get(); + BOOST_REQUIRE(btidx.size() == 0); + + std::vector a1 = {'a', 'l', 'i', 'c', 'e', '1'}; + std::vector a2 = {'a', 'l', 'i', 'c', 'e', '2'}; + std::vector a3 = {'a', 'l', 'i', 'c', 'e', '3'}; + + { + BOOST_TEST_MESSAGE("Send bitcoin_transaction_sign_operation"); + + bitcoin_transaction_sign_operation sign_op; + + sign_op.payer = alice_id; + sign_op.proposal_id = proposal_id_type(0); + sign_op.signatures.push_back(a1); + sign_op.signatures.push_back(a2); + sign_op.signatures.push_back(a3); + + trx.operations.push_back(sign_op); + set_expiration(db, trx); + sign(trx, alice_private_key); + PUSH_TX(db, trx, ~0); + trx.clear(); + } + + generate_block(); + + BOOST_REQUIRE(idx.size() == 1); + BOOST_REQUIRE(btidx.size() == 0); + auto pobj = idx.find(proposal_id_type(0)); + BOOST_REQUIRE(pobj != idx.end()); + + const auto& sidx = db.get_index_type().indices().get(); + const auto son_obj1 = sidx.find( alice_id ); + BOOST_REQUIRE(son_obj1 != sidx.end()); + + auto bitcoin_transaction_send_op = pobj->proposed_transaction.operations[0].get(); + BOOST_REQUIRE(bitcoin_transaction_send_op.signatures.size() == 1); + BOOST_REQUIRE(bitcoin_transaction_send_op.signatures[son_obj1->id][0] == a1); + BOOST_REQUIRE(bitcoin_transaction_send_op.signatures[son_obj1->id][1] == a2); + BOOST_REQUIRE(bitcoin_transaction_send_op.signatures[son_obj1->id][2] == a3); + + std::vector b1 = {'b', 'o', 'b', '1'}; + std::vector b2 = {'b', 'o', 'b', '2'}; + std::vector b3 = {'b', 'o', 'b', '3'}; + + { + BOOST_TEST_MESSAGE("Send bitcoin_transaction_sign_operation"); + + bitcoin_transaction_sign_operation sign_op; + + sign_op.payer = bob_id; + sign_op.proposal_id = proposal_id_type(0); + sign_op.signatures.push_back(b1); + sign_op.signatures.push_back(b2); + sign_op.signatures.push_back(b3); + + trx.operations.push_back(sign_op); + set_expiration(db, trx); + sign(trx, bob_private_key); + PUSH_TX(db, trx, ~0); + trx.clear(); + } + + generate_block(); + + BOOST_REQUIRE(idx.size() == 0); + + const auto son_obj2 = sidx.find( bob_id ); + BOOST_REQUIRE(son_obj2 != sidx.end()); + + BOOST_REQUIRE(btidx.size() == 1); + + const auto btobj = btidx.find(bitcoin_transaction_id_type(0)); + BOOST_REQUIRE(btobj != btidx.end()); + + BOOST_REQUIRE(btobj->processed == false); + + auto sigs = btobj->signatures; + + BOOST_REQUIRE(sigs[son_obj1->id][0] == a1); + BOOST_REQUIRE(sigs[son_obj1->id][1] == a2); + BOOST_REQUIRE(sigs[son_obj1->id][2] == a3); + + BOOST_REQUIRE(sigs[son_obj2->id][0] == b1); + BOOST_REQUIRE(sigs[son_obj2->id][1] == b2); + BOOST_REQUIRE(sigs[son_obj2->id][2] == b3); + } + FC_LOG_AND_RETHROW() +} + +BOOST_AUTO_TEST_SUITE_END()