forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-18 18:02:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

core/state: rename code reader interface

Browse source
This commit is contained in:
Gary Rong 2024-11-28 14:03:56 +08:00
parent c3e12a3dfb
commit f2d1a11aaf
4 changed files with 30 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
core/state/iterator.go
View file

@ -136,7 +136,7 @@ func (it *nodeIterator) step() error {
}
if !bytes.Equal(account.CodeHash, types.EmptyCodeHash.Bytes()) {
it.codeHash = common.BytesToHash(account.CodeHash)
it.code, err = it.state.reader.ContractCode(address, common.BytesToHash(account.CodeHash))
it.code, err = it.state.reader.Code(address, common.BytesToHash(account.CodeHash))
if err != nil {
return fmt.Errorf("code %x: %v", account.CodeHash, err)
}

42
core/state/reader.go
View file

@ -32,21 +32,21 @@ import (
"github.com/ethereum/go-ethereum/triedb/database"
)
// CodeReader defines the interface for accessing contract code.
type CodeReader interface {
// ContractCode retrieves a particular contract's code.
// ContractCodeReader defines the interface for accessing contract code.
type ContractCodeReader interface {
// Code retrieves a particular contract's code.
//
// - Returns nil code along with nil error if the requested contract code
// doesn't exist
// - Returns an error only if an unexpected issue occurs
ContractCode(addr common.Address, codeHash common.Hash) ([]byte, error)
Code(addr common.Address, codeHash common.Hash) ([]byte, error)
// ContractCodeSize retrieves a particular contracts code's size.
// CodeSize retrieves a particular contracts code's size.
//
// - Returns zero code size along with nil error if the requested contract code
// doesn't exist
// - Returns an error only if an unexpected issue occurs
ContractCodeSize(addr common.Address, codeHash common.Hash) (int, error)
CodeSize(addr common.Address, codeHash common.Hash) (int, error)
}
// StateReader defines the interface for accessing accounts and storage slots
@ -71,11 +71,11 @@ type StateReader interface {
// Reader defines the interface for accessing accounts, storage slots and contract
// code associated with a specific state.
type Reader interface {
CodeReader
ContractCodeReader
StateReader
}
// cachingCodeReader implements CodeReader, accessing contract code either in
// cachingCodeReader implements ContractCodeReader, accessing contract code either in
// local key-value store or the shared code cache.
type cachingCodeReader struct {
db ethdb.KeyValueReader
@ -95,9 +95,9 @@ func newCachingCodeReader(db ethdb.KeyValueReader, codeCache *lru.SizeConstraine
}
}
// ContractCode implements CodeReader, retrieving a particular contract's code.
// Code implements ContractCodeReader, retrieving a particular contract's code.
// If the contract code doesn't exist, no error will be returned.
func (r *cachingCodeReader) ContractCode(addr common.Address, codeHash common.Hash) ([]byte, error) {
func (r *cachingCodeReader) Code(addr common.Address, codeHash common.Hash) ([]byte, error) {
code, _ := r.codeCache.Get(codeHash)
if len(code) > 0 {
return code, nil
@ -110,13 +110,13 @@ func (r *cachingCodeReader) ContractCode(addr common.Address, codeHash common.Ha
return code, nil
}
// ContractCodeSize implements CodeReader, retrieving a particular contracts code's size.
// CodeSize implements ContractCodeReader, retrieving a particular contracts code's size.
// If the contract code doesn't exist, no error will be returned.
func (r *cachingCodeReader) ContractCodeSize(addr common.Address, codeHash common.Hash) (int, error) {
func (r *cachingCodeReader) CodeSize(addr common.Address, codeHash common.Hash) (int, error) {
if cached, ok := r.codeSizeCache.Get(codeHash); ok {
return cached, nil
}
code, err := r.ContractCode(addr, codeHash)
code, err := r.Code(addr, codeHash)
if err != nil {
return 0, err
}
@ -290,16 +290,16 @@ func (r *trieReader) Storage(addr common.Address, key common.Hash) (common.Hash,
return value, nil
}
// singleReader is the wrapper of CodeReader and StateReader interface.
// singleReader is the wrapper of ContractCodeReader and StateReader interface.
type singleReader struct {
CodeReader
ContractCodeReader
StateReader
}
// newSingleReader constructs a reader with the supplied code reader and state reader.
func newSingleReader(codeReader CodeReader, stateReader StateReader) *singleReader {
func newSingleReader(codeReader ContractCodeReader, stateReader StateReader) *singleReader {
return &singleReader{
CodeReader: codeReader,
ContractCodeReader: codeReader,
StateReader: stateReader,
}
}
@ -360,10 +360,10 @@ func (r *multiReader) Storage(addr common.Address, slot common.Hash) (common.Has
}
// ContractCode implements Reader, retrieving a particular contract's code.
func (r *multiReader) ContractCode(addr common.Address, codeHash common.Hash) ([]byte, error) {
func (r *multiReader) Code(addr common.Address, codeHash common.Hash) ([]byte, error) {
var errs []error
for _, reader := range r.readers {
code, err := reader.ContractCode(addr, codeHash)
code, err := reader.Code(addr, codeHash)
if err == nil {
return code, nil
}
@ -373,10 +373,10 @@ func (r *multiReader) ContractCode(addr common.Address, codeHash common.Hash) ([
}
// ContractCodeSize implements Reader, retrieving a particular contracts code's size.
func (r *multiReader) ContractCodeSize(addr common.Address, codeHash common.Hash) (int, error) {
func (r *multiReader) CodeSize(addr common.Address, codeHash common.Hash) (int, error) {
var errs []error
for _, reader := range r.readers {
size, err := reader.ContractCodeSize(addr, codeHash)
size, err := reader.CodeSize(addr, codeHash)
if err == nil {
return size, nil
}

4
core/state/state_object.go
View file

@ -510,7 +510,7 @@ func (s *stateObject) Code() []byte {
if bytes.Equal(s.CodeHash(), types.EmptyCodeHash.Bytes()) {
return nil
}
code, err := s.db.reader.ContractCode(s.address, common.BytesToHash(s.CodeHash()))
code, err := s.db.reader.Code(s.address, common.BytesToHash(s.CodeHash()))
if err != nil {
s.db.setError(fmt.Errorf("can't load code hash %x: %v", s.CodeHash(), err))
}
@ -531,7 +531,7 @@ func (s *stateObject) CodeSize() int {
if bytes.Equal(s.CodeHash(), types.EmptyCodeHash.Bytes()) {
return 0
}
size, err := s.db.reader.ContractCodeSize(s.address, common.BytesToHash(s.CodeHash()))
size, err := s.db.reader.CodeSize(s.address, common.BytesToHash(s.CodeHash()))
if err != nil {
s.db.setError(fmt.Errorf("can't load code size %x: %v", s.CodeHash(), err))
}

10
core/state/sync_test.go
View file

@ -221,7 +221,7 @@ func testIterativeStateSync(t *testing.T, count int, commit bool, bypath bool, s
codeResults = make([]trie.CodeSyncResult, len(codeElements))
)
for i, element := range codeElements {
data, err := cReader.ContractCode(common.Address{}, element.code)
data, err := cReader.Code(common.Address{}, element.code)
if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve contract bytecode for hash %x", element.code)
}
@ -345,7 +345,7 @@ func testIterativeDelayedStateSync(t *testing.T, scheme string) {
if len(codeElements) > 0 {
codeResults := make([]trie.CodeSyncResult, len(codeElements)/2+1)
for i, element := range codeElements[:len(codeResults)] {
data, err := cReader.ContractCode(common.Address{}, element.code)
data, err := cReader.Code(common.Address{}, element.code)
if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve contract bytecode for %x", element.code)
}
@ -451,7 +451,7 @@ func testIterativeRandomStateSync(t *testing.T, count int, scheme string) {
if len(codeQueue) > 0 {
results := make([]trie.CodeSyncResult, 0, len(codeQueue))
for hash := range codeQueue {
data, err := cReader.ContractCode(common.Address{}, hash)
data, err := cReader.Code(common.Address{}, hash)
if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve node data for %x", hash)
}
@ -550,7 +550,7 @@ func testIterativeRandomDelayedStateSync(t *testing.T, scheme string) {
for hash := range codeQueue {
delete(codeQueue, hash)
data, err := cReader.ContractCode(common.Address{}, hash)
data, err := cReader.Code(common.Address{}, hash)
if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve node data for %x", hash)
}
@ -670,7 +670,7 @@ func testIncompleteStateSync(t *testing.T, scheme string) {
if len(codeQueue) > 0 {
results := make([]trie.CodeSyncResult, 0, len(codeQueue))
for hash := range codeQueue {
data, err := cReader.ContractCode(common.Address{}, hash)
data, err := cReader.Code(common.Address{}, hash)
if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve node data for %x", hash)
}