123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308 |
- // Copyright 2014 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 state
- import (
- "bytes"
- "encoding/json"
- "math/big"
- "testing"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/core/rawdb"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/ethdb"
- checker "gopkg.in/check.v1"
- )
- type stateTest struct {
- db ethdb.Database
- state *StateDB
- }
- func newStateTest() *stateTest {
- db := rawdb.NewMemoryDatabase()
- sdb, _ := New(common.Hash{}, NewDatabase(db), nil)
- return &stateTest{db: db, state: sdb}
- }
- func TestDump(t *testing.T) {
- db := rawdb.NewMemoryDatabase()
- sdb, _ := New(common.Hash{}, NewDatabaseWithConfig(db, nil), nil)
- s := &stateTest{db: db, state: sdb}
- // generate a few entries
- obj1 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x01}))
- obj1.AddBalance(big.NewInt(22))
- 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))
- // write some of them to the trie
- s.state.updateStateObject(obj1)
- s.state.updateStateObject(obj2)
- s.state.Commit(false)
- // check that DumpToCollector contains the state objects that are in trie
- got := string(s.state.Dump(false, false, true))
- want := `{
- "root": "71edff0130dd2385947095001c73d9e28d862fc286fca2b922ca6f6f3cddfdd2",
- "accounts": {
- "0x0000000000000000000000000000000000000001": {
- "balance": "22",
- "nonce": 0,
- "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
- "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
- },
- "0x0000000000000000000000000000000000000002": {
- "balance": "44",
- "nonce": 0,
- "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
- "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"
- },
- "0x0000000000000000000000000000000000000102": {
- "balance": "0",
- "nonce": 0,
- "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
- "codeHash": "87874902497a5bb968da31a2998d8f22e949d1ef6214bcdedd8bae24cca4b9e3",
- "code": "03030303030303"
- }
- }
- }`
- if got != want {
- t.Errorf("DumpToCollector mismatch:\ngot: %s\nwant: %s\n", got, want)
- }
- }
- func (s *stateTest) TestDumpAddress(c *checker.C) {
- // generate a few entries
- obj1 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x01}))
- obj1.AddBalance(big.NewInt(22))
- 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))
- // write some of them to the trie
- s.state.updateStateObject(obj1)
- s.state.updateStateObject(obj2)
- s.state.Commit(false)
- addressToDump := common.BytesToAddress([]byte{0x01})
- // check that dump contains the state objects that are in trie
- got, _ := s.state.DumpAddress(addressToDump)
- out, _ := json.Marshal(got)
- want := `{"balance":"22","nonce":0,"root":"56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","codeHash":"c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"}`
- if string(out) != want {
- c.Errorf("dump mismatch:\ngot: %s\nwant: %s\n", string(out), want)
- }
- }
- func (s *stateTest) TestDumpAddressNotFound(c *checker.C) {
- // generate a few entries
- obj1 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x01}))
- obj1.AddBalance(big.NewInt(22))
- 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))
- // write some of them to the trie
- s.state.updateStateObject(obj1)
- s.state.updateStateObject(obj2)
- s.state.Commit(false)
- addressToDump := common.BytesToAddress([]byte{0x09})
- // check that dump contains the state objects that are in trie
- _, found := s.state.DumpAddress(addressToDump)
- if found {
- c.Errorf("dump mismatch:\ngot: %s\nwant: %s\n", found, false)
- }
- }
- func (s *stateTest) SetUpTest(c *checker.C) {
- s.db = rawdb.NewMemoryDatabase()
- s.state, _ = New(common.Hash{}, NewDatabase(s.db), nil)
- }
- func TestNull(t *testing.T) {
- s := newStateTest()
- address := common.HexToAddress("0x823140710bf13990e4500136726d8b55")
- s.state.CreateAccount(address)
- //value := common.FromHex("0x823140710bf13990e4500136726d8b55")
- var value common.Hash
- s.state.SetState(address, common.Hash{}, value)
- s.state.Commit(false)
- if value := s.state.GetState(address, common.Hash{}); value != (common.Hash{}) {
- t.Errorf("expected empty current value, got %x", value)
- }
- if value := s.state.GetCommittedState(address, common.Hash{}); value != (common.Hash{}) {
- t.Errorf("expected empty committed value, got %x", value)
- }
- }
- func TestSnapshot(t *testing.T) {
- stateobjaddr := common.BytesToAddress([]byte("aa"))
- var storageaddr common.Hash
- data1 := common.BytesToHash([]byte{42})
- data2 := common.BytesToHash([]byte{43})
- s := newStateTest()
- // snapshot the genesis state
- genesis := s.state.Snapshot()
- // set initial state object value
- s.state.SetState(stateobjaddr, storageaddr, data1)
- snapshot := s.state.Snapshot()
- // set a new state object value, revert it and ensure correct content
- s.state.SetState(stateobjaddr, storageaddr, data2)
- s.state.RevertToSnapshot(snapshot)
- if v := s.state.GetState(stateobjaddr, storageaddr); v != data1 {
- t.Errorf("wrong storage value %v, want %v", v, data1)
- }
- if v := s.state.GetCommittedState(stateobjaddr, storageaddr); v != (common.Hash{}) {
- t.Errorf("wrong committed storage value %v, want %v", v, common.Hash{})
- }
- // revert up to the genesis state and ensure correct content
- s.state.RevertToSnapshot(genesis)
- if v := s.state.GetState(stateobjaddr, storageaddr); v != (common.Hash{}) {
- t.Errorf("wrong storage value %v, want %v", v, common.Hash{})
- }
- if v := s.state.GetCommittedState(stateobjaddr, storageaddr); v != (common.Hash{}) {
- t.Errorf("wrong committed storage value %v, want %v", v, common.Hash{})
- }
- }
- func TestSnapshotEmpty(t *testing.T) {
- s := newStateTest()
- s.state.RevertToSnapshot(s.state.Snapshot())
- }
- func TestSnapshot2(t *testing.T) {
- state, _ := New(common.Hash{}, NewDatabase(rawdb.NewMemoryDatabase()), nil)
- stateobjaddr0 := common.BytesToAddress([]byte("so0"))
- stateobjaddr1 := common.BytesToAddress([]byte("so1"))
- var storageaddr common.Hash
- data0 := common.BytesToHash([]byte{17})
- data1 := common.BytesToHash([]byte{18})
- state.SetState(stateobjaddr0, storageaddr, data0)
- state.SetState(stateobjaddr1, storageaddr, data1)
- // db, trie are already non-empty values
- so0 := state.getStateObject(stateobjaddr0)
- so0.SetBalance(big.NewInt(42))
- so0.SetNonce(43)
- so0.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e'}), []byte{'c', 'a', 'f', 'e'})
- so0.suicided = false
- so0.deleted = false
- state.setStateObject(so0)
- root, _ := state.Commit(false)
- state, _ = New(root, state.db, state.snaps)
- // and one with deleted == true
- so1 := state.getStateObject(stateobjaddr1)
- so1.SetBalance(big.NewInt(52))
- so1.SetNonce(53)
- so1.SetCode(crypto.Keccak256Hash([]byte{'c', 'a', 'f', 'e', '2'}), []byte{'c', 'a', 'f', 'e', '2'})
- so1.suicided = true
- so1.deleted = true
- state.setStateObject(so1)
- so1 = state.getStateObject(stateobjaddr1)
- if so1 != nil {
- t.Fatalf("deleted object not nil when getting")
- }
- snapshot := state.Snapshot()
- state.RevertToSnapshot(snapshot)
- so0Restored := state.getStateObject(stateobjaddr0)
- // Update lazily-loaded values before comparing.
- so0Restored.GetState(state.db, storageaddr)
- so0Restored.Code(state.db)
- // non-deleted is equal (restored)
- compareStateObjects(so0Restored, so0, t)
- // deleted should be nil, both before and after restore of state copy
- so1Restored := state.getStateObject(stateobjaddr1)
- if so1Restored != nil {
- t.Fatalf("deleted object not nil after restoring snapshot: %+v", so1Restored)
- }
- }
- func compareStateObjects(so0, so1 *stateObject, t *testing.T) {
- if so0.Address() != so1.Address() {
- t.Fatalf("Address mismatch: have %v, want %v", so0.address, so1.address)
- }
- if so0.Balance().Cmp(so1.Balance()) != 0 {
- t.Fatalf("Balance mismatch: have %v, want %v", so0.Balance(), so1.Balance())
- }
- if so0.Nonce() != so1.Nonce() {
- t.Fatalf("Nonce mismatch: have %v, want %v", so0.Nonce(), so1.Nonce())
- }
- if so0.data.Root != so1.data.Root {
- t.Errorf("Root mismatch: have %x, want %x", so0.data.Root[:], so1.data.Root[:])
- }
- if !bytes.Equal(so0.CodeHash(), so1.CodeHash()) {
- t.Fatalf("CodeHash mismatch: have %v, want %v", so0.CodeHash(), so1.CodeHash())
- }
- if !bytes.Equal(so0.code, so1.code) {
- t.Fatalf("Code mismatch: have %v, want %v", so0.code, so1.code)
- }
- if len(so1.dirtyStorage) != len(so0.dirtyStorage) {
- t.Errorf("Dirty storage size mismatch: have %d, want %d", len(so1.dirtyStorage), len(so0.dirtyStorage))
- }
- for k, v := range so1.dirtyStorage {
- if so0.dirtyStorage[k] != v {
- t.Errorf("Dirty storage key %x mismatch: have %v, want %v", k, so0.dirtyStorage[k], v)
- }
- }
- for k, v := range so0.dirtyStorage {
- if so1.dirtyStorage[k] != v {
- t.Errorf("Dirty storage key %x mismatch: have %v, want none.", k, v)
- }
- }
- if len(so1.originStorage) != len(so0.originStorage) {
- t.Errorf("Origin storage size mismatch: have %d, want %d", len(so1.originStorage), len(so0.originStorage))
- }
- for k, v := range so1.originStorage {
- if so0.originStorage[k] != v {
- t.Errorf("Origin storage key %x mismatch: have %v, want %v", k, so0.originStorage[k], v)
- }
- }
- for k, v := range so0.originStorage {
- if so1.originStorage[k] != v {
- t.Errorf("Origin storage key %x mismatch: have %v, want none.", k, v)
- }
- }
- }
|