Add beacon chain update plugin and cranker executable

cmake/dependencies.boost.cmake

@@ -34,6 +34,7 @@ set(BOOST_COMPONENTS
         system
         thread
         unit_test_framework
+        url
 )
 foreach (COMPONENT ${BOOST_COMPONENTS})
     find_package(boost_${COMPONENT} ${BOOST_VERSION} EXACT CONFIG REQUIRED)

libraries/custom_appbase/include/sysio/chain/app.hpp

@@ -77,7 +77,8 @@ void log_non_default_options(const std::vector<bpo::basic_option<char>>& options
    for (const auto& op : options) {
       bool mask = false;
       if (op.string_key == "peer-private-key"s
-          || op.string_key == "p2p-auto-bp-peer"s) {
+          || op.string_key == "p2p-auto-bp-peer"s
+          || op.string_key == "beacon-chain-api-key"s) {
          mask = true;
           }
       std::string v;

libraries/libfc/include/fc/network/ethereum/ethereum_abi.hpp

@@ -17,7 +17,7 @@
 namespace fc::network::ethereum {
 
 namespace abi {
-enum class invoke_target_type { function, constructor, event, error };
+enum class invoke_target_type { function, constructor, event, error, receive };
 
 enum class data_type : int64_t {
    boolean,
@@ -196,7 +196,8 @@ using contract_invoke_data_items = std::vector<contract_invoke_data>;
  * Encode a contract call
  * @return hex string of encoded call `data` field in RLP format
  */
-std::string contract_encode_data(const abi::contract& contract, const contract_invoke_data_items& params);
+std::string contract_encode_data(const abi::contract& contract, const contract_invoke_data_items& params,
+                                 bool add_hex_prefix = false);
 
 template <typename T>
 concept not_abi_data_params_t = !std::is_same_v<std::decay_t<T>, contract_invoke_data_items>;
@@ -297,7 +298,7 @@ struct get_typename<fc::network::ethereum::abi::data_type> {
 };
 }; // namespace fc
 
-FC_REFLECT_ENUM(fc::network::ethereum::abi::invoke_target_type, (function)(constructor)(event)(error));
+FC_REFLECT_ENUM(fc::network::ethereum::abi::invoke_target_type, (function)(constructor)(event)(error)(receive));
 
 FC_REFLECT(fc::network::ethereum::abi::component_type::list_config_type, (is_list)(size));
 FC_REFLECT(fc::network::ethereum::abi::component_type, (name)(type)(list_config)(components)(internal_type));

libraries/libfc/include/fc/network/ethereum/ethereum_client.hpp

@@ -406,6 +406,13 @@ class ethereum_client : public std::enable_shared_from_this<ethereum_client> {
     */
    std::string send_raw_transaction(const std::string& raw_tx_data);
 
+   /**
+    * @brief Retrieves the transaction receipt and extracts the block number.
+    * @param tx_hash The transaction hash
+    * @return The block number if the receipt is available, or std::nullopt if not yet mined
+    */
+   std::optional<uint64_t> get_block_for_transaction(const std::string& tx_hash);
+
    /**
     * @brief Submit a raw transaction and await inclusion + N confirmations.
     *

libraries/libfc/src/io/json.cpp

@@ -1,6 +1,8 @@
 #include <fc/io/json.hpp>
 //#include <fc/io/fstream.hpp>
 //#include <fc/io/sstream.hpp>
+#include <fc/int128.hpp>
+#include <fc/int256.hpp>
 #include <fc/log/logger.hpp>
 //#include <utfcpp/utf8.h>
 #include <fc/utf8.hpp>
@@ -28,6 +30,19 @@ namespace fc
 
 #include <fc/io/json_relaxed.hpp>
 
+namespace
+{
+
+   // Max |value| decimal strings used to pick the smallest variant bucket that fits a token.
+   // Signed entries use the magnitude of *_MIN (one greater than *_MAX); unsigned entries use *_MAX.
+   constexpr std::string_view int64_max_magnitude_str  =  "9223372036854775808"; // | INT64_MIN|
+   constexpr std::string_view uint64_max_magnitude_str = "18446744073709551615"; // |UINT64_MIN|
+   constexpr std::string_view int256_max_str =
+      "57896044618658097711785492504343953926634992332820282019728792003956564819968";
+   constexpr std::string_view uint256_max_str =
+      "115792089237316195423570985008687907853269984665640564039457584007913129639935";
+}
+
 namespace fc
 {
    namespace {
@@ -307,6 +322,7 @@ namespace fc
         s += in.get();
       }
       bool done = false;
+      variant ret;
 
       try
       {
@@ -337,7 +353,8 @@ namespace fc
                  if( isalnum( c ) )
                  {
                     s += string_from_token( in );
-                    return s;
+                    ret = std::move(s);
+                    return ret;
                  }
                 done = true;
                 break;
@@ -350,14 +367,76 @@ namespace fc
       catch (const std::ios_base::failure&)
       {
       }
-      const std::string& str = s;
-      if (str == "-." || str == "." || str == "-") // check the obviously wrong things we could have encountered
-        FC_THROW_EXCEPTION(parse_error_exception, "Can't parse token \"{}\" as a JSON numeric constant", str);
-      if( dot )
-        return parser_type == json::parse_type::legacy_parser_with_string_doubles ? variant(str) : variant(to_double(str));
-      if( neg )
-        return to_int64(str);
-      return to_uint64(str);
+
+      const auto no_neg_start = neg ? 1 : 0;
+      const auto start = s.find_first_not_of('0', no_neg_start);
+      const auto str = (start != std::string::npos)
+         ? std::string_view(s).substr(start)
+         : std::string_view{};
+
+      // if the string is empty and we had actual digits after the sign
+      if (str.empty() && s.size() > no_neg_start) {
+         ret = 0u;
+         return ret;
+      }
+
+      // check for s== ".", "-","-.", since "[-]0*" is checked above
+      if (str == "." || str.empty()) // check the obviously wrong things we could have encountered
+         FC_THROW_EXCEPTION(parse_error_exception, "Can't parse token \"{}\" as a JSON numeric constant", str);
+
+      if( dot ) {
+         ret = parser_type == json::parse_type::legacy_parser_with_string_doubles
+               ? variant(std::move(s))
+               : variant(to_double(s));
+         return ret;
+      }
+
+      if( neg ) {
+         // Common case: fits in int64
+         if (str.length() < int64_max_magnitude_str.length() ||
+            (str.length() == int64_max_magnitude_str.length() && str <= int64_max_magnitude_str)) {
+            ret = to_int64(s);
+            return ret;
+         }
+
+         if (str.length() > int256_max_str.length() ||
+             (str.length() == int256_max_str.length() && str > int256_max_str)) {
+            FC_THROW_EXCEPTION(parse_error_exception,
+                               "Negative numeric token \"{}\" exceeds int256 range", s);
+         }
+
+         if (str == int256_max_str) {
+            const auto val = std::numeric_limits<fc::int256>::min();
+            ret = val;
+            return ret;
+         }
+
+         // using the string with no leading 0s, to avoid the string being assumed to be in octal,
+         // since a leading 0 with only digits between 0 and 7 are assumed to be octal
+         fc::int256 val256(str);
+         val256 = -val256;
+         ret = std::move(val256);
+         return ret;
+      }
+
+      // Common case: fits in uint64
+      if (str.length() < uint64_max_magnitude_str.length() ||
+         (str.length() == uint64_max_magnitude_str.length() && str <= uint64_max_magnitude_str)) {
+         ret = to_uint64(s);
+         return ret;
+      }
+
+      if (str.length() > uint256_max_str.length() ||
+          (str.length() == uint256_max_str.length() && str > uint256_max_str)) {
+         FC_THROW_EXCEPTION(parse_error_exception,
+                            "Numeric token \"{}\" exceeds uint256 range", s);
+      }
+
+      // using the string with no leading 0s, to avoid the string being assumed to be in octal,
+      // since a leading 0 with only digits between 0 and 7 are assumed to be octal
+      fc::uint256 val256(str);
+      ret = std::move(val256);
+      return ret;
    }
 
    template<typename T>

libraries/libfc/src/network/ethereum/ethereum_abi.cpp

@@ -846,7 +846,8 @@ abi::contract abi::parse_contract(const fc::variant& v) {
  * @return Hex string of encoded call data (selector + encoded parameters)
  * @throws fc::exception if parameter count mismatches or encoding fails
  */
-std::string contract_encode_data(const abi::contract& contract, const std::vector<fc::variant>& params) {
+std::string contract_encode_data(const abi::contract& contract, const std::vector<fc::variant>& params,
+                                 bool add_hex_prefix) {
    const auto& inputs = contract.inputs;
    FC_ASSERT_FMT(inputs.size() == params.size(), "Parameter count mismatch (expected={}, provided={})", inputs.size(),
                  params.size());
@@ -890,7 +891,7 @@ std::string contract_encode_data(const abi::contract& contract, const std::vecto
       out.insert(out.end(), tail.begin(), tail.end());
    }
 
-   return fc::to_hex(out);
+   return fc::to_hex(out, add_hex_prefix);
 }
 
 
@@ -1058,7 +1059,12 @@ void fc::from_variant(const fc::variant& var, fc::network::ethereum::abi::contra
 
    FC_ASSERT(var.is_object(), "Variant must be an object to deserialize ABI contract");
    auto& obj = var.get_object();
-   vo.name = obj["name"].as_string();
+   const auto name_itr = obj.find("name");
+   const bool no_name = name_itr == obj.end();
+   if (!no_name) {
+      vo.name = name_itr->value().as_string();
+   }
+
    auto type_str = obj["type"].as_string();
    vo.type = fc::reflector<fc::network::ethereum::abi::invoke_target_type>::from_string(type_str.c_str());
 
@@ -1079,4 +1085,10 @@ void fc::from_variant(const fc::variant& var, fc::network::ethereum::abi::contra
 
    parse_components(vo.inputs, "inputs");
    parse_components(vo.outputs, "outputs");
+   if(no_name) {
+      // we expect ABI contracts that have the legacy payment ethereum interface
+      const bool valid = type_str == "receive" &&
+                         obj["stateMutability"].as_string() == "payable";
+      FC_ASSERT(valid, "Variant Object must have a `name` key to deserialize ABI contract");
+   }
 }

libraries/libfc/src/network/ethereum/ethereum_client.cpp

@@ -86,7 +86,7 @@ fc::variant ethereum_client::execute(const std::string& method, const fc::varian
 fc::variant ethereum_client::execute_contract_view_fn(const address& contract_address, const abi::contract& abi,
                                                       const std::string& block_tag,
                                                       const contract_invoke_data_items& params) {
-   auto abi_call_encoded = contract_encode_data(abi, params);
+   auto abi_call_encoded = contract_encode_data(abi, params, true);
    auto to_data_mvo = fc::mutable_variant_object("to", to_hex(contract_address, true))("data", abi_call_encoded);
    fc::variants rpc_params = {to_data_mvo, fc::variant(block_tag)};
    return execute("eth_call", rpc_params);
@@ -120,7 +120,7 @@ fc::variant ethereum_client::execute_contract_tx_fn(const eip1559_tx& source_tx,
       tx_encoded = rlp::encode_eip1559_signed_typed(tx);
    }
 
-   return send_raw_transaction(to_hex(tx_encoded));
+   return send_raw_transaction(to_hex(tx_encoded, true));
 }
 
 
@@ -478,6 +478,16 @@ std::string ethereum_client::send_raw_transaction(const std::string& raw_tx_data
    return resp.as_string();
 }
 
+std::optional<uint64_t> ethereum_client::get_block_for_transaction(const std::string& tx_hash) {
+   auto receipt = get_transaction_receipt(tx_hash);
+   if (receipt.is_null())
+      return std::nullopt;
+   const auto& obj = receipt.get_object();
+   if (!obj.contains("blockNumber") || obj["blockNumber"].is_null())
+      return std::nullopt;
+   return static_cast<uint64_t>(to_uint256(obj["blockNumber"]));
+}
+
 std::string ethereum_client::wait_for_confirmation(const std::string& tx_hash,
                                                     const ethereum_confirm_options& opts) {
    // Phase 1: wait for the receipt to exist. A null result means the tx