Remove TXCREATE (#992)

gumb0 · web-flow · commit a79218c780e8 · 2024-09-10T14:46:53.000+02:00
`TXCREATE` and initcode transactions are not scheduled for any upgrade
currently, and it doesn't make sense to maintain this code at the
moment.
diff --git a/lib/evmone/advanced_instructions.cpp b/lib/evmone/advanced_instructions.cpp
@@ -310,7 +310,6 @@ constexpr std::array<instruction_exec_fn, 256> instruction_implementations = [](
     table[OP_SWAPN] = op_undefined;
     table[OP_EXCHANGE] = op_undefined;
     table[OP_EOFCREATE] = op_undefined;
-    table[OP_TXCREATE] = op_undefined;
     table[OP_RETURNCONTRACT] = op_undefined;
 
     return table;
diff --git a/lib/evmone/eof.hpp b/lib/evmone/eof.hpp
@@ -149,7 +149,7 @@ enum class EOFValidationError
 
 enum class ContainerKind : uint8_t
 {
-    /// Container that uses RETURNCONTRACT. Can be used by EOFCREATE/TXCREATE/Creation transaction.
+    /// Container that uses RETURNCONTRACT. Can be used by EOFCREATE/Creation transaction.
     initcode,
     /// Container that uses STOP/RETURN. Can be returned by RETURNCONTRACT.
     runtime,
diff --git a/lib/evmone/execution_state.hpp b/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.
@@ -232,25 +231,5 @@ class ExecutionState
             m_tx = host.get_tx_context();
         return m_tx;
     }
-
-    /// Get initcode by its hash from transaction initcodes.
-    ///
-    /// Returns empty bytes_view if no such initcode was found.
-    [[nodiscard]] bytes_view get_tx_initcode_by_hash(const evmc_bytes32& hash) noexcept
-    {
-        if (!m_initcodes.has_value())
-        {
-            m_initcodes.emplace();
-            const auto& tx_context = get_tx_context();
-            for (size_t i = 0; i < tx_context.initcodes_count; ++i)
-            {
-                const auto& initcode = tx_context.initcodes[i];
-                m_initcodes->insert({initcode.hash, {initcode.code, initcode.code_size}});
-            }
-        }
-
-        const auto it = m_initcodes->find(hash);
-        return it != m_initcodes->end() ? it->second : bytes_view{};
-    }
 };
 }  // namespace evmone
diff --git a/lib/evmone/instructions.hpp b/lib/evmone/instructions.hpp
@@ -1092,11 +1092,8 @@ Result create_impl(StackTop stack, int64_t gas_left, ExecutionState& state) noex
 inline constexpr auto create = create_impl<OP_CREATE>;
 inline constexpr auto create2 = create_impl<OP_CREATE2>;
 
-template <Opcode Op>
-Result create_eof_impl(
+Result eofcreate(
     StackTop stack, int64_t gas_left, ExecutionState& state, code_iterator& pos) noexcept;
-inline constexpr auto eofcreate = create_eof_impl<OP_EOFCREATE>;
-inline constexpr auto txcreate = create_eof_impl<OP_TXCREATE>;
 
 inline code_iterator callf(StackTop stack, ExecutionState& state, code_iterator pos) noexcept
 {
diff --git a/lib/evmone/instructions_calls.cpp b/lib/evmone/instructions_calls.cpp
@@ -36,7 +36,6 @@ consteval evmc_call_kind to_call_kind(Opcode op) noexcept
     case OP_CREATE2:
         return EVMC_CREATE2;
     case OP_EOFCREATE:
-    case OP_TXCREATE:
         return EVMC_EOFCREATE;
     default:
         intx::unreachable();
@@ -332,17 +331,12 @@ Result create_impl(StackTop stack, int64_t gas_left, ExecutionState& state) noex
     return {EVMC_SUCCESS, gas_left};
 }
 
-template <Opcode Op>
-Result create_eof_impl(
+Result eofcreate(
     StackTop stack, int64_t gas_left, ExecutionState& state, code_iterator& pos) noexcept
 {
-    static_assert(Op == OP_EOFCREATE || Op == OP_TXCREATE);
-
     if (state.in_static_mode())
         return {EVMC_STATIC_MODE_VIOLATION, gas_left};
 
-    const auto initcode_hash =
-        (Op == OP_TXCREATE) ? intx::be::store<evmc::bytes32>(stack.pop()) : evmc::bytes32{};
     const auto endowment = stack.pop();
     const auto salt = stack.pop();
     const auto input_offset_u256 = stack.pop();
@@ -354,32 +348,11 @@ Result create_eof_impl(
     if (!check_memory(gas_left, state.memory, input_offset_u256, input_size_u256))
         return {EVMC_OUT_OF_GAS, gas_left};
 
-    bytes_view initcontainer;
-    if constexpr (Op == OP_EOFCREATE)
-    {
-        const auto initcontainer_index = pos[1];
-        pos += 2;
-        const auto& container = state.original_code;
-        const auto& eof_header = state.analysis.baseline->eof_header;
-        initcontainer = eof_header.get_container(container, initcontainer_index);
-    }
-    else
-    {
-        pos += 1;
-
-        initcontainer = state.get_tx_initcode_by_hash(initcode_hash);
-        // In case initcode was not found, empty bytes_view was returned.
-        // Transaction initcodes are not allowed to be empty.
-        if (initcontainer.empty())
-            return {EVMC_SUCCESS, gas_left};  // "Light" failure
-
-        // Charge for initcode validation.
-        constexpr auto initcode_word_cost_validation = 2;
-        const auto initcode_cost_validation =
-            num_words(initcontainer.size()) * initcode_word_cost_validation;
-        if ((gas_left -= initcode_cost_validation) < 0)
-            return {EVMC_OUT_OF_GAS, gas_left};
-    }
+    const auto initcontainer_index = pos[1];
+    pos += 2;
+    const auto& container = state.original_code;
+    const auto& eof_header = state.analysis.baseline->eof_header;
+    const auto initcontainer = eof_header.get_container(container, initcontainer_index);
 
     // Charge for initcode hashing.
     constexpr auto initcode_word_cost_hashing = 6;
@@ -397,14 +370,7 @@ Result create_eof_impl(
         intx::be::load<uint256>(state.host.get_balance(state.msg->recipient)) < endowment)
         return {EVMC_SUCCESS, gas_left};  // "Light" failure.
 
-    if constexpr (Op == OP_TXCREATE)
-    {
-        const auto error_subcont = validate_eof(state.rev, ContainerKind::initcode, initcontainer);
-        if (error_subcont != EOFValidationError::success)
-            return {EVMC_SUCCESS, gas_left};  // "Light" failure.
-    }
-
-    evmc_message msg{.kind = to_call_kind(Op)};
+    evmc_message msg{.kind = EVMC_EOFCREATE};
     msg.gas = gas_left - gas_left / 64;
     if (input_size > 0)
     {
@@ -436,8 +402,4 @@ template Result create_impl<OP_CREATE>(
     StackTop stack, int64_t gas_left, ExecutionState& state) noexcept;
 template Result create_impl<OP_CREATE2>(
     StackTop stack, int64_t gas_left, ExecutionState& state) noexcept;
-template Result create_eof_impl<OP_EOFCREATE>(
-    StackTop stack, int64_t gas_left, ExecutionState& state, code_iterator& pos) noexcept;
-template Result create_eof_impl<OP_TXCREATE>(
-    StackTop stack, int64_t gas_left, ExecutionState& state, code_iterator& pos) noexcept;
 }  // namespace evmone::instr::core
diff --git a/lib/evmone/instructions_opcodes.hpp b/lib/evmone/instructions_opcodes.hpp
@@ -175,7 +175,6 @@ enum Opcode : uint8_t
     OP_EXCHANGE = 0xe8,
 
     OP_EOFCREATE = 0xec,
-    OP_TXCREATE = 0xed,
     OP_RETURNCONTRACT = 0xee,
 
     OP_CREATE = 0xf0,
diff --git a/lib/evmone/instructions_traits.hpp b/lib/evmone/instructions_traits.hpp
@@ -192,7 +192,6 @@ constexpr inline GasCostTable gas_costs = []() noexcept {
     table[EVMC_PRAGUE][OP_RETURNCONTRACT] = 0;
 
     table[EVMC_OSAKA] = table[EVMC_PRAGUE];
-    table[EVMC_OSAKA][OP_TXCREATE] = 32000;
 
     return table;
 }();
@@ -421,7 +420,6 @@ constexpr inline std::array<Traits, 256> traits = []() noexcept {
     table[OP_CREATE2] = {"CREATE2", 0, false, 4, -3, EVMC_CONSTANTINOPLE};
     table[OP_RETURNDATALOAD] = {"RETURNDATALOAD", 0, false, 1, 0, {}, REV_EOF1};
     table[OP_EOFCREATE] = {"EOFCREATE", 1, false, 4, -3, {}, REV_EOF1};
-    table[OP_TXCREATE] = {"TXCREATE", 0, false, 5, -4, {}, EVMC_OSAKA};
     table[OP_RETURNCONTRACT] = {"RETURNCONTRACT", 1, true, 2, -2, {}, REV_EOF1};
     table[OP_EXTCALL] = {"EXTCALL", 0, false, 4, -3, {}, REV_EOF1};
     table[OP_EXTDELEGATECALL] = {"EXTDELEGATECALL", 0, false, 3, -2, {}, REV_EOF1};
diff --git a/lib/evmone/instructions_xmacro.hpp b/lib/evmone/instructions_xmacro.hpp
@@ -283,7 +283,7 @@
     ON_OPCODE_UNDEFINED(0xea)                                 \
     ON_OPCODE_UNDEFINED(0xeb)                                 \
     ON_OPCODE_IDENTIFIER(OP_EOFCREATE, eofcreate)             \
-    ON_OPCODE_IDENTIFIER(OP_TXCREATE, txcreate)               \
+    ON_OPCODE_UNDEFINED(0xed)                                 \
     ON_OPCODE_IDENTIFIER(OP_RETURNCONTRACT, returncontract)   \
     ON_OPCODE_UNDEFINED(0xef)                                 \
                                                               \
diff --git a/test/state/errors.hpp b/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:
diff --git a/test/state/host.cpp b/test/state/host.cpp
@@ -258,7 +258,7 @@ std::optional<evmc_message> Host::prepare_message(evmc_message msg) noexcept
 
                     msg.recipient = compute_create_address(msg.sender, sender_nonce);
                 }
-                // EOFCREATE or TXCREATE
+                // EOFCREATE
                 else
                 {
                     const bytes_view initcontainer{msg.code, msg.code_size};
@@ -345,7 +345,7 @@ evmc::Result Host::create(const evmc_message& msg) noexcept
     {
         if (m_rev >= EVMC_PRAGUE)
         {
-            // Only EOFCREATE/TXCREATE/EOF-creation-tx is allowed to deploy code starting with EF.
+            // Only EOFCREATE/EOF-creation-tx is allowed to deploy code starting with EF.
             // It must be valid EOF, which was validated before execution.
             if (msg.kind != EVMC_EOFCREATE)
                 return evmc::Result{EVMC_CONTRACT_VALIDATION_FAILURE};
@@ -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(),
     };
 }
 
diff --git a/test/state/host.hpp b/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); }
 
diff --git a/test/state/state.cpp b/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:
diff --git a/test/state/state.hpp b/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
diff --git a/test/statetest/statetest_loader.cpp b/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 <>
diff --git a/test/unittests/eof_validation_test.cpp b/test/unittests/eof_validation_test.cpp
@@ -1223,7 +1223,6 @@ TEST_F(eof_validation, max_nested_containers_eofcreate_returncontract)
 // | ---------------------------- | ------ | ------ | ------ | -------------- |
 // | top-level initcode           | -      | -      | +      | +              |
 // | EOFCREATE                    | -      | -      | +      | +              |
-// | TXCREATE                     | -      | -      | +      | +              |
 // | top-level runtime            | +      | +      | +      | -              |
 // | RETURNCONTRACT               | +      | +      | +      | -              |
 // | EOFCREATE and RETURNCONTRACT | -      | -      | +      | -              |
diff --git a/test/unittests/instructions_test.cpp b/test/unittests/instructions_test.cpp
@@ -137,7 +137,6 @@ constexpr bool instruction_only_in_evmone(evmc_revision rev, Opcode op) noexcept
     case OP_EXTDELEGATECALL:
     case OP_EXTSTATICCALL:
     case OP_EOFCREATE:
-    case OP_TXCREATE:
     case OP_RETURNCONTRACT:
         return true;
     default:
diff --git a/test/unittests/state_transition.cpp b/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);
diff --git a/test/unittests/state_transition_eof_create_test.cpp b/test/unittests/state_transition_eof_create_test.cpp
diff --git a/test/unittests/state_tx_test.cpp b/test/unittests/state_tx_test.cpp
diff --git a/test/utils/bytecode.hpp b/test/utils/bytecode.hpp

Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ enum class EOFValidationError`
`149`	`149`
`150`	`150`	`enum class ContainerKind : uint8_t`
`151`	`151`	`{`
`152`		`- /// Container that uses RETURNCONTRACT. Can be used by EOFCREATE/TXCREATE/Creation transaction.`
	`152`	`+ /// Container that uses RETURNCONTRACT. Can be used by EOFCREATE/Creation transaction.`
`153`	`153`	`initcode,`
`154`	`154`	`/// Container that uses STOP/RETURN. Can be returned by RETURNCONTRACT.`
`155`	`155`	`runtime,`
Original file line number	Diff line number	Diff line change
`@@ -283,7 +283,7 @@`
`283`	`283`	`ON_OPCODE_UNDEFINED(0xea) \`
`284`	`284`	`ON_OPCODE_UNDEFINED(0xeb) \`
`285`	`285`	`ON_OPCODE_IDENTIFIER(OP_EOFCREATE, eofcreate) \`
`286`		`- ON_OPCODE_IDENTIFIER(OP_TXCREATE, txcreate) \`
	`286`	`+ ON_OPCODE_UNDEFINED(0xed) \`
`287`	`287`	`ON_OPCODE_IDENTIFIER(OP_RETURNCONTRACT, returncontract) \`
`288`	`288`	`ON_OPCODE_UNDEFINED(0xef) \`
`289`	`289`	`\`
Original file line number	Diff line number	Diff line change
`@@ -258,7 +258,7 @@ std::optional<evmc_message> Host::prepare_message(evmc_message msg) noexcept`
`258`	`258`
`259`	`259`	`msg.recipient = compute_create_address(msg.sender, sender_nonce);`
`260`	`260`	`}`
`261`		`- // EOFCREATE or TXCREATE`
	`261`	`+ // EOFCREATE`
`262`	`262`	`else`
`263`	`263`	`{`
`264`	`264`	`const bytes_view initcontainer{msg.code, msg.code_size};`
`@@ -345,7 +345,7 @@ evmc::Result Host::create(const evmc_message& msg) noexcept`
`345`	`345`	`{`
`346`	`346`	`if (m_rev >= EVMC_PRAGUE)`
`347`	`347`	`{`
`348`		`- // Only EOFCREATE/TXCREATE/EOF-creation-tx is allowed to deploy code starting with EF.`
	`348`	`+ // Only EOFCREATE/EOF-creation-tx is allowed to deploy code starting with EF.`
`349`	`349`	`// It must be valid EOF, which was validated before execution.`
`350`	`350`	`if (msg.kind != EVMC_EOFCREATE)`
`351`	`351`	`return evmc::Result{EVMC_CONTRACT_VALIDATION_FAILURE};`
`@@ -449,8 +449,6 @@ evmc_tx_context Host::get_tx_context() const noexcept`
`449`	`449`	`intx::be::store<uint256be>(m_block.blob_base_fee),`
`450`	`450`	`m_tx.blob_hashes.data(),`
`451`	`451`	`m_tx.blob_hashes.size(),`
`452`		`- m_tx_initcodes.data(),`
`453`		`- m_tx_initcodes.size(),`
`454`	`452`	`};`
`455`	`453`	`}`
`456`	`454`