EIP-4844 - pass blockchain tests (#1077)

Author: pdobacz

circle.yml

@@ -362,11 +362,8 @@ jobs:
       - run:
           name: "Execution spec tests (blockchain_tests)"
           working_directory: ~/build
-          # 4844 and 4788 temporarily turned off b/c they rely on blob features.
           command: >
-            bin/evmone-blockchaintest
-            --gtest_filter='*:-*eip4844*:*eip4788*'
-            ~/spec-tests/fixtures/blockchain_tests
+            bin/evmone-blockchaintest ~/spec-tests/fixtures/blockchain_tests
       - download_execution_spec_tests:
           release: [email protected]
           fixtures_suffix: pectra-devnet-4
@@ -428,10 +425,8 @@ jobs:
       - run:
           name: "EOF pre-release execution spec tests (blockchain_tests)"
           working_directory: ~/build
-          # 4844 and 4788 temporarily turned off b/c they rely on blob features.
           command: >
             bin/evmone-blockchaintest ~/spec-tests/fixtures/blockchain_tests/osaka
-            --gtest_filter='*:-*stEIP4844*'
       - run:
           name: "EOF pre-release execution spec tests (eof_tests)"
           working_directory: ~/build
@@ -466,18 +461,16 @@ jobs:
       - run:
           name: "Blockchain tests (GeneralStateTests)"
           working_directory: ~/build
-          # 4844 and 4788 temporarily turned off b/c they rely on blob features.
           command: >
             bin/evmone-blockchaintest
-            --gtest_filter='*:-VMTests/vmPerformance.*:*.*Call50000_sha256:*.CALLBlake2f_MaxRounds:*eip4844*:*stEIP4844*:*eip4788*'
+            --gtest_filter='*:-VMTests/vmPerformance.*:*.*Call50000_sha256:*.CALLBlake2f_MaxRounds'
             ~/tests/BlockchainTests/GeneralStateTests
       - run:
           name: "Blockchain tests (ValidBlocks)"
           working_directory: ~/build
-          # 4844 and 4788 temporarily turned off b/c they rely on blob features.
           command: >
             bin/evmone-blockchaintest
-            --gtest_filter='*:-bcMultiChainTest.*:bcTotalDifficultyTest.*:bcForkStressTest.ForkStressTest:bcGasPricerTest.RPC_API_Test:bcValidBlockTest.SimpleTx3LowS:*bcEIP4844*'
+            --gtest_filter='*:-bcMultiChainTest.*:bcTotalDifficultyTest.*:bcForkStressTest.ForkStressTest:bcGasPricerTest.RPC_API_Test:bcValidBlockTest.SimpleTx3LowS'
             ~/tests/BlockchainTests/ValidBlocks
             ~/tests/LegacyTests/Cancun/BlockchainTests/ValidBlocks
       - collect_coverage_gcc

test/blockchaintest/blockchaintest.hpp

@@ -39,7 +39,8 @@ struct BlockHeader
     hash256 transactions_root;
     hash256 withdrawal_root;
     hash256 parent_beacon_block_root;
-    uint64_t excess_blob_gas;
+    std::optional<uint64_t> blob_gas_used;
+    std::optional<uint64_t> excess_blob_gas;
     hash256 requests_hash;
 };
 

test/blockchaintest/blockchaintest_loader.cpp

@@ -18,6 +18,13 @@ T load_if_exists(const json::json& j, std::string_view key)
         return from_json<T>(*it);
     return {};
 }
+template <typename T>
+std::optional<T> load_optional(const json::json& j, std::string_view key)
+{
+    if (const auto it = j.find(key); it != j.end())
+        return from_json<T>(*it);
+    return std::nullopt;
+}
 }  // namespace
 
 template <>
@@ -41,7 +48,8 @@ BlockHeader from_json<BlockHeader>(const json::json& j)
         .transactions_root = from_json<hash256>(j.at("transactionsTrie")),
         .withdrawal_root = load_if_exists<hash256>(j, "withdrawalsRoot"),
         .parent_beacon_block_root = load_if_exists<hash256>(j, "parentBeaconBlockRoot"),
-        .excess_blob_gas = load_if_exists<uint64_t>(j, "excessBlobGas"),
+        .blob_gas_used = load_optional<uint64_t>(j, "blobGasUsed"),
+        .excess_blob_gas = load_optional<uint64_t>(j, "excessBlobGas"),
         .requests_hash = load_if_exists<hash256>(j, "requestsHash"),
     };
 }
@@ -62,8 +70,13 @@ static TestBlock load_test_block(const json::json& j, evmc_revision rev)
         tb.block_info.prev_randao = tb.expected_block_header.prev_randao;
         tb.block_info.base_fee = tb.expected_block_header.base_fee_per_gas;
         tb.block_info.parent_beacon_block_root = tb.expected_block_header.parent_beacon_block_root;
+        tb.block_info.blob_gas_used = tb.expected_block_header.blob_gas_used;
+        tb.block_info.excess_blob_gas = tb.expected_block_header.excess_blob_gas;
+
         tb.block_info.blob_base_fee =
-            compute_blob_gas_price(tb.expected_block_header.excess_blob_gas);
+            tb.block_info.excess_blob_gas.has_value() ?
+                std::optional(state::compute_blob_gas_price(*tb.block_info.excess_blob_gas)) :
+                std::nullopt;
 
         // Override prev_randao with difficulty pre-Merge
         if (rev < EVMC_PARIS)

test/blockchaintest/blockchaintest_runner.cpp

@@ -42,7 +42,7 @@ TransitionResult apply_block(TestState& state, evmc::VM& vm, const state::BlockI
 
     std::vector<state::Log> txs_logs;
     int64_t block_gas_left = block.gas_limit;
-    int64_t blob_gas_left = 0;
+    auto blob_gas_left = static_cast<int64_t>(block.blob_gas_used.value_or(0));
 
     std::vector<RejectedTransaction> rejected_txs;
     std::vector<state::TransactionReceipt> receipts;
@@ -75,7 +75,7 @@ TransitionResult apply_block(TestState& state, evmc::VM& vm, const state::BlockI
                 receipt.post_state = state::mpt_hash(block_state);
 
             block_gas_left -= receipt.gas_used;
-            blob_gas_left -= tx.blob_gas_used();
+            blob_gas_left -= static_cast<int64_t>(tx.blob_gas_used());
             receipts.emplace_back(std::move(receipt));
         }
     }
@@ -95,10 +95,34 @@ TransitionResult apply_block(TestState& state, evmc::VM& vm, const state::BlockI
         bloom, blob_gas_left, std::move(block_state)};
 }
 
-bool validate_block(evmc_revision, const TestBlock&, const BlockHeader&) noexcept
+bool validate_block(
+    evmc_revision rev, const TestBlock& test_block, const BlockHeader& parent_header) noexcept
 {
     // NOTE: includes only block validity unrelated to individual txs. See `apply_block`.
 
+    if (rev >= EVMC_CANCUN)
+    {
+        // `excess_blob_gas` and `blob_gas_used` mandatory after Cancun and invalid before.
+        if (!test_block.block_info.excess_blob_gas.has_value() ||
+            !test_block.block_info.blob_gas_used.has_value())
+            return false;
+
+        // Check that the excess blob gas was updated correctly.
+        if (*test_block.block_info.excess_blob_gas !=
+            state::calc_excess_blob_gas(
+                parent_header.blob_gas_used.value_or(0), parent_header.excess_blob_gas.value_or(0)))
+            return false;
+
+        // Ensure the total blob gas spent is at most equal to the limit
+        if (*test_block.block_info.blob_gas_used > state::BlockInfo::MAX_BLOB_GAS_PER_BLOCK)
+            return false;
+    }
+    else
+    {
+        if (test_block.block_info.excess_blob_gas.has_value() ||
+            test_block.block_info.blob_gas_used.has_value())
+            return false;
+    }
     return true;
 }
 

test/state/block.cpp

@@ -7,6 +7,8 @@
 
 namespace evmone::state
 {
+static constexpr uint64_t TARGET_BLOB_GAS_PER_BLOCK = 393216;
+
 intx::uint256 compute_blob_gas_price(uint64_t excess_blob_gas) noexcept
 {
     /// A helper function approximating `factor * e ** (numerator / denominator)`.
@@ -16,10 +18,16 @@ intx::uint256 compute_blob_gas_price(uint64_t excess_blob_gas) noexcept
         intx::uint256 i = 1;
         intx::uint256 output = 0;
         intx::uint256 numerator_accum = factor * denominator;
+        const intx::uint256 numerator256 = numerator;
         while (numerator_accum > 0)
         {
             output += numerator_accum;
-            numerator_accum = (numerator_accum * numerator) / (denominator * i);
+            // Ensure the multiplication won't overflow 256 bits.
+            if (const auto p = intx::umul(numerator_accum, numerator256);
+                p <= std::numeric_limits<intx::uint256>::max())
+                numerator_accum = intx::uint256(p) / (denominator * i);
+            else
+                return std::numeric_limits<intx::uint256>::max();
             i += 1;
         }
         return output / denominator;
@@ -30,6 +38,15 @@ intx::uint256 compute_blob_gas_price(uint64_t excess_blob_gas) noexcept
     return fake_exponential(MIN_BLOB_GASPRICE, excess_blob_gas, BLOB_GASPRICE_UPDATE_FRACTION);
 }
 
+uint64_t calc_excess_blob_gas(
+    uint64_t parent_blob_gas_used, uint64_t parent_excess_blob_gas) noexcept
+{
+    if (parent_excess_blob_gas + parent_blob_gas_used < TARGET_BLOB_GAS_PER_BLOCK)
+        return 0;
+    else
+        return parent_excess_blob_gas + parent_blob_gas_used - TARGET_BLOB_GAS_PER_BLOCK;
+}
+
 [[nodiscard]] bytes rlp_encode(const Withdrawal& withdrawal)
 {
     return rlp::encode_tuple(withdrawal.index, withdrawal.validator_index, withdrawal.recipient,

test/state/block.hpp

@@ -33,7 +33,7 @@ struct Withdrawal
 struct BlockInfo
 {
     /// Max amount of blob gas allowed in block. It's constant now but can be dynamic in the future.
-    static constexpr int64_t MAX_BLOB_GAS_PER_BLOCK = 786432;
+    static constexpr uint64_t MAX_BLOB_GAS_PER_BLOCK = 786432;
 
     int64_t number = 0;
     int64_t timestamp = 0;
@@ -49,13 +49,15 @@ struct BlockInfo
     /// The EIP-1559 base fee, since London.
     uint64_t base_fee = 0;
 
+    /// The "blob gas used" parameter from EIP-4844
+    std::optional<uint64_t> blob_gas_used;
+
     /// The "excess blob gas" parameter from EIP-4844
     /// for computing the blob gas price in the current block.
-    uint64_t excess_blob_gas = 0;
+    std::optional<uint64_t> excess_blob_gas;
 
-    /// The blob gas price parameter from EIP-4844.
-    /// This value is not stored in block headers directly but computed from excess_blob_gas.
-    intx::uint256 blob_base_fee = 0;
+    /// Blob gas price from EIP-4844, computed from excess_blob_gas.
+    std::optional<intx::uint256> blob_base_fee;
 
     std::vector<Ommer> ommers;
     std::vector<Withdrawal> withdrawals;
@@ -64,6 +66,10 @@ struct BlockInfo
 /// Computes the current blob gas price based on the excess blob gas.
 intx::uint256 compute_blob_gas_price(uint64_t excess_blob_gas) noexcept;
 
+/// Computes the current excess blob gas based on parameters of the parent block.
+uint64_t calc_excess_blob_gas(
+    uint64_t parent_blob_gas_used, uint64_t parent_excess_blob_gas) noexcept;
+
 /// Defines how to RLP-encode a Withdrawal.
 [[nodiscard]] bytes rlp_encode(const Withdrawal& withdrawal);
 }  // namespace evmone::state

test/state/host.cpp

@@ -493,7 +493,7 @@ evmc_tx_context Host::get_tx_context() const noexcept
         m_block.prev_randao,
         0x01_bytes32,  // Chain ID is expected to be 1.
         uint256be{m_block.base_fee},
-        intx::be::store<uint256be>(m_block.blob_base_fee),
+        intx::be::store<uint256be>(m_block.blob_base_fee.value_or(0)),
         m_tx.blob_hashes.data(),
         m_tx.blob_hashes.size(),
     };

test/state/state.cpp

@@ -311,7 +311,8 @@ std::variant<TransactionProperties, std::error_code> validate_transaction(
         if (tx.blob_hashes.empty())
             return make_error_code(EMPTY_BLOB_HASHES_LIST);
 
-        if (tx.max_blob_gas_price < block.blob_base_fee)
+        assert(block.blob_base_fee.has_value());
+        if (tx.max_blob_gas_price < *block.blob_base_fee)
             return make_error_code(FEE_CAP_LESS_THEN_BLOCKS);
 
         if (std::ranges::any_of(tx.blob_hashes, [](const auto& h) { return h.bytes[0] != 0x01; }))
@@ -451,9 +452,13 @@ TransactionReceipt transition(const StateView& state_view, const BlockInfo& bloc
 
     if (tx.type == Transaction::Type::blob)
     {
-        const auto blob_fee = tx.blob_gas_used() * block.blob_base_fee;
+        // This uint64 * uint256 cannot overflow, because tx.blob_gas_used has limits enforced
+        // before this stage.
+        assert(block.blob_base_fee.has_value());
+        const auto blob_fee = intx::umul(intx::uint256(tx.blob_gas_used()), *block.blob_base_fee);
+        assert(blob_fee <= std::numeric_limits<intx::uint256>::max());
         assert(sender_acc.balance >= blob_fee);  // Required for valid tx.
-        sender_acc.balance -= blob_fee;
+        sender_acc.balance -= intx::uint256(blob_fee);
     }
 
     Host host{rev, vm, state, block, block_hashes, tx};

test/state/transaction.hpp

@@ -43,10 +43,10 @@ struct Transaction
     };
 
     /// Returns amount of blob gas used by this transaction
-    [[nodiscard]] int64_t blob_gas_used() const
+    [[nodiscard]] uint64_t blob_gas_used() const
     {
         static constexpr auto GAS_PER_BLOB = 0x20000;
-        return GAS_PER_BLOB * static_cast<int64_t>(blob_hashes.size());
+        return GAS_PER_BLOB * blob_hashes.size();
     }
 
     Type type = Type::legacy;

test/statetest/statetest_loader.cpp

@@ -232,10 +232,7 @@ state::BlockInfo from_json<state::BlockInfo>(const json::json& j)
     {
         const auto parent_excess_blob_gas = from_json<uint64_t>(*it);
         const auto parent_blob_gas_used = from_json<uint64_t>(j.at("parentBlobGasUsed"));
-        static constexpr uint64_t TARGET_BLOB_GAS_PER_BLOCK = 0x60000;
-        excess_blob_gas =
-            std::max(parent_excess_blob_gas + parent_blob_gas_used, TARGET_BLOB_GAS_PER_BLOCK) -
-            TARGET_BLOB_GAS_PER_BLOCK;
+        excess_blob_gas = state::calc_excess_blob_gas(parent_blob_gas_used, parent_excess_blob_gas);
     }
     else if (const auto it2 = j.find("currentExcessBlobGas"); it2 != j.end())
     {
@@ -254,6 +251,7 @@ state::BlockInfo from_json<state::BlockInfo>(const json::json& j)
         .prev_randao = prev_randao,
         .parent_beacon_block_root = load_if_exists<hash256>(j, "parentBeaconBlockRoot"),
         .base_fee = base_fee,
+        .blob_gas_used = load_if_exists<uint64_t>(j, "blobGasUsed"),
         .excess_blob_gas = excess_blob_gas,
         .blob_base_fee = state::compute_blob_gas_price(excess_blob_gas),
         .ommers = std::move(ommers),