aboutsummaryrefslogtreecommitdiffstats
path: root/state
diff options
context:
space:
mode:
Diffstat (limited to 'state')
-rw-r--r--state/dump.go6
-rw-r--r--state/log.go11
-rw-r--r--state/state_object.go97
-rw-r--r--state/state_test.go43
-rw-r--r--state/statedb.go45
5 files changed, 143 insertions, 59 deletions
diff --git a/state/dump.go b/state/dump.go
index ac646480c..073f89414 100644
--- a/state/dump.go
+++ b/state/dump.go
@@ -30,12 +30,12 @@ func (self *StateDB) Dump() []byte {
for it.Next() {
stateObject := NewStateObjectFromBytes(it.Key, it.Value, self.db)
- account := Account{Balance: stateObject.balance.String(), Nonce: stateObject.Nonce, Root: ethutil.Bytes2Hex(stateObject.Root()), CodeHash: ethutil.Bytes2Hex(stateObject.codeHash)}
+ account := Account{Balance: stateObject.balance.String(), Nonce: stateObject.nonce, Root: ethutil.Bytes2Hex(stateObject.Root()), CodeHash: ethutil.Bytes2Hex(stateObject.codeHash)}
account.Storage = make(map[string]string)
storageIt := stateObject.State.trie.Iterator()
for storageIt.Next() {
- account.Storage[ethutil.Bytes2Hex(it.Key)] = ethutil.Bytes2Hex(it.Value)
+ account.Storage[ethutil.Bytes2Hex(storageIt.Key)] = ethutil.Bytes2Hex(storageIt.Value)
}
world.Accounts[ethutil.Bytes2Hex(it.Key)] = account
}
@@ -50,7 +50,7 @@ func (self *StateDB) Dump() []byte {
// 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)
it := self.State.trie.Iterator()
for it.Next() {
fmt.Printf("%x %x\n", it.Key, it.Value)
diff --git a/state/log.go b/state/log.go
index 46360f4aa..d503bd1a0 100644
--- a/state/log.go
+++ b/state/log.go
@@ -12,16 +12,19 @@ type Log interface {
Address() []byte
Topics() [][]byte
Data() []byte
+
+ Number() uint64
}
type StateLog struct {
address []byte
topics [][]byte
data []byte
+ number uint64
}
-func NewLog(address []byte, topics [][]byte, data []byte) *StateLog {
- return &StateLog{address, topics, data}
+func NewLog(address []byte, topics [][]byte, data []byte, number uint64) *StateLog {
+ return &StateLog{address, topics, data, number}
}
func (self *StateLog) Address() []byte {
@@ -36,6 +39,10 @@ func (self *StateLog) Data() []byte {
return self.data
}
+func (self *StateLog) Number() uint64 {
+ return self.number
+}
+
func NewLogFromValue(decoder *ethutil.Value) *StateLog {
log := &StateLog{
address: decoder.Get(0).Bytes(),
diff --git a/state/state_object.go b/state/state_object.go
index 0c157403c..487952a02 100644
--- a/state/state_object.go
+++ b/state/state_object.go
@@ -19,6 +19,14 @@ func (self Code) String() string {
type Storage map[string]*ethutil.Value
+func (self Storage) String() (str string) {
+ for key, value := range self {
+ str += fmt.Sprintf("%X : %X\n", key, value.Bytes())
+ }
+
+ return
+}
+
func (self Storage) Copy() Storage {
cpy := make(Storage)
for key, value := range self {
@@ -36,11 +44,11 @@ type StateObject struct {
// Shared attributes
balance *big.Int
codeHash []byte
- Nonce uint64
+ nonce uint64
// Contract related attributes
State *StateDB
- Code Code
- InitCode Code
+ code Code
+ initCode Code
storage Storage
@@ -53,6 +61,7 @@ type StateObject struct {
// When an object is marked for deletion it will be delete from the trie
// during the "update" phase of the state transition
remove bool
+ dirty bool
}
func (self *StateObject) Reset() {
@@ -64,7 +73,7 @@ func NewStateObject(addr []byte, db ethutil.Database) *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{db: db, address: address, balance: new(big.Int), gasPool: new(big.Int)}
+ object := &StateObject{db: db, address: address, balance: new(big.Int), gasPool: new(big.Int), dirty: true}
object.State = New(nil, db) //New(trie.New(ethutil.Config.Db, ""))
object.storage = make(Storage)
object.gasPool = new(big.Int)
@@ -88,20 +97,21 @@ func NewStateObjectFromBytes(address, data []byte, db ethutil.Database) *StateOb
object := &StateObject{address: address, db: db}
//object.RlpDecode(data)
- object.Nonce = extobject.Nonce
+ object.nonce = extobject.Nonce
object.balance = extobject.Balance
object.codeHash = extobject.CodeHash
object.State = New(extobject.Root, db)
object.storage = make(map[string]*ethutil.Value)
object.gasPool = new(big.Int)
- object.Code, _ = db.Get(extobject.CodeHash)
+ object.code, _ = db.Get(extobject.CodeHash)
return object
}
func (self *StateObject) MarkForDeletion() {
self.remove = true
- statelogger.DebugDetailf("%x: #%d %v (deletion)\n", self.Address(), self.Nonce, self.balance)
+ self.dirty = true
+ statelogger.DebugDetailf("%x: #%d %v (deletion)\n", self.Address(), self.nonce, self.balance)
}
func (c *StateObject) getAddr(addr []byte) *ethutil.Value {
@@ -119,7 +129,7 @@ func (self *StateObject) SetStorage(key *big.Int, value *ethutil.Value) {
self.SetState(key.Bytes(), value)
}
-func (self *StateObject) Storage() map[string]*ethutil.Value {
+func (self *StateObject) Storage() Storage {
return self.storage
}
@@ -141,6 +151,7 @@ func (self *StateObject) GetState(k []byte) *ethutil.Value {
func (self *StateObject) SetState(k []byte, value *ethutil.Value) {
key := ethutil.LeftPadBytes(k, 32)
self.storage[string(key)] = value.Copy()
+ self.dirty = true
}
func (self *StateObject) Sync() {
@@ -152,35 +163,37 @@ func (self *StateObject) Sync() {
self.setAddr([]byte(key), value)
}
+ self.storage = make(Storage)
}
func (c *StateObject) GetInstr(pc *big.Int) *ethutil.Value {
- if int64(len(c.Code)-1) < pc.Int64() {
+ if int64(len(c.code)-1) < pc.Int64() {
return ethutil.NewValue(0)
}
- return ethutil.NewValueFromBytes([]byte{c.Code[pc.Int64()]})
+ return ethutil.NewValueFromBytes([]byte{c.code[pc.Int64()]})
}
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) 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.dirty = true
}
-func (self *StateObject) Balance() *big.Int { return self.balance }
+func (c *StateObject) St() Storage {
+ return c.storage
+}
//
// Gas setters and getters
@@ -194,7 +207,9 @@ func (c *StateObject) ConvertGas(gas, price *big.Int) error {
return fmt.Errorf("insufficient amount: %v, %v", c.balance, total)
}
- c.SubAmount(total)
+ c.SubBalance(total)
+
+ c.dirty = true
return nil
}
@@ -210,10 +225,14 @@ func (self *StateObject) BuyGas(gas, price *big.Int) error {
return GasLimitError(self.gasPool, gas)
}
+ self.gasPool.Sub(self.gasPool, gas)
+
rGas := new(big.Int).Set(gas)
rGas.Mul(rGas, price)
- self.AddAmount(rGas)
+ self.AddBalance(rGas)
+
+ self.dirty = true
return nil
}
@@ -231,15 +250,16 @@ func (self *StateObject) Copy() *StateObject {
stateObject := NewStateObject(self.Address(), self.db)
stateObject.balance.Set(self.balance)
stateObject.codeHash = ethutil.CopyBytes(self.codeHash)
- stateObject.Nonce = self.Nonce
+ 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.code = ethutil.CopyBytes(self.code)
+ stateObject.initCode = ethutil.CopyBytes(self.initCode)
stateObject.storage = self.storage.Copy()
stateObject.gasPool.Set(self.gasPool)
stateObject.remove = self.remove
+ stateObject.dirty = self.dirty
return stateObject
}
@@ -252,8 +272,12 @@ func (self *StateObject) Set(stateObject *StateObject) {
// Attribute accessors
//
+func (self *StateObject) Balance() *big.Int {
+ return self.balance
+}
+
func (c *StateObject) N() *big.Int {
- return big.NewInt(int64(c.Nonce))
+ return big.NewInt(int64(c.nonce))
}
// Returns the address of the contract/account
@@ -263,7 +287,7 @@ func (c *StateObject) Address() []byte {
// Returns the initialization Code
func (c *StateObject) Init() Code {
- return c.InitCode
+ return c.initCode
}
func (self *StateObject) Trie() *trie.Trie {
@@ -274,8 +298,27 @@ func (self *StateObject) Root() []byte {
return self.Trie().Root()
}
+func (self *StateObject) Code() []byte {
+ return self.code
+}
+
func (self *StateObject) SetCode(code []byte) {
- self.Code = code
+ self.code = code
+ self.dirty = true
+}
+
+func (self *StateObject) SetInitCode(code []byte) {
+ self.initCode = code
+ self.dirty = true
+}
+
+func (self *StateObject) SetNonce(nonce uint64) {
+ self.nonce = nonce
+ self.dirty = true
+}
+
+func (self *StateObject) Nonce() uint64 {
+ return self.nonce
}
//
@@ -284,16 +327,16 @@ func (self *StateObject) SetCode(code []byte) {
// State object encoding methods
func (c *StateObject) RlpEncode() []byte {
- return ethutil.Encode([]interface{}{c.Nonce, c.balance, c.Root(), c.CodeHash()})
+ return ethutil.Encode([]interface{}{c.nonce, c.balance, c.Root(), c.CodeHash()})
}
func (c *StateObject) CodeHash() ethutil.Bytes {
- return crypto.Sha3(c.Code)
+ return crypto.Sha3(c.code)
}
func (c *StateObject) RlpDecode(data []byte) {
decoder := ethutil.NewValueFromBytes(data)
- c.Nonce = decoder.Get(0).Uint()
+ c.nonce = decoder.Get(0).Uint()
c.balance = decoder.Get(1).BigInt()
c.State = New(decoder.Get(2).Bytes(), c.db) //New(trie.New(ethutil.Config.Db, decoder.Get(2).Interface()))
c.storage = make(map[string]*ethutil.Value)
@@ -301,7 +344,7 @@ func (c *StateObject) RlpDecode(data []byte) {
c.codeHash = decoder.Get(3).Bytes()
- c.Code, _ = c.db.Get(c.codeHash)
+ c.code, _ = c.db.Get(c.codeHash)
}
// Storage change object. Used by the manifest for notifying changes to
diff --git a/state/state_test.go b/state/state_test.go
index 7c54cedc0..ee1cf9286 100644
--- a/state/state_test.go
+++ b/state/state_test.go
@@ -1,6 +1,8 @@
package state
import (
+ "math/big"
+
checker "gopkg.in/check.v1"
"github.com/ethereum/go-ethereum/ethdb"
@@ -16,11 +18,42 @@ var _ = checker.Suite(&StateSuite{})
// var ZeroHash256 = make([]byte, 32)
func (s *StateSuite) TestDump(c *checker.C) {
- key := []byte{0x01}
- value := []byte("foo")
- s.state.trie.Update(key, value)
- dump := s.state.Dump()
- c.Assert(dump, checker.NotNil)
+ // generate a few entries
+ obj1 := s.state.GetOrNewStateObject([]byte{0x01})
+ obj1.AddBalance(big.NewInt(22))
+ obj2 := s.state.GetOrNewStateObject([]byte{0x01, 0x02})
+ obj2.SetCode([]byte{3, 3, 3, 3, 3, 3, 3})
+ obj3 := s.state.GetOrNewStateObject([]byte{0x02})
+ obj3.SetBalance(big.NewInt(44))
+
+ // write some of them to the trie
+ s.state.UpdateStateObject(obj1)
+ s.state.UpdateStateObject(obj2)
+
+ // check that dump contains the state objects that are in trie
+ got := string(s.state.Dump())
+ want := `{
+ "root": "4e3a59299745ba6752247c8b91d0f716dac9ec235861c91f5ac1894a361d87ba",
+ "accounts": {
+ "0000000000000000000000000000000000000001": {
+ "balance": "22",
+ "nonce": 0,
+ "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+ "storage": {}
+ },
+ "0000000000000000000000000000000000000102": {
+ "balance": "0",
+ "nonce": 0,
+ "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ "codeHash": "87874902497a5bb968da31a2998d8f22e949d1ef6214bcdedd8bae24cca4b9e3",
+ "storage": {}
+ }
+ }
+}`
+ if got != want {
+ c.Errorf("dump mismatch:\ngot: %s\nwant: %s\n", got, want)
+ }
}
func (s *StateSuite) SetUpTest(c *checker.C) {
diff --git a/state/statedb.go b/state/statedb.go
index c83d59ed7..7e2b24b94 100644
--- a/state/statedb.go
+++ b/state/statedb.go
@@ -72,43 +72,42 @@ func (self *StateDB) AddBalance(addr []byte, amount *big.Int) {
func (self *StateDB) GetNonce(addr []byte) uint64 {
stateObject := self.GetStateObject(addr)
if stateObject != nil {
- return stateObject.Nonce
+ return stateObject.nonce
}
return 0
}
-func (self *StateDB) SetNonce(addr []byte, nonce uint64) {
+func (self *StateDB) GetCode(addr []byte) []byte {
stateObject := self.GetStateObject(addr)
if stateObject != nil {
- stateObject.Nonce = nonce
+ return stateObject.code
}
+
+ return nil
}
-func (self *StateDB) GetCode(addr []byte) []byte {
- stateObject := self.GetStateObject(addr)
+func (self *StateDB) GetState(a, b []byte) []byte {
+ stateObject := self.GetStateObject(a)
if stateObject != nil {
- return stateObject.Code
+ return stateObject.GetState(b).Bytes()
}
return nil
}
-func (self *StateDB) SetCode(addr, code []byte) {
+func (self *StateDB) SetNonce(addr []byte, nonce uint64) {
stateObject := self.GetStateObject(addr)
if stateObject != nil {
- stateObject.SetCode(code)
+ stateObject.SetNonce(nonce)
}
}
-// TODO vars
-func (self *StateDB) GetState(a, b []byte) []byte {
- stateObject := self.GetStateObject(a)
+func (self *StateDB) SetCode(addr, code []byte) {
+ stateObject := self.GetStateObject(addr)
if stateObject != nil {
- return stateObject.GetState(b).Bytes()
+ stateObject.SetCode(code)
}
-
- return nil
}
func (self *StateDB) SetState(addr, key []byte, value interface{}) {
@@ -138,7 +137,7 @@ func (self *StateDB) UpdateStateObject(stateObject *StateObject) {
addr := stateObject.Address()
if len(stateObject.CodeHash()) > 0 {
- self.db.Put(stateObject.CodeHash(), stateObject.Code)
+ self.db.Put(stateObject.CodeHash(), stateObject.code)
}
self.trie.Update(addr, stateObject.RlpEncode())
@@ -282,16 +281,18 @@ func (self *StateDB) Refunds() map[string]*big.Int {
}
func (self *StateDB) Update(gasUsed *big.Int) {
-
self.refund = make(map[string]*big.Int)
for _, stateObject := range self.stateObjects {
- if stateObject.remove {
- self.DeleteStateObject(stateObject)
- } else {
- stateObject.Sync()
-
- self.UpdateStateObject(stateObject)
+ if stateObject.dirty {
+ if stateObject.remove {
+ self.DeleteStateObject(stateObject)
+ } else {
+ stateObject.Sync()
+
+ self.UpdateStateObject(stateObject)
+ }
+ stateObject.dirty = false
}
}
}
generated by cgit (git 2.34.1) at 2024-10-17 18:31:01 +0800