plugeth-statediff/builder_test.go

// Copyright 2019 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 statediff_test

import (
	"encoding/hex"
	"testing"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/rlp"
	"github.com/holiman/uint256"

	statediff "github.com/cerc-io/plugeth-statediff"
	"github.com/cerc-io/plugeth-statediff/indexer/ipld"
	"github.com/cerc-io/plugeth-statediff/indexer/shared"
	"github.com/cerc-io/plugeth-statediff/test_helpers"
	sdtypes "github.com/cerc-io/plugeth-statediff/types"
	"github.com/cerc-io/plugeth-statediff/utils"
)

var (
	contractLeafKey                                        []byte
	emptyDiffs                                             []sdtypes.StateLeafNode
	emptyStorage                                           []sdtypes.StorageLeafNode
	block0, block1, block2, block3, block4, block5, block6 *types.Block
	builder                                                statediff.Builder
	minerAddress                                           = common.HexToAddress("0x0")
	minerLeafKey                                           = test_helpers.AddressToLeafKey(minerAddress)

	slot0 = common.HexToHash("0")
	slot1 = common.HexToHash("1")
	slot2 = common.HexToHash("2")
	slot3 = common.HexToHash("3")

	slot0StorageKey = crypto.Keccak256Hash(slot0[:])
	slot1StorageKey = crypto.Keccak256Hash(slot1[:])
	slot2StorageKey = crypto.Keccak256Hash(slot2[:])
	slot3StorageKey = crypto.Keccak256Hash(slot3[:])

	slot0StorageValue, _ = hex.DecodeString("94703c4b2bd70c169f5717101caee543299fc946c7") // prefixed AccountAddr1
	slot1StorageValue, _ = hex.DecodeString("01")
	slot2StorageValue, _ = hex.DecodeString("09")
	slot3StorageValue, _ = hex.DecodeString("03")

	slot0StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("390decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
		slot0StorageValue,
	})
	slot1StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("310e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6"),
		slot1StorageValue,
	})
	slot2StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("305787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace"),
		slot2StorageValue,
	})
	slot3StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("32575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b"),
		slot3StorageValue,
	})
	contractAccountAtBlock2 = &types.StateAccount{
		Nonce:    1,
		Balance:  uint256.NewInt(0),
		CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
		Root:     crypto.Keccak256Hash(block2StorageBranchRootNode),
	}
	contractAccountAtBlock2RLP, _      = rlp.EncodeToBytes(contractAccountAtBlock2)
	contractAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
		contractAccountAtBlock2RLP,
	})
	contractAccountAtBlock3 = &types.StateAccount{
		Nonce:    1,
		Balance:  uint256.NewInt(0),
		CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
		Root:     crypto.Keccak256Hash(block3StorageBranchRootNode),
	}
	contractAccountAtBlock3RLP, _      = rlp.EncodeToBytes(contractAccountAtBlock3)
	contractAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
		contractAccountAtBlock3RLP,
	})
	contractAccountAtBlock4 = &types.StateAccount{
		Nonce:    1,
		Balance:  uint256.NewInt(0),
		CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
		Root:     crypto.Keccak256Hash(block4StorageBranchRootNode),
	}
	contractAccountAtBlock4RLP, _      = rlp.EncodeToBytes(contractAccountAtBlock4)
	contractAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
		contractAccountAtBlock4RLP,
	})
	contractAccountAtBlock5 = &types.StateAccount{
		Nonce:    1,
		Balance:  uint256.NewInt(0),
		CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
		Root:     crypto.Keccak256Hash(block5StorageBranchRootNode),
	}
	contractAccountAtBlock5RLP, _      = rlp.EncodeToBytes(contractAccountAtBlock5)
	contractAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45"),
		contractAccountAtBlock5RLP,
	})
	minerAccountAtBlock1 = &types.StateAccount{
		Nonce:    0,
		Balance:  uint256.NewInt(2000002625000000000),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	minerAccountAtBlock1RLP, _      = rlp.EncodeToBytes(minerAccountAtBlock1)
	minerAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"),
		minerAccountAtBlock1RLP,
	})
	minerAccountAtBlock2 = &types.StateAccount{
		Nonce:    0,
		Balance:  uint256.NewInt(4000111203461610525),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	minerAccountAtBlock2RLP, _      = rlp.EncodeToBytes(minerAccountAtBlock2)
	minerAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"),
		minerAccountAtBlock2RLP,
	})

	account1AtBlock1 = &types.StateAccount{
		Nonce:    0,
		Balance:  test_helpers.Block1Account1Balance,
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account1AtBlock1RLP, _      = rlp.EncodeToBytes(account1AtBlock1)
	account1AtBlock1LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
		account1AtBlock1RLP,
	})
	account1AtBlock2 = &types.StateAccount{
		Nonce:    2,
		Balance:  uint256.NewInt(999555797000009000),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account1AtBlock2RLP, _      = rlp.EncodeToBytes(account1AtBlock2)
	account1AtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
		account1AtBlock2RLP,
	})
	account1AtBlock5 = &types.StateAccount{
		Nonce:    2,
		Balance:  uint256.NewInt(2999586469962854280),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account1AtBlock5RLP, _      = rlp.EncodeToBytes(account1AtBlock5)
	account1AtBlock5LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
		account1AtBlock5RLP,
	})
	account1AtBlock6 = &types.StateAccount{
		Nonce:    3,
		Balance:  uint256.NewInt(2999557977962854280),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account1AtBlock6RLP, _      = rlp.EncodeToBytes(account1AtBlock6)
	account1AtBlock6LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
		account1AtBlock6RLP,
	})
	account2AtBlock2 = &types.StateAccount{
		Nonce:    0,
		Balance:  uint256.NewInt(1000),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account2AtBlock2RLP, _      = rlp.EncodeToBytes(account2AtBlock2)
	account2AtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
		account2AtBlock2RLP,
	})
	account2AtBlock3 = &types.StateAccount{
		Nonce:    0,
		Balance:  uint256.NewInt(2000013574009435976),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account2AtBlock3RLP, _      = rlp.EncodeToBytes(account2AtBlock3)
	account2AtBlock3LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
		account2AtBlock3RLP,
	})
	account2AtBlock4 = &types.StateAccount{
		Nonce:    0,
		Balance:  uint256.NewInt(4000048088163070348),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account2AtBlock4RLP, _      = rlp.EncodeToBytes(account2AtBlock4)
	account2AtBlock4LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
		account2AtBlock4RLP,
	})
	account2AtBlock6 = &types.StateAccount{
		Nonce:    0,
		Balance:  uint256.NewInt(6000063258066544204),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account2AtBlock6RLP, _      = rlp.EncodeToBytes(account2AtBlock6)
	account2AtBlock6LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45"),
		account2AtBlock6RLP,
	})
	bankAccountAtBlock0 = &types.StateAccount{
		Nonce:    0,
		Balance:  uint256.MustFromBig(test_helpers.TestBankFunds),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock0RLP, _      = rlp.EncodeToBytes(bankAccountAtBlock0)
	bankAccountAtBlock0LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("2000bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock0RLP,
	})

	block1BankBalance   = test_helpers.TestBankFunds.Int64() - test_helpers.BalanceChange10000 - test_helpers.GasFees
	bankAccountAtBlock1 = &types.StateAccount{
		Nonce:    1,
		Balance:  uint256.NewInt(uint64(block1BankBalance)),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock1RLP, _      = rlp.EncodeToBytes(bankAccountAtBlock1)
	bankAccountAtBlock1LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock1RLP,
	})

	block2BankBalance   = block1BankBalance - test_helpers.BalanceChange1Ether - test_helpers.GasFees
	bankAccountAtBlock2 = &types.StateAccount{
		Nonce:    2,
		Balance:  uint256.NewInt(uint64(block2BankBalance)),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock2RLP, _      = rlp.EncodeToBytes(bankAccountAtBlock2)
	bankAccountAtBlock2LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock2RLP,
	})
	bankAccountAtBlock3 = &types.StateAccount{
		Nonce:    3,
		Balance:  uint256.NewInt(999914255999990000),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock3RLP, _      = rlp.EncodeToBytes(bankAccountAtBlock3)
	bankAccountAtBlock3LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock3RLP,
	})
	bankAccountAtBlock4 = &types.StateAccount{
		Nonce:    6,
		Balance:  uint256.NewInt(999826859999990000),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock4RLP, _      = rlp.EncodeToBytes(&bankAccountAtBlock4)
	bankAccountAtBlock4LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock4RLP,
	})
	bankAccountAtBlock5 = &types.StateAccount{
		Nonce:    8,
		Balance:  uint256.NewInt(999761283999990000),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock5RLP, _      = rlp.EncodeToBytes(bankAccountAtBlock5)
	bankAccountAtBlock5LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock5RLP,
	})

	block1BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256(bankAccountAtBlock1LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(minerAccountAtBlock1LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(account1AtBlock1LeafNode),
		[]byte{},
		[]byte{},
	})
	block2BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256(bankAccountAtBlock2LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(minerAccountAtBlock2LeafNode),
		crypto.Keccak256(contractAccountAtBlock2LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(account2AtBlock2LeafNode),
		[]byte{},
		crypto.Keccak256(account1AtBlock2LeafNode),
		[]byte{},
		[]byte{},
	})
	block3BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256(bankAccountAtBlock3LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(minerAccountAtBlock2LeafNode),
		crypto.Keccak256(contractAccountAtBlock3LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(account2AtBlock3LeafNode),
		[]byte{},
		crypto.Keccak256(account1AtBlock2LeafNode),
		[]byte{},
		[]byte{},
	})
	block4BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256(bankAccountAtBlock4LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(minerAccountAtBlock2LeafNode),
		crypto.Keccak256(contractAccountAtBlock4LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(account2AtBlock4LeafNode),
		[]byte{},
		crypto.Keccak256(account1AtBlock2LeafNode),
		[]byte{},
		[]byte{},
	})
	block5BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256(bankAccountAtBlock5LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(minerAccountAtBlock2LeafNode),
		crypto.Keccak256(contractAccountAtBlock5LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(account2AtBlock4LeafNode),
		[]byte{},
		crypto.Keccak256(account1AtBlock5LeafNode),
		[]byte{},
		[]byte{},
	})
	block6BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256(bankAccountAtBlock5LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(minerAccountAtBlock2LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(account2AtBlock6LeafNode),
		[]byte{},
		crypto.Keccak256(account1AtBlock6LeafNode),
		[]byte{},
		[]byte{},
	})

	block2StorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot0StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot1StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
	})
	block3StorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot0StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot1StorageLeafNode),
		crypto.Keccak256(slot3StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
	})
	block4StorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot0StorageLeafNode),
		[]byte{},
		crypto.Keccak256(slot2StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
	})
	block5StorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot0StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot3StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
	})
)

func TestBuilder(t *testing.T) {
	blocks, chain := test_helpers.MakeChain(3, test_helpers.Genesis, test_helpers.TestChainGen)
	contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
	defer chain.Stop()
	block0 = test_helpers.Genesis
	block1 = blocks[0]
	block2 = blocks[1]
	block3 = blocks[2]
	params := statediff.Params{}

	var tests = []test_helpers.DiffTestCase{
		{
			"testEmptyDiff",
			statediff.Args{
				OldStateRoot: block0.Root(),
				NewStateRoot: block0.Root(),
				BlockNumber:  block0.Number(),
				BlockHash:    block0.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block0.Number(),
				BlockHash:   block0.Hash(),
				Nodes:       emptyDiffs,
			},
		},
		{
			"testBlock0",
			//10000 transferred from testBankAddress to account1Addr
			statediff.Args{
				OldStateRoot: test_helpers.NullHash,
				NewStateRoot: block0.Root(),
				BlockNumber:  block0.Number(),
				BlockHash:    block0.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block0.Number(),
				BlockHash:   block0.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock0,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock0LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock0LeafNode)).String(),
						Content: bankAccountAtBlock0LeafNode,
					},
				},
			},
		},
		{
			"testBlock1",
			//10000 transferred from testBankAddress to account1Addr
			statediff.Args{
				OldStateRoot: block0.Root(),
				NewStateRoot: block1.Root(),
				BlockNumber:  block1.Number(),
				BlockHash:    block1.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block1.Number(),
				BlockHash:   block1.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock1,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock1LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: minerAccountAtBlock1,
							LeafKey: minerLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock1LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock1,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock1LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block1BranchRootNode)).String(),
						Content: block1BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock1LeafNode)).String(),
						Content: bankAccountAtBlock1LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock1LeafNode)).String(),
						Content: minerAccountAtBlock1LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock1LeafNode)).String(),
						Content: account1AtBlock1LeafNode,
					},
				},
			},
		},
		{
			"testBlock2",
			// 1000 transferred from testBankAddress to account1Addr
			// 1000 transferred from account1Addr to account2Addr
			// account1addr creates a new contract
			statediff.Args{
				OldStateRoot: block1.Root(),
				NewStateRoot: block2.Root(),
				BlockNumber:  block2.Number(),
				BlockHash:    block2.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block2.Number(),
				BlockHash:   block2.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock2,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock2LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: minerAccountAtBlock2,
							LeafKey: minerLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock2LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock2,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock2LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock2,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2LeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot0StorageValue,
								LeafKey: slot0StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(),
							},
							{
								Removed: false,
								Value:   slot1StorageValue,
								LeafKey: slot1StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
							},
						},
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account2AtBlock2,
							LeafKey: test_helpers.Account2LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock2LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.RawBinary, test_helpers.CodeHash.Bytes()).String(),
						Content: test_helpers.ByteCodeAfterDeployment,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block2BranchRootNode)).String(),
						Content: block2BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock2LeafNode)).String(),
						Content: bankAccountAtBlock2LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock2LeafNode)).String(),
						Content: minerAccountAtBlock2LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock2LeafNode)).String(),
						Content: account1AtBlock2LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2LeafNode)).String(),
						Content: contractAccountAtBlock2LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block2StorageBranchRootNode)).String(),
						Content: block2StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(),
						Content: slot0StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
						Content: slot1StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock2LeafNode)).String(),
						Content: account2AtBlock2LeafNode,
					},
				},
			},
		},
		{
			"testBlock3",
			//the contract's storage is changed
			//and the block is mined by account 2
			statediff.Args{
				OldStateRoot: block2.Root(),
				NewStateRoot: block3.Root(),
				BlockNumber:  block3.Number(),
				BlockHash:    block3.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block3.Number(),
				BlockHash:   block3.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock3,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock3LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock3,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3LeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot3StorageValue,
								LeafKey: slot3StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(),
							},
						},
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account2AtBlock3,
							LeafKey: test_helpers.Account2LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock3LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block3BranchRootNode)).String(),
						Content: block3BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock3LeafNode)).String(),
						Content: bankAccountAtBlock3LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3LeafNode)).String(),
						Content: contractAccountAtBlock3LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3StorageBranchRootNode)).String(),
						Content: block3StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(),
						Content: slot3StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock3LeafNode)).String(),
						Content: account2AtBlock3LeafNode,
					},
				},
			},
		},
	}

	test_helpers.RunBuildStateDiff(t, chain.StateCache(), tests, params)
	test_helpers.CheckedRoots{
		block0: bankAccountAtBlock0LeafNode,
		block1: block1BranchRootNode,
		block2: block2BranchRootNode,
		block3: block3BranchRootNode,
	}.Check(t)
}

func TestBuilderWithWatchedAddressList(t *testing.T) {
	blocks, chain := test_helpers.MakeChain(3, test_helpers.Genesis, test_helpers.TestChainGen)
	contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
	defer chain.Stop()
	block0 = test_helpers.Genesis
	block1 = blocks[0]
	block2 = blocks[1]
	block3 = blocks[2]
	params := statediff.Params{
		WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.ContractAddr},
	}
	params.ComputeWatchedAddressesLeafPaths()

	var tests = []test_helpers.DiffTestCase{
		{
			"testEmptyDiff",
			statediff.Args{
				OldStateRoot: block0.Root(),
				NewStateRoot: block0.Root(),
				BlockNumber:  block0.Number(),
				BlockHash:    block0.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block0.Number(),
				BlockHash:   block0.Hash(),
				Nodes:       emptyDiffs,
			},
		},
		{
			"testBlock0",
			//10000 transferred from testBankAddress to account1Addr
			statediff.Args{
				OldStateRoot: test_helpers.NullHash,
				NewStateRoot: block0.Root(),
				BlockNumber:  block0.Number(),
				BlockHash:    block0.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block0.Number(),
				BlockHash:   block0.Hash(),
				Nodes:       emptyDiffs,
			},
		},
		{
			"testBlock1",
			//10000 transferred from testBankAddress to account1Addr
			statediff.Args{
				OldStateRoot: block0.Root(),
				NewStateRoot: block1.Root(),
				BlockNumber:  block1.Number(),
				BlockHash:    block1.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block1.Number(),
				BlockHash:   block1.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock1,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock1LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block1BranchRootNode)).String(),
						Content: block1BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock1LeafNode)).String(),
						Content: account1AtBlock1LeafNode,
					},
				},
			},
		},
		{
			"testBlock2",
			//1000 transferred from testBankAddress to account1Addr
			//1000 transferred from account1Addr to account2Addr
			statediff.Args{
				OldStateRoot: block1.Root(),
				NewStateRoot: block2.Root(),
				BlockNumber:  block2.Number(),
				BlockHash:    block2.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block2.Number(),
				BlockHash:   block2.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock2,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2LeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot0StorageValue,
								LeafKey: slot0StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(),
							},
							{
								Removed: false,
								Value:   slot1StorageValue,
								LeafKey: slot1StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
							},
						},
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock2,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock2LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.RawBinary, test_helpers.CodeHash.Bytes()).String(),
						Content: test_helpers.ByteCodeAfterDeployment,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block2BranchRootNode)).String(),
						Content: block2BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2LeafNode)).String(),
						Content: contractAccountAtBlock2LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block2StorageBranchRootNode)).String(),
						Content: block2StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(),
						Content: slot0StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
						Content: slot1StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock2LeafNode)).String(),
						Content: account1AtBlock2LeafNode,
					},
				},
			},
		},
		{
			"testBlock3",
			//the contract's storage is changed
			//and the block is mined by account 2
			statediff.Args{
				OldStateRoot: block2.Root(),
				NewStateRoot: block3.Root(),
				BlockNumber:  block3.Number(),
				BlockHash:    block3.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block3.Number(),
				BlockHash:   block3.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock3,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3LeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot3StorageValue,
								LeafKey: slot3StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(),
							},
						},
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block3BranchRootNode)).String(),
						Content: block3BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3LeafNode)).String(),
						Content: contractAccountAtBlock3LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3StorageBranchRootNode)).String(),
						Content: block3StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(),
						Content: slot3StorageLeafNode,
					},
				},
			},
		},
	}

	test_helpers.RunBuildStateDiff(t, chain.StateCache(), tests, params)
	test_helpers.CheckedRoots{
		block0: bankAccountAtBlock0LeafNode,
		block1: block1BranchRootNode,
		block2: block2BranchRootNode,
		block3: block3BranchRootNode,
	}.Check(t)
}

func TestBuilderWithRemovedAccountAndStorage(t *testing.T) {
	blocks, chain := test_helpers.MakeChain(6, test_helpers.Genesis, test_helpers.TestChainGen)
	contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
	defer chain.Stop()
	block3 = blocks[2]
	block4 = blocks[3]
	block5 = blocks[4]
	block6 = blocks[5]
	params := statediff.Params{}

	var tests = []test_helpers.DiffTestCase{
		// blocks 0-3 are the same as in TestBuilderWithIntermediateNodes
		{
			"testBlock4",
			statediff.Args{
				OldStateRoot: block3.Root(),
				NewStateRoot: block4.Root(),
				BlockNumber:  block4.Number(),
				BlockHash:    block4.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block4.Number(),
				BlockHash:   block4.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock4,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock4LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock4,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock4LeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot2StorageValue,
								LeafKey: slot2StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot2StorageLeafNode)).String(),
							},
							{
								Removed: true,
								LeafKey: slot1StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
							{
								Removed: true,
								LeafKey: slot3StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
						},
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account2AtBlock4,
							LeafKey: test_helpers.Account2LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock4LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block4BranchRootNode)).String(),
						Content: block4BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock4LeafNode)).String(),
						Content: bankAccountAtBlock4LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock4LeafNode)).String(),
						Content: contractAccountAtBlock4LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block4StorageBranchRootNode)).String(),
						Content: block4StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot2StorageLeafNode)).String(),
						Content: slot2StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock4LeafNode)).String(),
						Content: account2AtBlock4LeafNode,
					},
				},
			},
		},
		{
			"testBlock5",
			statediff.Args{
				OldStateRoot: block4.Root(),
				NewStateRoot: block5.Root(),
				BlockNumber:  block5.Number(),
				BlockHash:    block5.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block5.Number(),
				BlockHash:   block5.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock5,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock5LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock5,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock5LeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot3StorageValue,
								LeafKey: slot3StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(),
							},
							{
								Removed: true,
								LeafKey: slot2StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
						},
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock5,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block5BranchRootNode)).String(),
						Content: block5BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock5LeafNode)).String(),
						Content: bankAccountAtBlock5LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock5LeafNode)).String(),
						Content: contractAccountAtBlock5LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block5StorageBranchRootNode)).String(),
						Content: block5StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(),
						Content: slot3StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String(),
						Content: account1AtBlock5LeafNode,
					},
				},
			},
		},
		{
			"testBlock6",
			statediff.Args{
				OldStateRoot: block5.Root(),
				NewStateRoot: block6.Root(),
				BlockNumber:  block6.Number(),
				BlockHash:    block6.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block6.Number(),
				BlockHash:   block6.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: true,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: nil,
							LeafKey: contractLeafKey,
							CID:     shared.RemovedNodeStateCID},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: true,
								LeafKey: slot0StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
							{
								Removed: true,
								LeafKey: slot3StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
						},
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account2AtBlock6,
							LeafKey: test_helpers.Account2LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock6LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock6,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block6BranchRootNode)).String(),
						Content: block6BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock6LeafNode)).String(),
						Content: account2AtBlock6LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String(),
						Content: account1AtBlock6LeafNode,
					},
				},
			},
		},
	}

	test_helpers.RunBuildStateDiff(t, chain.StateCache(), tests, params)
	test_helpers.CheckedRoots{
		block4: block4BranchRootNode,
		block5: block5BranchRootNode,
		block6: block6BranchRootNode,
	}.Check(t)
}

func TestBuilderWithRemovedNonWatchedAccount(t *testing.T) {
	blocks, chain := test_helpers.MakeChain(6, test_helpers.Genesis, test_helpers.TestChainGen)
	contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
	defer chain.Stop()
	block3 = blocks[2]
	block4 = blocks[3]
	block5 = blocks[4]
	block6 = blocks[5]
	params := statediff.Params{
		WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.Account2Addr},
	}
	params.ComputeWatchedAddressesLeafPaths()

	var tests = []test_helpers.DiffTestCase{
		{
			"testBlock4",
			statediff.Args{
				OldStateRoot: block3.Root(),
				NewStateRoot: block4.Root(),
				BlockNumber:  block4.Number(),
				BlockHash:    block4.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block4.Number(),
				BlockHash:   block4.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account2AtBlock4,
							LeafKey: test_helpers.Account2LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock4LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block4BranchRootNode)).String(),
						Content: block4BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock4LeafNode)).String(),
						Content: account2AtBlock4LeafNode,
					},
				},
			},
		},
		{
			"testBlock5",
			statediff.Args{
				OldStateRoot: block4.Root(),
				NewStateRoot: block5.Root(),
				BlockNumber:  block5.Number(),
				BlockHash:    block5.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block5.Number(),
				BlockHash:   block5.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock5,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block5BranchRootNode)).String(),
						Content: block5BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String(),
						Content: account1AtBlock5LeafNode,
					},
				},
			},
		},
		{
			"testBlock6",
			statediff.Args{
				OldStateRoot: block5.Root(),
				NewStateRoot: block6.Root(),
				BlockNumber:  block6.Number(),
				BlockHash:    block6.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block6.Number(),
				BlockHash:   block6.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account2AtBlock6,
							LeafKey: test_helpers.Account2LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock6LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock6,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block6BranchRootNode)).String(),
						Content: block6BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account2AtBlock6LeafNode)).String(),
						Content: account2AtBlock6LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String(),
						Content: account1AtBlock6LeafNode,
					},
				},
			},
		},
	}

	test_helpers.RunBuildStateDiff(t, chain.StateCache(), tests, params)
	test_helpers.CheckedRoots{
		block4: block4BranchRootNode,
		block5: block5BranchRootNode,
		block6: block6BranchRootNode,
	}.Check(t)
}

func TestBuilderWithRemovedWatchedAccount(t *testing.T) {
	blocks, chain := test_helpers.MakeChain(6, test_helpers.Genesis, test_helpers.TestChainGen)
	contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
	defer chain.Stop()
	block3 = blocks[2]
	block4 = blocks[3]
	block5 = blocks[4]
	block6 = blocks[5]
	params := statediff.Params{
		WatchedAddresses: []common.Address{test_helpers.Account1Addr, test_helpers.ContractAddr},
	}
	params.ComputeWatchedAddressesLeafPaths()

	var tests = []test_helpers.DiffTestCase{
		{
			"testBlock4",
			statediff.Args{
				OldStateRoot: block3.Root(),
				NewStateRoot: block4.Root(),
				BlockNumber:  block4.Number(),
				BlockHash:    block4.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block4.Number(),
				BlockHash:   block4.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock4,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock4LeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								LeafKey: slot2StorageKey.Bytes(),
								Value:   slot2StorageValue,
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot2StorageLeafNode)).String(),
							},
							{
								Removed: true,
								LeafKey: slot1StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
							{
								Removed: true,
								LeafKey: slot3StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
						},
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block4BranchRootNode)).String(),
						Content: block4BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock4LeafNode)).String(),
						Content: contractAccountAtBlock4LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block4StorageBranchRootNode)).String(),
						Content: block4StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot2StorageLeafNode)).String(),
						Content: slot2StorageLeafNode,
					},
				},
			},
		},
		{
			"testBlock5",
			statediff.Args{
				OldStateRoot: block4.Root(),
				NewStateRoot: block5.Root(),
				BlockNumber:  block5.Number(),
				BlockHash:    block5.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block5.Number(),
				BlockHash:   block5.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock5,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock5LeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								LeafKey: slot3StorageKey.Bytes(),
								Value:   slot3StorageValue,
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(),
							},
							{
								Removed: true,
								LeafKey: slot2StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
						},
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock5,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block5BranchRootNode)).String(),
						Content: block5BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock5LeafNode)).String(),
						Content: contractAccountAtBlock5LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block5StorageBranchRootNode)).String(),
						Content: block5StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot3StorageLeafNode)).String(),
						Content: slot3StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock5LeafNode)).String(),
						Content: account1AtBlock5LeafNode,
					},
				},
			},
		},
		{
			"testBlock6",
			statediff.Args{
				OldStateRoot: block5.Root(),
				NewStateRoot: block6.Root(),
				BlockNumber:  block6.Number(),
				BlockHash:    block6.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block6.Number(),
				BlockHash:   block6.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: true,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: nil,
							LeafKey: contractLeafKey,
							CID:     shared.RemovedNodeStateCID},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: true,
								LeafKey: slot0StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
							{
								Removed: true,
								LeafKey: slot3StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
						},
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock6,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block6BranchRootNode)).String(),
						Content: block6BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock6LeafNode)).String(),
						Content: account1AtBlock6LeafNode,
					},
				},
			},
		},
	}

	test_helpers.RunBuildStateDiff(t, chain.StateCache(), tests, params)
	test_helpers.CheckedRoots{
		block4: block4BranchRootNode,
		block5: block5BranchRootNode,
		block6: block6BranchRootNode,
	}.Check(t)
}

var (
	slot00StorageValue = utils.Hex2Bytes("9471562b71999873db5b286df957af199ec94617f7") // prefixed TestBankAddress

	slot00StorageLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("390decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563"),
		slot00StorageValue,
	})

	contractAccountAtBlock01 = &types.StateAccount{
		Nonce:    1,
		Balance:  uint256.NewInt(0),
		CodeHash: common.HexToHash("0xaaea5efba4fd7b45d7ec03918ac5d8b31aa93b48986af0e6b591f0f087c80127").Bytes(),
		Root:     crypto.Keccak256Hash(block01StorageBranchRootNode),
	}
	contractAccountAtBlock01RLP, _      = rlp.EncodeToBytes(contractAccountAtBlock01)
	contractAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3cb2583748c26e89ef19c2a8529b05a270f735553b4d44b6f2a1894987a71c8b"),
		contractAccountAtBlock01RLP,
	})

	bankAccountAtBlock01 = &types.StateAccount{
		Nonce:    1,
		Balance:  uint256.NewInt(3999629697375000000),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock01RLP, _      = rlp.EncodeToBytes(bankAccountAtBlock01)
	bankAccountAtBlock01LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock01RLP,
	})
	bankAccountAtBlock02 = &types.StateAccount{
		Nonce:    2,
		Balance:  uint256.NewInt(5999607323457344852),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock02RLP, _      = rlp.EncodeToBytes(bankAccountAtBlock02)
	bankAccountAtBlock02LeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("2000bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock02RLP,
	})

	block01BranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256Hash(bankAccountAtBlock01LeafNode),
		crypto.Keccak256Hash(contractAccountAtBlock01LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
	})

	block01StorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot00StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot1StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
	})
)

func TestBuilderWithMovedAccount(t *testing.T) {
	blocks, chain := test_helpers.MakeChain(2, test_helpers.Genesis, test_helpers.TestSelfDestructChainGen)
	contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
	defer chain.Stop()
	block0 = test_helpers.Genesis
	block1 = blocks[0]
	block2 = blocks[1]
	params := statediff.Params{}

	var tests = []test_helpers.DiffTestCase{
		{
			"testBlock1",
			statediff.Args{
				OldStateRoot: block0.Root(),
				NewStateRoot: block1.Root(),
				BlockNumber:  block1.Number(),
				BlockHash:    block1.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block1.Number(),
				BlockHash:   block1.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock01,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock01LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock01,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock01LeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								LeafKey: slot0StorageKey.Bytes(),
								Value:   slot00StorageValue,
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot00StorageLeafNode)).String(),
							},
							{
								Removed: false,
								LeafKey: slot1StorageKey.Bytes(),
								Value:   slot1StorageValue,
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
							},
						},
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.RawBinary, test_helpers.CodeHash.Bytes()).String(),
						Content: test_helpers.ByteCodeAfterDeployment,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block01BranchRootNode)).String(),
						Content: block01BranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock01LeafNode)).String(),
						Content: bankAccountAtBlock01LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock01LeafNode)).String(),
						Content: contractAccountAtBlock01LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block01StorageBranchRootNode)).String(),
						Content: block01StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot00StorageLeafNode)).String(),
						Content: slot00StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
						Content: slot1StorageLeafNode,
					},
				},
			},
		},
		{
			"testBlock2",
			statediff.Args{
				OldStateRoot: block1.Root(),
				NewStateRoot: block2.Root(),
				BlockNumber:  block2.Number(),
				BlockHash:    block2.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block2.Number(),
				BlockHash:   block2.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock02,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock02LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: true,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: nil,
							LeafKey: contractLeafKey,
							CID:     shared.RemovedNodeStateCID},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: true,
								LeafKey: slot0StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
							{
								Removed: true,
								LeafKey: slot1StorageKey.Bytes(),
								CID:     shared.RemovedNodeStorageCID,
								Value:   []byte{},
							},
						},
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock02LeafNode)).String(),
						Content: bankAccountAtBlock02LeafNode,
					},
				},
			},
		},
	}

	test_helpers.RunBuildStateDiff(t, chain.StateCache(), tests, params)
	test_helpers.CheckedRoots{
		block1: block01BranchRootNode,
		block2: bankAccountAtBlock02LeafNode,
	}.Check(t)
}

/*
pragma solidity ^0.5.10;

contract test {
    address payable owner;

    modifier onlyOwner {
        require(
            msg.sender == owner,
            "Only owner can call this function."
        );
        _;
    }

    uint256[100] data;

	constructor() public {
	    owner = msg.sender;
		data = [1];
	}

    function Put(uint256 addr, uint256 value) public {
        data[addr] = value;
    }

    function close() public onlyOwner { //onlyOwner is custom modifier
        selfdestruct(owner);  // `owner` is the owners address
    }
}
*/

var (
	b                    = uint256.NewInt(0).Sub(uint256.MustFromBig(test_helpers.TestBIGBankFunds), test_helpers.BalanceChangeBIG)
	block1BankBigBalance = uint256.NewInt(0).Sub(b, uint256.NewInt(uint64(test_helpers.GasFees2)))
	bankAccountAtBlock1b = &types.StateAccount{
		Nonce:    1,
		Balance:  block1BankBigBalance,
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock1bRLP, _      = rlp.EncodeToBytes(bankAccountAtBlock1b)
	bankAccountAtBlock1bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock1bRLP,
	})

	account1AtBlock1b = &types.StateAccount{
		Nonce:    0,
		Balance:  test_helpers.Block1bAccount1Balance,
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account1AtBlock1bRLP, _      = rlp.EncodeToBytes(account1AtBlock1b)
	account1AtBlock1bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
		account1AtBlock1bRLP,
	})

	account1AtBlock2bBalance = uint256.MustFromDecimal("1999999999999999999999999761539571000000000")
	account1AtBlock2b        = &types.StateAccount{
		Nonce:    1,
		Balance:  account1AtBlock2bBalance,
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	account1AtBlock2bRLP, _      = rlp.EncodeToBytes(account1AtBlock2b)
	account1AtBlock2bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3926db69aaced518e9b9f0f434a473e7174109c943548bb8f23be41ca76d9ad2"),
		account1AtBlock2bRLP,
	})

	minerAccountAtBlock2b = &types.StateAccount{
		Nonce:    0,
		Balance:  uint256.NewInt(4055891787808414571),
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	minerAccountAtBlock2bRLP, _      = rlp.EncodeToBytes(minerAccountAtBlock2b)
	minerAccountAtBlock2bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3380c7b7ae81a58eb98d9c78de4a1fd7fd9535fc953ed2be602daaa41767312a"),
		minerAccountAtBlock2bRLP,
	})

	contractAccountAtBlock2b = &types.StateAccount{
		Nonce:    1,
		Balance:  uint256.NewInt(0),
		CodeHash: test_helpers.CodeHashForInternalizedLeafNode.Bytes(),
		Root:     crypto.Keccak256Hash(block2StorageBranchRootNode),
	}
	contractAccountAtBlock2bRLP, _      = rlp.EncodeToBytes(contractAccountAtBlock2b)
	contractAccountAtBlock2bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3d7e14f1723fa19b5d6d9f8b86b49acefbc9c400bf4ed686c10d6b6467fc5b3a"),
		contractAccountAtBlock2bRLP,
	})

	bankAccountAtBlock3bBalance = uint256.MustFromDecimal("18000000000000000000000001999920365757724976")
	bankAccountAtBlock3b        = &types.StateAccount{
		Nonce:    3,
		Balance:  bankAccountAtBlock3bBalance,
		CodeHash: test_helpers.NullCodeHash.Bytes(),
		Root:     test_helpers.EmptyContractRoot,
	}
	bankAccountAtBlock3bRLP, _      = rlp.EncodeToBytes(bankAccountAtBlock3b)
	bankAccountAtBlock3bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("30bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a"),
		bankAccountAtBlock3bRLP,
	})

	contractAccountAtBlock3b = &types.StateAccount{
		Nonce:    1,
		Balance:  uint256.NewInt(0),
		CodeHash: test_helpers.CodeHashForInternalizedLeafNode.Bytes(),
		Root:     crypto.Keccak256Hash(block3bStorageBranchRootNode),
	}
	contractAccountAtBlock3bRLP, _      = rlp.EncodeToBytes(contractAccountAtBlock3b)
	contractAccountAtBlock3bLeafNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("3d7e14f1723fa19b5d6d9f8b86b49acefbc9c400bf4ed686c10d6b6467fc5b3a"),
		contractAccountAtBlock3bRLP,
	})

	slot40364  = common.BytesToHash(uint256.NewInt(40364).Bytes())
	slot105566 = common.BytesToHash(uint256.NewInt(105566).Bytes())

	slot40364StorageValue  = utils.Hex2Bytes("01")
	slot105566StorageValue = utils.Hex2Bytes("02")

	slot40364StorageKey  = crypto.Keccak256Hash(slot40364[:])
	slot105566StorageKey = crypto.Keccak256Hash(slot105566[:])

	slot40364StorageInternalLeafNode = []interface{}{
		utils.Hex2Bytes("3077bbc951a04529defc15da8c06e427cde0d7a1499c50975bbe8aab"),
		slot40364StorageValue,
	}
	slot105566StorageInternalLeafNode = []interface{}{
		utils.Hex2Bytes("3c62586c18bf1ecfda161ced374b7a894630e2db426814c24e5d42af"),
		slot105566StorageValue,
	}

	block3bStorageBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot0StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(slot1StorageLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(block3bStorageExtensionNode),
		[]byte{},
	})

	block3bStorageExtensionNode, _ = rlp.EncodeToBytes(&[]interface{}{
		utils.Hex2Bytes("1291631c"),
		crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves),
	})

	block3bStorageBranchNodeWithInternalLeaves, _ = rlp.EncodeToBytes(&[]interface{}{
		slot105566StorageInternalLeafNode,
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		slot40364StorageInternalLeafNode,
		[]byte{},
		[]byte{},
		[]byte{},
	})

	block1bBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256(bankAccountAtBlock1bLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(minerAccountAtBlock1LeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(account1AtBlock1bLeafNode),
		[]byte{},
		[]byte{},
	})

	block2bBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256(bankAccountAtBlock1bLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(minerAccountAtBlock2bLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(account1AtBlock2bLeafNode),
		crypto.Keccak256(contractAccountAtBlock2bLeafNode),
		[]byte{},
	})

	block3bBranchRootNode, _ = rlp.EncodeToBytes(&[]interface{}{
		crypto.Keccak256(bankAccountAtBlock3bLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(minerAccountAtBlock2bLeafNode),
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		[]byte{},
		crypto.Keccak256(account1AtBlock2bLeafNode),
		crypto.Keccak256(contractAccountAtBlock3bLeafNode),
		[]byte{},
	})
)

func TestBuilderWithInternalizedLeafNode(t *testing.T) {
	blocks, chain := test_helpers.MakeChain(3, test_helpers.GenesisForInternalLeafNodeTest, test_helpers.TestChainGenWithInternalLeafNode)
	contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
	defer chain.Stop()
	block0 = test_helpers.Genesis
	block1 = blocks[0]
	block2 = blocks[1]
	block3 = blocks[2]
	params := statediff.Params{}

	var tests = []test_helpers.DiffTestCase{
		{
			"testEmptyDiff",
			statediff.Args{
				OldStateRoot: block0.Root(),
				NewStateRoot: block0.Root(),
				BlockNumber:  block0.Number(),
				BlockHash:    block0.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block0.Number(),
				BlockHash:   block0.Hash(),
				Nodes:       emptyDiffs,
			},
		},
		{
			"testBlock0",
			//10000 transferred from testBankAddress to account1Addr
			statediff.Args{
				OldStateRoot: test_helpers.NullHash,
				NewStateRoot: block0.Root(),
				BlockNumber:  block0.Number(),
				BlockHash:    block0.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block0.Number(),
				BlockHash:   block0.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock0,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock0LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock0LeafNode)).String(),
						Content: bankAccountAtBlock0LeafNode,
					},
				},
			},
		},
		{
			"testBlock1",
			//10000 transferred from testBankAddress to account1Addr
			statediff.Args{
				OldStateRoot: block0.Root(),
				NewStateRoot: block1.Root(),
				BlockNumber:  block1.Number(),
				BlockHash:    block1.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block1.Number(),
				BlockHash:   block1.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock1b,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock1bLeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: minerAccountAtBlock1,
							LeafKey: minerLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock1LeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock1b,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock1bLeafNode)).String()},
						StorageDiff: emptyStorage,
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block1bBranchRootNode)).String(),
						Content: block1bBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock1bLeafNode)).String(),
						Content: bankAccountAtBlock1bLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock1LeafNode)).String(),
						Content: minerAccountAtBlock1LeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock1bLeafNode)).String(),
						Content: account1AtBlock1bLeafNode,
					},
				},
			},
		},
		{
			"testBlock2",
			// 1000 transferred from testBankAddress to account1Addr
			// 1000 transferred from account1Addr to account2Addr
			// account1addr creates a new contract
			statediff.Args{
				OldStateRoot: block1.Root(),
				NewStateRoot: block2.Root(),
				BlockNumber:  block2.Number(),
				BlockHash:    block2.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block2.Number(),
				BlockHash:   block2.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: minerAccountAtBlock2b,
							LeafKey: minerLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock2bLeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: account1AtBlock2b,
							LeafKey: test_helpers.Account1LeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock2bLeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock2b,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2bLeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot0StorageValue,
								LeafKey: slot0StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(),
							},
							{
								Removed: false,
								Value:   slot1StorageValue,
								LeafKey: slot1StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
							},
						},
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.RawBinary, test_helpers.CodeHashForInternalizedLeafNode.Bytes()).String(),
						Content: test_helpers.ByteCodeAfterDeploymentForInternalLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block2bBranchRootNode)).String(),
						Content: block2bBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(minerAccountAtBlock2bLeafNode)).String(),
						Content: minerAccountAtBlock2bLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(account1AtBlock2bLeafNode)).String(),
						Content: account1AtBlock2bLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2bLeafNode)).String(),
						Content: contractAccountAtBlock2bLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block2StorageBranchRootNode)).String(),
						Content: block2StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(),
						Content: slot0StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
						Content: slot1StorageLeafNode,
					},
				},
			},
		},
		{
			"testBlock3",
			//the contract's storage is changed
			//and the block is mined by account 2
			statediff.Args{
				OldStateRoot: block2.Root(),
				NewStateRoot: block3.Root(),
				BlockNumber:  block3.Number(),
				BlockHash:    block3.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block3.Number(),
				BlockHash:   block3.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: bankAccountAtBlock3b,
							LeafKey: test_helpers.BankLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock3bLeafNode)).String()},
						StorageDiff: emptyStorage,
					},
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock3b,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3bLeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot105566StorageValue,
								LeafKey: slot105566StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(),
							},
							{
								Removed: false,
								Value:   slot40364StorageValue,
								LeafKey: slot40364StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(),
							},
						},
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block3bBranchRootNode)).String(),
						Content: block3bBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(bankAccountAtBlock3bLeafNode)).String(),
						Content: bankAccountAtBlock3bLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3bLeafNode)).String(),
						Content: contractAccountAtBlock3bLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchRootNode)).String(),
						Content: block3bStorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageExtensionNode)).String(),
						Content: block3bStorageExtensionNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(),
						Content: block3bStorageBranchNodeWithInternalLeaves,
					},
				},
			},
		},
	}

	test_helpers.RunBuildStateDiff(t, chain.StateCache(), tests, params)
	test_helpers.CheckedRoots{
		block1: block1bBranchRootNode,
		block2: block2bBranchRootNode,
		block3: block3bBranchRootNode,
	}.Check(t)
}

func TestBuilderWithInternalizedLeafNodeAndWatchedAddress(t *testing.T) {
	blocks, chain := test_helpers.MakeChain(3, test_helpers.GenesisForInternalLeafNodeTest, test_helpers.TestChainGenWithInternalLeafNode)
	contractLeafKey = test_helpers.AddressToLeafKey(test_helpers.ContractAddr)
	defer chain.Stop()
	block0 = test_helpers.Genesis
	block1 = blocks[0]
	block2 = blocks[1]
	block3 = blocks[2]
	params := statediff.Params{
		WatchedAddresses: []common.Address{
			test_helpers.ContractAddr,
		},
	}
	params.ComputeWatchedAddressesLeafPaths()

	var tests = []test_helpers.DiffTestCase{
		{
			"testEmptyDiff",
			statediff.Args{
				OldStateRoot: block0.Root(),
				NewStateRoot: block0.Root(),
				BlockNumber:  block0.Number(),
				BlockHash:    block0.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block0.Number(),
				BlockHash:   block0.Hash(),
				Nodes:       emptyDiffs,
			},
		},
		{
			"testBlock0",
			//10000 transferred from testBankAddress to account1Addr
			statediff.Args{
				OldStateRoot: test_helpers.NullHash,
				NewStateRoot: block0.Root(),
				BlockNumber:  block0.Number(),
				BlockHash:    block0.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block0.Number(),
				BlockHash:   block0.Hash(),
				// there's some kind of weird behavior where if our root node is a leaf node even
				// though it is along the path to the watched leaf (necessarily, as it is the root)
				// it doesn't get included. unconsequential, but kinda odd.
			},
		},
		{
			"testBlock1",
			//10000 transferred from testBankAddress to account1Addr
			statediff.Args{
				OldStateRoot: block0.Root(),
				NewStateRoot: block1.Root(),
				BlockNumber:  block1.Number(),
				BlockHash:    block1.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block1.Number(),
				BlockHash:   block1.Hash(),
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block1bBranchRootNode)).String(),
						Content: block1bBranchRootNode,
					},
				},
			},
		},
		{
			"testBlock2",
			// 1000 transferred from testBankAddress to account1Addr
			// 1000 transferred from account1Addr to account2Addr
			// account1addr creates a new contract
			statediff.Args{
				OldStateRoot: block1.Root(),
				NewStateRoot: block2.Root(),
				BlockNumber:  block2.Number(),
				BlockHash:    block2.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block2.Number(),
				BlockHash:   block2.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock2b,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2bLeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot0StorageValue,
								LeafKey: slot0StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(),
							},
							{
								Removed: false,
								Value:   slot1StorageValue,
								LeafKey: slot1StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
							},
						},
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.RawBinary, test_helpers.CodeHashForInternalizedLeafNode.Bytes()).String(),
						Content: test_helpers.ByteCodeAfterDeploymentForInternalLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block2bBranchRootNode)).String(),
						Content: block2bBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock2bLeafNode)).String(),
						Content: contractAccountAtBlock2bLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block2StorageBranchRootNode)).String(),
						Content: block2StorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot0StorageLeafNode)).String(),
						Content: slot0StorageLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(slot1StorageLeafNode)).String(),
						Content: slot1StorageLeafNode,
					},
				},
			},
		},
		{
			"testBlock3",
			//the contract's storage is changed
			//and the block is mined by account 2
			statediff.Args{
				OldStateRoot: block2.Root(),
				NewStateRoot: block3.Root(),
				BlockNumber:  block3.Number(),
				BlockHash:    block3.Hash(),
			},
			&sdtypes.StateObject{
				BlockNumber: block3.Number(),
				BlockHash:   block3.Hash(),
				Nodes: []sdtypes.StateLeafNode{
					{
						Removed: false,
						AccountWrapper: sdtypes.AccountWrapper{
							Account: contractAccountAtBlock3b,
							LeafKey: contractLeafKey,
							CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3bLeafNode)).String()},
						StorageDiff: []sdtypes.StorageLeafNode{
							{
								Removed: false,
								Value:   slot105566StorageValue,
								LeafKey: slot105566StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(),
							},
							{
								Removed: false,
								Value:   slot40364StorageValue,
								LeafKey: slot40364StorageKey.Bytes(),
								CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(),
							},
						},
					},
				},
				IPLDs: []sdtypes.IPLD{
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(block3bBranchRootNode)).String(),
						Content: block3bBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(contractAccountAtBlock3bLeafNode)).String(),
						Content: contractAccountAtBlock3bLeafNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchRootNode)).String(),
						Content: block3bStorageBranchRootNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageExtensionNode)).String(),
						Content: block3bStorageExtensionNode,
					},
					{
						CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(block3bStorageBranchNodeWithInternalLeaves)).String(),
						Content: block3bStorageBranchNodeWithInternalLeaves,
					},
				},
			},
		},
	}

	test_helpers.RunBuildStateDiff(t, chain.StateCache(), tests, params)
	test_helpers.CheckedRoots{
		block1: block1bBranchRootNode,
		block2: block2bBranchRootNode,
		block3: block3bBranchRootNode,
	}.Check(t)
}

/*
pragma solidity ^0.5.10;

contract test {
    address payable owner;

    modifier onlyOwner {
        require(
            msg.sender == owner,
            "Only owner can call this function."
        );
        _;
    }

    uint256[105566] data;

	constructor() public {
	    owner = msg.sender;
		data = [1];
	}

    function Put(uint256 addr, uint256 value) public {
        data[addr] = value;
    }

    function close() public onlyOwner { //onlyOwner is custom modifier
        selfdestruct(owner);  // `owner` is the owners address
    }
}
*/