From 1e8b54abfb7129fcdf4812ad01b6a7cd61e4f65d Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 22 Jul 2014 11:54:48 +0200 Subject: Refactored state, state object and vm * The State and StateObject have been moved to their own package * The VM is moved to it's own package --- ethstate/.ethtest | 0 ethstate/errors.go | 23 ++++ ethstate/state.go | 259 ++++++++++++++++++++++++++++++++++++ ethstate/state_object.go | 339 +++++++++++++++++++++++++++++++++++++++++++++++ ethstate/state_test.go | 35 +++++ 5 files changed, 656 insertions(+) create mode 100644 ethstate/.ethtest create mode 100644 ethstate/errors.go create mode 100644 ethstate/state.go create mode 100644 ethstate/state_object.go create mode 100644 ethstate/state_test.go (limited to 'ethstate') diff --git a/ethstate/.ethtest b/ethstate/.ethtest new file mode 100644 index 000000000..e69de29bb diff --git a/ethstate/errors.go b/ethstate/errors.go new file mode 100644 index 000000000..d5d7db86b --- /dev/null +++ b/ethstate/errors.go @@ -0,0 +1,23 @@ +package ethstate + +import ( + "fmt" + "math/big" +) + +type GasLimitErr struct { + Message string + Is, Max *big.Int +} + +func IsGasLimitErr(err error) bool { + _, ok := err.(*GasLimitErr) + + return ok +} +func (err *GasLimitErr) Error() string { + return err.Message +} +func GasLimitError(is, max *big.Int) *GasLimitErr { + return &GasLimitErr{Message: fmt.Sprintf("GasLimit error. Max %s, transaction would take it to %s", max, is), Is: is, Max: max} +} diff --git a/ethstate/state.go b/ethstate/state.go new file mode 100644 index 000000000..a4b9b1e9c --- /dev/null +++ b/ethstate/state.go @@ -0,0 +1,259 @@ +package ethstate + +import ( + "github.com/ethereum/eth-go/ethcrypto" + "github.com/ethereum/eth-go/ethlog" + "github.com/ethereum/eth-go/ethtrie" + "github.com/ethereum/eth-go/ethutil" + "math/big" +) + +var statelogger = ethlog.NewLogger("STATE") + +// States within the ethereum protocol are used to store anything +// within the merkle trie. States take care of caching and storing +// nested states. It's the general query interface to retrieve: +// * Contracts +// * Accounts +type State struct { + // The trie for this structure + trie *ethtrie.Trie + + stateObjects map[string]*StateObject + + manifest *Manifest +} + +// Create a new state from a given trie +func NewState(trie *ethtrie.Trie) *State { + return &State{trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest()} +} + +// Retrieve the balance from the given address or 0 if object not found +func (self *State) GetBalance(addr []byte) *big.Int { + stateObject := self.GetStateObject(addr) + if stateObject != nil { + return stateObject.Amount + } + + return ethutil.Big0 +} + +func (self *State) GetNonce(addr []byte) uint64 { + stateObject := self.GetStateObject(addr) + if stateObject != nil { + return stateObject.Nonce + } + + return 0 +} + +// +// Setting, updating & deleting state object methods +// + +// Update the given state object and apply it to state trie +func (self *State) UpdateStateObject(stateObject *StateObject) { + addr := stateObject.Address() + + ethutil.Config.Db.Put(ethcrypto.Sha3Bin(stateObject.Code), stateObject.Code) + + self.trie.Update(string(addr), string(stateObject.RlpEncode())) + + self.manifest.AddObjectChange(stateObject) +} + +// Delete the given state object and delete it from the state trie +func (self *State) DeleteStateObject(stateObject *StateObject) { + self.trie.Delete(string(stateObject.Address())) + + delete(self.stateObjects, string(stateObject.Address())) +} + +// Retrieve a state object given my the address. Nil if not found +func (self *State) GetStateObject(addr []byte) *StateObject { + addr = ethutil.Address(addr) + + stateObject := self.stateObjects[string(addr)] + if stateObject != nil { + return stateObject + } + + data := self.trie.Get(string(addr)) + if len(data) == 0 { + return nil + } + + stateObject = NewStateObjectFromBytes(addr, []byte(data)) + self.stateObjects[string(addr)] = stateObject + + return stateObject +} + +// Retrieve a state object or create a new state object if nil +func (self *State) GetOrNewStateObject(addr []byte) *StateObject { + stateObject := self.GetStateObject(addr) + if stateObject == nil { + stateObject = self.NewStateObject(addr) + } + + return stateObject +} + +// Create a state object whether it exist in the trie or not +func (self *State) NewStateObject(addr []byte) *StateObject { + addr = ethutil.Address(addr) + + statelogger.Infof("(+) %x\n", addr) + + stateObject := NewStateObject(addr) + self.stateObjects[string(addr)] = stateObject + + return stateObject +} + +// Deprecated +func (self *State) GetAccount(addr []byte) *StateObject { + return self.GetOrNewStateObject(addr) +} + +// +// Setting, copying of the state methods +// + +func (s *State) Cmp(other *State) bool { + return s.trie.Cmp(other.trie) +} + +func (self *State) Copy() *State { + if self.trie != nil { + state := NewState(self.trie.Copy()) + for k, stateObject := range self.stateObjects { + state.stateObjects[k] = stateObject.Copy() + } + + return state + } + + return nil +} + +func (self *State) Set(state *State) { + if state == nil { + panic("Tried setting 'state' to nil through 'Set'") + } + + self.trie = state.trie + self.stateObjects = state.stateObjects +} + +func (s *State) Root() interface{} { + return s.trie.Root +} + +// Resets the trie and all siblings +func (s *State) Reset() { + s.trie.Undo() + + // Reset all nested states + for _, stateObject := range s.stateObjects { + if stateObject.state == nil { + continue + } + + //stateObject.state.Reset() + stateObject.Reset() + } + + s.Empty() +} + +// Syncs the trie and all siblings +func (s *State) Sync() { + // Sync all nested states + for _, stateObject := range s.stateObjects { + //s.UpdateStateObject(stateObject) + + if stateObject.state == nil { + continue + } + + stateObject.state.Sync() + } + + s.trie.Sync() + + s.Empty() +} + +func (self *State) Empty() { + self.stateObjects = make(map[string]*StateObject) +} + +func (self *State) Update() { + for _, stateObject := range self.stateObjects { + if stateObject.remove { + self.DeleteStateObject(stateObject) + } else { + stateObject.Sync() + + self.UpdateStateObject(stateObject) + } + } + + // FIXME trie delete is broken + valid, t2 := ethtrie.ParanoiaCheck(self.trie) + if !valid { + statelogger.Infof("Warn: PARANOIA: Different state root during copy %x vs %x\n", self.trie.Root, t2.Root) + + self.trie = t2 + } +} + +// Debug stuff +func (self *State) CreateOutputForDiff() { + for _, stateObject := range self.stateObjects { + stateObject.CreateOutputForDiff() + } +} + +func (self *State) Manifest() *Manifest { + return self.manifest +} + +// Object manifest +// +// The object manifest is used to keep changes to the state so we can keep track of the changes +// that occurred during a state transitioning phase. +type Manifest struct { + // XXX These will be handy in the future. Not important for now. + objectAddresses map[string]bool + storageAddresses map[string]map[string]bool + + objectChanges map[string]*StateObject + storageChanges map[string]map[string]*big.Int +} + +func NewManifest() *Manifest { + m := &Manifest{objectAddresses: make(map[string]bool), storageAddresses: make(map[string]map[string]bool)} + m.Reset() + + return m +} + +func (m *Manifest) Reset() { + m.objectChanges = make(map[string]*StateObject) + m.storageChanges = make(map[string]map[string]*big.Int) +} + +func (m *Manifest) AddObjectChange(stateObject *StateObject) { + m.objectChanges[string(stateObject.Address())] = stateObject +} + +func (m *Manifest) AddStorageChange(stateObject *StateObject, storageAddr []byte, storage *big.Int) { + if m.storageChanges[string(stateObject.Address())] == nil { + m.storageChanges[string(stateObject.Address())] = make(map[string]*big.Int) + } + + m.storageChanges[string(stateObject.Address())][string(storageAddr)] = storage +} diff --git a/ethstate/state_object.go b/ethstate/state_object.go new file mode 100644 index 000000000..d8513f37d --- /dev/null +++ b/ethstate/state_object.go @@ -0,0 +1,339 @@ +package ethstate + +import ( + "fmt" + "github.com/ethereum/eth-go/ethcrypto" + "github.com/ethereum/eth-go/ethtrie" + "github.com/ethereum/eth-go/ethutil" + "math/big" +) + +type Code []byte + +func (self Code) String() string { + return "" //strings.Join(Disassemble(self), " ") +} + +type Storage map[string]*ethutil.Value + +func (self Storage) Copy() Storage { + cpy := make(Storage) + for key, value := range self { + // XXX Do we need a 'value' copy or is this sufficient? + cpy[key] = value + } + + return cpy +} + +type StateObject struct { + // Address of the object + address []byte + // Shared attributes + Amount *big.Int + CodeHash []byte + Nonce uint64 + // Contract related attributes + state *State + Code Code + initCode Code + + storage Storage + + // Total gas pool is the total amount of gas currently + // left if this object is the coinbase. Gas is directly + // purchased of the coinbase. + gasPool *big.Int + + // Mark for deletion + // When an object is marked for deletion it will be delete from the trie + // during the "update" phase of the state transition + remove bool +} + +func (self *StateObject) Reset() { + self.storage = make(Storage) + self.state.Reset() +} + +/* +// Converts an transaction in to a state object +func MakeContract(tx *Transaction, state *State) *StateObject { + // Create contract if there's no recipient + if tx.IsContract() { + addr := tx.CreationAddress() + + contract := state.NewStateObject(addr) + contract.initCode = tx.Data + contract.state = NewState(ethtrie.NewTrie(ethutil.Config.Db, "")) + + return contract + } + + return nil +} +*/ + +func NewStateObject(addr []byte) *StateObject { + // This to ensure that it has 20 bytes (and not 0 bytes), thus left or right pad doesn't matter. + address := ethutil.Address(addr) + + object := &StateObject{address: address, Amount: new(big.Int), gasPool: new(big.Int)} + object.state = NewState(ethtrie.NewTrie(ethutil.Config.Db, "")) + object.storage = make(Storage) + object.gasPool = new(big.Int) + + return object +} + +func NewContract(address []byte, Amount *big.Int, root []byte) *StateObject { + contract := NewStateObject(address) + contract.Amount = Amount + contract.state = NewState(ethtrie.NewTrie(ethutil.Config.Db, string(root))) + + return contract +} + +func NewStateObjectFromBytes(address, data []byte) *StateObject { + object := &StateObject{address: address} + object.RlpDecode(data) + + return object +} + +func (self *StateObject) MarkForDeletion() { + self.remove = true + statelogger.DebugDetailf("%x: #%d %v (deletion)\n", self.Address(), self.Nonce, self.Amount) +} + +func (c *StateObject) GetAddr(addr []byte) *ethutil.Value { + return ethutil.NewValueFromBytes([]byte(c.state.trie.Get(string(addr)))) +} + +func (c *StateObject) SetAddr(addr []byte, value interface{}) { + c.state.trie.Update(string(addr), string(ethutil.NewValue(value).Encode())) +} + +func (self *StateObject) GetStorage(key *big.Int) *ethutil.Value { + return self.getStorage(key.Bytes()) +} +func (self *StateObject) SetStorage(key *big.Int, value *ethutil.Value) { + self.setStorage(key.Bytes(), value) +} + +func (self *StateObject) getStorage(k []byte) *ethutil.Value { + key := ethutil.LeftPadBytes(k, 32) + + value := self.storage[string(key)] + if value == nil { + value = self.GetAddr(key) + + if !value.IsNil() { + self.storage[string(key)] = value + } + } + + return value + + //return self.GetAddr(key) +} + +func (self *StateObject) setStorage(k []byte, value *ethutil.Value) { + key := ethutil.LeftPadBytes(k, 32) + self.storage[string(key)] = value.Copy() +} + +// Iterate over each storage address and yield callback +func (self *StateObject) EachStorage(cb ethtrie.EachCallback) { + // First loop over the uncommit/cached values in storage + for key, value := range self.storage { + // XXX Most iterators Fns as it stands require encoded values + encoded := ethutil.NewValue(value.Encode()) + cb(key, encoded) + } + + it := self.state.trie.NewIterator() + it.Each(func(key string, value *ethutil.Value) { + // If it's cached don't call the callback. + if self.storage[key] == nil { + cb(key, value) + } + }) +} + +func (self *StateObject) Sync() { + for key, value := range self.storage { + if value.Len() == 0 { // value.BigInt().Cmp(ethutil.Big0) == 0 { + //data := self.getStorage([]byte(key)) + //fmt.Printf("deleting %x %x 0x%x\n", self.Address(), []byte(key), data) + self.state.trie.Delete(string(key)) + continue + } + + self.SetAddr([]byte(key), value) + } + + valid, t2 := ethtrie.ParanoiaCheck(self.state.trie) + if !valid { + statelogger.Infof("Warn: PARANOIA: Different state storage root during copy %x vs %x\n", self.state.trie.Root, t2.Root) + + self.state.trie = t2 + } +} + +func (c *StateObject) GetInstr(pc *big.Int) *ethutil.Value { + if int64(len(c.Code)-1) < pc.Int64() { + return ethutil.NewValue(0) + } + + return ethutil.NewValueFromBytes([]byte{c.Code[pc.Int64()]}) +} + +func (c *StateObject) AddAmount(amount *big.Int) { + c.SetAmount(new(big.Int).Add(c.Amount, amount)) + + statelogger.Debugf("%x: #%d %v (+ %v)\n", c.Address(), c.Nonce, c.Amount, amount) +} + +func (c *StateObject) SubAmount(amount *big.Int) { + c.SetAmount(new(big.Int).Sub(c.Amount, amount)) + + statelogger.Debugf("%x: #%d %v (- %v)\n", c.Address(), c.Nonce, c.Amount, amount) +} + +func (c *StateObject) SetAmount(amount *big.Int) { + c.Amount = amount +} + +// +// Gas setters and getters +// + +// Return the gas back to the origin. Used by the Virtual machine or Closures +func (c *StateObject) ReturnGas(gas, price *big.Int) {} +func (c *StateObject) ConvertGas(gas, price *big.Int) error { + total := new(big.Int).Mul(gas, price) + if total.Cmp(c.Amount) > 0 { + return fmt.Errorf("insufficient amount: %v, %v", c.Amount, total) + } + + c.SubAmount(total) + + return nil +} + +func (self *StateObject) SetGasPool(gasLimit *big.Int) { + self.gasPool = new(big.Int).Set(gasLimit) + + statelogger.DebugDetailf("%x: fuel (+ %v)", self.Address(), self.gasPool) +} + +func (self *StateObject) BuyGas(gas, price *big.Int) error { + if self.gasPool.Cmp(gas) < 0 { + return GasLimitError(self.gasPool, gas) + } + + rGas := new(big.Int).Set(gas) + rGas.Mul(rGas, price) + + self.AddAmount(rGas) + + return nil +} + +func (self *StateObject) RefundGas(gas, price *big.Int) { + self.gasPool.Add(self.gasPool, gas) + + rGas := new(big.Int).Set(gas) + rGas.Mul(rGas, price) + + self.Amount.Sub(self.Amount, rGas) +} + +func (self *StateObject) Copy() *StateObject { + stateObject := NewStateObject(self.Address()) + stateObject.Amount.Set(self.Amount) + stateObject.CodeHash = ethutil.CopyBytes(self.CodeHash) + stateObject.Nonce = self.Nonce + if self.state != nil { + stateObject.state = self.state.Copy() + } + stateObject.Code = ethutil.CopyBytes(self.Code) + stateObject.initCode = ethutil.CopyBytes(self.initCode) + stateObject.storage = self.storage.Copy() + stateObject.gasPool.Set(self.gasPool) + + return stateObject +} + +func (self *StateObject) Set(stateObject *StateObject) { + *self = *stateObject +} + +// +// Attribute accessors +// + +func (c *StateObject) State() *State { + return c.state +} + +func (c *StateObject) N() *big.Int { + return big.NewInt(int64(c.Nonce)) +} + +// Returns the address of the contract/account +func (c *StateObject) Address() []byte { + return c.address +} + +// Returns the initialization Code +func (c *StateObject) Init() Code { + return c.initCode +} + +// Debug stuff +func (self *StateObject) CreateOutputForDiff() { + fmt.Printf("%x %x %x %x\n", self.Address(), self.state.Root(), self.Amount.Bytes(), self.Nonce) + self.EachStorage(func(addr string, value *ethutil.Value) { + fmt.Printf("%x %x\n", addr, value.Bytes()) + }) +} + +// +// Encoding +// + +// State object encoding methods +func (c *StateObject) RlpEncode() []byte { + var root interface{} + if c.state != nil { + root = c.state.trie.Root + } else { + root = "" + } + + return ethutil.Encode([]interface{}{c.Nonce, c.Amount, root, ethcrypto.Sha3Bin(c.Code)}) +} + +func (c *StateObject) RlpDecode(data []byte) { + decoder := ethutil.NewValueFromBytes(data) + + c.Nonce = decoder.Get(0).Uint() + c.Amount = decoder.Get(1).BigInt() + c.state = NewState(ethtrie.NewTrie(ethutil.Config.Db, decoder.Get(2).Interface())) + c.storage = make(map[string]*ethutil.Value) + c.gasPool = new(big.Int) + + c.CodeHash = decoder.Get(3).Bytes() + + c.Code, _ = ethutil.Config.Db.Get(c.CodeHash) +} + +// Storage change object. Used by the manifest for notifying changes to +// the sub channels. +type StorageState struct { + StateAddress []byte + Address []byte + Value *big.Int +} diff --git a/ethstate/state_test.go b/ethstate/state_test.go new file mode 100644 index 000000000..cd13e80bc --- /dev/null +++ b/ethstate/state_test.go @@ -0,0 +1,35 @@ +package ethstate + +import ( + "github.com/ethereum/eth-go/ethdb" + "github.com/ethereum/eth-go/ethtrie" + "github.com/ethereum/eth-go/ethutil" + "testing" +) + +var ZeroHash256 = make([]byte, 32) + +func TestSnapshot(t *testing.T) { + db, _ := ethdb.NewMemDatabase() + ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "") + ethutil.Config.Db = db + + state := NewState(ethtrie.NewTrie(db, "")) + + stateObject := state.GetOrNewStateObject([]byte("aa")) + + stateObject.SetStorage(ethutil.Big("0"), ethutil.NewValue(42)) + + snapshot := state.Copy() + + stateObject = state.GetStateObject([]byte("aa")) + stateObject.SetStorage(ethutil.Big("0"), ethutil.NewValue(43)) + + state.Set(snapshot) + + stateObject = state.GetStateObject([]byte("aa")) + res := stateObject.GetStorage(ethutil.Big("0")) + if !res.Cmp(ethutil.NewValue(42)) { + t.Error("Expected storage 0 to be 42", res) + } +} -- cgit v1.2.3 From 490ca410c01a1b8076214d00c21d2edf09c24f86 Mon Sep 17 00:00:00 2001 From: obscuren Date: Tue, 22 Jul 2014 15:57:54 +0200 Subject: Minor improvements and fixes to the new vm structure --- ethstate/state_object.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ethstate') diff --git a/ethstate/state_object.go b/ethstate/state_object.go index d8513f37d..6b00c5369 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -11,7 +11,7 @@ import ( type Code []byte func (self Code) String() string { - return "" //strings.Join(Disassemble(self), " ") + return string(self) //strings.Join(Disassemble(self), " ") } type Storage map[string]*ethutil.Value -- cgit v1.2.3 From 32d125131f602d63f66ee7eb09439074f0b94a91 Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 24 Jul 2014 12:04:15 +0200 Subject: Refactored to new state and vm --- ethstate/state.go | 52 ++++++++++++++++++++++++------------------------ ethstate/state_object.go | 44 +++++++++++++++++++--------------------- 2 files changed, 46 insertions(+), 50 deletions(-) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index a4b9b1e9c..51b585d4d 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -17,7 +17,7 @@ var statelogger = ethlog.NewLogger("STATE") // * Accounts type State struct { // The trie for this structure - trie *ethtrie.Trie + Trie *ethtrie.Trie stateObjects map[string]*StateObject @@ -26,7 +26,7 @@ type State struct { // Create a new state from a given trie func NewState(trie *ethtrie.Trie) *State { - return &State{trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest()} + return &State{Trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest()} } // Retrieve the balance from the given address or 0 if object not found @@ -58,14 +58,14 @@ func (self *State) UpdateStateObject(stateObject *StateObject) { ethutil.Config.Db.Put(ethcrypto.Sha3Bin(stateObject.Code), stateObject.Code) - self.trie.Update(string(addr), string(stateObject.RlpEncode())) + self.Trie.Update(string(addr), string(stateObject.RlpEncode())) self.manifest.AddObjectChange(stateObject) } // Delete the given state object and delete it from the state trie func (self *State) DeleteStateObject(stateObject *StateObject) { - self.trie.Delete(string(stateObject.Address())) + self.Trie.Delete(string(stateObject.Address())) delete(self.stateObjects, string(stateObject.Address())) } @@ -79,7 +79,7 @@ func (self *State) GetStateObject(addr []byte) *StateObject { return stateObject } - data := self.trie.Get(string(addr)) + data := self.Trie.Get(string(addr)) if len(data) == 0 { return nil } @@ -122,12 +122,12 @@ func (self *State) GetAccount(addr []byte) *StateObject { // func (s *State) Cmp(other *State) bool { - return s.trie.Cmp(other.trie) + return s.Trie.Cmp(other.Trie) } func (self *State) Copy() *State { - if self.trie != nil { - state := NewState(self.trie.Copy()) + if self.Trie != nil { + state := NewState(self.Trie.Copy()) for k, stateObject := range self.stateObjects { state.stateObjects[k] = stateObject.Copy() } @@ -143,21 +143,21 @@ func (self *State) Set(state *State) { panic("Tried setting 'state' to nil through 'Set'") } - self.trie = state.trie + self.Trie = state.Trie self.stateObjects = state.stateObjects } func (s *State) Root() interface{} { - return s.trie.Root + return s.Trie.Root } // Resets the trie and all siblings func (s *State) Reset() { - s.trie.Undo() + s.Trie.Undo() // Reset all nested states for _, stateObject := range s.stateObjects { - if stateObject.state == nil { + if stateObject.State == nil { continue } @@ -174,14 +174,14 @@ func (s *State) Sync() { for _, stateObject := range s.stateObjects { //s.UpdateStateObject(stateObject) - if stateObject.state == nil { + if stateObject.State == nil { continue } - stateObject.state.Sync() + stateObject.State.Sync() } - s.trie.Sync() + s.Trie.Sync() s.Empty() } @@ -202,11 +202,11 @@ func (self *State) Update() { } // FIXME trie delete is broken - valid, t2 := ethtrie.ParanoiaCheck(self.trie) + valid, t2 := ethtrie.ParanoiaCheck(self.Trie) if !valid { - statelogger.Infof("Warn: PARANOIA: Different state root during copy %x vs %x\n", self.trie.Root, t2.Root) + statelogger.Infof("Warn: PARANOIA: Different state root during copy %x vs %x\n", self.Trie.Root, t2.Root) - self.trie = t2 + self.Trie = t2 } } @@ -230,8 +230,8 @@ type Manifest struct { objectAddresses map[string]bool storageAddresses map[string]map[string]bool - objectChanges map[string]*StateObject - storageChanges map[string]map[string]*big.Int + ObjectChanges map[string]*StateObject + StorageChanges map[string]map[string]*big.Int } func NewManifest() *Manifest { @@ -242,18 +242,18 @@ func NewManifest() *Manifest { } func (m *Manifest) Reset() { - m.objectChanges = make(map[string]*StateObject) - m.storageChanges = make(map[string]map[string]*big.Int) + m.ObjectChanges = make(map[string]*StateObject) + m.StorageChanges = make(map[string]map[string]*big.Int) } func (m *Manifest) AddObjectChange(stateObject *StateObject) { - m.objectChanges[string(stateObject.Address())] = stateObject + m.ObjectChanges[string(stateObject.Address())] = stateObject } func (m *Manifest) AddStorageChange(stateObject *StateObject, storageAddr []byte, storage *big.Int) { - if m.storageChanges[string(stateObject.Address())] == nil { - m.storageChanges[string(stateObject.Address())] = make(map[string]*big.Int) + if m.StorageChanges[string(stateObject.Address())] == nil { + m.StorageChanges[string(stateObject.Address())] = make(map[string]*big.Int) } - m.storageChanges[string(stateObject.Address())][string(storageAddr)] = storage + m.StorageChanges[string(stateObject.Address())][string(storageAddr)] = storage } diff --git a/ethstate/state_object.go b/ethstate/state_object.go index 6b00c5369..ab14b8604 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -34,9 +34,9 @@ type StateObject struct { CodeHash []byte Nonce uint64 // Contract related attributes - state *State + State *State Code Code - initCode Code + InitCode Code storage Storage @@ -53,7 +53,7 @@ type StateObject struct { func (self *StateObject) Reset() { self.storage = make(Storage) - self.state.Reset() + self.State.Reset() } /* @@ -79,7 +79,7 @@ func NewStateObject(addr []byte) *StateObject { address := ethutil.Address(addr) object := &StateObject{address: address, Amount: new(big.Int), gasPool: new(big.Int)} - object.state = NewState(ethtrie.NewTrie(ethutil.Config.Db, "")) + object.State = NewState(ethtrie.NewTrie(ethutil.Config.Db, "")) object.storage = make(Storage) object.gasPool = new(big.Int) @@ -89,7 +89,7 @@ func NewStateObject(addr []byte) *StateObject { func NewContract(address []byte, Amount *big.Int, root []byte) *StateObject { contract := NewStateObject(address) contract.Amount = Amount - contract.state = NewState(ethtrie.NewTrie(ethutil.Config.Db, string(root))) + contract.State = NewState(ethtrie.NewTrie(ethutil.Config.Db, string(root))) return contract } @@ -107,11 +107,11 @@ func (self *StateObject) MarkForDeletion() { } func (c *StateObject) GetAddr(addr []byte) *ethutil.Value { - return ethutil.NewValueFromBytes([]byte(c.state.trie.Get(string(addr)))) + return ethutil.NewValueFromBytes([]byte(c.State.Trie.Get(string(addr)))) } func (c *StateObject) SetAddr(addr []byte, value interface{}) { - c.state.trie.Update(string(addr), string(ethutil.NewValue(value).Encode())) + c.State.Trie.Update(string(addr), string(ethutil.NewValue(value).Encode())) } func (self *StateObject) GetStorage(key *big.Int) *ethutil.Value { @@ -152,7 +152,7 @@ func (self *StateObject) EachStorage(cb ethtrie.EachCallback) { cb(key, encoded) } - it := self.state.trie.NewIterator() + it := self.State.Trie.NewIterator() it.Each(func(key string, value *ethutil.Value) { // If it's cached don't call the callback. if self.storage[key] == nil { @@ -166,18 +166,18 @@ func (self *StateObject) Sync() { if value.Len() == 0 { // value.BigInt().Cmp(ethutil.Big0) == 0 { //data := self.getStorage([]byte(key)) //fmt.Printf("deleting %x %x 0x%x\n", self.Address(), []byte(key), data) - self.state.trie.Delete(string(key)) + self.State.Trie.Delete(string(key)) continue } self.SetAddr([]byte(key), value) } - valid, t2 := ethtrie.ParanoiaCheck(self.state.trie) + valid, t2 := ethtrie.ParanoiaCheck(self.State.Trie) if !valid { - statelogger.Infof("Warn: PARANOIA: Different state storage root during copy %x vs %x\n", self.state.trie.Root, t2.Root) + statelogger.Infof("Warn: PARANOIA: Different state storage root during copy %x vs %x\n", self.State.Trie.Root, t2.Root) - self.state.trie = t2 + self.State.Trie = t2 } } @@ -255,11 +255,11 @@ func (self *StateObject) Copy() *StateObject { stateObject.Amount.Set(self.Amount) stateObject.CodeHash = ethutil.CopyBytes(self.CodeHash) stateObject.Nonce = self.Nonce - if self.state != nil { - stateObject.state = self.state.Copy() + if self.State != nil { + stateObject.State = self.State.Copy() } stateObject.Code = ethutil.CopyBytes(self.Code) - stateObject.initCode = ethutil.CopyBytes(self.initCode) + stateObject.InitCode = ethutil.CopyBytes(self.InitCode) stateObject.storage = self.storage.Copy() stateObject.gasPool.Set(self.gasPool) @@ -274,10 +274,6 @@ func (self *StateObject) Set(stateObject *StateObject) { // Attribute accessors // -func (c *StateObject) State() *State { - return c.state -} - func (c *StateObject) N() *big.Int { return big.NewInt(int64(c.Nonce)) } @@ -289,12 +285,12 @@ func (c *StateObject) Address() []byte { // Returns the initialization Code func (c *StateObject) Init() Code { - return c.initCode + return c.InitCode } // Debug stuff func (self *StateObject) CreateOutputForDiff() { - fmt.Printf("%x %x %x %x\n", self.Address(), self.state.Root(), self.Amount.Bytes(), self.Nonce) + fmt.Printf("%x %x %x %x\n", self.Address(), self.State.Root(), self.Amount.Bytes(), self.Nonce) self.EachStorage(func(addr string, value *ethutil.Value) { fmt.Printf("%x %x\n", addr, value.Bytes()) }) @@ -307,8 +303,8 @@ func (self *StateObject) CreateOutputForDiff() { // State object encoding methods func (c *StateObject) RlpEncode() []byte { var root interface{} - if c.state != nil { - root = c.state.trie.Root + if c.State != nil { + root = c.State.Trie.Root } else { root = "" } @@ -321,7 +317,7 @@ func (c *StateObject) RlpDecode(data []byte) { c.Nonce = decoder.Get(0).Uint() c.Amount = decoder.Get(1).BigInt() - c.state = NewState(ethtrie.NewTrie(ethutil.Config.Db, decoder.Get(2).Interface())) + c.State = NewState(ethtrie.NewTrie(ethutil.Config.Db, decoder.Get(2).Interface())) c.storage = make(map[string]*ethutil.Value) c.gasPool = new(big.Int) -- cgit v1.2.3 From 1f9894c0845a5259adbfd30fe3a86631e6403b8d Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 30 Jul 2014 00:31:15 +0200 Subject: Old code removed and renamed amount to balance --- ethstate/state.go | 5 +++-- ethstate/state_object.go | 39 ++++++++++++++++++++------------------- 2 files changed, 23 insertions(+), 21 deletions(-) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index 51b585d4d..693a591c3 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -1,11 +1,12 @@ package ethstate import ( + "math/big" + "github.com/ethereum/eth-go/ethcrypto" "github.com/ethereum/eth-go/ethlog" "github.com/ethereum/eth-go/ethtrie" "github.com/ethereum/eth-go/ethutil" - "math/big" ) var statelogger = ethlog.NewLogger("STATE") @@ -33,7 +34,7 @@ func NewState(trie *ethtrie.Trie) *State { func (self *State) GetBalance(addr []byte) *big.Int { stateObject := self.GetStateObject(addr) if stateObject != nil { - return stateObject.Amount + return stateObject.Balance } return ethutil.Big0 diff --git a/ethstate/state_object.go b/ethstate/state_object.go index ab14b8604..5932fbee6 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -2,10 +2,11 @@ package ethstate import ( "fmt" + "math/big" + "github.com/ethereum/eth-go/ethcrypto" "github.com/ethereum/eth-go/ethtrie" "github.com/ethereum/eth-go/ethutil" - "math/big" ) type Code []byte @@ -30,7 +31,7 @@ type StateObject struct { // Address of the object address []byte // Shared attributes - Amount *big.Int + Balance *big.Int CodeHash []byte Nonce uint64 // Contract related attributes @@ -78,7 +79,7 @@ func NewStateObject(addr []byte) *StateObject { // This to ensure that it has 20 bytes (and not 0 bytes), thus left or right pad doesn't matter. address := ethutil.Address(addr) - object := &StateObject{address: address, Amount: new(big.Int), gasPool: new(big.Int)} + object := &StateObject{address: address, Balance: new(big.Int), gasPool: new(big.Int)} object.State = NewState(ethtrie.NewTrie(ethutil.Config.Db, "")) object.storage = make(Storage) object.gasPool = new(big.Int) @@ -86,9 +87,9 @@ func NewStateObject(addr []byte) *StateObject { return object } -func NewContract(address []byte, Amount *big.Int, root []byte) *StateObject { +func NewContract(address []byte, balance *big.Int, root []byte) *StateObject { contract := NewStateObject(address) - contract.Amount = Amount + contract.Balance = balance contract.State = NewState(ethtrie.NewTrie(ethutil.Config.Db, string(root))) return contract @@ -103,7 +104,7 @@ func NewStateObjectFromBytes(address, data []byte) *StateObject { func (self *StateObject) MarkForDeletion() { self.remove = true - statelogger.DebugDetailf("%x: #%d %v (deletion)\n", self.Address(), self.Nonce, self.Amount) + statelogger.DebugDetailf("%x: #%d %v (deletion)\n", self.Address(), self.Nonce, self.Balance) } func (c *StateObject) GetAddr(addr []byte) *ethutil.Value { @@ -190,19 +191,19 @@ func (c *StateObject) GetInstr(pc *big.Int) *ethutil.Value { } func (c *StateObject) AddAmount(amount *big.Int) { - c.SetAmount(new(big.Int).Add(c.Amount, amount)) + c.SetBalance(new(big.Int).Add(c.Balance, amount)) - statelogger.Debugf("%x: #%d %v (+ %v)\n", c.Address(), c.Nonce, c.Amount, amount) + statelogger.Debugf("%x: #%d %v (+ %v)\n", c.Address(), c.Nonce, c.Balance, amount) } func (c *StateObject) SubAmount(amount *big.Int) { - c.SetAmount(new(big.Int).Sub(c.Amount, amount)) + c.SetBalance(new(big.Int).Sub(c.Balance, amount)) - statelogger.Debugf("%x: #%d %v (- %v)\n", c.Address(), c.Nonce, c.Amount, amount) + statelogger.Debugf("%x: #%d %v (- %v)\n", c.Address(), c.Nonce, c.Balance, amount) } -func (c *StateObject) SetAmount(amount *big.Int) { - c.Amount = amount +func (c *StateObject) SetBalance(amount *big.Int) { + c.Balance = amount } // @@ -213,8 +214,8 @@ func (c *StateObject) SetAmount(amount *big.Int) { func (c *StateObject) ReturnGas(gas, price *big.Int) {} func (c *StateObject) ConvertGas(gas, price *big.Int) error { total := new(big.Int).Mul(gas, price) - if total.Cmp(c.Amount) > 0 { - return fmt.Errorf("insufficient amount: %v, %v", c.Amount, total) + if total.Cmp(c.Balance) > 0 { + return fmt.Errorf("insufficient amount: %v, %v", c.Balance, total) } c.SubAmount(total) @@ -247,12 +248,12 @@ func (self *StateObject) RefundGas(gas, price *big.Int) { rGas := new(big.Int).Set(gas) rGas.Mul(rGas, price) - self.Amount.Sub(self.Amount, rGas) + self.Balance.Sub(self.Balance, rGas) } func (self *StateObject) Copy() *StateObject { stateObject := NewStateObject(self.Address()) - stateObject.Amount.Set(self.Amount) + stateObject.Balance.Set(self.Balance) stateObject.CodeHash = ethutil.CopyBytes(self.CodeHash) stateObject.Nonce = self.Nonce if self.State != nil { @@ -290,7 +291,7 @@ func (c *StateObject) Init() Code { // Debug stuff func (self *StateObject) CreateOutputForDiff() { - fmt.Printf("%x %x %x %x\n", self.Address(), self.State.Root(), self.Amount.Bytes(), self.Nonce) + fmt.Printf("%x %x %x %x\n", self.Address(), self.State.Root(), self.Balance.Bytes(), self.Nonce) self.EachStorage(func(addr string, value *ethutil.Value) { fmt.Printf("%x %x\n", addr, value.Bytes()) }) @@ -309,14 +310,14 @@ func (c *StateObject) RlpEncode() []byte { root = "" } - return ethutil.Encode([]interface{}{c.Nonce, c.Amount, root, ethcrypto.Sha3Bin(c.Code)}) + return ethutil.Encode([]interface{}{c.Nonce, c.Balance, root, ethcrypto.Sha3Bin(c.Code)}) } func (c *StateObject) RlpDecode(data []byte) { decoder := ethutil.NewValueFromBytes(data) c.Nonce = decoder.Get(0).Uint() - c.Amount = decoder.Get(1).BigInt() + c.Balance = decoder.Get(1).BigInt() c.State = NewState(ethtrie.NewTrie(ethutil.Config.Db, decoder.Get(2).Interface())) c.storage = make(map[string]*ethutil.Value) c.gasPool = new(big.Int) -- cgit v1.2.3 From 3debeb7236d2c8474fa9049cc91dc26bf1040b3f Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 4 Aug 2014 10:38:18 +0200 Subject: ethtrie.NewTrie => ethtrie.New --- ethstate/state_object.go | 24 +++--------------------- 1 file changed, 3 insertions(+), 21 deletions(-) (limited to 'ethstate') diff --git a/ethstate/state_object.go b/ethstate/state_object.go index 5932fbee6..309e3e762 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -57,30 +57,12 @@ func (self *StateObject) Reset() { self.State.Reset() } -/* -// Converts an transaction in to a state object -func MakeContract(tx *Transaction, state *State) *StateObject { - // Create contract if there's no recipient - if tx.IsContract() { - addr := tx.CreationAddress() - - contract := state.NewStateObject(addr) - contract.initCode = tx.Data - contract.state = NewState(ethtrie.NewTrie(ethutil.Config.Db, "")) - - return contract - } - - return nil -} -*/ - func NewStateObject(addr []byte) *StateObject { // This to ensure that it has 20 bytes (and not 0 bytes), thus left or right pad doesn't matter. address := ethutil.Address(addr) object := &StateObject{address: address, Balance: new(big.Int), gasPool: new(big.Int)} - object.State = NewState(ethtrie.NewTrie(ethutil.Config.Db, "")) + object.State = NewState(ethtrie.New(ethutil.Config.Db, "")) object.storage = make(Storage) object.gasPool = new(big.Int) @@ -90,7 +72,7 @@ func NewStateObject(addr []byte) *StateObject { func NewContract(address []byte, balance *big.Int, root []byte) *StateObject { contract := NewStateObject(address) contract.Balance = balance - contract.State = NewState(ethtrie.NewTrie(ethutil.Config.Db, string(root))) + contract.State = NewState(ethtrie.New(ethutil.Config.Db, string(root))) return contract } @@ -318,7 +300,7 @@ func (c *StateObject) RlpDecode(data []byte) { c.Nonce = decoder.Get(0).Uint() c.Balance = decoder.Get(1).BigInt() - c.State = NewState(ethtrie.NewTrie(ethutil.Config.Db, decoder.Get(2).Interface())) + c.State = NewState(ethtrie.New(ethutil.Config.Db, decoder.Get(2).Interface())) c.storage = make(map[string]*ethutil.Value) c.gasPool = new(big.Int) -- cgit v1.2.3 From 03ce15df4c7ef51d4373233ab5c3766282b31771 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 4 Aug 2014 10:42:40 +0200 Subject: ethstate.NewState => ethstate.New --- ethstate/state.go | 4 ++-- ethstate/state_object.go | 6 +++--- ethstate/state_test.go | 5 +++-- 3 files changed, 8 insertions(+), 7 deletions(-) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index 693a591c3..10bcf6335 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -26,7 +26,7 @@ type State struct { } // Create a new state from a given trie -func NewState(trie *ethtrie.Trie) *State { +func New(trie *ethtrie.Trie) *State { return &State{Trie: trie, stateObjects: make(map[string]*StateObject), manifest: NewManifest()} } @@ -128,7 +128,7 @@ func (s *State) Cmp(other *State) bool { func (self *State) Copy() *State { if self.Trie != nil { - state := NewState(self.Trie.Copy()) + state := New(self.Trie.Copy()) for k, stateObject := range self.stateObjects { state.stateObjects[k] = stateObject.Copy() } diff --git a/ethstate/state_object.go b/ethstate/state_object.go index 309e3e762..67d09edd8 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -62,7 +62,7 @@ func NewStateObject(addr []byte) *StateObject { address := ethutil.Address(addr) object := &StateObject{address: address, Balance: new(big.Int), gasPool: new(big.Int)} - object.State = NewState(ethtrie.New(ethutil.Config.Db, "")) + object.State = New(ethtrie.New(ethutil.Config.Db, "")) object.storage = make(Storage) object.gasPool = new(big.Int) @@ -72,7 +72,7 @@ func NewStateObject(addr []byte) *StateObject { func NewContract(address []byte, balance *big.Int, root []byte) *StateObject { contract := NewStateObject(address) contract.Balance = balance - contract.State = NewState(ethtrie.New(ethutil.Config.Db, string(root))) + contract.State = New(ethtrie.New(ethutil.Config.Db, string(root))) return contract } @@ -300,7 +300,7 @@ func (c *StateObject) RlpDecode(data []byte) { c.Nonce = decoder.Get(0).Uint() c.Balance = decoder.Get(1).BigInt() - c.State = NewState(ethtrie.New(ethutil.Config.Db, decoder.Get(2).Interface())) + c.State = New(ethtrie.New(ethutil.Config.Db, decoder.Get(2).Interface())) c.storage = make(map[string]*ethutil.Value) c.gasPool = new(big.Int) diff --git a/ethstate/state_test.go b/ethstate/state_test.go index cd13e80bc..00c9de9d6 100644 --- a/ethstate/state_test.go +++ b/ethstate/state_test.go @@ -1,10 +1,11 @@ package ethstate import ( + "testing" + "github.com/ethereum/eth-go/ethdb" "github.com/ethereum/eth-go/ethtrie" "github.com/ethereum/eth-go/ethutil" - "testing" ) var ZeroHash256 = make([]byte, 32) @@ -14,7 +15,7 @@ func TestSnapshot(t *testing.T) { ethutil.ReadConfig(".ethtest", "/tmp/ethtest", "") ethutil.Config.Db = db - state := NewState(ethtrie.NewTrie(db, "")) + state := New(ethtrie.New(db, "")) stateObject := state.GetOrNewStateObject([]byte("aa")) -- cgit v1.2.3 From da50c751480da32036f41ccbeb1f292694ca0286 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 6 Aug 2014 09:53:00 +0200 Subject: Added state dump method --- ethstate/dump.go | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) create mode 100644 ethstate/dump.go (limited to 'ethstate') diff --git a/ethstate/dump.go b/ethstate/dump.go new file mode 100644 index 000000000..2406dfc49 --- /dev/null +++ b/ethstate/dump.go @@ -0,0 +1,47 @@ +package ethstate + +import ( + "encoding/json" + "fmt" + + "github.com/ethereum/eth-go/ethutil" +) + +type Account struct { + Balance string `json:"balance"` + Nonce uint64 `json:"nonce"` + CodeHash string `json:"codeHash"` + Storage map[string]string `json:"storage"` +} + +type World struct { + Root string `json:"root"` + Accounts map[string]Account `json:"accounts"` +} + +func (self *State) Dump() string { + world := World{ + Root: ethutil.Bytes2Hex(self.Trie.Root.([]byte)), + Accounts: make(map[string]Account), + } + + self.Trie.NewIterator().Each(func(key string, value *ethutil.Value) { + stateObject := NewStateObjectFromBytes([]byte(key), value.Bytes()) + + account := Account{Balance: stateObject.Balance.String(), Nonce: stateObject.Nonce, CodeHash: ethutil.Bytes2Hex(stateObject.CodeHash)} + account.Storage = make(map[string]string) + + stateObject.EachStorage(func(key string, value *ethutil.Value) { + value.Decode() + account.Storage[ethutil.Bytes2Hex([]byte(key))] = ethutil.Bytes2Hex(value.Bytes()) + }) + world.Accounts[ethutil.Bytes2Hex([]byte(key))] = account + }) + + json, err := json.MarshalIndent(world, "", " ") + if err != nil { + fmt.Println("dump err", err) + } + + return string(json) +} -- cgit v1.2.3 From 2e5d28c73f1d97865def3ffe8c7ad0a4819f15f3 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 11 Aug 2014 16:23:17 +0200 Subject: Added bloom filter & block filter methods --- ethstate/manifest.go | 67 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 ethstate/manifest.go (limited to 'ethstate') diff --git a/ethstate/manifest.go b/ethstate/manifest.go new file mode 100644 index 000000000..b771127a6 --- /dev/null +++ b/ethstate/manifest.go @@ -0,0 +1,67 @@ +package ethstate + +import ( + "fmt" + "math/big" +) + +// Object manifest +// +// The object manifest is used to keep changes to the state so we can keep track of the changes +// that occurred during a state transitioning phase. +type Manifest struct { + // XXX These will be handy in the future. Not important for now. + objectAddresses map[string]bool + storageAddresses map[string]map[string]bool + + ObjectChanges map[string]*StateObject + StorageChanges map[string]map[string]*big.Int + + Messages []*Message +} + +func NewManifest() *Manifest { + m := &Manifest{objectAddresses: make(map[string]bool), storageAddresses: make(map[string]map[string]bool)} + m.Reset() + + return m +} + +func (m *Manifest) Reset() { + m.ObjectChanges = make(map[string]*StateObject) + m.StorageChanges = make(map[string]map[string]*big.Int) +} + +func (m *Manifest) AddObjectChange(stateObject *StateObject) { + m.ObjectChanges[string(stateObject.Address())] = stateObject +} + +func (m *Manifest) AddStorageChange(stateObject *StateObject, storageAddr []byte, storage *big.Int) { + if m.StorageChanges[string(stateObject.Address())] == nil { + m.StorageChanges[string(stateObject.Address())] = make(map[string]*big.Int) + } + + m.StorageChanges[string(stateObject.Address())][string(storageAddr)] = storage +} + +func (self *Manifest) AddMessage(msg *Message) *Message { + self.Messages = append(self.Messages, msg) + + return msg +} + +type Message struct { + To, From []byte + Input []byte + Output []byte + Path int + Origin []byte + Timestamp int64 + Coinbase []byte + Block []byte + Number *big.Int +} + +func (self *Message) String() string { + return fmt.Sprintf("Message{to: %x from: %x input: %x output: %x origin: %x coinbase: %x block: %x number: %v timestamp: %d path: %d", self.To, self.From, self.Input, self.Output, self.Origin, self.Coinbase, self.Block, self.Number, self.Timestamp, self.Path) +} -- cgit v1.2.3 From a760ce05b948e89bc564af20599dcf95698ac0eb Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 11 Aug 2014 16:23:38 +0200 Subject: Updated chain for filtering --- ethstate/state.go | 45 ++++----------------------------------------- 1 file changed, 4 insertions(+), 41 deletions(-) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index 10bcf6335..19210916e 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -211,50 +211,13 @@ func (self *State) Update() { } } -// Debug stuff -func (self *State) CreateOutputForDiff() { - for _, stateObject := range self.stateObjects { - stateObject.CreateOutputForDiff() - } -} - func (self *State) Manifest() *Manifest { return self.manifest } -// Object manifest -// -// The object manifest is used to keep changes to the state so we can keep track of the changes -// that occurred during a state transitioning phase. -type Manifest struct { - // XXX These will be handy in the future. Not important for now. - objectAddresses map[string]bool - storageAddresses map[string]map[string]bool - - ObjectChanges map[string]*StateObject - StorageChanges map[string]map[string]*big.Int -} - -func NewManifest() *Manifest { - m := &Manifest{objectAddresses: make(map[string]bool), storageAddresses: make(map[string]map[string]bool)} - m.Reset() - - return m -} - -func (m *Manifest) Reset() { - m.ObjectChanges = make(map[string]*StateObject) - m.StorageChanges = make(map[string]map[string]*big.Int) -} - -func (m *Manifest) AddObjectChange(stateObject *StateObject) { - m.ObjectChanges[string(stateObject.Address())] = stateObject -} - -func (m *Manifest) AddStorageChange(stateObject *StateObject, storageAddr []byte, storage *big.Int) { - if m.StorageChanges[string(stateObject.Address())] == nil { - m.StorageChanges[string(stateObject.Address())] = make(map[string]*big.Int) +// Debug stuff +func (self *State) CreateOutputForDiff() { + for _, stateObject := range self.stateObjects { + stateObject.CreateOutputForDiff() } - - m.StorageChanges[string(stateObject.Address())][string(storageAddr)] = storage } -- cgit v1.2.3 From c7ee9844bd6f8ed2bb466f8adf21f437ecc83564 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 15 Aug 2014 00:25:16 +0200 Subject: Removed old code --- ethstate/manifest.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'ethstate') diff --git a/ethstate/manifest.go b/ethstate/manifest.go index b771127a6..88ce673b9 100644 --- a/ethstate/manifest.go +++ b/ethstate/manifest.go @@ -17,7 +17,7 @@ type Manifest struct { ObjectChanges map[string]*StateObject StorageChanges map[string]map[string]*big.Int - Messages []*Message + Messages Messages } func NewManifest() *Manifest { @@ -50,6 +50,7 @@ func (self *Manifest) AddMessage(msg *Message) *Message { return msg } +type Messages []*Message type Message struct { To, From []byte Input []byte -- cgit v1.2.3 From 7d95e8624a3bdca4a68b2a7ff6ed133264088cc1 Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 15 Aug 2014 16:19:10 +0200 Subject: Added message to closure && added change addresses --- ethstate/manifest.go | 30 ++++++++---------------------- ethstate/state.go | 2 -- 2 files changed, 8 insertions(+), 24 deletions(-) (limited to 'ethstate') diff --git a/ethstate/manifest.go b/ethstate/manifest.go index 88ce673b9..604f77b89 100644 --- a/ethstate/manifest.go +++ b/ethstate/manifest.go @@ -10,38 +10,18 @@ import ( // The object manifest is used to keep changes to the state so we can keep track of the changes // that occurred during a state transitioning phase. type Manifest struct { - // XXX These will be handy in the future. Not important for now. - objectAddresses map[string]bool - storageAddresses map[string]map[string]bool - - ObjectChanges map[string]*StateObject - StorageChanges map[string]map[string]*big.Int - Messages Messages } func NewManifest() *Manifest { - m := &Manifest{objectAddresses: make(map[string]bool), storageAddresses: make(map[string]map[string]bool)} + m := &Manifest{} m.Reset() return m } func (m *Manifest) Reset() { - m.ObjectChanges = make(map[string]*StateObject) - m.StorageChanges = make(map[string]map[string]*big.Int) -} - -func (m *Manifest) AddObjectChange(stateObject *StateObject) { - m.ObjectChanges[string(stateObject.Address())] = stateObject -} - -func (m *Manifest) AddStorageChange(stateObject *StateObject, storageAddr []byte, storage *big.Int) { - if m.StorageChanges[string(stateObject.Address())] == nil { - m.StorageChanges[string(stateObject.Address())] = make(map[string]*big.Int) - } - - m.StorageChanges[string(stateObject.Address())][string(storageAddr)] = storage + m.Messages = nil } func (self *Manifest) AddMessage(msg *Message) *Message { @@ -61,6 +41,12 @@ type Message struct { Coinbase []byte Block []byte Number *big.Int + + ChangedAddresses [][]byte +} + +func (self *Message) AddStorageChange(addr []byte) { + self.ChangedAddresses = append(self.ChangedAddresses, addr) } func (self *Message) String() string { diff --git a/ethstate/state.go b/ethstate/state.go index 19210916e..cf060e795 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -60,8 +60,6 @@ func (self *State) UpdateStateObject(stateObject *StateObject) { ethutil.Config.Db.Put(ethcrypto.Sha3Bin(stateObject.Code), stateObject.Code) self.Trie.Update(string(addr), string(stateObject.RlpEncode())) - - self.manifest.AddObjectChange(stateObject) } // Delete the given state object and delete it from the state trie -- cgit v1.2.3 From 793e666f36e512bceb0d92d0a8dfe1d7c508c0e2 Mon Sep 17 00:00:00 2001 From: obscuren Date: Sun, 17 Aug 2014 12:42:32 +0200 Subject: Dump bytes instead of strings --- ethstate/dump.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'ethstate') diff --git a/ethstate/dump.go b/ethstate/dump.go index 2406dfc49..be60a05fc 100644 --- a/ethstate/dump.go +++ b/ethstate/dump.go @@ -19,7 +19,7 @@ type World struct { Accounts map[string]Account `json:"accounts"` } -func (self *State) Dump() string { +func (self *State) Dump() []byte { world := World{ Root: ethutil.Bytes2Hex(self.Trie.Root.([]byte)), Accounts: make(map[string]Account), @@ -43,5 +43,5 @@ func (self *State) Dump() string { fmt.Println("dump err", err) } - return string(json) + return json } -- cgit v1.2.3 From b0ae61c6521003d7861d89944e1d426e939535bb Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 18 Aug 2014 10:17:45 +0200 Subject: Removed the "Get" part --- ethstate/manifest.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'ethstate') diff --git a/ethstate/manifest.go b/ethstate/manifest.go index 604f77b89..945de22ab 100644 --- a/ethstate/manifest.go +++ b/ethstate/manifest.go @@ -41,6 +41,7 @@ type Message struct { Coinbase []byte Block []byte Number *big.Int + Value *big.Int ChangedAddresses [][]byte } @@ -50,5 +51,5 @@ func (self *Message) AddStorageChange(addr []byte) { } func (self *Message) String() string { - return fmt.Sprintf("Message{to: %x from: %x input: %x output: %x origin: %x coinbase: %x block: %x number: %v timestamp: %d path: %d", self.To, self.From, self.Input, self.Output, self.Origin, self.Coinbase, self.Block, self.Number, self.Timestamp, self.Path) + return fmt.Sprintf("Message{to: %x from: %x input: %x output: %x origin: %x coinbase: %x block: %x number: %v timestamp: %d path: %d value: %v", self.To, self.From, self.Input, self.Output, self.Origin, self.Coinbase, self.Block, self.Number, self.Timestamp, self.Path, self.Value) } -- cgit v1.2.3 From 42d43147cac99469eb3f445342fe9e1ebeb5222e Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 22 Aug 2014 10:58:49 +0200 Subject: Changed log statements --- ethstate/state.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index cf060e795..2f7f00a32 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -103,7 +103,7 @@ func (self *State) GetOrNewStateObject(addr []byte) *StateObject { func (self *State) NewStateObject(addr []byte) *StateObject { addr = ethutil.Address(addr) - statelogger.Infof("(+) %x\n", addr) + statelogger.Debugf("(+) %x\n", addr) stateObject := NewStateObject(addr) self.stateObjects[string(addr)] = stateObject -- cgit v1.2.3 From 3f904bf3acb5779f68834ebca95825ea1990f85b Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 25 Aug 2014 11:29:42 +0200 Subject: Implemented POST --- ethstate/state_object.go | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'ethstate') diff --git a/ethstate/state_object.go b/ethstate/state_object.go index 67d09edd8..bf4e92583 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -245,6 +245,7 @@ func (self *StateObject) Copy() *StateObject { stateObject.InitCode = ethutil.CopyBytes(self.InitCode) stateObject.storage = self.storage.Copy() stateObject.gasPool.Set(self.gasPool) + stateObject.remove = self.remove return stateObject } @@ -271,6 +272,11 @@ func (c *StateObject) Init() Code { return c.InitCode } +// To satisfy ClosureRef +func (self *StateObject) Object() *StateObject { + return self +} + // Debug stuff func (self *StateObject) CreateOutputForDiff() { fmt.Printf("%x %x %x %x\n", self.Address(), self.State.Root(), self.Balance.Bytes(), self.Nonce) -- cgit v1.2.3 From d91357d00ca080c63d81570504e5c45fb15e3841 Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 8 Sep 2014 00:50:04 +0200 Subject: Added GetCode method --- ethstate/state.go | 9 +++++++++ ethstate/state_object.go | 6 +++++- 2 files changed, 14 insertions(+), 1 deletion(-) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index 2f7f00a32..42bbf021b 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -49,6 +49,15 @@ func (self *State) GetNonce(addr []byte) uint64 { return 0 } +func (self *State) GetCode(addr []byte) []byte { + stateObject := self.GetStateObject(addr) + if stateObject != nil { + return stateObject.Code + } + + return nil +} + // // Setting, updating & deleting state object methods // diff --git a/ethstate/state_object.go b/ethstate/state_object.go index bf4e92583..6fc0696a8 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -297,8 +297,12 @@ func (c *StateObject) RlpEncode() []byte { } else { root = "" } + var codeHash []byte + if len(c.Code) > 0 { + codeHash = ethcrypto.Sha3Bin(c.Code) + } - return ethutil.Encode([]interface{}{c.Nonce, c.Balance, root, ethcrypto.Sha3Bin(c.Code)}) + return ethutil.Encode([]interface{}{c.Nonce, c.Balance, root, codeHash}) } func (c *StateObject) RlpDecode(data []byte) { -- cgit v1.2.3 From 33a0dec8a157b9687ca6038f4deb011f3f1f7bdc Mon Sep 17 00:00:00 2001 From: obscuren Date: Mon, 15 Sep 2014 15:42:12 +0200 Subject: Improved catching up and refactored --- ethstate/dump.go | 2 +- ethstate/state.go | 5 +++-- ethstate/state_object.go | 15 ++++++++++----- 3 files changed, 14 insertions(+), 8 deletions(-) (limited to 'ethstate') diff --git a/ethstate/dump.go b/ethstate/dump.go index be60a05fc..cdd4228b8 100644 --- a/ethstate/dump.go +++ b/ethstate/dump.go @@ -28,7 +28,7 @@ func (self *State) Dump() []byte { self.Trie.NewIterator().Each(func(key string, value *ethutil.Value) { stateObject := NewStateObjectFromBytes([]byte(key), value.Bytes()) - account := Account{Balance: stateObject.Balance.String(), Nonce: stateObject.Nonce, CodeHash: ethutil.Bytes2Hex(stateObject.CodeHash)} + account := Account{Balance: stateObject.Balance.String(), Nonce: stateObject.Nonce, CodeHash: ethutil.Bytes2Hex(stateObject.codeHash)} account.Storage = make(map[string]string) stateObject.EachStorage(func(key string, value *ethutil.Value) { diff --git a/ethstate/state.go b/ethstate/state.go index 42bbf021b..0e87659fc 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -3,7 +3,6 @@ package ethstate import ( "math/big" - "github.com/ethereum/eth-go/ethcrypto" "github.com/ethereum/eth-go/ethlog" "github.com/ethereum/eth-go/ethtrie" "github.com/ethereum/eth-go/ethutil" @@ -66,7 +65,9 @@ func (self *State) GetCode(addr []byte) []byte { func (self *State) UpdateStateObject(stateObject *StateObject) { addr := stateObject.Address() - ethutil.Config.Db.Put(ethcrypto.Sha3Bin(stateObject.Code), stateObject.Code) + if len(stateObject.CodeHash()) > 0 { + ethutil.Config.Db.Put(stateObject.CodeHash(), stateObject.Code) + } self.Trie.Update(string(addr), string(stateObject.RlpEncode())) } diff --git a/ethstate/state_object.go b/ethstate/state_object.go index 6fc0696a8..be083e80a 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -32,7 +32,7 @@ type StateObject struct { address []byte // Shared attributes Balance *big.Int - CodeHash []byte + codeHash []byte Nonce uint64 // Contract related attributes State *State @@ -236,7 +236,7 @@ func (self *StateObject) RefundGas(gas, price *big.Int) { func (self *StateObject) Copy() *StateObject { stateObject := NewStateObject(self.Address()) stateObject.Balance.Set(self.Balance) - stateObject.CodeHash = ethutil.CopyBytes(self.CodeHash) + stateObject.codeHash = ethutil.CopyBytes(self.codeHash) stateObject.Nonce = self.Nonce if self.State != nil { stateObject.State = self.State.Copy() @@ -297,12 +297,17 @@ func (c *StateObject) RlpEncode() []byte { } else { root = "" } + + return ethutil.Encode([]interface{}{c.Nonce, c.Balance, root, c.CodeHash()}) +} + +func (c *StateObject) CodeHash() ethutil.Bytes { var codeHash []byte if len(c.Code) > 0 { codeHash = ethcrypto.Sha3Bin(c.Code) } - return ethutil.Encode([]interface{}{c.Nonce, c.Balance, root, codeHash}) + return codeHash } func (c *StateObject) RlpDecode(data []byte) { @@ -314,9 +319,9 @@ func (c *StateObject) RlpDecode(data []byte) { c.storage = make(map[string]*ethutil.Value) c.gasPool = new(big.Int) - c.CodeHash = decoder.Get(3).Bytes() + c.codeHash = decoder.Get(3).Bytes() - c.Code, _ = ethutil.Config.Db.Get(c.CodeHash) + c.Code, _ = ethutil.Config.Db.Get(c.codeHash) } // Storage change object. Used by the manifest for notifying changes to -- cgit v1.2.3 From b417766b36f46316cbae6fa42815f1a519e5f733 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 8 Oct 2014 11:59:44 +0200 Subject: Minor tweaks for poc7 --- ethstate/state.go | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index 0e87659fc..23b106e34 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -181,8 +181,6 @@ func (s *State) Reset() { func (s *State) Sync() { // Sync all nested states for _, stateObject := range s.stateObjects { - //s.UpdateStateObject(stateObject) - if stateObject.State == nil { continue } @@ -200,9 +198,11 @@ func (self *State) Empty() { } func (self *State) Update() { + var deleted bool for _, stateObject := range self.stateObjects { if stateObject.remove { self.DeleteStateObject(stateObject) + deleted = true } else { stateObject.Sync() @@ -211,11 +211,13 @@ func (self *State) Update() { } // FIXME trie delete is broken - valid, t2 := ethtrie.ParanoiaCheck(self.Trie) - if !valid { - statelogger.Infof("Warn: PARANOIA: Different state root during copy %x vs %x\n", self.Trie.Root, t2.Root) + if deleted { + valid, t2 := ethtrie.ParanoiaCheck(self.Trie) + if !valid { + statelogger.Infof("Warn: PARANOIA: Different state root during copy %x vs %x\n", self.Trie.Root, t2.Root) - self.Trie = t2 + self.Trie = t2 + } } } -- cgit v1.2.3 From 9d86a49a7327199c01977f3372c8adf748252c32 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 8 Oct 2014 12:06:39 +0200 Subject: Renamed Sha3Bin to Sha3 --- ethstate/state_object.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'ethstate') diff --git a/ethstate/state_object.go b/ethstate/state_object.go index be083e80a..fe4c5f73b 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -304,7 +304,7 @@ func (c *StateObject) RlpEncode() []byte { func (c *StateObject) CodeHash() ethutil.Bytes { var codeHash []byte if len(c.Code) > 0 { - codeHash = ethcrypto.Sha3Bin(c.Code) + codeHash = ethcrypto.Sha3(c.Code) } return codeHash -- cgit v1.2.3 From 3d177be73e127b08a52988fde308eed29eac4699 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 15 Oct 2014 00:40:41 +0200 Subject: Couple of minor issues fixed * CALLVALUE pushed incorrect value to the stack * Set execution model to closure --- ethstate/state.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index 23b106e34..c2486849b 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -94,11 +94,15 @@ func (self *State) GetStateObject(addr []byte) *StateObject { } stateObject = NewStateObjectFromBytes(addr, []byte(data)) - self.stateObjects[string(addr)] = stateObject + self.SetStateObject(stateObject) return stateObject } +func (self *State) SetStateObject(object *StateObject) { + self.stateObjects[string(object.address)] = object +} + // Retrieve a state object or create a new state object if nil func (self *State) GetOrNewStateObject(addr []byte) *StateObject { stateObject := self.GetStateObject(addr) -- cgit v1.2.3 From 311c6f8a3fed5ac03ee4b442fd0f420072bc41b4 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 15 Oct 2014 17:12:26 +0200 Subject: Fixed remote Arithmetic tests --- ethstate/state.go | 9 +++++++++ ethstate/state_object.go | 10 ++++------ 2 files changed, 13 insertions(+), 6 deletions(-) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index c2486849b..b897b7ce3 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -57,6 +57,15 @@ func (self *State) GetCode(addr []byte) []byte { return nil } +func (self *State) GetState(a, b []byte) []byte { + stateObject := self.GetStateObject(a) + if stateObject != nil { + return stateObject.GetState(b).Bytes() + } + + return nil +} + // // Setting, updating & deleting state object methods // diff --git a/ethstate/state_object.go b/ethstate/state_object.go index fe4c5f73b..4d2aae1a7 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -98,13 +98,13 @@ func (c *StateObject) SetAddr(addr []byte, value interface{}) { } func (self *StateObject) GetStorage(key *big.Int) *ethutil.Value { - return self.getStorage(key.Bytes()) + return self.GetState(key.Bytes()) } func (self *StateObject) SetStorage(key *big.Int, value *ethutil.Value) { - self.setStorage(key.Bytes(), value) + self.SetState(key.Bytes(), value) } -func (self *StateObject) getStorage(k []byte) *ethutil.Value { +func (self *StateObject) GetState(k []byte) *ethutil.Value { key := ethutil.LeftPadBytes(k, 32) value := self.storage[string(key)] @@ -117,11 +117,9 @@ func (self *StateObject) getStorage(k []byte) *ethutil.Value { } return value - - //return self.GetAddr(key) } -func (self *StateObject) setStorage(k []byte, value *ethutil.Value) { +func (self *StateObject) SetState(k []byte, value *ethutil.Value) { key := ethutil.LeftPadBytes(k, 32) self.storage[string(key)] = value.Copy() } -- cgit v1.2.3 From 70f7a0be1187cc0e487e7b95cad238c6530d29ae Mon Sep 17 00:00:00 2001 From: obscuren Date: Thu, 16 Oct 2014 13:38:21 +0200 Subject: Use the state instead of the state object directly. If a state gets reset and you still hold a pointer to the previous, incorrect, state object you'll operate on the wrong object. Using the state to set/get objects and attributes you won't have this problem since the state will always have the correct object. --- ethstate/state.go | 25 +++++++++++++++++++++++++ ethstate/state_object.go | 4 ++++ 2 files changed, 29 insertions(+) (limited to 'ethstate') diff --git a/ethstate/state.go b/ethstate/state.go index b897b7ce3..2efe2a311 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -48,6 +48,13 @@ func (self *State) GetNonce(addr []byte) uint64 { return 0 } +func (self *State) SetNonce(addr []byte, nonce uint64) { + stateObject := self.GetStateObject(addr) + if stateObject != nil { + stateObject.Nonce = nonce + } +} + func (self *State) GetCode(addr []byte) []byte { stateObject := self.GetStateObject(addr) if stateObject != nil { @@ -66,6 +73,24 @@ func (self *State) GetState(a, b []byte) []byte { return nil } +func (self *State) SetState(addr, key []byte, value interface{}) { + stateObject := self.GetStateObject(addr) + if stateObject != nil { + stateObject.SetState(key, ethutil.NewValue(value)) + } +} + +func (self *State) Delete(addr []byte) bool { + stateObject := self.GetStateObject(addr) + if stateObject != nil { + stateObject.MarkForDeletion() + + return true + } + + return false +} + // // Setting, updating & deleting state object methods // diff --git a/ethstate/state_object.go b/ethstate/state_object.go index 4d2aae1a7..a5b7c65e9 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -104,6 +104,10 @@ func (self *StateObject) SetStorage(key *big.Int, value *ethutil.Value) { self.SetState(key.Bytes(), value) } +func (self *StateObject) Storage() map[string]*ethutil.Value { + return self.storage +} + func (self *StateObject) GetState(k []byte) *ethutil.Value { key := ethutil.LeftPadBytes(k, 32) -- cgit v1.2.3 From b5beb1aac11af92bfe0f3ed7560b9eb08495ed09 Mon Sep 17 00:00:00 2001 From: obscuren Date: Wed, 22 Oct 2014 15:22:21 +0200 Subject: added a transfer method to vm env --- ethstate/dump.go | 2 +- ethstate/state.go | 2 +- ethstate/state_object.go | 40 ++++++++++++++++++++++------------------ 3 files changed, 24 insertions(+), 20 deletions(-) (limited to 'ethstate') diff --git a/ethstate/dump.go b/ethstate/dump.go index cdd4228b8..e7cbde48b 100644 --- a/ethstate/dump.go +++ b/ethstate/dump.go @@ -28,7 +28,7 @@ func (self *State) Dump() []byte { self.Trie.NewIterator().Each(func(key string, value *ethutil.Value) { stateObject := NewStateObjectFromBytes([]byte(key), value.Bytes()) - account := Account{Balance: stateObject.Balance.String(), Nonce: stateObject.Nonce, CodeHash: ethutil.Bytes2Hex(stateObject.codeHash)} + account := Account{Balance: stateObject.balance.String(), Nonce: stateObject.Nonce, CodeHash: ethutil.Bytes2Hex(stateObject.codeHash)} account.Storage = make(map[string]string) stateObject.EachStorage(func(key string, value *ethutil.Value) { diff --git a/ethstate/state.go b/ethstate/state.go index 2efe2a311..59d2265a9 100644 --- a/ethstate/state.go +++ b/ethstate/state.go @@ -33,7 +33,7 @@ func New(trie *ethtrie.Trie) *State { func (self *State) GetBalance(addr []byte) *big.Int { stateObject := self.GetStateObject(addr) if stateObject != nil { - return stateObject.Balance + return stateObject.balance } return ethutil.Big0 diff --git a/ethstate/state_object.go b/ethstate/state_object.go index a5b7c65e9..1ba005439 100644 --- a/ethstate/state_object.go +++ b/ethstate/state_object.go @@ -31,7 +31,7 @@ type StateObject struct { // Address of the object address []byte // Shared attributes - Balance *big.Int + balance *big.Int codeHash []byte Nonce uint64 // Contract related attributes @@ -61,7 +61,7 @@ func NewStateObject(addr []byte) *StateObject { // This to ensure that it has 20 bytes (and not 0 bytes), thus left or right pad doesn't matter. address := ethutil.Address(addr) - object := &StateObject{address: address, Balance: new(big.Int), gasPool: new(big.Int)} + object := &StateObject{address: address, balance: new(big.Int), gasPool: new(big.Int)} object.State = New(ethtrie.New(ethutil.Config.Db, "")) object.storage = make(Storage) object.gasPool = new(big.Int) @@ -71,7 +71,7 @@ func NewStateObject(addr []byte) *StateObject { func NewContract(address []byte, balance *big.Int, root []byte) *StateObject { contract := NewStateObject(address) - contract.Balance = balance + contract.balance = balance contract.State = New(ethtrie.New(ethutil.Config.Db, string(root))) return contract @@ -86,7 +86,7 @@ func NewStateObjectFromBytes(address, data []byte) *StateObject { func (self *StateObject) MarkForDeletion() { self.remove = true - statelogger.DebugDetailf("%x: #%d %v (deletion)\n", self.Address(), self.Nonce, self.Balance) + statelogger.DebugDetailf("%x: #%d %v (deletion)\n", self.Address(), self.Nonce, self.balance) } func (c *StateObject) GetAddr(addr []byte) *ethutil.Value { @@ -174,22 +174,26 @@ func (c *StateObject) GetInstr(pc *big.Int) *ethutil.Value { return ethutil.NewValueFromBytes([]byte{c.Code[pc.Int64()]}) } -func (c *StateObject) AddAmount(amount *big.Int) { - c.SetBalance(new(big.Int).Add(c.Balance, amount)) +func (c *StateObject) AddBalance(amount *big.Int) { + c.SetBalance(new(big.Int).Add(c.balance, amount)) - statelogger.Debugf("%x: #%d %v (+ %v)\n", c.Address(), c.Nonce, c.Balance, amount) + statelogger.Debugf("%x: #%d %v (+ %v)\n", c.Address(), c.Nonce, c.balance, amount) } +func (c *StateObject) AddAmount(amount *big.Int) { c.AddBalance(amount) } -func (c *StateObject) SubAmount(amount *big.Int) { - c.SetBalance(new(big.Int).Sub(c.Balance, amount)) +func (c *StateObject) SubBalance(amount *big.Int) { + c.SetBalance(new(big.Int).Sub(c.balance, amount)) - statelogger.Debugf("%x: #%d %v (- %v)\n", c.Address(), c.Nonce, c.Balance, amount) + statelogger.Debugf("%x: #%d %v (- %v)\n", c.Address(), c.Nonce, c.balance, amount) } +func (c *StateObject) SubAmount(amount *big.Int) { c.SubBalance(amount) } func (c *StateObject) SetBalance(amount *big.Int) { - c.Balance = amount + c.balance = amount } +func (self *StateObject) Balance() *big.Int { return self.balance } + // // Gas setters and getters // @@ -198,8 +202,8 @@ func (c *StateObject) SetBalance(amount *big.Int) { func (c *StateObject) ReturnGas(gas, price *big.Int) {} func (c *StateObject) ConvertGas(gas, price *big.Int) error { total := new(big.Int).Mul(gas, price) - if total.Cmp(c.Balance) > 0 { - return fmt.Errorf("insufficient amount: %v, %v", c.Balance, total) + if total.Cmp(c.balance) > 0 { + return fmt.Errorf("insufficient amount: %v, %v", c.balance, total) } c.SubAmount(total) @@ -232,12 +236,12 @@ func (self *StateObject) RefundGas(gas, price *big.Int) { rGas := new(big.Int).Set(gas) rGas.Mul(rGas, price) - self.Balance.Sub(self.Balance, rGas) + self.balance.Sub(self.balance, rGas) } func (self *StateObject) Copy() *StateObject { stateObject := NewStateObject(self.Address()) - stateObject.Balance.Set(self.Balance) + stateObject.balance.Set(self.balance) stateObject.codeHash = ethutil.CopyBytes(self.codeHash) stateObject.Nonce = self.Nonce if self.State != nil { @@ -281,7 +285,7 @@ func (self *StateObject) Object() *StateObject { // Debug stuff func (self *StateObject) CreateOutputForDiff() { - fmt.Printf("%x %x %x %x\n", self.Address(), self.State.Root(), self.Balance.Bytes(), self.Nonce) + fmt.Printf("%x %x %x %x\n", self.Address(), self.State.Root(), self.balance.Bytes(), self.Nonce) self.EachStorage(func(addr string, value *ethutil.Value) { fmt.Printf("%x %x\n", addr, value.Bytes()) }) @@ -300,7 +304,7 @@ func (c *StateObject) RlpEncode() []byte { root = "" } - return ethutil.Encode([]interface{}{c.Nonce, c.Balance, root, c.CodeHash()}) + return ethutil.Encode([]interface{}{c.Nonce, c.balance, root, c.CodeHash()}) } func (c *StateObject) CodeHash() ethutil.Bytes { @@ -316,7 +320,7 @@ func (c *StateObject) RlpDecode(data []byte) { decoder := ethutil.NewValueFromBytes(data) c.Nonce = decoder.Get(0).Uint() - c.Balance = decoder.Get(1).BigInt() + c.balance = decoder.Get(1).BigInt() c.State = New(ethtrie.New(ethutil.Config.Db, decoder.Get(2).Interface())) c.storage = make(map[string]*ethutil.Value) c.gasPool = new(big.Int) -- cgit v1.2.3