Merge pull request #779 from eosnetworkfoundation/elmato/add-gas-para…

…meters-scaling-tests

Add gas parameters scaling tests

.github/workflows/contract.yml

@@ -70,7 +70,7 @@ jobs:
           owner: AntelopeIO
           repo: spring
           file: 'antelope-spring-dev.*ubuntu22\.04_amd64.deb'
-          target: 'main'
+          target: '1'
           prereleases: false
           artifact-name: antelope-spring-dev-ubuntu22-amd64
           container-package: antelope-spring-experimental-binaries

include/evm_runtime/evm_contract.hpp

@@ -138,7 +138,7 @@ class [[eosio::contract]] evm_contract : public contract
    void assert_inited();
    void assert_unfrozen();
 
-   silkworm::Receipt execute_tx(const runtime_config& rc, eosio::name miner, silkworm::Block& block, const transaction& tx, silkworm::ExecutionProcessor& ep);
+   silkworm::Receipt execute_tx(const runtime_config& rc, eosio::name miner, silkworm::Block& block, const transaction& tx, silkworm::ExecutionProcessor& ep, const evmone::gas_parameters& gas_params);
    void process_filtered_messages(const std::vector<silkworm::FilteredMessage>& filtered_messages);
 
    uint64_t get_and_increment_nonce(const name owner);

include/evm_runtime/tables.hpp

@@ -249,6 +249,10 @@ struct [[eosio::table]] [[eosio::contract("evm_contract")]] config2
 struct gas_prices_type {
     uint64_t overhead_price{0};
     uint64_t storage_price{0};
+
+    uint64_t get_base_price()const {
+        return std::max(overhead_price, storage_price);
+    }
 };
 
 using evm_version_type = uint64_t;

src/CMakeLists.txt

@@ -71,6 +71,7 @@ list(APPEND SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/../silkworm/silkworm/core/crypto/ecdsa.c
     ${CMAKE_CURRENT_SOURCE_DIR}/../silkworm/silkworm/core/crypto/secp256k1n.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/../silkworm/silkworm/core/chain/config.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/../silkworm/eosevm/refund_v3.cpp
 )
 
 add_contract( evm_contract evm_runtime ${SOURCES})

src/actions.cpp

@@ -180,7 +180,7 @@ void check_result( ValidationResult r, const Transaction& txn, const char* desc
     eosio::check( false, std::move(err_msg));
 }
 
-Receipt evm_contract::execute_tx(const runtime_config& rc, eosio::name miner, Block& block, const transaction& txn, silkworm::ExecutionProcessor& ep) {
+Receipt evm_contract::execute_tx(const runtime_config& rc, eosio::name miner, Block& block, const transaction& txn, silkworm::ExecutionProcessor& ep, const evmone::gas_parameters& gas_params) {
     const auto& tx = txn.get_tx();
     balances balance_table(get_self(), get_self().value);
 
@@ -241,20 +241,23 @@ 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().get_eos_evm_version(), ep.evm().get_gas_params());
+                            ep.evm().get_eos_evm_version(), 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" );
 
     Receipt receipt;
-    ep.execute_transaction(tx, receipt);
+    const auto res = ep.execute_transaction(tx, receipt, gas_params);
 
     // Calculate the miner portion of the actual gas fee (if necessary):
     std::optional<intx::uint256> gas_fee_miner_portion;
     if (miner) {
+        auto version = _config->get_evm_version();
         uint64_t tx_gas_used = receipt.cumulative_gas_used; // Only transaction in the "block" so cumulative_gas_used is the tx gas_used.
-        if(_config->get_evm_version() >= 1) {
+        if(version >= 3) {
+            gas_fee_miner_portion.emplace(res.inclusion_fee);
+        } else if(version >= 1) {
             eosio::check(ep.evm().block().header.base_fee_per_gas.has_value(), "no base fee");
             intx::uint512 gas_fee = intx::uint256(tx_gas_used) * tx.priority_fee_per_gas(ep.evm().block().header.base_fee_per_gas.value());
             check(gas_fee < std::numeric_limits<intx::uint256>::max(), "too much gas");
@@ -344,12 +347,18 @@ void evm_contract::exec(const exec_input& input, const std::optional<exec_callba
     eosevm::block_mapping bm(_config->get_genesis_time().sec_since_epoch());
 
     Block block;
-
     auto evm_version = _config->get_evm_version();
+
     std::optional<uint64_t> base_fee_per_gas;
+    auto gas_prices = _config->get_gas_prices();
     if (evm_version >= 1) {
-        base_fee_per_gas = _config->get_gas_price();
+        if( evm_version >= 3) {
+            base_fee_per_gas = gas_prices.get_base_price();
+        } else {
+            base_fee_per_gas = _config->get_gas_price();
+        }
     }
+
     eosevm::prepare_block_header(block.header, bm, get_self().value,
         bm.timestamp_to_evm_block_num(eosio::current_time_point().time_since_epoch().count()), evm_version, base_fee_per_gas);
 
@@ -368,15 +377,15 @@ void evm_contract::exec(const exec_input& input, const std::optional<exec_callba
         );
     }, consensus_param);
 
-    EVM evm{block, ibstate, *found_chain_config.value().second, gas_params};
+    EVM evm{block, ibstate, *found_chain_config.value().second};
 
     Transaction txn;
     txn.to    = to_address(input.to);
     txn.data  = Bytes{input.data.begin(), input.data.end()};
     txn.from  = input.from.has_value()  ? to_address(input.from.value()) : evmc::address{};
     txn.value = input.value.has_value() ? to_uint256(input.value.value()) : 0;
 
-    const CallResult vm_res{evm.execute(txn, 0x7ffffffffff)};
+    const CallResult vm_res{evm.execute(txn, 0x7ffffffffff, gas_params)};
 
     exec_output output{
         .status  = int32_t(vm_res.status),
@@ -475,7 +484,7 @@ void evm_contract::process_tx(const runtime_config& rc, eosio::name miner, const
     auto gas_prices = _config->get_gas_prices();
     if (current_version >= 1) {
         if( current_version >= 3) {
-            //base_fee_per_gas = f(gas_prices, min_inclusion_price)
+            base_fee_per_gas = gas_prices.get_base_price();
         } else {
             base_fee_per_gas = _config->get_gas_price();
         }
@@ -506,7 +515,8 @@ void evm_contract::process_tx(const runtime_config& rc, eosio::name miner, const
         check(tx.max_fee_per_gas >= _config->get_gas_price(), "gas price is too low");
     }
 
-    silkworm::ExecutionProcessor ep{block, engine, state, *found_chain_config->second, gas_params};
+    auto gp = silkworm::gas_prices_t{gas_prices.overhead_price, gas_prices.storage_price};
+    silkworm::ExecutionProcessor ep{block, engine, state, *found_chain_config->second, gp};
 
     // Filter EVM messages (with data) that are sent to the reserved address
     // corresponding to the EOS account holding the contract (self)
@@ -515,7 +525,7 @@ void evm_contract::process_tx(const runtime_config& rc, eosio::name miner, const
         return message.recipient == me && message.input_size > 0;
     });
 
-    auto receipt = execute_tx(rc, miner, block, txn, ep);
+    auto receipt = execute_tx(rc, miner, block, txn, ep, gas_params);
 
     process_filtered_messages(ep.state().filtered_messages());
 

src/config_wrapper.cpp

@@ -300,7 +300,7 @@ void config_wrapper::update_consensus_parameters(eosio::asset ram_price_mb, uint
                              account_bytes * gas_per_byte, /* gas_newaccount */
                              contract_fixed_bytes * gas_per_byte, /*gas_txcreate*/
                              gas_per_byte,/*gas_codedeposit*/
-                             gas_sset_min + storage_slot_bytes * gas_per_byte /*gas_sset*/
+                             (get_evm_version() < 3 ? gas_sset_min : 0) + storage_slot_bytes * gas_per_byte /*gas_sset*/
     );
 
     if(get_evm_version() >= 1) {
@@ -324,7 +324,7 @@ void config_wrapper::update_consensus_parameters2(std::optional<uint64_t> gas_tx
             if (gas_txcreate.has_value()) v.gas_parameter.gas_txcreate = *gas_txcreate;
             if (gas_codedeposit.has_value()) v.gas_parameter.gas_codedeposit = *gas_codedeposit;
             if (gas_sset.has_value()) {
-                eosio::check(*gas_sset >= gas_sset_min, "gas_sset too small");
+                eosio::check(get_evm_version() >= 3 || *gas_sset >= gas_sset_min, "gas_sset too small");
                 v.gas_parameter.gas_sset = *gas_sset;
             }
         }, p);

src/test_actions.cpp

@@ -32,7 +32,7 @@ using namespace silkworm;
             .enforce_chain_id = false,
             .allow_non_self_miner = true
         };
-        execute_tx(rc, eosio::name{}, block, transaction{std::move(tx)}, ep);
+        execute_tx(rc, eosio::name{}, block, transaction{std::move(tx)}, ep, {});
     }
     engine.finalize(ep.state(), ep.evm().block());
     ep.state().write_to_db(ep.evm().block().header.number);

tests/CMakeLists.txt

@@ -33,6 +33,7 @@ add_eosio_test_executable( unit_test
     ${CMAKE_SOURCE_DIR}/mapping_tests.cpp
     ${CMAKE_SOURCE_DIR}/gas_fee_tests.cpp
     ${CMAKE_SOURCE_DIR}/gas_param_tests.cpp
+    ${CMAKE_SOURCE_DIR}/gas_prices_tests.cpp
     ${CMAKE_SOURCE_DIR}/blockhash_tests.cpp
     ${CMAKE_SOURCE_DIR}/exec_tests.cpp
     ${CMAKE_SOURCE_DIR}/call_tests.cpp

tests/basic_evm_tester.hpp

@@ -344,9 +344,9 @@ class evm_validating_tester : public testing::base_tester {
    signed_block_ptr produce_block( fc::microseconds skip_time = fc::milliseconds(config::block_interval_ms), bool no_throw = false )override {
       auto produce_block_result = _produce_block(skip_time, false, no_throw);
       auto sb = produce_block_result.block;
-      auto [best_head, obh] = validating_node->accept_block( sb->calculate_id(), sb );
-      EOS_ASSERT(obh, unlinkable_block_exception, "block did not link ${b}", ("b", sb->calculate_id()));
-      validating_node->apply_blocks( {}, trx_meta_cache_lookup{} );
+      auto bhf = validating_node->create_block_handle_future( sb->calculate_id(), sb );
+      struct controller::block_report br; 
+      validating_node->push_block(br, bhf.get(), forked_callback_t{}, trx_meta_cache_lookup{} );
 
       return sb;
    }
@@ -362,17 +362,17 @@ class evm_validating_tester : public testing::base_tester {
    }
 
    void validate_push_block(const signed_block_ptr& sb) {
-      auto [best_head, obh] = validating_node->accept_block( sb->calculate_id(), sb );
-      EOS_ASSERT(obh, unlinkable_block_exception, "block did not link ${b}", ("b", sb->calculate_id()));
-      validating_node->apply_blocks( {}, trx_meta_cache_lookup{} );
+      auto bhf = validating_node->create_block_handle_future( sb->calculate_id(), sb );
+      struct controller::block_report br;
+      validating_node->push_block(br, bhf.get(), forked_callback_t{}, trx_meta_cache_lookup{} );
    }
 
    signed_block_ptr produce_empty_block( fc::microseconds skip_time = fc::milliseconds(config::block_interval_ms) )override {
       unapplied_transactions.add_aborted( control->abort_block() );
       auto sb = _produce_block(skip_time, true);
-      auto [best_head, obh] = validating_node->accept_block( sb->calculate_id(), sb );
-      EOS_ASSERT(obh, unlinkable_block_exception, "block did not link ${b}", ("b", sb->calculate_id()));
-      validating_node->apply_blocks( {}, trx_meta_cache_lookup{} );
+      auto bhf = validating_node->create_block_handle_future( sb->calculate_id(), sb );
+      struct controller::block_report br;
+      validating_node->push_block(br, bhf.get(), forked_callback_t{}, trx_meta_cache_lookup{} );
 
       return sb;
    }