Merge pull request #218 from AntelopeIO/set_finalizers_hf

IF: add set_finalizers host function

.cicd/defaults.json

@@ -1,6 +1,6 @@
 {
     "leap-dev":{
-       "target":"main",
+       "target":"hotstuff_integration",
        "prerelease":false
     }
  }

libraries/eosiolib/capi/eosio/instant_finality.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup instant_finality_c Instant_finality C API
+ * @ingroup c_api
+ * @brief Defines %C Instant_finality API
+ */
+
+/**
+ * Submits a finalizer policy change to Instant Finality
+ * 
+ * @param data - pointer finalizer_policy object packed as bytes
+ * @param len  - size of packed finalazer_policy object
+ * @pre `data` is a valid pointer to a range of memory at least `len` bytes long that contains packed abi_finalizer_policy data
+ * abi_finalizer_policy structure is defined in instant_finality.hpp
+ */
+__attribute__((eosio_wasm_import))
+void set_finalizers( const char* data, uint32_t len );
+
+#ifdef __cplusplus
+}
+#endif

libraries/eosiolib/contracts/eosio/instant_finality.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "../../capi/eosio/types.h"
+#include "../../core/eosio/crypto_bls_ext.hpp"
+
+#include <string>
+#include <vector>
+
+/**
+ * @defgroup instant_finality Instant_finality
+ * @ingroup instant_finality
+ * @ingroup contracts
+ * @brief Defines C++ Instant Finality API
+ */
+
+namespace eosio {
+    namespace internal_use_do_not_use {
+        extern "C" {
+            __attribute__((eosio_wasm_import))
+            void set_finalizers( const char* data, uint32_t len );
+        } // extern "C"
+    } //internal_use_do_not_use
+
+    struct abi_finalizer_authority {
+        std::string           description;
+        uint64_t              fweight = 0; // weight that this finalizer's vote has for meeting fthreshold
+        std::vector<char>     public_key_g1_affine_le; // Affine little endian
+
+        EOSLIB_SERIALIZE(abi_finalizer_authority, (description)(fweight)(public_key_g1_affine_le));
+    };
+    struct abi_finalizer_policy {
+        uint64_t                             fthreshold = 0;
+        std::vector<abi_finalizer_authority> finalizers;
+
+        EOSLIB_SERIALIZE(abi_finalizer_policy, (fthreshold)(finalizers));
+    };
+
+/**
+ * Submits a finalizer policy change to Instant Finality
+ *
+ * @param finalizer_policy - finalizer policy to be set
+ */
+    inline void set_finalizers( const abi_finalizer_policy& finalizer_policy ) {
+        for (const auto& finalizer : finalizer_policy.finalizers)
+            eosio::check(finalizer.public_key_g1_affine_le.size() == sizeof(bls_g1), "public key has a wrong size" );
+        auto packed = eosio::pack(finalizer_policy);
+        internal_use_do_not_use::set_finalizers(packed.data(), packed.size());
+    }
+
+} //eosio

libraries/native/intrinsics.cpp

@@ -905,8 +905,12 @@ extern "C" {
    uint32_t get_active_security_group(char* data, uint32_t datalen){
       return intrinsics::get().call<intrinsics::get_active_security_group>(data, datalen);
    }
-
-}
+
+   void set_finalizers(const char* data, uint32_t len) {
+      intrinsics::get().call<intrinsics::set_finalizers>(data, len);
+   }
+
+} // extern "C"
 
 int32_t blake2_f( uint32_t rounds, const char* state, uint32_t state_len, const char* msg, uint32_t msg_len, 
                   const char* t0_offset, uint32_t t0_len, const char* t1_offset, uint32_t t1_len, int32_t final, char* result, uint32_t result_len) {

libraries/native/native/eosio/intrinsics_def.hpp

@@ -6,6 +6,7 @@
 #include <eosio/crypto_ext.h>
 #include <eosio/crypto_bls_ext.h>
 #include <eosio/db.h>
+#include <eosio/instant_finality.h>
 #include <eosio/permission.h>
 #include <eosio/print.h>
 #include <eosio/privileged.h>
@@ -183,9 +184,8 @@ intrinsic_macro(bls_g1_map) \
 intrinsic_macro(bls_g2_map) \
 intrinsic_macro(bls_fp_mod) \
 intrinsic_macro(bls_fp_mul) \
-intrinsic_macro(bls_fp_exp)
-
-
+intrinsic_macro(bls_fp_exp) \
+intrinsic_macro(set_finalizers)
 
 #define CREATE_ENUM(name) \
    name,

tests/integration/contracts.hpp.in

@@ -25,6 +25,9 @@ namespace eosio::testing {
 
       static std::vector<uint8_t> bls_primitives_test_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/../unit/test_contracts/bls_primitives_tests.wasm"); }
       static std::vector<char>    bls_primitives_test_abi() { return read_abi("${CMAKE_BINARY_DIR}/../unit/test_contracts/bls_primitives_tests.abi"); }
+
+      static std::vector<uint8_t> instant_finality_test_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/../unit/test_contracts/instant_finality_tests.wasm"); }
+      static std::vector<char>    instant_finality_test_abi() { return read_abi("${CMAKE_BINARY_DIR}/../unit/test_contracts/instant_finality_tests.abi"); }
 
       static std::vector<uint8_t> get_code_hash_write_test_wasm() { return read_wasm("${CMAKE_BINARY_DIR}/../unit/test_contracts/get_code_hash_write.wasm"); }
       static std::vector<char>    get_code_hash_write_test_abi() { return read_abi("${CMAKE_BINARY_DIR}/../unit/test_contracts/get_code_hash_write.abi"); }

tests/integration/instant_finality_tests.cpp

@@ -0,0 +1,53 @@
+#include <boost/test/unit_test.hpp>
+
+#include <eosio/testing/tester.hpp>
+#include <eosio/chain/abi_serializer.hpp>
+#include <fc/variant_object.hpp>
+
+#include <contracts.hpp>
+
+using namespace eosio;
+using namespace eosio::testing;
+using namespace fc;
+
+using mvo = fc::mutable_variant_object;
+
+BOOST_AUTO_TEST_SUITE(instant_finality_tests)
+
+BOOST_FIXTURE_TEST_CASE(instant_finality_test, tester) try {
+    create_accounts( { "test"_n } );
+    produce_block();
+
+    set_code( config::system_account_name,  contracts::instant_finality_test_wasm() );
+    set_abi(  config::system_account_name,  contracts::instant_finality_test_abi().data() );
+
+    produce_block();
+
+    push_action(config::system_account_name, "setfinalizer"_n, "test"_n, mvo()
+        ("finalizer_policy", mvo()("fthreshold", 1)
+                         ("finalizers", std::vector<mvo>{mvo()
+                                        ("description", "test_desc")
+                                        ("fweight", 1)
+                                        ("public_key_g1_affine_le", "220ef5c49c1868e85b82658df9766fc2cee4bd0b5d9880d4cdee9139edd3c4ebdae4074f1d3db3f3c9213962942eef091b00d9f2a9b837015c8dbe507f242aee459272589b6b2973bcf33eb4608722c70c1ac3d1ade40c845b9e15ea6380080a")})));
+    signed_block_ptr cur_block = produce_block();
+    fc::variant pretty_output;
+    abi_serializer::to_variant( *cur_block, pretty_output, get_resolver(), fc::microseconds::maximum() );
+    BOOST_REQUIRE(pretty_output.get_object().contains("proposed_finalizer_policy"));
+    BOOST_REQUIRE_EQUAL(pretty_output["proposed_finalizer_policy"]["generation"], 1);
+    BOOST_REQUIRE_EQUAL(pretty_output["proposed_finalizer_policy"]["fthreshold"], 1);
+    BOOST_REQUIRE_EQUAL(pretty_output["proposed_finalizer_policy"]["finalizers"].size(), 1u);
+    BOOST_REQUIRE_EQUAL(pretty_output["proposed_finalizer_policy"]["finalizers"][size_t(0)]["description"], "test_desc");
+    BOOST_REQUIRE_EQUAL(pretty_output["proposed_finalizer_policy"]["finalizers"][size_t(0)]["fweight"], 1);
+    BOOST_REQUIRE_EQUAL(pretty_output["proposed_finalizer_policy"]["finalizers"][size_t(0)]["public_key"], "PUB_BLS_Ig71xJwYaOhbgmWN+XZvws7kvQtdmIDUze6ROe3TxOva5AdPHT2z88khOWKULu8JGwDZ8qm4NwFcjb5QfyQq7kWSclibaylzvPM+tGCHIscMGsPRreQMhFueFepjgAgKXjOb8g==");
+
+    // testing wrong public key size
+    BOOST_CHECK_THROW(push_action(config::system_account_name, "setfinalizer"_n, "test"_n, mvo()
+        ("finalizer_policy", mvo()("fthreshold", 1)
+                         ("finalizers", std::vector<mvo>{mvo()
+                                        ("description", "test_desc")
+                                        ("fweight", 1)
+                                        ("public_key_g1_affine_le", std::vector<char>{'a', 'b', 'c'})}))), fc::exception);
+
+} FC_LOG_AND_RETHROW()
+
+BOOST_AUTO_TEST_SUITE_END()

tests/toolchain/compile-fail/host_functions_tests.cpp

@@ -8,6 +8,7 @@ set_blockchain_parameters_packed : yes
 set_parameters_packed : yes
 set_privileged  : yes
 send_deferred : yes
+set_finalizers : yes
 */
 
 #include <eosio/eosio.hpp>

tests/unit/test_contracts/CMakeLists.txt

@@ -8,6 +8,7 @@ add_contract(transfer_contract transfer_contract transfer.cpp)
 add_contract(minimal_tests minimal_tests minimal_tests.cpp)
 add_contract(crypto_primitives_tests crypto_primitives_tests crypto_primitives_tests.cpp)
 add_contract(bls_primitives_tests bls_primitives_tests bls_primitives_tests.cpp)
+add_contract(instant_finality_tests instant_finality_tests instant_finality_tests.cpp)
 add_contract(get_code_hash_tests get_code_hash_write get_code_hash_write.cpp)
 add_contract(get_code_hash_tests get_code_hash_read get_code_hash_read.cpp)
 add_contract(name_pk_tests name_pk_tests name_pk_tests.cpp)

tests/unit/test_contracts/capi/privileged.c

@@ -1,4 +1,5 @@
 #include <eosio/privileged.h>
+#include <eosio/instant_finality.h>
 #include <stdint.h>
 
 void test_privileged( void ) {
@@ -11,4 +12,5 @@ void test_privileged( void ) {
    set_blockchain_parameters_packed(NULL, 0);
    get_blockchain_parameters_packed(NULL, 0);
    preactivate_feature(NULL);
+   set_finalizers(NULL, 0);
 }

tests/unit/test_contracts/instant_finality_tests.cpp

@@ -0,0 +1,12 @@
+#include <eosio/eosio.hpp>
+#include <eosio/instant_finality.hpp>
+
+class [[eosio::contract]] instant_finality_tests : public eosio::contract{
+public:
+    using contract::contract;
+
+    [[eosio::action]]
+    void setfinalizer(const eosio::abi_finalizer_policy& finalizer_policy) {
+        eosio::set_finalizers(finalizer_policy);
+    }
+};

tools/include/eosio/gen.hpp

@@ -895,7 +895,8 @@ struct generation_utils {
          "db_idx_long_double_remove",
          "send_deferred",
          "send_inline",
-         "send_context_free_inline"
+         "send_context_free_inline",
+         "set_finalizers"
       };
 
       return write_host_funcs.count(func_decl->getNameInfo().getAsString()) >= 1;