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()) { if !bytes.Equal(account.CodeHash, types.EmptyCodeHash.Bytes()) {
it.codeHash = common.BytesToHash(account.CodeHash) 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 { if err != nil {
return fmt.Errorf("code %x: %v", account.CodeHash, err) return fmt.Errorf("code %x: %v", account.CodeHash, err)
} }

44
core/state/reader.go
View file

@ -32,21 +32,21 @@ import (
"github.com/ethereum/go-ethereum/triedb/database" "github.com/ethereum/go-ethereum/triedb/database"
) )
// CodeReader defines the interface for accessing contract code. // ContractCodeReader defines the interface for accessing contract code.
type CodeReader interface { type ContractCodeReader interface {
// ContractCode retrieves a particular contract's code. // Code retrieves a particular contract's code.
// //
// - Returns nil code along with nil error if the requested contract code // - Returns nil code along with nil error if the requested contract code
// doesn't exist // doesn't exist
// - Returns an error only if an unexpected issue occurs // - 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 // - Returns zero code size along with nil error if the requested contract code
// doesn't exist // doesn't exist
// - Returns an error only if an unexpected issue occurs // - 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 // 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 // Reader defines the interface for accessing accounts, storage slots and contract
// code associated with a specific state. // code associated with a specific state.
type Reader interface { type Reader interface {
CodeReader ContractCodeReader
StateReader 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. // local key-value store or the shared code cache.
type cachingCodeReader struct { type cachingCodeReader struct {
db ethdb.KeyValueReader 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. // 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) code, _ := r.codeCache.Get(codeHash)
if len(code) > 0 { if len(code) > 0 {
return code, nil return code, nil
@ -110,13 +110,13 @@ func (r *cachingCodeReader) ContractCode(addr common.Address, codeHash common.Ha
return code, nil 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. // 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 { if cached, ok := r.codeSizeCache.Get(codeHash); ok {
return cached, nil return cached, nil
} }
code, err := r.ContractCode(addr, codeHash) code, err := r.Code(addr, codeHash)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -290,17 +290,17 @@ func (r *trieReader) Storage(addr common.Address, key common.Hash) (common.Hash,
return value, nil return value, nil
} }
// singleReader is the wrapper of CodeReader and StateReader interface. // singleReader is the wrapper of ContractCodeReader and StateReader interface.
type singleReader struct { type singleReader struct {
CodeReader ContractCodeReader
StateReader StateReader
} }
// newSingleReader constructs a reader with the supplied code reader and state reader. // 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{ return &singleReader{
CodeReader: codeReader, ContractCodeReader: codeReader,
StateReader: stateReader, 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. // 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 var errs []error
for _, reader := range r.readers { for _, reader := range r.readers {
code, err := reader.ContractCode(addr, codeHash) code, err := reader.Code(addr, codeHash)
if err == nil { if err == nil {
return code, 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. // 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 var errs []error
for _, reader := range r.readers { for _, reader := range r.readers {
size, err := reader.ContractCodeSize(addr, codeHash) size, err := reader.CodeSize(addr, codeHash)
if err == nil { if err == nil {
return size, 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()) { if bytes.Equal(s.CodeHash(), types.EmptyCodeHash.Bytes()) {
return nil 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 { if err != nil {
s.db.setError(fmt.Errorf("can't load code hash %x: %v", s.CodeHash(), err)) 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()) { if bytes.Equal(s.CodeHash(), types.EmptyCodeHash.Bytes()) {
return 0 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 { if err != nil {
s.db.setError(fmt.Errorf("can't load code size %x: %v", s.CodeHash(), err)) 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)) codeResults = make([]trie.CodeSyncResult, len(codeElements))
) )
for i, element := range 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 { if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve contract bytecode for hash %x", element.code) 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 { if len(codeElements) > 0 {
codeResults := make([]trie.CodeSyncResult, len(codeElements)/2+1) codeResults := make([]trie.CodeSyncResult, len(codeElements)/2+1)
for i, element := range codeElements[:len(codeResults)] { 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 { if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve contract bytecode for %x", element.code) 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 { if len(codeQueue) > 0 {
results := make([]trie.CodeSyncResult, 0, len(codeQueue)) results := make([]trie.CodeSyncResult, 0, len(codeQueue))
for hash := range 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 { if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve node data for %x", hash) 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 { for hash := range codeQueue {
delete(codeQueue, hash) delete(codeQueue, hash)
data, err := cReader.ContractCode(common.Address{}, hash) data, err := cReader.Code(common.Address{}, hash)
if err != nil || len(data) == 0 { if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve node data for %x", hash) 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 { if len(codeQueue) > 0 {
results := make([]trie.CodeSyncResult, 0, len(codeQueue)) results := make([]trie.CodeSyncResult, 0, len(codeQueue))
for hash := range 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 { if err != nil || len(data) == 0 {
t.Fatalf("failed to retrieve node data for %x", hash) t.Fatalf("failed to retrieve node data for %x", hash)
} }