Allow EOF creation transactions

lib/evmone/eof.cpp

@@ -18,7 +18,6 @@
 #include <span>
 #include <stack>
 #include <unordered_set>
-#include <variant>
 #include <vector>
 
 namespace evmone
@@ -203,13 +202,10 @@ std::variant<EOFSectionHeaders, EOFValidationError> validate_section_headers(byt
         std::accumulate(section_headers[CONTAINER_SECTION].begin(),
             section_headers[CONTAINER_SECTION].end(), 0);
     const auto remaining_container_size = container_end - it;
-    // Only data section may be truncated, so remaining_container size must be in
-    // [declared_size_without_data, declared_size_without_data + declared_data_size]
+    // Only data section may be truncated, so remaining_container size must be at least
+    // declared_size_without_data
     if (remaining_container_size < section_bodies_without_data)
         return EOFValidationError::invalid_section_bodies_size;
-    if (remaining_container_size >
-        section_bodies_without_data + section_headers[DATA_SECTION].front())
-        return EOFValidationError::invalid_section_bodies_size;
 
     if (section_headers[TYPE_SECTION][0] != section_headers[CODE_SECTION].size() * 4)
         return EOFValidationError::invalid_type_section_size;
@@ -250,68 +246,6 @@ std::variant<std::vector<EOFCodeType>, EOFValidationError> validate_types(
     return types;
 }
 
-std::variant<EOF1Header, EOFValidationError> validate_header(
-    evmc_revision rev, bytes_view container) noexcept
-{
-    if (!is_eof_container(container))
-        return EOFValidationError::invalid_prefix;
-
-    const auto version = get_eof_version(container);
-    if (version != 1)
-        return EOFValidationError::eof_version_unknown;
-
-    if (rev < EVMC_PRAGUE)
-        return EOFValidationError::eof_version_unknown;
-
-    const auto section_headers_or_error = validate_section_headers(container);
-    if (const auto* error = std::get_if<EOFValidationError>(&section_headers_or_error))
-        return *error;
-
-    const auto& section_headers = std::get<EOFSectionHeaders>(section_headers_or_error);
-    const auto& code_sizes = section_headers[CODE_SECTION];
-    const auto data_size = section_headers[DATA_SECTION][0];
-
-    const auto header_size = eof_header_size(section_headers);
-
-    const auto types_or_error =
-        validate_types(container, header_size, section_headers[TYPE_SECTION].front());
-    if (const auto* error = std::get_if<EOFValidationError>(&types_or_error))
-        return *error;
-    const auto& types = std::get<std::vector<EOFCodeType>>(types_or_error);
-
-    std::vector<uint16_t> code_offsets;
-    const auto type_section_size = section_headers[TYPE_SECTION][0];
-    auto offset = header_size + type_section_size;
-    for (const auto code_size : code_sizes)
-    {
-        assert(offset <= std::numeric_limits<uint16_t>::max());
-        code_offsets.emplace_back(static_cast<uint16_t>(offset));
-        offset += code_size;
-    }
-
-    const auto& container_sizes = section_headers[CONTAINER_SECTION];
-    std::vector<uint16_t> container_offsets;
-    for (const auto container_size : container_sizes)
-    {
-        container_offsets.emplace_back(static_cast<uint16_t>(offset));
-        offset += container_size;
-    }
-    // NOTE: assertion always satisfied only as long as initcode limits apply (48K).
-    assert(offset <= std::numeric_limits<uint16_t>::max());
-    const auto data_offset = static_cast<uint16_t>(offset);
-
-    return EOF1Header{
-        .version = container[2],
-        .code_sizes = code_sizes,
-        .code_offsets = code_offsets,
-        .data_size = data_size,
-        .data_offset = data_offset,
-        .container_sizes = container_sizes,
-        .container_offsets = container_offsets,
-        .types = types,
-    };
-}
-
 /// Result of validating instructions in a code section.
 struct InstructionValidationResult
 {
@@ -662,6 +596,9 @@ EOFValidationError validate_eof1(evmc_revision rev, bytes_view main_container) n
 
         auto& header = std::get<EOF1Header>(error_or_header);
 
+        if (container.size() > static_cast<size_t>(header.data_offset) + header.data_size)
+            return EOFValidationError::invalid_section_bodies_size;
+
         // Validate code sections
         std::vector<bool> visited_code_sections(header.code_sizes.size());
         std::queue<uint16_t> code_sections_queue({0});
@@ -753,6 +690,68 @@ bool is_eof_container(bytes_view container) noexcept
     return container.size() > 1 && container[0] == MAGIC[0] && container[1] == MAGIC[1];
 }
 
+std::variant<EOF1Header, EOFValidationError> validate_header(
+    evmc_revision rev, bytes_view container) noexcept
+{
+    if (!is_eof_container(container))
+        return EOFValidationError::invalid_prefix;
+
+    const auto version = get_eof_version(container);
+    if (version != 1)
+        return EOFValidationError::eof_version_unknown;
+
+    if (rev < EVMC_PRAGUE)
+        return EOFValidationError::eof_version_unknown;
+
+    const auto section_headers_or_error = validate_section_headers(container);
+    if (const auto* error = std::get_if<EOFValidationError>(&section_headers_or_error))
+        return *error;
+
+    const auto& section_headers = std::get<EOFSectionHeaders>(section_headers_or_error);
+    const auto& code_sizes = section_headers[CODE_SECTION];
+    const auto data_size = section_headers[DATA_SECTION][0];
+
+    const auto header_size = eof_header_size(section_headers);
+
+    const auto types_or_error =
+        validate_types(container, header_size, section_headers[TYPE_SECTION].front());
+    if (const auto* error = std::get_if<EOFValidationError>(&types_or_error))
+        return *error;
+    const auto& types = std::get<std::vector<EOFCodeType>>(types_or_error);
+
+    std::vector<uint16_t> code_offsets;
+    const auto type_section_size = section_headers[TYPE_SECTION][0];
+    auto offset = header_size + type_section_size;
+    for (const auto code_size : code_sizes)
+    {
+        assert(offset <= std::numeric_limits<uint16_t>::max());
+        code_offsets.emplace_back(static_cast<uint16_t>(offset));
+        offset += code_size;
+    }
+
+    const auto& container_sizes = section_headers[CONTAINER_SECTION];
+    std::vector<uint16_t> container_offsets;
+    for (const auto container_size : container_sizes)
+    {
+        container_offsets.emplace_back(static_cast<uint16_t>(offset));
+        offset += container_size;
+    }
+    // NOTE: assertion always satisfied only as long as initcode limits apply (48K).
+    assert(offset <= std::numeric_limits<uint16_t>::max());
+    const auto data_offset = static_cast<uint16_t>(offset);
+
+    return EOF1Header{
+        .version = container[2],
+        .code_sizes = code_sizes,
+        .code_offsets = code_offsets,
+        .data_size = data_size,
+        .data_offset = data_offset,
+        .container_sizes = container_sizes,
+        .container_offsets = container_offsets,
+        .types = types,
+    };
+}
+
 /// This function expects the prefix and version to be valid, as it ignores it.
 EOF1Header read_valid_eof1_header(bytes_view container)
 {
@@ -820,6 +819,9 @@ bool append_data_section(bytes& container, bytes_view aux_data)
 {
     const auto header = read_valid_eof1_header(container);
 
+    // Assert we don't need to trim off the bytes beyond the declared data section first.
+    assert(container.size() <= header.data_offset + header.data_size);
+
     const auto new_data_size = container.size() - header.data_offset + aux_data.size();
     if (new_data_size > std::numeric_limits<uint16_t>::max())
         return false;

lib/evmone/eof.hpp

@@ -10,6 +10,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <string>
+#include <variant>
 #include <vector>
 
 namespace evmone
@@ -71,7 +72,7 @@ struct EOF1Header
     [[nodiscard]] bool can_init(size_t container_size) const noexcept
     {
         // Containers with truncated data section cannot be initcontainers.
-        const auto truncated_data = static_cast<size_t>(data_offset + data_size) != container_size;
+        const auto truncated_data = static_cast<size_t>(data_offset + data_size) > container_size;
         return !truncated_data;
     }
 
@@ -145,6 +146,10 @@ enum class EOFValidationError
 /// If the prefix is missing or invalid, 0 is returned meaning legacy code.
 [[nodiscard]] uint8_t get_eof_version(bytes_view container) noexcept;
 
+/// Validates the header and returns its representation if successful.
+[[nodiscard]] EVMC_EXPORT std::variant<EOF1Header, EOFValidationError> validate_header(
+    evmc_revision rev, bytes_view container) noexcept;
+
 /// Validates whether given container is a valid EOF according to the rules of given revision.
 [[nodiscard]] EVMC_EXPORT EOFValidationError validate_eof(
     evmc_revision rev, bytes_view container) noexcept;

test/state/errors.hpp

@@ -30,7 +30,6 @@ enum ErrorCode : int
     EMPTY_BLOB_HASHES_LIST,
     INVALID_BLOB_HASH_VERSION,
     BLOB_GAS_LIMIT_EXCEEDED,
-    EOF_CREATION_TRANSACTION,
     UNKNOWN_ERROR,
 };
 
@@ -83,8 +82,6 @@ inline const std::error_category& evmone_category() noexcept
                 return "invalid blob hash version";
             case BLOB_GAS_LIMIT_EXCEEDED:
                 return "blob gas limit exceeded";
-            case EOF_CREATION_TRANSACTION:
-                return "EOF initcode in creation transaction";
             case UNKNOWN_ERROR:
                 return "Unknown error";
             default:

test/state/host.cpp

@@ -213,7 +213,7 @@ address compute_eofcreate_address(
     return new_addr;
 }
 
-std::optional<evmc_message> Host::prepare_message(evmc_message msg)
+std::optional<evmc_message> Host::prepare_message(evmc_message msg) noexcept
 {
     if (msg.depth == 0 || msg.kind == EVMC_CREATE || msg.kind == EVMC_CREATE2 ||
         msg.kind == EVMC_EOFCREATE)
@@ -244,9 +244,45 @@ std::optional<evmc_message> Host::prepare_message(evmc_message msg)
             else
             {
                 assert(msg.kind == EVMC_EOFCREATE);
-                const bytes_view initcontainer{msg.code, msg.code_size};
-                msg.recipient =
-                    compute_eofcreate_address(msg.sender, msg.create2_salt, initcontainer);
+                const bytes_view input = {msg.input_data, msg.input_size};
+
+                // Indicator of an EOF creation tx - EVMC_EOFCREATE at depth 0.
+                if (msg.depth == 0)
+                {
+                    // Assert this is a legacy EOF creation tx.
+                    assert(is_eof_container(input));
+                    const auto header_or_error = validate_header(m_rev, input);
+
+                    const auto* header = std::get_if<EOF1Header>(&header_or_error);
+                    if (header == nullptr)
+                        return {};  // Light early exception.
+
+                    if (!header->can_init(msg.input_size))
+                        return {};  // Light early exception.
+
+                    const auto container_size =
+                        static_cast<size_t>(header->data_offset + header->data_size);
+                    // Follows from the header->can_init condition above.
+                    assert(container_size <= msg.input_size);
+
+                    msg.code = msg.input_data;
+                    msg.code_size = container_size;
+                    msg.input_data = msg.input_data + container_size;
+                    msg.input_size = msg.input_size - container_size;
+
+                    if (validate_eof(m_rev, {msg.code, msg.code_size}) !=
+                        EOFValidationError::success)
+                        return {};  // Light early exception.
+
+                    msg.recipient = compute_create_address(msg.sender, sender_nonce);
+                }
+                // EOFCREATE or TXCREATE
+                else
+                {
+                    const bytes_view initcontainer{msg.code, msg.code_size};
+                    msg.recipient =
+                        compute_eofcreate_address(msg.sender, msg.create2_salt, initcontainer);
+                }
             }
 
             // By EIP-2929, the access to new created address is never reverted.
@@ -327,7 +363,7 @@ evmc::Result Host::create(const evmc_message& msg) noexcept
     {
         if (m_rev >= EVMC_PRAGUE)
         {
-            // Only EOFCREATE/TXCREATE is allowed to deploy code starting with EF.
+            // Only EOFCREATE/TXCREATE/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};

test/state/host.hpp

@@ -126,7 +126,7 @@ class Host : public evmc::Host
     /// which may finally be moved to EVM.
     /// Any state modification is not reverted.
     /// @return Modified message or std::nullopt in case of EVM exception.
-    std::optional<evmc_message> prepare_message(evmc_message msg);
+    std::optional<evmc_message> prepare_message(evmc_message msg) noexcept;
 
     evmc::Result execute_message(const evmc_message& msg) noexcept;
 };

test/state/state.cpp

@@ -55,20 +55,37 @@ int64_t compute_tx_intrinsic_cost(evmc_revision rev, const Transaction& tx) noex
     static constexpr auto call_tx_cost = 21000;
     static constexpr auto create_tx_cost = 53000;
     static constexpr auto initcode_word_cost = 2;
-    const auto is_create = !tx.to.has_value();
+    const auto is_create = !tx.to.has_value();  // Covers also EOF creation txs.
     const auto initcode_cost =
         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;
 }
 
-evmc_message build_message(const Transaction& tx, int64_t execution_gas_limit) noexcept
+evmc_message build_message(
+    const Transaction& tx, int64_t execution_gas_limit, evmc_revision rev) noexcept
 {
     const auto recipient = tx.to.has_value() ? *tx.to : evmc::address{};
-    return {tx.to.has_value() ? EVMC_CALL : EVMC_CREATE, 0, 0, execution_gas_limit, recipient,
-        tx.sender, tx.data.data(), tx.data.size(), intx::be::store<evmc::uint256be>(tx.value), {},
-        recipient, nullptr, 0};
+
+    const auto is_legacy_eof_create =
+        rev >= EVMC_PRAGUE && !tx.to.has_value() && is_eof_container(tx.data);
+
+    return {.kind = is_legacy_eof_create ? EVMC_EOFCREATE :
+                    tx.to.has_value()    ? EVMC_CALL :
+                                           EVMC_CREATE,
+        .flags = 0,
+        .depth = 0,
+        .gas = execution_gas_limit,
+        .recipient = recipient,
+        .sender = tx.sender,
+        .input_data = tx.data.data(),
+        .input_size = tx.data.size(),
+        .value = intx::be::store<evmc::uint256be>(tx.value),
+        .create2_salt = {},
+        .code_address = recipient,
+        .code = nullptr,
+        .code_size = 0};
 }
 }  // namespace
 
@@ -326,9 +343,6 @@ std::variant<int64_t, std::error_code> validate_transaction(const Account& sende
     if (rev >= EVMC_SHANGHAI && !tx.to.has_value() && tx.data.size() > max_initcode_size)
         return make_error_code(INIT_CODE_SIZE_LIMIT_EXCEEDED);
 
-    if (rev >= EVMC_PRAGUE && !tx.to.has_value() && is_eof_container(tx.data))
-        return make_error_code(EOF_CREATION_TRANSACTION);
-
     // Compute and check if sender has enough balance for the theoretical maximum transaction cost.
     // Note this is different from tx_max_cost computed with effective gas price later.
     // The computation cannot overflow if done with 512-bit precision.
@@ -485,7 +499,7 @@ std::variant<TransactionReceipt, std::error_code> transition(State& state, const
     if (rev >= EVMC_SHANGHAI)
         host.access_account(block.coinbase);
 
-    const auto result = host.call(build_message(tx, execution_gas_limit));
+    const auto result = host.call(build_message(tx, execution_gas_limit, rev));
 
     auto gas_used = tx.gas_limit - result.gas_left;
 
@@ -652,8 +666,6 @@ std::variant<TransactionReceipt, std::error_code> transition(State& state, const
         return "TR_BLOBVERSION_INVALID";
     case BLOB_GAS_LIMIT_EXCEEDED:
         return "TR_BLOBLIST_OVERSIZE";
-    case EOF_CREATION_TRANSACTION:
-        return "TR_EOFCreationTransaction";
     case UNKNOWN_ERROR:
         return "Unknown error";
     default: