package ipld_eth_statedb import ( "bytes" "fmt" "io" "math/big" "time" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" ) var emptyCodeHash = crypto.Keccak256(nil) type Code []byte func (c Code) String() string { return string(c) //strings.Join(Disassemble(c), " ") } type Storage map[common.Hash]common.Hash func (s Storage) String() (str string) { for key, value := range s { str += fmt.Sprintf("%X : %X\n", key, value) } return } func (s Storage) Copy() Storage { cpy := make(Storage, len(s)) for key, value := range s { cpy[key] = value } return cpy } // stateObject represents an Ethereum account which is being modified. // // The usage pattern is as follows: // First you need to obtain a state object. // Account values can be accessed and modified through the object. // Finally, call CommitTrie to write the modified storage trie into a database. type stateObject struct { address common.Address addrHash common.Hash // hash of ethereum address of the account data types.StateAccount db *StateDB // DB error. // State objects are used by the consensus core and VM which are // unable to deal with database-level errors. Any error that occurs // during a database read is memoized here and will eventually be returned // by StateDB.Commit. dbErr error // Write caches. trie state.Trie // storage trie, which becomes non-nil on first access code Code // contract bytecode, which gets set when code is loaded originStorage Storage // Storage cache of original entries to dedup rewrites, reset for every transaction pendingStorage Storage // Storage entries that need to be flushed to disk, at the end of an entire block dirtyStorage Storage // Storage entries that have been modified in the current transaction execution fakeStorage Storage // Fake storage which constructed by caller for debugging purpose. // Cache flags. // When an object is marked suicided it will be delete from the trie // during the "update" phase of the state transition. dirtyCode bool // true if the code was updated suicided bool deleted bool } // empty returns whether the account is considered empty. func (s *stateObject) empty() bool { return s.data.Nonce == 0 && s.data.Balance.Sign() == 0 && bytes.Equal(s.data.CodeHash, emptyCodeHash) } // newObject creates a state object. func newObject(db *StateDB, address common.Address, data types.StateAccount) *stateObject { if data.Balance == nil { data.Balance = new(big.Int) } if data.CodeHash == nil { data.CodeHash = emptyCodeHash } if data.Root == (common.Hash{}) { data.Root = emptyRoot } return &stateObject{ db: db, address: address, addrHash: crypto.Keccak256Hash(address[:]), data: data, originStorage: make(Storage), pendingStorage: make(Storage), dirtyStorage: make(Storage), } } // EncodeRLP implements rlp.Encoder. func (s *stateObject) EncodeRLP(w io.Writer) error { return rlp.Encode(w, &s.data) } // setError remembers the first non-nil error it is called with. func (s *stateObject) setError(err error) { if s.dbErr == nil { s.dbErr = err } } func (s *stateObject) markSuicided() { s.suicided = true } func (s *stateObject) touch() { s.db.journal.append(touchChange{ account: &s.address, }) if s.address == ripemd { // Explicitly put it in the dirty-cache, which is otherwise generated from // flattened journals. s.db.journal.dirty(s.address) } } func (s *stateObject) getTrie(db state.Database) state.Trie { if s.trie == nil { // Try fetching from prefetcher first // We don't prefetch empty tries if s.data.Root != emptyRoot && s.db.prefetcher != nil { // When the miner is creating the pending state, there is no // prefetcher s.trie = s.db.prefetcher.trie(s.addrHash, s.data.Root) } if s.trie == nil { var err error s.trie, err = db.OpenStorageTrie(s.addrHash, s.data.Root) if err != nil { s.trie, _ = db.OpenStorageTrie(s.addrHash, common.Hash{}) s.setError(fmt.Errorf("can't create storage trie: %v", err)) } } } return s.trie } // GetState retrieves a value from the account storage trie. func (s *stateObject) GetState(db state.Database, key common.Hash) common.Hash { // If the fake storage is set, only lookup the state here(in the debugging mode) if s.fakeStorage != nil { return s.fakeStorage[key] } // If we have a dirty value for this state entry, return it value, dirty := s.dirtyStorage[key] if dirty { return value } // Otherwise return the entry's original value return s.GetCommittedState(db, key) } // GetCommittedState retrieves a value from the committed account storage trie. func (s *stateObject) GetCommittedState(db state.Database, key common.Hash) common.Hash { // If the fake storage is set, only lookup the state here(in the debugging mode) if s.fakeStorage != nil { return s.fakeStorage[key] } // If we have a pending write or clean cached, return that if value, pending := s.pendingStorage[key]; pending { return value } if value, cached := s.originStorage[key]; cached { return value } // If no live objects are available, attempt to use snapshots var ( enc []byte err error ) if s.db.snap != nil { // If the object was destructed in *this* block (and potentially resurrected), // the storage has been cleared out, and we should *not* consult the previous // snapshot about any storage values. The only possible alternatives are: // 1) resurrect happened, and new slot values were set -- those should // have been handles via pendingStorage above. // 2) we don't have new values, and can deliver empty response back if _, destructed := s.db.snapDestructs[s.addrHash]; destructed { return common.Hash{} } start := time.Now() enc, err = s.db.snap.Storage(s.addrHash, crypto.Keccak256Hash(key.Bytes())) if metrics.EnabledExpensive { s.db.SnapshotStorageReads += time.Since(start) } } // If the snapshot is unavailable or reading from it fails, load from the database. if s.db.snap == nil || err != nil { start := time.Now() enc, err = s.getTrie(db).TryGet(key.Bytes()) if metrics.EnabledExpensive { s.db.StorageReads += time.Since(start) } if err != nil { s.setError(err) return common.Hash{} } } var value common.Hash if len(enc) > 0 { _, content, _, err := rlp.Split(enc) if err != nil { s.setError(err) } value.SetBytes(content) } s.originStorage[key] = value return value } // SetState updates a value in account storage. func (s *stateObject) SetState(db state.Database, key, value common.Hash) { // If the fake storage is set, put the temporary state update here. if s.fakeStorage != nil { s.fakeStorage[key] = value return } // If the new value is the same as old, don't set prev := s.GetState(db, key) if prev == value { return } // New value is different, update and journal the change s.db.journal.append(storageChange{ account: &s.address, key: key, prevalue: prev, }) s.setState(key, value) } // SetStorage replaces the entire state storage with the given one. // // After this function is called, all original state will be ignored and state // lookup only happens in the fake state storage. // // Note this function should only be used for debugging purpose. func (s *stateObject) SetStorage(storage map[common.Hash]common.Hash) { // Allocate fake storage if it's nil. if s.fakeStorage == nil { s.fakeStorage = make(Storage) } for key, value := range storage { s.fakeStorage[key] = value } // Don't bother journal since this function should only be used for // debugging and the `fake` storage won't be committed to database. } func (s *stateObject) setState(key, value common.Hash) { s.dirtyStorage[key] = value } // finalise moves all dirty storage slots into the pending area to be hashed or // committed later. It is invoked at the end of every transaction. func (s *stateObject) finalise(prefetch bool) { slotsToPrefetch := make([][]byte, 0, len(s.dirtyStorage)) for key, value := range s.dirtyStorage { s.pendingStorage[key] = value if value != s.originStorage[key] { slotsToPrefetch = append(slotsToPrefetch, common.CopyBytes(key[:])) // Copy needed for closure } } if s.db.prefetcher != nil && prefetch && len(slotsToPrefetch) > 0 && s.data.Root != emptyRoot { s.db.prefetcher.prefetch(s.addrHash, s.data.Root, slotsToPrefetch) } if len(s.dirtyStorage) > 0 { s.dirtyStorage = make(Storage) } } // updateTrie writes cached storage modifications into the object's storage trie. // It will return nil if the trie has not been loaded and no changes have been made func (s *stateObject) updateTrie(db state.Database) state.Trie { // Make sure all dirty slots are finalized into the pending storage area s.finalise(false) // Don't prefetch anymore, pull directly if need be if len(s.pendingStorage) == 0 { return s.trie } // Track the amount of time wasted on updating the storage trie if metrics.EnabledExpensive { defer func(start time.Time) { s.db.StorageUpdates += time.Since(start) }(time.Now()) } // The snapshot storage map for the object var storage map[common.Hash][]byte // Insert all the pending updates into the trie tr := s.getTrie(db) hasher := s.db.hasher usedStorage := make([][]byte, 0, len(s.pendingStorage)) for key, value := range s.pendingStorage { // Skip noop changes, persist actual changes if value == s.originStorage[key] { continue } s.originStorage[key] = value var v []byte if (value == common.Hash{}) { s.setError(tr.TryDelete(key[:])) s.db.StorageDeleted += 1 } else { // Encoding []byte cannot fail, ok to ignore the error. v, _ = rlp.EncodeToBytes(common.TrimLeftZeroes(value[:])) s.setError(tr.TryUpdate(key[:], v)) s.db.StorageUpdated += 1 } // If state snapshotting is active, cache the data til commit if s.db.snap != nil { if storage == nil { // Retrieve the old storage map, if available, create a new one otherwise if storage = s.db.snapStorage[s.addrHash]; storage == nil { storage = make(map[common.Hash][]byte) s.db.snapStorage[s.addrHash] = storage } } storage[crypto.HashData(hasher, key[:])] = v // v will be nil if it's deleted } usedStorage = append(usedStorage, common.CopyBytes(key[:])) // Copy needed for closure } if s.db.prefetcher != nil { s.db.prefetcher.used(s.addrHash, s.data.Root, usedStorage) } if len(s.pendingStorage) > 0 { s.pendingStorage = make(Storage) } return tr } // UpdateRoot sets the trie root to the current root hash of func (s *stateObject) updateRoot(db state.Database) { // If nothing changed, don't bother with hashing anything if s.updateTrie(db) == nil { return } // Track the amount of time wasted on hashing the storage trie if metrics.EnabledExpensive { defer func(start time.Time) { s.db.StorageHashes += time.Since(start) }(time.Now()) } s.data.Root = s.trie.Hash() } // CommitTrie the storage trie of the object to db. // This updates the trie root. func (s *stateObject) CommitTrie(db state.Database) (*trie.NodeSet, error) { // If nothing changed, don't bother with hashing anything if s.updateTrie(db) == nil { return nil, nil } if s.dbErr != nil { return nil, s.dbErr } // Track the amount of time wasted on committing the storage trie if metrics.EnabledExpensive { defer func(start time.Time) { s.db.StorageCommits += time.Since(start) }(time.Now()) } root, nodes, err := s.trie.Commit(false) if err == nil { s.data.Root = root } return nodes, err } // AddBalance adds amount to s's balance. // It is used to add funds to the destination account of a transfer. func (s *stateObject) AddBalance(amount *big.Int) { // EIP161: We must check emptiness for the objects such that the account // clearing (0,0,0 objects) can take effect. if amount.Sign() == 0 { if s.empty() { s.touch() } return } s.SetBalance(new(big.Int).Add(s.Balance(), amount)) } // SubBalance removes amount from s's balance. // It is used to remove funds from the origin account of a transfer. func (s *stateObject) SubBalance(amount *big.Int) { if amount.Sign() == 0 { return } s.SetBalance(new(big.Int).Sub(s.Balance(), amount)) } func (s *stateObject) SetBalance(amount *big.Int) { s.db.journal.append(balanceChange{ account: &s.address, prev: new(big.Int).Set(s.data.Balance), }) s.setBalance(amount) } func (s *stateObject) setBalance(amount *big.Int) { s.data.Balance = amount } func (s *stateObject) deepCopy(db *StateDB) *stateObject { stateObject := newObject(db, s.address, s.data) if s.trie != nil { stateObject.trie = db.db.CopyTrie(s.trie) } stateObject.code = s.code stateObject.dirtyStorage = s.dirtyStorage.Copy() stateObject.originStorage = s.originStorage.Copy() stateObject.pendingStorage = s.pendingStorage.Copy() stateObject.suicided = s.suicided stateObject.dirtyCode = s.dirtyCode stateObject.deleted = s.deleted return stateObject } // // Attribute accessors // // Returns the address of the contract/account func (s *stateObject) Address() common.Address { return s.address } // Code returns the contract code associated with this object, if any. func (s *stateObject) Code(db state.Database) []byte { if s.code != nil { return s.code } if bytes.Equal(s.CodeHash(), emptyCodeHash) { return nil } code, err := db.ContractCode(s.addrHash, common.BytesToHash(s.CodeHash())) if err != nil { s.setError(fmt.Errorf("can't load code hash %x: %v", s.CodeHash(), err)) } s.code = code return code } // CodeSize returns the size of the contract code associated with this object, // or zero if none. This method is an almost mirror of Code, but uses a cache // inside the database to avoid loading codes seen recently. func (s *stateObject) CodeSize(db state.Database) int { if s.code != nil { return len(s.code) } if bytes.Equal(s.CodeHash(), emptyCodeHash) { return 0 } size, err := db.ContractCodeSize(s.addrHash, common.BytesToHash(s.CodeHash())) if err != nil { s.setError(fmt.Errorf("can't load code size %x: %v", s.CodeHash(), err)) } return size } func (s *stateObject) SetCode(codeHash common.Hash, code []byte) { prevcode := s.Code(s.db.db) s.db.journal.append(codeChange{ account: &s.address, prevhash: s.CodeHash(), prevcode: prevcode, }) s.setCode(codeHash, code) } func (s *stateObject) setCode(codeHash common.Hash, code []byte) { s.code = code s.data.CodeHash = codeHash[:] s.dirtyCode = true } func (s *stateObject) SetNonce(nonce uint64) { s.db.journal.append(nonceChange{ account: &s.address, prev: s.data.Nonce, }) s.setNonce(nonce) } func (s *stateObject) setNonce(nonce uint64) { s.data.Nonce = nonce } func (s *stateObject) CodeHash() []byte { return s.data.CodeHash } func (s *stateObject) Balance() *big.Int { return s.data.Balance } func (s *stateObject) Nonce() uint64 { return s.data.Nonce } // Never called, but must be present to allow stateObject to be used // as a vm.Account interface that also satisfies the vm.ContractRef // interface. Interfaces are awesome. func (s *stateObject) Value() *big.Int { panic("Value on stateObject should never be called") }