Revert "feat(dump): implement Binary Trie state dumping for t8n tool"

This reverts commit 91ba8a2.

Author: CPerezz

cmd/evm/internal/t8ntool/transition.go

@@ -197,14 +197,10 @@ func Transition(ctx *cli.Context) error {
 	// Dump the execution result
 	collector := make(Alloc)
 	var btleaves map[common.Hash]hexutil.Bytes
-	s.DumpToCollector(collector, nil)
 	isBinary := chainConfig.IsVerkle(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp)
-	if isBinary {
-		// For Binary Trie mode, we need to dump both:
-		// 1. The state to collector (alloc) for multi-block tests to maintain state between blocks
-		// 2. The Binary Trie leaves for witness data
-		// Without the collector dump, the test framework cannot track state changes (like nonce updates)
-		// between blocks, causing tests with multiple blocks (e.g., withdrawal tests) to fail.
+	if !isBinary {
+		s.DumpToCollector(collector, nil)
+	} else {
 		btleaves = make(map[common.Hash]hexutil.Bytes)
 		if err := s.DumpBinTrieLeaves(btleaves); err != nil {
 			return err

core/state/dump.go

@@ -17,21 +17,17 @@
 package state
 
 import (
-	"bytes"
-	"encoding/binary"
 	"encoding/json"
 	"fmt"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/trie"
 	"github.com/ethereum/go-ethereum/trie/bintrie"
-	"github.com/holiman/uint256"
 )
 
 // DumpConfig is a set of options to control what portions of the state will be
@@ -138,12 +134,6 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey []
 	if err != nil {
 		return nil
 	}
-
-	// Check if this is a Binary Trie and handle it specially
-	if btrie, ok := tr.(*bintrie.BinaryTrie); ok {
-		return s.dumpBinaryTrieToCollector(btrie, c, conf)
-	}
-
 	trieIt, err := tr.NodeIterator(conf.Start)
 	if err != nil {
 		log.Error("Trie dumping error", "err", err)
@@ -232,166 +222,6 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey []
 	return nextKey
 }
 
-// dumpBinaryTrieToCollector handles dumping Binary Trie state to the collector.
-// This is necessary because Binary Trie stores account data in a completely different format
-// than MPT. While MPT uses RLP-encoded StateAccount structures, Binary Trie stores raw bytes
-// with specific offsets as defined in EIP-7864.
-//
-// Binary Trie storage layout for account data:
-// - BasicDataLeafKey (suffix byte 0): Contains nonce and balance
-//   - Bytes 0-7: Code size (4 bytes) + padding
-//   - Bytes 8-15: Nonce (8 bytes, big-endian)
-//   - Bytes 16-31: Balance (16 bytes, big-endian)
-//
-// - CodeHashLeafKey (suffix byte 1): Contains the code hash (32 bytes)
-// - Storage slots (suffix bytes 64+): Contains storage values
-//
-// This function needs to:
-// 1. Iterate through Binary Trie nodes to find account data
-// 2. Extract and decode account information from raw bytes
-// 3. Map Binary Trie keys back to Ethereum addresses
-// 4. Reconstruct the full account state for the collector
-func (s *StateDB) dumpBinaryTrieToCollector(btrie *bintrie.BinaryTrie, c DumpCollector, conf *DumpConfig) (nextKey []byte) {
-	var (
-		accounts uint64
-		// Map to track processed stems to avoid duplicate accounts
-		// This prevents dumping the same account when iterating through
-		// since nultiple leaves can belong to the same account (basic data, code hash, storage).
-		processedStems = make(map[string]bool)
-	)
-
-	// Step 1: Create an iterator to traverse the Binary Trie
-	// The iterator will visit all nodes in the trie, allowing us to find leaf nodes
-	// that contain actual account data
-	it, err := btrie.NodeIterator(nil)
-	if err != nil {
-		log.Error("Failed to create Binary Trie iterator", "err", err)
-		return nil
-	}
-
-	// Step 2: Iterate through all nodes in the Binary Trie
-	for it.Next(true) {
-		// Skip non-leaf nodes as they don't contain account data
-		if !it.Leaf() {
-			continue
-		}
-
-		// Step 3: Extract the leaf's key and value
-		// The key is 32 bytes: 31-byte stem + 1-byte suffix
-		// The stem encodes the account address, the suffix indicates the data type
-		leafKey := it.LeafKey()
-		leafValue := it.LeafBlob()
-
-		// Step 4: Parse the key structure
-		// First 31 bytes: stem (encodes the account address)
-		// Last byte: suffix (indicates the type of data)
-		stem := string(leafKey[:31])
-		suffixByte := leafKey[31]
-
-		// Step 5: Check if this leaf contains BasicData (nonce + balance)
-		// BasicDataLeafKey = 0 is the suffix for account basic data
-		if suffixByte == bintrie.BasicDataLeafKey {
-			// Step 6: Ensure we only process each account once
-			// Multiple leaves can belong to the same account (basic data, code hash, storage)
-			// We only want to dump each account once
-			if processedStems[stem] {
-				continue
-			}
-			processedStems[stem] = true
-
-			// Step 7: Extract nonce from the Binary Trie format
-			// Nonce is stored at offset 8 as an 8-byte big-endian integer
-			var nonce uint64
-			if len(leafValue) > bintrie.BasicDataNonceOffset+8 {
-				nonce = binary.BigEndian.Uint64(leafValue[bintrie.BasicDataNonceOffset:])
-			}
-
-			// Step 8: Extract balance from the Binary Trie format
-			// Balance is stored at offset 16 as a 16-byte big-endian integer
-			var balance = new(uint256.Int)
-			if len(leafValue) > bintrie.BasicDataBalanceOffset+16 {
-				balanceBytes := make([]byte, 16)
-				copy(balanceBytes, leafValue[bintrie.BasicDataBalanceOffset:bintrie.BasicDataBalanceOffset+16])
-				balance.SetBytes(balanceBytes)
-			}
-
-			// Step 9: Map the Binary Trie key back to an Ethereum address
-			// This is the challenging part: Binary Trie keys are hashed versions of addresses
-			// We need to find which address maps to this particular key
-			//
-			// Current approach: (Made up by Claude) ->
-			// Iterate through known addresses in stateObjects
-			// and check if their Binary Trie key matches our leaf key
-			var foundAddr *common.Address
-			for addr := range s.stateObjects {
-				// Generate the Binary Trie key for this address
-				testKey := bintrie.GetBinaryTreeKeyBasicData(addr)
-				if bytes.Equal(testKey, leafKey) {
-					a := addr // Create a copy to avoid reference issues
-					foundAddr = &a
-					break
-				}
-			}
-
-			// Step 10: Error if we couldn't find the corresponding address
-			// This might happen for accounts not in the current state cache
-			if foundAddr == nil {
-				// TODO(@CPerezz): Figure out how to proceed.
-				panic("Binary Trie dump error: Cannot recover address from hash.")
-			}
-
-			// Step 11: Create the dump account structure with basic data
-			addr := *foundAddr
-			dumpAccount := DumpAccount{
-				Balance:     balance.ToBig().String(),
-				Nonce:       nonce,
-				Address:     &addr,
-				AddressHash: crypto.Keccak256(addr[:]),
-			}
-
-			// Step 12: Fetch the code hash from a separate Binary Trie leaf
-			// Code hash is stored at suffix byte 1 (CodeHashLeafKey)
-			codeHashKey := bintrie.GetBinaryTreeKeyCodeHash(addr)
-			if codeHashData, err := btrie.GetWithHashedKey(codeHashKey); err == nil && codeHashData != nil {
-				dumpAccount.CodeHash = codeHashData
-				// Step 13: Fetch the actual code if needed and not empty
-				if !conf.SkipCode && !bytes.Equal(codeHashData, types.EmptyCodeHash.Bytes()) {
-					dumpAccount.Code = s.GetCode(addr)
-				}
-			}
-
-			// Step 14: Fetch storage values if needed
-			if !conf.SkipStorage {
-				dumpAccount.Storage = make(map[common.Hash]string)
-				// TODO(CPerezz): Properly iterate through Binary Trie storage slots
-				// Storage slots are at suffix bytes 64+ in the Binary Trie
-				// Idea from Claude:
-				// Use the cached dirty storage from state objects
-				if obj := s.getStateObject(addr); obj != nil {
-					for key, value := range obj.dirtyStorage {
-						dumpAccount.Storage[key] = common.Bytes2Hex(value[:])
-					}
-				}
-			}
-
-			// Step 15: Send the account to the collector
-			c.OnAccount(&addr, dumpAccount)
-			accounts++
-
-			// Step 17: Check if we've reached the maximum number of accounts
-			if conf.Max > 0 && accounts >= conf.Max {
-				// Save the next key for resumption if there are more accounts
-				if it.Next(true) {
-					nextKey = it.LeafKey()
-				}
-				break
-			}
-		}
-	}
-
-	return nextKey
-}
-
 // DumpBinTrieLeaves collects all binary trie leaf nodes into the provided map.
 func (s *StateDB) DumpBinTrieLeaves(collector map[common.Hash]hexutil.Bytes) error {
 	if s.trie == nil {