diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go
index 9667077c64..3bb0e8651b 100644
--- a/accounts/abi/bind/backends/simulated.go
+++ b/accounts/abi/bind/backends/simulated.go
@@ -681,7 +681,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 
 	// Set infinite balance to the fake caller account.
 	from := stateDB.GetOrNewStateObject(call.From)
-	from.SetBalance(math.MaxBig256, 0x0)
+	from.SetBalance(math.MaxBig256, state.BalanceChangeUnspecified)
 
 	// Execute the call.
 	msg := &core.Message{
diff --git a/core/state/state_test.go b/core/state/state_test.go
index d1d6186405..08968a6cc1 100644
--- a/core/state/state_test.go
+++ b/core/state/state_test.go
@@ -53,7 +53,7 @@ func TestDump(t *testing.T) {
 	obj2 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x01, 0x02}))
 	obj2.SetCode(crypto.Keccak256Hash([]byte{3, 3, 3, 3, 3, 3, 3}), []byte{3, 3, 3, 3, 3, 3, 3})
 	obj3 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x02}))
-	obj3.SetBalance(big.NewInt(44), 0x0)
+	obj3.SetBalance(big.NewInt(44), BalanceChangeUnspecified)
 
 	// write some of them to the trie
 	s.state.updateStateObject(obj1)
@@ -107,7 +107,7 @@ func TestIterativeDump(t *testing.T) {
 	obj2 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x01, 0x02}))
 	obj2.SetCode(crypto.Keccak256Hash([]byte{3, 3, 3, 3, 3, 3, 3}), []byte{3, 3, 3, 3, 3, 3, 3})
 	obj3 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x02}))
-	obj3.SetBalance(big.NewInt(44), 0x0)
+	obj3.SetBalance(big.NewInt(44), BalanceChangeUnspecified)
 	obj4 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x00}))
 	obj4.AddBalance(big.NewInt(1337), 0x0)
 
@@ -205,7 +205,7 @@ func TestSnapshot2(t *testing.T) {
 
 	// db, trie are already non-empty values
 	so0 := state.getStateObject(stateobjaddr0)
-	so0.SetBalance(big.NewInt(42), 0x0)
+	so0.SetBalance(big.NewInt(42), BalanceChangeUnspecified)
 	so0.SetNonce(43)
 	so0.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e'}), []byte{'c', 'a', 'f', 'e'})
 	so0.selfDestructed = false
@@ -217,7 +217,7 @@ func TestSnapshot2(t *testing.T) {
 
 	// and one with deleted == true
 	so1 := state.getStateObject(stateobjaddr1)
-	so1.SetBalance(big.NewInt(52), 0x0)
+	so1.SetBalance(big.NewInt(52), BalanceChangeUnspecified)
 	so1.SetNonce(53)
 	so1.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e', '2'}), []byte{'c', 'a', 'f', 'e', '2'})
 	so1.selfDestructed = true
diff --git a/core/state/statedb_fuzz_test.go b/core/state/statedb_fuzz_test.go
index e2524b4b13..592d34b466 100644
--- a/core/state/statedb_fuzz_test.go
+++ b/core/state/statedb_fuzz_test.go
@@ -60,7 +60,7 @@ func newStateTestAction(addr common.Address, r *rand.Rand, index int) testAction
 		{
 			name: "SetBalance",
 			fn: func(a testAction, s *StateDB) {
-				s.SetBalance(addr, big.NewInt(a.args[0]), 0)
+				s.SetBalance(addr, big.NewInt(a.args[0]), BalanceChangeUnspecified)
 			},
 			args: make([]int64, 1),
 		},
diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go
index 15842fa86d..4f4c7b3b2e 100644
--- a/core/state/statedb_test.go
+++ b/core/state/statedb_test.go
@@ -91,7 +91,7 @@ func TestIntermediateLeaks(t *testing.T) {
 	finalState, _ := New(types.EmptyRootHash, NewDatabaseWithNodeDB(finalDb, finalNdb), nil)
 
 	modify := func(state *StateDB, addr common.Address, i, tweak byte) {
-		state.SetBalance(addr, big.NewInt(int64(11*i)+int64(tweak)), 0x0)
+		state.SetBalance(addr, big.NewInt(int64(11*i)+int64(tweak)), BalanceChangeUnspecified)
 		state.SetNonce(addr, uint64(42*i+tweak))
 		if i%2 == 0 {
 			state.SetState(addr, common.Hash{i, i, i, 0}, common.Hash{})
@@ -266,7 +266,7 @@ func newTestAction(addr common.Address, r *rand.Rand) testAction {
 		{
 			name: "SetBalance",
 			fn: func(a testAction, s *StateDB) {
-				s.SetBalance(addr, big.NewInt(a.args[0]), 0x0)
+				s.SetBalance(addr, big.NewInt(a.args[0]), BalanceChangeUnspecified)
 			},
 			args: make([]int64, 1),
 		},
@@ -554,7 +554,7 @@ func TestTouchDelete(t *testing.T) {
 func TestCopyOfCopy(t *testing.T) {
 	state, _ := New(types.EmptyRootHash, NewDatabase(rawdb.NewMemoryDatabase()), nil)
 	addr := common.HexToAddress("aaaa")
-	state.SetBalance(addr, big.NewInt(42), 0x0)
+	state.SetBalance(addr, big.NewInt(42), BalanceChangeUnspecified)
 
 	if got := state.Copy().GetBalance(addr).Uint64(); got != 42 {
 		t.Fatalf("1st copy fail, expected 42, got %v", got)
@@ -577,9 +577,9 @@ func TestCopyCommitCopy(t *testing.T) {
 	skey := common.HexToHash("aaa")
 	sval := common.HexToHash("bbb")
 
-	state.SetBalance(addr, big.NewInt(42), 0x0) // Change the account trie
-	state.SetCode(addr, []byte("hello"))        // Change an external metadata
-	state.SetState(addr, skey, sval)            // Change the storage trie
+	state.SetBalance(addr, big.NewInt(42), BalanceChangeUnspecified) // Change the account trie
+	state.SetCode(addr, []byte("hello"))                             // Change an external metadata
+	state.SetState(addr, skey, sval)                                 // Change the storage trie
 
 	if balance := state.GetBalance(addr); balance.Cmp(big.NewInt(42)) != 0 {
 		t.Fatalf("initial balance mismatch: have %v, want %v", balance, 42)
@@ -650,9 +650,9 @@ func TestCopyCopyCommitCopy(t *testing.T) {
 	skey := common.HexToHash("aaa")
 	sval := common.HexToHash("bbb")
 
-	state.SetBalance(addr, big.NewInt(42), 0x0) // Change the account trie
-	state.SetCode(addr, []byte("hello"))        // Change an external metadata
-	state.SetState(addr, skey, sval)            // Change the storage trie
+	state.SetBalance(addr, big.NewInt(42), BalanceChangeUnspecified) // Change the account trie
+	state.SetCode(addr, []byte("hello"))                             // Change an external metadata
+	state.SetState(addr, skey, sval)                                 // Change the storage trie
 
 	if balance := state.GetBalance(addr); balance.Cmp(big.NewInt(42)) != 0 {
 		t.Fatalf("initial balance mismatch: have %v, want %v", balance, 42)
@@ -719,9 +719,9 @@ func TestCommitCopy(t *testing.T) {
 	skey := common.HexToHash("aaa")
 	sval := common.HexToHash("bbb")
 
-	state.SetBalance(addr, big.NewInt(42), 0) // Change the account trie
-	state.SetCode(addr, []byte("hello"))      // Change an external metadata
-	state.SetState(addr, skey, sval)          // Change the storage trie
+	state.SetBalance(addr, big.NewInt(42), BalanceChangeUnspecified) // Change the account trie
+	state.SetCode(addr, []byte("hello"))                             // Change an external metadata
+	state.SetState(addr, skey, sval)                                 // Change the storage trie
 
 	if balance := state.GetBalance(addr); balance.Cmp(big.NewInt(42)) != 0 {
 		t.Fatalf("initial balance mismatch: have %v, want %v", balance, 42)
@@ -768,7 +768,7 @@ func TestDeleteCreateRevert(t *testing.T) {
 	state, _ := New(types.EmptyRootHash, NewDatabase(rawdb.NewMemoryDatabase()), nil)
 
 	addr := common.BytesToAddress([]byte("so"))
-	state.SetBalance(addr, big.NewInt(1), 0x0)
+	state.SetBalance(addr, big.NewInt(1), BalanceChangeUnspecified)
 
 	root, _ := state.Commit(0, false)
 	state, _ = New(root, state.db, state.snaps)
@@ -778,7 +778,7 @@ func TestDeleteCreateRevert(t *testing.T) {
 	state.Finalise(true)
 
 	id := state.Snapshot()
-	state.SetBalance(addr, big.NewInt(2), 0x0)
+	state.SetBalance(addr, big.NewInt(2), BalanceChangeUnspecified)
 	state.RevertToSnapshot(id)
 
 	// Commit the entire state and make sure we don't crash and have the correct state
@@ -820,10 +820,10 @@ func testMissingTrieNodes(t *testing.T, scheme string) {
 	state, _ := New(types.EmptyRootHash, db, nil)
 	addr := common.BytesToAddress([]byte("so"))
 	{
-		state.SetBalance(addr, big.NewInt(1), 0x0)
+		state.SetBalance(addr, big.NewInt(1), BalanceChangeUnspecified)
 		state.SetCode(addr, []byte{1, 2, 3})
 		a2 := common.BytesToAddress([]byte("another"))
-		state.SetBalance(a2, big.NewInt(100), 0x0)
+		state.SetBalance(a2, big.NewInt(100), BalanceChangeUnspecified)
 		state.SetCode(a2, []byte{1, 2, 4})
 		root, _ = state.Commit(0, false)
 		t.Logf("root: %x", root)
@@ -848,7 +848,7 @@ func testMissingTrieNodes(t *testing.T, scheme string) {
 		t.Errorf("expected %d, got %d", exp, got)
 	}
 	// Modify the state
-	state.SetBalance(addr, big.NewInt(2), 0x0)
+	state.SetBalance(addr, big.NewInt(2), BalanceChangeUnspecified)
 	root, err := state.Commit(0, false)
 	if err == nil {
 		t.Fatalf("expected error, got root :%x", root)
@@ -1116,13 +1116,13 @@ func TestResetObject(t *testing.T) {
 		slotB    = common.HexToHash("0x2")
 	)
 	// Initialize account with balance and storage in first transaction.
-	state.SetBalance(addr, big.NewInt(1), 0x0)
+	state.SetBalance(addr, big.NewInt(1), BalanceChangeUnspecified)
 	state.SetState(addr, slotA, common.BytesToHash([]byte{0x1}))
 	state.IntermediateRoot(true)
 
 	// Reset account and mutate balance and storages
 	state.CreateAccount(addr)
-	state.SetBalance(addr, big.NewInt(2), 0x0)
+	state.SetBalance(addr, big.NewInt(2), BalanceChangeUnspecified)
 	state.SetState(addr, slotB, common.BytesToHash([]byte{0x2}))
 	root, _ := state.Commit(0, true)
 
@@ -1148,7 +1148,7 @@ func TestDeleteStorage(t *testing.T) {
 		addr     = common.HexToAddress("0x1")
 	)
 	// Initialize account and populate storage
-	state.SetBalance(addr, big.NewInt(1), 0x0)
+	state.SetBalance(addr, big.NewInt(1), BalanceChangeUnspecified)
 	state.CreateAccount(addr)
 	for i := 0; i < 1000; i++ {
 		slot := common.Hash(uint256.NewInt(uint64(i)).Bytes32())
diff --git a/core/state/trie_prefetcher_test.go b/core/state/trie_prefetcher_test.go
index 79a0f7f3c3..a376c790c3 100644
--- a/core/state/trie_prefetcher_test.go
+++ b/core/state/trie_prefetcher_test.go
@@ -34,9 +34,9 @@ func filledStateDB() *StateDB {
 	skey := common.HexToHash("aaa")
 	sval := common.HexToHash("bbb")
 
-	state.SetBalance(addr, big.NewInt(42), 0x0) // Change the account trie
-	state.SetCode(addr, []byte("hello"))        // Change an external metadata
-	state.SetState(addr, skey, sval)            // Change the storage trie
+	state.SetBalance(addr, big.NewInt(42), BalanceChangeUnspecified) // Change the account trie
+	state.SetCode(addr, []byte("hello"))                             // Change an external metadata
+	state.SetState(addr, skey, sval)                                 // Change the storage trie
 	for i := 0; i < 100; i++ {
 		sk := common.BigToHash(big.NewInt(int64(i)))
 		state.SetState(addr, sk, sk) // Change the storage trie
diff --git a/core/txpool/legacypool/legacypool_test.go b/core/txpool/legacypool/legacypool_test.go
index 6de0e0e7f6..9621f5eb17 100644
--- a/core/txpool/legacypool/legacypool_test.go
+++ b/core/txpool/legacypool/legacypool_test.go
@@ -255,7 +255,7 @@ func (c *testChain) State() (*state.StateDB, error) {
 		c.statedb, _ = state.New(types.EmptyRootHash, state.NewDatabase(rawdb.NewMemoryDatabase()), nil)
 		// simulate that the new head block included tx0 and tx1
 		c.statedb.SetNonce(c.address, 2)
-		c.statedb.SetBalance(c.address, new(big.Int).SetUint64(params.Ether), 0x0)
+		c.statedb.SetBalance(c.address, new(big.Int).SetUint64(params.Ether), state.BalanceChangeUnspecified)
 		*c.trigger = false
 	}
 	return stdb, nil
@@ -275,7 +275,7 @@ func TestStateChangeDuringReset(t *testing.T) {
 	)
 
 	// setup pool with 2 transaction in it
-	statedb.SetBalance(address, new(big.Int).SetUint64(params.Ether), 0x0)
+	statedb.SetBalance(address, new(big.Int).SetUint64(params.Ether), state.BalanceChangeUnspecified)
 	blockchain := &testChain{newTestBlockChain(params.TestChainConfig, 1000000000, statedb, new(event.Feed)), address, &trigger}
 
 	tx0 := transaction(0, 100000, key)
diff --git a/eth/api_debug_test.go b/eth/api_debug_test.go
index f6df9733f5..b93afbab06 100644
--- a/eth/api_debug_test.go
+++ b/eth/api_debug_test.go
@@ -72,7 +72,7 @@ func TestAccountRange(t *testing.T) {
 		hash := common.HexToHash(fmt.Sprintf("%x", i))
 		addr := common.BytesToAddress(crypto.Keccak256Hash(hash.Bytes()).Bytes())
 		addrs[i] = addr
-		sdb.SetBalance(addrs[i], big.NewInt(1), 0x0)
+		sdb.SetBalance(addrs[i], big.NewInt(1), state.BalanceChangeUnspecified)
 		if _, ok := m[addr]; ok {
 			t.Fatalf("bad")
 		} else {
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index 1c1fa84a8d..4f792260ed 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -945,41 +945,41 @@ type OverrideAccount struct {
 type StateOverride map[common.Address]OverrideAccount
 
 // Apply overrides the fields of specified accounts into the given state.
-func (diff *StateOverride) Apply(state *state.StateDB) error {
+func (diff *StateOverride) Apply(statedb *state.StateDB) error {
 	if diff == nil {
 		return nil
 	}
 	for addr, account := range *diff {
 		// Override account nonce.
 		if account.Nonce != nil {
-			state.SetNonce(addr, uint64(*account.Nonce))
+			statedb.SetNonce(addr, uint64(*account.Nonce))
 		}
 		// Override account(contract) code.
 		if account.Code != nil {
-			state.SetCode(addr, *account.Code)
+			statedb.SetCode(addr, *account.Code)
 		}
 		// Override account balance.
 		if account.Balance != nil {
-			state.SetBalance(addr, (*big.Int)(*account.Balance), 0x0)
+			statedb.SetBalance(addr, (*big.Int)(*account.Balance), state.BalanceChangeUnspecified)
 		}
 		if account.State != nil && account.StateDiff != nil {
 			return fmt.Errorf("account %s has both 'state' and 'stateDiff'", addr.Hex())
 		}
 		// Replace entire state if caller requires.
 		if account.State != nil {
-			state.SetStorage(addr, *account.State)
+			statedb.SetStorage(addr, *account.State)
 		}
 		// Apply state diff into specified accounts.
 		if account.StateDiff != nil {
 			for key, value := range *account.StateDiff {
-				state.SetState(addr, key, value)
+				statedb.SetState(addr, key, value)
 			}
 		}
 	}
 	// Now finalize the changes. Finalize is normally performed between transactions.
 	// By using finalize, the overrides are semantically behaving as
 	// if they were created in a transaction just before the tracing occur.
-	state.Finalise(false)
+	statedb.Finalise(false)
 	return nil
 }
 
diff --git a/light/odr_test.go b/light/odr_test.go
index 72571cd8ed..44450fc2ff 100644
--- a/light/odr_test.go
+++ b/light/odr_test.go
@@ -201,7 +201,7 @@ func odrContractCall(ctx context.Context, db ethdb.Database, bc *core.BlockChain
 		}
 
 		// Perform read-only call.
-		st.SetBalance(testBankAddress, math.MaxBig256, 0x0)
+		st.SetBalance(testBankAddress, math.MaxBig256, state.BalanceChangeUnspecified)
 		msg := &core.Message{
 			From:              testBankAddress,
 			To:                &testContractAddr,
diff --git a/tests/state_test_util.go b/tests/state_test_util.go
index 05e19ed742..1478eb3d28 100644
--- a/tests/state_test_util.go
+++ b/tests/state_test_util.go
@@ -322,7 +322,7 @@ func MakePreState(db ethdb.Database, accounts core.GenesisAlloc, snapshotter boo
 	for addr, a := range accounts {
 		statedb.SetCode(addr, a.Code)
 		statedb.SetNonce(addr, a.Nonce)
-		statedb.SetBalance(addr, a.Balance, 0x0)
+		statedb.SetBalance(addr, a.Balance, state.BalanceChangeUnspecified)
 		for k, v := range a.Storage {
 			statedb.SetState(addr, k, v)
 		}