Add host functions to support EVM

libraries/chain/controller.cpp

@@ -325,6 +325,8 @@ struct controller_impl {
       set_activation_handler<builtin_protocol_feature_t::configurable_wasm_limits>();
       set_activation_handler<builtin_protocol_feature_t::blockchain_parameters>();
       set_activation_handler<builtin_protocol_feature_t::get_code_hash>();
+      set_activation_handler<builtin_protocol_feature_t::get_block_num>();
+      set_activation_handler<builtin_protocol_feature_t::evm_precompiles>();
 
       self.irreversible_block.connect([this](const block_state_ptr& bsp) {
          wasmif.current_lib(bsp->block_num);
@@ -2938,6 +2940,15 @@ time_point controller::pending_block_time()const {
    return my->pending->get_pending_block_header_state().timestamp;
 }
 
+uint32_t controller::pending_block_num()const {
+   EOS_ASSERT( my->pending, block_validate_exception, "no pending block" );
+
+   if( std::holds_alternative<completed_block>(my->pending->_block_stage) )
+      return std::get<completed_block>(my->pending->_block_stage)._block_state->header.block_num();
+
+   return my->pending->get_pending_block_header_state().block_num;
+}
+
 account_name controller::pending_block_producer()const {
    EOS_ASSERT( my->pending, block_validate_exception, "no pending block" );
 
@@ -3577,6 +3588,26 @@ void controller_impl::on_activation<builtin_protocol_feature_t::get_code_hash>()
    } );
 }
 
+template<>
+void controller_impl::on_activation<builtin_protocol_feature_t::get_block_num>() {
+   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "get_block_num" );
+   } );
+}
+
+template<>
+void controller_impl::on_activation<builtin_protocol_feature_t::evm_precompiles>() {
+   db.modify( db.get<protocol_state_object>(), [&]( auto& ps ) {
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "alt_bn128_add" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "alt_bn128_mul" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "alt_bn128_pair" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "mod_exp" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "blake2_f" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "sha3" );
+      add_intrinsic_to_whitelist( ps.whitelisted_intrinsics, "ecrecover" );
+   } );
+}
+
 /// End of protocol feature activation handlers
 
 } } /// eosio::chain

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

@@ -226,6 +226,7 @@ namespace eosio { namespace chain {
          account_name                   pending_block_producer()const;
          const block_signing_authority& pending_block_signing_authority()const;
          std::optional<block_id_type>   pending_producer_block_id()const;
+         uint32_t                       pending_block_num()const;
 
          const vector<transaction_receipt>& get_pending_trx_receipts()const;
 

libraries/chain/include/eosio/chain/protocol_feature_manager.hpp

@@ -32,7 +32,9 @@ enum class builtin_protocol_feature_t : uint32_t {
    // 15 reserved
    blockchain_parameters = 16, // matches release 2.1 value
    get_code_hash = 17,
-   configurable_wasm_limits = 18, // configurable_wasm_limits2
+   configurable_wasm_limits = 18, // configurable_wasm_limits2,
+   evm_precompiles = 19,
+   get_block_num = 20,
    reserved_private_fork_protocol_features = 500000,
 };
 

libraries/chain/include/eosio/chain/webassembly/eos-vm-oc/intrinsic_mapping.hpp

@@ -259,7 +259,15 @@ inline constexpr auto get_intrinsic_table() {
       "env.set_wasm_parameters_packed",
       "env.get_parameters_packed",
       "env.set_parameters_packed",
-      "env.get_code_hash"
+      "env.get_code_hash",
+      "env.alt_bn128_add",
+      "env.alt_bn128_mul",
+      "env.alt_bn128_pair",
+      "env.mod_exp",
+      "env.sha3",
+      "env.blake2_f",
+      "env.ecrecover",
+      "env.get_block_num"
    );
 }
 inline constexpr std::size_t find_intrinsic_index(std::string_view hf) {

libraries/chain/include/eosio/chain/webassembly/error_codes.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+
+namespace eosio { namespace chain { namespace webassembly { namespace error_codes {
+
+   enum crypto : int32_t {
+      none      = 0,
+      fail      = 1
+   };
+
+}}}} // ns eosio::chain::webassembly::error_codes

libraries/chain/include/eosio/chain/webassembly/interface.hpp

@@ -542,6 +542,15 @@ namespace webassembly {
          */
          uint64_t current_time() const;
 
+         /**
+          * Returns the current block number.
+          *
+          * @ingroup system
+          *
+          * @return current block number.
+         */
+         uint32_t get_block_num() const;
+
          /**
           * Returns the transaction's publication time.
           *
@@ -1690,6 +1699,92 @@ namespace webassembly {
          */
          int32_t get_action(uint32_t type, uint32_t index, legacy_span<char> buffer) const;
 
+         /**
+          * Host function for addition on the elliptic curve alt_bn128
+          *
+          * @ingroup crypto
+          * @param op1 - a span containing the first operand G1 point.
+          * @param op2 - a span containing the second operand G1 point.
+          * @param[out] result - the result op1 + op2.
+          * @return 1 if there was an error 0 otherwise
+         */
+         int32_t alt_bn128_add(span<const char> op1, span<const char> op2, span<char> result) const;
+
+         /**
+          * Host function for scalar multiplication on the elliptic curve alt_bn128
+          *
+          * @ingroup crypto
+          * @param g1_point - a span containing G1 point.
+          * @param scalar   - a span containing the scalar.
+          * @param[out] result - g1 * scalar.
+          * @return 1 if there was an error 0 otherwise
+         */
+         int32_t alt_bn128_mul(span<const char> g1_point, span<const char> scalar, span<char> result) const;
+
+         /**
+          * Host function for optimal ate pairing check on the elliptic curve alt_bn128 
+          *
+          * @ingroup crypto
+          * @param g1_g2_pairs - a span containing pairs of G1,G2 points. (2 * 32 bytes) + (2 * 64 bytes)
+          * @param[out] result - true if pairing evaluates to 1, false otherwise
+          * @return 1 if there was an error 0 otherwise
+         */
+         int32_t alt_bn128_pair(span<const char> g1_g2_pairs, bool* result) const;
+
+         /**
+          * Big integer modular exponentiation
+          *
+          * <BASE> <EXPONENT> <MODULUS>
+          * returns an output (BASE**EXPONENT) % MODULUS as a byte array {{{{ with the same length as the modulus }}}}
+          *
+          * @ingroup crypto
+          * @param base        - a span containing BASE.
+          * @param exp         - a span containing EXPONENT.
+          * @param modulus     - a span containing MODULUS.
+          * @param[out] out    - the result (BASE**EXPONENT) % MODULUS
+          * @return              1 if there was an error 0 otherwise
+         */
+         int32_t mod_exp(span<const char> base, span<const char> exp, span<const char> modulus, span<char> out) const;
+
+         /**
+          * BLAKE2 compression function `F`
+          * https://eips.ethereum.org/EIPS/eip-152
+          * Precompiled contract which implements the compression function F used in the BLAKE2 cryptographic hashing algorithm.
+          *
+          * @ingroup crypto
+          * @param rounds        - the number of rounds - 32-bit unsigned big-endian word
+          * @param state         - a span containing the state vector - 8 unsigned 64-bit little-endian words
+          * @param message       - a span containing the message block vector - 16 unsigned 64-bit little-endian words
+          * @param t0_offset     - offset counters - unsigned 64-bit little-endian word
+          * @param t1_offset     - offset counters - unsigned 64-bit little-endian word
+          * @param final         - the final block indicator flag - 8-bit word
+          * @param[out] result   - the result
+          * @return                1 if there was an error 0 otherwise
+         */
+         int32_t blake2_f( uint32_t rounds, span<const char> state, span<const char> message, span<const char> t0_offset, span<const char> t1_offset, bool final, span<char> result) const;
+
+         /**
+          * Hashes data using SHA3.
+          *
+          * @ingroup crypto
+          * @param data - a span containing the data.
+          * @param[out] hash_val - the resulting digest.
+          * @param keccak - use keccak version.
+         */
+         void sha3( span<const char> data, span<char> hash_val, bool keccak) const;
+
+         /**
+          * Calculates the uncompressed public key used for a given signature on a given digest.
+          *
+          * @ingroup crypto
+          * @param signatue - signature.
+          * @param digest - digest of the message that was signed.
+          * @param[out] pub - output buffer for the public key result.
+          *
+          * @return 1 if there was an error 0 otherwise.
+         */
+         int32_t ecrecover( span<const char> signature, span<const char> digest, span<char> pub) const;
+
          // compiler builtins api
          void __ashlti3(legacy_ptr<int128_t>, uint64_t, uint64_t, uint32_t) const;
          void __ashrti3(legacy_ptr<int128_t>, uint64_t, uint64_t, uint32_t) const;

libraries/chain/protocol_feature_manager.cpp

@@ -26,6 +26,33 @@ Pre-activated protocol features must be activated in the next block.
             {},
             {time_point{}, false, true} // enabled without preactivation and ready to go at any time
          } )
+         (  builtin_protocol_feature_t::evm_precompiles, builtin_protocol_feature_spec{
+            "EVM_PRECOMPILES",
+            fc::variant("7fc04d1e925fd57bfe584b0146186560b8e73371af475978196698f2d26cf0a2").as<digest_type>(),
+            // SHA256 hash of the raw message below within the comment delimiters (do not modify message below).
+/*
+Builtin protocol feature: EVM_PRECOMPILES
+
+Adds new host functions to support the EVM runtime
+- Big integer modular exponentiation (mod_exp)
+- Add, multiply, and pairing check functions for the alt_bn128 elliptic curve. (alt_bn128_add, alt_bn128_mul, alt_bn128_pair)
+- BLAKE2b F compression function (blake2_f)
+- sha3 hash function (with Keccak256 support)
+- ecrecover (safe ECDSA uncompressed pubkey recover)
+*/
+            {}
+         } )
+         (  builtin_protocol_feature_t::get_block_num, builtin_protocol_feature_spec{
+            "GET_BLOCK_NUM",
+            fc::variant("e5d7992006e628a38c5e6c28dd55ff5e57ea682079bf41fef9b3cced0f46b491").as<digest_type>(),
+            // SHA256 hash of the raw message below within the comment delimiters (do not modify message below).
+/*
+Builtin protocol feature: GET_BLOCK_NUM
+
+Enables new `get_block_num` intrinsic which returns the current block number.
+*/
+            {}
+         } )
          (  builtin_protocol_feature_t::only_link_to_existing_permission, builtin_protocol_feature_spec{
             "ONLY_LINK_TO_EXISTING_PERMISSION",
             fc::variant("f3c3d91c4603cde2397268bfed4e662465293aab10cd9416db0d442b8cec2949").as<digest_type>(),