PoS_EVM
/
woop
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename state.StateDB to state.DB (#255)

Browse Source 
This fixes a golint “name stutter” warning.
pull/263/head
Eugene Kim 6 years ago
parent 92161a2f2d
commit 0ec8fa1548
22 changed files with 129 additions and 129 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 4
      api/client/service/server.go
  2. 4
      api/client/service/server_test.go
  3. 4
      consensus/consensus.go
  4. 2
      consensus/consensus_engine.go
  5. 2
      core/block_validator.go
  6. 6
      core/blockchain.go
  7. 6
      core/chain_makers.go
  8. 6
      core/state/dump.go
  9. 26
      core/state/journal.go
  10. 14
      core/state/managed_state.go
  11. 10
      core/state/managed_state_test.go
  12. 8
      core/state/state_object.go
  13. 2
      core/state/state_test.go
  14. 108
      core/state/statedb.go
  15. 26
      core/state/statedb_test.go
  16. 4
      core/state_processor.go
  17. 4
      core/tx_pool.go
  18. 6
      core/tx_pool_test.go
  19. 4
      core/types.go
  20. 2
      core/vm/logger_test.go
  21. 4
      core/vm/runtime/runtime.go
  22. 4
      node/worker/worker.go

4
api/client/service/server.go
Unescape View File

@ -15,7 +15,7 @@ import (
// Server is the Server struct for client service package.
type Server struct {
stateReader func() (*state.StateDB, error)
stateReader func() (*state.DB, error)
callFaucetContract func(common.Address) common.Hash
}
@ -55,7 +55,7 @@ func (s *Server) Start(ip, port string) (*grpc.Server, error) {
}
// NewServer creates new Server which implements ClientServiceServer interface.
func NewServer(stateReader func() (*state.StateDB, error), callFaucetContract func(common.Address) common.Hash) *Server {
func NewServer(stateReader func() (*state.DB, error), callFaucetContract func(common.Address) common.Hash) *Server {
s := &Server{stateReader: stateReader, callFaucetContract: callFaucetContract}
return s
}

4
api/client/service/server_test.go
Unescape View File

@ -29,7 +29,7 @@ var (
func TestGetFreeToken(test *testing.T) {
hash := common.Hash{}
hash.SetBytes([]byte("hello"))
server := NewServer(func() (*state.StateDB, error) {
server := NewServer(func() (*state.DB, error) {
return nil, nil
}, func(common.Address) common.Hash {
return hash
@ -63,7 +63,7 @@ func TestFetchAccountState(test *testing.T) {
hash := common.Hash{}
hash.SetBytes([]byte("hello"))
server := NewServer(func() (*state.StateDB, error) {
server := NewServer(func() (*state.DB, error) {
return chain.State()
}, func(common.Address) common.Hash {
return hash

4
consensus/consensus.go
Unescape View File

@ -426,7 +426,7 @@ func (consensus *Consensus) VerifySeal(chain ChainReader, header *types.Header)
// Finalize implements consensus.Engine, accumulating the block and uncle rewards,
// setting the final state and assembling the block.
func (consensus *Consensus) Finalize(chain ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, receipts []*types.Receipt) (*types.Block, error) {
func (consensus *Consensus) Finalize(chain ChainReader, header *types.Header, state *state.DB, txs []*types.Transaction, receipts []*types.Receipt) (*types.Block, error) {
// Accumulate any block and uncle rewards and commit the final state root
// Header seems complete, assemble into a block and return
accumulateRewards(chain.Config(), state, header)
@ -472,7 +472,7 @@ func (consensus *Consensus) Prepare(chain ChainReader, header *types.Header) err
// AccumulateRewards credits the coinbase of the given block with the mining
// reward. The total reward consists of the static block reward and rewards for
// included uncles. The coinbase of each uncle block is also rewarded.
func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header) {
func accumulateRewards(config *params.ChainConfig, state *state.DB, header *types.Header) {
// TODO: implement mining rewards
}

2
consensus/consensus_engine.go
Unescape View File

@ -60,7 +60,7 @@ type Engine interface {
// and assembles the final block.
// Note: The block header and state database might be updated to reflect any
// consensus rules that happen at finalization (e.g. block rewards).
Finalize(chain ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction,
Finalize(chain ChainReader, header *types.Header, state *state.DB, txs []*types.Transaction,
receipts []*types.Receipt) (*types.Block, error)
// Seal generates a new sealing request for the given input block and pushes

2
core/block_validator.go
Unescape View File

@ -74,7 +74,7 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error {
// transition, such as amount of used gas, the receipt roots and the state root
// itself. ValidateState returns a database batch if the validation was a success
// otherwise nil and an error is returned.
func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas uint64) error {
func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.DB, receipts types.Receipts, usedGas uint64) error {
header := block.Header()
if block.GasUsed() != usedGas {
return fmt.Errorf("invalid gas used (remote: %d local: %d)", block.GasUsed(), usedGas)

6
core/blockchain.go
Unescape View File

@ -401,12 +401,12 @@ func (bc *BlockChain) Processor() Processor {
}
// State returns a new mutable state based on the current HEAD block.
func (bc *BlockChain) State() (*state.StateDB, error) {
func (bc *BlockChain) State() (*state.DB, error) {
return bc.StateAt(bc.CurrentBlock().Root())
}
// StateAt returns a new mutable state based on a particular point in time.
func (bc *BlockChain) StateAt(root common.Hash) (*state.StateDB, error) {
func (bc *BlockChain) StateAt(root common.Hash) (*state.DB, error) {
return state.New(root, bc.stateCache)
}
@ -913,7 +913,7 @@ func (bc *BlockChain) WriteBlockWithoutState(block *types.Block, td *big.Int) (e
}
// WriteBlockWithState writes the block and all associated state to the database.
func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.StateDB) (status WriteStatus, err error) {
func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.Receipt, state *state.DB) (status WriteStatus, err error) {
bc.wg.Add(1)
defer bc.wg.Done()

6
core/chain_makers.go
Unescape View File

@ -36,7 +36,7 @@ type BlockGen struct {
parent *types.Block
chain []*types.Block
header *types.Header
statedb *state.StateDB
statedb *state.DB
gasPool *GasPool
txs []*types.Transaction
@ -167,7 +167,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
}
blocks, receipts := make(types.Blocks, n), make([]types.Receipts, n)
chainreader := &fakeChainReader{config: config}
genblock := func(i int, parent *types.Block, statedb *state.StateDB) (*types.Block, types.Receipts) {
genblock := func(i int, parent *types.Block, statedb *state.DB) (*types.Block, types.Receipts) {
b := &BlockGen{i: i, chain: blocks, parent: parent, statedb: statedb, config: config, engine: engine}
b.header = makeHeader(chainreader, parent, statedb, b.engine)
@ -216,7 +216,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
return blocks, receipts
}
func makeHeader(chain consensus.ChainReader, parent *types.Block, state *state.StateDB, engine consensus.Engine) *types.Header {
func makeHeader(chain consensus.ChainReader, parent *types.Block, state *state.DB, engine consensus.Engine) *types.Header {
var time *big.Int
if parent.Time() == nil {
time = big.NewInt(10)

6
core/state/dump.go
Unescape View File

@ -41,8 +41,8 @@ type Dump struct {
Accounts map[string]DumpAccount `json:"accounts"`
}
// RawDump returns Dump from given StateDB.
func (stateDB *StateDB) RawDump() Dump {
// RawDump returns Dump from given DB.
func (stateDB *DB) RawDump() Dump {
dump := Dump{
Root: fmt.Sprintf("%x", stateDB.trie.Hash()),
Accounts: make(map[string]DumpAccount),
@ -75,7 +75,7 @@ func (stateDB *StateDB) RawDump() Dump {
}
// Dump dumps into []byte.
func (stateDB *StateDB) Dump() []byte {
func (stateDB *DB) Dump() []byte {
json, err := json.MarshalIndent(stateDB.RawDump(), "", " ")
if err != nil {
fmt.Println("dump err", err)

26
core/state/journal.go
Unescape View File

@ -26,7 +26,7 @@ import (
// reverted on demand.
type journalEntry interface {
// revert undoes the changes introduced by this journal entry.
revert(*StateDB)
revert(*DB)
// dirtied returns the Ethereum address modified by this journal entry.
dirtied() *common.Address
@ -57,7 +57,7 @@ func (j *journal) append(entry journalEntry) {
// revert undoes a batch of journalled modifications along with any reverted
// dirty handling too.
func (j *journal) revert(statedb *StateDB, snapshot int) {
func (j *journal) revert(statedb *DB, snapshot int) {
for i := len(j.entries) - 1; i >= snapshot; i-- {
// Undo the changes made by the operation
j.entries[i].revert(statedb)
@ -133,7 +133,7 @@ type (
}
)
func (ch createObjectChange) revert(s *StateDB) {
func (ch createObjectChange) revert(s *DB) {
delete(s.stateObjects, *ch.account)
delete(s.stateObjectsDirty, *ch.account)
}
@ -142,7 +142,7 @@ func (ch createObjectChange) dirtied() *common.Address {
return ch.account
}
func (ch resetObjectChange) revert(s *StateDB) {
func (ch resetObjectChange) revert(s *DB) {
s.setStateObject(ch.prev)
}
@ -150,7 +150,7 @@ func (ch resetObjectChange) dirtied() *common.Address {
return nil
}
func (ch suicideChange) revert(s *StateDB) {
func (ch suicideChange) revert(s *DB) {
obj := s.getStateObject(*ch.account)
if obj != nil {
obj.suicided = ch.prev
@ -164,14 +164,14 @@ func (ch suicideChange) dirtied() *common.Address {
var ripemd = common.HexToAddress("0000000000000000000000000000000000000003")
func (ch touchChange) revert(s *StateDB) {
func (ch touchChange) revert(s *DB) {
}
func (ch touchChange) dirtied() *common.Address {
return ch.account
}
func (ch balanceChange) revert(s *StateDB) {
func (ch balanceChange) revert(s *DB) {
s.getStateObject(*ch.account).setBalance(ch.prev)
}
@ -179,7 +179,7 @@ func (ch balanceChange) dirtied() *common.Address {
return ch.account
}
func (ch nonceChange) revert(s *StateDB) {
func (ch nonceChange) revert(s *DB) {
s.getStateObject(*ch.account).setNonce(ch.prev)
}
@ -187,7 +187,7 @@ func (ch nonceChange) dirtied() *common.Address {
return ch.account
}
func (ch codeChange) revert(s *StateDB) {
func (ch codeChange) revert(s *DB) {
s.getStateObject(*ch.account).setCode(common.BytesToHash(ch.prevhash), ch.prevcode)
}
@ -195,7 +195,7 @@ func (ch codeChange) dirtied() *common.Address {
return ch.account
}
func (ch storageChange) revert(s *StateDB) {
func (ch storageChange) revert(s *DB) {
s.getStateObject(*ch.account).setState(ch.key, ch.prevalue)
}
@ -203,7 +203,7 @@ func (ch storageChange) dirtied() *common.Address {
return ch.account
}
func (ch refundChange) revert(s *StateDB) {
func (ch refundChange) revert(s *DB) {
s.refund = ch.prev
}
@ -211,7 +211,7 @@ func (ch refundChange) dirtied() *common.Address {
return nil
}
func (ch addLogChange) revert(s *StateDB) {
func (ch addLogChange) revert(s *DB) {
logs := s.logs[ch.txhash]
if len(logs) == 1 {
delete(s.logs, ch.txhash)
@ -225,7 +225,7 @@ func (ch addLogChange) dirtied() *common.Address {
return nil
}
func (ch addPreimageChange) revert(s *StateDB) {
func (ch addPreimageChange) revert(s *DB) {
delete(s.preimages, ch.hash)
}

14
core/state/managed_state.go
Unescape View File

@ -30,7 +30,7 @@ type account struct {
// ManagedState is the managed state.
type ManagedState struct {
*StateDB
*DB
mu sync.RWMutex
@ -38,18 +38,18 @@ type ManagedState struct {
}
// ManageState returns a new managed state with the statedb as it's backing layer
func ManageState(statedb *StateDB) *ManagedState {
func ManageState(statedb *DB) *ManagedState {
return &ManagedState{
StateDB: statedb.Copy(),
DB: statedb.Copy(),
accounts: make(map[common.Address]*account),
}
}
// SetState sets the backing layer of the managed state
func (ms *ManagedState) SetState(statedb *StateDB) {
func (ms *ManagedState) SetState(statedb *DB) {
ms.mu.Lock()
defer ms.mu.Unlock()
ms.StateDB = statedb
ms.DB = statedb
}
// RemoveNonce removed the nonce from the managed state and all future pending nonces
@ -94,7 +94,7 @@ func (ms *ManagedState) GetNonce(addr common.Address) uint64 {
account := ms.getAccount(addr)
return uint64(len(account.nonces)) + account.nstart
}
return ms.StateDB.GetNonce(addr)
return ms.DB.GetNonce(addr)
}
// SetNonce sets the new canonical nonce for the managed state
@ -128,7 +128,7 @@ func (ms *ManagedState) getAccount(addr common.Address) *account {
} else {
// Always make sure the state account nonce isn't actually higher
// than the tracked one.
so := ms.StateDB.getStateObject(addr)
so := ms.DB.getStateObject(addr)
if so != nil && uint64(len(account.nonces))+account.nstart < so.Nonce() {
ms.accounts[addr] = newAccount(so)
}

10
core/state/managed_state_test.go
Unescape View File

@ -28,8 +28,8 @@ var addr = common.BytesToAddress([]byte("test"))
func create() (*ManagedState, *account) {
statedb, _ := New(common.Hash{}, NewDatabase(ethdb.NewMemDatabase()))
ms := ManageState(statedb)
ms.StateDB.SetNonce(addr, 100)
ms.accounts[addr] = newAccount(ms.StateDB.getStateObject(addr))
ms.DB.SetNonce(addr, 100)
ms.accounts[addr] = newAccount(ms.DB.getStateObject(addr))
return ms, ms.accounts[addr]
}
@ -89,7 +89,7 @@ func TestRemoteNonceChange(t *testing.T) {
account.nonces = append(account.nonces, nn...)
ms.NewNonce(addr)
ms.StateDB.stateObjects[addr].data.Nonce = 200
ms.DB.stateObjects[addr].data.Nonce = 200
nonce := ms.NewNonce(addr)
if nonce != 200 {
t.Error("expected nonce after remote update to be", 200, "got", nonce)
@ -97,7 +97,7 @@ func TestRemoteNonceChange(t *testing.T) {
ms.NewNonce(addr)
ms.NewNonce(addr)
ms.NewNonce(addr)
ms.StateDB.stateObjects[addr].data.Nonce = 200
ms.DB.stateObjects[addr].data.Nonce = 200
nonce = ms.NewNonce(addr)
if nonce != 204 {
t.Error("expected nonce after remote update to be", 204, "got", nonce)
@ -115,7 +115,7 @@ func TestSetNonce(t *testing.T) {
}
addr[0] = 1
ms.StateDB.SetNonce(addr, 1)
ms.DB.SetNonce(addr, 1)
if ms.GetNonce(addr) != 1 {
t.Error("Expected nonce of 1, got", ms.GetNonce(addr))

8
core/state/state_object.go
Unescape View File

@ -66,13 +66,13 @@ type stateObject struct {
address common.Address
addrHash common.Hash // hash of ethereum address of the account
data Account
db *StateDB
db *DB
// 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.
// by DB.Commit.
dbErr error
// Write caches.
@ -105,7 +105,7 @@ type Account struct {
}
// newObject creates a state object.
func newObject(db *StateDB, address common.Address, data Account) *stateObject {
func newObject(db *DB, address common.Address, data Account) *stateObject {
if data.Balance == nil {
data.Balance = new(big.Int)
}
@ -298,7 +298,7 @@ func (s *stateObject) setBalance(amount *big.Int) {
// Return the gas back to the origin. Used by the Virtual machine or Closures
func (s *stateObject) ReturnGas(gas *big.Int) {}
func (s *stateObject) deepCopy(db *StateDB) *stateObject {
func (s *stateObject) deepCopy(db *DB) *stateObject {
stateObject := newObject(db, s.address, s.data)
if s.trie != nil {
stateObject.trie = db.db.CopyTrie(s.trie)

2
core/state/state_test.go
Unescape View File

@ -29,7 +29,7 @@ import (
type StateSuite struct {
db *ethdb.MemDatabase
state *StateDB
state *DB
}
var _ = checker.Suite(&StateSuite{})

108
core/state/statedb.go
Unescape View File

@ -52,12 +52,12 @@ func (n *proofList) Put(key []byte, value []byte) error {
return nil
}
// StateDB within the ethereum protocol are used to store anything
// DB within the ethereum protocol are used to store anything
// within the merkle trie. StateDBs take care of caching and storing
// nested states. It's the general query interface to retrieve:
// * Contracts
// * Accounts
type StateDB struct {
type DB struct {
db Database
trie Trie
@ -69,7 +69,7 @@ type StateDB struct {
// 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.
// by DB.Commit.
dbErr error
// The refund counter, also used by state transitioning.
@ -92,12 +92,12 @@ type StateDB struct {
}
// New creates a new state from a given trie.
func New(root common.Hash, db Database) (*StateDB, error) {
func New(root common.Hash, db Database) (*DB, error) {
tr, err := db.OpenTrie(root)
if err != nil {
return nil, err
}
return &StateDB{
return &DB{
db: db,
trie: tr,
stateObjects: make(map[common.Address]*stateObject),
@ -109,19 +109,19 @@ func New(root common.Hash, db Database) (*StateDB, error) {
}
// setError remembers the first non-nil error it is called with.
func (stateDB *StateDB) setError(err error) {
func (stateDB *DB) setError(err error) {
if stateDB.dbErr == nil {
stateDB.dbErr = err
}
}
func (stateDB *StateDB) Error() error {
func (stateDB *DB) Error() error {
return stateDB.dbErr
}
// Reset clears out all ephemeral state objects from the state db, but keeps
// the underlying state trie to avoid reloading data for the next operations.
func (stateDB *StateDB) Reset(root common.Hash) error {
func (stateDB *DB) Reset(root common.Hash) error {
tr, err := stateDB.db.OpenTrie(root)
if err != nil {
return err
@ -140,7 +140,7 @@ func (stateDB *StateDB) Reset(root common.Hash) error {
}
// AddLog adds logs into stateDB
func (stateDB *StateDB) AddLog(log *types.Log) {
func (stateDB *DB) AddLog(log *types.Log) {
stateDB.journal.append(addLogChange{txhash: stateDB.thash})
log.TxHash = stateDB.thash
@ -152,12 +152,12 @@ func (stateDB *StateDB) AddLog(log *types.Log) {
}
// GetLogs gets logs from stateDB given a hash
func (stateDB *StateDB) GetLogs(hash common.Hash) []*types.Log {
func (stateDB *DB) GetLogs(hash common.Hash) []*types.Log {
return stateDB.logs[hash]
}
// Logs returns a list of Log.
func (stateDB *StateDB) Logs() []*types.Log {
func (stateDB *DB) Logs() []*types.Log {
var logs []*types.Log
for _, lgs := range stateDB.logs {
logs = append(logs, lgs...)
@ -166,7 +166,7 @@ func (stateDB *StateDB) Logs() []*types.Log {
}
// AddPreimage records a SHA3 preimage seen by the VM.
func (stateDB *StateDB) AddPreimage(hash common.Hash, preimage []byte) {
func (stateDB *DB) AddPreimage(hash common.Hash, preimage []byte) {
if _, ok := stateDB.preimages[hash]; !ok {
stateDB.journal.append(addPreimageChange{hash: hash})
pi := make([]byte, len(preimage))
@ -176,19 +176,19 @@ func (stateDB *StateDB) AddPreimage(hash common.Hash, preimage []byte) {
}
// Preimages returns a list of SHA3 preimages that have been submitted.
func (stateDB *StateDB) Preimages() map[common.Hash][]byte {
func (stateDB *DB) Preimages() map[common.Hash][]byte {
return stateDB.preimages
}
// AddRefund adds gas to the refund counter
func (stateDB *StateDB) AddRefund(gas uint64) {
func (stateDB *DB) AddRefund(gas uint64) {
stateDB.journal.append(refundChange{prev: stateDB.refund})
stateDB.refund += gas
}
// SubRefund removes gas from the refund counter.
// This method will panic if the refund counter goes below zero
func (stateDB *StateDB) SubRefund(gas uint64) {
func (stateDB *DB) SubRefund(gas uint64) {
stateDB.journal.append(refundChange{prev: stateDB.refund})
if gas > stateDB.refund {
panic("Refund counter below zero")
@ -198,19 +198,19 @@ func (stateDB *StateDB) SubRefund(gas uint64) {
// Exist reports whether the given account address exists in the state.
// Notably this also returns true for suicided accounts.
func (stateDB *StateDB) Exist(addr common.Address) bool {
func (stateDB *DB) Exist(addr common.Address) bool {
return stateDB.getStateObject(addr) != nil
}
// Empty returns whether the state object is either non-existent
// or empty according to the EIP161 specification (balance = nonce = code = 0)
func (stateDB *StateDB) Empty(addr common.Address) bool {
func (stateDB *DB) Empty(addr common.Address) bool {
so := stateDB.getStateObject(addr)
return so == nil || so.empty()
}
// GetBalance retrieves the balance from the given address or 0 if object not found
func (stateDB *StateDB) GetBalance(addr common.Address) *big.Int {
func (stateDB *DB) GetBalance(addr common.Address) *big.Int {
stateObject := stateDB.getStateObject(addr)
if stateObject != nil {
return stateObject.Balance()
@ -219,7 +219,7 @@ func (stateDB *StateDB) GetBalance(addr common.Address) *big.Int {
}
// GetNonce returns the nonce of the given address.
func (stateDB *StateDB) GetNonce(addr common.Address) uint64 {
func (stateDB *DB) GetNonce(addr common.Address) uint64 {
stateObject := stateDB.getStateObject(addr)
if stateObject != nil {
return stateObject.Nonce()
@ -229,7 +229,7 @@ func (stateDB *StateDB) GetNonce(addr common.Address) uint64 {
}
// GetCode returns code of a given address.
func (stateDB *StateDB) GetCode(addr common.Address) []byte {
func (stateDB *DB) GetCode(addr common.Address) []byte {
stateObject := stateDB.getStateObject(addr)
if stateObject != nil {
return stateObject.Code(stateDB.db)
@ -238,7 +238,7 @@ func (stateDB *StateDB) GetCode(addr common.Address) []byte {
}
// GetCodeSize returns code size of a given address in stateDB.
func (stateDB *StateDB) GetCodeSize(addr common.Address) int {
func (stateDB *DB) GetCodeSize(addr common.Address) int {
stateObject := stateDB.getStateObject(addr)
if stateObject == nil {
return 0
@ -254,7 +254,7 @@ func (stateDB *StateDB) GetCodeSize(addr common.Address) int {
}
// GetCodeHash returns code hash of a given address.
func (stateDB *StateDB) GetCodeHash(addr common.Address) common.Hash {
func (stateDB *DB) GetCodeHash(addr common.Address) common.Hash {
stateObject := stateDB.getStateObject(addr)
if stateObject == nil {
return common.Hash{}
@ -263,7 +263,7 @@ func (stateDB *StateDB) GetCodeHash(addr common.Address) common.Hash {
}
// GetState retrieves a value from the given account's storage trie.
func (stateDB *StateDB) GetState(addr common.Address, hash common.Hash) common.Hash {
func (stateDB *DB) GetState(addr common.Address, hash common.Hash) common.Hash {
stateObject := stateDB.getStateObject(addr)
if stateObject != nil {
return stateObject.GetState(stateDB.db, hash)
@ -272,14 +272,14 @@ func (stateDB *StateDB) GetState(addr common.Address, hash common.Hash) common.H
}
// GetProof returns the MerkleProof for a given Account
func (stateDB *StateDB) GetProof(a common.Address) ([][]byte, error) {
func (stateDB *DB) GetProof(a common.Address) ([][]byte, error) {
var proof proofList
err := stateDB.trie.Prove(crypto.Keccak256(a.Bytes()), 0, &proof)
return [][]byte(proof), err
}
// GetStorageProof returns the StorageProof for given key
func (stateDB *StateDB) GetStorageProof(a common.Address, key common.Hash) ([][]byte, error) {
func (stateDB *DB) GetStorageProof(a common.Address, key common.Hash) ([][]byte, error) {
var proof proofList
trie := stateDB.StorageTrie(a)
if trie == nil {
@ -290,7 +290,7 @@ func (stateDB *StateDB) GetStorageProof(a common.Address, key common.Hash) ([][]
}
// GetCommittedState retrieves a value from the given account's committed storage trie.
func (stateDB *StateDB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash {
func (stateDB *DB) GetCommittedState(addr common.Address, hash common.Hash) common.Hash {
stateObject := stateDB.getStateObject(addr)
if stateObject != nil {
return stateObject.GetCommittedState(stateDB.db, hash)
@ -299,13 +299,13 @@ func (stateDB *StateDB) GetCommittedState(addr common.Address, hash common.Hash)
}
// Database retrieves the low level database supporting the lower level trie ops.
func (stateDB *StateDB) Database() Database {
func (stateDB *DB) Database() Database {
return stateDB.db
}
// StorageTrie returns the storage trie of an account.
// The return value is a copy and is nil for non-existent accounts.
func (stateDB *StateDB) StorageTrie(addr common.Address) Trie {
func (stateDB *DB) StorageTrie(addr common.Address) Trie {
stateObject := stateDB.getStateObject(addr)
if stateObject == nil {
return nil
@ -315,7 +315,7 @@ func (stateDB *StateDB) StorageTrie(addr common.Address) Trie {
}
// HasSuicided checks if the state object of the given addr is suicided.
func (stateDB *StateDB) HasSuicided(addr common.Address) bool {
func (stateDB *DB) HasSuicided(addr common.Address) bool {
stateObject := stateDB.getStateObject(addr)
if stateObject != nil {
return stateObject.suicided
@ -328,7 +328,7 @@ func (stateDB *StateDB) HasSuicided(addr common.Address) bool {
*/
// AddBalance adds amount to the account associated with addr.
func (stateDB *StateDB) AddBalance(addr common.Address, amount *big.Int) {
func (stateDB *DB) AddBalance(addr common.Address, amount *big.Int) {
stateObject := stateDB.GetOrNewStateObject(addr)
if stateObject != nil {
stateObject.AddBalance(amount)
@ -336,7 +336,7 @@ func (stateDB *StateDB) AddBalance(addr common.Address, amount *big.Int) {
}
// SubBalance subtracts amount from the account associated with addr.
func (stateDB *StateDB) SubBalance(addr common.Address, amount *big.Int) {
func (stateDB *DB) SubBalance(addr common.Address, amount *big.Int) {
stateObject := stateDB.GetOrNewStateObject(addr)
if stateObject != nil {
stateObject.SubBalance(amount)
@ -344,7 +344,7 @@ func (stateDB *StateDB) SubBalance(addr common.Address, amount *big.Int) {
}
// SetBalance sets balance of an address.
func (stateDB *StateDB) SetBalance(addr common.Address, amount *big.Int) {
func (stateDB *DB) SetBalance(addr common.Address, amount *big.Int) {
stateObject := stateDB.GetOrNewStateObject(addr)
if stateObject != nil {
stateObject.SetBalance(amount)
@ -352,7 +352,7 @@ func (stateDB *StateDB) SetBalance(addr common.Address, amount *big.Int) {
}
// SetNonce sets nonce of a given address.
func (stateDB *StateDB) SetNonce(addr common.Address, nonce uint64) {
func (stateDB *DB) SetNonce(addr common.Address, nonce uint64) {
stateObject := stateDB.GetOrNewStateObject(addr)
if stateObject != nil {
stateObject.SetNonce(nonce)
@ -360,7 +360,7 @@ func (stateDB *StateDB) SetNonce(addr common.Address, nonce uint64) {
}
// SetCode sets code of a given address.
func (stateDB *StateDB) SetCode(addr common.Address, code []byte) {
func (stateDB *DB) SetCode(addr common.Address, code []byte) {
stateObject := stateDB.GetOrNewStateObject(addr)
if stateObject != nil {
stateObject.SetCode(crypto.Keccak256Hash(code), code)
@ -368,7 +368,7 @@ func (stateDB *StateDB) SetCode(addr common.Address, code []byte) {
}
// SetState sets hash value of a given address.
func (stateDB *StateDB) SetState(addr common.Address, key, value common.Hash) {
func (stateDB *DB) SetState(addr common.Address, key, value common.Hash) {
stateObject := stateDB.GetOrNewStateObject(addr)
if stateObject != nil {
stateObject.SetState(stateDB.db, key, value)
@ -380,7 +380,7 @@ func (stateDB *StateDB) SetState(addr common.Address, key, value common.Hash) {
//
// The account's state object is still available until the state is committed,
// getStateObject will return a non-nil account after Suicide.
func (stateDB *StateDB) Suicide(addr common.Address) bool {
func (stateDB *DB) Suicide(addr common.Address) bool {
stateObject := stateDB.getStateObject(addr)
if stateObject == nil {
return false
@ -401,7 +401,7 @@ func (stateDB *StateDB) Suicide(addr common.Address) bool {
//
// updateStateObject writes the given object to the trie.
func (stateDB *StateDB) updateStateObject(stateObject *stateObject) {
func (stateDB *DB) updateStateObject(stateObject *stateObject) {
addr := stateObject.Address()
data, err := rlp.EncodeToBytes(stateObject)
if err != nil {
@ -411,14 +411,14 @@ func (stateDB *StateDB) updateStateObject(stateObject *stateObject) {
}
// deleteStateObject removes the given object from the state trie.
func (stateDB *StateDB) deleteStateObject(stateObject *stateObject) {
func (stateDB *DB) deleteStateObject(stateObject *stateObject) {
stateObject.deleted = true
addr := stateObject.Address()
stateDB.setError(stateDB.trie.TryDelete(addr[:]))
}
// Retrieve a state object given by the address. Returns nil if not found.
func (stateDB *StateDB) getStateObject(addr common.Address) (stateObject *stateObject) {
func (stateDB *DB) getStateObject(addr common.Address) (stateObject *stateObject) {
// Prefer 'live' objects.
if obj := stateDB.stateObjects[addr]; obj != nil {
if obj.deleted {
@ -444,12 +444,12 @@ func (stateDB *StateDB) getStateObject(addr common.Address) (stateObject *stateO
return obj
}
func (stateDB *StateDB) setStateObject(object *stateObject) {
func (stateDB *DB) setStateObject(object *stateObject) {
stateDB.stateObjects[object.Address()] = object
}
// GetOrNewStateObject retrieves a state object or create a new state object if nil.
func (stateDB *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {
func (stateDB *DB) GetOrNewStateObject(addr common.Address) *stateObject {
stateObject := stateDB.getStateObject(addr)
if stateObject == nil || stateObject.deleted {
stateObject, _ = stateDB.createObject(addr)
@ -459,7 +459,7 @@ func (stateDB *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {
// createObject creates a new state object. If there is an existing account with
// the given address, it is overwritten and returned as the second return value.
func (stateDB *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {
func (stateDB *DB) createObject(addr common.Address) (newobj, prev *stateObject) {
prev = stateDB.getStateObject(addr)
newobj = newObject(stateDB, addr, Account{})
newobj.setNonce(0) // sets the object to dirty
@ -482,7 +482,7 @@ func (stateDB *StateDB) createObject(addr common.Address) (newobj, prev *stateOb
// 2. tx_create(sha(account ++ nonce)) (note that this gets the address of 1)
//
// Carrying over the balance ensures that Ether doesn't disappear.
func (stateDB *StateDB) CreateAccount(addr common.Address) {
func (stateDB *DB) CreateAccount(addr common.Address) {
new, prev := stateDB.createObject(addr)
if prev != nil {
new.setBalance(prev.data.Balance)
@ -490,7 +490,7 @@ func (stateDB *StateDB) CreateAccount(addr common.Address) {
}
// ForEachStorage runs a function on every item in state DB.
func (stateDB *StateDB) ForEachStorage(addr common.Address, cb func(key, value common.Hash) bool) {
func (stateDB *DB) ForEachStorage(addr common.Address, cb func(key, value common.Hash) bool) {
so := stateDB.getStateObject(addr)
if so == nil {
return
@ -508,12 +508,12 @@ func (stateDB *StateDB) ForEachStorage(addr common.Address, cb func(key, value c
// Copy creates a deep, independent copy of the state.
// Snapshots of the copied state cannot be applied to the copy.
func (stateDB *StateDB) Copy() *StateDB {
func (stateDB *DB) Copy() *DB {
stateDB.lock.Lock()
defer stateDB.lock.Unlock()
// Copy all the basic fields, initialize the memory ones
state := &StateDB{
state := &DB{
db: stateDB.db,
trie: stateDB.db.CopyTrie(stateDB.trie),
stateObjects: make(map[common.Address]*stateObject, len(stateDB.journal.dirties)),
@ -559,7 +559,7 @@ func (stateDB *StateDB) Copy() *StateDB {
}
// Snapshot returns an identifier for the current revision of the state.
func (stateDB *StateDB) Snapshot() int {
func (stateDB *DB) Snapshot() int {
id := stateDB.nextRevisionID
stateDB.nextRevisionID++
stateDB.validRevisions = append(stateDB.validRevisions, revision{id, stateDB.journal.length()})
@ -567,7 +567,7 @@ func (stateDB *StateDB) Snapshot() int {
}
// RevertToSnapshot reverts all state changes made since the given revision.
func (stateDB *StateDB) RevertToSnapshot(revid int) {
func (stateDB *DB) RevertToSnapshot(revid int) {
// Find the snapshot in the stack of valid snapshots.
idx := sort.Search(len(stateDB.validRevisions), func(i int) bool {
return stateDB.validRevisions[i].id >= revid
@ -583,13 +583,13 @@ func (stateDB *StateDB) RevertToSnapshot(revid int) {
}
// GetRefund returns the current value of the refund counter.
func (stateDB *StateDB) GetRefund() uint64 {
func (stateDB *DB) GetRefund() uint64 {
return stateDB.refund
}
// Finalise finalises the state by removing the self destructed objects
// and clears the journal as well as the refunds.
func (stateDB *StateDB) Finalise(deleteEmptyObjects bool) {
func (stateDB *DB) Finalise(deleteEmptyObjects bool) {
for addr := range stateDB.journal.dirties {
stateObject, exist := stateDB.stateObjects[addr]
if !exist {
@ -617,27 +617,27 @@ func (stateDB *StateDB) Finalise(deleteEmptyObjects bool) {
// IntermediateRoot computes the current root hash of the state trie.
// It is called in between transactions to get the root hash that
// goes into transaction receipts.
func (stateDB *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
func (stateDB *DB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
stateDB.Finalise(deleteEmptyObjects)
return stateDB.trie.Hash()
}
// Prepare sets the current transaction hash and index and block hash which is
// used when the EVM emits new state logs.
func (stateDB *StateDB) Prepare(thash, bhash common.Hash, ti int) {
func (stateDB *DB) Prepare(thash, bhash common.Hash, ti int) {
stateDB.thash = thash
stateDB.bhash = bhash
stateDB.txIndex = ti
}
func (stateDB *StateDB) clearJournalAndRefund() {
func (stateDB *DB) clearJournalAndRefund() {
stateDB.journal = newJournal()
stateDB.validRevisions = stateDB.validRevisions[:0]
stateDB.refund = 0
}
// Commit writes the state to the underlying in-memory trie database.
func (stateDB *StateDB) Commit(deleteEmptyObjects bool) (root common.Hash, err error) {
func (stateDB *DB) Commit(deleteEmptyObjects bool) (root common.Hash, err error) {
defer stateDB.clearJournalAndRefund()
for addr := range stateDB.journal.dirties {

26
core/state/statedb_test.go
Unescape View File

@ -71,7 +71,7 @@ func TestIntermediateLeaks(t *testing.T) {
transState, _ := New(common.Hash{}, NewDatabase(transDb))
finalState, _ := New(common.Hash{}, NewDatabase(finalDb))
modify := func(state *StateDB, addr common.Address, i, tweak byte) {
modify := func(state *DB, addr common.Address, i, tweak byte) {
state.SetBalance(addr, big.NewInt(int64(11*i)+int64(tweak)))
state.SetNonce(addr, uint64(42*i+tweak))
if i%2 == 0 {
@ -178,7 +178,7 @@ func TestSnapshotRandom(t *testing.T) {
}
}
// A snapshotTest checks that reverting StateDB snapshots properly undoes all changes
// A snapshotTest checks that reverting DB snapshots properly undoes all changes
// captured by the snapshot. Instances of this test with pseudorandom content are created
// by Generate.
//
@ -198,7 +198,7 @@ type snapshotTest struct {
type testAction struct {
name string
fn func(testAction, *StateDB)
fn func(testAction, *DB)
args []int64
noAddr bool
}
@ -208,28 +208,28 @@ func newTestAction(addr common.Address, r *rand.Rand) testAction {
actions := []testAction{
{
name: "SetBalance",
fn: func(a testAction, s *StateDB) {
fn: func(a testAction, s *DB) {
s.SetBalance(addr, big.NewInt(a.args[0]))
},
args: make([]int64, 1),
},
{
name: "AddBalance",
fn: func(a testAction, s *StateDB) {
fn: func(a testAction, s *DB) {
s.AddBalance(addr, big.NewInt(a.args[0]))
},
args: make([]int64, 1),
},
{
name: "SetNonce",
fn: func(a testAction, s *StateDB) {
fn: func(a testAction, s *DB) {
s.SetNonce(addr, uint64(a.args[0]))
},
args: make([]int64, 1),
},
{
name: "SetState",
fn: func(a testAction, s *StateDB) {
fn: func(a testAction, s *DB) {
var key, val common.Hash
binary.BigEndian.PutUint16(key[:], uint16(a.args[0]))
binary.BigEndian.PutUint16(val[:], uint16(a.args[1]))
@ -239,7 +239,7 @@ func newTestAction(addr common.Address, r *rand.Rand) testAction {
},
{
name: "SetCode",
fn: func(a testAction, s *StateDB) {
fn: func(a testAction, s *DB) {
code := make([]byte, 16)
binary.BigEndian.PutUint64(code, uint64(a.args[0]))
binary.BigEndian.PutUint64(code[8:], uint64(a.args[1]))
@ -249,19 +249,19 @@ func newTestAction(addr common.Address, r *rand.Rand) testAction {
},
{
name: "CreateAccount",
fn: func(a testAction, s *StateDB) {
fn: func(a testAction, s *DB) {
s.CreateAccount(addr)
},
},
{
name: "Suicide",
fn: func(a testAction, s *StateDB) {
fn: func(a testAction, s *DB) {
s.Suicide(addr)
},
},
{
name: "AddRefund",
fn: func(a testAction, s *StateDB) {
fn: func(a testAction, s *DB) {
s.AddRefund(uint64(a.args[0]))
},
args: make([]int64, 1),
@ -269,7 +269,7 @@ func newTestAction(addr common.Address, r *rand.Rand) testAction {
},
{
name: "AddLog",
fn: func(a testAction, s *StateDB) {
fn: func(a testAction, s *DB) {
data := make([]byte, 2)
binary.BigEndian.PutUint16(data, uint16(a.args[0]))
s.AddLog(&types.Log{Address: addr, Data: data})
@ -361,7 +361,7 @@ func (test *snapshotTest) run() bool {
}
// checkEqual checks that methods of state and checkstate return the same values.
func (test *snapshotTest) checkEqual(state, checkstate *StateDB) error {
func (test *snapshotTest) checkEqual(state, checkstate *DB) error {
for _, addr := range test.addrs {
var err error
checkeq := func(op string, a, b interface{}) bool {

4
core/state_processor.go
Unescape View File

@ -52,7 +52,7 @@ func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consen
// Process returns the receipts and logs accumulated during the process and
// returns the amount of gas that was used in the process. If any of the
// transactions failed to execute due to insufficient gas it will return an error.
func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) {
func (p *StateProcessor) Process(block *types.Block, statedb *state.DB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) {
var (
receipts types.Receipts
usedGas = new(uint64)
@ -84,7 +84,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
// and uses the input parameters for its environment. It returns the receipt
// for the transaction, gas used and an error if the transaction failed,
// indicating the block was invalid.
func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, uint64, error) {
func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.DB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, uint64, error) {
msg, err := tx.AsMessage(types.MakeSigner(config, header.Number))
if err != nil {
return nil, 0, err

4
core/tx_pool.go
Unescape View File

@ -117,7 +117,7 @@ const (
type blockChain interface {
CurrentBlock() *types.Block
GetBlock(hash common.Hash, number uint64) *types.Block
StateAt(root common.Hash) (*state.StateDB, error)
StateAt(root common.Hash) (*state.DB, error)
SubscribeChainHeadEvent(ch chan<- ChainHeadEvent) event.Subscription
}
@ -195,7 +195,7 @@ type TxPool struct {
signer types.Signer
mu sync.RWMutex
currentState *state.StateDB // Current state in the blockchain head
currentState *state.DB // Current state in the blockchain head
pendingState *state.ManagedState // Pending state tracking virtual nonces
currentMaxGas uint64 // Current gas limit for transaction caps

6
core/tx_pool_test.go
Unescape View File

@ -45,7 +45,7 @@ func init() {
}
type testBlockChain struct {
statedb *state.StateDB
statedb *state.DB
gasLimit uint64
chainHeadFeed *event.Feed
}
@ -60,7 +60,7 @@ func (bc *testBlockChain) GetBlock(hash common.Hash, number uint64) *types.Block
return bc.CurrentBlock()
}
func (bc *testBlockChain) StateAt(common.Hash) (*state.StateDB, error) {
func (bc *testBlockChain) StateAt(common.Hash) (*state.DB, error) {
return bc.statedb, nil
}
@ -157,7 +157,7 @@ type testChain struct {
// testChain.State() is used multiple times to reset the pending state.
// when simulate is true it will create a state that indicates
// that tx0 and tx1 are included in the chain.
func (c *testChain) State() (*state.StateDB, error) {
func (c *testChain) State() (*state.DB, error) {
// delay "state change" by one. The tx pool fetches the
// state multiple times and by delaying it a bit we simulate
// a state change between those fetches.

4
core/types.go
Unescape View File

@ -32,7 +32,7 @@ type Validator interface {
// ValidateState validates the given statedb and optionally the receipts and
// gas used.
ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas uint64) error
ValidateState(block, parent *types.Block, state *state.DB, receipts types.Receipts, usedGas uint64) error
}
// Processor is an interface for processing blocks using a given initial state.
@ -42,5 +42,5 @@ type Validator interface {
// of gas used in the process and return an error if any of the internal rules
// failed.
type Processor interface {
Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error)
Process(block *types.Block, statedb *state.DB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error)
}

2
core/vm/logger_test.go
Unescape View File

@ -43,7 +43,7 @@ func (d *dummyContractRef) SetNonce(uint64) {}
func (d *dummyContractRef) Balance() *big.Int { return new(big.Int) }
type dummyStatedb struct {
state.StateDB
state.DB
}
// GetRefund ...

4
core/vm/runtime/runtime.go
Unescape View File

@ -44,7 +44,7 @@ type Config struct {
Debug bool
EVMConfig vm.Config
State *state.StateDB
State *state.DB
GetHashFn func(n uint64) common.Hash
}
@ -92,7 +92,7 @@ func setDefaults(cfg *Config) {
//
// Executes sets up a in memory, temporarily, environment for the execution of
// the given code. It makes sure that it's restored to it's original state afterwards.
func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) {
func Execute(code, input []byte, cfg *Config) ([]byte, *state.DB, error) {
if cfg == nil {
cfg = new(Config)
}

4
node/worker/worker.go
Unescape View File

@ -17,7 +17,7 @@ import (
// environment is the worker's current environment and holds all of the current state information.
type environment struct {
state *state.StateDB // apply state changes here
state *state.DB // apply state changes here
gasPool *core.GasPool // available gas used to pack transactions
header *types.Header
@ -136,7 +136,7 @@ func (w *Worker) makeCurrent(parent *types.Block, header *types.Header) error {
}
// GetCurrentState gets the current state.
func (w *Worker) GetCurrentState() *state.StateDB {
func (w *Worker) GetCurrentState() *state.DB {
return w.current.state
}

Write Preview
Loading…
Cancel
Save