diff --git a/core/state/managed_state.go b/core/state/managed_state.go index f8e2f2b876..73d3a3fe3d 100644 --- a/core/state/managed_state.go +++ b/core/state/managed_state.go @@ -33,14 +33,14 @@ type ManagedState struct { mu sync.RWMutex - accounts map[string]*account + accounts map[common.Address]*account } // ManagedState returns a new managed state with the statedb as it's backing layer func ManageState(statedb *StateDB) *ManagedState { return &ManagedState{ StateDB: statedb.Copy(), - accounts: make(map[string]*account), + accounts: make(map[common.Address]*account), } } @@ -103,7 +103,7 @@ func (ms *ManagedState) SetNonce(addr common.Address, nonce uint64) { so := ms.GetOrNewStateObject(addr) so.SetNonce(nonce) - ms.accounts[addr.Str()] = newAccount(so) + ms.accounts[addr] = newAccount(so) } // HasAccount returns whether the given address is managed or not @@ -114,27 +114,26 @@ func (ms *ManagedState) HasAccount(addr common.Address) bool { } func (ms *ManagedState) hasAccount(addr common.Address) bool { - _, ok := ms.accounts[addr.Str()] + _, ok := ms.accounts[addr] return ok } // populate the managed state func (ms *ManagedState) getAccount(addr common.Address) *account { - straddr := addr.Str() - if account, ok := ms.accounts[straddr]; !ok { + if account, ok := ms.accounts[addr]; !ok { so := ms.GetOrNewStateObject(addr) - ms.accounts[straddr] = newAccount(so) + ms.accounts[addr] = newAccount(so) } else { // Always make sure the state account nonce isn't actually higher // than the tracked one. so := ms.StateDB.GetStateObject(addr) if so != nil && uint64(len(account.nonces))+account.nstart < so.nonce { - ms.accounts[straddr] = newAccount(so) + ms.accounts[addr] = newAccount(so) } } - return ms.accounts[straddr] + return ms.accounts[addr] } func newAccount(so *StateObject) *account { diff --git a/core/state/managed_state_test.go b/core/state/managed_state_test.go index 0b53a42c54..58e9369cf7 100644 --- a/core/state/managed_state_test.go +++ b/core/state/managed_state_test.go @@ -30,10 +30,10 @@ func create() (*ManagedState, *account) { statedb, _ := New(common.Hash{}, db) ms := ManageState(statedb) so := &StateObject{address: addr, nonce: 100} - ms.StateDB.stateObjects[addr.Str()] = so - ms.accounts[addr.Str()] = newAccount(so) + ms.StateDB.stateObjects[addr] = so + ms.accounts[addr] = newAccount(so) - return ms, ms.accounts[addr.Str()] + return ms, ms.accounts[addr] } func TestNewNonce(t *testing.T) { @@ -92,7 +92,7 @@ func TestRemoteNonceChange(t *testing.T) { account.nonces = append(account.nonces, nn...) nonce := ms.NewNonce(addr) - ms.StateDB.stateObjects[addr.Str()].nonce = 200 + ms.StateDB.stateObjects[addr].nonce = 200 nonce = ms.NewNonce(addr) if nonce != 200 { t.Error("expected nonce after remote update to be", 201, "got", nonce) @@ -100,7 +100,7 @@ func TestRemoteNonceChange(t *testing.T) { ms.NewNonce(addr) ms.NewNonce(addr) ms.NewNonce(addr) - ms.StateDB.stateObjects[addr.Str()].nonce = 200 + ms.StateDB.stateObjects[addr].nonce = 200 nonce = ms.NewNonce(addr) if nonce != 204 { t.Error("expected nonce after remote update to be", 201, "got", nonce) diff --git a/core/state/state_object.go b/core/state/state_object.go index 9f0ce5b4b1..dd55b3c74b 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -58,7 +58,6 @@ func (self Storage) Copy() Storage { } type StateObject struct { - db trie.Database // State database for storing state changes trie *trie.SecureTrie // Address belonging to this account @@ -84,7 +83,6 @@ type StateObject struct { func NewStateObject(address common.Address, db trie.Database) *StateObject { object := &StateObject{ - db: db, address: address, balance: new(big.Int), dirty: true, @@ -119,10 +117,6 @@ func (c *StateObject) setAddr(addr, value common.Hash) { c.trie.Update(addr[:], v) } -func (self *StateObject) Storage() Storage { - return self.storage -} - func (self *StateObject) GetState(key common.Hash) common.Hash { value, exists := self.storage[key] if !exists { @@ -178,15 +172,11 @@ func (c *StateObject) SetBalance(amount *big.Int) { c.dirty = true } -func (c *StateObject) St() Storage { - return c.storage -} - // Return the gas back to the origin. Used by the Virtual machine or Closures func (c *StateObject) ReturnGas(gas, price *big.Int) {} -func (self *StateObject) Copy() *StateObject { - stateObject := NewStateObject(self.Address(), self.db) +func (self *StateObject) Copy(db trie.Database) *StateObject { + stateObject := NewStateObject(self.address, db) stateObject.balance.Set(self.balance) stateObject.codeHash = common.CopyBytes(self.codeHash) stateObject.nonce = self.nonce @@ -278,7 +268,7 @@ func (c *StateObject) EncodeRLP(w io.Writer) error { // DecodeObject decodes an RLP-encoded state object. func DecodeObject(address common.Address, db trie.Database, data []byte) (*StateObject, error) { var ( - obj = &StateObject{address: address, db: db, storage: make(Storage)} + obj = &StateObject{address: address, storage: make(Storage)} ext extStateObject err error ) diff --git a/core/state/statedb.go b/core/state/statedb.go index 8ba81613d6..082dab7356 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -43,7 +43,7 @@ type StateDB struct { db ethdb.Database trie *trie.SecureTrie - stateObjects map[string]*StateObject + stateObjects map[common.Address]*StateObject refund *big.Int @@ -62,7 +62,7 @@ func New(root common.Hash, db ethdb.Database) (*StateDB, error) { return &StateDB{ db: db, trie: tr, - stateObjects: make(map[string]*StateObject), + stateObjects: make(map[common.Address]*StateObject), refund: new(big.Int), logs: make(map[common.Hash]vm.Logs), }, nil @@ -83,7 +83,7 @@ func (self *StateDB) Reset(root common.Hash) error { *self = StateDB{ db: self.db, trie: tr, - stateObjects: make(map[string]*StateObject), + stateObjects: make(map[common.Address]*StateObject), refund: new(big.Int), logs: make(map[common.Hash]vm.Logs), } @@ -242,12 +242,12 @@ func (self *StateDB) DeleteStateObject(stateObject *StateObject) { addr := stateObject.Address() self.trie.Delete(addr[:]) - //delete(self.stateObjects, addr.Str()) + //delete(self.stateObjects, addr) } // Retrieve a state object given my the address. Nil if not found func (self *StateDB) GetStateObject(addr common.Address) (stateObject *StateObject) { - stateObject = self.stateObjects[addr.Str()] + stateObject = self.stateObjects[addr] if stateObject != nil { if stateObject.deleted { stateObject = nil @@ -270,7 +270,7 @@ func (self *StateDB) GetStateObject(addr common.Address) (stateObject *StateObje } func (self *StateDB) SetStateObject(object *StateObject) { - self.stateObjects[object.Address().Str()] = object + self.stateObjects[object.Address()] = object } // Retrieve a state object or create a new state object if nil @@ -291,7 +291,7 @@ func (self *StateDB) newStateObject(addr common.Address) *StateObject { stateObject := NewStateObject(addr, self.db) stateObject.SetNonce(StartingNonce) - self.stateObjects[addr.Str()] = stateObject + self.stateObjects[addr] = stateObject return stateObject } @@ -323,9 +323,9 @@ func (self *StateDB) Copy() *StateDB { // ignore error - we assume state-to-be-copied always exists state, _ := New(common.Hash{}, self.db) state.trie = self.trie - for k, stateObject := range self.stateObjects { + for addr, stateObject := range self.stateObjects { if stateObject.dirty { - state.stateObjects[k] = stateObject.Copy() + state.stateObjects[addr] = stateObject.Copy(self.db) } }