Merge pull request #692 from eosnetworkfoundation/elmato/use-gas-para…

…meters

Use active gas parameters in ExecutionState

include/evm_runtime/config_wrapper.hpp

@@ -45,6 +45,7 @@ struct config_wrapper {
     void update_consensus_parameters(eosio::asset ram_price_mb, uint64_t minimum_gas_price);
     void update_consensus_parameters2(std::optional<uint64_t> gas_txnewaccount, std::optional<uint64_t> gas_newaccount, std::optional<uint64_t> gas_txcreate, std::optional<uint64_t> gas_codedeposit, std::optional<uint64_t> gas_sset, std::optional<uint64_t> minimum_gas_price);
 
+    const consensus_parameter_data_type& get_consensus_param();
     std::pair<const consensus_parameter_data_type &, bool> get_consensus_param_and_maybe_promote();
 
 private:

src/CMakeLists.txt

@@ -92,5 +92,5 @@ target_compile_options(evm_runtime PUBLIC --no-missing-ricardian-clause)
 if (WITH_LARGE_STACK)
     target_link_options(evm_runtime PUBLIC --stack-size=50000000)
 else()
-    target_link_options(evm_runtime PUBLIC --stack-size=36000)
+    target_link_options(evm_runtime PUBLIC --stack-size=35248)
 endif()

src/actions.cpp

@@ -234,7 +234,9 @@ Receipt evm_contract::execute_tx(const runtime_config& rc, eosio::name miner, Bl
     }
 
     ValidationResult r = silkworm::protocol::pre_validate_transaction(tx, ep.evm().revision(), ep.evm().config().chain_id,
-                                                             ep.evm().block().header.base_fee_per_gas, ep.evm().block().header.data_gas_price());
+                            ep.evm().block().header.base_fee_per_gas, ep.evm().block().header.data_gas_price(),
+                            ep.evm().get_eos_evm_version(), ep.evm().get_gas_params());
+
     check_result( r, tx, "pre_validate_transaction error" );
     r = silkworm::protocol::validate_transaction(tx, ep.state(), ep.available_gas());
     check_result( r, tx, "validate_transaction error" );
@@ -333,7 +335,19 @@ void evm_contract::exec(const exec_input& input, const std::optional<exec_callba
     evm_runtime::state state{get_self(), get_self(), true};
     IntraBlockState ibstate{state};
 
-    EVM evm{block, ibstate, *found_chain_config.value().second};
+    const auto& consensus_param = _config->get_consensus_param();
+
+    auto gas_params = std::visit([&](const auto &v) {
+        return evmone::gas_parameters(
+            v.gas_parameter.gas_txnewaccount,
+            v.gas_parameter.gas_newaccount,
+            v.gas_parameter.gas_txcreate,
+            v.gas_parameter.gas_codedeposit,
+            v.gas_parameter.gas_sset
+        );
+    }, consensus_param);
+
+    EVM evm{block, ibstate, *found_chain_config.value().second, gas_params};
 
     Transaction txn;
     txn.to    = to_address(input.to);
@@ -440,7 +454,18 @@ void evm_contract::process_tx(const runtime_config& rc, eosio::name miner, const
     silkworm::protocol::TrustRuleSet engine{*found_chain_config->second};
 
     evm_runtime::state state{get_self(), get_self(), false, false};
-    silkworm::ExecutionProcessor ep{block, engine, state, *found_chain_config->second};
+
+    auto gas_params = std::visit([&](const auto &v) {
+        return evmone::gas_parameters(
+            v.gas_parameter.gas_txnewaccount,
+            v.gas_parameter.gas_newaccount,
+            v.gas_parameter.gas_txcreate,
+            v.gas_parameter.gas_codedeposit,
+            v.gas_parameter.gas_sset
+        );
+    }, gas_param_pair.first);
+
+    silkworm::ExecutionProcessor ep{block, engine, state, *found_chain_config->second, gas_params};
 
     check(tx.max_priority_fee_per_gas == tx.max_fee_per_gas, "max_priority_fee_per_gas must be equal to max_fee_per_gas");
     check(tx.max_fee_per_gas >= _config->get_gas_price(), "gas price is too low");

src/config_wrapper.cpp

@@ -217,6 +217,12 @@ void config_wrapper::update_consensus_parameters2(std::optional<uint64_t> gas_tx
     set_dirty();
 }
 
+const consensus_parameter_data_type& config_wrapper::get_consensus_param() {
+    // should not happen
+    eosio::check(_cached_config.consensus_parameter.has_value(), "consensus_parameter not exist");
+    return _cached_config.consensus_parameter->get_consensus_param(_cached_config.genesis_time, get_current_time());
+}
+
 std::pair<const consensus_parameter_data_type &, bool> config_wrapper::get_consensus_param_and_maybe_promote() {
 
     // should not happen

src/test_actions.cpp

@@ -19,7 +19,7 @@ using namespace silkworm;
 
     evm_runtime::test::engine engine{evm_runtime::test::kTestNetwork};
     evm_runtime::state state{get_self(), get_self()};
-    silkworm::ExecutionProcessor ep{block, engine, state, evm_runtime::test::kTestNetwork};
+    silkworm::ExecutionProcessor ep{block, engine, state, evm_runtime::test::kTestNetwork, {}};
 
     if(orlptx) {
         Transaction tx;

tests/basic_evm_tester.cpp

@@ -672,6 +672,24 @@ std::optional<account_object> basic_evm_tester::find_account_by_id(uint64_t id)
    return convert_to_account_object(row);
 }
 
+intx::uint128 basic_evm_tester::tx_data_cost(const silkworm::Transaction& txn) const {
+    intx::uint128 gas{0};
+
+    const intx::uint128 data_len{txn.data.length()};
+    if (data_len == 0) {
+        return gas;
+    }
+
+    const intx::uint128 non_zero_bytes{as_range::count_if(txn.data, [](uint8_t c) { return c != 0; })};
+    const intx::uint128 nonZeroGas{silkworm::protocol::fee::kGTxDataNonZeroIstanbul};
+    gas += non_zero_bytes * nonZeroGas;
+    const intx::uint128 zero_bytes{data_len - non_zero_bytes};
+    gas += zero_bytes * silkworm::protocol::fee::kGTxDataZero;
+
+    return gas;
+}
+
+
 bool basic_evm_tester::scan_account_storage(uint64_t account_id, std::function<bool(storage_slot)> visitor) const
 {
    static constexpr eosio::chain::name storage_table_name = "storage"_n;

tests/basic_evm_tester.hpp

@@ -13,6 +13,7 @@
 #include <silkworm/core/rlp/encode.hpp>
 #include <silkworm/core/common/util.hpp>
 #include <silkworm/core/execution/address.hpp>
+#include <silkworm/core/protocol/param.hpp>
 
 #include <secp256k1.h>
 
@@ -467,6 +468,8 @@ class basic_evm_tester : public evm_validating_tester
    bool scan_gcstore(std::function<bool(gcstore)> visitor) const;
    bool scan_account_code(std::function<bool(account_code)> visitor) const;
    void scan_balances(std::function<bool(evm_test::vault_balance_row)> visitor) const;
+
+   intx::uint128 tx_data_cost(const silkworm::Transaction& txn) const;
 };
 
 inline constexpr intx::uint256 operator"" _wei(const char* s) { return intx::from_string<intx::uint256>(s); }