Remove initcode transactions

Author: gumb0

lib/evmone/execution_state.hpp

@@ -175,7 +175,6 @@ class ExecutionState
 
 private:
     evmc_tx_context m_tx = {};
-    std::optional<std::unordered_map<evmc::bytes32, bytes_view>> m_initcodes;
 
 public:
     /// Pointer to code analysis.

test/state/errors.hpp

@@ -23,9 +23,6 @@ enum ErrorCode : int
     GAS_LIMIT_REACHED,
     SENDER_NOT_EOA,
     INIT_CODE_SIZE_LIMIT_EXCEEDED,
-    INIT_CODE_EMPTY,
-    INIT_CODE_COUNT_LIMIT_EXCEEDED,
-    INIT_CODE_COUNT_ZERO,
     CREATE_BLOB_TX,
     EMPTY_BLOB_HASHES_LIST,
     INVALID_BLOB_HASH_VERSION,
@@ -68,12 +65,6 @@ inline const std::error_category& evmone_category() noexcept
                 return "sender not an eoa:";
             case INIT_CODE_SIZE_LIMIT_EXCEEDED:
                 return "max initcode size exceeded";
-            case INIT_CODE_EMPTY:
-                return "initcode empty";
-            case INIT_CODE_COUNT_LIMIT_EXCEEDED:
-                return "max initcode count exceeded";
-            case INIT_CODE_COUNT_ZERO:
-                return "initcode list empty";
             case CREATE_BLOB_TX:
                 return "blob transaction must not be a create transaction";
             case EMPTY_BLOB_HASHES_LIST:

test/state/host.cpp

@@ -449,8 +449,6 @@ evmc_tx_context Host::get_tx_context() const noexcept
         intx::be::store<uint256be>(m_block.blob_base_fee),
         m_tx.blob_hashes.data(),
         m_tx.blob_hashes.size(),
-        m_tx_initcodes.data(),
-        m_tx_initcodes.size(),
     };
 }
 

test/state/host.hpp

@@ -42,22 +42,12 @@ class Host : public evmc::Host
     const BlockInfo& m_block;
     const Transaction& m_tx;
     std::vector<Log> m_logs;
-    std::vector<evmc_tx_initcode> m_tx_initcodes;
 
 public:
     Host(evmc_revision rev, evmc::VM& vm, State& state, const BlockInfo& block,
         const Transaction& tx) noexcept
       : m_rev{rev}, m_vm{vm}, m_state{state}, m_block{block}, m_tx{tx}
-    {
-        if (tx.type == Transaction::Type::initcodes)
-        {
-            for (const auto& initcode : tx.initcodes)
-            {
-                const auto hash = keccak256({initcode.data(), initcode.size()});
-                m_tx_initcodes.push_back({hash, initcode.data(), initcode.size()});
-            }
-        }
-    }
+    {}
 
     [[nodiscard]] std::vector<Log>&& take_logs() noexcept { return std::move(m_logs); }
 

test/state/state.cpp

@@ -16,8 +16,6 @@ namespace evmone::state
 {
 namespace
 {
-constexpr auto MAX_INITCODE_COUNT = 256;
-
 inline constexpr int64_t num_words(size_t size_in_bytes) noexcept
 {
     return static_cast<int64_t>((size_in_bytes + 31) / 32);
@@ -44,14 +42,6 @@ int64_t compute_access_list_cost(const AccessList& access_list) noexcept
     return cost;
 }
 
-int64_t compute_initcode_list_cost(evmc_revision rev, std::span<const bytes> initcodes) noexcept
-{
-    int64_t cost = 0;
-    for (const auto& initcode : initcodes)
-        cost += compute_tx_data_cost(rev, initcode);
-    return cost;
-}
-
 int64_t compute_tx_intrinsic_cost(evmc_revision rev, const Transaction& tx) noexcept
 {
     static constexpr auto call_tx_cost = 21000;
@@ -62,7 +52,7 @@ int64_t compute_tx_intrinsic_cost(evmc_revision rev, const Transaction& tx) noex
         is_create && rev >= EVMC_SHANGHAI ? initcode_word_cost * num_words(tx.data.size()) : 0;
     const auto tx_cost = is_create && rev >= EVMC_HOMESTEAD ? create_tx_cost : call_tx_cost;
     return tx_cost + compute_tx_data_cost(rev, tx.data) + compute_access_list_cost(tx.access_list) +
-           compute_initcode_list_cost(rev, tx.initcodes) + initcode_cost;
+           initcode_cost;
 }
 
 evmc_message build_message(
@@ -283,28 +273,12 @@ std::variant<int64_t, std::error_code> validate_transaction(const Account& sende
             return make_error_code(BLOB_GAS_LIMIT_EXCEEDED);
         break;
 
-    case Transaction::Type::initcodes:
-        if (rev < EVMC_OSAKA)
-            return make_error_code(TX_TYPE_NOT_SUPPORTED);
-        if (tx.initcodes.size() > MAX_INITCODE_COUNT)
-            return make_error_code(INIT_CODE_COUNT_LIMIT_EXCEEDED);
-        if (tx.initcodes.empty())
-            return make_error_code(INIT_CODE_COUNT_ZERO);
-        if (std::any_of(tx.initcodes.begin(), tx.initcodes.end(),
-                [](const bytes& v) { return v.size() > MAX_INITCODE_SIZE; }))
-            return make_error_code(INIT_CODE_SIZE_LIMIT_EXCEEDED);
-        if (std::any_of(
-                tx.initcodes.begin(), tx.initcodes.end(), [](const bytes& v) { return v.empty(); }))
-            return make_error_code(INIT_CODE_EMPTY);
-        break;
-
     default:;
     }
 
     switch (tx.type)
     {
     case Transaction::Type::blob:
-    case Transaction::Type::initcodes:
     case Transaction::Type::eip1559:
         if (rev < EVMC_LONDON)
             return make_error_code(TX_TYPE_NOT_SUPPORTED);
@@ -620,12 +594,6 @@ std::variant<TransactionReceipt, std::error_code> transition(State& state, const
         return "SenderNotEOA";
     case INIT_CODE_SIZE_LIMIT_EXCEEDED:
         return "TR_InitCodeLimitExceeded";
-    case INIT_CODE_EMPTY:
-        return "TR_InitCodeEmpty";
-    case INIT_CODE_COUNT_LIMIT_EXCEEDED:
-        return "TR_InitCodeCountLimitExceeded";
-    case INIT_CODE_COUNT_ZERO:
-        return "TR_InitCodeCountZero";
     case CREATE_BLOB_TX:
         return "TR_BLOBCREATE";
     case EMPTY_BLOB_HASHES_LIST:

test/state/state.hpp

@@ -196,9 +196,6 @@ struct Transaction
         /// The typed blob transaction (with array of blob hashes).
         /// Introduced by EIP-4844 https://eips.ethereum.org/EIPS/eip-4844.
         blob = 3,
-
-        /// The typed transaction with initcode list.
-        initcodes = 4,
     };
 
     /// Returns amount of blob gas used by this transaction
@@ -224,7 +221,6 @@ struct Transaction
     intx::uint256 r;
     intx::uint256 s;
     uint8_t v = 0;
-    std::vector<bytes> initcodes;
 };
 
 struct Log

test/statetest/statetest_loader.cpp

@@ -331,12 +331,6 @@ static void from_json_tx_common(const json::json& j, state::Transaction& o)
         for (const auto& hash : *it)
             o.blob_hashes.push_back(from_json<bytes32>(hash));
     }
-    else if (const auto it_initcodes = j.find("initcodes"); it_initcodes != j.end())
-    {
-        o.type = state::Transaction::Type::initcodes;
-        for (const auto& initcode : *it_initcodes)
-            o.initcodes.push_back(from_json<bytes>(initcode));
-    }
 }
 
 template <>

test/unittests/state_transition.cpp

@@ -200,13 +200,6 @@ void state_transition::export_state_test(
         jtx["maxPriorityFeePerGas"] = hex0x(tx.max_priority_gas_price);
     }
 
-    if (tx.type == Transaction::Type::initcodes)
-    {
-        auto& jinitcodes = jtx["initcodes"] = json::json::array();
-        for (const auto& initcode : tx.initcodes)
-            jinitcodes.emplace_back(hex0x(initcode));
-    }
-
     jtx["data"][0] = hex0x(tx.data);
     jtx["gasLimit"][0] = hex0x(tx.gas_limit);
     jtx["value"][0] = hex0x(tx.value);

test/unittests/state_transition_eof_create_test.cpp

@@ -1198,20 +1198,3 @@ TEST_F(state_transition, creation_tx_invalid_eof_version)
     expect.status = EVMC_FAILURE;
     expect.gas_used = 53516;
 }
-
-TEST_F(state_transition, initcode_transaction_before_prague)
-{
-    rev = EVMC_CANCUN;
-
-    const auto deploy_container = eof_bytecode(bytecode(OP_INVALID));
-
-    const auto init_code = returncontract(0, 0, 0);
-    const bytecode init_container = eof_bytecode(init_code, 2).container(deploy_container);
-
-    tx.type = Transaction::Type::initcodes;
-    tx.initcodes.assign(257, init_container);
-
-    tx.to = To;
-
-    expect.tx_error = TX_TYPE_NOT_SUPPORTED;
-}

test/unittests/state_tx_test.cpp

@@ -31,7 +31,6 @@ TEST(state_tx, validate_nonce)
         .nonce = 1,
         .r = 0,
         .s = 0,
-        .initcodes = {},
     };
 
     ASSERT_FALSE(holds_alternative<std::error_code>(
@@ -68,7 +67,6 @@ TEST(state_tx, validate_sender)
         .nonce = 0,
         .r = 0,
         .s = 0,
-        .initcodes = {},
     };
 
     ASSERT_FALSE(holds_alternative<std::error_code>(
@@ -178,7 +176,6 @@ TEST(state_tx, validate_data)
         .nonce = 1,
         .r = 0,
         .s = 0,
-        .initcodes = {},
     };
 
     ASSERT_FALSE(holds_alternative<std::error_code>(