Set std::nullopt as call frame to-address when creation fails

Author: Baltoli

category/execution/ethereum/core/address.hpp

@@ -19,6 +19,7 @@
 
 #include <evmc/evmc.hpp>
 
+#include <algorithm>
 #include <cstddef>
 #include <functional>
 
@@ -29,6 +30,11 @@ using Address = ::evmc::address;
 static_assert(sizeof(Address) == 20);
 static_assert(alignof(Address) == 1);
 
+constexpr bool is_zero(evmc_address const &addr)
+{
+    return std::ranges::all_of(addr.bytes, [](auto const b) { return b == 0; });
+}
+
 MONAD_NAMESPACE_END
 
 namespace boost

category/execution/ethereum/test/test_call_trace.cpp

@@ -13,6 +13,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+#include <category/core/byte_string.hpp>
 #include <category/core/int.hpp>
 #include <category/execution/ethereum/block_hash_buffer.hpp>
 #include <category/execution/ethereum/chain/ethereum_mainnet.hpp>
@@ -40,6 +41,7 @@
 #include <optional>
 
 using namespace monad;
+using namespace monad::literals;
 using namespace monad::test;
 
 namespace
@@ -255,3 +257,93 @@ TYPED_TEST(TraitsTest, execute_reverted_insufficient_balance)
 
     EXPECT_EQ(call_frames[0], expected);
 }
+
+TYPED_TEST(TraitsTest, create_call_trace)
+{
+    InMemoryMachine machine;
+    mpt::Db db{machine};
+    TrieDb tdb{db};
+    vm::VM vm;
+
+    // Try to deploy a contract with reverting initcode
+    auto const code = 0x60fe6000526001601f6000f0_bytes;
+    auto const icode = vm::make_shared_intercode(code);
+    auto const code_hash = to_bytes(keccak256(code));
+
+    commit_sequential(
+        tdb,
+        StateDeltas{
+            {ADDR_A,
+             StateDelta{
+                 .account =
+                     {std::nullopt,
+                      Account{
+                          .balance = std::numeric_limits<uint256_t>::max()}}}},
+            {ADDR_B,
+             StateDelta{
+                 .account =
+                     {std::nullopt,
+                      Account{.balance = 0, .code_hash = code_hash}}}}},
+        Code{
+            {code_hash, icode},
+        },
+        BlockHeader{});
+
+    BlockState bs{tdb, vm};
+    Incarnation const incarnation{0, 0};
+    State s{bs, incarnation};
+
+    Transaction const tx{
+        .max_fee_per_gas = 1,
+        .gas_limit = 1'000'000,
+        .value = 0,
+        .to = ADDR_B,
+    };
+
+    auto const &sender = ADDR_A;
+    auto const &beneficiary = ADDR_A;
+
+    evmc_tx_context const tx_context{};
+    BlockHashBufferFinalized buffer{};
+    std::vector<CallFrame> call_frames;
+    CallTracer call_tracer{tx, call_frames};
+    EvmcHost<typename TestFixture::Trait> host{
+        call_tracer, tx_context, buffer, s};
+
+    auto const result =
+        ExecuteTransactionNoValidation<typename TestFixture::Trait>(
+            EthereumMainnet{},
+            tx,
+            sender,
+            authorities_empty,
+            BlockHeader{.beneficiary = beneficiary},
+            0)(s, host);
+    EXPECT_TRUE(result.status_code == EVMC_SUCCESS);
+    ASSERT_TRUE(call_frames.size() == 2);
+
+    // We don't care about the specific revision-dependent gas used in each call
+    // frame, only that the outer frame succeeds while the inner one fails to
+    // create and has a `std::nullopt` to address.
+
+    EXPECT_EQ(call_frames[0].type, CallType::CALL);
+    EXPECT_EQ(call_frames[0].flags, 0u);
+    EXPECT_EQ(call_frames[0].from, sender);
+    EXPECT_EQ(call_frames[0].to, ADDR_B);
+    EXPECT_EQ(call_frames[0].value, 0u);
+    EXPECT_EQ(call_frames[0].input, byte_string{});
+    EXPECT_EQ(call_frames[0].output, byte_string{});
+    EXPECT_EQ(call_frames[0].status, EVMC_SUCCESS);
+    EXPECT_EQ(call_frames[0].depth, 0u);
+    EXPECT_EQ(call_frames[0].logs, std::vector<CallFrame::Log>{});
+
+    EXPECT_EQ(call_frames[1].type, CallType::CREATE);
+    EXPECT_EQ(call_frames[1].flags, 0u);
+    EXPECT_EQ(call_frames[1].from, ADDR_B);
+    EXPECT_EQ(call_frames[1].to, std::nullopt);
+    EXPECT_EQ(call_frames[1].value, 0u);
+    EXPECT_EQ(call_frames[1].input, 0xFE_bytes);
+    EXPECT_EQ(call_frames[1].output, byte_string{});
+    EXPECT_EQ(call_frames[1].status, EVMC_FAILURE);
+    EXPECT_EQ(call_frames[1].depth, 1u);
+    EXPECT_EQ(call_frames[1].logs, std::vector<CallFrame::Log>{});
+}

category/execution/ethereum/trace/call_tracer.cpp

@@ -169,7 +169,9 @@ void CallTracer::on_exit(evmc::Result const &res)
     frame.status = res.status_code;
 
     if (frame.type == CallType::CREATE || frame.type == CallType::CREATE2) {
-        frame.to = res.create_address;
+        frame.to = is_zero(res.create_address)
+                       ? std::nullopt
+                       : std::optional{res.create_address};
     }
 
     last_.pop();