go-ethereum/core/verkle_witness_test.go

// Copyright 2024 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package core

import (
	"bytes"
	"encoding/binary"
	"encoding/hex"
	"math/big"
	"slices"
	"testing"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/consensus/beacon"
	"github.com/ethereum/go-ethereum/consensus/ethash"
	"github.com/ethereum/go-ethereum/core/rawdb"
	"github.com/ethereum/go-ethereum/core/state"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/core/vm"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/params"
	"github.com/ethereum/go-ethereum/trie/utils"
	"github.com/ethereum/go-ethereum/triedb"
	"github.com/ethereum/go-verkle"
	"github.com/holiman/uint256"
)

var (
	testVerkleChainConfig = &params.ChainConfig{
		ChainID:                 big.NewInt(1),
		HomesteadBlock:          big.NewInt(0),
		EIP150Block:             big.NewInt(0),
		EIP155Block:             big.NewInt(0),
		EIP158Block:             big.NewInt(0),
		ByzantiumBlock:          big.NewInt(0),
		ConstantinopleBlock:     big.NewInt(0),
		PetersburgBlock:         big.NewInt(0),
		IstanbulBlock:           big.NewInt(0),
		MuirGlacierBlock:        big.NewInt(0),
		BerlinBlock:             big.NewInt(0),
		LondonBlock:             big.NewInt(0),
		Ethash:                  new(params.EthashConfig),
		ShanghaiTime:            u64(0),
		VerkleTime:              u64(0),
		TerminalTotalDifficulty: common.Big0,
		// TODO uncomment when proof generation is merged
		// ProofInBlocks:                 true,
	}
	testKaustinenLikeChainConfig = &params.ChainConfig{
		ChainID:                 big.NewInt(69420),
		HomesteadBlock:          big.NewInt(0),
		EIP150Block:             big.NewInt(0),
		EIP155Block:             big.NewInt(0),
		EIP158Block:             big.NewInt(0),
		ByzantiumBlock:          big.NewInt(0),
		ConstantinopleBlock:     big.NewInt(0),
		PetersburgBlock:         big.NewInt(0),
		IstanbulBlock:           big.NewInt(0),
		MuirGlacierBlock:        big.NewInt(0),
		BerlinBlock:             big.NewInt(0),
		LondonBlock:             big.NewInt(0),
		Ethash:                  new(params.EthashConfig),
		ShanghaiTime:            u64(0),
		VerkleTime:              u64(0),
		TerminalTotalDifficulty: common.Big0,
	}
)

func TestProcessVerkle(t *testing.T) {
	var (
		code                            = common.FromHex(`6060604052600a8060106000396000f360606040526008565b00`)
		intrinsicContractCreationGas, _ = IntrinsicGas(code, nil, true, true, true, true)
		// A contract creation that calls EXTCODECOPY in the constructor. Used to ensure that the witness
		// will not contain that copied data.
		// Source: https://gist.github.com/gballet/a23db1e1cb4ed105616b5920feb75985
		codeWithExtCodeCopy                = common.FromHex(`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`)
		intrinsicCodeWithExtCodeCopyGas, _ = IntrinsicGas(codeWithExtCodeCopy, nil, true, true, true, true)
		signer                             = types.LatestSigner(testVerkleChainConfig)
		testKey, _                         = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
		bcdb                               = rawdb.NewMemoryDatabase() // Database for the blockchain
		coinbase                           = common.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7")
		gspec                              = &Genesis{
			Config: testVerkleChainConfig,
			Alloc: GenesisAlloc{
				coinbase: {
					Balance: big.NewInt(1000000000000000000), // 1 ether
					Nonce:   0,
				},
				params.BeaconRootsAddress:        {Nonce: 1, Code: params.BeaconRootsCode, Balance: common.Big0},
				params.HistoryStorageAddress:     {Nonce: 1, Code: params.HistoryStorageCode, Balance: common.Big0},
				params.WithdrawalQueueAddress:    {Nonce: 1, Code: params.WithdrawalQueueCode, Balance: common.Big0},
				params.ConsolidationQueueAddress: {Nonce: 1, Code: params.ConsolidationQueueCode, Balance: common.Big0},
			},
		}
	)
	// Verkle trees use the snapshot, which must be enabled before the
	// data is saved into the tree+database.
	// genesis := gspec.MustCommit(bcdb, triedb)
	cacheConfig := DefaultCacheConfigWithScheme(rawdb.PathScheme)
	cacheConfig.SnapshotLimit = 0
	blockchain, _ := NewBlockChain(bcdb, cacheConfig, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil)
	defer blockchain.Stop()

	txCost1 := params.TxGas
	txCost2 := params.TxGas
	contractCreationCost := intrinsicContractCreationGas +
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + params.WitnessBranchReadCost + params.WitnessBranchWriteCost + /* creation */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* creation with value */
		739 /* execution costs */
	codeWithExtCodeCopyGas := intrinsicCodeWithExtCodeCopyGas +
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + params.WitnessBranchReadCost + params.WitnessBranchWriteCost + /* creation (tx) */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + params.WitnessBranchReadCost + params.WitnessBranchWriteCost + /* creation (CREATE at pc=0x20) */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* write code hash */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #0 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #1 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #2 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #3 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #4 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #5 */
		params.WitnessChunkReadCost + /* SLOAD in constructor */
		params.WitnessChunkWriteCost + /* SSTORE in constructor */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + params.WitnessBranchReadCost + params.WitnessBranchWriteCost + /* creation (CREATE at PC=0x121) */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* write code hash */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #0 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #1 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #2 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #3 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #4 */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* code chunk #5 */
		params.WitnessChunkReadCost + /* SLOAD in constructor */
		params.WitnessChunkWriteCost + /* SSTORE in constructor */
		params.WitnessChunkReadCost + params.WitnessChunkWriteCost + /* write code hash for tx creation */
		15*(params.WitnessChunkReadCost+params.WitnessChunkWriteCost) + /* code chunks #0..#14 */
		4844 /* execution costs */
	blockGasUsagesExpected := []uint64{
		txCost1*2 + txCost2,
		txCost1*2 + txCost2 + contractCreationCost + codeWithExtCodeCopyGas,
	}
	_, chain, _, proofs, statediffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 2, func(i int, gen *BlockGen) {
		gen.SetPoS()

		// TODO need to check that the tx cost provided is the exact amount used (no remaining left-over)
		tx, _ := types.SignTx(types.NewTransaction(uint64(i)*3, common.Address{byte(i), 2, 3}, big.NewInt(999), txCost1, big.NewInt(875000000), nil), signer, testKey)
		gen.AddTx(tx)
		tx, _ = types.SignTx(types.NewTransaction(uint64(i)*3+1, common.Address{}, big.NewInt(999), txCost1, big.NewInt(875000000), nil), signer, testKey)
		gen.AddTx(tx)
		tx, _ = types.SignTx(types.NewTransaction(uint64(i)*3+2, common.Address{}, big.NewInt(0), txCost2, big.NewInt(875000000), nil), signer, testKey)
		gen.AddTx(tx)

		// Add two contract creations in block #2
		if i == 1 {
			tx, _ = types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 6,
				Value:    big.NewInt(16),
				Gas:      3000000,
				GasPrice: big.NewInt(875000000),
				Data:     code,
			})
			gen.AddTx(tx)

			tx, _ = types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 7,
				Value:    big.NewInt(0),
				Gas:      3000000,
				GasPrice: big.NewInt(875000000),
				Data:     codeWithExtCodeCopy,
			})
			gen.AddTx(tx)
		}
	})

	// Check proof for both blocks
	err := verkle.Verify(proofs[0], gspec.ToBlock().Root().Bytes(), chain[0].Root().Bytes(), statediffs[0])
	if err != nil {
		t.Fatal(err)
	}
	err = verkle.Verify(proofs[1], chain[0].Root().Bytes(), chain[1].Root().Bytes(), statediffs[1])
	if err != nil {
		t.Fatal(err)
	}

	t.Log("verified verkle proof, inserting blocks into the chain")

	endnum, err := blockchain.InsertChain(chain)
	if err != nil {
		t.Fatalf("block %d imported with error: %v", endnum, err)
	}

	for i := 0; i < 2; i++ {
		b := blockchain.GetBlockByNumber(uint64(i) + 1)
		if b == nil {
			t.Fatalf("expected block %d to be present in chain", i+1)
		}
		if b.Hash() != chain[i].Hash() {
			t.Fatalf("block #%d not found at expected height", b.NumberU64())
		}
		if b.GasUsed() != blockGasUsagesExpected[i] {
			t.Fatalf("expected block #%d txs to use %d, got %d\n", b.NumberU64(), blockGasUsagesExpected[i], b.GasUsed())
		}
	}
}

func TestProcessParentBlockHash(t *testing.T) {
	// This test uses blocks where,
	// block 1 parent hash is 0x0100....
	// block 2 parent hash is 0x0200....
	// etc
	checkBlockHashes := func(statedb *state.StateDB) {
		statedb.SetNonce(params.HistoryStorageAddress, 1)
		statedb.SetCode(params.HistoryStorageAddress, params.HistoryStorageCode)
		// Process n blocks, from 1 .. num
		var num = 2
		for i := 1; i <= num; i++ {
			header := &types.Header{ParentHash: common.Hash{byte(i)}, Number: big.NewInt(int64(i)), Difficulty: new(big.Int)}
			vmContext := NewEVMBlockContext(header, nil, new(common.Address))
			evm := vm.NewEVM(vmContext, vm.TxContext{}, statedb, params.MergedTestChainConfig, vm.Config{})
			ProcessParentBlockHash(header.ParentHash, evm, statedb)
		}
		// Read block hashes for block 0 .. num-1
		for i := 0; i < num; i++ {
			have, want := getContractStoredBlockHash(statedb, uint64(i)), common.Hash{byte(i + 1)}
			if have != want {
				t.Errorf("block %d, have parent hash %v, want %v", i, have, want)
			}
		}
	}
	t.Run("MPT", func(t *testing.T) {
		statedb, _ := state.New(types.EmptyRootHash, state.NewDatabaseForTesting())
		checkBlockHashes(statedb)
	})
	t.Run("Verkle", func(t *testing.T) {
		db := rawdb.NewMemoryDatabase()
		cacheConfig := DefaultCacheConfigWithScheme(rawdb.PathScheme)
		cacheConfig.SnapshotLimit = 0
		triedb := triedb.NewDatabase(db, cacheConfig.triedbConfig(true))
		statedb, _ := state.New(types.EmptyVerkleHash, state.NewDatabase(triedb, nil))
		checkBlockHashes(statedb)
	})
}

// getContractStoredBlockHash is a utility method which reads the stored parent blockhash for block 'number'
func getContractStoredBlockHash(statedb *state.StateDB, number uint64) common.Hash {
	ringIndex := number % params.HistoryServeWindow
	var key common.Hash
	binary.BigEndian.PutUint64(key[24:], ringIndex)
	return statedb.GetState(params.HistoryStorageAddress, key)
}

// TestProcessVerkleInvalidContractCreation checks for several modes of contract creation failures
func TestProcessVerkleInvalidContractCreation(t *testing.T) {
	var (
		account1 = common.HexToAddress("0x687704DB07e902e9A8B3754031D168D46E3D586e")
		account2 = common.HexToAddress("0x6177843db3138ae69679A54b95cf345ED759450d")
		gspec    = verkleTestGenesis(testKaustinenLikeChainConfig)
	)
	// slightly modify it to suit the live txs from the testnet
	gspec.Alloc[account2] = types.Account{
		Balance: big.NewInt(1000000000000000000), // 1 ether
		Nonce:   1,
	}

	// Create two blocks that reproduce what is happening on kaustinen.
	// - The first block contains two failing contract creation transactions, that
	//   write to storage before they revert.
	//
	// - The second block contains a single failing contract creation transaction,
	//   that fails right off the bat.
	_, chain, _, _, statediffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 2, func(i int, gen *BlockGen) {
		gen.SetPoS()

		if i == 0 {
			for _, rlpData := range []string{
				// SSTORE at slot 41 and reverts
				"f8d48084479c2c18830186a08080b8806000602955bda3f9600060ca55600060695523b360006039551983576000601255b0620c2fde2c592ac2600060bc55e0ac6000606455a63e22600060e655eb607e605c5360a2605d5360c7605e53601d605f5360eb606053606b606153608e60625360816063536079606453601e60655360fc60665360b7606753608b60685383021e7ca0cc20c65a97d2e526b8ec0f4266e8b01bdcde43b9aeb59d8bfb44e8eb8119c109a07a8e751813ae1b2ce734960dbc39a4f954917d7822a2c5d1dca18b06c584131f",
				// SSTORE at slot 133 and reverts
				"02f8db83010f2c01843b9aca0084479c2c18830186a08080b88060006085553fad6000600a55600060565555600060b55506600060cf557f1b8b38183e7bd1bdfaa7123c5a4976e54cce0e42049d841411978fd3595e25c66019527f0538943712953cf08900aae40222a40b2d5a4ac8075ad8cf0870e2be307edbb96039527f9f3174ff85024747041ae7a611acffb987c513c088d90ab288aec080a0cd6ac65ce2cb0a912371f6b5a551ba8caffc22ec55ad4d3cb53de41d05eb77b6a02e0dfe8513dfa6ec7bfd7eda6f5c0dac21b39b982436045e128cec46cfd3f960",
				// this one is a simple transfer that succeeds, necessary to get the correct nonce in the other block.
				"f8e80184479c2c18830186a094bbbbde4ca27f83fc18aa108170547ff57675936a80b8807ff71f7c15faadb969a76a5f54a81a0117e1e743cb7f24e378eda28442ea4c6eb6604a527fb5409e5718d44e23bfffac926e5ea726067f772772e7e19446acba0c853f62f5606a526020608a536088608b536039608c536004608d5360af608e537f7f7675d9f210e0a61564e6d11e7cd75f5bc9009ac9f6b94a0fc63035441a83021e7ba04a4a172d81ebb02847829b76a387ac09749c8b65668083699abe20c887fb9efca07c5b1a990702ec7b31a5e8e3935cd9a77649f8c25a84131229e24ab61aec6093",
			} {
				var tx = new(types.Transaction)
				if err := tx.UnmarshalBinary(common.Hex2Bytes(rlpData)); err != nil {
					t.Fatal(err)
				}
				gen.AddTx(tx)
			}
		} else {
			var tx = new(types.Transaction)
			// immediately reverts
			if err := tx.UnmarshalBinary(common.Hex2Bytes("01f8d683010f2c028443ad7d0e830186a08080b880b00e7fa3c849dce891cce5fae8a4c46cbb313d6aec0c0ffe7863e05fb7b22d4807674c6055527ffbfcb0938f3e18f7937aa8fa95d880afebd5c4cec0d85186095832d03c85cf8a60755260ab60955360cf6096536066609753606e60985360fa609953609e609a53608e609b536024609c5360f6609d536072609e5360a4609fc080a08fc6f7101f292ff1fb0de8ac69c2d320fbb23bfe61cf327173786ea5daee6e37a044c42d91838ef06646294bf4f9835588aee66243b16a66a2da37641fae4c045f")); err != nil {
				t.Fatal(err)
			}
			gen.AddTx(tx)
		}
	})

	tx1ContractAddress := crypto.CreateAddress(account1, 0)
	tx1ContractStem := utils.GetTreeKey(tx1ContractAddress[:], uint256.NewInt(0), 105)
	tx1ContractStem = tx1ContractStem[:31]

	tx2ContractAddress := crypto.CreateAddress(account2, 1)
	tx2SlotKey := [32]byte{}
	tx2SlotKey[31] = 133
	tx2ContractStem := utils.StorageSlotKey(tx2ContractAddress[:], tx2SlotKey[:])
	tx2ContractStem = tx2ContractStem[:31]

	eip2935Stem := utils.GetTreeKey(params.HistoryStorageAddress[:], uint256.NewInt(0), 0)
	eip2935Stem = eip2935Stem[:31]

	// Check that the witness contains what we expect: a storage entry for each of the two contract
	// creations that failed: one at 133 for the 2nd tx, and one at 105 for the first tx.
	for _, stemStateDiff := range statediffs[0] {
		// Check that the slot number 133, which is overflowing the account header,
		// is present. Note that the offset of the 2nd group (first group after the
		// header) is skipping the first 64 values, hence we still have an offset
		// of 133, and not 133 - 64.
		if bytes.Equal(stemStateDiff.Stem[:], tx2ContractStem[:]) {
			for _, suffixDiff := range stemStateDiff.SuffixDiffs {
				if suffixDiff.Suffix != 133 {
					t.Fatalf("invalid suffix diff found for %x in block #1: %d\n", stemStateDiff.Stem, suffixDiff.Suffix)
				}
				if suffixDiff.CurrentValue != nil {
					t.Fatalf("invalid prestate value found for %x in block #1: %v != nil\n", stemStateDiff.Stem, suffixDiff.CurrentValue)
				}
				if suffixDiff.NewValue != nil {
					t.Fatalf("invalid poststate value found for %x in block #1: %v != nil\n", stemStateDiff.Stem, suffixDiff.NewValue)
				}
			}
		} else if bytes.Equal(stemStateDiff.Stem[:], tx1ContractStem) {
			// For this contract creation, check that only the account header and storage slot 41
			// are found in the witness.
			for _, suffixDiff := range stemStateDiff.SuffixDiffs {
				if suffixDiff.Suffix != 105 && suffixDiff.Suffix != 0 && suffixDiff.Suffix != 1 {
					t.Fatalf("invalid suffix diff found for %x in block #1: %d\n", stemStateDiff.Stem, suffixDiff.Suffix)
				}
			}
		} else if bytes.Equal(stemStateDiff.Stem[:], eip2935Stem) {
			// Check the eip 2935 group of leaves.
			// Check that only one leaf was accessed, and is present in the witness.
			if len(stemStateDiff.SuffixDiffs) > 1 {
				t.Fatalf("invalid suffix diff count found for BLOCKHASH contract: %d != 1", len(stemStateDiff.SuffixDiffs))
			}
			// Check that this leaf is the first storage slot
			if stemStateDiff.SuffixDiffs[0].Suffix != 64 {
				t.Fatalf("invalid suffix diff value found for BLOCKHASH contract: %d != 64", stemStateDiff.SuffixDiffs[0].Suffix)
			}
			// check that the prestate value is nil and that the poststate value isn't.
			if stemStateDiff.SuffixDiffs[0].CurrentValue != nil {
				t.Fatalf("non-nil current value in BLOCKHASH contract insert: %x", stemStateDiff.SuffixDiffs[0].CurrentValue)
			}
			if stemStateDiff.SuffixDiffs[0].NewValue == nil {
				t.Fatalf("nil new value in BLOCKHASH contract insert")
			}
			if *stemStateDiff.SuffixDiffs[0].NewValue != chain[0].Hash() {
				t.Fatalf("invalid BLOCKHASH value: %x != %x", *stemStateDiff.SuffixDiffs[0].NewValue, chain[0].Hash())
			}
		} else {
			// For all other entries present in the witness, check that nothing beyond
			// the account header was accessed.
			for _, suffixDiff := range stemStateDiff.SuffixDiffs {
				if suffixDiff.Suffix > 2 {
					t.Fatalf("invalid suffix diff found for %x in block #1: %d\n", stemStateDiff.Stem, suffixDiff.Suffix)
				}
			}
		}
	}

	// Check that no account has a value above 4 in the 2nd block as no storage nor
	// code should make it to the witness.
	for _, stemStateDiff := range statediffs[1] {
		for _, suffixDiff := range stemStateDiff.SuffixDiffs {
			if bytes.Equal(stemStateDiff.Stem[:], eip2935Stem) {
				// BLOCKHASH contract stem
				if len(stemStateDiff.SuffixDiffs) > 1 {
					t.Fatalf("invalid suffix diff count found for BLOCKHASH contract at block #2: %d != 1", len(stemStateDiff.SuffixDiffs))
				}
				if stemStateDiff.SuffixDiffs[0].Suffix != 65 {
					t.Fatalf("invalid suffix diff value found for BLOCKHASH contract at block #2: %d != 65", stemStateDiff.SuffixDiffs[0].Suffix)
				}
				if stemStateDiff.SuffixDiffs[0].NewValue == nil {
					t.Fatalf("missing post state value for BLOCKHASH contract at block #2")
				}
				if *stemStateDiff.SuffixDiffs[0].NewValue != common.HexToHash("0788c2c0f23aa07eb8bf76fe6c1ca9064a4821c1fd0af803913da488a58dba54") {
					t.Fatalf("invalid post state value for BLOCKHASH contract at block #2: 0788c2c0f23aa07eb8bf76fe6c1ca9064a4821c1fd0af803913da488a58dba54 != %x", (*stemStateDiff.SuffixDiffs[0].NewValue)[:])
				}
			} else if suffixDiff.Suffix > 4 {
				t.Fatalf("invalid suffix diff found for %x in block #2: %d\n", stemStateDiff.Stem, suffixDiff.Suffix)
			}
		}
	}
}

func verkleTestGenesis(config *params.ChainConfig) *Genesis {
	var (
		coinbase = common.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7")
		account1 = common.HexToAddress("0x687704DB07e902e9A8B3754031D168D46E3D586e")
		account2 = common.HexToAddress("0x6177843db3138ae69679A54b95cf345ED759450d")
	)
	return &Genesis{
		Config: config,
		Alloc: GenesisAlloc{
			coinbase: GenesisAccount{
				Balance: big.NewInt(1000000000000000000), // 1 ether
				Nonce:   0,
			},
			account1: GenesisAccount{
				Balance: big.NewInt(1000000000000000000), // 1 ether
				Nonce:   0,
			},
			account2: GenesisAccount{
				Balance: big.NewInt(1000000000000000000), // 1 ether
				Nonce:   3,
			},
			params.BeaconRootsAddress:        {Nonce: 1, Code: params.BeaconRootsCode, Balance: common.Big0},
			params.HistoryStorageAddress:     {Nonce: 1, Code: params.HistoryStorageCode, Balance: common.Big0},
			params.WithdrawalQueueAddress:    {Nonce: 1, Code: params.WithdrawalQueueCode, Balance: common.Big0},
			params.ConsolidationQueueAddress: {Nonce: 1, Code: params.ConsolidationQueueCode, Balance: common.Big0},
		},
	}
}

// TestProcessVerkleContractWithEmptyCode checks that the witness contains all valid
// entries, if the initcode returns an empty code.
func TestProcessVerkleContractWithEmptyCode(t *testing.T) {
	// The test txs were taken from a secondary testnet with chain id 69421
	config := *testKaustinenLikeChainConfig
	config.ChainID.SetUint64(69421)
	gspec := verkleTestGenesis(&config)

	_, chain, _, _, statediffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 1, func(i int, gen *BlockGen) {
		gen.SetPoS()
		var tx types.Transaction
		// a transaction that does some PUSH1n but returns a 0-sized contract
		txpayload := common.Hex2Bytes("02f8db83010f2d03843b9aca008444cf6a05830186a08080b8807fdfbbb59f2371a76485ce557fd0de00c298d3ede52a3eab56d35af674eb49ec5860335260826053536001605453604c60555360f3605653606060575360446058536096605953600c605a5360df605b5360f3605c5360fb605d53600c605e53609a605f53607f60605360fe606153603d60625360f4606353604b60645360cac001a0486b6dc55b8a311568b7239a2cae1d77e7446dba71df61eaafd53f73820a138fa010bd48a45e56133ac4c5645142c2ea48950d40eb35050e9510b6bad9e15c5865")
		if err := tx.UnmarshalBinary(txpayload); err != nil {
			t.Fatal(err)
		}
		gen.AddTx(&tx)
	})

	eip2935Stem := utils.GetTreeKey(params.HistoryStorageAddress[:], uint256.NewInt(0), 0)
	eip2935Stem = eip2935Stem[:31]

	for _, stemStateDiff := range statediffs[0] {
		// Handle the case of the history contract: make sure only the correct
		// slots are added to the witness.
		if bytes.Equal(stemStateDiff.Stem[:], eip2935Stem) {
			// BLOCKHASH contract stem
			if len(stemStateDiff.SuffixDiffs) > 1 {
				t.Fatalf("invalid suffix diff count found for BLOCKHASH contract: %d != 1", len(stemStateDiff.SuffixDiffs))
			}
			if stemStateDiff.SuffixDiffs[0].Suffix != 64 {
				t.Fatalf("invalid suffix diff value found for BLOCKHASH contract: %d != 64", stemStateDiff.SuffixDiffs[0].Suffix)
			}
			// check that the "current value" is nil and that the new value isn't.
			if stemStateDiff.SuffixDiffs[0].CurrentValue != nil {
				t.Fatalf("non-nil current value in BLOCKHASH contract insert: %x", stemStateDiff.SuffixDiffs[0].CurrentValue)
			}
			if stemStateDiff.SuffixDiffs[0].NewValue == nil {
				t.Fatalf("nil new value in BLOCKHASH contract insert")
			}
			if *stemStateDiff.SuffixDiffs[0].NewValue != chain[0].Hash() {
				t.Fatalf("invalid BLOCKHASH value: %x != %x", *stemStateDiff.SuffixDiffs[0].NewValue, chain[0].Hash())
			}
		} else {
			for _, suffixDiff := range stemStateDiff.SuffixDiffs {
				if suffixDiff.Suffix > 2 {
					// if d8898012c484fb48610ecb7963886339207dab004bce968b007b616ffa18e0 shows up, it means that the PUSHn
					// in the transaction above added entries into the witness, when they should not have since they are
					// part of a contract deployment.
					t.Fatalf("invalid suffix diff found for %x in block #1: %d\n", stemStateDiff.Stem, suffixDiff.Suffix)
				}
			}
		}
	}
}

// TestProcessVerkleExtCodeHashOpcode verifies that calling EXTCODEHASH on another
// deployed contract, creates all the right entries in the witness.
func TestProcessVerkleExtCodeHashOpcode(t *testing.T) {
	// The test txs were taken from a secondary testnet with chain id 69421
	config := *testKaustinenLikeChainConfig
	config.ChainID.SetUint64(69421)

	var (
		signer     = types.LatestSigner(&config)
		testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
		gspec      = verkleTestGenesis(&config)
	)
	dummyContract := []byte{
		byte(vm.PUSH1), 2,
		byte(vm.PUSH1), 12,
		byte(vm.PUSH1), 0x00,
		byte(vm.CODECOPY),

		byte(vm.PUSH1), 2,
		byte(vm.PUSH1), 0x00,
		byte(vm.RETURN),

		byte(vm.PUSH1), 42,
	}
	deployer := crypto.PubkeyToAddress(testKey.PublicKey)
	dummyContractAddr := crypto.CreateAddress(deployer, 0)

	// contract that calls EXTCODEHASH on the dummy contract
	extCodeHashContract := []byte{
		byte(vm.PUSH1), 22,
		byte(vm.PUSH1), 12,
		byte(vm.PUSH1), 0x00,
		byte(vm.CODECOPY),

		byte(vm.PUSH1), 22,
		byte(vm.PUSH1), 0x00,
		byte(vm.RETURN),

		byte(vm.PUSH20),
		0x3a, 0x22, 0x0f, 0x35, 0x12, 0x52, 0x08, 0x9d, 0x38, 0x5b, 0x29, 0xbe, 0xca, 0x14, 0xe2, 0x7f, 0x20, 0x4c, 0x29, 0x6a,
		byte(vm.EXTCODEHASH),
	}
	extCodeHashContractAddr := crypto.CreateAddress(deployer, 1)

	_, _, _, _, statediffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 2, func(i int, gen *BlockGen) {
		gen.SetPoS()

		if i == 0 {
			// Create dummy contract.
			tx, _ := types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 0,
				Value:    big.NewInt(0),
				Gas:      100_000,
				GasPrice: big.NewInt(875000000),
				Data:     dummyContract,
			})
			gen.AddTx(tx)

			// Create contract with EXTCODEHASH opcode.
			tx, _ = types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 1,
				Value:    big.NewInt(0),
				Gas:      100_000,
				GasPrice: big.NewInt(875000000),
				Data:     extCodeHashContract})
			gen.AddTx(tx)
		} else {
			tx, _ := types.SignTx(types.NewTransaction(2, extCodeHashContractAddr, big.NewInt(0), 100_000, big.NewInt(875000000), nil), signer, testKey)
			gen.AddTx(tx)
		}
	})

	contractKeccakTreeKey := utils.CodeHashKey(dummyContractAddr[:])

	var stateDiffIdx = -1
	for i, stemStateDiff := range statediffs[1] {
		if bytes.Equal(stemStateDiff.Stem[:], contractKeccakTreeKey[:31]) {
			stateDiffIdx = i
			break
		}
	}
	if stateDiffIdx == -1 {
		t.Fatalf("no state diff found for stem")
	}

	codeHashStateDiff := statediffs[1][stateDiffIdx].SuffixDiffs[0]
	// Check location of code hash was accessed
	if codeHashStateDiff.Suffix != utils.CodeHashLeafKey {
		t.Fatalf("code hash invalid suffix")
	}
	// check the code hash wasn't present in the prestate, as
	// the contract was deployed in this block.
	if codeHashStateDiff.CurrentValue == nil {
		t.Fatalf("codeHash.CurrentValue must not be empty")
	}
	// check the poststate value corresponds to the code hash
	// of the deployed contract.
	expCodeHash := crypto.Keccak256Hash(dummyContract[12:])
	if *codeHashStateDiff.CurrentValue != expCodeHash {
		t.Fatalf("codeHash.CurrentValue unexpected code hash")
	}
	if codeHashStateDiff.NewValue != nil {
		t.Fatalf("codeHash.NewValue must be nil")
	}
}

// TestProcessVerkleBalanceOpcode checks that calling balance
// on another contract will add the correct entries to the witness.
func TestProcessVerkleBalanceOpcode(t *testing.T) {
	// The test txs were taken from a secondary testnet with chain id 69421
	config := *testKaustinenLikeChainConfig
	config.ChainID.SetUint64(69421)

	var (
		signer     = types.LatestSigner(&config)
		testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
		account2   = common.HexToAddress("0x6177843db3138ae69679A54b95cf345ED759450d")
		gspec      = verkleTestGenesis(&config)
	)
	_, _, _, _, statediffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 1, func(i int, gen *BlockGen) {
		gen.SetPoS()
		txData := slices.Concat(
			[]byte{byte(vm.PUSH20)},
			common.HexToAddress("0x6177843db3138ae69679A54b95cf345ED759450d").Bytes(),
			[]byte{byte(vm.BALANCE)})

		tx, _ := types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 0,
			Value:    big.NewInt(0),
			Gas:      100_000,
			GasPrice: big.NewInt(875000000),
			Data:     txData})
		gen.AddTx(tx)
	})

	account2BalanceTreeKey := utils.BasicDataKey(account2[:])

	var stateDiffIdx = -1
	for i, stemStateDiff := range statediffs[0] {
		if bytes.Equal(stemStateDiff.Stem[:], account2BalanceTreeKey[:31]) {
			stateDiffIdx = i
			break
		}
	}
	if stateDiffIdx == -1 {
		t.Fatalf("no state diff found for stem")
	}

	var zero [32]byte
	balanceStateDiff := statediffs[0][stateDiffIdx].SuffixDiffs[0]
	if balanceStateDiff.Suffix != utils.BasicDataLeafKey {
		t.Fatalf("invalid suffix diff")
	}
	// check the prestate balance wasn't 0 or missing
	if balanceStateDiff.CurrentValue == nil || *balanceStateDiff.CurrentValue == zero {
		t.Fatalf("invalid current value %v", *balanceStateDiff.CurrentValue)
	}
	// check that the poststate witness value for the balance is nil,
	// meaning that it didn't get updated.
	if balanceStateDiff.NewValue != nil {
		t.Fatalf("invalid new value")
	}
}

// TestProcessVerkleSelfDestructInSeparateTx controls the contents of the witness after
// a non-eip6780-compliant selfdestruct occurs.
func TestProcessVerkleSelfDestructInSeparateTx(t *testing.T) {
	// The test txs were taken from a secondary testnet with chain id 69421
	config := *testKaustinenLikeChainConfig
	config.ChainID.SetUint64(69421)

	var (
		signer     = types.LatestSigner(&config)
		testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
		account2   = common.HexToAddress("0x6177843db3138ae69679A54b95cf345ED759450d")
		gspec      = verkleTestGenesis(&config)
	)

	// runtime code: selfdestruct ( 0x6177843db3138ae69679A54b95cf345ED759450d )
	runtimeCode := slices.Concat(
		[]byte{byte(vm.PUSH20)},
		account2.Bytes(),
		[]byte{byte(vm.SELFDESTRUCT)})

	//The goal of this test is to test SELFDESTRUCT that happens in a contract
	// execution which is created in a previous transaction.
	selfDestructContract := slices.Concat([]byte{
		byte(vm.PUSH1), byte(len(runtimeCode)),
		byte(vm.PUSH1), 12,
		byte(vm.PUSH1), 0x00,
		byte(vm.CODECOPY), // Codecopy( to-offset: 0, code offset: 12, length: 22 )

		byte(vm.PUSH1), byte(len(runtimeCode)),
		byte(vm.PUSH1), 0x00,
		byte(vm.RETURN), // Return ( 0 : len(runtimecode)
	},
		runtimeCode)

	deployer := crypto.PubkeyToAddress(testKey.PublicKey)
	contract := crypto.CreateAddress(deployer, 0)

	_, _, _, _, statediffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 2, func(i int, gen *BlockGen) {
		gen.SetPoS()

		if i == 0 {
			// Create selfdestruct contract, sending 42 wei.
			tx, _ := types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 0,
				Value:    big.NewInt(42),
				Gas:      100_000,
				GasPrice: big.NewInt(875000000),
				Data:     selfDestructContract,
			})
			gen.AddTx(tx)
		} else {
			// Call it.
			tx, _ := types.SignTx(types.NewTransaction(1, contract, big.NewInt(0), 100_000, big.NewInt(875000000), nil), signer, testKey)
			gen.AddTx(tx)
		}
	})

	var zero [32]byte
	{ // Check self-destructed contract in the witness
		selfDestructContractTreeKey := utils.CodeHashKey(contract[:])

		var stateDiffIdx = -1
		for i, stemStateDiff := range statediffs[1] {
			if bytes.Equal(stemStateDiff.Stem[:], selfDestructContractTreeKey[:31]) {
				stateDiffIdx = i
				break
			}
		}
		if stateDiffIdx == -1 {
			t.Fatalf("no state diff found for stem")
		}

		balanceStateDiff := statediffs[1][stateDiffIdx].SuffixDiffs[0]
		if balanceStateDiff.Suffix != utils.BasicDataLeafKey {
			t.Fatalf("balance invalid suffix")
		}

		// The original balance was 42.
		var oldBalance [16]byte
		oldBalance[15] = 42
		if !bytes.Equal((*balanceStateDiff.CurrentValue)[utils.BasicDataBalanceOffset:], oldBalance[:]) {
			t.Fatalf("the pre-state balance before self-destruct must be %x, got %x", oldBalance, *balanceStateDiff.CurrentValue)
		}

		// The new balance must be 0.
		if !bytes.Equal((*balanceStateDiff.NewValue)[utils.BasicDataBalanceOffset:], zero[utils.BasicDataBalanceOffset:]) {
			t.Fatalf("the post-state balance after self-destruct must be 0")
		}
	}
	{ // Check self-destructed target in the witness.
		selfDestructTargetTreeKey := utils.CodeHashKey(account2[:])

		var stateDiffIdx = -1
		for i, stemStateDiff := range statediffs[1] {
			if bytes.Equal(stemStateDiff.Stem[:], selfDestructTargetTreeKey[:31]) {
				stateDiffIdx = i
				break
			}
		}
		if stateDiffIdx == -1 {
			t.Fatalf("no state diff found for stem")
		}

		balanceStateDiff := statediffs[1][stateDiffIdx].SuffixDiffs[0]
		if balanceStateDiff.Suffix != utils.BasicDataLeafKey {
			t.Fatalf("balance invalid suffix")
		}
		if balanceStateDiff.CurrentValue == nil {
			t.Fatalf("codeHash.CurrentValue must not be empty")
		}
		if balanceStateDiff.NewValue == nil {
			t.Fatalf("codeHash.NewValue must not be empty")
		}
		preStateBalance := binary.BigEndian.Uint64(balanceStateDiff.CurrentValue[utils.BasicDataBalanceOffset+8:])
		postStateBalance := binary.BigEndian.Uint64(balanceStateDiff.NewValue[utils.BasicDataBalanceOffset+8:])
		if postStateBalance-preStateBalance != 42 {
			t.Fatalf("the post-state balance after self-destruct must be 42, got %d-%d=%d", postStateBalance, preStateBalance, postStateBalance-preStateBalance)
		}
	}
}

// TestProcessVerkleSelfDestructInSeparateTx controls the contents of the witness after
// a eip6780-compliant selfdestruct occurs.
func TestProcessVerkleSelfDestructInSameTx(t *testing.T) {
	// The test txs were taken from a secondary testnet with chain id 69421
	config := *testKaustinenLikeChainConfig
	config.ChainID.SetUint64(69421)

	var (
		signer     = types.LatestSigner(&config)
		testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
		account2   = common.HexToAddress("0x6177843db3138ae69679A54b95cf345ED759450d")
		gspec      = verkleTestGenesis(&config)
	)

	// The goal of this test is to test SELFDESTRUCT that happens in a contract
	// execution which is created in **the same** transaction sending the remaining
	// balance to an external (i.e: not itself) account.

	selfDestructContract := slices.Concat(
		[]byte{byte(vm.PUSH20)},
		account2.Bytes(),
		[]byte{byte(vm.SELFDESTRUCT)})
	deployer := crypto.PubkeyToAddress(testKey.PublicKey)
	contract := crypto.CreateAddress(deployer, 0)

	_, _, _, _, statediffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 1, func(i int, gen *BlockGen) {
		gen.SetPoS()
		tx, _ := types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 0,
			Value:    big.NewInt(42),
			Gas:      100_000,
			GasPrice: big.NewInt(875000000),
			Data:     selfDestructContract,
		})
		gen.AddTx(tx)
	})

	{ // Check self-destructed contract in the witness
		selfDestructContractTreeKey := utils.CodeHashKey(contract[:])

		var stateDiffIdx = -1
		for i, stemStateDiff := range statediffs[0] {
			if bytes.Equal(stemStateDiff.Stem[:], selfDestructContractTreeKey[:31]) {
				stateDiffIdx = i
				break
			}
		}
		if stateDiffIdx == -1 {
			t.Fatalf("no state diff found for stem")
		}

		balanceStateDiff := statediffs[0][stateDiffIdx].SuffixDiffs[0]
		if balanceStateDiff.Suffix != utils.BasicDataLeafKey {
			t.Fatalf("balance invalid suffix")
		}

		if balanceStateDiff.CurrentValue != nil {
			t.Fatalf("the pre-state balance before must be nil, since the contract didn't exist")
		}

		if balanceStateDiff.NewValue != nil {
			t.Fatalf("the post-state balance after self-destruct must be nil since the contract shouldn't be created at all")
		}
	}
	{ // Check self-destructed target in the witness.
		selfDestructTargetTreeKey := utils.CodeHashKey(account2[:])

		var stateDiffIdx = -1
		for i, stemStateDiff := range statediffs[0] {
			if bytes.Equal(stemStateDiff.Stem[:], selfDestructTargetTreeKey[:31]) {
				stateDiffIdx = i
				break
			}
		}
		if stateDiffIdx == -1 {
			t.Fatalf("no state diff found for stem")
		}

		balanceStateDiff := statediffs[0][stateDiffIdx].SuffixDiffs[0]
		if balanceStateDiff.Suffix != utils.BasicDataLeafKey {
			t.Fatalf("balance invalid suffix")
		}
		if balanceStateDiff.CurrentValue == nil {
			t.Fatalf("codeHash.CurrentValue must not be empty")
		}
		if balanceStateDiff.NewValue == nil {
			t.Fatalf("codeHash.NewValue must not be empty")
		}
		preStateBalance := binary.BigEndian.Uint64(balanceStateDiff.CurrentValue[utils.BasicDataBalanceOffset+8:])
		postStateBalance := binary.BigEndian.Uint64(balanceStateDiff.NewValue[utils.BasicDataBalanceOffset+8:])
		if postStateBalance-preStateBalance != 42 {
			t.Fatalf("the post-state balance after self-destruct must be 42. got %d", postStateBalance)
		}
	}
}

// TestProcessVerkleSelfDestructInSeparateTxWithSelfBeneficiary checks the content of the witness
// if a selfdestruct occurs in a different tx than the one that created it, but the beneficiary
// is the selfdestructed account.
func TestProcessVerkleSelfDestructInSeparateTxWithSelfBeneficiary(t *testing.T) {
	// The test txs were taken from a secondary testnet with chain id 69421
	config := *testKaustinenLikeChainConfig
	config.ChainID.SetUint64(69421)

	var (
		signer     = types.LatestSigner(&config)
		testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
		gspec      = verkleTestGenesis(&config)
	)
	// The goal of this test is to test SELFDESTRUCT that happens in a contract
	// execution which is created in a *previous* transaction sending the remaining
	// balance to itself.
	selfDestructContract := []byte{
		byte(vm.PUSH1), 2, // PUSH1 2
		byte(vm.PUSH1), 10, // PUSH1 12
		byte(vm.PUSH0),    // PUSH0
		byte(vm.CODECOPY), // Codecopy ( to offset 0, code@offset: 10, length: 2)

		byte(vm.PUSH1), 22,
		byte(vm.PUSH0),
		byte(vm.RETURN), // RETURN( memory[0:2] )

		// Deployed code
		byte(vm.ADDRESS),
		byte(vm.SELFDESTRUCT),
	}
	deployer := crypto.PubkeyToAddress(testKey.PublicKey)
	contract := crypto.CreateAddress(deployer, 0)

	_, _, _, _, statediffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 2, func(i int, gen *BlockGen) {
		gen.SetPoS()
		if i == 0 {
			// Create self-destruct contract, sending 42 wei.
			tx, _ := types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 0,
				Value:    big.NewInt(42),
				Gas:      100_000,
				GasPrice: big.NewInt(875000000),
				Data:     selfDestructContract,
			})
			gen.AddTx(tx)
		} else {
			// Call it.
			tx, _ := types.SignTx(types.NewTransaction(1, contract, big.NewInt(0), 100_000, big.NewInt(875000000), nil), signer, testKey)
			gen.AddTx(tx)
		}
	})

	{
		// Check self-destructed contract in the witness.
		// The way 6780 is implemented today, it always SubBalance from the self-destructed contract, and AddBalance
		// to the beneficiary. In this case both addresses are the same, thus this might be optimizable from a gas
		// perspective. But until that happens, we need to honor this "balance reading" adding it to the witness.

		selfDestructContractTreeKey := utils.CodeHashKey(contract[:])

		var stateDiffIdx = -1
		for i, stemStateDiff := range statediffs[1] {
			if bytes.Equal(stemStateDiff.Stem[:], selfDestructContractTreeKey[:31]) {
				stateDiffIdx = i
				break
			}
		}
		if stateDiffIdx == -1 {
			t.Fatal("no state diff found for stem")
		}

		balanceStateDiff := statediffs[1][stateDiffIdx].SuffixDiffs[0]
		if balanceStateDiff.Suffix != utils.BasicDataLeafKey {
			t.Fatal("balance invalid suffix")
		}

		// The original balance was 42.
		var oldBalance [16]byte
		oldBalance[15] = 42
		if !bytes.Equal((*balanceStateDiff.CurrentValue)[utils.BasicDataBalanceOffset:], oldBalance[:]) {
			t.Fatal("the pre-state balance before self-destruct must be 42")
		}

		// Note that the SubBalance+AddBalance net effect is a 0 change, so NewValue
		// must be nil.
		if balanceStateDiff.NewValue != nil {
			t.Fatal("the post-state balance after self-destruct must be empty")
		}
	}
}

// TestProcessVerkleSelfDestructInSameTxWithSelfBeneficiary checks the content of the witness
// if a selfdestruct occurs in the same tx as the one that created it, but the beneficiary
// is the selfdestructed account.
func TestProcessVerkleSelfDestructInSameTxWithSelfBeneficiary(t *testing.T) {
	// The test txs were taken from a secondary testnet with chain id 69421
	config := *testKaustinenLikeChainConfig
	config.ChainID.SetUint64(69421)

	var (
		signer     = types.LatestSigner(&config)
		testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
		gspec      = verkleTestGenesis(&config)
		deployer   = crypto.PubkeyToAddress(testKey.PublicKey)
		contract   = crypto.CreateAddress(deployer, 0)
	)

	// The goal of this test is to test SELFDESTRUCT that happens while executing
	// the init code of a contract creation, that occurs in **the same** transaction.
	// The balance is sent to itself.
	t.Logf("Contract: %v", contract.String())

	selfDestructContract := []byte{byte(vm.ADDRESS), byte(vm.SELFDESTRUCT)}

	_, _, _, _, stateDiffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 1, func(i int, gen *BlockGen) {
		gen.SetPoS()
		tx, _ := types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 0,
			Value:    big.NewInt(42),
			Gas:      100_000,
			GasPrice: big.NewInt(875000000),
			Data:     selfDestructContract,
		})
		gen.AddTx(tx)
	})
	stateDiff := stateDiffs[0] // state difference of block 1

	{ // Check self-destructed contract in the witness
		selfDestructContractTreeKey := utils.CodeHashKey(contract[:])

		var stateDiffIdx = -1
		for i, stemStateDiff := range stateDiff {
			if bytes.Equal(stemStateDiff.Stem[:], selfDestructContractTreeKey[:31]) {
				stateDiffIdx = i
				break
			}
		}
		if stateDiffIdx == -1 {
			t.Fatal("no state diff found for stem")
		}
		balanceStateDiff := stateDiff[stateDiffIdx].SuffixDiffs[0]
		if balanceStateDiff.Suffix != utils.BasicDataLeafKey {
			t.Fatal("balance invalid suffix")
		}
		if balanceStateDiff.CurrentValue != nil {
			t.Fatal("the pre-state balance before must be nil, since the contract didn't exist")
		}
		// Ensure that the value is burnt, and therefore that the balance of the self-destructed
		// contract isn't modified (it should remain missing from the state)
		if balanceStateDiff.NewValue != nil {
			t.Fatal("the post-state balance after self-destruct must be nil since the contract shouldn't be created at all")
		}
	}
}

// TestProcessVerkleSelfDestructInSameTxWithSelfBeneficiaryAndPrefundedAccount checks the
// content of the witness if a selfdestruct occurs in the same tx as the one that created it,
// it, but the beneficiary is the selfdestructed account. The difference with the test above,
// is that the created account is prefunded and so the final value should be 0.
func TestProcessVerkleSelfDestructInSameTxWithSelfBeneficiaryAndPrefundedAccount(t *testing.T) {
	// The test txs were taken from a secondary testnet with chain id 69421
	config := *testKaustinenLikeChainConfig
	config.ChainID.SetUint64(69421)

	var (
		signer     = types.LatestSigner(&config)
		testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
		gspec      = verkleTestGenesis(&config)
		deployer   = crypto.PubkeyToAddress(testKey.PublicKey)
		contract   = crypto.CreateAddress(deployer, 0)
	)
	// Prefund the account, at an address that the contract will be deployed at,
	// before it selfdestrucs. We can therefore check that the account itseld is
	// NOT destroyed, which is what the currrent version of the spec requires.
	// TODO(gballet) revisit after the spec has been modified.
	gspec.Alloc[contract] = types.Account{
		Balance: big.NewInt(100),
	}

	selfDestructContract := []byte{byte(vm.ADDRESS), byte(vm.SELFDESTRUCT)}

	_, _, _, _, stateDiffs := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 1, func(i int, gen *BlockGen) {
		gen.SetPoS()
		tx, _ := types.SignNewTx(testKey, signer, &types.LegacyTx{Nonce: 0,
			Value:    big.NewInt(42),
			Gas:      100_000,
			GasPrice: big.NewInt(875000000),
			Data:     selfDestructContract,
		})
		gen.AddTx(tx)
	})
	stateDiff := stateDiffs[0] // state difference of block 1

	{ // Check self-destructed contract in the witness
		selfDestructContractTreeKey := utils.CodeHashKey(contract[:])

		var stateDiffIdx = -1
		for i, stemStateDiff := range stateDiff {
			if bytes.Equal(stemStateDiff.Stem[:], selfDestructContractTreeKey[:31]) {
				stateDiffIdx = i
				break
			}
		}
		if stateDiffIdx == -1 {
			t.Fatal("no state diff found for stem")
		}
		balanceStateDiff := stateDiff[stateDiffIdx].SuffixDiffs[0]
		if balanceStateDiff.Suffix != utils.BasicDataLeafKey {
			t.Fatal("balance invalid suffix")
		}
		expected, _ := hex.DecodeString("0000000000000000000000000000000000000000000000000000000000000064")
		if balanceStateDiff.CurrentValue == nil || !bytes.Equal(balanceStateDiff.CurrentValue[:], expected) {
			t.Fatalf("incorrect prestate balance: %x != %x", *balanceStateDiff.CurrentValue, expected)
		}
		// Ensure that the value is burnt, and therefore that the balance of the self-destructed
		// contract isn't modified (it should remain missing from the state)
		expected = make([]byte, 32)
		if balanceStateDiff.NewValue == nil {
			t.Fatal("incorrect nil poststate balance")
		}
		if !bytes.Equal(balanceStateDiff.NewValue[:], expected[:]) {
			t.Fatalf("incorrect poststate balance: %x != %x", *balanceStateDiff.NewValue, expected[:])
		}
	}
}