SideChain implementation

.gitignore

@@ -25,6 +25,11 @@ tests/chain_bench
 tests/chain_test
 tests/intense_test
 tests/performance_test
+tests/betting_test
+tests/tournament_test
+tests/random_test
+tests/sidechain_test
+tests/generate_empty_blocks/generate_empty_blocks
 
 doxygen
 

CMakeLists.txt

@@ -60,7 +60,7 @@ IF( WIN32 )
   set(BOOST_ALL_DYN_LINK OFF) # force dynamic linking for all libraries
 ENDIF(WIN32)
 
-FIND_PACKAGE(Boost 1.57 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
+FIND_PACKAGE(Boost 1.60 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
 # For Boost 1.53 on windows, coroutine was not in BOOST_LIBRARYDIR and do not need it to build,  but if boost versin >= 1.54, find coroutine otherwise will cause link errors
 IF(NOT "${Boost_VERSION}" MATCHES "1.53(.*)")
    SET(BOOST_LIBRARIES_TEMP ${Boost_LIBRARIES})
@@ -132,6 +132,9 @@ else( WIN32 ) # Apple AND Linux
 
     if( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" )
         set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-builtin-memcmp" )
+        if ( CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6.0 )
+            set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fpermissive" )
+        endif()
     elseif( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" )
         if( CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 4.0.0 OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.0.0 )
             set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-invalid-partial-specialization" )

libraries/CMakeLists.txt

@@ -10,3 +10,4 @@ add_subdirectory( utilities )
 add_subdirectory( app )
 add_subdirectory( plugins )
 add_subdirectory( wallet )
+add_subdirectory( sidechain )

libraries/app/application.cpp

@@ -538,7 +538,9 @@ namespace detail {
             // you can help the network code out by throwing a block_older_than_undo_history exception.
             // when the net code sees that, it will stop trying to push blocks from that chain, but
             // leave that peer connected so that they can get sync blocks from us
-            bool result = _chain_db->push_block(blk_msg.block, (_is_block_producer | _force_validate) ? database::skip_nothing : database::skip_transaction_signatures);
+            auto skip_nothing_mode = sync_mode ? database::skip_nothing | database::skip_btc_tx_sending : database::skip_nothing;
+            auto skip_transaction_signatures_mode = sync_mode ? database::skip_transaction_signatures | database::skip_btc_tx_sending : database::skip_transaction_signatures;
+            bool result = _chain_db->push_block(blk_msg.block, (_is_block_producer | _force_validate) ? skip_nothing_mode : skip_transaction_signatures_mode);
 
             // the block was accepted, so we now know all of the transactions contained in the block
             if (!sync_mode)
@@ -963,6 +965,11 @@ void application::set_program_options(boost::program_options::options_descriptio
          ("genesis-json", bpo::value<boost::filesystem::path>(), "File to read Genesis State from")
          ("dbg-init-key", bpo::value<string>(), "Block signing key to use for init witnesses, overrides genesis file")
          ("api-access", bpo::value<boost::filesystem::path>(), "JSON file specifying API permissions")
+         ("bitcoin-node-ip", bpo::value<string>()->implicit_value("127.0.0.1"), "IP address of Bitcoin node")
+         ("bitcoin-node-zmq-port", bpo::value<uint32_t>()->implicit_value(28332), "ZMQ port of Bitcoin node")
+         ("bitcoin-node-rpc-port", bpo::value<uint32_t>()->implicit_value(18332), "RPC port of Bitcoin node")
+         ("bitcoin-node-rpc-user", bpo::value<string>(), "Bitcoin RPC user")
+         ("bitcoin-node-rpc-password", bpo::value<string>(), "Bitcoin RPC password")
          ;
    command_line_options.add(configuration_file_options);
    command_line_options.add_options()

libraries/app/database_api.cpp

@@ -161,6 +161,9 @@ class database_api_impl : public std::enable_shared_from_this<database_api_impl>
       vector<tournament_object> get_tournaments_by_state(tournament_id_type stop, unsigned limit, tournament_id_type start, tournament_state state);
       vector<tournament_id_type> get_registered_tournaments(account_id_type account_filter, uint32_t limit) const;
 
+      //Sidechain
+      vector<bitcoin_address_object> get_bitcoin_addresses(const account_id_type& acc_id) const;
+
 
    //private:
       template<typename T>
@@ -172,7 +175,6 @@ class database_api_impl : public std::enable_shared_from_this<database_api_impl>
 
          if( !is_subscribed_to_item(i) )
          {
-            idump((i));
             _subscribe_filter.insert( vec.data(), vec.size() );//(vecconst char*)&i, sizeof(i) );
          }
       }
@@ -2021,6 +2023,32 @@ vector<tournament_id_type> database_api_impl::get_registered_tournaments(account
    return tournament_ids;
 }
 
+//////////////////////////////////////////////////////////////////////
+//                                                                  //
+// Sidechain                                                        //
+//                                                                  //
+//////////////////////////////////////////////////////////////////////
+
+vector<bitcoin_address_object> database_api::get_bitcoin_addresses(const account_id_type& acc) const 
+{
+   return my->get_bitcoin_addresses(acc);
+}
+
+vector<bitcoin_address_object> database_api_impl::get_bitcoin_addresses(const account_id_type& acc) const 
+{
+   vector<bitcoin_address_object> result;
+
+   const auto& btc_addr_idx = _db.get_index_type<bitcoin_address_index>().indices().get<by_owner>();
+
+   auto itr = btc_addr_idx.lower_bound( acc );
+   while( itr != btc_addr_idx.end() && itr->owner == acc )
+   {
+      result.push_back( *itr );
+      ++itr;
+   }
+   return result;
+}
+
 //////////////////////////////////////////////////////////////////////
 //                                                                  //
 // Private methods                                                  //

libraries/app/impacted.cpp

@@ -282,6 +282,30 @@ struct get_impacted_account_visitor
       _impacted.insert( op.affiliate );
    }
    void operator()( const affiliate_referral_payout_operation& op ) { }
+   void operator()( const withdraw_pbtc_operation& op )
+   {
+      _impacted.insert( op.payer );
+   }
+   void operator()( const bitcoin_address_create_operation& op )
+   {
+      _impacted.insert( op.payer );
+   }
+   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 operator()( const bitcoin_issue_operation& op )
+   {
+      _impacted.insert( op.payer );
+   }
+   void operator()( const bitcoin_transaction_revert_operation& op )
+   {
+      _impacted.insert( op.payer );
+   }
 };
 
 void operation_get_impacted_accounts( const operation& op, flat_set<account_id_type>& result )

libraries/app/include/graphene/app/database_api.hpp

@@ -47,6 +47,7 @@
 #include <graphene/chain/worker_object.hpp>
 #include <graphene/chain/witness_object.hpp>
 #include <graphene/chain/tournament_object.hpp>
+#include <graphene/chain/bitcoin_address_object.hpp>
 
 #include <graphene/market_history/market_history_plugin.hpp>
 
@@ -644,6 +645,11 @@ class database_api
        * @return the list of tournaments that a given account is registered to play in
        */
       vector<tournament_id_type> get_registered_tournaments(account_id_type account_filter, uint32_t limit) const;
+
+      /**
+       * @return the list of bitcoin addresses which belong to acc_id
+       */
+      vector<bitcoin_address_object> get_bitcoin_addresses(const account_id_type& acc_id) const;
 
    private:
       std::shared_ptr< database_api_impl > my;
@@ -765,4 +771,5 @@ FC_API(graphene::app::database_api,
    (get_tournaments_by_state)
    (get_tournaments )
    (get_registered_tournaments)
+   (get_bitcoin_addresses)
 )

libraries/chain/CMakeLists.txt

@@ -21,6 +21,7 @@ if( GRAPHENE_DISABLE_UNITY_BUILD )
         db_market.cpp
         db_update.cpp
         db_witness_schedule.cpp
+        db_sidechain.cpp
       )
    message( STATUS "Graphene database unity build disabled" )
 else( GRAPHENE_DISABLE_UNITY_BUILD )
@@ -85,6 +86,9 @@ add_library( graphene_chain
              confidential_evaluator.cpp
              special_authority.cpp
              buyback.cpp
+             bitcoin_address_evaluator.cpp
+             bitcoin_transaction_evaluator.cpp
+             sidechain_evaluator.cpp
 
              account_object.cpp
              asset_object.cpp
@@ -110,14 +114,16 @@ add_library( graphene_chain
              betting_market_group_object.cpp
 
              affiliate_payout.cpp
+             withdraw_pbtc_evaluator.cpp
 
              ${HEADERS}
              ${PROTOCOL_HEADERS}
              "${CMAKE_CURRENT_BINARY_DIR}/include/graphene/chain/hardfork.hpp"
            )
 
 add_dependencies( graphene_chain build_hardfork_hpp )
-target_link_libraries( graphene_chain fc graphene_db )
+
+target_link_libraries( graphene_chain fc graphene_db sidechain )
 target_include_directories( graphene_chain
                             PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_BINARY_DIR}/include" )
 

libraries/chain/bitcoin_address_evaluator.cpp

@@ -0,0 +1,46 @@
+#include <graphene/chain/bitcoin_address_evaluator.hpp>
+#include <graphene/chain/database.hpp>
+#include <graphene/chain/exceptions.hpp>
+#include <graphene/chain/bitcoin_address_object.hpp>
+
+namespace graphene { namespace chain {
+
+void_result bitcoin_address_create_evaluator::do_evaluate( const bitcoin_address_create_operation& op )
+{
+   database& d = db();
+   FC_ASSERT( !d.is_sidechain_fork_needed() );
+   auto& acc_idx = d.get_index_type<account_index>().indices().get<by_id>();
+   auto acc_itr = acc_idx.find( op.owner );
+   FC_ASSERT( acc_itr != acc_idx.end() );
+   return void_result();
+}
+
+object_id_type bitcoin_address_create_evaluator::do_apply( const bitcoin_address_create_operation& op )
+{
+   database& d = db();
+   const auto pw_obj = d.get_latest_PW();
+   auto witnesses_keys = pw_obj.address.witnesses_keys;
+
+   const auto& new_btc_address = d.create<bitcoin_address_object>( [&]( bitcoin_address_object& a ) {
+      witnesses_keys.erase( --witnesses_keys.end() );
+      witnesses_keys.emplace( d.get_sidechain_account_id(), pubkey_from_id( a.id ) );
+
+      a.owner = op.owner;
+      a.address = sidechain::btc_multisig_segwit_address( SIDECHAIN_DEFAULT_NUMBER_SIG_MULTISIG, witnesses_keys );
+      a.count_invalid_pub_key = 1;
+   });
+
+   return new_btc_address.id;
+}
+
+public_key_type bitcoin_address_create_evaluator::pubkey_from_id( object_id_type id )
+{
+   fc::ecc::public_key_data pubkey_data;
+
+   pubkey_data.at( 0 ) = 0x02; // version
+   const auto hash = fc::sha256::hash( std::to_string( id.instance() ) ) ;
+   std::copy( hash.data(), hash.data() + hash.data_size(), pubkey_data.begin() + 1 );
+
+   return public_key_type( pubkey_data );
+}
+} } // namespace graphene::chain