Feature/dpos pbft bos upgrade: fix snapshot compatibility; add pbft_api plugin; fix bugs

libraries/chain/block_header_state.cpp

@@ -33,7 +33,7 @@ namespace eosio { namespace chain {
    *  contain a transaction mroot, action mroot, or new_producers as those components
    *  are derived from chain state.
    */
-  block_header_state block_header_state::generate_next( block_timestamp_type when, bool new_version )const {
+  block_header_state block_header_state::generate_next( block_timestamp_type when, bool pbft_enabled )const {
     block_header_state result;
 
     if( when != block_timestamp_type() ) {
@@ -65,7 +65,7 @@ namespace eosio { namespace chain {
     result.pbft_stable_checkpoint_blocknum       = pbft_stable_checkpoint_blocknum;
 
 
-    if (new_version) {
+    if (pbft_enabled) {
         result.dpos_irreversible_blocknum = dpos_irreversible_blocknum;
     } else {
         result.producer_to_last_implied_irb[prokey.producer_name] = result.dpos_proposed_irreversible_blocknum;
@@ -81,7 +81,7 @@ namespace eosio { namespace chain {
     auto num_active_producers = active_schedule.producers.size();
     uint32_t required_confs = (uint32_t)(num_active_producers * 2 / 3) + 1;
 
-    if (!new_version) {
+    if (!pbft_enabled) {
         if (confirm_count.size() < config::maximum_tracked_dpos_confirmations) {
             result.confirm_count.reserve(confirm_count.size() + 1);
             result.confirm_count = confirm_count;
@@ -97,10 +97,10 @@ namespace eosio { namespace chain {
     return result;
   } /// generate_next
 
-   bool block_header_state::maybe_promote_pending( bool new_version ) {
+   bool block_header_state::maybe_promote_pending( bool pbft_enabled ) {
 
       bool should_promote_pending = pending_schedule.producers.size();
-      if ( !new_version ) {
+      if ( !pbft_enabled ) {
           should_promote_pending = should_promote_pending && dpos_irreversible_blocknum >= pending_schedule_lib_num;
       }
 
@@ -115,7 +115,7 @@ namespace eosio { namespace chain {
                new_producer_to_last_produced[pro.producer_name] = existing->second;
             } else {
                //TODO: max of bft and dpos lib
-               if (new_version) {
+               if (pbft_enabled) {
                    new_producer_to_last_produced[pro.producer_name] = bft_irreversible_blocknum;
                } else {
                    new_producer_to_last_produced[pro.producer_name] = dpos_irreversible_blocknum;
@@ -131,7 +131,7 @@ namespace eosio { namespace chain {
                new_producer_to_last_implied_irb[pro.producer_name] = existing->second;
             } else {
                //TODO: max of bft and dpos lib
-               if (new_version) {
+               if (pbft_enabled) {
                    new_producer_to_last_implied_irb[pro.producer_name] = bft_irreversible_blocknum;
                } else {
                    new_producer_to_last_implied_irb[pro.producer_name] = dpos_irreversible_blocknum;
@@ -168,13 +168,13 @@ namespace eosio { namespace chain {
    *
    *  If the header specifies new_producers then apply them accordingly.
    */
-  block_header_state block_header_state::next( const signed_block_header& h, bool skip_validate_signee, bool new_version  )const {
+  block_header_state block_header_state::next( const signed_block_header& h, bool skip_validate_signee, bool pbft_enabled  )const {
     EOS_ASSERT( h.timestamp != block_timestamp_type(), block_validate_exception, "", ("h",h) );
     //EOS_ASSERT( h.header_extensions.size() == 0, block_validate_exception, "no supported extensions" );
 
     EOS_ASSERT( h.timestamp > header.timestamp, block_validate_exception, "block must be later in time" );
     EOS_ASSERT( h.previous == id, unlinkable_block_exception, "block must link to current state" );
-    auto result = generate_next( h.timestamp, new_version);
+    auto result = generate_next( h.timestamp, pbft_enabled);
     EOS_ASSERT( result.header.producer == h.producer, wrong_producer, "wrong producer specified" );
     EOS_ASSERT( result.header.schedule_version == h.schedule_version, producer_schedule_exception, "schedule_version in signed block is corrupted" );
 
@@ -189,10 +189,10 @@ namespace eosio { namespace chain {
      /// must result in header state changes
 
 
-    result.set_confirmed(h.confirmed, new_version);
+    result.set_confirmed(h.confirmed, pbft_enabled);
 
 
-    auto was_pending_promoted = result.maybe_promote_pending(new_version);
+    auto was_pending_promoted = result.maybe_promote_pending(pbft_enabled);
 
     if( h.new_producers ) {
       EOS_ASSERT( !was_pending_promoted, producer_schedule_exception, "cannot set pending producer schedule in the same block in which pending was promoted to active" );
@@ -214,15 +214,15 @@ namespace eosio { namespace chain {
     return result;
   } /// next
 
-  void block_header_state::set_confirmed( uint16_t num_prev_blocks, bool new_version ) {
+  void block_header_state::set_confirmed( uint16_t num_prev_blocks, bool pbft_enabled ) {
      /*
      idump((num_prev_blocks)(confirm_count.size()));
 
      for( uint32_t i = 0; i < confirm_count.size(); ++i ) {
         std::cerr << "confirm_count["<<i<<"] = " << int(confirm_count[i]) << "\n";
      }
      */
-     if (new_version) {
+     if (pbft_enabled) {
          header.confirmed = 0;
          return;
      }

libraries/chain/block_state.cpp

@@ -3,15 +3,15 @@
 
 namespace eosio { namespace chain {
 
-   block_state::block_state( const block_header_state& prev, block_timestamp_type when, bool new_version )
-   :block_header_state( prev.generate_next( when, new_version) ),
+   block_state::block_state( const block_header_state& prev, block_timestamp_type when, bool pbft_enabled )
+   :block_header_state( prev.generate_next( when, pbft_enabled) ),
     block( std::make_shared<signed_block>()  )
    {
       static_cast<block_header&>(*block) = header;
    }
 
-   block_state::block_state( const block_header_state& prev, signed_block_ptr b, bool skip_validate_signee, bool new_version )
-   :block_header_state( prev.next( *b, skip_validate_signee, new_version)), block( move(b) )
+   block_state::block_state( const block_header_state& prev, signed_block_ptr b, bool skip_validate_signee, bool pbft_enabled )
+   :block_header_state( prev.next( *b, skip_validate_signee, pbft_enabled)), block( move(b) )
    { }