IF: Savanna

.cicd/defaults.json

@@ -1,9 +1,9 @@
 {
     "cdt":{
-       "target":"4",
+       "target":"hotstuff_integration",
        "prerelease":false
     },
     "referencecontracts":{
-       "ref":"main"
+       "ref":"instant-finality"
     }
  }

.github/workflows/build.yaml

@@ -236,7 +236,7 @@ jobs:
           error-log-paths: '["build/etc", "build/var", "build/spring-ignition-wd", "build/TestLogs"]'
           log-tarball-prefix: ${{matrix.cfg.name}}
           tests-label: long_running_tests
-          test-timeout: 1800
+          test-timeout: 2700
       - name: Export core dumps
         run: docker run --mount type=bind,source=/var/lib/systemd/coredump,target=/cores alpine sh -c 'tar -C /cores/ -c .' | tar x
         if: failure()

.gitignore

@@ -92,3 +92,4 @@ node_modules
 package-lock.json
 
 snapshots
+!unittests/snapshots

CMakeModules/EosioTesterBuild.cmake.in

@@ -110,6 +110,7 @@ target_include_directories(EosioChain INTERFACE
                               @CMAKE_BINARY_DIR@/libraries/chain/include
                               @CMAKE_SOURCE_DIR@/libraries/libfc/include
                               @CMAKE_SOURCE_DIR@/libraries/libfc/libraries/boringssl/boringssl/src/include
+                              @CMAKE_SOURCE_DIR@/libraries/libfc/libraries/bls12-381/include
                               @CMAKE_SOURCE_DIR@/libraries/softfloat/source/include
                               @CMAKE_SOURCE_DIR@/libraries/appbase/include
                               @CMAKE_SOURCE_DIR@/libraries/chainbase/include

benchmark/benchmark.cpp

@@ -15,7 +15,8 @@ std::map<std::string, std::function<void()>> features {
    { "key", key_benchmarking },
    { "hash", hash_benchmarking },
    { "blake2", blake2_benchmarking },
-   { "bls", bls_benchmarking }
+   { "bls", bls_benchmarking },
+   { "merkle", merkle_benchmarking }
 };
 
 // values to control cout format
@@ -34,6 +35,10 @@ void set_num_runs(uint32_t runs) {
    num_runs = runs;
 }
 
+uint32_t get_num_runs() {
+   return num_runs;
+}
+
 void print_header() {
    std::cout << std::left << std::setw(name_width) << "function"
       << std::setw(runs_width) << "runs"
@@ -63,12 +68,14 @@ bytes to_bytes(const std::string& source) {
    return output;
 };
 
-void benchmarking(const std::string& name, const std::function<void()>& func) {
+void benchmarking(const std::string& name, const std::function<void()>& func,
+                  std::optional<size_t> opt_num_runs /* = {} */) {
    uint64_t total{0};
    uint64_t min{std::numeric_limits<uint64_t>::max()};
    uint64_t max{0};
+   uint32_t runs = opt_num_runs ? *opt_num_runs : num_runs;
 
-   for (auto i = 0U; i < num_runs; ++i) {
+   for (auto i = 0U; i < runs; ++i) {
       auto start_time = std::chrono::high_resolution_clock::now();
       func();
       auto end_time = std::chrono::high_resolution_clock::now();
@@ -79,7 +86,7 @@ void benchmarking(const std::string& name, const std::function<void()>& func) {
       max = std::max(max, duration);
    }
 
-   print_results(name, num_runs, total, min, max);
+   print_results(name, runs, total, min, max);
 }
 
 } // benchmark

benchmark/benchmark.hpp

@@ -4,13 +4,15 @@
 #include <map>
 #include <vector>
 #include <limits>
+#include <optional>
 
 #include <fc/crypto/hex.hpp>
 
 namespace eosio::benchmark {
 using bytes = std::vector<char>;
 
 void set_num_runs(uint32_t runs);
+uint32_t get_num_runs();
 std::map<std::string, std::function<void()>> get_features();
 void print_header();
 bytes to_bytes(const std::string& source);
@@ -21,7 +23,8 @@ void key_benchmarking();
 void hash_benchmarking();
 void blake2_benchmarking();
 void bls_benchmarking();
+void merkle_benchmarking();
 
-void benchmarking(const std::string& name, const std::function<void()>& func); 
+void benchmarking(const std::string& name, const std::function<void()>& func, std::optional<size_t> num_runs = {});
 
 } // benchmark

benchmark/bls.cpp

@@ -70,7 +70,8 @@ struct interface_in_benchmark {
       // build transaction context from the packed transaction
       timer = std::make_unique<platform_timer>();
       trx_timer = std::make_unique<transaction_checktime_timer>(*timer);
-      trx_ctx = std::make_unique<transaction_context>(*chain->control.get(), *ptrx, ptrx->id(), std::move(*trx_timer));
+      trx_ctx = std::make_unique<transaction_context>(*chain->control.get(), *ptrx, ptrx->id(), std::move(*trx_timer),
+                                                      action_digests_t::store_which_t::legacy);
       trx_ctx->max_transaction_time_subjective = fc::microseconds::maximum();
       trx_ctx->init_for_input_trx( ptrx->get_unprunable_size(), ptrx->get_prunable_size() );
       trx_ctx->exec(); // this is required to generate action traces to be used by apply_context constructor

benchmark/merkle.cpp

@@ -0,0 +1,69 @@
+#include <benchmark.hpp>
+#include <eosio/chain/incremental_merkle.hpp>
+#include <eosio/chain/incremental_merkle_legacy.hpp>
+#include <random>
+
+namespace eosio::benchmark {
+
+using namespace eosio::chain;
+
+std::vector<digest_type> create_test_digests(size_t n) {
+   std::vector<digest_type> v;
+   v.reserve(n);
+   for (size_t i=0; i<n; ++i)
+      v.push_back(fc::sha256::hash(std::string{"Node"} + std::to_string(i)));
+   return v;
+}
+
+void benchmark_calc_merkle(uint32_t size_boost) {
+   using namespace std::string_literals;
+   const size_t num_digests = size_boost * 1000ull; // don't use exact powers of 2 as it is a special case
+
+   const std::vector<digest_type> digests = create_test_digests(num_digests);
+   const deque<digest_type> deq { digests.begin(), digests.end() };
+
+   auto num_str = std::to_string(size_boost);
+   while(num_str.size() < 4)
+      num_str.insert(0, 1, ' ');
+   auto msg_header = "Calc, "s + num_str + ",000 digests,  "s;
+   uint32_t num_runs = std::min(get_num_runs(), std::max(1u, get_num_runs() / size_boost));
+   benchmarking(msg_header + "legacy: ", [&]() { calculate_merkle_legacy(deq); }, num_runs);
+   benchmarking(msg_header + "savanna:", [&]() { calculate_merkle(digests.begin(), digests.end()); }, num_runs);
+}
+
+void benchmark_incr_merkle(uint32_t size_boost) {
+   using namespace std::string_literals;
+   const size_t num_digests = size_boost * 1000ull; // don't use exact powers of 2 as it is a special case
+
+   const std::vector<digest_type> digests = create_test_digests(num_digests);
+
+   auto num_str = std::to_string(size_boost);
+   while(num_str.size() < 4)
+      num_str.insert(0, 1, ' ');
+   auto msg_header = "Incr, "s + num_str + ",000 digests,  "s;
+   uint32_t num_runs = std::min(get_num_runs(), std::max(1u, get_num_runs() / size_boost));
+
+   auto incr = [&](const auto& incr_tree) {
+      auto work_tree = incr_tree;
+      for (const auto& d : digests)
+         work_tree.append(d);
+      return work_tree.get_root();
+   };
+
+   benchmarking(msg_header + "legacy: ", [&]() { incr(incremental_merkle_tree_legacy()); }, num_runs);
+   benchmarking(msg_header + "savanna:", [&]() { incr(incremental_merkle_tree()); }, num_runs);
+}
+
+// register benchmarking functions
+void merkle_benchmarking() {
+   benchmark_calc_merkle(1000); // calculate_merkle of very large sequence (1,000,000 digests)
+   benchmark_calc_merkle(50);   // calculate_merkle of large sequence (50,000 digests)
+   benchmark_calc_merkle(1);    // calculate_merkle of small sequence (1000 digests)
+   std::cout << "\n";
+
+   benchmark_incr_merkle(100);  // incremental_merkle of very large sequence (100,000 digests)
+   benchmark_incr_merkle(25);   // incremental_merkle of large sequence (25,000 digests)
+   benchmark_incr_merkle(1);    // incremental_merkle of small sequence (1000 digests)
+}
+
+}

docs/block_production/lifecycle.md

@@ -0,0 +1,27 @@
+The following diagram describes Leap block production, as implemented in `libraries/chain/controller.cpp`:
+
+```mermaid
+flowchart TD
+    pp[producer_plugin] --> D
+    A("replay()"):::fun --> B("replay_push_block()"):::fun
+    B --> E("maybe_switch_forks()"):::fun
+    C("init()"):::fun ---> E
+    C --> A
+    D("push_block()"):::fun ---> E
+    subgraph G["apply_block()"]
+       direction TB
+       start -- "stage = Ø" --> sb
+       sb("start_block()"):::fun -- "stage = building_block" --> et
+       et["execute transactions" ] -- "stage = building_block" --> fb("finish_block()"):::fun
+       fb -- "stage = assembled block" --> cb["add transaction metadata and create completed block"]
+       cb -- "stage = completed block" --> commit("commit_block() (where we [maybe] add to fork_db and mark valid)"):::fun
+
+    end
+    B ----> start
+    E --> G
+    D --> F("log_irreversible()"):::fun
+    commit -- "stage =  Ø" -->  F
+    F -- "if in irreversible mode" --> G
+
+    classDef fun fill:#f96
+```

libraries/chain/CMakeLists.txt

@@ -3,6 +3,7 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/genesis_state_root_key.cpp.in ${CMAKE
 
 file(GLOB HEADERS "include/eosio/chain/*.hpp"
                   "include/eosio/chain/webassembly/*.hpp"
+                  "include/eosio/chain/finality/*.hpp"
                   "${CMAKE_CURRENT_BINARY_DIR}/include/eosio/chain/core_symbol.hpp" )
 
 if((APPLE AND UNIX) OR (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD"))
@@ -78,16 +79,24 @@ set(CHAIN_WEBASSEMBLY_SOURCES
    webassembly/transaction.cpp
 )
 
+set(CHAIN_FINALITY_SOURCES
+        finality/finalizer.cpp
+        finality/instant_finality_extension.cpp
+        finality/quorum_certificate.cpp
+        finality/finality_core.cpp
+)
+
 add_library(eosio_rapidjson INTERFACE)
 target_include_directories(eosio_rapidjson INTERFACE ../rapidjson/include)
 
 ## SORT .cpp by most likely to change / break compile
 add_library( eosio_chain
-             merkle.cpp
              name.cpp
              transaction.cpp
              block.cpp
              block_header.cpp
+             block_header_state.cpp
+             block_state.cpp
              block_header_state_legacy.cpp
              block_state_legacy.cpp
              fork_database.cpp
@@ -119,6 +128,7 @@ add_library( eosio_chain
              ${CHAIN_EOSVMOC_SOURCES}
              ${CHAIN_EOSVM_SOURCES}
              ${CHAIN_WEBASSEMBLY_SOURCES}
+             ${CHAIN_FINALITY_SOURCES}
 
              authority.cpp
              trace.cpp

libraries/chain/abi_serializer.cpp

@@ -1,6 +1,7 @@
 #include <eosio/chain/abi_serializer.hpp>
 #include <eosio/chain/asset.hpp>
 #include <eosio/chain/exceptions.hpp>
+#include <eosio/chain/finality/instant_finality_extension.hpp>
 #include <fc/io/raw.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <fc/io/varint.hpp>
@@ -633,6 +634,14 @@ namespace eosio { namespace chain {
       _variant_to_binary(type, var, ds, ctx);
    }
 
+   void impl::abi_to_variant::add_block_header_instant_finality_extension( mutable_variant_object& mvo, const header_extension_multimap& header_exts ) {
+      if (header_exts.count(instant_finality_extension::extension_id())) {
+         const auto& if_extension =
+                 std::get<instant_finality_extension>(header_exts.lower_bound(instant_finality_extension::extension_id())->second);
+         mvo("instant_finality_extension", if_extension);
+      }
+   }
+
    type_name abi_serializer::get_action_type(name action)const {
       auto itr = actions.find(action);
       if( itr != actions.end() ) return itr->second;

libraries/chain/apply_context.cpp

@@ -14,7 +14,7 @@
 
 using boost::container::flat_set;
 
-namespace eosio { namespace chain {
+namespace eosio::chain {
 
 static inline void print_debug(account_name receiver, const action_trace& ar) {
    if (!ar.console.empty()) {
@@ -184,7 +184,7 @@ void apply_context::exec_one()
       r.auth_sequence[auth.actor] = next_auth_sequence( auth.actor );
    }
 
-   trx_context.executed_action_receipt_digests.emplace_back( r.digest() );
+   trx_context.executed_action_receipts.compute_and_append_digests_from(trace);
 
    finalize_trace( trace, start );
 
@@ -218,17 +218,17 @@ void apply_context::exec()
       exec_one();
    }
 
-   if( _cfa_inline_actions.size() > 0 || _inline_actions.size() > 0 ) {
+   if( !_cfa_inline_actions.empty() || !_inline_actions.empty() ) {
       EOS_ASSERT( recurse_depth < control.get_global_properties().configuration.max_inline_action_depth,
                   transaction_exception, "max inline action depth per transaction reached" );
-   }
 
-   for( uint32_t ordinal : _cfa_inline_actions ) {
-      trx_context.execute_action( ordinal, recurse_depth + 1 );
-   }
+      for( uint32_t ordinal : _cfa_inline_actions ) {
+         trx_context.execute_action( ordinal, recurse_depth + 1 );
+      }
 
-   for( uint32_t ordinal : _inline_actions ) {
-      trx_context.execute_action( ordinal, recurse_depth + 1 );
+      for( uint32_t ordinal : _inline_actions ) {
+         trx_context.execute_action( ordinal, recurse_depth + 1 );
+      }
    }
 
 } /// exec()
@@ -1105,4 +1105,4 @@ bool apply_context::should_use_eos_vm_oc()const {
 }
 
 
-} } /// eosio::chain
+} /// eosio::chain

libraries/chain/block.cpp

@@ -1,6 +1,6 @@
 #include <eosio/chain/block.hpp>
 
-namespace eosio { namespace chain {
+namespace eosio::chain {
    void additional_block_signatures_extension::reflector_init() {
       static_assert( fc::raw::has_feature_reflector_init_on_unpacked_reflected_types,
                      "additional_block_signatures_extension expects FC to support reflector_init" );
@@ -20,6 +20,11 @@ namespace eosio { namespace chain {
       }
    }
 
+   void quorum_certificate_extension::reflector_init() {
+      static_assert( fc::raw::has_feature_reflector_init_on_unpacked_reflected_types, "quorum_certificate_extension expects FC to support reflector_init" );
+      static_assert( extension_id() == 3, "extension id for quorum_certificate_extension must be 3" );
+   }
+
    flat_multimap<uint16_t, block_extension> signed_block::validate_and_extract_extensions()const {
       using decompose_t = block_extension_types::decompose_t;
 
@@ -58,7 +63,42 @@ namespace eosio { namespace chain {
       }
 
       return results;
+   }
+
+   // Does not validate ordering, assumes validate_and_extract_extensions() has been called in verify_qc_claim()
+   std::optional<block_extension> signed_block::extract_extension(uint16_t extension_id)const {
+      using decompose_t = block_extension_types::decompose_t;
+
+      assert(std::ranges::is_sorted(block_extensions)); // currently all extensions are unique so default compare works
+
+      for( size_t i = 0; i < block_extensions.size(); ++i ) {
+         const auto& e = block_extensions[i];
+         auto id = e.first;
+
+         if (id > extension_id)
+            break;
+         if (id != extension_id)
+            continue;
+
+         std::optional<block_extension> ext;
+         ext.emplace();
+
+         auto match = decompose_t::extract<block_extension>( id, e.second, *ext );
+         EOS_ASSERT( match, invalid_block_extension,
+                     "Block extension with id type ${id} is not supported",
+                     ("id", id)
+         );
+
+         return ext;
+      }
+
+      return {};
+   }
 
+   bool signed_block::contains_extension(uint16_t extension_id)const {
+      return std::any_of(block_extensions.cbegin(), block_extensions.cend(), [&](const auto& p) {
+         return p.first == extension_id;
+      });
    }
 
-} } /// namespace eosio::chain
+} /// namespace eosio::chain