Merge pull request #2762 from wanderingbort/feature/integrate-slim-net

integrate slim net plugin

contracts/hello/hello.cpp

 #include <eosiolib/eosio.hpp>
-#include <eosiolib/print.hpp>
 using namespace eosio;
 
 class hello : public eosio::contract {

contracts/hello/hello.hi_rc.md

@@ -3,7 +3,7 @@
 ## ACTION NAME: hi
 
 ### Parameters
-Input paramters:
+Input parameters:
 
 * `user` (string to include in the output)
 

libraries/chain/controller.cpp

@@ -130,6 +130,9 @@ struct controller_impl {
       }
    }
 
+   void emit_transaction(const transaction_metadata_ptr& trx, const transaction_trace_ptr& trace) {
+
+   }
 
    void on_irreversible( const block_state_ptr& s ) {
       if( !blog.head() )
@@ -547,6 +550,11 @@ struct controller_impl {
          (trx->on_result)(trace);
          trx->on_result = decltype(trx->on_result)(); //assign empty std::function
       }
+
+      if (!trx->accepted) {
+         emit( self.accepted_transaction, trx);
+         trx->accepted = true;
+      }
    }
 
    /**
@@ -609,8 +617,8 @@ struct controller_impl {
             fc::move_append( pending->_actions, move(trx_context.executed) );
 
             transaction_trace_notify( trx, trace );
-
             emit( self.applied_transaction, trace );
+
             trx_context.squash();
             return;
          } catch( ... ) {
@@ -620,8 +628,10 @@ struct controller_impl {
             throw;
          }
       } catch( const fc::exception& e ) {
-         trace->hard_except = e;
-         trace->hard_except_ptr = std::current_exception();
+         if (trace) {
+            trace->hard_except = e;
+            trace->hard_except_ptr = std::current_exception();
+         }
       }
       transaction_trace_notify( trx, trace );
    } FC_CAPTURE_AND_RETHROW() } /// push_transaction
@@ -1163,13 +1173,10 @@ void controller::log_irreversible_blocks() {
    */
 }
 signed_block_ptr controller::fetch_block_by_id( block_id_type id )const {
-   idump((id));
    auto state = my->fork_db.get_block(id);
    if( state ) return state->block;
-   edump((block_header::num_from_id(id)));
    auto bptr = fetch_block_by_number( block_header::num_from_id(id) );
    if( bptr && bptr->id() == id ) return bptr;
-   elog( "not found" );
    return signed_block_ptr();
 }
 
@@ -1179,10 +1186,18 @@ signed_block_ptr controller::fetch_block_by_number( uint32_t block_num )const  {
       return blk_state->block;
    }
 
-   ilog( "blog read by number ${n}", ("n", block_num) );
    return my->blog.read_block_by_num(block_num);
 } FC_CAPTURE_AND_RETHROW( (block_num) ) }
 
+block_id_type controller::get_block_id_for_num( uint32_t block_num )const { try {
+   auto blk_state = my->fork_db.get_block_in_current_chain_by_num( block_num );
+   if( blk_state ) {
+      return blk_state->id;
+   }
+
+   return my->blog.read_block_by_num(block_num)->id();
+} FC_CAPTURE_AND_RETHROW( (block_num) ) }
+
 void controller::pop_block() {
    my->pop_block();
 }

libraries/chain/include/eosio/chain/controller.hpp

@@ -136,6 +136,8 @@ namespace eosio { namespace chain {
          signed_block_ptr fetch_block_by_number( uint32_t block_num )const;
          signed_block_ptr fetch_block_by_id( block_id_type id )const;
 
+         block_id_type get_block_id_for_num( uint32_t block_num )const;
+
          void validate_referenced_accounts( const transaction& t )const;
          void validate_expiration( const transaction& t )const;
          void validate_tapos( const transaction& t )const;

libraries/chain/include/eosio/chain/transaction.hpp

@@ -128,6 +128,7 @@ namespace eosio { namespace chain {
       bytes                                   packed_context_free_data;
       bytes                                   packed_trx;
 
+      time_point_sec     expiration()const;
       transaction_id_type id()const;
       bytes              get_raw_transaction()const;
       vector<bytes>      get_context_free_data()const;
@@ -135,6 +136,10 @@ namespace eosio { namespace chain {
       signed_transaction get_signed_transaction()const;
       void               set_transaction(const transaction& t, compression_type _compression = none);
       void               set_transaction(const transaction& t, const vector<bytes>& cfd, compression_type _compression = none);
+
+   private:
+      mutable optional<transaction>           unpacked_trx; // <-- intermediate buffer used to retrieve values
+      void local_unpack()const;
    };
 
    using packed_transaction_ptr = std::shared_ptr<packed_transaction>;

libraries/chain/include/eosio/chain/transaction_metadata.hpp

@@ -20,6 +20,7 @@ class transaction_metadata {
       signed_transaction                    trx;
       packed_transaction                    packed_trx;
       optional<flat_set<public_key_type>>   signing_keys;
+      bool                                  accepted = false;
 
       std::function<void(const transaction_trace_ptr&)>       on_result;
 

libraries/chain/transaction.cpp

@@ -281,25 +281,40 @@ vector<bytes> packed_transaction::get_context_free_data()const
    } FC_CAPTURE_AND_RETHROW((compression)(packed_context_free_data))
 }
 
+time_point_sec packed_transaction::expiration()const
+{
+   local_unpack();
+   return unpacked_trx->expiration;
+}
+
 transaction_id_type packed_transaction::id()const
 {
-   try {
-      return get_transaction().id();
-   } FC_CAPTURE_AND_RETHROW((compression)(packed_trx))
+   local_unpack();
+   return get_transaction().id();
 }
 
-transaction packed_transaction::get_transaction()const
+void packed_transaction::local_unpack()const
 {
-   try {
-      switch(compression) {
+   if (!unpacked_trx) {
+      try {
+         switch(compression) {
          case none:
-            return unpack_transaction(packed_trx);
+            unpacked_trx = unpack_transaction(packed_trx);
+            break;
          case zlib:
-            return zlib_decompress_transaction(packed_trx);
+            unpacked_trx = zlib_decompress_transaction(packed_trx);
+            break;
          default:
             FC_THROW("Unknown transaction compression algorithm");
-      }
-   } FC_CAPTURE_AND_RETHROW((compression)(packed_trx))
+         }
+      } FC_CAPTURE_AND_RETHROW((compression)(packed_trx))
+   }
+}
+
+transaction packed_transaction::get_transaction()const
+{
+   local_unpack();
+   return transaction(*unpacked_trx);
 }
 
 signed_transaction packed_transaction::get_signed_transaction() const

libraries/fc/CMakeLists.txt

@@ -138,15 +138,6 @@ else()
   set( ZLIB_LIBRARIES "" )
 endif( ZLIB_FOUND )
 
-find_package( BZip2 )
-if( BZIP2_FOUND )
-   MESSAGE( STATUS "bzip2 found" )
-   add_definitions( -DHAS_BZIP2 )
-else()
-   MESSAGE( STATUS "bzip2 not found" )
-   set( BZIP2_LIBRARIES "" )
-endif( BZIP2_FOUND )
-
 # This will become unnecessary once we update to websocketpp which fixes upstream issue #395
 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DWEBSOCKETPP_STRICT_MASKING")
 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DBOOST_ASIO_HAS_STD_CHRONO")
@@ -162,7 +153,7 @@ target_include_directories(fc
 IF(NOT WIN32)
   set(LINK_USR_LOCAL_LIB -L/usr/local/lib)
 ENDIF()
-target_link_libraries( fc PUBLIC ${LINK_USR_LOCAL_LIB} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES} ${ZLIB_LIBRARIES} ${BZIP2_LIBRARIES} ${PLATFORM_SPECIFIC_LIBS} ${RPCRT4} ${CMAKE_DL_LIBS} ${rt_library} ${readline_libraries} ${ECC_LIB} )
+target_link_libraries( fc PUBLIC ${LINK_USR_LOCAL_LIB} ${Boost_LIBRARIES} ${OPENSSL_LIBRARIES} ${ZLIB_LIBRARIES} ${PLATFORM_SPECIFIC_LIBS} ${RPCRT4} ${CMAKE_DL_LIBS} ${rt_library} ${readline_libraries} ${ECC_LIB} )
 
 
 SET(OPENSSL_CONF_TARGET )

libraries/fc/include/fc/crypto/common.hpp

@@ -34,15 +34,14 @@ namespace fc { namespace crypto {
 
    template<typename Result, const char * const * Prefixes, int Position, typename KeyType, typename ...Rem>
    struct base58_str_parser_impl<Result, Prefixes, Position, KeyType, Rem...> {
-      static Result apply(const std::string& base58str)
+      static Result apply(const std::string& prefix_str, const std::string& data_str)
       {
          using data_type = typename KeyType::data_type;
          using wrapper = checksummed_data<data_type>;
          constexpr auto prefix = Prefixes[Position];
 
-         if (prefix_matches(prefix, base58str)) {
-            auto str = base58str.substr(const_strlen(prefix));
-            auto bin = fc::from_base58(str);
+         if (prefix == prefix_str) {
+            auto bin = fc::from_base58(data_str);
             FC_ASSERT(bin.size() >= sizeof(data_type) + sizeof(uint32_t));
             auto wrapped = fc::raw::unpack<wrapper>(bin);
             auto checksum = wrapper::calculate_checksum(wrapped.data, prefix);
@@ -50,14 +49,14 @@ namespace fc { namespace crypto {
             return Result(KeyType(wrapped.data));
          }
 
-         return base58_str_parser_impl<Result, Prefixes, Position + 1, Rem...>::apply(base58str);
+         return base58_str_parser_impl<Result, Prefixes, Position + 1, Rem...>::apply(prefix_str, data_str);
       }
    };
 
    template<typename Result, const char * const * Prefixes, int Position>
    struct base58_str_parser_impl<Result, Prefixes, Position> {
-      static Result apply(const std::string& base58str) {
-         FC_ASSERT(false, "No matching prefix for ${str}", ("str", base58str));
+      static Result apply(const std::string& prefix_str, const std::string& data_str ) {
+         FC_ASSERT(false, "No matching suite type for ${prefix}_${data}", ("prefix", prefix_str)("data",data_str));
       }
    };
 
@@ -73,7 +72,14 @@ namespace fc { namespace crypto {
    template<const char * const * Prefixes, typename ...Ts>
    struct base58_str_parser<fc::static_variant<Ts...>, Prefixes> {
       static fc::static_variant<Ts...> apply(const std::string& base58str) {
-         return base58_str_parser_impl<fc::static_variant<Ts...>, Prefixes, 0, Ts...>::apply(base58str);
+         const auto pivot = base58str.find('_');
+         FC_ASSERT(pivot != std::string::npos, "No delimiter in data, cannot determine suite type: ${str}", ("str", base58str));
+
+         const auto prefix_str = base58str.substr(0, pivot);
+         auto data_str = base58str.substr(pivot + 1);
+         FC_ASSERT(!data_str.empty(), "Data only has suite type prefix: ${str}", ("str", base58str));
+
+         return base58_str_parser_impl<fc::static_variant<Ts...>, Prefixes, 0, Ts...>::apply(prefix_str, data_str);
       }
    };
 
@@ -91,7 +97,7 @@ namespace fc { namespace crypto {
          auto packed = raw::pack( wrapper );
          auto data_str = to_base58( packed.data(), packed.size() );
          if (!is_default) {
-            data_str = string(Prefixes[position]) + data_str;
+            data_str = string(Prefixes[position]) + "_" + data_str;
          }
 
          return data_str;

libraries/fc/include/fc/crypto/private_key.hpp

@@ -9,7 +9,7 @@
 namespace fc { namespace crypto {
 
    namespace config {
-      constexpr const char* private_key_base_prefix = "EOS";
+      constexpr const char* private_key_base_prefix = "PVT";
       constexpr const char* private_key_prefix[] = {
          "K1",
          "R1"

libraries/fc/include/fc/crypto/public_key.hpp

@@ -8,7 +8,8 @@
 
 namespace fc { namespace crypto {
    namespace config {
-      constexpr const char* public_key_base_prefix = "EOS";
+      constexpr const char* public_key_legacy_prefix = "EOS";
+      constexpr const char* public_key_base_prefix = "PUB";
       constexpr const char* public_key_prefix[] = {
          "K1",
          "R1"

libraries/fc/include/fc/crypto/signature.hpp

@@ -7,7 +7,7 @@
 
 namespace fc { namespace crypto {
    namespace config {
-      constexpr const char* signature_base_prefix = "EOS";
+      constexpr const char* signature_base_prefix = "SIG";
       constexpr const char* signature_prefix[] = {
          "K1",
          "R1"

libraries/fc/src/crypto/private_key.cpp

@@ -90,18 +90,23 @@ namespace fc { namespace crypto {
 
    static private_key::storage_type parse_base58(const string& base58str)
    {
-      try {
+      if (base58str.find('_') == std::string::npos) {
          // wif import
          using default_type = private_key::storage_type::template type_at<0>;
          return private_key::storage_type(from_wif<default_type>(base58str));
-      } catch (...) {
-         // wif import failed
-      }
+      } else {
+         constexpr auto prefix = config::private_key_base_prefix;
+
+         const auto pivot = base58str.find('_');
+         FC_ASSERT(pivot != std::string::npos, "No delimiter in string, cannot determine type: ${str}", ("str", base58str));
 
-      constexpr auto prefix = config::private_key_base_prefix;
-      FC_ASSERT(prefix_matches(prefix, base58str), "Private Key has invalid prefix: ${str}", ("str", base58str));
-      auto sub_str = base58str.substr(const_strlen(prefix));
-      return base58_str_parser<private_key::storage_type, config::private_key_prefix>::apply(sub_str);
+         const auto prefix_str = base58str.substr(0, pivot);
+         FC_ASSERT(prefix == prefix_str, "Private Key has invalid prefix: ${str}", ("str", base58str)("prefix_str", prefix_str));
+
+         auto data_str = base58str.substr(pivot + 1);
+         FC_ASSERT(!data_str.empty(), "Private Key has no data: ${str}", ("str", base58str));
+         return base58_str_parser<private_key::storage_type, config::private_key_prefix>::apply(data_str);
+      }
    }
 
    private_key::private_key(const std::string& base58str)
@@ -118,7 +123,7 @@ namespace fc { namespace crypto {
       }
 
       auto data_str = _storage.visit(base58str_visitor<storage_type, config::private_key_prefix>());
-      return std::string(config::private_key_base_prefix) + data_str;
+      return std::string(config::private_key_base_prefix) + "_" + data_str;
    }
 
    std::ostream& operator<<(std::ostream& s, const private_key& k) {

libraries/fc/src/crypto/public_key.cpp

@@ -26,25 +26,30 @@ namespace fc { namespace crypto {
 
    static public_key::storage_type parse_base58(const std::string& base58str)
    {
-      constexpr auto prefix = config::public_key_base_prefix;
-      FC_ASSERT(prefix_matches(prefix, base58str), "Public Key has invalid prefix: ${str}", ("str", base58str));
-
-      auto sub_str = base58str.substr(const_strlen(prefix));
-      try {
+      constexpr auto legacy_prefix = config::public_key_legacy_prefix;
+      if(prefix_matches(legacy_prefix, base58str) && base58str.find('_') == std::string::npos ) {
+         auto sub_str = base58str.substr(const_strlen(legacy_prefix));
          using default_type = typename public_key::storage_type::template type_at<0>;
          using data_type = default_type::data_type;
          using wrapper = checksummed_data<data_type>;
          auto bin = fc::from_base58(sub_str);
-         if (bin.size() == sizeof(data_type) + sizeof(uint32_t)) {
-            auto wrapped = fc::raw::unpack<wrapper>(bin);
-            FC_ASSERT(wrapper::calculate_checksum(wrapped.data) == wrapped.check);
-            return public_key::storage_type(default_type(wrapped.data));
-         }
-      } catch (...) {
-         // default import failed
+         FC_ASSERT(bin.size() == sizeof(data_type) + sizeof(uint32_t), "");
+         auto wrapped = fc::raw::unpack<wrapper>(bin);
+         FC_ASSERT(wrapper::calculate_checksum(wrapped.data) == wrapped.check);
+         return public_key::storage_type(default_type(wrapped.data));
+      } else {
+         constexpr auto prefix = config::public_key_base_prefix;
+
+         const auto pivot = base58str.find('_');
+         FC_ASSERT(pivot != std::string::npos, "No delimiter in string, cannot determine data type: ${str}", ("str", base58str));
+
+         const auto prefix_str = base58str.substr(0, pivot);
+         FC_ASSERT(prefix == prefix_str, "Public Key has invalid prefix: ${str}", ("str", base58str)("prefix_str", prefix_str));
+
+         auto data_str = base58str.substr(pivot + 1);
+         FC_ASSERT(!data_str.empty(), "Public Key has no data: ${str}", ("str", base58str));
+         return base58_str_parser<public_key::storage_type, config::public_key_prefix>::apply(data_str);
       }
-
-      return base58_str_parser<public_key::storage_type, config::public_key_prefix>::apply(sub_str);
    }
 
    public_key::public_key(const std::string& base58str)
@@ -66,7 +71,13 @@ namespace fc { namespace crypto {
    public_key::operator std::string() const
    {
       auto data_str = _storage.visit(base58str_visitor<storage_type, config::public_key_prefix, 0>());
-      return std::string(config::public_key_base_prefix) + data_str;
+
+      auto which = _storage.which();
+      if (which == 0) {
+         return std::string(config::public_key_legacy_prefix) + data_str;
+      } else {
+         return std::string(config::public_key_base_prefix) + "_" + data_str;
+      }
    }
 
    std::ostream& operator<<(std::ostream& s, const public_key& k) {

libraries/fc/src/crypto/signature.cpp

@@ -15,24 +15,16 @@ namespace fc { namespace crypto {
    static signature::storage_type parse_base58(const std::string& base58str)
    {
       constexpr auto prefix = config::signature_base_prefix;
-      FC_ASSERT(prefix_matches(prefix, base58str), "Signature has invalid prefix: ${str}", ("str", base58str));
 
-      auto sub_str = base58str.substr(const_strlen(prefix));
-      try {
-         using default_type = signature::storage_type::template type_at<0>;
-         using data_type = default_type::data_type;
-         using wrapper = checksummed_data<data_type>;
-         auto bin = fc::from_base58(sub_str);
-         if (bin.size() == sizeof(data_type) + sizeof(uint32_t)) {
-            auto wrapped = fc::raw::unpack<wrapper>(bin);
-            FC_ASSERT(wrapper::calculate_checksum(wrapped.data) == wrapped.check);
-            return signature::storage_type(default_type(wrapped.data));
-         }
-      } catch (...) {
-         // default import failed
-      }
+      const auto pivot = base58str.find('_');
+      FC_ASSERT(pivot != std::string::npos, "No delimiter in string, cannot determine type: ${str}", ("str", base58str));
+
+      const auto prefix_str = base58str.substr(0, pivot);
+      FC_ASSERT(prefix == prefix_str, "Signature Key has invalid prefix: ${str}", ("str", base58str)("prefix_str", prefix_str));
 
-      return base58_str_parser<signature::storage_type, config::signature_prefix>::apply(sub_str);
+      auto data_str = base58str.substr(pivot + 1);
+      FC_ASSERT(!data_str.empty(), "Signature has no data: ${str}", ("str", base58str));
+      return base58_str_parser<signature::storage_type, config::signature_prefix>::apply(data_str);
    }
 
    signature::signature(const std::string& base58str)
@@ -41,8 +33,8 @@ namespace fc { namespace crypto {
 
    signature::operator std::string() const
    {
-      auto data_str = _storage.visit(base58str_visitor<storage_type, config::signature_prefix, 0>());
-      return std::string(config::signature_base_prefix) + data_str;
+      auto data_str = _storage.visit(base58str_visitor<storage_type, config::signature_prefix>());
+      return std::string(config::signature_base_prefix) + "_" + data_str;
    }
 
    std::ostream& operator<<(std::ostream& s, const signature& k) {

libraries/fc/test/crypto/test_cypher_suites.cpp

@@ -21,8 +21,8 @@ BOOST_AUTO_TEST_CASE(test_k1) try {
 } FC_LOG_AND_RETHROW();
 
 BOOST_AUTO_TEST_CASE(test_r1) try {
-   auto private_key_string = std::string("EOSR1iyQmnyPEGvFd8uffnk152WC2WryBjgTrg22fXQryuGL9mU6qW");
-   auto expected_public_key = std::string("EOSR16EPHFSKVYHBjQgxVGQPrwCxTg7BbZ69H9i4gztN9deKTEXYne4");
+   auto private_key_string = std::string("PVT_R1_iyQmnyPEGvFd8uffnk152WC2WryBjgTrg22fXQryuGL9mU6qW");
+   auto expected_public_key = std::string("PUB_R1_6EPHFSKVYHBjQgxVGQPrwCxTg7BbZ69H9i4gztN9deKTEXYne4");
    auto test_private_key = private_key(private_key_string);
    auto test_public_key = test_private_key.get_public_key();
 

plugins/CMakeLists.txt

-#add_subdirectory(net_plugin)
-#add_subdirectory(net_api_plugin)
+add_subdirectory(net_plugin)
+add_subdirectory(net_api_plugin)
 add_subdirectory(http_plugin)
 add_subdirectory(chain_plugin)
 add_subdirectory(chain_api_plugin)
@@ -11,7 +11,7 @@ add_subdirectory(history_api_plugin)
 #add_subdirectory(account_history_api_plugin)
 add_subdirectory(wallet_plugin)
 add_subdirectory(wallet_api_plugin)
-#add_subdirectory(txn_test_gen_plugin)
+add_subdirectory(txn_test_gen_plugin)
 #add_subdirectory(faucet_testnet_plugin)
 #add_subdirectory(mongo_db_plugin)
 

plugins/mongo_db_plugin/mongo_db_plugin.cpp

@@ -76,7 +76,7 @@ public:
    // transaction.id -> actions
    std::map<std::string, std::vector<chain::action>> reversible_actions;
    boost::mutex mtx;
-   boost::condition_variable condtion;
+   boost::condition_variable condition;
    boost::thread consume_thread;
    boost::atomic<bool> done{false};
    boost::atomic<bool> startup{true};
@@ -116,7 +116,7 @@ void mongo_db_plugin_impl::applied_irreversible_block(const signed_block& block)
          boost::mutex::scoped_lock lock(mtx);
          signed_block_queue.push_back(block);
          lock.unlock();
-         condtion.notify_one();
+         condition.notify_one();
       }
    } catch (fc::exception& e) {
       elog("FC Exception while applied_irreversible_block ${e}", ("e", e.to_string()));
@@ -136,7 +136,7 @@ void mongo_db_plugin_impl::applied_block(const block_trace& bt) {
          boost::mutex::scoped_lock lock(mtx);
          block_trace_queue.emplace_back(std::make_pair(bt, bt.block));
          lock.unlock();
-         condtion.notify_one();
+         condition.notify_one();
       }
    } catch (fc::exception& e) {
       elog("FC Exception while applied_block ${e}", ("e", e.to_string()));
@@ -152,7 +152,7 @@ void mongo_db_plugin_impl::consume_blocks() {
       while (true) {
          boost::mutex::scoped_lock lock(mtx);
          while (signed_block_queue.empty() && block_trace_queue.empty() && !done) {
-            condtion.wait(lock);
+            condition.wait(lock);
          }
          // capture blocks for processing
          size_t block_trace_size = block_trace_queue.size();
@@ -705,7 +705,7 @@ mongo_db_plugin_impl::mongo_db_plugin_impl()
 mongo_db_plugin_impl::~mongo_db_plugin_impl() {
    try {
       done = true;
-      condtion.notify_one();
+      condition.notify_one();
 
       consume_thread.join();
    } catch (std::exception& e) {

plugins/net_plugin/include/eosio/net_plugin/protocol.hpp

@@ -14,6 +14,13 @@ namespace eosio {
    static_assert(sizeof(std::chrono::system_clock::duration::rep) >= 8, "system_clock is expected to be at least 64 bits");
    typedef std::chrono::system_clock::duration::rep tstamp;
 
+   struct chain_size_message {
+      uint32_t                   last_irreversible_block_num = 0;
+      block_id_type              last_irreversible_block_id;
+      uint32_t                   head_num = 0;
+      block_id_type              head_id;
+   };
+
    struct handshake_message {
       uint16_t                   network_version = 0; ///< incremental value above a computed base
       chain_id_type              chain_id; ///< used to identify chain
@@ -32,6 +39,7 @@ namespace eosio {
       int16_t                    generation;
    };
 
+
   enum go_away_reason {
     no_reason, ///< no reason to go away
     self, ///< the connection is to itself
@@ -130,18 +138,21 @@ namespace eosio {
    };
 
    using net_message = static_variant<handshake_message,
+                                      chain_size_message,
                                       go_away_message,
                                       time_message,
                                       notice_message,
                                       request_message,
                                       sync_request_message,
-                                      signed_block_ptr,
-                                      signed_transaction,
+                                      signed_block,
                                       packed_transaction>;
 
 } // namespace eosio
 
 FC_REFLECT( eosio::select_ids<fc::sha256>, (mode)(pending)(ids) )
+FC_REFLECT( eosio::chain_size_message,
+            (last_irreversible_block_num)(last_irreversible_block_id)
+            (head_num)(head_id))
 FC_REFLECT( eosio::handshake_message,
             (network_version)(chain_id)(node_id)(key)
             (time)(token)(sig)(p2p_address)

plugins/net_plugin/net_plugin.cpp

@@ -41,16 +41,16 @@ namespace eosio {
    using boost::asio::ip::address_v4;
    using boost::asio::ip::host_name;
    using boost::intrusive::rbtree;
+   using boost::multi_index_container;
 
    using fc::time_point;
    using fc::time_point_sec;
    using eosio::chain::transaction_id_type;
    namespace bip = boost::interprocess;
-   using chain::contracts::uint16;
 
    class connection;
    class sync_manager;
-   class big_msg_manager;
+   class dispatch_manager;
 
    using connection_ptr = std::shared_ptr<connection>;
    using connection_wptr = std::weak_ptr<connection>;
@@ -165,7 +165,7 @@ namespace eosio {
       std::set< connection_ptr >       connections;
       bool                             done = false;
       unique_ptr< sync_manager >       sync_master;
-      unique_ptr< big_msg_manager >    big_msg_master;
+      unique_ptr< dispatch_manager >   dispatcher;
 
       unique_ptr<boost::asio::steady_timer> connector_check;
       unique_ptr<boost::asio::steady_timer> transaction_check;
@@ -201,12 +201,17 @@ namespace eosio {
       template<typename VerifierFunc>
       void send_all( const net_message &msg, VerifierFunc verify );
 
-      static void transaction_ready( const transaction_metadata&, const packed_transaction& txn);
-      void broadcast_block_impl( const signed_block &sb);
+      void accepted_block_header(const block_state_ptr&);
+      void accepted_block(const block_state_ptr&);
+      void irreversible_block(const block_state_ptr&);
+      void accepted_transaction(const transaction_metadata_ptr&);
+      void applied_transaction(const transaction_trace_ptr&);
+      void accepted_confirmation(const header_confirmation&);
 
       bool is_valid( const handshake_message &msg);
 
       void handle_message( connection_ptr c, const handshake_message &msg);
+      void handle_message( connection_ptr c, const chain_size_message &msg);
       void handle_message( connection_ptr c, const go_away_message &msg );
       /** \name Peer Timestamps
        *  Time message handling
@@ -226,10 +231,8 @@ namespace eosio {
       void handle_message( connection_ptr c, const notice_message &msg);
       void handle_message( connection_ptr c, const request_message &msg);
       void handle_message( connection_ptr c, const sync_request_message &msg);
-      void handle_message( connection_ptr c, const signed_block_summary &msg);
       void handle_message( connection_ptr c, const signed_block &msg);
       void handle_message( connection_ptr c, const packed_transaction &msg);
-      void handle_message( connection_ptr c, const signed_transaction &msg);
 
       void start_conn_timer( );
       void start_txn_timer( );
@@ -368,7 +371,7 @@ namespace eosio {
    /**
     *
     */
-   struct block_state {
+   struct peer_block_state {
       block_id_type id;
       uint32_t      block_num;
       bool          is_known;
@@ -380,22 +383,22 @@ namespace eosio {
       void operator() (struct transaction_state &ts) {
          ts.requested_time = time_point::now();
       }
-      void operator () (struct block_state &bs) {
+      void operator () (struct eosio::peer_block_state &bs) {
          bs.requested_time = time_point::now();
       }
    } set_request_time;
 
    typedef multi_index_container<
-      block_state,
+      eosio::peer_block_state,
       indexed_by<
-         ordered_unique< tag<by_id>, member<block_state, block_id_type, &block_state::id > >,
-         ordered_unique< tag<by_block_num>, member<block_state, uint32_t, &block_state::block_num > >
+         ordered_unique< tag<by_id>, member<eosio::peer_block_state, block_id_type, &eosio::peer_block_state::id > >,
+         ordered_unique< tag<by_block_num>, member<eosio::peer_block_state, uint32_t, &eosio::peer_block_state::block_num > >
          >
-      > block_state_index;
+      > peer_block_state_index;
 
 
    struct update_known_by_peer {
-      void operator() (block_state& bs) {
+      void operator() (eosio::peer_block_state& bs) {
          bs.is_known = true;
       }
       void operator() (transaction_state& ts) {
@@ -429,7 +432,7 @@ namespace eosio {
       ~connection();
       void initialize();
 
-      block_state_index       blk_state;
+      peer_block_state_index       blk_state;
       transaction_state_index trx_state;
       optional<sync_state>    peer_requested;  // this peer is requesting info from us
       socket_ptr              socket;
@@ -606,24 +609,37 @@ namespace eosio {
 
    };
 
-   class big_msg_manager {
+   class dispatch_manager {
    public:
       uint32_t just_send_it_max;
-      connection_ptr pending_txn_source;
+
       struct block_request {
          block_id_type id;
          bool local_retry;
       };
       vector<block_request> req_blks;
-      vector<transaction_id_type> req_txn;
-
-      void bcast_block (const signed_block_summary& msg, connection_ptr skip = connection_ptr());
-      void bcast_transaction (const transaction_id_type& id,
-                              time_point_sec expiration,
-                              const packed_transaction& msg);
-      void rejected_transaction (const packed_transaction& msg);
-      void recv_block (connection_ptr conn, const signed_block_summary& msg);
-      void recv_transaction(connection_ptr c, const transaction_id_type& id);
+      vector<transaction_id_type> req_trx;
+
+      struct block_origin {
+         block_id_type id;
+         connection_ptr origin;
+      };
+
+      struct transaction_origin {
+         transaction_id_type id;
+         connection_ptr origin;
+      };
+
+      vector<block_origin> received_blocks;
+      vector<transaction_origin> received_transactions;
+
+      void bcast_transaction (const packed_transaction& msg);
+      void rejected_transaction (const transaction_id_type& msg);
+      void bcast_block (const signed_block& msg);
+      void rejected_block (const block_id_type &id);
+
+      void recv_block (connection_ptr conn, const block_id_type& msg);
+      void recv_transaction(connection_ptr conn, const transaction_id_type& id);
       void recv_notice (connection_ptr conn, const notice_message& msg, bool generated);
 
       void retry_fetch (connection_ptr conn);
@@ -729,7 +745,7 @@ namespace eosio {
       connecting = false;
       syncing = false;
       if( last_req ) {
-         my_impl->big_msg_master->retry_fetch (shared_from_this());
+         my_impl->dispatcher->retry_fetch (shared_from_this());
       }
       reset();
       sent_handshake_count = 0;
@@ -778,7 +794,7 @@ namespace eosio {
    }
 
    void connection::blk_send_branch() {
-      chain_controller &cc = my_impl->chain_plug->chain();
+      controller &cc = my_impl->chain_plug->chain();
       uint32_t head_num = cc.head_block_num ();
       notice_message note;
       note.known_blocks.mode = normal;
@@ -793,9 +809,8 @@ namespace eosio {
       uint32_t lib_num;
       try {
          lib_num = cc.last_irreversible_block_num();
-         if( lib_num != 0 )
-            lib_id = cc.get_block_id_for_num(lib_num);
-         head_id = cc.get_block_id_for_num(head_num);
+         lib_id = cc.last_irreversible_block_id();
+         head_id = cc.head_block_id();
       }
       catch (const assert_exception &ex) {
          elog( "unable to retrieve block info: ${n} for ${p}",("n",ex.to_string())("p",peer_name()));
@@ -807,11 +822,11 @@ namespace eosio {
       catch (...) {
       }
 
-      vector<optional<signed_block> > bstack;
+      vector<signed_block_ptr> bstack;
       block_id_type null_id;
       for (auto bid = head_id; bid != null_id && bid != lib_id; ) {
          try {
-            optional<signed_block> b = cc.fetch_block_by_id(bid);
+            signed_block_ptr b = cc.fetch_block_by_id(bid);
             if ( b ) {
                bid = b->previous;
                bstack.push_back(b);
@@ -837,12 +852,12 @@ namespace eosio {
    }
 
    void connection::blk_send(const vector<block_id_type> &ids) {
-      chain_controller &cc = my_impl->chain_plug->chain();
+      controller &cc = my_impl->chain_plug->chain();
       int count = 0;
       for(auto &blkid : ids) {
          ++count;
          try {
-            optional<signed_block> b = cc.fetch_block_by_id(blkid);
+            signed_block_ptr b = cc.fetch_block_by_id(blkid);
             if(b) {
                uint32_t bnum = b->block_num();
                bool send_whole = bnum <= cc.last_irreversible_block_num();
@@ -851,8 +866,8 @@ namespace eosio {
                   enqueue(net_message(*b));
                }
                else {
-                  signed_block_summary &sbs = *b;
-                  enqueue(net_message(sbs));
+                  //signed_block_summary &sbs = *b;
+                  enqueue(net_message(*b));
                }
             }
             else {
@@ -989,7 +1004,7 @@ namespace eosio {
    }
 
    bool connection::enqueue_sync_block() {
-      chain_controller& cc = app().find_plugin<chain_plugin>()->chain();
+      controller& cc = app().find_plugin<chain_plugin>()->chain();
       if (!peer_requested)
          return false;
       uint32_t num = ++peer_requested->last;
@@ -998,7 +1013,7 @@ namespace eosio {
          peer_requested.reset();
       }
       try {
-         fc::optional<signed_block> sb = cc.fetch_block_by_number(num);
+         signed_block_ptr sb = cc.fetch_block_by_number(num);
          if(sb) {
             enqueue( *sb, trigger_send);
             return true;
@@ -1094,7 +1109,7 @@ namespace eosio {
    void connection::fetch_timeout( boost::system::error_code ec ) {
       if( !ec ) {
          if( pending_fetch.valid() && !( pending_fetch->req_trx.empty( ) || pending_fetch->req_blocks.empty( ) ) ) {
-            my_impl->big_msg_master->retry_fetch (shared_from_this() );
+            my_impl->dispatcher->retry_fetch (shared_from_this() );
          }
       }
       else if( ec == boost::asio::error::operation_aborted ) {
@@ -1331,7 +1346,7 @@ namespace eosio {
    }
 
    void sync_manager::recv_handshake (connection_ptr c, const handshake_message &msg) {
-      chain_controller& cc = chain_plug->chain();
+      controller& cc = chain_plug->chain();
       uint32_t lib_num = cc.last_irreversible_block_num( );
       uint32_t peer_lib = msg.last_irreversible_block_num;
       reset_lib_num(c);
@@ -1510,7 +1525,15 @@ namespace eosio {
 
    //------------------------------------------------------------------------
 
-   void big_msg_manager::bcast_block (const signed_block_summary &bsum, connection_ptr skip) {
+   void dispatch_manager::bcast_block (const signed_block &bsum) {
+      connection_ptr skip;
+      for (auto org = received_blocks.begin(); org != received_blocks.end(); org++) {
+         if (org->id == bsum.id()) {
+            skip = org->origin;
+            received_blocks.erase(org);
+            break;
+         }
+      }
       net_message msg(bsum);
       uint32_t packsiz = fc::raw::pack_size(msg);
       uint32_t msgsiz = packsiz + sizeof(packsiz);
@@ -1529,7 +1552,7 @@ namespace eosio {
                const auto& bs = c->blk_state.find(bid);
                bool unknown = bs == c->blk_state.end();
                if (unknown) {
-                  c->blk_state.insert((block_state){bid,bnum,false,true,time_point()});
+                  c->blk_state.insert((eosio::peer_block_state){bid,bnum,false,true,time_point()});
                }
                else {
                   elog("${p} already has knowledge of block ${b}", ("p",c->peer_name())("b",bid));
@@ -1544,68 +1567,88 @@ namespace eosio {
             }
             const auto& prev = cp->blk_state.find (bsum.previous);
             if (prev != cp->blk_state.end() && !prev->is_known) {
-               cp->blk_state.insert((block_state){bid,bnum,false,true,time_point()});
+               cp->blk_state.insert((eosio::peer_block_state){bid,bnum,false,true,time_point()});
                cp->enqueue( pending_notify );
             }
             else {
-               cp->blk_state.insert((block_state){bid,bnum,true,true,time_point()});
+               cp->blk_state.insert((eosio::peer_block_state){bid,bnum,true,true,time_point()});
                cp->enqueue( bsum );
             }
          }
       }
    }
 
-   void big_msg_manager::rejected_transaction (const packed_transaction& txn) {
-      transaction_id_type tid = txn.get_transaction().id();
-      fc_dlog(logger,"not sending rejected transaction ${tid}",("tid",tid));
-      pending_txn_source.reset();
+   void dispatch_manager::rejected_block (const block_id_type& id) {
+      fc_dlog(logger,"not sending rejected transaction ${tid}",("tid",id));
+      for (auto org = received_blocks.begin(); org != received_blocks.end(); org++) {
+         if (org->id == id) {
+            received_blocks.erase(org);
+            break;
+         }
+      }
+   }
 
+   void dispatch_manager::rejected_transaction (const transaction_id_type& id) {
+      fc_dlog(logger,"not sending rejected transaction ${tid}",("tid",id));
+      for (auto org = received_transactions.begin(); org != received_transactions.end(); org++) {
+         if (org->id == id) {
+            received_transactions.erase(org);
+            break;
+         }
+      }
    }
 
-   void big_msg_manager::bcast_transaction (const transaction_id_type & txnid,
-                                            time_point_sec expiration,
-                                            const packed_transaction& txn) {
-      connection_ptr skip = pending_txn_source;
-      pending_txn_source.reset();
+   void dispatch_manager::bcast_transaction (const packed_transaction& trx) {
+      connection_ptr skip;
+      transaction_id_type id = trx.id();
+
+      for (auto org = received_transactions.begin(); org != received_transactions.end(); org++) {
+         if (org->id == id) {
+            skip = org->origin;
+            received_transactions.erase(org);
+            break;
+         }
+      }
+
 
-      for (auto ref = req_txn.begin(); ref != req_txn.end(); ++ref) {
-         if (*ref == txnid) {
-            req_txn.erase(ref);
+      for (auto ref = req_trx.begin(); ref != req_trx.end(); ++ref) {
+         if (*ref == id) {
+            req_trx.erase(ref);
             break;
          }
       }
 
-      if( my_impl->local_txns.get<by_id>().find( txnid ) != my_impl->local_txns.end( ) ) { //found
-         fc_dlog(logger, "found txnid in local_txns" );
+      if( my_impl->local_txns.get<by_id>().find( id ) != my_impl->local_txns.end( ) ) { //found
+         fc_dlog(logger, "found trxid in local_trxs" );
          return;
       }
       uint32_t packsiz = 0;
       uint32_t bufsiz = 0;
 
-      net_message msg(txn);
+      net_message msg(trx);
       packsiz = fc::raw::pack_size(msg);
       bufsiz = packsiz + sizeof(packsiz);
       vector<char> buff(bufsiz);
       fc::datastream<char*> ds( buff.data(), bufsiz);
       ds.write( reinterpret_cast<char*>(&packsiz), sizeof(packsiz) );
       fc::raw::pack( ds, msg );
-      node_transaction_state nts = {txnid,
-                                    expiration,
-                                    txn,
+      node_transaction_state nts = {id,
+                                    trx.expiration(),
+                                    trx,
                                     std::move(buff),
                                     0, 0, 0};
       my_impl->local_txns.insert(std::move(nts));
 
       if(bufsiz <= just_send_it_max) {
-         my_impl->send_all( txn, [skip, txnid](connection_ptr c) -> bool {
+         my_impl->send_all( trx, [skip, id](connection_ptr c) -> bool {
                if(c == skip || c->syncing ) {
                   return false;
                }
-               const auto& bs = c->trx_state.find(txnid);
+               const auto& bs = c->trx_state.find(id);
                bool unknown = bs == c->trx_state.end();
                if( unknown) {
-                  c->trx_state.insert(transaction_state({txnid,true,true,0,time_point() }));
-                  fc_dlog(logger, "sending whole txn to ${n}", ("n",c->peer_name() ) );
+                  c->trx_state.insert(transaction_state({id,true,true,0,time_point() }));
+                  fc_dlog(logger, "sending whole trx to ${n}", ("n",c->peer_name() ) );
                }
                return unknown;
             });
@@ -1613,17 +1656,17 @@ namespace eosio {
       else {
          notice_message pending_notify;
          pending_notify.known_trx.mode = normal;
-         pending_notify.known_trx.ids.push_back( txnid );
+         pending_notify.known_trx.ids.push_back( id );
          pending_notify.known_blocks.mode = none;
-         my_impl->send_all(pending_notify, [skip, txnid](connection_ptr c) -> bool {
+         my_impl->send_all(pending_notify, [skip, id](connection_ptr c) -> bool {
                if (c == skip || c->syncing) {
                   return false;
                }
-               const auto& bs = c->trx_state.find(txnid);
+               const auto& bs = c->trx_state.find(id);
                bool unknown = bs == c->trx_state.end();
                if( unknown) {
                   fc_dlog(logger, "sending notice to ${n}", ("n",c->peer_name() ) );
-                  c->trx_state.insert(transaction_state({txnid,false,true,0, time_point() }));
+                  c->trx_state.insert(transaction_state({id,false,true,0, time_point() }));
                }
                return unknown;
             });
@@ -1631,7 +1674,8 @@ namespace eosio {
 
    }
 
-   void big_msg_manager::recv_block (connection_ptr c, const signed_block_summary& msg) {
+#if 0
+   void dispatch_manager::recv_block (connection_ptr c, const signed_block& msg) {
       block_id_type blk_id = msg.id();
       uint32_t num = msg.block_num();
       const auto& blkstate = c->blk_state.get<by_id>().find(blk_id);
@@ -1661,7 +1705,7 @@ namespace eosio {
                   const auto& bs = conn->blk_state.find(blk_id);
                   bool unknown = bs == conn->blk_state.end();
                   if (unknown) {
-                     conn->blk_state.insert(block_state({blk_id,num,false,true,fc::time_point() }));
+                     conn->blk_state.insert(eosio::peer_block_state({blk_id,num,false,true,fc::time_point() }));
                   }
                   return unknown;
                });
@@ -1703,7 +1747,7 @@ namespace eosio {
                   const auto& bs = conn->blk_state.find(blk_id);
                   bool unknown = bs == conn->blk_state.end();
                   if (unknown) {
-                     conn->blk_state.insert(block_state({blk_id,num,false,true,fc::time_point() }));
+                     conn->blk_state.insert(eosio::peer_block_state({blk_id,num,false,true,fc::time_point() }));
                   }
                   return unknown;
                });
@@ -1713,13 +1757,27 @@ namespace eosio {
          fc_dlog(logger, "not forwarding from active syncing connection ${p}",("p",c->peer_name()));
       }
    }
+#endif
 
-   void big_msg_manager::recv_transaction (connection_ptr c, const transaction_id_type& tid) {
-      pending_txn_source = c;
+   void dispatch_manager::recv_transaction (connection_ptr c, const transaction_id_type& id) {
+      received_transactions.emplace_back((transaction_origin){id, c});
       if (c &&
           c->last_req &&
           c->last_req->req_trx.mode != none &&
-          c->last_req->req_trx.ids.back() == tid) {
+          c->last_req->req_trx.ids.back() == id) {
+         c->last_req.reset();
+      }
+
+      fc_dlog(logger, "canceling wait on ${p}", ("p",c->peer_name()));
+      c->cancel_wait();
+   }
+
+   void dispatch_manager::recv_block (connection_ptr c, const block_id_type& id) {
+      received_blocks.emplace_back((block_origin){id, c});
+      if (c &&
+          c->last_req &&
+          c->last_req->req_blocks.mode != none &&
+          c->last_req->req_blocks.ids.back() == id) {
          c->last_req.reset();
       }
 
@@ -1727,12 +1785,12 @@ namespace eosio {
       c->cancel_wait();
    }
 
-   void big_msg_manager::recv_notice (connection_ptr c, const notice_message& msg, bool generated) {
+   void dispatch_manager::recv_notice (connection_ptr c, const notice_message& msg, bool generated) {
       request_message req;
       req.req_trx.mode = none;
       req.req_blocks.mode = none;
       bool send_req = false;
-      chain_controller &cc = my_impl->chain_plug->chain();
+      controller &cc = my_impl->chain_plug->chain();
       if (msg.known_trx.mode == normal) {
          req.req_trx.mode = normal;
          req.req_trx.pending = 0;
@@ -1746,7 +1804,7 @@ namespace eosio {
                         time_point()} );
 
                req.req_trx.ids.push_back( t );
-               req_txn.push_back( t );
+               req_trx.push_back( t );
             }
             else {
                fc_dlog(logger,"big msg manager found txn id in table, ${id}",("id", t));
@@ -1762,7 +1820,7 @@ namespace eosio {
       if (msg.known_blocks.mode == normal) {
          req.req_blocks.mode = normal;
          for( const auto& blkid : msg.known_blocks.ids) {
-            optional<signed_block> b;
+            signed_block_ptr b;
             try {
                b = cc.fetch_block_by_id(blkid);
             } catch (const assert_exception &ex) {
@@ -1790,7 +1848,7 @@ namespace eosio {
       }
    }
 
-   void big_msg_manager::retry_fetch( connection_ptr c ) {
+   void dispatch_manager::retry_fetch( connection_ptr c ) {
       if (!c->last_req) {
          return;
       }
@@ -1947,9 +2005,15 @@ namespace eosio {
          if(!conn->socket) {
             return;
          }
+         connection_wptr weak_conn = conn;
          conn->socket->async_read_some
             (conn->pending_message_buffer.get_buffer_sequence_for_boost_async_read(),
-             [this,conn]( boost::system::error_code ec, std::size_t bytes_transferred ) {
+             [this,weak_conn]( boost::system::error_code ec, std::size_t bytes_transferred ) {
+               auto conn = weak_conn.lock();
+               if (!conn) {
+                  return;
+               }
+
                try {
                   if( !ec ) {
                      if (bytes_transferred > conn->pending_message_buffer.bytes_to_write()) {
@@ -2062,6 +2126,11 @@ namespace eosio {
       return valid;
    }
 
+   void net_plugin_impl::handle_message( connection_ptr c, const chain_size_message &msg) {
+      fc_dlog( logger, "got a chain_size_message from ${p}", ("p",c->peer_name()));
+
+   }
+
    void net_plugin_impl::handle_message( connection_ptr c, const handshake_message &msg) {
       fc_dlog( logger, "got a handshake_message from ${p} ${h}", ("p",c->peer_addr)("h",msg.p2p_address));
       if (!is_valid(msg)) {
@@ -2069,7 +2138,7 @@ namespace eosio {
          c->enqueue( go_away_message( fatal_other ));
          return;
       }
-      chain_controller& cc = chain_plug->chain();
+      controller& cc = chain_plug->chain();
       uint32_t lib_num = cc.last_irreversible_block_num( );
       uint32_t peer_lib = msg.last_irreversible_block_num;
       if( c->connecting ) {
@@ -2246,7 +2315,7 @@ namespace eosio {
          break;
       }
       case normal: {
-         big_msg_master->recv_notice (c, msg, false);
+         dispatcher->recv_notice (c, msg, false);
       }
       }
 
@@ -2266,7 +2335,7 @@ namespace eosio {
          break;
       }
       case normal : {
-         big_msg_master->recv_notice (c, msg, false);
+         dispatcher->recv_notice (c, msg, false);
          break;
       }
       default: {
@@ -2331,7 +2400,7 @@ namespace eosio {
          fc_dlog(logger, "got a duplicate transaction - dropping");
          return;
       }
-      big_msg_master->recv_transaction(c, tid);
+      dispatcher->recv_transaction(c, tid);
       uint64_t code = 0;
       try {
          chain_plug->accept_transaction( msg);
@@ -2346,118 +2415,18 @@ namespace eosio {
          elog( " caught something attempting to accept transaction");
       }
 
-      big_msg_master->rejected_transaction(msg);
-   }
-
-   void net_plugin_impl::handle_message( connection_ptr c, const signed_transaction &msg) {
-      fc_dlog(logger, "Got a signed transaction from ${p} cancel wait",("p",c->peer_name()));
-      c->cancel_wait();
-   }
-
-   void net_plugin_impl::handle_message( connection_ptr c, const signed_block_summary &msg) {
-      chain_controller &cc = chain_plug->chain();
-      block_id_type blk_id = msg.id();
-      uint32_t blk_num = msg.block_num();
-      c->cancel_wait();
-
-      try {
-         if( cc.is_known_block(blk_id)) {
-            sync_master->recv_block(c, blk_id, blk_num, true);
-            return;
-         }
-      } catch( ...) {
-         // should this even be caught?
-         elog("Caught an unknown exception trying to recall blockID");
-      }
-
-      fc::microseconds age( fc::time_point::now() - msg.timestamp);
-      fc_dlog(logger, "got signed_block_summary #${n} from ${p} block age in secs = ${age}",
-              ("n",blk_num)("p",c->peer_name())("age",age.to_seconds()));
-
-      signed_block sb(msg);
-      update_block_num ubn(blk_num);
-      for (const auto &region : sb.regions) {
-         for (const auto &cycle_sum : region.cycles_summary) {
-            for (const auto &shard : cycle_sum) {
-               for (const auto &recpt : shard.transactions) {
-                  auto ltx = local_txns.get<by_id>().find(recpt.id);
-                  switch (recpt.status) {
-                  case transaction_receipt::delayed: {
-                     if (ltx == local_txns.end()) {
-                        fc_dlog(logger, "got a delayed transaction, treat it like a notify");
-                        notice_message pending_notify;
-                        pending_notify.known_blocks.mode = normal;
-                        pending_notify.known_blocks.ids.push_back( blk_id );
-                        pending_notify.known_trx.mode = none;
-                        big_msg_master->recv_notice (c, pending_notify, true);
-                        return;
-                     }
-                     // else fall through to executed.
-                  }
-                  case transaction_receipt::executed: {
-                     if( ltx != local_txns.end()) {
-                        sb.input_transactions.push_back(ltx->packed_txn);
-                        local_txns.modify( ltx, ubn );
-                     }
-                     break;
-                  }
-                  case transaction_receipt::soft_fail:
-                  case transaction_receipt::hard_fail: {
-                     if( ltx != local_txns.end()) {
-                        sb.input_transactions.push_back(ltx->packed_txn);
-                        local_txns.modify( ltx, ubn );
-                        auto ctx = c->trx_state.get<by_id>().find(recpt.id);
-                        if( ctx != c->trx_state.end()) {
-                           c->trx_state.modify( ctx, ubn );
-                        }
-                     }
-                     break;
-                  }
-                  }
-               }
-            }
-         }
-      }
-
-      bool accepted = false;
-      try {
-         chain_plug->accept_block(sb, sync_master->is_active(c));
-         accepted = true;
-      } catch( const unlinkable_block_exception &ex) {
-         elog( "unlinkable_block_exception accept block #${n} syncing from ${p}",("n",blk_num)("p",c->peer_name()));
-      } catch( const block_validate_exception &ex) {
-         elog( "block_validate_exception accept block #${n} syncing from ${p}",("n",blk_num)("p",c->peer_name()));
-      } catch( const assert_exception &ex) {
-         elog( "unable to accept block on assert exception ${n} from ${p}",("n",ex.to_string())("p",c->peer_name()));
-      } catch( const fc::exception &ex) {
-         elog( "accept_block threw a non-assert exception ${x} from ${p}",( "x",ex.to_string())("p",c->peer_name()));
-      } catch( ...) {
-         elog( "handle sync block caught something else from ${p}",("num",blk_num)("p",c->peer_name()));
-      }
-#if 0 // after reviewing my conversaion with Bart, I believe this to be improper.
-      // as he explained, if the the block is deemed invalid by the local chain, then this implies a
-      // fork by the sender.
-      notice_message pending_notify;
-      pending_notify.known_blocks.mode = normal;
-      pending_notify.known_blocks.ids.push_back( blk_id );
-      pending_notify.known_trx.mode = none;
-      big_msg_master->recv_notice (c, pending_notify, true);
-#endif
-      big_msg_master->recv_block(c, msg);
-      sync_master->recv_block(c, blk_id, blk_num, accepted);
-
+      dispatcher->rejected_transaction(tid);
    }
 
    void net_plugin_impl::handle_message( connection_ptr c, const signed_block &msg) {
-      // should only be during synch or rolling upgrade
-      chain_controller &cc = chain_plug->chain();
+      controller &cc = chain_plug->chain();
       block_id_type blk_id = msg.id();
       uint32_t blk_num = msg.block_num();
       fc_dlog(logger, "canceling wait on ${p}", ("p",c->peer_name()));
       c->cancel_wait();
 
       try {
-         if( cc.is_known_block(blk_id)) {
+         if( cc.fetch_block_by_id(blk_id)) {
             sync_master->recv_block(c, blk_id, blk_num, true);
             return;
          }
@@ -2466,13 +2435,15 @@ namespace eosio {
          elog("Caught an unknown exception trying to recall blockID");
       }
 
+      dispatcher->recv_block(c, blk_id);
       fc::microseconds age( fc::time_point::now() - msg.timestamp);
       fc_dlog(logger, "got signed_block #${n} from ${p} block age in secs = ${age}",
               ("n",blk_num)("p",c->peer_name())("age",age.to_seconds()));
 
       go_away_reason reason = fatal_other;
       try {
-         chain_plug->accept_block(msg, sync_master->is_active(c));
+         signed_block_ptr sbp = std::make_shared<signed_block>(msg);
+         chain_plug->accept_block(sbp); //, sync_master->is_active(c));
          reason = no_reason;
       } catch( const unlinkable_block_exception &ex) {
          elog( "unlinkable_block_exception accept block #${n} syncing from ${p}",("n",blk_num)("p",c->peer_name()));
@@ -2491,20 +2462,15 @@ namespace eosio {
 
       update_block_num ubn(blk_num);
       if( reason == no_reason ) {
-         for (const auto &region : msg.regions) {
-            for (const auto &cycle_sum : region.cycles_summary) {
-               for (const auto &shard : cycle_sum) {
-                  for (const auto &recpt : shard.transactions) {
-                     auto ltx = local_txns.get<by_id>().find(recpt.id);
-                     if( ltx != local_txns.end()) {
-                        local_txns.modify( ltx, ubn );
-                     }
-                     auto ctx = c->trx_state.get<by_id>().find(recpt.id);
-                     if( ctx != c->trx_state.end()) {
-                        c->trx_state.modify( ctx, ubn );
-                     }
-                  }
-               }
+         for (const auto &recpt : msg.transactions) {
+            auto id = (recpt.trx.which() == 0) ? recpt.trx.get<transaction_id_type>() : recpt.trx.get<packed_transaction>().id();
+            auto ltx = local_txns.get<by_id>().find(id);
+            if( ltx != local_txns.end()) {
+               local_txns.modify( ltx, ubn );
+            }
+            auto ctx = c->trx_state.get<by_id>().find(id);
+            if( ctx != c->trx_state.end()) {
+               c->trx_state.modify( ctx, ubn );
             }
          }
       }
@@ -2567,7 +2533,7 @@ namespace eosio {
       old.erase( ex_lo, ex_up);
 
       auto &stale = local_txns.get<by_block_num>();
-      chain_controller &cc = chain_plug->chain();
+      controller &cc = chain_plug->chain();
       uint32_t bn = cc.last_irreversible_block_num();
       stale.erase( stale.lower_bound(1), stale.upper_bound(bn) );
       for ( auto &c : connections ) {
@@ -2616,20 +2582,30 @@ namespace eosio {
       c->close();
    }
 
-   /**
-    * This one is necessary to hook into the boost notifier api
-    **/
-   void net_plugin_impl::transaction_ready(const transaction_metadata& md, const packed_transaction& txn) {
-      fc_dlog(logger,"transaction ready called, id = ${id}",("id",md.id));
-      time_point_sec expire;
-      if (md.decompressed_trx) {
-         expire = md.decompressed_trx->expiration;
-      }
-      my_impl->big_msg_master->bcast_transaction(md.id, expire, txn);
+   void net_plugin_impl::accepted_block_header(const block_state_ptr& block) {
+      fc_ilog(logger,"signaled, id = ${id}",("id", block->id));
+   }
+
+   void net_plugin_impl::accepted_block(const block_state_ptr& block) {
+      fc_ilog(logger,"signaled, id = ${id}",("id", block->id));
+      dispatcher->bcast_block(*block->block);
+   }
+
+   void net_plugin_impl::irreversible_block(const block_state_ptr&block) {
+      fc_ilog(logger,"signaled, id = ${id}",("id", block->id));
+   }
+
+   void net_plugin_impl::accepted_transaction(const transaction_metadata_ptr& md) {
+      fc_ilog(logger,"signaled, id = ${id}",("id", md->id));
+      dispatcher->bcast_transaction(md->packed_trx);
    }
 
-   void net_plugin_impl::broadcast_block_impl( const chain::signed_block &sb) {
-      big_msg_master->bcast_block(sb);
+   void net_plugin_impl::applied_transaction(const transaction_trace_ptr& txn) {
+      fc_ilog(logger,"signaled, id = ${id}",("id", txn->id));
+   }
+
+   void net_plugin_impl::accepted_confirmation(const header_confirmation& head) {
+      fc_ilog(logger,"signaled, id = ${id}",("id", head.block_id));
    }
 
    bool net_plugin_impl::authenticate_peer(const handshake_message& msg) const {
@@ -2736,7 +2712,7 @@ namespace eosio {
       hello.agent = my_impl->user_agent_name;
 
 
-      chain_controller& cc = my_impl->chain_plug->chain();
+      controller& cc = my_impl->chain_plug->chain();
       hello.head_id = fc::sha256();
       hello.last_irreversible_block_id = fc::sha256();
       hello.head_num = cc.head_block_num();
@@ -2755,7 +2731,7 @@ namespace eosio {
             hello.head_id = cc.get_block_id_for_num( hello.head_num );
          }
          catch( const unknown_block_exception &ex) {
-            hello.head_num = 0;
+           hello.head_num = 0;
          }
       }
    }
@@ -2799,12 +2775,12 @@ namespace eosio {
       my->network_version_match = options.at("network-version-match").as<bool>();
 
       my->sync_master.reset( new sync_manager(options.at("sync-fetch-span").as<uint32_t>() ) );
-      my->big_msg_master.reset( new big_msg_manager );
+      my->dispatcher.reset( new dispatch_manager );
 
       my->connector_period = std::chrono::seconds(options.at("connection-cleanup-period").as<int>());
       my->txn_exp_period = def_txn_expire_wait;
       my->resp_expected_period = def_resp_expected_wait;
-      my->big_msg_master->just_send_it_max = options.at("max-implicit-request").as<uint32_t>();
+      my->dispatcher->just_send_it_max = options.at("max-implicit-request").as<uint32_t>();
       my->max_client_count = options.at("max-clients").as<int>();
 
       my->num_clients = 0;
@@ -2902,8 +2878,15 @@ namespace eosio {
          ilog("starting listener, max clients is ${mc}",("mc",my->max_client_count));
          my->start_listen_loop();
       }
-
-      my->chain_plug->chain().on_pending_transaction.connect( &net_plugin_impl::transaction_ready);
+      {
+         chain::controller&cc = my->chain_plug->chain();
+         cc.accepted_block_header.connect( boost::bind(&net_plugin_impl::accepted_block_header, my.get(), _1));
+         cc.accepted_block.connect(  boost::bind(&net_plugin_impl::accepted_block, my.get(), _1));
+         cc.irreversible_block.connect( boost::bind(&net_plugin_impl::irreversible_block, my.get(), _1));
+         cc.accepted_transaction.connect( boost::bind(&net_plugin_impl::accepted_transaction, my.get(), _1));
+         cc.applied_transaction.connect( boost::bind(&net_plugin_impl::applied_transaction, my.get(), _1));
+         cc.accepted_confirmation.connect( boost::bind(&net_plugin_impl::accepted_confirmation, my.get(), _1));
+      }
       my->start_monitors();
 
       for( auto seed_node : my->supplied_peers ) {
@@ -2935,11 +2918,6 @@ namespace eosio {
       FC_CAPTURE_AND_RETHROW()
    }
 
-   void net_plugin::broadcast_block( const chain::signed_block &sb) {
-      fc_dlog(logger, "broadcasting block #${num}",("num",sb.block_num()) );
-      my->broadcast_block_impl( sb);
-   }
-
    size_t net_plugin::num_peers() const {
       return my->count_open_sockets();
    }

plugins/producer_plugin/producer_plugin.cpp

@@ -117,6 +117,12 @@ class producer_plugin_impl {
          });
          // push the new block
          chain.push_block(block);
+
+         ilog("Received block ${id}... #${n} @ ${t} signed by ${p} [trxs: ${count}, lib: ${lib}, confirmed: ${confs}]",
+              ("p",block->producer)("id",fc::variant(block->id()).as_string().substr(0,16))
+              ("n",block_header::num_from_id(block->id()))("t",block->timestamp)
+              ("count",block->transactions.size())("lib",chain.last_irreversible_block_num())("confs", block->confirmed) );
+
       }
 
       transaction_trace_ptr on_incoming_transaction(const packed_transaction_ptr& trx) {
@@ -403,7 +409,7 @@ block_production_condition::block_production_condition_enum producer_plugin_impl
             auto producer  = db.head_block_producer();
             auto pending   = db.head_block_state();
 
-            wlog("\r${p} generated block ${id}... #${n} @ ${t} with ${count} trxs, lib: ${lib}, confirmed: ${confs}",
+            ilog("Produced block ${id}... #${n} @ ${t} signed by ${p} [trxs: ${count}, lib: ${lib}, confirmed: ${confs}]",
                  ("p",producer)("id",fc::variant(pending->id).as_string().substr(0,16))
                  ("n",pending->block_num)("t",pending->block->timestamp)
                  ("count",pending->block->transactions.size())("lib",db.last_irreversible_block_num())("confs", pending->header.confirmed)(capture) );
@@ -508,7 +514,7 @@ block_production_condition::block_production_condition_enum producer_plugin_impl
       }
    }
 
-  // idump( (fc::time_point::now() - chain.pending_block_time()) );
+   //idump( (fc::time_point::now() - chain.pending_block_time()) );
    chain.finalize_block();
    chain.sign_block( [&]( const digest_type& d ) { return private_key_itr->second.sign(d); } );
    chain.commit_block();

plugins/txn_test_gen_plugin/txn_test_gen_plugin.cpp

@@ -71,9 +71,9 @@ using namespace eosio::chain;
      eosio::detail::txn_test_gen_empty result;
 
 struct txn_test_gen_plugin_impl {
-   transaction_trace_ptr push_transaction( signed_transaction& trx ) { try {
-      controller& cc = app().get_plugin<chain_plugin>().chain();
-      return cc.push_transaction( std::make_shared<transaction_metadata>(trx) );
+   void push_transaction( signed_transaction& trx ) { try {
+      chain_plugin& cp = app().get_plugin<chain_plugin>();
+      return cp.accept_transaction( packed_transaction(trx) );
    } FC_CAPTURE_AND_RETHROW( (transaction_header(trx)) ) }
 
    void create_test_accounts(const std::string& init_name, const std::string& init_priv_key) {
@@ -147,12 +147,10 @@ struct txn_test_gen_plugin_impl {
          {
             setabi handler;
             handler.account = newaccountC;
-            handler.abi = eosio_token_abi_def;
+            handler.abi = json::from_string(eosio_token_abi).as<abi_def>();
             trx.actions.emplace_back( vector<chain::permission_level>{{newaccountC,"active"}}, handler);
          }
 
-         abi_serializer eosio_token_serializer(eosio_token_abi_def);
-
          {
             action act;
             act.account = N(eosio.token);
@@ -252,6 +250,9 @@ struct txn_test_gen_plugin_impl {
       fc::crypto::private_key a_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'a')));
       fc::crypto::private_key b_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'b')));
 
+      static uint64_t nonce = static_cast<uint64_t>(fc::time_point::now().sec_since_epoch()) << 32;
+      abi_serializer eosio_serializer(cc.db().find<account_object, by_name>(config::system_account_name)->get_abi());
+
       uint32_t reference_block_num = cc.last_irreversible_block_num();
       if (txn_reference_block_lag >= 0) {
          reference_block_num = cc.head_block_num();
@@ -306,9 +307,9 @@ struct txn_test_gen_plugin_impl {
    action act_a_to_b;
    action act_b_to_a;
 
-   uint64_t nonce = static_cast<uint64_t>(fc::time_point::now().sec_since_epoch()) << 32;
+   int32_t txn_reference_block_lag;
 
-   abi_serializer eosio_token_serializer = fc::json::from_string(eosio_token_abi).as<contracts::abi_def>();
+   abi_serializer eosio_token_serializer = fc::json::from_string(eosio_token_abi).as<abi_def>();
 };
 
 txn_test_gen_plugin::txn_test_gen_plugin() {}

plugins/validator_plugin/validator_plugin.cpp

@@ -48,6 +48,12 @@ class validator_plugin_impl {
 
          // push the new block
          chain.push_block(block);
+
+         ilog("Received block ${id}... #${n} @ ${t} signed by ${p} [trxs: ${count}, lib: ${lib}, confirmed: ${confs}]",
+              ("p",block->producer)("id",fc::variant(block->id()).as_string().substr(0,16))
+              ("n",block_header::num_from_id(block->id()))("t",block->timestamp)
+              ("count",block->transactions.size())("lib",chain.last_irreversible_block_num())("confs", block->confirmed) );
+
       }
 
       transaction_trace_ptr on_incoming_transaction(const packed_transaction_ptr& trx) {

programs/cleos/help_text.cpp

@@ -207,7 +207,7 @@ const char* error_advice_3120010 =  R"=====(Ensure that your packed transaction
 }
 e.g.
 {
-  "signatures" : [ "EOSJze4m1ZHQ4UjuHpBcX6uHPN4Xyggv52raQMTBZJghzDLepaPcSGCNYTxaP2NiaF4yRF5RaYwqsQYAwBwFtfuTJr34Z5GJX" ],
+  "signatures" : [ "SIG_K1_Jze4m1ZHQ4UjuHpBcX6uHPN4Xyggv52raQMTBZJghzDLepaPcSGCNYTxaP2NiaF4yRF5RaYwqsQYAwBwFtfuTJr34Z5GJX" ],
   "compression" : "none",
   "hex_transaction" : "6c36a25a00002602626c5e7f0000000000010000001e4d75af460000000000a53176010000000000ea305500000000a8ed3232180000001e4d75af4680969800000000000443555200000000"
 })=====";

programs/eosio-applesedemo/README.md

@@ -50,7 +50,7 @@ that requires usage of a fingerprint when signing a digest (such a signing a tra
 ```
 $ applesedemo.app/Contents/MacOS/applesedemo --create-se-touch-only
 Successfully created
-public_key(EOSR17iKCZrb1JqSjUncCbDGQenzSqyuNmPU8iUA15efNW5KD1iHd9x)
+public_key(PUB_R1_7iKCZrb1JqSjUncCbDGQenzSqyuNmPU8iUA15efNW5KD1iHd9x)
 ```
 The public key for the private key is printed; note it somewhere. It is possible to ask the Secure Enclave to
 create multiple private keys and assign labels to them but this application only allows a single key at once.
@@ -64,14 +64,14 @@ Now, ask the Secure Enclave to sign the digest with the private key only it know
 generated until a valid fingerprint is used.
 ```
 $ applesedemo.app/Contents/MacOS/applesedemo --sign 0ba904eae8773b70c75333db4de2f3ac45a8ad4ddba1b242f0b3cfc199391dd8
-signature(EOSR1Jx4sBidhFV6PSvS8hWbG5oh77HKud8xpkoHLvWaZVaBeWttRpyEjaGbPRVEKu3JePTyVjANmP4GKFtG2DAuB4MTVqsdC9W)
+signature(SIG_R1_Jx4sBidhFV6PSvS8hWbG5oh77HKud8xpkoHLvWaZVaBeWttRpyEjaGbPRVEKu3JePTyVjANmP4GKFtG2DAuB4MTVqsdC9W)
 ```
 ## Key Recovery
 Given the signature and digest, we must be able to correlate that with the public key that signed the digest.
 ```
 $ applesedemo.app/Contents/MacOS/applesedemo --recover 0ba904eae8773b70c75333db4de2f3ac45a8ad4ddba1b242f0b3cfc199391dd8 \
-     EOSR1Jx4sBidhFV6PSvS8hWbG5oh77HKud8xpkoHLvWaZVaBeWttRpyEjaGbPRVEKu3JePTyVjANmP4GKFtG2DAuB4MTVqsdC9W
-public_key(EOSR17iKCZrb1JqSjUncCbDGQenzSqyuNmPU8iUA15efNW5KD1iHd9x)
+     SIG_R1_Jx4sBidhFV6PSvS8hWbG5oh77HKud8xpkoHLvWaZVaBeWttRpyEjaGbPRVEKu3JePTyVjANmP4GKFtG2DAuB4MTVqsdC9W
+public_key(PUB_R1_7iKCZrb1JqSjUncCbDGQenzSqyuNmPU8iUA15efNW5KD1iHd9x)
 ```
 Indeed, the public key recovered from this digest and signature matches the public key from the key stored in the Secure
 Enclave.
\ No newline at end of file

programs/eosio-applesedemo/main.cpp

@@ -76,7 +76,7 @@ void print_pub_for_key(SecKeyRef key) {
    pub_wrapper.check = fc::crypto::checksummed_data<fc::crypto::r1::public_key_data>::calculate_checksum(pub_wrapper.data, "R1");
    std::vector<char> checksummed = fc::raw::pack(pub_wrapper);
    
-   cout << "public_key(EOSR1" << fc::to_base58(checksummed.data(), checksummed.size()) << ")" << endl;
+   cout << "public_key(PUB_R1_" << fc::to_base58(checksummed.data(), checksummed.size()) << ")" << endl;
 }
 
 void print_attributes() {
@@ -221,7 +221,7 @@ void sign(const string& hex) {
    signature_wrapper.check = fc::crypto::checksummed_data<fc::crypto::r1::compact_signature>::calculate_checksum(signature_wrapper.data, "R1");
    checksummed = fc::raw::pack(signature_wrapper);
    
-   cout << "signature(EOSR1" << fc::to_base58(checksummed.data(), checksummed.size()) << ")" << endl;
+   cout << "signature(SIG_R1_" << fc::to_base58(checksummed.data(), checksummed.size()) << ")" << endl;
 
 err:
    CFRelease(key);

programs/eosio-launcher/main.cpp

@@ -1042,6 +1042,11 @@ launcher_def::write_logging_config_file(tn_node_def &node) {
                   ( "host", instance.name )
              ) );
     log_config.loggers.front().appenders.push_back("net");
+    fc::logger_config p2p ("net_plugin_impl");
+    p2p.level=fc::log_level::debug;
+    p2p.appenders.push_back ("stderr");
+    p2p.appenders.push_back ("net");
+    log_config.loggers.emplace_back(p2p);
   }
 
   auto str = fc::json::to_pretty_string( log_config, fc::json::stringify_large_ints_and_doubles );

programs/nodeos/CMakeLists.txt

@@ -49,9 +49,10 @@ target_link_libraries( nodeos
         PRIVATE -Wl,${whole_archive_flag} history_api_plugin         -Wl,${no_whole_archive_flag}
         PRIVATE -Wl,${whole_archive_flag} chain_api_plugin           -Wl,${no_whole_archive_flag}
         PRIVATE -Wl,${whole_archive_flag} wallet_api_plugin          -Wl,${no_whole_archive_flag}
-#        PRIVATE -Wl,${whole_archive_flag} net_api_plugin             -Wl,${no_whole_archive_flag}
+        PRIVATE -Wl,${whole_archive_flag} net_plugin                 -Wl,${no_whole_archive_flag}
+        PRIVATE -Wl,${whole_archive_flag} net_api_plugin             -Wl,${no_whole_archive_flag}
 #        PRIVATE -Wl,${whole_archive_flag} faucet_testnet_plugin      -Wl,${no_whole_archive_flag}
-#        PRIVATE -Wl,${whole_archive_flag} txn_test_gen_plugin        -Wl,${no_whole_archive_flag}
+        PRIVATE -Wl,${whole_archive_flag} txn_test_gen_plugin        -Wl,${no_whole_archive_flag}
         PRIVATE -Wl,${whole_archive_flag} producer_plugin            -Wl,${no_whole_archive_flag}
         PRIVATE chain_plugin http_plugin validator_plugin
         PRIVATE eosio_chain fc ${CMAKE_DL_LIBS} ${PLATFORM_SPECIFIC_LIBS} )

programs/nodeos/main.cpp

@@ -7,7 +7,7 @@
 #include <eosio/chain_plugin/chain_plugin.hpp>
 #include <eosio/http_plugin/http_plugin.hpp>
 #include <eosio/history_plugin.hpp>
-//#include <eosio/net_plugin/net_plugin.hpp>
+#include <eosio/net_plugin/net_plugin.hpp>
 #include <eosio/producer_plugin/producer_plugin.hpp>
 #include <eosio/validator_plugin/validator_plugin.hpp>
 #include <eosio/utilities/common.hpp>
@@ -86,10 +86,10 @@ int main(int argc, char** argv)
       app().set_version(eosio::nodeos::config::version);
       app().register_plugin<history_plugin>();
 
-      auto root = fc::app_path(); 
+      auto root = fc::app_path();
       app().set_default_data_dir(root / "eosio/nodeos/data" );
       app().set_default_config_dir(root / "eosio/nodeos/config" );
-      if(!app().initialize<chain_plugin, http_plugin, validator_plugin>(argc, argv))
+      if(!app().initialize<chain_plugin, http_plugin, validator_plugin, net_plugin>(argc, argv))
          return -1;
       initialize_logging();
       ilog("nodeos version ${ver}", ("ver", eosio::utilities::common::itoh(static_cast<uint32_t>(app().version()))));

scripts/eosio_build_ubuntu.sh

@@ -2,14 +2,14 @@
 	OS_MAJ=`echo "${OS_VER}" | cut -d'.' -f1`
 	OS_MIN=`echo "${OS_VER}" | cut -d'.' -f2`
 
-	MEM_MEG=$( free -m | grep Mem | tr -s ' ' | cut -d\  -f2 )
-	CPU_SPEED=$( lscpu | grep "MHz" | tr -s ' ' | cut -d\  -f3 | cut -d'.' -f1 )
-	CPU_CORE=$( lscpu | grep "^CPU(s)" | tr -s ' ' | cut -d\  -f2 )
+	MEM_MEG=$( free -m | grep Mem | tr -s ' ' | cut -d\  -f2 || cut -d' ' -f2 )
+	CPU_SPEED=$( lscpu | grep -m1 "MHz" | tr -s ' ' | cut -d\  -f3 || cut -d' ' -f3 | cut -d'.' -f1 )
+	CPU_CORE=$( lscpu | grep "^CPU(s)" | tr -s ' ' | cut -d\  -f2 || cut -d' ' -f2 )
 
 	MEM_GIG=$(( (($MEM_MEG / 1000) / 2) ))
 	JOBS=$(( ${MEM_GIG} > ${CPU_CORE} ? ${CPU_CORE} : ${MEM_GIG} ))
 
-	DISK_INSTALL=`df -h . | tail -1 | tr -s ' ' | cut -d\  -f1`
+	DISK_INSTALL=`df -h . | tail -1 | tr -s ' ' | cut -d\  -f1 || cut -d' ' -f1`
 	DISK_TOTAL_KB=`df . | tail -1 | awk '{print $2}'`
 	DISK_AVAIL_KB=`df . | tail -1 | awk '{print $4}'`
 	DISK_TOTAL=$(( $DISK_TOTAL_KB / 1048576 ))
@@ -324,4 +324,4 @@ mongodconf
 		printf '\texport PATH=${HOME}/opt/mongodb/bin:$PATH\n'
 		printf "\tcd ${HOME}/eos/build; make test\n\n"
 	return 0
-	}
\ No newline at end of file
+	}

testnet.template

@@ -13,8 +13,8 @@ if [ -z "$biosport" ]; then
 fi
 
 wddir=eosio-ignition-wd
-wdport=8899
-wdhost=127.0.0.1
+wdaddr=localhost:8899
+wdurl=http://$wdaddr
 # Manual deployers, add a line below this block that looks like:
 #    bioshost=$BIOS_HOSTNAME
 #    biosport=$BIOS_HTTP_PORT
@@ -35,7 +35,7 @@ mkdir $wddir
 step=1
 echo Initializing ignition sequence  at $(date) | tee $logfile
 
-echo "http-server-address = 127.0.0.1:$wdport" > $wddir/config.ini
+echo "http-server-address = $wdaddr" > $wddir/config.ini
 
 programs/keosd/keosd --config-dir $wddir --data-dir $wddir 2> $wddir/wdlog.txt &
 echo $$ > ignition_wallet.pid
@@ -44,9 +44,9 @@ sleep 1
 
 ecmd () {
     echo ===== Start: $step ============ >> $logfile
-    echo executing: cleos --wallet-port $wdport -p $biosport  -H $bioshost $* | tee -a $logfile
+    echo executing: cleos --wallet-url $wdurl --url http://$bioshost:$biosport $* | tee -a $logfile
     echo ----------------------- >> $logfile
-    programs/cleos/cleos --wallet-port $wdport --wallet-host $wdhost -p $biosport  -H $bioshost $* >> $logfile 2>&1
+    programs/cleos/cleos  --wallet-url $wdurl --url http://$bioshost:$biosport $* >> $logfile 2>&1
     echo ==== End: $step ============== >> $logfile
     step=$(($step + 1))
 }
@@ -89,18 +89,18 @@ ecmd set contract eosio contracts/eosio.bios contracts/eosio.bios/eosio.bios.was
 
 #the setprods.json argument cannot pass through the function call due to embedded quotes
 echo ===== Start: $step ============ >> $logfile
-echo executing: cleos --wallet-port $wdport -p $biosport -H $bioshost push action eosio setprods setprods.json -p eosio@active | tee -a $logfile
+echo executing: cleos  --wallet-url $wdurl --url http://$bioshost:$biosport push action eosio setprods setprods.json -p eosio@active | tee -a $logfile
 echo ----------------------- >> $logfile
-programs/cleos/cleos --wallet-port $wdport --wallet-host $wdhost -p $biosport -H $bioshost push action eosio setprods setprods.json -p eosio@active >> $logfile 2>&1
+programs/cleos/cleos  --wallet-url $wdurl --url http://$bioshost:$biosport push action eosio setprods setprods.json -p eosio@active >> $logfile 2>&1
 echo ==== End: $step ============== >> $logfile
 step=$(($step + 1))
 
 ecmd set contract eosio contracts/eosio.system contracts/eosio.system/eosio.system.wast contracts/eosio.system/eosio.system.abi
 
 echo ===== Start: $step ============ >> $logfile
-echo executing: cleos --wallet-port $wdport -p $biosport -H $bioshost push action eosio issue '{"to":"eosio","quantity":"1000000000.0000 EOS","memo":"init"}' -p eosio@active | tee -a $logfile
+echo executing: cleos  --wallet-url $wdurl --url http://$bioshost:$biosport push action eosio issue '{"to":"eosio","quantity":"1000000000.0000 EOS","memo":"init"}' -p eosio@active | tee -a $logfile
 echo ----------------------- >> $logfile
-programs/cleos/cleos --wallet-port $wdport --wallet-host $wdhost -p $biosport -H $bioshost push action eosio issue '{"to":"eosio","quantity":"1000000000.0000 EOS","memo":"init"}' -p eosio@active >> $logfile 2>&1
+programs/cleos/cleos  --wallet-url $wdurl --url http://$bioshost:$biosport push action eosio issue '{"to":"eosio","quantity":"1000000000.0000 EOS","memo":"init"}' -p eosio@active >> $logfile 2>&1
 echo ==== End: $step ============== >> $logfile
 step=$(($step + 1))
 

unittests/abi_tests.cpp

@@ -1802,8 +1802,8 @@ BOOST_AUTO_TEST_CASE(general)
       "string_arr"        : ["ola ke ase","ola ke desi"],
       "time"              : "2021-12-20T15:30",
       "time_arr"          : ["2021-12-20T15:30","2021-12-20T15:31"],
-      "signature"         : "EOSJzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwT77X1U",
-      "signature_arr"     : ["EOSJzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwT77X1U","EOSJzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwT77X1U"],
+      "signature"         : "SIG_K1_Jzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwV1v4G5",
+      "signature_arr"     : ["SIG_K1_Jzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwV1v4G5","SIG_K1_Jzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwV1v4G5"],
       "checksum256"       : "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
       "checksum256_arr"      : ["ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad","ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"],
       "fieldname"         : "name1",
@@ -1891,7 +1891,8 @@ BOOST_AUTO_TEST_CASE(general)
         "ref_block_num":"1",
         "ref_block_prefix":"2",
         "expiration":"2021-12-20T15:30",
-        "signatures" : ["EOSJzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwT77X1U"],
+        "region": "1",
+        "signatures" : ["SIG_K1_Jzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwV1v4G5"],
         "context_free_data" : ["abcdef","0123456789","ABCDEF0123456789abcdef"],
         "context_free_actions":[{"account":"contextfree1", "name":"cfactionname1", "authorization":[{"actor":"cfacc1","permission":"cfpermname1"}], "data":"778899"}],
         "actions":[{"account":"accountname1", "name":"actionname1", "authorization":[{"actor":"acc1","permission":"permname1"}], "data":"445566"}],
@@ -1903,7 +1904,8 @@ BOOST_AUTO_TEST_CASE(general)
         "ref_block_num":"1",
         "ref_block_prefix":"2",
         "expiration":"2021-12-20T15:30",
-        "signatures" : ["EOSJzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwT77X1U"],
+        "region": "1",
+        "signatures" : ["SIG_K1_Jzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwV1v4G5"],
         "context_free_data" : ["abcdef","0123456789","ABCDEF0123456789abcdef"],
         "context_free_actions":[{"account":"contextfree1", "name":"cfactionname1", "authorization":[{"actor":"cfacc1","permission":"cfpermname1"}], "data":"778899"}],
         "actions":[{"account":"acc1", "name":"actionname1", "authorization":[{"actor":"acc1","permission":"permname1"}], "data":"445566"}],
@@ -1914,7 +1916,8 @@ BOOST_AUTO_TEST_CASE(general)
         "ref_block_num":"2",
         "ref_block_prefix":"3",
         "expiration":"2021-12-20T15:40",
-        "signatures" : ["EOSJzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwT77X1U"],
+        "region": "1",
+        "signatures" : ["SIG_K1_Jzdpi5RCzHLGsQbpGhndXBzcFs8vT5LHAtWLMxPzBdwRHSmJkcCdVu6oqPUQn1hbGUdErHvxtdSTS1YA73BThQFwV1v4G5"],
         "context_free_data" : ["abcdef","0123456789","ABCDEF0123456789abcdef"],
         "context_free_actions":[{"account":"contextfree2", "name":"cfactionname2", "authorization":[{"actor":"cfacc2","permission":"cfpermname2"}], "data":"667788"}],
         "actions":[{"account":"acc2", "name":"actionname2", "authorization":[{"actor":"acc2","permission":"permname2"}], "data":""}],

unittests/eosio.system_tests.cpp

@@ -607,7 +607,7 @@ BOOST_FIXTURE_TEST_CASE( producer_register_unregister, eosio_system_tester ) try
    //call regproducer again to change parameters
    fc::variant params2 = producer_parameters_example(2);
 
-   vector<char> key2 = fc::raw::pack( fc::crypto::public_key( std::string("EOSR16EPHFSKVYHBjQgxVGQPrwCxTg7BbZ69H9i4gztN9deKTEXYne4") ) );
+   vector<char> key2 = fc::raw::pack( fc::crypto::public_key( std::string("PUB_R1_6EPHFSKVYHBjQgxVGQPrwCxTg7BbZ69H9i4gztN9deKTEXYne4") ) );
    BOOST_REQUIRE_EQUAL( success(), push_action(N(alice), N(regproducer), mvo()
                                                ("producer",  "alice")
                                                ("producer_key", key2 )