diff --git a/accounts/abi/argument.go b/accounts/abi/argument.go
index fa5461895a..227a088b7d 100644
--- a/accounts/abi/argument.go
+++ b/accounts/abi/argument.go
@@ -127,7 +127,7 @@ func (arguments Arguments) Copy(v interface{}, values []interface{}) error {
return arguments.copyAtomic(v, values[0])
}
-// unpackAtomic unpacks ( hexdata -> go ) a single value
+// copyAtomic copies ( hexdata -> go ) a single value
func (arguments Arguments) copyAtomic(v interface{}, marshalledValues interface{}) error {
dst := reflect.ValueOf(v).Elem()
src := reflect.ValueOf(marshalledValues)
diff --git a/accounts/external/backend.go b/accounts/external/backend.go
index 6f1581f9b8..62322753da 100644
--- a/accounts/external/backend.go
+++ b/accounts/external/backend.go
@@ -205,7 +205,7 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
to = &t
}
args := &apitypes.SendTxArgs{
- Data: &data,
+ Input: &data,
Nonce: hexutil.Uint64(tx.Nonce()),
Value: hexutil.Big(*tx.Value()),
Gas: hexutil.Uint64(tx.Gas()),
@@ -215,7 +215,7 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
switch tx.Type() {
case types.LegacyTxType, types.AccessListTxType:
args.GasPrice = (*hexutil.Big)(tx.GasPrice())
- case types.DynamicFeeTxType:
+ case types.DynamicFeeTxType, types.BlobTxType:
args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
default:
@@ -235,6 +235,17 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
accessList := tx.AccessList()
args.AccessList = &accessList
}
+ if tx.Type() == types.BlobTxType {
+ args.BlobHashes = tx.BlobHashes()
+ sidecar := tx.BlobTxSidecar()
+ if sidecar == nil {
+ return nil, errors.New("blobs must be present for signing")
+ }
+ args.Blobs = sidecar.Blobs
+ args.Commitments = sidecar.Commitments
+ args.Proofs = sidecar.Proofs
+ }
+
var res signTransactionResult
if err := api.client.Call(&res, "account_signTransaction", args); err != nil {
return nil, err
diff --git a/accounts/keystore/account_cache.go b/accounts/keystore/account_cache.go
index 4ed1439514..f7cf688e62 100644
--- a/accounts/keystore/account_cache.go
+++ b/accounts/keystore/account_cache.go
@@ -22,6 +22,7 @@ import (
"fmt"
"os"
"path/filepath"
+ "slices"
"sort"
"strings"
"sync"
@@ -31,7 +32,6 @@ import (
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/log"
- "golang.org/x/exp/slices"
)
// Minimum amount of time between cache reloads. This limit applies if the platform does
diff --git a/accounts/keystore/account_cache_test.go b/accounts/keystore/account_cache_test.go
index bb92cc2adc..1a9f9a4714 100644
--- a/accounts/keystore/account_cache_test.go
+++ b/accounts/keystore/account_cache_test.go
@@ -23,6 +23,7 @@ import (
"os"
"path/filepath"
"reflect"
+ "slices"
"testing"
"time"
@@ -30,7 +31,6 @@ import (
"github.com/davecgh/go-spew/spew"
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common"
- "golang.org/x/exp/slices"
)
var (
@@ -51,7 +51,7 @@ var (
}
)
-// waitWatcherStarts waits up to 1s for the keystore watcher to start.
+// waitWatcherStart waits up to 1s for the keystore watcher to start.
func waitWatcherStart(ks *KeyStore) bool {
// On systems where file watch is not supported, just return "ok".
if !ks.cache.watcher.enabled() {
diff --git a/accounts/keystore/keystore_test.go b/accounts/keystore/keystore_test.go
index c871392b82..f8922a3f3f 100644
--- a/accounts/keystore/keystore_test.go
+++ b/accounts/keystore/keystore_test.go
@@ -20,6 +20,7 @@ import (
"math/rand"
"os"
"runtime"
+ "slices"
"strings"
"sync"
"sync/atomic"
@@ -30,7 +31,6 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/event"
- "golang.org/x/exp/slices"
)
var testSigData = make([]byte, 32)
@@ -343,7 +343,7 @@ func TestWalletNotifications(t *testing.T) {
checkEvents(t, wantEvents, events)
}
-// TestImportExport tests the import functionality of a keystore.
+// TestImportECDSA tests the import functionality of a keystore.
func TestImportECDSA(t *testing.T) {
t.Parallel()
_, ks := tmpKeyStore(t)
@@ -362,7 +362,7 @@ func TestImportECDSA(t *testing.T) {
}
}
-// TestImportECDSA tests the import and export functionality of a keystore.
+// TestImportExport tests the import and export functionality of a keystore.
func TestImportExport(t *testing.T) {
t.Parallel()
_, ks := tmpKeyStore(t)
diff --git a/beacon/blsync/config.go b/beacon/blsync/config.go
index 1b0b0dbff9..93ed81306c 100644
--- a/beacon/blsync/config.go
+++ b/beacon/blsync/config.go
@@ -72,9 +72,9 @@ var (
)
func makeChainConfig(ctx *cli.Context) lightClientConfig {
- utils.CheckExclusive(ctx, utils.MainnetFlag, utils.GoerliFlag, utils.SepoliaFlag)
- customConfig := ctx.IsSet(utils.BeaconConfigFlag.Name) || ctx.IsSet(utils.BeaconGenesisRootFlag.Name) || ctx.IsSet(utils.BeaconGenesisTimeFlag.Name)
var config lightClientConfig
+ customConfig := ctx.IsSet(utils.BeaconConfigFlag.Name)
+ utils.CheckExclusive(ctx, utils.MainnetFlag, utils.GoerliFlag, utils.SepoliaFlag, utils.BeaconConfigFlag)
switch {
case ctx.Bool(utils.MainnetFlag.Name):
config = MainnetConfig
@@ -87,24 +87,37 @@ func makeChainConfig(ctx *cli.Context) lightClientConfig {
config = MainnetConfig
}
}
- if customConfig && config.Forks != nil {
- utils.Fatalf("Cannot use custom beacon chain config flags in combination with pre-defined network config")
- }
- if ctx.IsSet(utils.BeaconGenesisRootFlag.Name) {
+ // Genesis root and time should always be specified together with custom chain config
+ if customConfig {
+ if !ctx.IsSet(utils.BeaconGenesisRootFlag.Name) {
+ utils.Fatalf("Custom beacon chain config is specified but genesis root is missing")
+ }
+ if !ctx.IsSet(utils.BeaconGenesisTimeFlag.Name) {
+ utils.Fatalf("Custom beacon chain config is specified but genesis time is missing")
+ }
+ if !ctx.IsSet(utils.BeaconCheckpointFlag.Name) {
+ utils.Fatalf("Custom beacon chain config is specified but checkpoint is missing")
+ }
+ config.ChainConfig = &types.ChainConfig{
+ GenesisTime: ctx.Uint64(utils.BeaconGenesisTimeFlag.Name),
+ }
if c, err := hexutil.Decode(ctx.String(utils.BeaconGenesisRootFlag.Name)); err == nil && len(c) <= 32 {
copy(config.GenesisValidatorsRoot[:len(c)], c)
} else {
utils.Fatalf("Invalid hex string", "beacon.genesis.gvroot", ctx.String(utils.BeaconGenesisRootFlag.Name), "error", err)
}
- }
- if ctx.IsSet(utils.BeaconGenesisTimeFlag.Name) {
- config.GenesisTime = ctx.Uint64(utils.BeaconGenesisTimeFlag.Name)
- }
- if ctx.IsSet(utils.BeaconConfigFlag.Name) {
if err := config.ChainConfig.LoadForks(ctx.String(utils.BeaconConfigFlag.Name)); err != nil {
utils.Fatalf("Could not load beacon chain config file", "file name", ctx.String(utils.BeaconConfigFlag.Name), "error", err)
}
+ } else {
+ if ctx.IsSet(utils.BeaconGenesisRootFlag.Name) {
+ utils.Fatalf("Genesis root is specified but custom beacon chain config is missing")
+ }
+ if ctx.IsSet(utils.BeaconGenesisTimeFlag.Name) {
+ utils.Fatalf("Genesis time is specified but custom beacon chain config is missing")
+ }
}
+ // Checkpoint is required with custom chain config and is optional with pre-defined config
if ctx.IsSet(utils.BeaconCheckpointFlag.Name) {
if c, err := hexutil.Decode(ctx.String(utils.BeaconCheckpointFlag.Name)); err == nil && len(c) <= 32 {
copy(config.Checkpoint[:len(c)], c)
diff --git a/beacon/engine/types.go b/beacon/engine/types.go
index 60accc3c79..fc77c13af7 100644
--- a/beacon/engine/types.go
+++ b/beacon/engine/types.go
@@ -19,6 +19,7 @@ package engine
import (
"fmt"
"math/big"
+ "slices"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
@@ -132,12 +133,7 @@ func (b PayloadID) Version() PayloadVersion {
// Is returns whether the identifier matches any of provided payload versions.
func (b PayloadID) Is(versions ...PayloadVersion) bool {
- for _, v := range versions {
- if v == b.Version() {
- return true
- }
- }
- return false
+ return slices.Contains(versions, b.Version())
}
func (b PayloadID) String() string {
@@ -313,7 +309,7 @@ const (
// ClientVersionV1 contains information which identifies a client implementation.
type ClientVersionV1 struct {
Code string `json:"code"`
- Name string `json:"clientName"`
+ Name string `json:"name"`
Version string `json:"version"`
Commit string `json:"commit"`
}
diff --git a/beacon/light/api/light_api.go b/beacon/light/api/light_api.go
index 1bba220d31..ceb4261c3c 100755
--- a/beacon/light/api/light_api.go
+++ b/beacon/light/api/light_api.go
@@ -17,11 +17,13 @@
package api
import (
+ "context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
+ "sync"
"time"
"github.com/donovanhide/eventsource"
@@ -287,7 +289,7 @@ func decodeFinalityUpdate(enc []byte) (types.FinalityUpdate, error) {
}, nil
}
-// GetHead fetches and validates the beacon header with the given blockRoot.
+// GetHeader fetches and validates the beacon header with the given blockRoot.
// If blockRoot is null hash then the latest head header is fetched.
func (api *BeaconLightApi) GetHeader(blockRoot common.Hash) (types.Header, error) {
var blockId string
@@ -416,39 +418,34 @@ type HeadEventListener struct {
// The callbacks are also called for the current head and optimistic head at startup.
// They are never called concurrently.
func (api *BeaconLightApi) StartHeadListener(listener HeadEventListener) func() {
- closeCh := make(chan struct{}) // initiate closing the stream
- closedCh := make(chan struct{}) // stream closed (or failed to create)
- stoppedCh := make(chan struct{}) // sync loop stopped
- streamCh := make(chan *eventsource.Stream, 1)
+ var (
+ ctx, closeCtx = context.WithCancel(context.Background())
+ streamCh = make(chan *eventsource.Stream, 1)
+ wg sync.WaitGroup
+ )
+
+ // When connected to a Lodestar node the subscription blocks until the first actual
+ // event arrives; therefore we create the subscription in a separate goroutine while
+ // letting the main goroutine sync up to the current head.
+ wg.Add(1)
go func() {
- defer close(closedCh)
- // when connected to a Lodestar node the subscription blocks until the
- // first actual event arrives; therefore we create the subscription in
- // a separate goroutine while letting the main goroutine sync up to the
- // current head
- req, err := http.NewRequest("GET", api.url+
- "/eth/v1/events?topics=head&topics=light_client_optimistic_update&topics=light_client_finality_update", nil)
- if err != nil {
- listener.OnError(fmt.Errorf("error creating event subscription request: %v", err))
- return
- }
- for k, v := range api.customHeaders {
- req.Header.Set(k, v)
- }
- stream, err := eventsource.SubscribeWithRequest("", req)
- if err != nil {
- listener.OnError(fmt.Errorf("error creating event subscription: %v", err))
- close(streamCh)
+ defer wg.Done()
+ stream := api.startEventStream(ctx, &listener)
+ if stream == nil {
+ // This case happens when the context was closed.
return
}
+ // Stream was opened, wait for close signal.
streamCh <- stream
- <-closeCh
+ <-ctx.Done()
stream.Close()
}()
+ wg.Add(1)
go func() {
- defer close(stoppedCh)
+ defer wg.Done()
+ // Request initial data.
if head, err := api.GetHeader(common.Hash{}); err == nil {
listener.OnNewHead(head.Slot, head.Hash())
}
@@ -458,32 +455,42 @@ func (api *BeaconLightApi) StartHeadListener(listener HeadEventListener) func()
if finalityUpdate, err := api.GetFinalityUpdate(); err == nil {
listener.OnFinality(finalityUpdate)
}
- stream := <-streamCh
- if stream == nil {
+
+ // Receive the stream.
+ var stream *eventsource.Stream
+ select {
+ case stream = <-streamCh:
+ case <-ctx.Done():
return
}
for {
select {
+ case <-ctx.Done():
+ stream.Close()
+
case event, ok := <-stream.Events:
if !ok {
return
}
switch event.Event() {
case "head":
- if slot, blockRoot, err := decodeHeadEvent([]byte(event.Data())); err == nil {
+ slot, blockRoot, err := decodeHeadEvent([]byte(event.Data()))
+ if err == nil {
listener.OnNewHead(slot, blockRoot)
} else {
listener.OnError(fmt.Errorf("error decoding head event: %v", err))
}
case "light_client_optimistic_update":
- if signedHead, err := decodeOptimisticHeadUpdate([]byte(event.Data())); err == nil {
+ signedHead, err := decodeOptimisticHeadUpdate([]byte(event.Data()))
+ if err == nil {
listener.OnSignedHead(signedHead)
} else {
listener.OnError(fmt.Errorf("error decoding optimistic update event: %v", err))
}
case "light_client_finality_update":
- if finalityUpdate, err := decodeFinalityUpdate([]byte(event.Data())); err == nil {
+ finalityUpdate, err := decodeFinalityUpdate([]byte(event.Data()))
+ if err == nil {
listener.OnFinality(finalityUpdate)
} else {
listener.OnError(fmt.Errorf("error decoding finality update event: %v", err))
@@ -491,6 +498,7 @@ func (api *BeaconLightApi) StartHeadListener(listener HeadEventListener) func()
default:
listener.OnError(fmt.Errorf("unexpected event: %s", event.Event()))
}
+
case err, ok := <-stream.Errors:
if !ok {
return
@@ -499,9 +507,43 @@ func (api *BeaconLightApi) StartHeadListener(listener HeadEventListener) func()
}
}
}()
+
return func() {
- close(closeCh)
- <-closedCh
- <-stoppedCh
+ closeCtx()
+ wg.Wait()
+ }
+}
+
+// startEventStream establishes an event stream. This will keep retrying until the stream has been
+// established. It can only return nil when the context is canceled.
+func (api *BeaconLightApi) startEventStream(ctx context.Context, listener *HeadEventListener) *eventsource.Stream {
+ for retry := true; retry; retry = ctxSleep(ctx, 5*time.Second) {
+ path := "/eth/v1/events?topics=head&topics=light_client_optimistic_update&topics=light_client_finality_update"
+ req, err := http.NewRequestWithContext(ctx, "GET", api.url+path, nil)
+ if err != nil {
+ listener.OnError(fmt.Errorf("error creating event subscription request: %v", err))
+ continue
+ }
+ for k, v := range api.customHeaders {
+ req.Header.Set(k, v)
+ }
+ stream, err := eventsource.SubscribeWithRequest("", req)
+ if err != nil {
+ listener.OnError(fmt.Errorf("error creating event subscription: %v", err))
+ continue
+ }
+ return stream
+ }
+ return nil
+}
+
+func ctxSleep(ctx context.Context, timeout time.Duration) (ok bool) {
+ timer := time.NewTimer(timeout)
+ defer timer.Stop()
+ select {
+ case <-timer.C:
+ return true
+ case <-ctx.Done():
+ return false
}
}
diff --git a/beacon/light/head_tracker.go b/beacon/light/head_tracker.go
index 579e1b53da..6036322f01 100644
--- a/beacon/light/head_tracker.go
+++ b/beacon/light/head_tracker.go
@@ -56,7 +56,7 @@ func (h *HeadTracker) ValidatedHead() (types.SignedHeader, bool) {
return h.signedHead, h.hasSignedHead
}
-// ValidatedHead returns the latest validated head.
+// ValidatedFinality returns the latest validated finality.
func (h *HeadTracker) ValidatedFinality() (types.FinalityUpdate, bool) {
h.lock.RLock()
defer h.lock.RUnlock()
@@ -64,7 +64,7 @@ func (h *HeadTracker) ValidatedFinality() (types.FinalityUpdate, bool) {
return h.finalityUpdate, h.hasFinalityUpdate
}
-// Validate validates the given signed head. If the head is successfully validated
+// ValidateHead validates the given signed head. If the head is successfully validated
// and it is better than the old validated head (higher slot or same slot and more
// signers) then ValidatedHead is updated. The boolean return flag signals if
// ValidatedHead has been changed.
diff --git a/beacon/light/request/server.go b/beacon/light/request/server.go
index 407eb69f49..bcb8744b38 100644
--- a/beacon/light/request/server.go
+++ b/beacon/light/request/server.go
@@ -212,7 +212,7 @@ func (s *serverWithTimeout) startTimeout(reqData RequestResponse) {
})
}
-// stop stops all goroutines associated with the server.
+// unsubscribe stops all goroutines associated with the server.
func (s *serverWithTimeout) unsubscribe() {
s.lock.Lock()
defer s.lock.Unlock()
@@ -337,7 +337,7 @@ func (s *serverWithLimits) sendRequest(request Request) (reqId ID) {
return s.serverWithTimeout.sendRequest(request)
}
-// stop stops all goroutines associated with the server.
+// unsubscribe stops all goroutines associated with the server.
func (s *serverWithLimits) unsubscribe() {
s.lock.Lock()
defer s.lock.Unlock()
diff --git a/beacon/light/sync/head_sync.go b/beacon/light/sync/head_sync.go
index 9fef95b0df..5ccc2e18a2 100644
--- a/beacon/light/sync/head_sync.go
+++ b/beacon/light/sync/head_sync.go
@@ -101,7 +101,7 @@ func (s *HeadSync) newSignedHead(server request.Server, signedHead types.SignedH
s.headTracker.ValidateHead(signedHead)
}
-// newSignedHead handles received signed head; either validates it if the chain
+// newFinalityUpdate handles received finality update; either validates it if the chain
// is properly synced or stores it for further validation.
func (s *HeadSync) newFinalityUpdate(server request.Server, finalityUpdate types.FinalityUpdate) {
if !s.chainInit || types.SyncPeriod(finalityUpdate.SignatureSlot) > s.nextSyncPeriod {
@@ -111,7 +111,7 @@ func (s *HeadSync) newFinalityUpdate(server request.Server, finalityUpdate types
s.headTracker.ValidateFinality(finalityUpdate)
}
-// processUnvalidatedHeads iterates the list of unvalidated heads and validates
+// processUnvalidated iterates the list of unvalidated heads and validates
// those which can be validated.
func (s *HeadSync) processUnvalidated() {
if !s.chainInit {
diff --git a/beacon/types/config.go b/beacon/types/config.go
index a52da5212e..7706e85f6c 100644
--- a/beacon/types/config.go
+++ b/beacon/types/config.go
@@ -19,7 +19,9 @@ package types
import (
"crypto/sha256"
"fmt"
+ "math"
"os"
+ "slices"
"sort"
"strconv"
"strings"
@@ -27,6 +29,7 @@ import (
"github.com/ethereum/go-ethereum/beacon/merkle"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/log"
"gopkg.in/yaml.v3"
)
@@ -34,6 +37,8 @@ import (
// across signing different data structures.
const syncCommitteeDomain = 7
+var knownForks = []string{"GENESIS", "ALTAIR", "BELLATRIX", "CAPELLA", "DENEB"}
+
// Fork describes a single beacon chain fork and also stores the calculated
// signature domain used after this fork.
type Fork struct {
@@ -46,6 +51,9 @@ type Fork struct {
// Fork version, see https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#custom-types
Version []byte
+ // index in list of known forks or MaxInt if unknown
+ knownIndex int
+
// calculated by computeDomain, based on fork version and genesis validators root
domain merkle.Value
}
@@ -99,9 +107,14 @@ func (f Forks) SigningRoot(header Header) (common.Hash, error) {
return signingRoot, nil
}
-func (f Forks) Len() int { return len(f) }
-func (f Forks) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
-func (f Forks) Less(i, j int) bool { return f[i].Epoch < f[j].Epoch }
+func (f Forks) Len() int { return len(f) }
+func (f Forks) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
+func (f Forks) Less(i, j int) bool {
+ if f[i].Epoch != f[j].Epoch {
+ return f[i].Epoch < f[j].Epoch
+ }
+ return f[i].knownIndex < f[j].knownIndex
+}
// ChainConfig contains the beacon chain configuration.
type ChainConfig struct {
@@ -122,16 +135,22 @@ func (c *ChainConfig) ForkAtEpoch(epoch uint64) Fork {
// AddFork adds a new item to the list of forks.
func (c *ChainConfig) AddFork(name string, epoch uint64, version []byte) *ChainConfig {
+ knownIndex := slices.Index(knownForks, name)
+ if knownIndex == -1 {
+ knownIndex = math.MaxInt // assume that the unknown fork happens after the known ones
+ if epoch != math.MaxUint64 {
+ log.Warn("Unknown fork in config.yaml", "fork name", name, "known forks", knownForks)
+ }
+ }
fork := &Fork{
- Name: name,
- Epoch: epoch,
- Version: version,
+ Name: name,
+ Epoch: epoch,
+ Version: version,
+ knownIndex: knownIndex,
}
fork.computeDomain(c.GenesisValidatorsRoot)
-
c.Forks = append(c.Forks, fork)
sort.Sort(c.Forks)
-
return c
}
@@ -181,6 +200,5 @@ func (c *ChainConfig) LoadForks(path string) error {
for name := range versions {
return fmt.Errorf("epoch number missing for fork %q in beacon chain config file", name)
}
- sort.Sort(c.Forks)
return nil
}
diff --git a/beacon/types/exec_header.go b/beacon/types/exec_header.go
index 3085c3de69..dce101ba20 100644
--- a/beacon/types/exec_header.go
+++ b/beacon/types/exec_header.go
@@ -36,7 +36,7 @@ type ExecutionHeader struct {
obj headerObject
}
-// HeaderFromJSON decodes an execution header from JSON data provided by
+// ExecutionHeaderFromJSON decodes an execution header from JSON data provided by
// the beacon chain API.
func ExecutionHeaderFromJSON(forkName string, data []byte) (*ExecutionHeader, error) {
var obj headerObject
diff --git a/build/checksums.txt b/build/checksums.txt
index f92f739a2f..27577285b8 100644
--- a/build/checksums.txt
+++ b/build/checksums.txt
@@ -5,22 +5,22 @@
# https://github.com/ethereum/execution-spec-tests/releases/download/v2.1.0/
ca89c76851b0900bfcc3cbb9a26cbece1f3d7c64a3bed38723e914713290df6c fixtures_develop.tar.gz
-# version:golang 1.22.1
+# version:golang 1.22.2
# https://go.dev/dl/
-79c9b91d7f109515a25fc3ecdaad125d67e6bdb54f6d4d98580f46799caea321 go1.22.1.src.tar.gz
-3bc971772f4712fec0364f4bc3de06af22a00a12daab10b6f717fdcd13156cc0 go1.22.1.darwin-amd64.tar.gz
-f6a9cec6b8a002fcc9c0ee24ec04d67f430a52abc3cfd613836986bcc00d8383 go1.22.1.darwin-arm64.tar.gz
-99f81c10d5a3f8a886faf8fa86aaa2aaf929fbed54a972ae5eec3c5e0bdb961a go1.22.1.freebsd-386.tar.gz
-51c614ddd92ee4a9913a14c39bf80508d9cfba08561f24d2f075fd00f3cfb067 go1.22.1.freebsd-amd64.tar.gz
-8484df36d3d40139eaf0fe5e647b006435d826cc12f9ae72973bf7ec265e0ae4 go1.22.1.linux-386.tar.gz
-aab8e15785c997ae20f9c88422ee35d962c4562212bb0f879d052a35c8307c7f go1.22.1.linux-amd64.tar.gz
-e56685a245b6a0c592fc4a55f0b7803af5b3f827aaa29feab1f40e491acf35b8 go1.22.1.linux-arm64.tar.gz
-8cb7a90e48c20daed39a6ac8b8a40760030ba5e93c12274c42191d868687c281 go1.22.1.linux-armv6l.tar.gz
-ac775e19d93cc1668999b77cfe8c8964abfbc658718feccfe6e0eb87663cd668 go1.22.1.linux-ppc64le.tar.gz
-7bb7dd8e10f95c9a4cc4f6bef44c816a6e7c9e03f56ac6af6efbb082b19b379f go1.22.1.linux-s390x.tar.gz
-0c5ebb7eb39b7884ec99f92b425d4c03a96a72443562aafbf6e7d15c42a3108a go1.22.1.windows-386.zip
-cf9c66a208a106402a527f5b956269ca506cfe535fc388e828d249ea88ed28ba go1.22.1.windows-amd64.zip
-85b8511b298c9f4199ecae26afafcc3d46155bac934d43f2357b9224bcaa310f go1.22.1.windows-arm64.zip
+374ea82b289ec738e968267cac59c7d5ff180f9492250254784b2044e90df5a9 go1.22.2.src.tar.gz
+33e7f63077b1c5bce4f1ecadd4d990cf229667c40bfb00686990c950911b7ab7 go1.22.2.darwin-amd64.tar.gz
+660298be38648723e783ba0398e90431de1cb288c637880cdb124f39bd977f0d go1.22.2.darwin-arm64.tar.gz
+efc7162b0cad2f918ac566a923d4701feb29dc9c0ab625157d49b1cbcbba39da go1.22.2.freebsd-386.tar.gz
+d753428296e6709527e291fd204700a587ffef2c0a472b21aebea11618245929 go1.22.2.freebsd-amd64.tar.gz
+586d9eb7fe0489ab297ad80dd06414997df487c5cf536c490ffeaa8d8f1807a7 go1.22.2.linux-386.tar.gz
+5901c52b7a78002aeff14a21f93e0f064f74ce1360fce51c6ee68cd471216a17 go1.22.2.linux-amd64.tar.gz
+36e720b2d564980c162a48c7e97da2e407dfcc4239e1e58d98082dfa2486a0c1 go1.22.2.linux-arm64.tar.gz
+9243dfafde06e1efe24d59df6701818e6786b4adfdf1191098050d6d023c5369 go1.22.2.linux-armv6l.tar.gz
+251a8886c5113be6490bdbb955ddee98763b49c9b1bf4c8364c02d3b482dab00 go1.22.2.linux-ppc64le.tar.gz
+2b39019481c28c560d65e9811a478ae10e3ef765e0f59af362031d386a71bfef go1.22.2.linux-s390x.tar.gz
+651753c06df037020ef4d162c5b273452e9ba976ed17ae39e66ef7ee89d8147e go1.22.2.windows-386.zip
+8e581cf330f49d3266e936521a2d8263679ef7e2fc2cbbceb85659122d883596 go1.22.2.windows-amd64.zip
+ddfca5beb9a0c62254266c3090c2555d899bf3e7aa26243e7de3621108f06875 go1.22.2.windows-arm64.zip
# version:golangci 1.55.2
# https://github.com/golangci/golangci-lint/releases/
diff --git a/build/update-license.go b/build/update-license.go
index 70e2de06c7..58e8b16045 100644
--- a/build/update-license.go
+++ b/build/update-license.go
@@ -46,13 +46,12 @@ import (
"path/filepath"
"regexp"
"runtime"
+ "slices"
"strconv"
"strings"
"sync"
"text/template"
"time"
-
- "golang.org/x/exp/slices"
)
var (
diff --git a/cmd/clef/rules.md b/cmd/clef/rules.md
index 112dae6512..cc4a645596 100644
--- a/cmd/clef/rules.md
+++ b/cmd/clef/rules.md
@@ -9,14 +9,14 @@ It enables usecases like the following:
The two main features that are required for this to work well are;
-1. Rule Implementation: how to create, manage and interpret rules in a flexible but secure manner
-2. Credential managements and credentials; how to provide auto-unlock without exposing keys unnecessarily.
+1. Rule Implementation: how to create, manage, and interpret rules in a flexible but secure manner
+2. Credential management and credentials; how to provide auto-unlock without exposing keys unnecessarily.
The section below deals with both of them
## Rule Implementation
-A ruleset file is implemented as a `js` file. Under the hood, the ruleset-engine is a `SignerUI`, implementing the same methods as the `json-rpc` methods
+A ruleset file is implemented as a `js` file. Under the hood, the ruleset engine is a `SignerUI`, implementing the same methods as the `json-rpc` methods
defined in the UI protocol. Example:
```js
@@ -27,7 +27,7 @@ function asBig(str) {
return new BigNumber(str)
}
-// Approve transactions to a certain contract if value is below a certain limit
+// Approve transactions to a certain contract if the value is below a certain limit
function ApproveTx(req) {
var limit = big.Newint("0xb1a2bc2ec50000")
var value = asBig(req.transaction.value);
@@ -70,7 +70,7 @@ The Otto vm has a few [caveats](https://github.com/robertkrimen/otto):
Additionally, a few more have been added
* The rule execution cannot load external javascript files.
-* The only preloaded library is [`bignumber.js`](https://github.com/MikeMcl/bignumber.js) version `2.0.3`. This one is fairly old, and is not aligned with the documentation at the github repository.
+* The only preloaded library is [`bignumber.js`](https://github.com/MikeMcl/bignumber.js) version `2.0.3`. This one is fairly old, and is not aligned with the documentation at the GitHub repository.
* Each invocation is made in a fresh virtual machine. This means that you cannot store data in global variables between invocations. This is a deliberate choice -- if you want to store data, use the disk-backed `storage`, since rules should not rely on ephemeral data.
* Javascript API parameters are _always_ an object. This is also a design choice, to ensure that parameters are accessed by _key_ and not by order. This is to prevent mistakes due to missing parameters or parameter changes.
* The JS engine has access to `storage` and `console`.
@@ -88,8 +88,8 @@ Some security precautions can be made, such as:
##### Security of implementation
-The drawbacks of this very flexible solution is that the `signer` needs to contain a javascript engine. This is pretty simple to implement, since it's already
-implemented for `geth`. There are no known security vulnerabilities in, nor have we had any security-problems with it so far.
+The drawback of this very flexible solution is that the `signer` needs to contain a javascript engine. This is pretty simple to implement since it's already
+implemented for `geth`. There are no known security vulnerabilities in it, nor have we had any security problems with it so far.
The javascript engine would be an added attack surface; but if the validation of `rulesets` is made good (with hash-based attestation), the actual javascript cannot be considered
an attack surface -- if an attacker can control the ruleset, a much simpler attack would be to implement an "always-approve" rule instead of exploiting the js vm. The only benefit
@@ -105,7 +105,7 @@ It's unclear whether any other DSL could be more secure; since there's always th
## Credential management
-The ability to auto-approve transaction means that the signer needs to have necessary credentials to decrypt keyfiles. These passwords are hereafter called `ksp` (keystore pass).
+The ability to auto-approve transactions means that the signer needs to have the necessary credentials to decrypt keyfiles. These passwords are hereafter called `ksp` (keystore pass).
### Example implementation
@@ -127,8 +127,8 @@ The `vault.dat` would be an encrypted container storing the following informatio
### Security considerations
-This would leave it up to the user to ensure that the `path/to/masterseed` is handled in a secure way. It's difficult to get around this, although one could
-imagine leveraging OS-level keychains where supported. The setup is however in general similar to how ssh-keys are stored in `.ssh/`.
+This would leave it up to the user to ensure that the `path/to/masterseed` is handled securely. It's difficult to get around this, although one could
+imagine leveraging OS-level keychains where supported. The setup is however, in general, similar to how ssh-keys are stored in `.ssh/`.
# Implementation status
@@ -149,7 +149,7 @@ function big(str) {
// Time window: 1 week
var window = 1000* 3600*24*7;
-// Limit : 1 ether
+// Limit: 1 ether
var limit = new BigNumber("1e18");
function isLimitOk(transaction) {
@@ -163,7 +163,7 @@ function isLimitOk(transaction) {
if (stored != "") {
txs = JSON.parse(stored)
}
- // First, remove all that have passed out of the time-window
+ // First, remove all that has passed out of the time window
var newtxs = txs.filter(function(tx){return tx.tstamp > windowstart});
console.log(txs, newtxs.length);
@@ -174,7 +174,7 @@ function isLimitOk(transaction) {
console.log("ApproveTx > Sum so far", sum);
console.log("ApproveTx > Requested", value.toNumber());
- // Would we exceed weekly limit ?
+ // Would we exceed the weekly limit ?
return sum.plus(value).lt(limit)
}
diff --git a/cmd/devp2p/dns_route53.go b/cmd/devp2p/dns_route53.go
index 21a32f9414..a6125b8263 100644
--- a/cmd/devp2p/dns_route53.go
+++ b/cmd/devp2p/dns_route53.go
@@ -20,6 +20,7 @@ import (
"context"
"errors"
"fmt"
+ "slices"
"strconv"
"strings"
"time"
@@ -32,7 +33,6 @@ import (
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/p2p/dnsdisc"
"github.com/urfave/cli/v2"
- "golang.org/x/exp/slices"
)
const (
diff --git a/cmd/devp2p/internal/ethtest/chain.go b/cmd/devp2p/internal/ethtest/chain.go
index a34a41dacd..2b503d62df 100644
--- a/cmd/devp2p/internal/ethtest/chain.go
+++ b/cmd/devp2p/internal/ethtest/chain.go
@@ -27,6 +27,7 @@ import (
"math/big"
"os"
"path/filepath"
+ "slices"
"sort"
"strings"
@@ -40,7 +41,6 @@ import (
"github.com/ethereum/go-ethereum/eth/protocols/eth"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rlp"
- "golang.org/x/exp/slices"
)
// Chain is a lightweight blockchain-like store which can read a hivechain
diff --git a/cmd/devp2p/internal/ethtest/transaction.go b/cmd/devp2p/internal/ethtest/transaction.go
index 80b5d80745..cbbbbce8d9 100644
--- a/cmd/devp2p/internal/ethtest/transaction.go
+++ b/cmd/devp2p/internal/ethtest/transaction.go
@@ -102,7 +102,7 @@ func (s *Suite) sendTxs(t *utesting.T, txs []*types.Transaction) error {
}
}
- return fmt.Errorf("timed out waiting for txs")
+ return errors.New("timed out waiting for txs")
}
func (s *Suite) sendInvalidTxs(t *utesting.T, txs []*types.Transaction) error {
diff --git a/cmd/devp2p/internal/v5test/discv5tests.go b/cmd/devp2p/internal/v5test/discv5tests.go
index 56624a0ca8..7dbd3c3be5 100644
--- a/cmd/devp2p/internal/v5test/discv5tests.go
+++ b/cmd/devp2p/internal/v5test/discv5tests.go
@@ -19,6 +19,7 @@ package v5test
import (
"bytes"
"net"
+ "slices"
"sync"
"time"
@@ -266,7 +267,7 @@ func (s *Suite) TestFindnodeResults(t *utesting.T) {
n := bn.conn.localNode.Node()
expect[n.ID()] = n
d := uint(enode.LogDist(n.ID(), s.Dest.ID()))
- if !containsUint(dists, d) {
+ if !slices.Contains(dists, d) {
dists = append(dists, d)
}
}
diff --git a/cmd/devp2p/internal/v5test/framework.go b/cmd/devp2p/internal/v5test/framework.go
index 10856a50bc..92a5048150 100644
--- a/cmd/devp2p/internal/v5test/framework.go
+++ b/cmd/devp2p/internal/v5test/framework.go
@@ -252,12 +252,3 @@ func checkRecords(records []*enr.Record) ([]*enode.Node, error) {
}
return nodes, nil
}
-
-func containsUint(ints []uint, x uint) bool {
- for i := range ints {
- if ints[i] == x {
- return true
- }
- }
- return false
-}
diff --git a/cmd/devp2p/nodeset.go b/cmd/devp2p/nodeset.go
index 7360dc5bcf..4fa862de14 100644
--- a/cmd/devp2p/nodeset.go
+++ b/cmd/devp2p/nodeset.go
@@ -21,11 +21,11 @@ import (
"encoding/json"
"fmt"
"os"
+ "slices"
"time"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/p2p/enode"
- "golang.org/x/exp/slices"
)
const jsonIndent = " "
diff --git a/cmd/ethkey/README.md b/cmd/ethkey/README.md
index bfddd14677..a7f5316f45 100644
--- a/cmd/ethkey/README.md
+++ b/cmd/ethkey/README.md
@@ -50,4 +50,4 @@ contains the password.
## JSON
-In case you need to output the result in a JSON format, you shall by using the `--json` flag.
+In case you need to output the result in a JSON format, you shall use the `--json` flag.
diff --git a/cmd/evm/internal/t8ntool/flags.go b/cmd/evm/internal/t8ntool/flags.go
index c2eca8cc21..f2606c86d1 100644
--- a/cmd/evm/internal/t8ntool/flags.go
+++ b/cmd/evm/internal/t8ntool/flags.go
@@ -50,6 +50,10 @@ var (
Name: "trace.returndata",
Usage: "Enable return data output in traces",
}
+ TraceEnableCallFramesFlag = &cli.BoolFlag{
+ Name: "trace.callframes",
+ Usage: "Enable call frames output in traces",
+ }
OutputBasedir = &cli.StringFlag{
Name: "output.basedir",
Usage: "Specifies where output files are placed. Will be created if it does not exist.",
diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go
index 5aa554e133..2b5eaa65aa 100644
--- a/cmd/evm/internal/t8ntool/transition.go
+++ b/cmd/evm/internal/t8ntool/transition.go
@@ -29,6 +29,7 @@ import (
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/consensus/misc/eip1559"
"github.com/ethereum/go-ethereum/core/state"
+ "github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/eth/tracers"
@@ -101,9 +102,14 @@ func Transition(ctx *cli.Context) error {
if err != nil {
return nil, nil, NewError(ErrorIO, fmt.Errorf("failed creating trace-file: %v", err))
}
- logger := logger.NewJSONLogger(logConfig, traceFile)
+ var l *tracing.Hooks
+ if ctx.Bool(TraceEnableCallFramesFlag.Name) {
+ l = logger.NewJSONLoggerWithCallFrames(logConfig, traceFile)
+ } else {
+ l = logger.NewJSONLogger(logConfig, traceFile)
+ }
tracer := &tracers.Tracer{
- Hooks: logger,
+ Hooks: l,
// jsonLogger streams out result to file.
GetResult: func() (json.RawMessage, error) { return nil, nil },
Stop: func(err error) {},
diff --git a/cmd/evm/main.go b/cmd/evm/main.go
index c3e6a4af91..f9a2a075d0 100644
--- a/cmd/evm/main.go
+++ b/cmd/evm/main.go
@@ -152,6 +152,7 @@ var stateTransitionCommand = &cli.Command{
t8ntool.TraceEnableMemoryFlag,
t8ntool.TraceDisableStackFlag,
t8ntool.TraceEnableReturnDataFlag,
+ t8ntool.TraceEnableCallFramesFlag,
t8ntool.OutputBasedir,
t8ntool.OutputAllocFlag,
t8ntool.OutputResultFlag,
diff --git a/cmd/evm/runner.go b/cmd/evm/runner.go
index 7f6f5f6be0..f179e733e6 100644
--- a/cmd/evm/runner.go
+++ b/cmd/evm/runner.go
@@ -272,8 +272,17 @@ func runCmd(ctx *cli.Context) error {
output, leftOverGas, stats, err := timedExec(bench, execFunc)
if ctx.Bool(DumpFlag.Name) {
- statedb.Commit(genesisConfig.Number, true)
- fmt.Println(string(statedb.Dump(nil)))
+ root, err := statedb.Commit(genesisConfig.Number, true)
+ if err != nil {
+ fmt.Printf("Failed to commit changes %v\n", err)
+ return err
+ }
+ dumpdb, err := state.New(root, sdb, nil)
+ if err != nil {
+ fmt.Printf("Failed to open statedb %v\n", err)
+ return err
+ }
+ fmt.Println(string(dumpdb.Dump(nil)))
}
if ctx.Bool(DebugFlag.Name) {
diff --git a/cmd/evm/t8n_test.go b/cmd/evm/t8n_test.go
index 7e0bc36cbe..5a74491c3b 100644
--- a/cmd/evm/t8n_test.go
+++ b/cmd/evm/t8n_test.go
@@ -375,6 +375,14 @@ func TestT8nTracing(t *testing.T) {
}`},
expectedTraces: []string{"trace-0-0x88f5fbd1524731a81e49f637aa847543268a5aaf2a6b32a69d2c6d978c45dcfb.json"},
},
+ {
+ base: "./testdata/32",
+ input: t8nInput{
+ "alloc.json", "txs.json", "env.json", "Merge", "",
+ },
+ extraArgs: []string{"--trace", "--trace.callframes"},
+ expectedTraces: []string{"trace-0-0x47806361c0fa084be3caa18afe8c48156747c01dbdfc1ee11b5aecdbe4fcf23e.jsonl"},
+ },
} {
args := []string{"t8n"}
args = append(args, tc.input.get(tc.base)...)
diff --git a/cmd/evm/testdata/32/README.md b/cmd/evm/testdata/32/README.md
new file mode 100644
index 0000000000..508ac970dd
--- /dev/null
+++ b/cmd/evm/testdata/32/README.md
@@ -0,0 +1 @@
+This test does some EVM execution, and can be used to test callframes emitted by the tracer when they are enabled.
diff --git a/cmd/evm/testdata/32/alloc.json b/cmd/evm/testdata/32/alloc.json
new file mode 100644
index 0000000000..0cd4493955
--- /dev/null
+++ b/cmd/evm/testdata/32/alloc.json
@@ -0,0 +1,30 @@
+{
+ "0x8a0a19589531694250d570040a0c4b74576919b8": {
+ "nonce": "0x00",
+ "balance": "0x0de0b6b3a7640000",
+ "code": "0x600060006000600060007310000000000000000000000000000000000000015af1600155600060006000600060007310000000000000000000000000000000000000025af16002553d600060003e600051600355",
+ "storage": {
+ "0x01": "0x0100",
+ "0x02": "0x0100",
+ "0x03": "0x0100"
+ }
+ },
+ "0x1000000000000000000000000000000000000001": {
+ "nonce": "0x00",
+ "balance": "0x29a2241af62c0000",
+ "code": "0x6103e8ff",
+ "storage": {}
+ },
+ "0x1000000000000000000000000000000000000002": {
+ "nonce": "0x00",
+ "balance": "0x4563918244f40000",
+ "code": "0x600060006000600060647310000000000000000000000000000000000000015af1600f0160005260206000fd",
+ "storage": {}
+ },
+ "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
+ "nonce": "0x00",
+ "balance": "0x6124fee993bc0000",
+ "code": "0x",
+ "storage": {}
+ }
+}
\ No newline at end of file
diff --git a/cmd/evm/testdata/32/env.json b/cmd/evm/testdata/32/env.json
new file mode 100644
index 0000000000..4f0833e711
--- /dev/null
+++ b/cmd/evm/testdata/32/env.json
@@ -0,0 +1,12 @@
+{
+ "currentCoinbase": "0x2adc25665018aa1fe0e6bc666dac8fc2697ff9ba",
+ "currentGasLimit": "71794957647893862",
+ "currentNumber": "1",
+ "currentTimestamp": "1000",
+ "currentRandom": "0",
+ "currentDifficulty": "0",
+ "blockHashes": {},
+ "ommers": [],
+ "currentBaseFee": "7",
+ "parentUncleHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
+}
\ No newline at end of file
diff --git a/cmd/evm/testdata/32/trace-0-0x47806361c0fa084be3caa18afe8c48156747c01dbdfc1ee11b5aecdbe4fcf23e.jsonl b/cmd/evm/testdata/32/trace-0-0x47806361c0fa084be3caa18afe8c48156747c01dbdfc1ee11b5aecdbe4fcf23e.jsonl
new file mode 100644
index 0000000000..b6c5237baa
--- /dev/null
+++ b/cmd/evm/testdata/32/trace-0-0x47806361c0fa084be3caa18afe8c48156747c01dbdfc1ee11b5aecdbe4fcf23e.jsonl
@@ -0,0 +1,61 @@
+{"from":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b","to":"0x8a0a19589531694250d570040a0c4b74576919b8","gas":"0x74f18","value":"0x0","type":"CALL"}
+{"pc":0,"op":96,"gas":"0x74f18","gasCost":"0x3","memSize":0,"stack":[],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":2,"op":96,"gas":"0x74f15","gasCost":"0x3","memSize":0,"stack":["0x0"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":4,"op":96,"gas":"0x74f12","gasCost":"0x3","memSize":0,"stack":["0x0","0x0"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":6,"op":96,"gas":"0x74f0f","gasCost":"0x3","memSize":0,"stack":["0x0","0x0","0x0"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":8,"op":96,"gas":"0x74f0c","gasCost":"0x3","memSize":0,"stack":["0x0","0x0","0x0","0x0"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":10,"op":115,"gas":"0x74f09","gasCost":"0x3","memSize":0,"stack":["0x0","0x0","0x0","0x0","0x0"],"depth":1,"refund":0,"opName":"PUSH20"}
+{"pc":31,"op":90,"gas":"0x74f06","gasCost":"0x2","memSize":0,"stack":["0x0","0x0","0x0","0x0","0x0","0x1000000000000000000000000000000000000001"],"depth":1,"refund":0,"opName":"GAS"}
+{"pc":32,"op":241,"gas":"0x74f04","gasCost":"0x731f1","memSize":0,"stack":["0x0","0x0","0x0","0x0","0x0","0x1000000000000000000000000000000000000001","0x74f04"],"depth":1,"refund":0,"opName":"CALL"}
+{"from":"0x8a0a19589531694250d570040a0c4b74576919b8","to":"0x1000000000000000000000000000000000000001","gas":"0x727c9","value":"0x0","type":"CALL"}
+{"pc":0,"op":97,"gas":"0x727c9","gasCost":"0x3","memSize":0,"stack":[],"depth":2,"refund":0,"opName":"PUSH2"}
+{"pc":3,"op":255,"gas":"0x727c6","gasCost":"0x7f58","memSize":0,"stack":["0x3e8"],"depth":2,"refund":0,"opName":"SELFDESTRUCT"}
+{"from":"0x1000000000000000000000000000000000000001","to":"0x00000000000000000000000000000000000003e8","gas":"0x0","value":"0x29a2241af62c0000","type":"SELFDESTRUCT"}
+{"output":"","gasUsed":"0x0"}
+{"output":"","gasUsed":"0x7f5b"}
+{"pc":33,"op":96,"gas":"0x6c581","gasCost":"0x3","memSize":0,"stack":["0x1"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":35,"op":85,"gas":"0x6c57e","gasCost":"0x1388","memSize":0,"stack":["0x1","0x1"],"depth":1,"refund":0,"opName":"SSTORE"}
+{"pc":36,"op":96,"gas":"0x6b1f6","gasCost":"0x3","memSize":0,"stack":[],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":38,"op":96,"gas":"0x6b1f3","gasCost":"0x3","memSize":0,"stack":["0x0"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":40,"op":96,"gas":"0x6b1f0","gasCost":"0x3","memSize":0,"stack":["0x0","0x0"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":42,"op":96,"gas":"0x6b1ed","gasCost":"0x3","memSize":0,"stack":["0x0","0x0","0x0"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":44,"op":96,"gas":"0x6b1ea","gasCost":"0x3","memSize":0,"stack":["0x0","0x0","0x0","0x0"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":46,"op":115,"gas":"0x6b1e7","gasCost":"0x3","memSize":0,"stack":["0x0","0x0","0x0","0x0","0x0"],"depth":1,"refund":0,"opName":"PUSH20"}
+{"pc":67,"op":90,"gas":"0x6b1e4","gasCost":"0x2","memSize":0,"stack":["0x0","0x0","0x0","0x0","0x0","0x1000000000000000000000000000000000000002"],"depth":1,"refund":0,"opName":"GAS"}
+{"pc":68,"op":241,"gas":"0x6b1e2","gasCost":"0x69744","memSize":0,"stack":["0x0","0x0","0x0","0x0","0x0","0x1000000000000000000000000000000000000002","0x6b1e2"],"depth":1,"refund":0,"opName":"CALL"}
+{"from":"0x8a0a19589531694250d570040a0c4b74576919b8","to":"0x1000000000000000000000000000000000000002","gas":"0x68d1c","value":"0x0","type":"CALL"}
+{"pc":0,"op":96,"gas":"0x68d1c","gasCost":"0x3","memSize":0,"stack":[],"depth":2,"refund":0,"opName":"PUSH1"}
+{"pc":2,"op":96,"gas":"0x68d19","gasCost":"0x3","memSize":0,"stack":["0x0"],"depth":2,"refund":0,"opName":"PUSH1"}
+{"pc":4,"op":96,"gas":"0x68d16","gasCost":"0x3","memSize":0,"stack":["0x0","0x0"],"depth":2,"refund":0,"opName":"PUSH1"}
+{"pc":6,"op":96,"gas":"0x68d13","gasCost":"0x3","memSize":0,"stack":["0x0","0x0","0x0"],"depth":2,"refund":0,"opName":"PUSH1"}
+{"pc":8,"op":96,"gas":"0x68d10","gasCost":"0x3","memSize":0,"stack":["0x0","0x0","0x0","0x0"],"depth":2,"refund":0,"opName":"PUSH1"}
+{"pc":10,"op":115,"gas":"0x68d0d","gasCost":"0x3","memSize":0,"stack":["0x0","0x0","0x0","0x0","0x64"],"depth":2,"refund":0,"opName":"PUSH20"}
+{"pc":31,"op":90,"gas":"0x68d0a","gasCost":"0x2","memSize":0,"stack":["0x0","0x0","0x0","0x0","0x64","0x1000000000000000000000000000000000000001"],"depth":2,"refund":0,"opName":"GAS"}
+{"pc":32,"op":241,"gas":"0x68d08","gasCost":"0x67363","memSize":0,"stack":["0x0","0x0","0x0","0x0","0x64","0x1000000000000000000000000000000000000001","0x68d08"],"depth":2,"refund":0,"opName":"CALL"}
+{"from":"0x1000000000000000000000000000000000000002","to":"0x1000000000000000000000000000000000000001","gas":"0x658d3","value":"0x64","type":"CALL"}
+{"pc":0,"op":97,"gas":"0x658d3","gasCost":"0x3","memSize":0,"stack":[],"depth":3,"refund":0,"opName":"PUSH2"}
+{"pc":3,"op":255,"gas":"0x658d0","gasCost":"0x1388","memSize":0,"stack":["0x3e8"],"depth":3,"refund":0,"opName":"SELFDESTRUCT"}
+{"from":"0x1000000000000000000000000000000000000001","to":"0x00000000000000000000000000000000000003e8","gas":"0x0","value":"0x64","type":"SELFDESTRUCT"}
+{"output":"","gasUsed":"0x0"}
+{"output":"","gasUsed":"0x138b"}
+{"pc":33,"op":96,"gas":"0x65eed","gasCost":"0x3","memSize":0,"stack":["0x1"],"depth":2,"refund":0,"opName":"PUSH1"}
+{"pc":35,"op":1,"gas":"0x65eea","gasCost":"0x3","memSize":0,"stack":["0x1","0xf"],"depth":2,"refund":0,"opName":"ADD"}
+{"pc":36,"op":96,"gas":"0x65ee7","gasCost":"0x3","memSize":0,"stack":["0x10"],"depth":2,"refund":0,"opName":"PUSH1"}
+{"pc":38,"op":82,"gas":"0x65ee4","gasCost":"0x6","memSize":0,"stack":["0x10","0x0"],"depth":2,"refund":0,"opName":"MSTORE"}
+{"pc":39,"op":96,"gas":"0x65ede","gasCost":"0x3","memSize":32,"stack":[],"depth":2,"refund":0,"opName":"PUSH1"}
+{"pc":41,"op":96,"gas":"0x65edb","gasCost":"0x3","memSize":32,"stack":["0x20"],"depth":2,"refund":0,"opName":"PUSH1"}
+{"pc":43,"op":253,"gas":"0x65ed8","gasCost":"0x0","memSize":32,"stack":["0x20","0x0"],"depth":2,"refund":0,"opName":"REVERT"}
+{"pc":43,"op":253,"gas":"0x65ed8","gasCost":"0x0","memSize":32,"stack":[],"depth":2,"refund":0,"opName":"REVERT","error":"execution reverted"}
+{"output":"0000000000000000000000000000000000000000000000000000000000000010","gasUsed":"0x2e44","error":"execution reverted"}
+{"pc":69,"op":96,"gas":"0x67976","gasCost":"0x3","memSize":0,"stack":["0x0"],"depth":1,"refund":0,"opName":"PUSH1"}
+{"pc":71,"op":85,"gas":"0x67973","gasCost":"0x1388","memSize":0,"stack":["0x0","0x2"],"depth":1,"refund":4800,"opName":"SSTORE"}
+{"pc":72,"op":61,"gas":"0x665eb","gasCost":"0x2","memSize":0,"stack":[],"depth":1,"refund":4800,"opName":"RETURNDATASIZE"}
+{"pc":73,"op":96,"gas":"0x665e9","gasCost":"0x3","memSize":0,"stack":["0x20"],"depth":1,"refund":4800,"opName":"PUSH1"}
+{"pc":75,"op":96,"gas":"0x665e6","gasCost":"0x3","memSize":0,"stack":["0x20","0x0"],"depth":1,"refund":4800,"opName":"PUSH1"}
+{"pc":77,"op":62,"gas":"0x665e3","gasCost":"0x9","memSize":0,"stack":["0x20","0x0","0x0"],"depth":1,"refund":4800,"opName":"RETURNDATACOPY"}
+{"pc":78,"op":96,"gas":"0x665da","gasCost":"0x3","memSize":32,"stack":[],"depth":1,"refund":4800,"opName":"PUSH1"}
+{"pc":80,"op":81,"gas":"0x665d7","gasCost":"0x3","memSize":32,"stack":["0x0"],"depth":1,"refund":4800,"opName":"MLOAD"}
+{"pc":81,"op":96,"gas":"0x665d4","gasCost":"0x3","memSize":32,"stack":["0x10"],"depth":1,"refund":4800,"opName":"PUSH1"}
+{"pc":83,"op":85,"gas":"0x665d1","gasCost":"0x1388","memSize":32,"stack":["0x10","0x3"],"depth":1,"refund":4800,"opName":"SSTORE"}
+{"pc":84,"op":0,"gas":"0x65249","gasCost":"0x0","memSize":32,"stack":[],"depth":1,"refund":4800,"opName":"STOP"}
+{"output":"","gasUsed":"0xfccf"}
diff --git a/cmd/evm/testdata/32/txs.json b/cmd/evm/testdata/32/txs.json
new file mode 100644
index 0000000000..0530fd60e6
--- /dev/null
+++ b/cmd/evm/testdata/32/txs.json
@@ -0,0 +1,17 @@
+[
+ {
+ "type": "0x0",
+ "chainId": "0x0",
+ "nonce": "0x0",
+ "gasPrice": "0xa",
+ "gas": "0x7a120",
+ "to": "0x8a0a19589531694250d570040a0c4b74576919b8",
+ "value": "0x0",
+ "input": "0x",
+ "v": "0x1c",
+ "r": "0x9a207ad45b7fc2aa5f8e72a30487f2b0bc489778e6d022f19036efdf2a922a17",
+ "s": "0x640d4da05078b5a4aa561f1b4d58176ea828bfa0f88d27d14459c1d789e1a1eb",
+ "sender": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
+ "secretKey": "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8"
+ }
+]
\ No newline at end of file
diff --git a/cmd/geth/attach_test.go b/cmd/geth/attach_test.go
index 91007ccf65..ceae3a122e 100644
--- a/cmd/geth/attach_test.go
+++ b/cmd/geth/attach_test.go
@@ -48,7 +48,7 @@ func TestAttachWithHeaders(t *testing.T) {
// This is fixed in a follow-up PR.
}
-// TestAttachWithHeaders tests that 'geth db --remotedb' with custom headers works, i.e
+// TestRemoteDbWithHeaders tests that 'geth db --remotedb' with custom headers works, i.e
// that custom headers are forwarded to the target.
func TestRemoteDbWithHeaders(t *testing.T) {
t.Parallel()
diff --git a/cmd/utils/export_test.go b/cmd/utils/export_test.go
index 84ba8d0c31..c22aad64b8 100644
--- a/cmd/utils/export_test.go
+++ b/cmd/utils/export_test.go
@@ -97,7 +97,7 @@ func testExport(t *testing.T, f string) {
}
}
-// testDeletion tests if the deletion markers can be exported/imported correctly
+// TestDeletionExport tests if the deletion markers can be exported/imported correctly
func TestDeletionExport(t *testing.T) {
f := fmt.Sprintf("%v/tempdump", os.TempDir())
defer func() {
diff --git a/common/lru/basiclru.go b/common/lru/basiclru.go
index a429157fe5..7386c77840 100644
--- a/common/lru/basiclru.go
+++ b/common/lru/basiclru.go
@@ -115,9 +115,7 @@ func (c *BasicLRU[K, V]) Peek(key K) (value V, ok bool) {
// Purge empties the cache.
func (c *BasicLRU[K, V]) Purge() {
c.list.init()
- for k := range c.items {
- delete(c.items, k)
- }
+ clear(c.items)
}
// Remove drops an item from the cache. Returns true if the key was present in cache.
@@ -174,7 +172,7 @@ func (l *list[T]) init() {
l.root.prev = &l.root
}
-// push adds an element to the front of the list.
+// pushElem adds an element to the front of the list.
func (l *list[T]) pushElem(e *listElem[T]) {
e.prev = &l.root
e.next = l.root.next
diff --git a/common/prque/lazyqueue.go b/common/prque/lazyqueue.go
index 59bda72fa7..ebe53d5e6b 100644
--- a/common/prque/lazyqueue.go
+++ b/common/prque/lazyqueue.go
@@ -17,11 +17,11 @@
package prque
import (
+ "cmp"
"container/heap"
"time"
"github.com/ethereum/go-ethereum/common/mclock"
- "golang.org/x/exp/constraints"
)
// LazyQueue is a priority queue data structure where priorities can change over
@@ -33,7 +33,7 @@ import (
//
// If the upper estimate is exceeded then Update should be called for that item.
// A global Refresh function should also be called periodically.
-type LazyQueue[P constraints.Ordered, V any] struct {
+type LazyQueue[P cmp.Ordered, V any] struct {
clock mclock.Clock
// Items are stored in one of two internal queues ordered by estimated max
// priority until the next and the next-after-next refresh. Update and Refresh
@@ -50,12 +50,12 @@ type LazyQueue[P constraints.Ordered, V any] struct {
}
type (
- PriorityCallback[P constraints.Ordered, V any] func(data V) P // actual priority callback
- MaxPriorityCallback[P constraints.Ordered, V any] func(data V, until mclock.AbsTime) P // estimated maximum priority callback
+ PriorityCallback[P cmp.Ordered, V any] func(data V) P // actual priority callback
+ MaxPriorityCallback[P cmp.Ordered, V any] func(data V, until mclock.AbsTime) P // estimated maximum priority callback
)
// NewLazyQueue creates a new lazy queue
-func NewLazyQueue[P constraints.Ordered, V any](setIndex SetIndexCallback[V], priority PriorityCallback[P, V], maxPriority MaxPriorityCallback[P, V], clock mclock.Clock, refreshPeriod time.Duration) *LazyQueue[P, V] {
+func NewLazyQueue[P cmp.Ordered, V any](setIndex SetIndexCallback[V], priority PriorityCallback[P, V], maxPriority MaxPriorityCallback[P, V], clock mclock.Clock, refreshPeriod time.Duration) *LazyQueue[P, V] {
q := &LazyQueue[P, V]{
popQueue: newSstack[P, V](nil),
setIndex: setIndex,
diff --git a/common/prque/prque.go b/common/prque/prque.go
index 0e8c9f897f..cb0d9f3580 100755
--- a/common/prque/prque.go
+++ b/common/prque/prque.go
@@ -18,22 +18,21 @@
package prque
import (
+ "cmp"
"container/heap"
-
- "golang.org/x/exp/constraints"
)
-// Priority queue data structure.
-type Prque[P constraints.Ordered, V any] struct {
+// Prque is a priority queue data structure.
+type Prque[P cmp.Ordered, V any] struct {
cont *sstack[P, V]
}
// New creates a new priority queue.
-func New[P constraints.Ordered, V any](setIndex SetIndexCallback[V]) *Prque[P, V] {
+func New[P cmp.Ordered, V any](setIndex SetIndexCallback[V]) *Prque[P, V] {
return &Prque[P, V]{newSstack[P, V](setIndex)}
}
-// Pushes a value with a given priority into the queue, expanding if necessary.
+// Push a value with a given priority into the queue, expanding if necessary.
func (p *Prque[P, V]) Push(data V, priority P) {
heap.Push(p.cont, &item[P, V]{data, priority})
}
@@ -44,14 +43,14 @@ func (p *Prque[P, V]) Peek() (V, P) {
return item.value, item.priority
}
-// Pops the value with the greatest priority off the stack and returns it.
+// Pop the value with the greatest priority off the stack and returns it.
// Currently no shrinking is done.
func (p *Prque[P, V]) Pop() (V, P) {
item := heap.Pop(p.cont).(*item[P, V])
return item.value, item.priority
}
-// Pops only the item from the queue, dropping the associated priority value.
+// PopItem pops only the item from the queue, dropping the associated priority value.
func (p *Prque[P, V]) PopItem() V {
return heap.Pop(p.cont).(*item[P, V]).value
}
@@ -61,17 +60,17 @@ func (p *Prque[P, V]) Remove(i int) V {
return heap.Remove(p.cont, i).(*item[P, V]).value
}
-// Checks whether the priority queue is empty.
+// Empty checks whether the priority queue is empty.
func (p *Prque[P, V]) Empty() bool {
return p.cont.Len() == 0
}
-// Returns the number of element in the priority queue.
+// Size returns the number of element in the priority queue.
func (p *Prque[P, V]) Size() int {
return p.cont.Len()
}
-// Clears the contents of the priority queue.
+// Reset clears the contents of the priority queue.
func (p *Prque[P, V]) Reset() {
*p = *New[P, V](p.cont.setIndex)
}
diff --git a/common/prque/sstack.go b/common/prque/sstack.go
index 5dcd1d9dd0..6865a51e23 100755
--- a/common/prque/sstack.go
+++ b/common/prque/sstack.go
@@ -10,13 +10,13 @@
package prque
-import "golang.org/x/exp/constraints"
+import "cmp"
// The size of a block of data
const blockSize = 4096
// A prioritized item in the sorted stack.
-type item[P constraints.Ordered, V any] struct {
+type item[P cmp.Ordered, V any] struct {
value V
priority P
}
@@ -29,7 +29,7 @@ type SetIndexCallback[V any] func(data V, index int)
// Internal sortable stack data structure. Implements the Push and Pop ops for
// the stack (heap) functionality and the Len, Less and Swap methods for the
// sortability requirements of the heaps.
-type sstack[P constraints.Ordered, V any] struct {
+type sstack[P cmp.Ordered, V any] struct {
setIndex SetIndexCallback[V]
size int
capacity int
@@ -40,7 +40,7 @@ type sstack[P constraints.Ordered, V any] struct {
}
// Creates a new, empty stack.
-func newSstack[P constraints.Ordered, V any](setIndex SetIndexCallback[V]) *sstack[P, V] {
+func newSstack[P cmp.Ordered, V any](setIndex SetIndexCallback[V]) *sstack[P, V] {
result := new(sstack[P, V])
result.setIndex = setIndex
result.active = make([]*item[P, V], blockSize)
@@ -49,7 +49,7 @@ func newSstack[P constraints.Ordered, V any](setIndex SetIndexCallback[V]) *ssta
return result
}
-// Pushes a value onto the stack, expanding it if necessary. Required by
+// Push a value onto the stack, expanding it if necessary. Required by
// heap.Interface.
func (s *sstack[P, V]) Push(data any) {
if s.size == s.capacity {
@@ -69,7 +69,7 @@ func (s *sstack[P, V]) Push(data any) {
s.size++
}
-// Pops a value off the stack and returns it. Currently no shrinking is done.
+// Pop a value off the stack and returns it. Currently no shrinking is done.
// Required by heap.Interface.
func (s *sstack[P, V]) Pop() (res any) {
s.size--
@@ -85,18 +85,18 @@ func (s *sstack[P, V]) Pop() (res any) {
return
}
-// Returns the length of the stack. Required by sort.Interface.
+// Len returns the length of the stack. Required by sort.Interface.
func (s *sstack[P, V]) Len() int {
return s.size
}
-// Compares the priority of two elements of the stack (higher is first).
+// Less compares the priority of two elements of the stack (higher is first).
// Required by sort.Interface.
func (s *sstack[P, V]) Less(i, j int) bool {
return s.blocks[i/blockSize][i%blockSize].priority > s.blocks[j/blockSize][j%blockSize].priority
}
-// Swaps two elements in the stack. Required by sort.Interface.
+// Swap two elements in the stack. Required by sort.Interface.
func (s *sstack[P, V]) Swap(i, j int) {
ib, io, jb, jo := i/blockSize, i%blockSize, j/blockSize, j%blockSize
a, b := s.blocks[jb][jo], s.blocks[ib][io]
@@ -107,7 +107,7 @@ func (s *sstack[P, V]) Swap(i, j int) {
s.blocks[ib][io], s.blocks[jb][jo] = a, b
}
-// Resets the stack, effectively clearing its contents.
+// Reset the stack, effectively clearing its contents.
func (s *sstack[P, V]) Reset() {
*s = *newSstack[P, V](s.setIndex)
}
diff --git a/consensus/clique/snapshot.go b/consensus/clique/snapshot.go
index a97115121b..8ff0b3a70f 100644
--- a/consensus/clique/snapshot.go
+++ b/consensus/clique/snapshot.go
@@ -19,6 +19,7 @@ package clique
import (
"bytes"
"encoding/json"
+ "slices"
"time"
"github.com/ethereum/go-ethereum/common"
@@ -28,7 +29,6 @@ import (
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/params"
- "golang.org/x/exp/slices"
)
// Vote represents a single vote that an authorized signer made to modify the
diff --git a/consensus/clique/snapshot_test.go b/consensus/clique/snapshot_test.go
index 26cebe008a..4ef7a7b3ae 100644
--- a/consensus/clique/snapshot_test.go
+++ b/consensus/clique/snapshot_test.go
@@ -21,6 +21,7 @@ import (
"crypto/ecdsa"
"fmt"
"math/big"
+ "slices"
"testing"
"github.com/ethereum/go-ethereum/common"
@@ -30,7 +31,6 @@ import (
"github.com/ethereum/go-ethereum/core/vm"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/params"
- "golang.org/x/exp/slices"
)
// testerAccountPool is a pool to maintain currently active tester accounts,
diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go
index cc19d12a56..9800bf9288 100644
--- a/consensus/ethash/consensus.go
+++ b/consensus/ethash/consensus.go
@@ -568,7 +568,7 @@ var (
u256_32 = uint256.NewInt(32)
)
-// AccumulateRewards credits the coinbase of the given block with the mining
+// 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, stateDB *state.StateDB, header *types.Header, uncles []*types.Header) {
diff --git a/core/asm/lexer.go b/core/asm/lexer.go
index e025c6f363..630360b106 100644
--- a/core/asm/lexer.go
+++ b/core/asm/lexer.go
@@ -127,7 +127,7 @@ func (l *lexer) ignore() {
l.start = l.pos
}
-// Accepts checks whether the given input matches the next rune
+// accept checks whether the given input matches the next rune
func (l *lexer) accept(valid string) bool {
if strings.ContainsRune(valid, l.next()) {
return true
diff --git a/core/block_validator.go b/core/block_validator.go
index f3d65cea25..3d49f4e6a3 100644
--- a/core/block_validator.go
+++ b/core/block_validator.go
@@ -132,7 +132,7 @@ func (v *BlockValidator) ValidateState(block *types.Block, statedb *state.StateD
if rbloom != header.Bloom {
return fmt.Errorf("invalid bloom (remote: %x local: %x)", header.Bloom, rbloom)
}
- // Tre receipt Trie's root (R = (Tr [[H1, R1], ... [Hn, Rn]]))
+ // The receipt Trie's root (R = (Tr [[H1, R1], ... [Hn, Rn]]))
receiptSha := types.DeriveSha(receipts, trie.NewStackTrie(nil))
if receiptSha != header.ReceiptHash {
return fmt.Errorf("invalid receipt root hash (remote: %x local: %x)", header.ReceiptHash, receiptSha)
diff --git a/core/blockchain.go b/core/blockchain.go
index 12fdcf7245..788804b72e 100644
--- a/core/blockchain.go
+++ b/core/blockchain.go
@@ -147,8 +147,11 @@ type CacheConfig struct {
}
// triedbConfig derives the configures for trie database.
-func (c *CacheConfig) triedbConfig() *triedb.Config {
- config := &triedb.Config{Preimages: c.Preimages}
+func (c *CacheConfig) triedbConfig(isVerkle bool) *triedb.Config {
+ config := &triedb.Config{
+ Preimages: c.Preimages,
+ IsVerkle: isVerkle,
+ }
if c.StateScheme == rawdb.HashScheme {
config.HashDB = &hashdb.Config{
CleanCacheSize: c.TrieCleanLimit * 1024 * 1024,
@@ -241,6 +244,8 @@ type BlockChain struct {
bodyRLPCache *lru.Cache[common.Hash, rlp.RawValue]
receiptsCache *lru.Cache[common.Hash, []*types.Receipt]
blockCache *lru.Cache[common.Hash, *types.Block]
+
+ txLookupLock sync.RWMutex
txLookupCache *lru.Cache[common.Hash, txLookup]
wg sync.WaitGroup
@@ -265,7 +270,7 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
cacheConfig = defaultCacheConfig
}
// Open trie database with provided config
- triedb := triedb.NewDatabase(db, cacheConfig.triedbConfig())
+ triedb := triedb.NewDatabase(db, cacheConfig.triedbConfig(genesis != nil && genesis.IsVerkle()))
// Setup the genesis block, commit the provided genesis specification
// to database if the genesis block is not present yet, or load the
@@ -436,7 +441,7 @@ func NewBlockChain(db ethdb.Database, cacheConfig *CacheConfig, genesis *Genesis
}
if alloc == nil {
- return nil, fmt.Errorf("live blockchain tracer requires genesis alloc to be set")
+ return nil, errors.New("live blockchain tracer requires genesis alloc to be set")
}
bc.logger.OnGenesisBlock(bc.genesisBlock, alloc)
@@ -639,7 +644,7 @@ func (bc *BlockChain) SetSafe(header *types.Header) {
}
}
-// rewindPathHead implements the logic of rewindHead in the context of hash scheme.
+// rewindHashHead implements the logic of rewindHead in the context of hash scheme.
func (bc *BlockChain) rewindHashHead(head *types.Header, root common.Hash) (*types.Header, uint64) {
var (
limit uint64 // The oldest block that will be searched for this rewinding
@@ -1549,17 +1554,6 @@ func (bc *BlockChain) writeBlockWithState(block *types.Block, receipts []*types.
return nil
}
-// WriteBlockAndSetHead writes the given block and all associated state to the database,
-// and applies the block as the new chain head.
-func (bc *BlockChain) WriteBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) {
- if !bc.chainmu.TryLock() {
- return NonStatTy, errChainStopped
- }
- defer bc.chainmu.Unlock()
-
- return bc.writeBlockAndSetHead(block, receipts, logs, state, emitHeadEvent)
-}
-
// writeBlockAndSetHead is the internal implementation of WriteBlockAndSetHead.
// This function expects the chain mutex to be held.
func (bc *BlockChain) writeBlockAndSetHead(block *types.Block, receipts []*types.Receipt, logs []*types.Log, state *state.StateDB, emitHeadEvent bool) (status WriteStatus, err error) {
@@ -2298,14 +2292,14 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Block) error {
// rewind the canonical chain to a lower point.
log.Error("Impossible reorg, please file an issue", "oldnum", oldBlock.Number(), "oldhash", oldBlock.Hash(), "oldblocks", len(oldChain), "newnum", newBlock.Number(), "newhash", newBlock.Hash(), "newblocks", len(newChain))
}
- // Reset the tx lookup cache in case to clear stale txlookups.
- // This is done before writing any new chain data to avoid the
- // weird scenario that canonical chain is changed while the
- // stale lookups are still cached.
- bc.txLookupCache.Purge()
+ // Acquire the tx-lookup lock before mutation. This step is essential
+ // as the txlookups should be changed atomically, and all subsequent
+ // reads should be blocked until the mutation is complete.
+ bc.txLookupLock.Lock()
- // Insert the new chain(except the head block(reverse order)),
- // taking care of the proper incremental order.
+ // Insert the new chain segment in incremental order, from the old
+ // to the new. The new chain head (newChain[0]) is not inserted here,
+ // as it will be handled separately outside of this function
for i := len(newChain) - 1; i >= 1; i-- {
// Insert the block in the canonical way, re-writing history
bc.writeHeadBlock(newChain[i])
@@ -2342,6 +2336,11 @@ func (bc *BlockChain) reorg(oldHead *types.Header, newHead *types.Block) error {
if err := indexesBatch.Write(); err != nil {
log.Crit("Failed to delete useless indexes", "err", err)
}
+ // Reset the tx lookup cache to clear stale txlookup cache.
+ bc.txLookupCache.Purge()
+
+ // Release the tx-lookup lock after mutation.
+ bc.txLookupLock.Unlock()
// Send out events for logs from the old canon chain, and 'reborn'
// logs from the new canon chain. The number of logs can be very
diff --git a/core/blockchain_reader.go b/core/blockchain_reader.go
index 9e8e3bd419..8a85800dd8 100644
--- a/core/blockchain_reader.go
+++ b/core/blockchain_reader.go
@@ -266,6 +266,9 @@ func (bc *BlockChain) GetAncestor(hash common.Hash, number, ancestor uint64, max
// transaction indexing is already finished. The transaction is not existent
// from the node's perspective.
func (bc *BlockChain) GetTransactionLookup(hash common.Hash) (*rawdb.LegacyTxLookupEntry, *types.Transaction, error) {
+ bc.txLookupLock.RLock()
+ defer bc.txLookupLock.RUnlock()
+
// Short circuit if the txlookup already in the cache, retrieve otherwise
if item, exist := bc.txLookupCache.Get(hash); exist {
return item.lookup, item.transaction, nil
diff --git a/core/blockchain_sethead_test.go b/core/blockchain_sethead_test.go
index b96ee12c99..8b77f9f8b2 100644
--- a/core/blockchain_sethead_test.go
+++ b/core/blockchain_sethead_test.go
@@ -22,7 +22,7 @@ package core
import (
"fmt"
"math/big"
- "path"
+ "path/filepath"
"strings"
"testing"
"time"
@@ -1966,7 +1966,7 @@ func testSetHeadWithScheme(t *testing.T, tt *rewindTest, snapshots bool, scheme
// Create a temporary persistent database
datadir := t.TempDir()
- ancient := path.Join(datadir, "ancient")
+ ancient := filepath.Join(datadir, "ancient")
db, err := rawdb.Open(rawdb.OpenOptions{
Directory: datadir,
diff --git a/core/bloombits/matcher.go b/core/bloombits/matcher.go
index 6a4cfb23db..486581fe23 100644
--- a/core/bloombits/matcher.go
+++ b/core/bloombits/matcher.go
@@ -596,6 +596,9 @@ func (s *MatcherSession) deliverSections(bit uint, sections []uint64, bitsets []
// of the session, any request in-flight need to be responded to! Empty responses
// are fine though in that case.
func (s *MatcherSession) Multiplex(batch int, wait time.Duration, mux chan chan *Retrieval) {
+ waitTimer := time.NewTimer(wait)
+ defer waitTimer.Stop()
+
for {
// Allocate a new bloom bit index to retrieve data for, stopping when done
bit, ok := s.allocateRetrieval()
@@ -604,6 +607,7 @@ func (s *MatcherSession) Multiplex(batch int, wait time.Duration, mux chan chan
}
// Bit allocated, throttle a bit if we're below our batch limit
if s.pendingSections(bit) < batch {
+ waitTimer.Reset(wait)
select {
case <-s.quit:
// Session terminating, we can't meaningfully service, abort
@@ -611,7 +615,7 @@ func (s *MatcherSession) Multiplex(batch int, wait time.Duration, mux chan chan
s.deliverSections(bit, []uint64{}, [][]byte{})
return
- case <-time.After(wait):
+ case <-waitTimer.C:
// Throttling up, fetch whatever is available
}
}
diff --git a/core/chain_makers.go b/core/chain_makers.go
index 1c42ab0c9a..13d7cb86c0 100644
--- a/core/chain_makers.go
+++ b/core/chain_makers.go
@@ -32,6 +32,7 @@ import (
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/triedb"
+ "github.com/gballet/go-verkle"
"github.com/holiman/uint256"
)
@@ -418,6 +419,112 @@ func GenerateChainWithGenesis(genesis *Genesis, engine consensus.Engine, n int,
return db, blocks, receipts
}
+func GenerateVerkleChain(config *params.ChainConfig, parent *types.Block, engine consensus.Engine, db ethdb.Database, trdb *triedb.Database, n int, gen func(int, *BlockGen)) ([]*types.Block, []types.Receipts, []*verkle.VerkleProof, []verkle.StateDiff) {
+ if config == nil {
+ config = params.TestChainConfig
+ }
+ proofs := make([]*verkle.VerkleProof, 0, n)
+ keyvals := make([]verkle.StateDiff, 0, n)
+ cm := newChainMaker(parent, config, engine)
+
+ genblock := func(i int, parent *types.Block, triedb *triedb.Database, statedb *state.StateDB) (*types.Block, types.Receipts) {
+ b := &BlockGen{i: i, cm: cm, parent: parent, statedb: statedb, engine: engine}
+ b.header = cm.makeHeader(parent, statedb, b.engine)
+
+ // TODO uncomment when proof generation is merged
+ // Save pre state for proof generation
+ // preState := statedb.Copy()
+
+ // TODO uncomment when the 2935 PR is merged
+ // if config.IsPrague(b.header.Number, b.header.Time) {
+ // if !config.IsPrague(b.parent.Number(), b.parent.Time()) {
+ // Transition case: insert all 256 ancestors
+ // InsertBlockHashHistoryAtEip2935Fork(statedb, b.header.Number.Uint64()-1, b.header.ParentHash, chainreader)
+ // } else {
+ // ProcessParentBlockHash(statedb, b.header.Number.Uint64()-1, b.header.ParentHash)
+ // }
+ // }
+ // Execute any user modifications to the block
+ if gen != nil {
+ gen(i, b)
+ }
+ body := &types.Body{
+ Transactions: b.txs,
+ Uncles: b.uncles,
+ Withdrawals: b.withdrawals,
+ }
+ block, err := b.engine.FinalizeAndAssemble(cm, b.header, statedb, body, b.receipts)
+ if err != nil {
+ panic(err)
+ }
+
+ // Write state changes to db
+ root, err := statedb.Commit(b.header.Number.Uint64(), config.IsEIP158(b.header.Number))
+ if err != nil {
+ panic(fmt.Sprintf("state write error: %v", err))
+ }
+ if err = triedb.Commit(root, false); err != nil {
+ panic(fmt.Sprintf("trie write error: %v", err))
+ }
+
+ // TODO uncomment when proof generation is merged
+ // proofs = append(proofs, block.ExecutionWitness().VerkleProof)
+ // keyvals = append(keyvals, block.ExecutionWitness().StateDiff)
+
+ return block, b.receipts
+ }
+
+ for i := 0; i < n; i++ {
+ statedb, err := state.New(parent.Root(), state.NewDatabaseWithNodeDB(db, trdb), nil)
+ if err != nil {
+ panic(err)
+ }
+ block, receipts := genblock(i, parent, trdb, statedb)
+
+ // Post-process the receipts.
+ // Here we assign the final block hash and other info into the receipt.
+ // In order for DeriveFields to work, the transaction and receipt lists need to be
+ // of equal length. If AddUncheckedTx or AddUncheckedReceipt are used, there will be
+ // extra ones, so we just trim the lists here.
+ receiptsCount := len(receipts)
+ txs := block.Transactions()
+ if len(receipts) > len(txs) {
+ receipts = receipts[:len(txs)]
+ } else if len(receipts) < len(txs) {
+ txs = txs[:len(receipts)]
+ }
+ var blobGasPrice *big.Int
+ if block.ExcessBlobGas() != nil {
+ blobGasPrice = eip4844.CalcBlobFee(*block.ExcessBlobGas())
+ }
+ if err := receipts.DeriveFields(config, block.Hash(), block.NumberU64(), block.Time(), block.BaseFee(), blobGasPrice, txs); err != nil {
+ panic(err)
+ }
+
+ // Re-expand to ensure all receipts are returned.
+ receipts = receipts[:receiptsCount]
+
+ // Advance the chain.
+ cm.add(block, receipts)
+ parent = block
+ }
+ return cm.chain, cm.receipts, proofs, keyvals
+}
+
+func GenerateVerkleChainWithGenesis(genesis *Genesis, engine consensus.Engine, n int, gen func(int, *BlockGen)) (ethdb.Database, []*types.Block, []types.Receipts, []*verkle.VerkleProof, []verkle.StateDiff) {
+ db := rawdb.NewMemoryDatabase()
+ cacheConfig := DefaultCacheConfigWithScheme(rawdb.PathScheme)
+ cacheConfig.SnapshotLimit = 0
+ triedb := triedb.NewDatabase(db, cacheConfig.triedbConfig(true))
+ defer triedb.Close()
+ genesisBlock, err := genesis.Commit(db, triedb)
+ if err != nil {
+ panic(err)
+ }
+ blocks, receipts, proofs, keyvals := GenerateVerkleChain(genesis.Config, genesisBlock, engine, db, triedb, n, gen)
+ return db, blocks, receipts, proofs, keyvals
+}
+
func (cm *chainMaker) makeHeader(parent *types.Block, state *state.StateDB, engine consensus.Engine) *types.Header {
time := parent.Time() + 10 // block time is fixed at 10 seconds
header := &types.Header{
@@ -482,7 +589,7 @@ func makeBlockChain(chainConfig *params.ChainConfig, parent *types.Block, n int,
return blocks
}
-// makeBlockChain creates a deterministic chain of blocks from genesis
+// makeBlockChainWithGenesis creates a deterministic chain of blocks from genesis
func makeBlockChainWithGenesis(genesis *Genesis, n int, engine consensus.Engine, seed int) (ethdb.Database, []*types.Block) {
db, blocks, _ := GenerateChainWithGenesis(genesis, engine, n, func(i int, b *BlockGen) {
b.SetCoinbase(common.Address{0: byte(seed), 19: byte(i)})
diff --git a/core/evm.go b/core/evm.go
index 4c12e2aa02..5d3c454d7c 100644
--- a/core/evm.go
+++ b/core/evm.go
@@ -59,7 +59,7 @@ func NewEVMBlockContext(header *types.Header, chain ChainContext, author *common
if header.ExcessBlobGas != nil {
blobBaseFee = eip4844.CalcBlobFee(*header.ExcessBlobGas)
}
- if header.Difficulty.Cmp(common.Big0) == 0 {
+ if header.Difficulty.Sign() == 0 {
random = &header.MixDigest
}
return vm.BlockContext{
diff --git a/core/forkid/forkid.go b/core/forkid/forkid.go
index 76825d3bef..4db366da82 100644
--- a/core/forkid/forkid.go
+++ b/core/forkid/forkid.go
@@ -24,12 +24,12 @@ import (
"math"
"math/big"
"reflect"
+ "slices"
"strings"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/params"
- "golang.org/x/exp/slices"
)
var (
diff --git a/core/genesis.go b/core/genesis.go
index ee0e322f80..f05e84199a 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -582,7 +582,7 @@ func DeveloperGenesisBlock(gasLimit uint64, faucet *common.Address) *Genesis {
Config: &config,
GasLimit: gasLimit,
BaseFee: big.NewInt(params.InitialBaseFee),
- Difficulty: big.NewInt(1),
+ Difficulty: big.NewInt(0),
Alloc: map[common.Address]types.Account{
common.BytesToAddress([]byte{1}): {Balance: big.NewInt(1)}, // ECRecover
common.BytesToAddress([]byte{2}): {Balance: big.NewInt(1)}, // SHA256
diff --git a/core/mkalloc.go b/core/mkalloc.go
index 12c40c14fb..201c2fe7de 100644
--- a/core/mkalloc.go
+++ b/core/mkalloc.go
@@ -30,12 +30,12 @@ import (
"fmt"
"math/big"
"os"
+ "slices"
"strconv"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/rlp"
- "golang.org/x/exp/slices"
)
type allocItem struct {
diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go
index 964b3a311d..e61559993c 100644
--- a/core/rawdb/accessors_chain.go
+++ b/core/rawdb/accessors_chain.go
@@ -22,6 +22,7 @@ import (
"errors"
"fmt"
"math/big"
+ "slices"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
@@ -31,7 +32,6 @@ import (
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rlp"
- "golang.org/x/exp/slices"
)
// ReadCanonicalHash retrieves the hash assigned to a canonical block number.
@@ -695,7 +695,7 @@ func (r *receiptLogs) DecodeRLP(s *rlp.Stream) error {
return nil
}
-// DeriveLogFields fills the logs in receiptLogs with information such as block number, txhash, etc.
+// deriveLogFields fills the logs in receiptLogs with information such as block number, txhash, etc.
func deriveLogFields(receipts []*receiptLogs, hash common.Hash, number uint64, txs types.Transactions) error {
logIndex := uint(0)
if len(txs) != len(receipts) {
diff --git a/core/rawdb/database.go b/core/rawdb/database.go
index 9cab30bfcd..7b2c0415cb 100644
--- a/core/rawdb/database.go
+++ b/core/rawdb/database.go
@@ -21,7 +21,6 @@ import (
"errors"
"fmt"
"os"
- "path"
"path/filepath"
"strings"
"time"
@@ -172,7 +171,7 @@ func resolveChainFreezerDir(ancient string) string {
// sub folder, if not then two possibilities:
// - chain freezer is not initialized
// - chain freezer exists in legacy location (root ancient folder)
- freezer := path.Join(ancient, ChainFreezerName)
+ freezer := filepath.Join(ancient, ChainFreezerName)
if !common.FileExist(freezer) {
if !common.FileExist(ancient) {
// The entire ancient store is not initialized, still use the sub
diff --git a/core/rawdb/freezer_test.go b/core/rawdb/freezer_test.go
index b92cd7b734..93bc2c2254 100644
--- a/core/rawdb/freezer_test.go
+++ b/core/rawdb/freezer_test.go
@@ -23,7 +23,6 @@ import (
"math/big"
"math/rand"
"os"
- "path"
"path/filepath"
"sync"
"testing"
@@ -398,11 +397,11 @@ func TestRenameWindows(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- f2, err := os.Create(path.Join(dir1, fname2))
+ f2, err := os.Create(filepath.Join(dir1, fname2))
if err != nil {
t.Fatal(err)
}
- f3, err := os.Create(path.Join(dir2, fname2))
+ f3, err := os.Create(filepath.Join(dir2, fname2))
if err != nil {
t.Fatal(err)
}
@@ -424,15 +423,15 @@ func TestRenameWindows(t *testing.T) {
if err := f3.Close(); err != nil {
t.Fatal(err)
}
- if err := os.Rename(f.Name(), path.Join(dir2, fname)); err != nil {
+ if err := os.Rename(f.Name(), filepath.Join(dir2, fname)); err != nil {
t.Fatal(err)
}
- if err := os.Rename(f2.Name(), path.Join(dir2, fname2)); err != nil {
+ if err := os.Rename(f2.Name(), filepath.Join(dir2, fname2)); err != nil {
t.Fatal(err)
}
// Check file contents
- f, err = os.Open(path.Join(dir2, fname))
+ f, err = os.Open(filepath.Join(dir2, fname))
if err != nil {
t.Fatal(err)
}
@@ -446,7 +445,7 @@ func TestRenameWindows(t *testing.T) {
t.Errorf("unexpected file contents. Got %v\n", buf)
}
- f, err = os.Open(path.Join(dir2, fname2))
+ f, err = os.Open(filepath.Join(dir2, fname2))
if err != nil {
t.Fatal(err)
}
diff --git a/core/state/access_list.go b/core/state/access_list.go
index 4194691345..718bf17cf7 100644
--- a/core/state/access_list.go
+++ b/core/state/access_list.go
@@ -17,6 +17,8 @@
package state
import (
+ "maps"
+
"github.com/ethereum/go-ethereum/common"
)
@@ -57,16 +59,10 @@ func newAccessList() *accessList {
// Copy creates an independent copy of an accessList.
func (a *accessList) Copy() *accessList {
cp := newAccessList()
- for k, v := range a.addresses {
- cp.addresses[k] = v
- }
+ cp.addresses = maps.Clone(a.addresses)
cp.slots = make([]map[common.Hash]struct{}, len(a.slots))
for i, slotMap := range a.slots {
- newSlotmap := make(map[common.Hash]struct{}, len(slotMap))
- for k := range slotMap {
- newSlotmap[k] = struct{}{}
- }
- cp.slots[i] = newSlotmap
+ cp.slots[i] = maps.Clone(slotMap)
}
return cp
}
diff --git a/core/state/database.go b/core/state/database.go
index 7520923eef..188ecf0c86 100644
--- a/core/state/database.go
+++ b/core/state/database.go
@@ -209,6 +209,8 @@ func (db *cachingDB) CopyTrie(t Trie) Trie {
switch t := t.(type) {
case *trie.StateTrie:
return t.Copy()
+ case *trie.VerkleTrie:
+ return t.Copy()
default:
panic(fmt.Errorf("unknown trie type %T", t))
}
diff --git a/core/state/snapshot/difflayer.go b/core/state/snapshot/difflayer.go
index 70c9f44189..779c1ea98c 100644
--- a/core/state/snapshot/difflayer.go
+++ b/core/state/snapshot/difflayer.go
@@ -21,6 +21,7 @@ import (
"fmt"
"math"
"math/rand"
+ "slices"
"sync"
"sync/atomic"
"time"
@@ -29,7 +30,6 @@ import (
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/rlp"
bloomfilter "github.com/holiman/bloomfilter/v2"
- "golang.org/x/exp/slices"
)
var (
diff --git a/core/state/snapshot/iterator_fast.go b/core/state/snapshot/iterator_fast.go
index 0502d9cf85..9b018bac56 100644
--- a/core/state/snapshot/iterator_fast.go
+++ b/core/state/snapshot/iterator_fast.go
@@ -19,10 +19,10 @@ package snapshot
import (
"bytes"
"fmt"
+ "slices"
"sort"
"github.com/ethereum/go-ethereum/common"
- "golang.org/x/exp/slices"
)
// weightedIterator is a iterator with an assigned weight. It is used to prioritise
diff --git a/core/state/state_object.go b/core/state/state_object.go
index 910f496341..1aa7946fd0 100644
--- a/core/state/state_object.go
+++ b/core/state/state_object.go
@@ -20,6 +20,7 @@ import (
"bytes"
"fmt"
"io"
+ "maps"
"time"
"github.com/ethereum/go-ethereum/common"
@@ -47,11 +48,7 @@ func (s Storage) String() (str string) {
}
func (s Storage) Copy() Storage {
- cpy := make(Storage, len(s))
- for key, value := range s {
- cpy[key] = value
- }
- return cpy
+ return maps.Clone(s)
}
// stateObject represents an Ethereum account which is being modified.
@@ -298,6 +295,18 @@ func (s *stateObject) updateTrie() (Trie, error) {
}
// Insert all the pending storage updates into the trie
usedStorage := make([][]byte, 0, len(s.pendingStorage))
+
+ // Perform trie updates before deletions. This prevents resolution of unnecessary trie nodes
+ // in circumstances similar to the following:
+ //
+ // Consider nodes `A` and `B` who share the same full node parent `P` and have no other siblings.
+ // During the execution of a block:
+ // - `A` is deleted,
+ // - `C` is created, and also shares the parent `P`.
+ // If the deletion is handled first, then `P` would be left with only one child, thus collapsed
+ // into a shortnode. This requires `B` to be resolved from disk.
+ // Whereas if the created node is handled first, then the collapse is avoided, and `B` is not resolved.
+ var deletions []common.Hash
for key, value := range s.pendingStorage {
// Skip noop changes, persist actual changes
if value == s.originStorage[key] {
@@ -307,13 +316,7 @@ func (s *stateObject) updateTrie() (Trie, error) {
s.originStorage[key] = value
var encoded []byte // rlp-encoded value to be used by the snapshot
- if (value == common.Hash{}) {
- if err := tr.DeleteStorage(s.address, key[:]); err != nil {
- s.db.setError(err)
- return nil, err
- }
- s.db.StorageDeleted += 1
- } else {
+ if (value != common.Hash{}) {
// Encoding []byte cannot fail, ok to ignore the error.
trimmed := common.TrimLeftZeroes(value[:])
encoded, _ = rlp.EncodeToBytes(trimmed)
@@ -322,6 +325,8 @@ func (s *stateObject) updateTrie() (Trie, error) {
return nil, err
}
s.db.StorageUpdated += 1
+ } else {
+ deletions = append(deletions, key)
}
// Cache the mutated storage slots until commit
if storage == nil {
@@ -353,6 +358,13 @@ func (s *stateObject) updateTrie() (Trie, error) {
// Cache the items for preloading
usedStorage = append(usedStorage, common.CopyBytes(key[:])) // Copy needed for closure
}
+ for _, key := range deletions {
+ if err := tr.DeleteStorage(s.address, key[:]); err != nil {
+ s.db.setError(err)
+ return nil, err
+ }
+ s.db.StorageDeleted += 1
+ }
if s.db.prefetcher != nil {
s.db.prefetcher.used(s.addrHash, s.data.Root, usedStorage)
}
diff --git a/core/state/statedb.go b/core/state/statedb.go
index 24914927c2..f2c2e7a798 100644
--- a/core/state/statedb.go
+++ b/core/state/statedb.go
@@ -19,7 +19,9 @@ package state
import (
"fmt"
+ "maps"
"math/big"
+ "slices"
"sort"
"time"
@@ -243,9 +245,7 @@ func (s *StateDB) Logs() []*types.Log {
func (s *StateDB) AddPreimage(hash common.Hash, preimage []byte) {
if _, ok := s.preimages[hash]; !ok {
s.journal.append(addPreimageChange{hash: hash})
- pi := make([]byte, len(preimage))
- copy(pi, preimage)
- s.preimages[hash] = pi
+ s.preimages[hash] = slices.Clone(preimage)
}
}
@@ -541,12 +541,11 @@ func (s *StateDB) updateStateObject(obj *stateObject) {
}
// deleteStateObject removes the given object from the state trie.
-func (s *StateDB) deleteStateObject(obj *stateObject) {
+func (s *StateDB) deleteStateObject(addr common.Address) {
// Track the amount of time wasted on deleting the account from the trie
defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now())
// Delete the account from the trie
- addr := obj.Address()
if err := s.trie.DeleteAccount(addr); err != nil {
s.setError(fmt.Errorf("deleteStateObject (%x) error: %v", addr[:], err))
}
@@ -752,9 +751,8 @@ func (s *StateDB) Copy() *StateDB {
state.stateObjectsDirty[addr] = struct{}{}
}
// Deep copy the destruction markers.
- for addr, value := range s.stateObjectsDestruct {
- state.stateObjectsDestruct[addr] = value
- }
+ state.stateObjectsDestruct = maps.Clone(s.stateObjectsDestruct)
+
// Deep copy the state changes made in the scope of block
// along with their original values.
state.accounts = copySet(s.accounts)
@@ -772,9 +770,7 @@ func (s *StateDB) Copy() *StateDB {
state.logs[hash] = cpy
}
// Deep copy the preimages occurred in the scope of block
- for hash, preimage := range s.preimages {
- state.preimages[hash] = preimage
- }
+ state.preimages = maps.Clone(s.preimages)
// Do we need to copy the access list and transient storage?
// In practice: No. At the start of a transaction, these two lists are empty.
// In practice, we only ever copy state _between_ transactions/blocks, never
@@ -917,16 +913,30 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
}
}
usedAddrs := make([][]byte, 0, len(s.stateObjectsPending))
+ // Perform updates before deletions. This prevents resolution of unnecessary trie nodes
+ // in circumstances similar to the following:
+ //
+ // Consider nodes `A` and `B` who share the same full node parent `P` and have no other siblings.
+ // During the execution of a block:
+ // - `A` self-destructs,
+ // - `C` is created, and also shares the parent `P`.
+ // If the self-destruct is handled first, then `P` would be left with only one child, thus collapsed
+ // into a shortnode. This requires `B` to be resolved from disk.
+ // Whereas if the created node is handled first, then the collapse is avoided, and `B` is not resolved.
+ var deletedAddrs []common.Address
for addr := range s.stateObjectsPending {
- if obj := s.stateObjects[addr]; obj.deleted {
- s.deleteStateObject(obj)
- s.AccountDeleted += 1
- } else {
+ if obj := s.stateObjects[addr]; !obj.deleted {
s.updateStateObject(obj)
s.AccountUpdated += 1
+ } else {
+ deletedAddrs = append(deletedAddrs, obj.address)
}
usedAddrs = append(usedAddrs, common.CopyBytes(addr[:])) // Copy needed for closure
}
+ for _, deletedAddr := range deletedAddrs {
+ s.deleteStateObject(deletedAddr)
+ s.AccountDeleted += 1
+ }
if prefetcher != nil {
prefetcher.used(common.Hash{}, s.originalRoot, usedAddrs)
}
@@ -1143,6 +1153,11 @@ func (s *StateDB) handleDestruction(nodes *trienode.MergedNodeSet) error {
return nil
}
+// GetTrie returns the account trie.
+func (s *StateDB) GetTrie() Trie {
+ return s.trie
+}
+
// Commit writes the state to the underlying in-memory trie database.
// Once the state is committed, tries cached in stateDB (including account
// trie, storage tries) will no longer be functional. A new state instance
diff --git a/core/state_processor_test.go b/core/state_processor_test.go
index 7718c0cde4..dc9cb203bc 100644
--- a/core/state_processor_test.go
+++ b/core/state_processor_test.go
@@ -422,3 +422,108 @@ func GenerateBadBlock(parent *types.Block, engine consensus.Engine, txs types.Tr
}
return types.NewBlock(header, txs, nil, receipts, trie.NewStackTrie(nil))
}
+
+var (
+ code = common.FromHex(`6060604052600a8060106000396000f360606040526008565b00`)
+ intrinsicContractCreationGas, _ = IntrinsicGas(code, nil, true, true, true, true)
+ // A contract creation that calls EXTCODECOPY in the constructor. Used to ensure that the witness
+ // will not contain that copied data.
+ // Source: https://gist.github.com/gballet/a23db1e1cb4ed105616b5920feb75985
+ codeWithExtCodeCopy = common.FromHex(`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`)
+ intrinsicCodeWithExtCodeCopyGas, _ = IntrinsicGas(codeWithExtCodeCopy, nil, true, true, true, true)
+)
+
+func TestProcessVerkle(t *testing.T) {
+ var (
+ config = ¶ms.ChainConfig{
+ ChainID: big.NewInt(1),
+ HomesteadBlock: big.NewInt(0),
+ EIP150Block: big.NewInt(0),
+ EIP155Block: big.NewInt(0),
+ EIP158Block: big.NewInt(0),
+ ByzantiumBlock: big.NewInt(0),
+ ConstantinopleBlock: big.NewInt(0),
+ PetersburgBlock: big.NewInt(0),
+ IstanbulBlock: big.NewInt(0),
+ MuirGlacierBlock: big.NewInt(0),
+ BerlinBlock: big.NewInt(0),
+ LondonBlock: big.NewInt(0),
+ Ethash: new(params.EthashConfig),
+ ShanghaiTime: u64(0),
+ VerkleTime: u64(0),
+ TerminalTotalDifficulty: common.Big0,
+ TerminalTotalDifficultyPassed: true,
+ // TODO uncomment when proof generation is merged
+ // ProofInBlocks: true,
+ }
+ signer = types.LatestSigner(config)
+ testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
+ bcdb = rawdb.NewMemoryDatabase() // Database for the blockchain
+ coinbase = common.HexToAddress("0x71562b71999873DB5b286dF957af199Ec94617F7")
+ gspec = &Genesis{
+ Config: config,
+ Alloc: GenesisAlloc{
+ coinbase: GenesisAccount{
+ Balance: big.NewInt(1000000000000000000), // 1 ether
+ Nonce: 0,
+ },
+ },
+ }
+ )
+ // Verkle trees use the snapshot, which must be enabled before the
+ // data is saved into the tree+database.
+ // genesis := gspec.MustCommit(bcdb, triedb)
+ cacheConfig := DefaultCacheConfigWithScheme("path")
+ cacheConfig.SnapshotLimit = 0
+ blockchain, _ := NewBlockChain(bcdb, cacheConfig, gspec, nil, beacon.New(ethash.NewFaker()), vm.Config{}, nil, nil)
+ defer blockchain.Stop()
+
+ txCost1 := params.TxGas
+ txCost2 := params.TxGas
+ contractCreationCost := intrinsicContractCreationGas + uint64(2039 /* execution costs */)
+ codeWithExtCodeCopyGas := intrinsicCodeWithExtCodeCopyGas + uint64(293644 /* execution costs */)
+ blockGasUsagesExpected := []uint64{
+ txCost1*2 + txCost2,
+ txCost1*2 + txCost2 + contractCreationCost + codeWithExtCodeCopyGas,
+ }
+ _, chain, _, _, _ := GenerateVerkleChainWithGenesis(gspec, beacon.New(ethash.NewFaker()), 2, func(i int, gen *BlockGen) {
+ gen.SetPoS()
+
+ // TODO need to check that the tx cost provided is the exact amount used (no remaining left-over)
+ tx, _ := types.SignTx(types.NewTransaction(uint64(i)*3, common.Address{byte(i), 2, 3}, big.NewInt(999), txCost1, big.NewInt(875000000), nil), signer, testKey)
+ gen.AddTx(tx)
+ tx, _ = types.SignTx(types.NewTransaction(uint64(i)*3+1, common.Address{}, big.NewInt(999), txCost1, big.NewInt(875000000), nil), signer, testKey)
+ gen.AddTx(tx)
+ tx, _ = types.SignTx(types.NewTransaction(uint64(i)*3+2, common.Address{}, big.NewInt(0), txCost2, big.NewInt(875000000), nil), signer, testKey)
+ gen.AddTx(tx)
+
+ // Add two contract creations in block #2
+ if i == 1 {
+ tx, _ = types.SignTx(types.NewContractCreation(6, big.NewInt(16), 3000000, big.NewInt(875000000), code), signer, testKey)
+ gen.AddTx(tx)
+
+ tx, _ = types.SignTx(types.NewContractCreation(7, big.NewInt(0), 3000000, big.NewInt(875000000), codeWithExtCodeCopy), signer, testKey)
+ gen.AddTx(tx)
+ }
+ })
+
+ t.Log("inserting blocks into the chain")
+
+ endnum, err := blockchain.InsertChain(chain)
+ if err != nil {
+ t.Fatalf("block %d imported with error: %v", endnum, err)
+ }
+
+ for i := 0; i < 2; i++ {
+ b := blockchain.GetBlockByNumber(uint64(i) + 1)
+ if b == nil {
+ t.Fatalf("expected block %d to be present in chain", i+1)
+ }
+ if b.Hash() != chain[i].Hash() {
+ t.Fatalf("block #%d not found at expected height", b.NumberU64())
+ }
+ if b.GasUsed() != blockGasUsagesExpected[i] {
+ t.Fatalf("expected block #%d txs to use %d, got %d\n", b.NumberU64(), blockGasUsagesExpected[i], b.GasUsed())
+ }
+ }
+}
diff --git a/core/tracing/CHANGELOG.md b/core/tracing/CHANGELOG.md
new file mode 100644
index 0000000000..77eda4ad76
--- /dev/null
+++ b/core/tracing/CHANGELOG.md
@@ -0,0 +1,69 @@
+# Changelog
+
+All notable changes to the tracing interface will be documented in this file.
+
+## [Unreleased]
+
+There has been a major breaking change in the tracing interface for custom native tracers. JS and built-in tracers are not affected by this change and tracing API methods may be used as before. This overhaul has been done as part of the new live tracing feature ([#29189](https://github.com/ethereum/go-ethereum/pull/29189)). To learn more about live tracing please refer to the [docs](https://geth.ethereum.org/docs/developers/evm-tracing/live-tracing).
+
+**The `EVMLogger` interface which the tracers implemented has been removed.** It has been replaced by a new struct `tracing.Hooks`. `Hooks` keeps pointers to event listening functions. Internally the EVM will use these function pointers to emit events and can skip an event if the tracer has opted not to implement it. In fact this is the main reason for this change of approach. Another benefit is the ease of adding new hooks in future, and dynamically assigning event receivers.
+
+The consequence of this change can be seen in the constructor of a tracer. Let's take the 4byte tracer as an example. Previously the constructor return an instance which satisfied the interface. Now it should return a pointer to `tracers.Tracer` (which is now also a struct as opposed to an interface) and explicitly assign the event listeners. As a side-benefit the tracers will not have to provide empty implementation of methods just to satisfy the interface:
+
+```go
+func newFourByteTracer(ctx *tracers.Context, _ json.RawMessage) (tracers.Tracer, error) {
+ t := &fourByteTracer{
+ ids: make(map[string]int),
+ }
+ return t, nil
+
+}
+```
+
+And now:
+
+```go
+func newFourByteTracer(ctx *tracers.Context, _ json.RawMessage) (*tracers.Tracer, error) {
+ t := &fourByteTracer{
+ ids: make(map[string]int),
+ }
+ return &tracers.Tracer{
+ Hooks: &tracing.Hooks{
+ OnTxStart: t.onTxStart,
+ OnEnter: t.onEnter,
+ },
+ GetResult: t.getResult,
+ Stop: t.stop,
+ }, nil
+}
+```
+
+### Event listeners
+
+If you have sharp eyes you might have noticed the new names for `OnTxStart` and `OnEnter`, previously called `CaptureTxStart` and `CaptureEnter`. Indeed there have been various modifications to the signatures of the event listeners. All method names now follow the `On*` pattern instead of `Capture*`. However the modifications are not limited to the names.
+
+#### New methods
+
+The live tracing feature was half about adding more observability into the state of the blockchain. As such there have been a host of method additions. Please consult the [Hooks](./hooks.go) struct for the full list of methods. Custom tracers which are invoked through the API (as opposed to "live" tracers) can benefit from the following new methods:
+
+- `OnGasChange(old, new uint64, reason GasChangeReason)`: This hook tracks the lifetime of gas within a transaction and its subcalls. It will first track the initial purchase of gas with ether, then the following consumptions and refunds of gas until at the end the rest is returned.
+- `OnBalanceChange(addr common.Address, prev, new *big.Int, reason BalanceChangeReason)`: This hook tracks the balance changes of accounts. Where possible a reason is provided for the change (e.g. a transfer, gas purchase, withdrawal deposit etc).
+- `OnNonceChange(addr common.Address, prev, new uint64)`: This hook tracks the nonce changes of accounts.
+- `OnCodeChange(addr common.Address, prevCodeHash common.Hash, prevCode []byte, codeHash common.Hash, code []byte)`: This hook tracks the code changes of accounts.
+- `OnStorageChange(addr common.Address, slot common.Hash, prev, new common.Hash)`: This hook tracks the storage changes of accounts.
+- `OnLogChange(log *types.Log)`: This hook tracks the logs emitted by the EVM.
+
+#### Removed methods
+
+The hooks `CaptureStart` and `CaptureEnd` have been removed. These hooks signaled the top-level call frame of a transaction. The relevant info will be now emitted by `OnEnter` and `OnExit` which are emitted for every call frame. They now contain a `depth` parameter which can be used to distinguish the top-level call frame when necessary. The `create bool` parameter to `CaptureStart` can now be inferred from `typ byte` in `OnEnter`, i.e. `vm.OpCode(typ) == vm.CREATE`.
+
+#### Modified methods
+
+- `CaptureTxStart` -> `OnTxStart(vm *VMContext, tx *types.Transaction, from common.Address)`. It now emits the full transaction object as well as `from` which should be used to get the sender address. The `*VMContext` is a replacement for the `*vm.EVM` object previously passed to `CaptureStart`.
+- `CaptureTxEnd` -> `OnTxEnd(receipt *types.Receipt, err error)`. It now returns the full receipt object.
+- `CaptureEnter` -> `OnEnter(depth int, typ byte, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int)`. The new `depth int` parameter indicates the call stack depth. It is 0 for the top-level call. Furthermore, the location where `OnEnter` is called in the EVM is now made a soon as a call is started. This means some specific error cases that were not before calling `OnEnter/OnExit` will now do so, leading some transaction to have an extra call traced.
+- `CaptureExit` -> `OnExit(depth int, output []byte, gasUsed uint64, err error, reverted bool)`. It has the new `depth` parameter, same as `OnEnter`. The new `reverted` parameter indicates whether the call frame was reverted.
+- `CaptureState` -> `OnOpcode(pc uint64, op byte, gas, cost uint64, scope tracing.OpContext, rData []byte, depth int, err error)`. `op` is of type `byte` which can be cast to `vm.OpCode` when necessary. A `*vm.ScopeContext` is not passed anymore. It is replaced by `tracing.OpContext` which offers access to the memory, stack and current contract.
+- `CaptureFault` -> `OnFault(pc uint64, op byte, gas, cost uint64, scope tracing.OpContext, depth int, err error)`. Similar to above.
+
+[unreleased]: https://github.com/ethereum/go-ethereum/compare/v1.13.14...master
\ No newline at end of file
diff --git a/core/txpool/blobpool/blobpool.go b/core/txpool/blobpool/blobpool.go
index 6dbcc9dadc..f1c2c10fc9 100644
--- a/core/txpool/blobpool/blobpool.go
+++ b/core/txpool/blobpool/blobpool.go
@@ -1226,7 +1226,7 @@ func (p *BlobPool) Add(txs []*types.Transaction, local bool, sync bool) []error
return errs
}
-// Add inserts a new blob transaction into the pool if it passes validation (both
+// add inserts a new blob transaction into the pool if it passes validation (both
// consensus validity and pool restrictions).
func (p *BlobPool) add(tx *types.Transaction) (err error) {
// The blob pool blocks on adding a transaction. This is because blob txs are
diff --git a/core/txpool/blobpool/limbo.go b/core/txpool/blobpool/limbo.go
index ec754f6894..32381a3936 100644
--- a/core/txpool/blobpool/limbo.go
+++ b/core/txpool/blobpool/limbo.go
@@ -60,7 +60,7 @@ func newLimbo(datadir string) (*limbo, error) {
fails = append(fails, id)
}
}
- store, err := billy.Open(billy.Options{Path: datadir}, newSlotter(), index)
+ store, err := billy.Open(billy.Options{Path: datadir, Repair: true}, newSlotter(), index)
if err != nil {
return nil, err
}
diff --git a/core/txpool/legacypool/list.go b/core/txpool/legacypool/list.go
index 7db9c98ace..b749db44d4 100644
--- a/core/txpool/legacypool/list.go
+++ b/core/txpool/legacypool/list.go
@@ -20,6 +20,7 @@ import (
"container/heap"
"math"
"math/big"
+ "slices"
"sort"
"sync"
"sync/atomic"
@@ -28,7 +29,6 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
"github.com/holiman/uint256"
- "golang.org/x/exp/slices"
)
// nonceHeap is a heap.Interface implementation over 64bit unsigned integers for
diff --git a/core/types/block.go b/core/types/block.go
index 1a357baa3a..53054f52d3 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -197,8 +197,8 @@ type Block struct {
withdrawals Withdrawals
// caches
- hash atomic.Value
- size atomic.Value
+ hash atomic.Pointer[common.Hash]
+ size atomic.Uint64
// These fields are used by package eth to track
// inter-peer block relay.
@@ -406,8 +406,8 @@ func (b *Block) BlobGasUsed() *uint64 {
// Size returns the true RLP encoded storage size of the block, either by encoding
// and returning it, or returning a previously cached value.
func (b *Block) Size() uint64 {
- if size := b.size.Load(); size != nil {
- return size.(uint64)
+ if size := b.size.Load(); size > 0 {
+ return size
}
c := writeCounter(0)
rlp.Encode(&c, b)
@@ -486,11 +486,11 @@ func (b *Block) WithWithdrawals(withdrawals []*Withdrawal) *Block {
// The hash is computed on the first call and cached thereafter.
func (b *Block) Hash() common.Hash {
if hash := b.hash.Load(); hash != nil {
- return hash.(common.Hash)
+ return *hash
}
- v := b.header.Hash()
- b.hash.Store(v)
- return v
+ h := b.header.Hash()
+ b.hash.Store(&h)
+ return h
}
type Blocks []*Block
diff --git a/core/types/transaction.go b/core/types/transaction.go
index 7d2e9d5325..6a27ecbfec 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -57,9 +57,9 @@ type Transaction struct {
time time.Time // Time first seen locally (spam avoidance)
// caches
- hash atomic.Value
- size atomic.Value
- from atomic.Value
+ hash atomic.Pointer[common.Hash]
+ size atomic.Uint64
+ from atomic.Pointer[sigCache]
}
// NewTx creates a new transaction.
@@ -446,6 +446,26 @@ func (tx *Transaction) WithoutBlobTxSidecar() *Transaction {
return cpy
}
+// WithBlobTxSidecar returns a copy of tx with the blob sidecar added.
+func (tx *Transaction) WithBlobTxSidecar(sideCar *BlobTxSidecar) *Transaction {
+ blobtx, ok := tx.inner.(*BlobTx)
+ if !ok {
+ return tx
+ }
+ cpy := &Transaction{
+ inner: blobtx.withSidecar(sideCar),
+ time: tx.time,
+ }
+ // Note: tx.size cache not carried over because the sidecar is included in size!
+ if h := tx.hash.Load(); h != nil {
+ cpy.hash.Store(h)
+ }
+ if f := tx.from.Load(); f != nil {
+ cpy.from.Store(f)
+ }
+ return cpy
+}
+
// SetTime sets the decoding time of a transaction. This is used by tests to set
// arbitrary times and by persistent transaction pools when loading old txs from
// disk.
@@ -462,7 +482,7 @@ func (tx *Transaction) Time() time.Time {
// Hash returns the transaction hash.
func (tx *Transaction) Hash() common.Hash {
if hash := tx.hash.Load(); hash != nil {
- return hash.(common.Hash)
+ return *hash
}
var h common.Hash
@@ -471,15 +491,15 @@ func (tx *Transaction) Hash() common.Hash {
} else {
h = prefixedRlpHash(tx.Type(), tx.inner)
}
- tx.hash.Store(h)
+ tx.hash.Store(&h)
return h
}
// Size returns the true encoded storage size of the transaction, either by encoding
// and returning it, or returning a previously cached value.
func (tx *Transaction) Size() uint64 {
- if size := tx.size.Load(); size != nil {
- return size.(uint64)
+ if size := tx.size.Load(); size > 0 {
+ return size
}
// Cache miss, encode and cache.
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
index 70dee0776e..6e5f6712f8 100644
--- a/core/types/transaction_signing.go
+++ b/core/types/transaction_signing.go
@@ -128,8 +128,7 @@ func MustSignNewTx(prv *ecdsa.PrivateKey, s Signer, txdata TxData) *Transaction
// signing method. The cache is invalidated if the cached signer does
// not match the signer used in the current call.
func Sender(signer Signer, tx *Transaction) (common.Address, error) {
- if sc := tx.from.Load(); sc != nil {
- sigCache := sc.(sigCache)
+ if sigCache := tx.from.Load(); sigCache != nil {
// If the signer used to derive from in a previous
// call is not the same as used current, invalidate
// the cache.
@@ -142,7 +141,7 @@ func Sender(signer Signer, tx *Transaction) (common.Address, error) {
if err != nil {
return common.Address{}, err
}
- tx.from.Store(sigCache{signer: signer, from: addr})
+ tx.from.Store(&sigCache{signer: signer, from: addr})
return addr, nil
}
diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go
index 76a010d2e5..361b977611 100644
--- a/core/types/transaction_test.go
+++ b/core/types/transaction_test.go
@@ -22,6 +22,7 @@ import (
"encoding/json"
"errors"
"fmt"
+ "maps"
"math/big"
"reflect"
"testing"
@@ -515,10 +516,7 @@ func TestYParityJSONUnmarshalling(t *testing.T) {
test := test
t.Run(fmt.Sprintf("txType=%d: %s", txType, test.name), func(t *testing.T) {
// Copy the base json
- testJson := make(map[string]interface{})
- for k, v := range baseJson {
- testJson[k] = v
- }
+ testJson := maps.Clone(baseJson)
// Set v, yParity and type
if test.v != "" {
diff --git a/core/types/tx_blob.go b/core/types/tx_blob.go
index 25a85695ef..ce1f287caa 100644
--- a/core/types/tx_blob.go
+++ b/core/types/tx_blob.go
@@ -191,6 +191,12 @@ func (tx *BlobTx) withoutSidecar() *BlobTx {
return &cpy
}
+func (tx *BlobTx) withSidecar(sideCar *BlobTxSidecar) *BlobTx {
+ cpy := *tx
+ cpy.Sidecar = sideCar
+ return &cpy
+}
+
func (tx *BlobTx) encode(b *bytes.Buffer) error {
if tx.Sidecar == nil {
return rlp.Encode(b, tx)
diff --git a/core/vm/contracts.go b/core/vm/contracts.go
index a6af31f584..bef8575bb5 100644
--- a/core/vm/contracts.go
+++ b/core/vm/contracts.go
@@ -111,15 +111,15 @@ var PrecompiledContractsCancun = map[common.Address]PrecompiledContract{
// PrecompiledContractsBLS contains the set of pre-compiled Ethereum
// contracts specified in EIP-2537. These are exported for testing purposes.
var PrecompiledContractsBLS = map[common.Address]PrecompiledContract{
- common.BytesToAddress([]byte{10}): &bls12381G1Add{},
- common.BytesToAddress([]byte{11}): &bls12381G1Mul{},
- common.BytesToAddress([]byte{12}): &bls12381G1MultiExp{},
- common.BytesToAddress([]byte{13}): &bls12381G2Add{},
- common.BytesToAddress([]byte{14}): &bls12381G2Mul{},
- common.BytesToAddress([]byte{15}): &bls12381G2MultiExp{},
- common.BytesToAddress([]byte{16}): &bls12381Pairing{},
- common.BytesToAddress([]byte{17}): &bls12381MapG1{},
- common.BytesToAddress([]byte{18}): &bls12381MapG2{},
+ common.BytesToAddress([]byte{11}): &bls12381G1Add{},
+ common.BytesToAddress([]byte{12}): &bls12381G1Mul{},
+ common.BytesToAddress([]byte{13}): &bls12381G1MultiExp{},
+ common.BytesToAddress([]byte{14}): &bls12381G2Add{},
+ common.BytesToAddress([]byte{15}): &bls12381G2Mul{},
+ common.BytesToAddress([]byte{16}): &bls12381G2MultiExp{},
+ common.BytesToAddress([]byte{17}): &bls12381Pairing{},
+ common.BytesToAddress([]byte{18}): &bls12381MapG1{},
+ common.BytesToAddress([]byte{19}): &bls12381MapG2{},
}
var (
@@ -182,7 +182,7 @@ func RunPrecompiledContract(p PrecompiledContract, input []byte, suppliedGas uin
return output, suppliedGas, err
}
-// ECRECOVER implemented as a native contract.
+// ecrecover implemented as a native contract.
type ecrecover struct{}
func (c *ecrecover) RequiredGas(input []byte) uint64 {
@@ -457,7 +457,7 @@ func runBn256Add(input []byte) ([]byte, error) {
return res.Marshal(), nil
}
-// bn256Add implements a native elliptic curve point addition conforming to
+// bn256AddIstanbul implements a native elliptic curve point addition conforming to
// Istanbul consensus rules.
type bn256AddIstanbul struct{}
diff --git a/core/vm/errors.go b/core/vm/errors.go
index ba3261c797..e5efc952d4 100644
--- a/core/vm/errors.go
+++ b/core/vm/errors.go
@@ -31,6 +31,7 @@ var (
ErrContractAddressCollision = errors.New("contract address collision")
ErrExecutionReverted = errors.New("execution reverted")
ErrMaxCodeSizeExceeded = errors.New("max code size exceeded")
+ ErrMaxInitCodeSizeExceeded = errors.New("max initcode size exceeded")
ErrInvalidJump = errors.New("invalid jump destination")
ErrWriteProtection = errors.New("write protection")
ErrReturnDataOutOfBounds = errors.New("return data out of bounds")
diff --git a/core/vm/evm.go b/core/vm/evm.go
index 25b5bc84e8..36bbf0d3da 100644
--- a/core/vm/evm.go
+++ b/core/vm/evm.go
@@ -439,13 +439,19 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64,
if evm.chainRules.IsBerlin {
evm.StateDB.AddAddressToAccessList(address)
}
- // Ensure there's no existing contract already at the designated address
+ // Ensure there's no existing contract already at the designated address.
+ // Account is regarded as existent if any of these three conditions is met:
+ // - the nonce is nonzero
+ // - the code is non-empty
+ // - the storage is non-empty
contractHash := evm.StateDB.GetCodeHash(address)
- if evm.StateDB.GetNonce(address) != 0 || (contractHash != (common.Hash{}) && contractHash != types.EmptyCodeHash) {
+ storageRoot := evm.StateDB.GetStorageRoot(address)
+ if evm.StateDB.GetNonce(address) != 0 ||
+ (contractHash != (common.Hash{}) && contractHash != types.EmptyCodeHash) || // non-empty code
+ (storageRoot != (common.Hash{}) && storageRoot != types.EmptyRootHash) { // non-empty storage
if evm.Config.Tracer != nil && evm.Config.Tracer.OnGasChange != nil {
evm.Config.Tracer.OnGasChange(gas, 0, tracing.GasChangeCallFailedExecution)
}
-
return nil, common.Address{}, 0, ErrContractAddressCollision
}
// Create a new account on the state
diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go
index 4b141d8f9a..fd5fa14cf5 100644
--- a/core/vm/gas_table.go
+++ b/core/vm/gas_table.go
@@ -18,6 +18,7 @@ package vm
import (
"errors"
+ "fmt"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/math"
@@ -310,9 +311,12 @@ func gasCreateEip3860(evm *EVM, contract *Contract, stack *Stack, mem *Memory, m
return 0, err
}
size, overflow := stack.Back(2).Uint64WithOverflow()
- if overflow || size > params.MaxInitCodeSize {
+ if overflow {
return 0, ErrGasUintOverflow
}
+ if size > params.MaxInitCodeSize {
+ return 0, fmt.Errorf("%w: size %d", ErrMaxInitCodeSizeExceeded, size)
+ }
// Since size <= params.MaxInitCodeSize, these multiplication cannot overflow
moreGas := params.InitCodeWordGas * ((size + 31) / 32)
if gas, overflow = math.SafeAdd(gas, moreGas); overflow {
@@ -326,9 +330,12 @@ func gasCreate2Eip3860(evm *EVM, contract *Contract, stack *Stack, mem *Memory,
return 0, err
}
size, overflow := stack.Back(2).Uint64WithOverflow()
- if overflow || size > params.MaxInitCodeSize {
+ if overflow {
return 0, ErrGasUintOverflow
}
+ if size > params.MaxInitCodeSize {
+ return 0, fmt.Errorf("%w: size %d", ErrMaxInitCodeSizeExceeded, size)
+ }
// Since size <= params.MaxInitCodeSize, these multiplication cannot overflow
moreGas := (params.InitCodeWordGas + params.Keccak256WordGas) * ((size + 31) / 32)
if gas, overflow = math.SafeAdd(gas, moreGas); overflow {
diff --git a/core/vm/gas_table_test.go b/core/vm/gas_table_test.go
index 4a2545b6ed..02fc94840d 100644
--- a/core/vm/gas_table_test.go
+++ b/core/vm/gas_table_test.go
@@ -18,6 +18,7 @@ package vm
import (
"bytes"
+ "errors"
"math"
"math/big"
"sort"
@@ -98,7 +99,7 @@ func TestEIP2200(t *testing.T) {
vmenv := NewEVM(vmctx, TxContext{}, statedb, params.AllEthashProtocolChanges, Config{ExtraEips: []int{2200}})
_, gas, err := vmenv.Call(AccountRef(common.Address{}), address, nil, tt.gaspool, new(uint256.Int))
- if err != tt.failure {
+ if !errors.Is(err, tt.failure) {
t.Errorf("test %d: failure mismatch: have %v, want %v", i, err, tt.failure)
}
if used := tt.gaspool - gas; used != tt.used {
diff --git a/core/vm/interface.go b/core/vm/interface.go
index d7028cc7c7..30742e96de 100644
--- a/core/vm/interface.go
+++ b/core/vm/interface.go
@@ -49,6 +49,7 @@ type StateDB interface {
GetCommittedState(common.Address, common.Hash) common.Hash
GetState(common.Address, common.Hash) common.Hash
SetState(common.Address, common.Hash, common.Hash)
+ GetStorageRoot(addr common.Address) common.Hash
GetTransientState(addr common.Address, key common.Hash) common.Hash
SetTransientState(addr common.Address, key, value common.Hash)
diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go
index 8b7f8b02bd..406927e321 100644
--- a/core/vm/interpreter.go
+++ b/core/vm/interpreter.go
@@ -17,6 +17,8 @@
package vm
import (
+ "fmt"
+
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/math"
"github.com/ethereum/go-ethereum/core/tracing"
@@ -50,7 +52,7 @@ func (ctx *ScopeContext) MemoryData() []byte {
return ctx.Memory.Data()
}
-// MemoryData returns the stack data. Callers must not modify the contents
+// StackData returns the stack data. Callers must not modify the contents
// of the returned data.
func (ctx *ScopeContext) StackData() []uint256.Int {
if ctx.Stack == nil {
@@ -255,7 +257,10 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
var dynamicCost uint64
dynamicCost, err = operation.dynamicGas(in.evm, contract, stack, mem, memorySize)
cost += dynamicCost // for tracing
- if err != nil || !contract.UseGas(dynamicCost, in.evm.Config.Tracer, tracing.GasChangeIgnored) {
+ if err != nil {
+ return nil, fmt.Errorf("%w: %v", ErrOutOfGas, err)
+ }
+ if !contract.UseGas(dynamicCost, in.evm.Config.Tracer, tracing.GasChangeIgnored) {
return nil, ErrOutOfGas
}
diff --git a/crypto/signature_nocgo.go b/crypto/signature_nocgo.go
index f70617019e..989057442b 100644
--- a/crypto/signature_nocgo.go
+++ b/crypto/signature_nocgo.go
@@ -167,7 +167,7 @@ type btCurve struct {
*btcec.KoblitzCurve
}
-// Marshall converts a point given as (x, y) into a byte slice.
+// Marshal converts a point given as (x, y) into a byte slice.
func (curve btCurve) Marshal(x, y *big.Int) []byte {
byteLen := (curve.Params().BitSize + 7) / 8
diff --git a/crypto/signify/signify_fuzz.go b/crypto/signify/signify_fuzz.go
index 457af044d1..239a2134df 100644
--- a/crypto/signify/signify_fuzz.go
+++ b/crypto/signify/signify_fuzz.go
@@ -134,6 +134,7 @@ func createKeyPair() (string, string) {
defer os.Remove(tmpKey.Name())
defer os.Remove(tmpKey.Name() + ".pub")
defer os.Remove(tmpKey.Name() + ".sec")
+ defer tmpKey.Close()
cmd := exec.Command("signify", "-G", "-n", "-p", tmpKey.Name()+".pub", "-s", tmpKey.Name()+".sec")
if output, err := cmd.CombinedOutput(); err != nil {
panic(fmt.Sprintf("could not verify the file: %v, output: \n%s", err, output))
diff --git a/eth/api_debug_test.go b/eth/api_debug_test.go
index 1d75c4c041..750cee5e44 100644
--- a/eth/api_debug_test.go
+++ b/eth/api_debug_test.go
@@ -20,6 +20,7 @@ import (
"bytes"
"fmt"
"reflect"
+ "slices"
"strings"
"testing"
@@ -32,7 +33,6 @@ import (
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/triedb"
"github.com/holiman/uint256"
- "golang.org/x/exp/slices"
)
var dumper = spew.ConfigState{Indent: " "}
diff --git a/eth/backend.go b/eth/backend.go
index e6f9c05950..04ee82efee 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -101,8 +101,8 @@ type Ethereum struct {
shutdownTracker *shutdowncheck.ShutdownTracker // Tracks if and when the node has shutdown ungracefully
}
-// New creates a new Ethereum object (including the
-// initialisation of the common Ethereum object)
+// New creates a new Ethereum object (including the initialisation of the common Ethereum object),
+// whose lifecycle will be managed by the provided node.
func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
// Ensure configuration values are compatible and sane
if config.SyncMode == downloader.LightSync {
@@ -111,7 +111,7 @@ func New(stack *node.Node, config *ethconfig.Config) (*Ethereum, error) {
if !config.SyncMode.IsValid() {
return nil, fmt.Errorf("invalid sync mode %d", config.SyncMode)
}
- if config.Miner.GasPrice == nil || config.Miner.GasPrice.Cmp(common.Big0) <= 0 {
+ if config.Miner.GasPrice == nil || config.Miner.GasPrice.Sign() <= 0 {
log.Warn("Sanitizing invalid miner gas price", "provided", config.Miner.GasPrice, "updated", ethconfig.Defaults.Miner.GasPrice)
config.Miner.GasPrice = new(big.Int).Set(ethconfig.Defaults.Miner.GasPrice)
}
diff --git a/eth/catalyst/simulated_beacon.go b/eth/catalyst/simulated_beacon.go
index 4ae60ed490..fecd83f276 100644
--- a/eth/catalyst/simulated_beacon.go
+++ b/eth/catalyst/simulated_beacon.go
@@ -63,7 +63,7 @@ func (w *withdrawalQueue) gatherPending(maxCount int) []*types.Withdrawal {
case withdrawal := <-w.pending:
withdrawals = append(withdrawals, withdrawal)
if len(withdrawals) == maxCount {
- break
+ return withdrawals
}
default:
return withdrawals
diff --git a/eth/catalyst/simulated_beacon_test.go b/eth/catalyst/simulated_beacon_test.go
index df682b49d9..bb10938c35 100644
--- a/eth/catalyst/simulated_beacon_test.go
+++ b/eth/catalyst/simulated_beacon_test.go
@@ -74,7 +74,7 @@ func startSimulatedBeaconEthService(t *testing.T, genesis *core.Genesis) (*node.
// send enough transactions to fill multiple blocks
func TestSimulatedBeaconSendWithdrawals(t *testing.T) {
var withdrawals []types.Withdrawal
- txs := make(map[common.Hash]types.Transaction)
+ txs := make(map[common.Hash]*types.Transaction)
var (
// testKey is a private key to use for funding a tester account.
@@ -110,7 +110,7 @@ func TestSimulatedBeaconSendWithdrawals(t *testing.T) {
if err != nil {
t.Fatalf("error signing transaction, err=%v", err)
}
- txs[tx.Hash()] = *tx
+ txs[tx.Hash()] = tx
if err := ethService.APIBackend.SendTx(context.Background(), tx); err != nil {
t.Fatal("SendTx failed", err)
diff --git a/eth/downloader/beaconsync.go b/eth/downloader/beaconsync.go
index d3f75c8527..7dfc419f4e 100644
--- a/eth/downloader/beaconsync.go
+++ b/eth/downloader/beaconsync.go
@@ -289,6 +289,9 @@ func (d *Downloader) fetchBeaconHeaders(from uint64) error {
localHeaders = d.readHeaderRange(tail, int(count))
log.Warn("Retrieved beacon headers from local", "from", from, "count", count)
}
+ fsHeaderContCheckTimer := time.NewTimer(fsHeaderContCheck)
+ defer fsHeaderContCheckTimer.Stop()
+
for {
// Some beacon headers might have appeared since the last cycle, make
// sure we're always syncing to all available ones
@@ -381,8 +384,9 @@ func (d *Downloader) fetchBeaconHeaders(from uint64) error {
}
// State sync still going, wait a bit for new headers and retry
log.Trace("Pivot not yet committed, waiting...")
+ fsHeaderContCheckTimer.Reset(fsHeaderContCheck)
select {
- case <-time.After(fsHeaderContCheck):
+ case <-fsHeaderContCheckTimer.C:
case <-d.cancelCh:
return errCanceled
}
diff --git a/eth/downloader/downloader.go b/eth/downloader/downloader.go
index 6b26822e22..941f575aa8 100644
--- a/eth/downloader/downloader.go
+++ b/eth/downloader/downloader.go
@@ -1276,7 +1276,10 @@ func (d *Downloader) processHeaders(origin uint64, td, ttd *big.Int, beaconMode
var (
mode = d.getMode()
gotHeaders = false // Wait for batches of headers to process
+ timer = time.NewTimer(time.Second)
)
+ defer timer.Stop()
+
for {
select {
case <-d.cancelCh:
@@ -1397,10 +1400,11 @@ func (d *Downloader) processHeaders(origin uint64, td, ttd *big.Int, beaconMode
if mode == FullSync || mode == SnapSync {
// If we've reached the allowed number of pending headers, stall a bit
for d.queue.PendingBodies() >= maxQueuedHeaders || d.queue.PendingReceipts() >= maxQueuedHeaders {
+ timer.Reset(time.Second)
select {
case <-d.cancelCh:
return errCanceled
- case <-time.After(time.Second):
+ case <-timer.C:
}
}
// Otherwise insert the headers for content retrieval
@@ -1567,7 +1571,10 @@ func (d *Downloader) processSnapSyncContent() error {
var (
oldPivot *fetchResult // Locked in pivot block, might change eventually
oldTail []*fetchResult // Downloaded content after the pivot
+ timer = time.NewTimer(time.Second)
)
+ defer timer.Stop()
+
for {
// Wait for the next batch of downloaded data to be available. If we have
// not yet reached the pivot point, wait blockingly as there's no need to
@@ -1650,6 +1657,7 @@ func (d *Downloader) processSnapSyncContent() error {
oldPivot = P
}
// Wait for completion, occasionally checking for pivot staleness
+ timer.Reset(time.Second)
select {
case <-sync.done:
if sync.err != nil {
@@ -1660,7 +1668,7 @@ func (d *Downloader) processSnapSyncContent() error {
}
oldPivot = nil
- case <-time.After(time.Second):
+ case <-timer.C:
oldTail = afterP
continue
}
diff --git a/eth/downloader/downloader_test.go b/eth/downloader/downloader_test.go
index 2468e1a980..0fdc7ead9c 100644
--- a/eth/downloader/downloader_test.go
+++ b/eth/downloader/downloader_test.go
@@ -57,7 +57,7 @@ func newTester(t *testing.T) *downloadTester {
return newTesterWithNotification(t, nil)
}
-// newTester creates a new downloader test mocker.
+// newTesterWithNotification creates a new downloader test mocker.
func newTesterWithNotification(t *testing.T, success func()) *downloadTester {
freezer := t.TempDir()
db, err := rawdb.NewDatabaseWithFreezer(rawdb.NewMemoryDatabase(), freezer, "", false)
diff --git a/eth/downloader/skeleton_test.go b/eth/downloader/skeleton_test.go
index 2b108dfe93..3693ab095f 100644
--- a/eth/downloader/skeleton_test.go
+++ b/eth/downloader/skeleton_test.go
@@ -94,7 +94,7 @@ func newSkeletonTestPeer(id string, headers []*types.Header) *skeletonTestPeer {
}
}
-// newSkeletonTestPeer creates a new mock peer to test the skeleton sync with,
+// newSkeletonTestPeerWithHook creates a new mock peer to test the skeleton sync with,
// and sets an optional serve hook that can return headers for delivery instead
// of the predefined chain. Useful for emulating malicious behavior that would
// otherwise require dedicated peer types.
diff --git a/eth/fetcher/tx_fetcher_test.go b/eth/fetcher/tx_fetcher_test.go
index 4a62e579b6..3d3ef81ede 100644
--- a/eth/fetcher/tx_fetcher_test.go
+++ b/eth/fetcher/tx_fetcher_test.go
@@ -20,6 +20,7 @@ import (
"errors"
"math/big"
"math/rand"
+ "slices"
"testing"
"time"
@@ -1823,12 +1824,12 @@ func testTransactionFetcher(t *testing.T, tt txFetcherTest) {
continue
}
for _, hash := range hashes {
- if !containsHash(request.hashes, hash) {
+ if !slices.Contains(request.hashes, hash) {
t.Errorf("step %d, peer %s: hash %x missing from requests", i, peer, hash)
}
}
for _, hash := range request.hashes {
- if !containsHash(hashes, hash) {
+ if !slices.Contains(hashes, hash) {
t.Errorf("step %d, peer %s: hash %x extra in requests", i, peer, hash)
}
}
@@ -1850,7 +1851,7 @@ func testTransactionFetcher(t *testing.T, tt txFetcherTest) {
for hash := range fetcher.fetching {
var found bool
for _, req := range fetcher.requests {
- if containsHash(req.hashes, hash) {
+ if slices.Contains(req.hashes, hash) {
found = true
break
}
@@ -1891,12 +1892,12 @@ func testTransactionFetcher(t *testing.T, tt txFetcherTest) {
continue
}
for _, hash := range hashes {
- if !containsHash(request.hashes, hash) {
+ if !slices.Contains(request.hashes, hash) {
t.Errorf("step %d, peer %s: hash %x missing from requests", i, peer, hash)
}
}
for _, hash := range request.hashes {
- if !containsHash(hashes, hash) {
+ if !slices.Contains(hashes, hash) {
t.Errorf("step %d, peer %s: hash %x extra in requests", i, peer, hash)
}
}
@@ -1909,7 +1910,7 @@ func testTransactionFetcher(t *testing.T, tt txFetcherTest) {
for _, ann := range announces {
var found bool
for _, hs := range step.fetching {
- if containsHash(hs, ann.hash) {
+ if slices.Contains(hs, ann.hash) {
found = true
break
}
@@ -1925,7 +1926,7 @@ func testTransactionFetcher(t *testing.T, tt txFetcherTest) {
}
}
for hash := range fetcher.announced {
- if !containsHash(queued, hash) {
+ if !slices.Contains(queued, hash) {
t.Errorf("step %d: hash %x extra in announced", i, hash)
}
}
@@ -1984,16 +1985,6 @@ func containsHashInAnnounces(slice []announce, hash common.Hash) bool {
return false
}
-// containsHash returns whether a hash is contained within a hash slice.
-func containsHash(slice []common.Hash, hash common.Hash) bool {
- for _, have := range slice {
- if have == hash {
- return true
- }
- }
- return false
-}
-
// Tests that a transaction is forgotten after the timeout.
func TestTransactionForgotten(t *testing.T) {
fetcher := NewTxFetcher(
diff --git a/eth/filters/filter.go b/eth/filters/filter.go
index f2b92d5a99..2f59026b73 100644
--- a/eth/filters/filter.go
+++ b/eth/filters/filter.go
@@ -20,6 +20,7 @@ import (
"context"
"errors"
"math/big"
+ "slices"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/bloombits"
@@ -347,16 +348,6 @@ func (f *Filter) pendingLogs() []*types.Log {
return nil
}
-// includes returns true if the element is present in the list.
-func includes[T comparable](things []T, element T) bool {
- for _, thing := range things {
- if thing == element {
- return true
- }
- }
- return false
-}
-
// filterLogs creates a slice of logs matching the given criteria.
func filterLogs(logs []*types.Log, fromBlock, toBlock *big.Int, addresses []common.Address, topics [][]common.Hash) []*types.Log {
var check = func(log *types.Log) bool {
@@ -366,7 +357,7 @@ func filterLogs(logs []*types.Log, fromBlock, toBlock *big.Int, addresses []comm
if toBlock != nil && toBlock.Int64() >= 0 && toBlock.Uint64() < log.BlockNumber {
return false
}
- if len(addresses) > 0 && !includes(addresses, log.Address) {
+ if len(addresses) > 0 && !slices.Contains(addresses, log.Address) {
return false
}
// If the to filtered topics is greater than the amount of topics in logs, skip.
@@ -377,7 +368,7 @@ func filterLogs(logs []*types.Log, fromBlock, toBlock *big.Int, addresses []comm
if len(sub) == 0 {
continue // empty rule set == wildcard
}
- if !includes(sub, log.Topics[i]) {
+ if !slices.Contains(sub, log.Topics[i]) {
return false
}
}
diff --git a/eth/filters/filter_system.go b/eth/filters/filter_system.go
index c32b837eb4..d8b41a4259 100644
--- a/eth/filters/filter_system.go
+++ b/eth/filters/filter_system.go
@@ -95,7 +95,7 @@ func NewFilterSystem(backend Backend, config Config) *FilterSystem {
type logCacheElem struct {
logs []*types.Log
- body atomic.Value
+ body atomic.Pointer[types.Body]
}
// cachedLogElem loads block logs from the backend and caches the result.
@@ -133,7 +133,7 @@ func (sys *FilterSystem) cachedLogElem(ctx context.Context, blockHash common.Has
func (sys *FilterSystem) cachedGetBody(ctx context.Context, elem *logCacheElem, hash common.Hash, number uint64) (*types.Body, error) {
if body := elem.body.Load(); body != nil {
- return body.(*types.Body), nil
+ return body, nil
}
body, err := sys.backend.GetBody(ctx, hash, rpc.BlockNumber(number))
if err != nil {
diff --git a/eth/filters/filter_system_test.go b/eth/filters/filter_system_test.go
index 6238c97735..4a0f40cce9 100644
--- a/eth/filters/filter_system_test.go
+++ b/eth/filters/filter_system_test.go
@@ -442,7 +442,7 @@ func TestInvalidLogFilterCreation(t *testing.T) {
}
}
-// TestLogFilterUninstall tests invalid getLogs requests
+// TestInvalidGetLogsRequest tests invalid getLogs requests
func TestInvalidGetLogsRequest(t *testing.T) {
t.Parallel()
diff --git a/eth/gasprice/feehistory.go b/eth/gasprice/feehistory.go
index 8ab57294b7..1c7f8ba42a 100644
--- a/eth/gasprice/feehistory.go
+++ b/eth/gasprice/feehistory.go
@@ -23,6 +23,7 @@ import (
"fmt"
"math"
"math/big"
+ "slices"
"sync/atomic"
"github.com/ethereum/go-ethereum/common"
@@ -30,7 +31,6 @@ import (
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/rpc"
- "golang.org/x/exp/slices"
)
var (
diff --git a/eth/gasprice/gasprice.go b/eth/gasprice/gasprice.go
index 3fa70e41a0..c90408e363 100644
--- a/eth/gasprice/gasprice.go
+++ b/eth/gasprice/gasprice.go
@@ -19,6 +19,7 @@ package gasprice
import (
"context"
"math/big"
+ "slices"
"sync"
"github.com/ethereum/go-ethereum/common"
@@ -30,7 +31,6 @@ import (
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rpc"
- "golang.org/x/exp/slices"
)
const sampleNumber = 3 // Number of transactions sampled in a block
diff --git a/eth/handler.go b/eth/handler.go
index 0d27e061c4..c7c582af40 100644
--- a/eth/handler.go
+++ b/eth/handler.go
@@ -466,9 +466,7 @@ func (h *handler) BroadcastTransactions(txs types.Transactions) {
largeTxs int // Number of large transactions to announce only
directCount int // Number of transactions sent directly to peers (duplicates included)
- directPeers int // Number of peers that were sent transactions directly
annCount int // Number of transactions announced across all peers (duplicates included)
- annPeers int // Number of peers announced about transactions
txset = make(map[*ethPeer][]common.Hash) // Set peer->hash to transfer directly
annos = make(map[*ethPeer][]common.Hash) // Set peer->hash to announce
@@ -525,17 +523,15 @@ func (h *handler) BroadcastTransactions(txs types.Transactions) {
}
}
for peer, hashes := range txset {
- directPeers++
directCount += len(hashes)
peer.AsyncSendTransactions(hashes)
}
for peer, hashes := range annos {
- annPeers++
annCount += len(hashes)
peer.AsyncSendPooledTransactionHashes(hashes)
}
log.Debug("Distributed transactions", "plaintxs", len(txs)-blobTxs-largeTxs, "blobtxs", blobTxs, "largetxs", largeTxs,
- "bcastpeers", directPeers, "bcastcount", directCount, "annpeers", annPeers, "anncount", annCount)
+ "bcastpeers", len(txset), "bcastcount", directCount, "annpeers", len(annos), "anncount", annCount)
}
// txBroadcastLoop announces new transactions to connected peers.
diff --git a/eth/handler_eth_test.go b/eth/handler_eth_test.go
index 297a6bf154..a38059ca95 100644
--- a/eth/handler_eth_test.go
+++ b/eth/handler_eth_test.go
@@ -390,7 +390,7 @@ func testTransactionPropagation(t *testing.T, protocol uint) {
}
// Interconnect all the sink handlers with the source handler
for i, sink := range sinks {
- sink := sink // Closure for gorotuine below
+ sink := sink // Closure for goroutine below
sourcePipe, sinkPipe := p2p.MsgPipe()
defer sourcePipe.Close()
diff --git a/eth/protocols/eth/handler_test.go b/eth/protocols/eth/handler_test.go
index fdf551ef21..934dadc9a5 100644
--- a/eth/protocols/eth/handler_test.go
+++ b/eth/protocols/eth/handler_test.go
@@ -63,7 +63,7 @@ func newTestBackend(blocks int) *testBackend {
return newTestBackendWithGenerator(blocks, false, nil)
}
-// newTestBackend creates a chain with a number of explicitly defined blocks and
+// newTestBackendWithGenerator creates a chain with a number of explicitly defined blocks and
// wraps it into a mock backend.
func newTestBackendWithGenerator(blocks int, shanghai bool, generator func(int, *core.BlockGen)) *testBackend {
var (
diff --git a/eth/protocols/snap/metrics.go b/eth/protocols/snap/metrics.go
index a8dc2b5824..19e9151824 100644
--- a/eth/protocols/snap/metrics.go
+++ b/eth/protocols/snap/metrics.go
@@ -54,4 +54,9 @@ var (
// skipStorageHealingGauge is the metric to track how many storages are retrieved
// in multiple requests but healing is not necessary.
skipStorageHealingGauge = metrics.NewRegisteredGauge("eth/protocols/snap/sync/storage/noheal", nil)
+
+ // largeStorageDiscardGauge is the metric to track how many chunked storages are
+ // discarded during the snap sync.
+ largeStorageDiscardGauge = metrics.NewRegisteredGauge("eth/protocols/snap/sync/storage/chunk/discard", nil)
+ largeStorageResumedGauge = metrics.NewRegisteredGauge("eth/protocols/snap/sync/storage/chunk/resume", nil)
)
diff --git a/eth/protocols/snap/progress_test.go b/eth/protocols/snap/progress_test.go
new file mode 100644
index 0000000000..9d923bd2f5
--- /dev/null
+++ b/eth/protocols/snap/progress_test.go
@@ -0,0 +1,154 @@
+// Copyright 2024 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see .
+
+package snap
+
+import (
+ "encoding/json"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+)
+
+// Legacy sync progress definitions
+type legacyStorageTask struct {
+ Next common.Hash // Next account to sync in this interval
+ Last common.Hash // Last account to sync in this interval
+}
+
+type legacyAccountTask struct {
+ Next common.Hash // Next account to sync in this interval
+ Last common.Hash // Last account to sync in this interval
+ SubTasks map[common.Hash][]*legacyStorageTask // Storage intervals needing fetching for large contracts
+}
+
+type legacyProgress struct {
+ Tasks []*legacyAccountTask // The suspended account tasks (contract tasks within)
+}
+
+func compareProgress(a legacyProgress, b SyncProgress) bool {
+ if len(a.Tasks) != len(b.Tasks) {
+ return false
+ }
+ for i := 0; i < len(a.Tasks); i++ {
+ if a.Tasks[i].Next != b.Tasks[i].Next {
+ return false
+ }
+ if a.Tasks[i].Last != b.Tasks[i].Last {
+ return false
+ }
+ // new fields are not checked here
+
+ if len(a.Tasks[i].SubTasks) != len(b.Tasks[i].SubTasks) {
+ return false
+ }
+ for addrHash, subTasksA := range a.Tasks[i].SubTasks {
+ subTasksB, ok := b.Tasks[i].SubTasks[addrHash]
+ if !ok || len(subTasksB) != len(subTasksA) {
+ return false
+ }
+ for j := 0; j < len(subTasksA); j++ {
+ if subTasksA[j].Next != subTasksB[j].Next {
+ return false
+ }
+ if subTasksA[j].Last != subTasksB[j].Last {
+ return false
+ }
+ }
+ }
+ }
+ return true
+}
+
+func makeLegacyProgress() legacyProgress {
+ return legacyProgress{
+ Tasks: []*legacyAccountTask{
+ {
+ Next: common.Hash{},
+ Last: common.Hash{0x77},
+ SubTasks: map[common.Hash][]*legacyStorageTask{
+ common.Hash{0x1}: {
+ {
+ Next: common.Hash{},
+ Last: common.Hash{0xff},
+ },
+ },
+ },
+ },
+ {
+ Next: common.Hash{0x88},
+ Last: common.Hash{0xff},
+ },
+ },
+ }
+}
+
+func convertLegacy(legacy legacyProgress) SyncProgress {
+ var progress SyncProgress
+ for i, task := range legacy.Tasks {
+ subTasks := make(map[common.Hash][]*storageTask)
+ for owner, list := range task.SubTasks {
+ var cpy []*storageTask
+ for i := 0; i < len(list); i++ {
+ cpy = append(cpy, &storageTask{
+ Next: list[i].Next,
+ Last: list[i].Last,
+ })
+ }
+ subTasks[owner] = cpy
+ }
+ accountTask := &accountTask{
+ Next: task.Next,
+ Last: task.Last,
+ SubTasks: subTasks,
+ }
+ if i == 0 {
+ accountTask.StorageCompleted = []common.Hash{{0xaa}, {0xbb}} // fulfill new fields
+ }
+ progress.Tasks = append(progress.Tasks, accountTask)
+ }
+ return progress
+}
+
+func TestSyncProgressCompatibility(t *testing.T) {
+ // Decode serialized bytes of legacy progress, backward compatibility
+ legacy := makeLegacyProgress()
+ blob, err := json.Marshal(legacy)
+ if err != nil {
+ t.Fatalf("Failed to marshal progress %v", err)
+ }
+ var dec SyncProgress
+ if err := json.Unmarshal(blob, &dec); err != nil {
+ t.Fatalf("Failed to unmarshal progress %v", err)
+ }
+ if !compareProgress(legacy, dec) {
+ t.Fatal("sync progress is not backward compatible")
+ }
+
+ // Decode serialized bytes of new format progress
+ progress := convertLegacy(legacy)
+ blob, err = json.Marshal(progress)
+ if err != nil {
+ t.Fatalf("Failed to marshal progress %v", err)
+ }
+ var legacyDec legacyProgress
+ if err := json.Unmarshal(blob, &legacyDec); err != nil {
+ t.Fatalf("Failed to unmarshal progress %v", err)
+ }
+ if !compareProgress(legacyDec, progress) {
+ t.Fatal("sync progress is not forward compatible")
+ }
+}
diff --git a/eth/protocols/snap/sync.go b/eth/protocols/snap/sync.go
index 887a50775d..d5d6fd6d69 100644
--- a/eth/protocols/snap/sync.go
+++ b/eth/protocols/snap/sync.go
@@ -295,11 +295,19 @@ type bytecodeHealResponse struct {
// accountTask represents the sync task for a chunk of the account snapshot.
type accountTask struct {
- // These fields get serialized to leveldb on shutdown
+ // These fields get serialized to key-value store on shutdown
Next common.Hash // Next account to sync in this interval
Last common.Hash // Last account to sync in this interval
SubTasks map[common.Hash][]*storageTask // Storage intervals needing fetching for large contracts
+ // This is a list of account hashes whose storage are already completed
+ // in this cycle. This field is newly introduced in v1.14 and will be
+ // empty if the task is resolved from legacy progress data. Furthermore,
+ // this additional field will be ignored by legacy Geth. The only side
+ // effect is that these contracts might be resynced in the new cycle,
+ // retaining the legacy behavior.
+ StorageCompleted []common.Hash `json:",omitempty"`
+
// These fields are internals used during runtime
req *accountRequest // Pending request to fill this task
res *accountResponse // Validate response filling this task
@@ -309,8 +317,9 @@ type accountTask struct {
needState []bool // Flags whether the filling accounts need storage retrieval
needHeal []bool // Flags whether the filling accounts's state was chunked and need healing
- codeTasks map[common.Hash]struct{} // Code hashes that need retrieval
- stateTasks map[common.Hash]common.Hash // Account hashes->roots that need full state retrieval
+ codeTasks map[common.Hash]struct{} // Code hashes that need retrieval
+ stateTasks map[common.Hash]common.Hash // Account hashes->roots that need full state retrieval
+ stateCompleted map[common.Hash]struct{} // Account hashes whose storage have been completed
genBatch ethdb.Batch // Batch used by the node generator
genTrie *trie.StackTrie // Node generator from storage slots
@@ -318,6 +327,30 @@ type accountTask struct {
done bool // Flag whether the task can be removed
}
+// activeSubTasks returns the set of storage tasks covered by the current account
+// range. Normally this would be the entire subTask set, but on a sync interrupt
+// and later resume it can happen that a shorter account range is retrieved. This
+// method ensures that we only start up the subtasks covered by the latest account
+// response.
+//
+// Nil is returned if the account range is empty.
+func (task *accountTask) activeSubTasks() map[common.Hash][]*storageTask {
+ if len(task.res.hashes) == 0 {
+ return nil
+ }
+ var (
+ tasks = make(map[common.Hash][]*storageTask)
+ last = task.res.hashes[len(task.res.hashes)-1]
+ )
+ for hash, subTasks := range task.SubTasks {
+ subTasks := subTasks // closure
+ if hash.Cmp(last) <= 0 {
+ tasks[hash] = subTasks
+ }
+ }
+ return tasks
+}
+
// storageTask represents the sync task for a chunk of the storage snapshot.
type storageTask struct {
Next common.Hash // Next account to sync in this interval
@@ -745,6 +778,14 @@ func (s *Syncer) loadSyncStatus() {
for _, task := range s.tasks {
task := task // closure for task.genBatch in the stacktrie writer callback
+ // Restore the completed storages
+ task.stateCompleted = make(map[common.Hash]struct{})
+ for _, hash := range task.StorageCompleted {
+ task.stateCompleted[hash] = struct{}{}
+ }
+ task.StorageCompleted = nil
+
+ // Allocate batch for account trie generation
task.genBatch = ethdb.HookedBatch{
Batch: s.db.NewBatch(),
OnPut: func(key []byte, value []byte) {
@@ -767,6 +808,8 @@ func (s *Syncer) loadSyncStatus() {
options = options.WithSkipBoundary(task.Next != (common.Hash{}), task.Last != common.MaxHash, boundaryAccountNodesGauge)
}
task.genTrie = trie.NewStackTrie(options)
+
+ // Restore leftover storage tasks
for accountHash, subtasks := range task.SubTasks {
for _, subtask := range subtasks {
subtask := subtask // closure for subtask.genBatch in the stacktrie writer callback
@@ -861,11 +904,12 @@ func (s *Syncer) loadSyncStatus() {
options = options.WithSkipBoundary(next != common.Hash{}, last != common.MaxHash, boundaryAccountNodesGauge)
}
s.tasks = append(s.tasks, &accountTask{
- Next: next,
- Last: last,
- SubTasks: make(map[common.Hash][]*storageTask),
- genBatch: batch,
- genTrie: trie.NewStackTrie(options),
+ Next: next,
+ Last: last,
+ SubTasks: make(map[common.Hash][]*storageTask),
+ genBatch: batch,
+ stateCompleted: make(map[common.Hash]struct{}),
+ genTrie: trie.NewStackTrie(options),
})
log.Debug("Created account sync task", "from", next, "last", last)
next = common.BigToHash(new(big.Int).Add(last.Big(), common.Big1))
@@ -886,6 +930,14 @@ func (s *Syncer) saveSyncStatus() {
}
}
}
+ // Save the account hashes of completed storage.
+ task.StorageCompleted = make([]common.Hash, 0, len(task.stateCompleted))
+ for hash := range task.stateCompleted {
+ task.StorageCompleted = append(task.StorageCompleted, hash)
+ }
+ if len(task.StorageCompleted) > 0 {
+ log.Debug("Leftover completed storages", "number", len(task.StorageCompleted), "next", task.Next, "last", task.Last)
+ }
}
// Store the actual progress markers
progress := &SyncProgress{
@@ -970,6 +1022,10 @@ func (s *Syncer) cleanStorageTasks() {
delete(task.SubTasks, account)
task.pend--
+ // Mark the state as complete to prevent resyncing, regardless
+ // if state healing is necessary.
+ task.stateCompleted[account] = struct{}{}
+
// If this was the last pending task, forward the account task
if task.pend == 0 {
s.forwardAccountTask(task)
@@ -1209,7 +1265,8 @@ func (s *Syncer) assignStorageTasks(success chan *storageResponse, fail chan *st
continue
}
// Skip tasks that are already retrieving (or done with) all small states
- if len(task.SubTasks) == 0 && len(task.stateTasks) == 0 {
+ storageTasks := task.activeSubTasks()
+ if len(storageTasks) == 0 && len(task.stateTasks) == 0 {
continue
}
// Task pending retrieval, try to find an idle peer. If no such peer
@@ -1253,7 +1310,7 @@ func (s *Syncer) assignStorageTasks(success chan *storageResponse, fail chan *st
roots = make([]common.Hash, 0, storageSets)
subtask *storageTask
)
- for account, subtasks := range task.SubTasks {
+ for account, subtasks := range storageTasks {
for _, st := range subtasks {
// Skip any subtasks already filling
if st.req != nil {
@@ -1850,11 +1907,11 @@ func (s *Syncer) processAccountResponse(res *accountResponse) {
res.task.res = res
// Ensure that the response doesn't overflow into the subsequent task
- last := res.task.Last.Big()
+ lastBig := res.task.Last.Big()
for i, hash := range res.hashes {
// Mark the range complete if the last is already included.
// Keep iteration to delete the extra states if exists.
- cmp := hash.Big().Cmp(last)
+ cmp := hash.Big().Cmp(lastBig)
if cmp == 0 {
res.cont = false
continue
@@ -1890,7 +1947,21 @@ func (s *Syncer) processAccountResponse(res *accountResponse) {
}
// Check if the account is a contract with an unknown storage trie
if account.Root != types.EmptyRootHash {
- if !rawdb.HasTrieNode(s.db, res.hashes[i], nil, account.Root, s.scheme) {
+ // If the storage was already retrieved in the last cycle, there's no need
+ // to resync it again, regardless of whether the storage root is consistent
+ // or not.
+ if _, exist := res.task.stateCompleted[res.hashes[i]]; exist {
+ // The leftover storage tasks are not expected, unless system is
+ // very wrong.
+ if _, ok := res.task.SubTasks[res.hashes[i]]; ok {
+ panic(fmt.Errorf("unexpected leftover storage tasks, owner: %x", res.hashes[i]))
+ }
+ // Mark the healing tag if storage root node is inconsistent, or
+ // it's non-existent due to storage chunking.
+ if !rawdb.HasTrieNode(s.db, res.hashes[i], nil, account.Root, s.scheme) {
+ res.task.needHeal[i] = true
+ }
+ } else {
// If there was a previous large state retrieval in progress,
// don't restart it from scratch. This happens if a sync cycle
// is interrupted and resumed later. However, *do* update the
@@ -1902,7 +1973,12 @@ func (s *Syncer) processAccountResponse(res *accountResponse) {
}
res.task.needHeal[i] = true
resumed[res.hashes[i]] = struct{}{}
+ largeStorageResumedGauge.Inc(1)
} else {
+ // It's possible that in the hash scheme, the storage, along
+ // with the trie nodes of the given root, is already present
+ // in the database. Schedule the storage task anyway to simplify
+ // the logic here.
res.task.stateTasks[res.hashes[i]] = account.Root
}
res.task.needState[i] = true
@@ -1910,13 +1986,29 @@ func (s *Syncer) processAccountResponse(res *accountResponse) {
}
}
}
- // Delete any subtasks that have been aborted but not resumed. This may undo
- // some progress if a new peer gives us less accounts than an old one, but for
- // now we have to live with that.
- for hash := range res.task.SubTasks {
- if _, ok := resumed[hash]; !ok {
- log.Debug("Aborting suspended storage retrieval", "account", hash)
- delete(res.task.SubTasks, hash)
+ // Delete any subtasks that have been aborted but not resumed. It's essential
+ // as the corresponding contract might be self-destructed in this cycle(it's
+ // no longer possible in ethereum as self-destruction is disabled in Cancun
+ // Fork, but the condition is still necessary for other networks).
+ //
+ // Keep the leftover storage tasks if they are not covered by the responded
+ // account range which should be picked up in next account wave.
+ if len(res.hashes) > 0 {
+ // The hash of last delivered account in the response
+ last := res.hashes[len(res.hashes)-1]
+ for hash := range res.task.SubTasks {
+ // TODO(rjl493456442) degrade the log level before merging.
+ if hash.Cmp(last) > 0 {
+ log.Info("Keeping suspended storage retrieval", "account", hash)
+ continue
+ }
+ // TODO(rjl493456442) degrade the log level before merging.
+ // It should never happen in ethereum.
+ if _, ok := resumed[hash]; !ok {
+ log.Error("Aborting suspended storage retrieval", "account", hash)
+ delete(res.task.SubTasks, hash)
+ largeStorageDiscardGauge.Inc(1)
+ }
}
}
// If the account range contained no contracts, or all have been fully filled
@@ -2014,6 +2106,7 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
if res.subTask == nil && res.mainTask.needState[j] && (i < len(res.hashes)-1 || !res.cont) {
res.mainTask.needState[j] = false
res.mainTask.pend--
+ res.mainTask.stateCompleted[account] = struct{}{} // mark it as completed
smallStorageGauge.Inc(1)
}
// If the last contract was chunked, mark it as needing healing
@@ -2201,7 +2294,7 @@ func (s *Syncer) processStorageResponse(res *storageResponse) {
// If the chunk's root is an overflown but full delivery,
// clear the heal request.
accountHash := res.accounts[len(res.accounts)-1]
- if root == res.subTask.root && rawdb.HasStorageTrieNode(s.db, accountHash, nil, root) {
+ if root == res.subTask.root && rawdb.HasTrieNode(s.db, accountHash, nil, root, s.scheme) {
for i, account := range res.mainTask.res.hashes {
if account == accountHash {
res.mainTask.needHeal[i] = false
@@ -2409,10 +2502,19 @@ func (s *Syncer) forwardAccountTask(task *accountTask) {
return
}
task.Next = incHash(hash)
+
+ // Remove the completion flag once the account range is pushed
+ // forward. The leftover accounts will be skipped in the next
+ // cycle.
+ delete(task.stateCompleted, hash)
}
// All accounts marked as complete, track if the entire task is done
task.done = !res.cont
+ // Error out if there is any leftover completion flag.
+ if task.done && len(task.stateCompleted) != 0 {
+ panic(fmt.Errorf("storage completion flags should be emptied, %d left", len(task.stateCompleted)))
+ }
// Stack trie could have generated trie nodes, push them to disk (we need to
// flush after finalizing task.done. It's fine even if we crash and lose this
// write as it will only cause more data to be downloaded during heal.
diff --git a/eth/protocols/snap/sync_test.go b/eth/protocols/snap/sync_test.go
index 9bfc9bcb5c..f35babb731 100644
--- a/eth/protocols/snap/sync_test.go
+++ b/eth/protocols/snap/sync_test.go
@@ -23,6 +23,7 @@ import (
"fmt"
"math/big"
mrand "math/rand"
+ "slices"
"sync"
"testing"
"time"
@@ -41,7 +42,6 @@ import (
"github.com/ethereum/go-ethereum/triedb/pathdb"
"github.com/holiman/uint256"
"golang.org/x/crypto/sha3"
- "golang.org/x/exp/slices"
)
func TestHashing(t *testing.T) {
@@ -839,7 +839,7 @@ func testMultiSyncManyUseless(t *testing.T, scheme string) {
verifyTrie(scheme, syncer.db, sourceAccountTrie.Hash(), t)
}
-// TestMultiSyncManyUseless contains one good peer, and many which doesn't return anything valuable at all
+// TestMultiSyncManyUselessWithLowTimeout contains one good peer, and many which doesn't return anything valuable at all
func TestMultiSyncManyUselessWithLowTimeout(t *testing.T) {
t.Parallel()
@@ -1378,7 +1378,7 @@ func testSyncWithStorageAndNonProvingPeer(t *testing.T, scheme string) {
verifyTrie(scheme, syncer.db, sourceAccountTrie.Hash(), t)
}
-// TestSyncWithStorage tests basic sync using accounts + storage + code, against
+// TestSyncWithStorageMisbehavingProve tests basic sync using accounts + storage + code, against
// a peer who insists on delivering full storage sets _and_ proofs. This triggered
// an error, where the recipient erroneously clipped the boundary nodes, but
// did not mark the account for healing.
diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go
index 3254f4961f..36caee0dda 100644
--- a/eth/tracers/api_test.go
+++ b/eth/tracers/api_test.go
@@ -24,6 +24,7 @@ import (
"fmt"
"math/big"
"reflect"
+ "slices"
"sync/atomic"
"testing"
"time"
@@ -43,7 +44,6 @@ import (
"github.com/ethereum/go-ethereum/internal/ethapi"
"github.com/ethereum/go-ethereum/params"
"github.com/ethereum/go-ethereum/rpc"
- "golang.org/x/exp/slices"
)
var (
@@ -61,7 +61,7 @@ type testBackend struct {
relHook func() // Hook is invoked when the requested state is released
}
-// testBackend creates a new test backend. OBS: After test is done, teardown must be
+// newTestBackend creates a new test backend. OBS: After test is done, teardown must be
// invoked in order to release associated resources.
func newTestBackend(t *testing.T, n int, gspec *core.Genesis, generator func(i int, b *core.BlockGen)) *testBackend {
backend := &testBackend{
diff --git a/eth/tracers/internal/tracetest/calltrace_test.go b/eth/tracers/internal/tracetest/calltrace_test.go
index 896d4d8a88..31b2ef6d16 100644
--- a/eth/tracers/internal/tracetest/calltrace_test.go
+++ b/eth/tracers/internal/tracetest/calltrace_test.go
@@ -27,7 +27,6 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/common/math"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/types"
@@ -39,14 +38,6 @@ import (
"github.com/ethereum/go-ethereum/tests"
)
-type callContext struct {
- Number math.HexOrDecimal64 `json:"number"`
- Difficulty *math.HexOrDecimal256 `json:"difficulty"`
- Time math.HexOrDecimal64 `json:"timestamp"`
- GasLimit math.HexOrDecimal64 `json:"gasLimit"`
- Miner common.Address `json:"miner"`
-}
-
// callLog is the result of LOG opCode
type callLog struct {
Address common.Address `json:"address"`
@@ -125,17 +116,8 @@ func testCallTracer(tracerName string, dirPath string, t *testing.T) {
// Configure a blockchain with the given prestate
var (
signer = types.MakeSigner(test.Genesis.Config, new(big.Int).SetUint64(uint64(test.Context.Number)), uint64(test.Context.Time))
- context = vm.BlockContext{
- CanTransfer: core.CanTransfer,
- Transfer: core.Transfer,
- Coinbase: test.Context.Miner,
- BlockNumber: new(big.Int).SetUint64(uint64(test.Context.Number)),
- Time: uint64(test.Context.Time),
- Difficulty: (*big.Int)(test.Context.Difficulty),
- GasLimit: uint64(test.Context.GasLimit),
- BaseFee: test.Genesis.BaseFee,
- }
- state = tests.MakePreState(rawdb.NewMemoryDatabase(), test.Genesis.Alloc, false, rawdb.HashScheme)
+ context = test.Context.toBlockContext(test.Genesis)
+ state = tests.MakePreState(rawdb.NewMemoryDatabase(), test.Genesis.Alloc, false, rawdb.HashScheme)
)
state.Close()
diff --git a/eth/tracers/internal/tracetest/flat_calltrace_test.go b/eth/tracers/internal/tracetest/flat_calltrace_test.go
index cd9791db2a..ec7a944b91 100644
--- a/eth/tracers/internal/tracetest/flat_calltrace_test.go
+++ b/eth/tracers/internal/tracetest/flat_calltrace_test.go
@@ -61,8 +61,8 @@ type flatCallTraceResult struct {
// flatCallTracerTest defines a single test to check the call tracer against.
type flatCallTracerTest struct {
- Genesis core.Genesis `json:"genesis"`
- Context callContext `json:"context"`
+ Genesis *core.Genesis `json:"genesis"`
+ Context *callContext `json:"context"`
Input string `json:"input"`
TracerConfig json.RawMessage `json:"tracerConfig"`
Result []flatCallTrace `json:"result"`
@@ -84,15 +84,7 @@ func flatCallTracerTestRunner(tracerName string, filename string, dirPath string
return fmt.Errorf("failed to parse testcase input: %v", err)
}
signer := types.MakeSigner(test.Genesis.Config, new(big.Int).SetUint64(uint64(test.Context.Number)), uint64(test.Context.Time))
- context := vm.BlockContext{
- CanTransfer: core.CanTransfer,
- Transfer: core.Transfer,
- Coinbase: test.Context.Miner,
- BlockNumber: new(big.Int).SetUint64(uint64(test.Context.Number)),
- Time: uint64(test.Context.Time),
- Difficulty: (*big.Int)(test.Context.Difficulty),
- GasLimit: uint64(test.Context.GasLimit),
- }
+ context := test.Context.toBlockContext(test.Genesis)
state := tests.MakePreState(rawdb.NewMemoryDatabase(), test.Genesis.Alloc, false, rawdb.HashScheme)
defer state.Close()
@@ -171,7 +163,7 @@ func testFlatCallTracer(tracerName string, dirPath string, t *testing.T) {
}
}
-// jsonEqual is similar to reflect.DeepEqual, but does a 'bounce' via json prior to
+// jsonEqualFlat is similar to reflect.DeepEqual, but does a 'bounce' via json prior to
// comparison
func jsonEqualFlat(x, y interface{}) bool {
xTrace := new([]flatCallTrace)
diff --git a/eth/tracers/internal/tracetest/makeTest.js b/eth/tracers/internal/tracetest/makeTest.js
index 306f107190..3ad7a5df73 100644
--- a/eth/tracers/internal/tracetest/makeTest.js
+++ b/eth/tracers/internal/tracetest/makeTest.js
@@ -33,16 +33,21 @@ var makeTest = function(tx, traceConfig) {
var result = debug.traceTransaction(tx, traceConfig);
delete result.time;
+ var context = {
+ number: block.number.toString(),
+ difficulty: block.difficulty,
+ timestamp: block.timestamp.toString(),
+ gasLimit: block.gasLimit.toString(),
+ miner: block.miner,
+ };
+ if (block.baseFeePerGas) {
+ context.baseFeePerGas = block.baseFeePerGas.toString();
+ }
+
console.log(JSON.stringify({
genesis: genesis,
- context: {
- number: block.number.toString(),
- difficulty: block.difficulty,
- timestamp: block.timestamp.toString(),
- gasLimit: block.gasLimit.toString(),
- miner: block.miner,
- },
+ context: context,
input: eth.getRawTransaction(tx),
result: result,
}, null, 2));
-}
\ No newline at end of file
+}
diff --git a/eth/tracers/internal/tracetest/prestate_test.go b/eth/tracers/internal/tracetest/prestate_test.go
index dee2bf492e..9cbd126694 100644
--- a/eth/tracers/internal/tracetest/prestate_test.go
+++ b/eth/tracers/internal/tracetest/prestate_test.go
@@ -25,7 +25,6 @@ import (
"testing"
"github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
"github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/core/types"
@@ -94,25 +93,11 @@ func testPrestateDiffTracer(tracerName string, dirPath string, t *testing.T) {
// Configure a blockchain with the given prestate
var (
signer = types.MakeSigner(test.Genesis.Config, new(big.Int).SetUint64(uint64(test.Context.Number)), uint64(test.Context.Time))
- context = vm.BlockContext{
- CanTransfer: core.CanTransfer,
- Transfer: core.Transfer,
- Coinbase: test.Context.Miner,
- BlockNumber: new(big.Int).SetUint64(uint64(test.Context.Number)),
- Time: uint64(test.Context.Time),
- Difficulty: (*big.Int)(test.Context.Difficulty),
- GasLimit: uint64(test.Context.GasLimit),
- BaseFee: test.Genesis.BaseFee,
- }
- state = tests.MakePreState(rawdb.NewMemoryDatabase(), test.Genesis.Alloc, false, rawdb.HashScheme)
+ context = test.Context.toBlockContext(test.Genesis)
+ state = tests.MakePreState(rawdb.NewMemoryDatabase(), test.Genesis.Alloc, false, rawdb.HashScheme)
)
defer state.Close()
- if test.Genesis.ExcessBlobGas != nil && test.Genesis.BlobGasUsed != nil {
- excessBlobGas := eip4844.CalcExcessBlobGas(*test.Genesis.ExcessBlobGas, *test.Genesis.BlobGasUsed)
- context.BlobBaseFee = eip4844.CalcBlobFee(excessBlobGas)
- }
-
tracer, err := tracers.DefaultDirectory.New(tracerName, new(tracers.Context), test.TracerConfig)
if err != nil {
t.Fatalf("failed to create call tracer: %v", err)
diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer/blob_tx.json b/eth/tracers/internal/tracetest/testdata/call_tracer/blob_tx.json
new file mode 100644
index 0000000000..549acb1fe6
--- /dev/null
+++ b/eth/tracers/internal/tracetest/testdata/call_tracer/blob_tx.json
@@ -0,0 +1,67 @@
+{
+ "genesis": {
+ "baseFeePerGas": "7",
+ "blobGasUsed": "0",
+ "difficulty": "0",
+ "excessBlobGas": "36306944",
+ "extraData": "0xd983010e00846765746888676f312e32312e308664617277696e",
+ "gasLimit": "15639172",
+ "hash": "0xc682259fda061bb9ce8ccb491d5b2d436cb73daf04e1025dd116d045ce4ad28c",
+ "miner": "0x0000000000000000000000000000000000000000",
+ "mixHash": "0xae1a5ba939a4c9ac38aabeff361169fb55a6fc2c9511457e0be6eff9514faec0",
+ "nonce": "0x0000000000000000",
+ "number": "315",
+ "parentBeaconBlockRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
+ "stateRoot": "0x577f42ab21ccfd946511c57869ace0bdf7c217c36f02b7cd3459df0ed1cffc1a",
+ "timestamp": "1709626771",
+ "totalDifficulty": "1",
+ "withdrawals": [],
+ "withdrawalsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ "alloc": {
+ "0x0000000000000000000000000000000000000000": {
+ "balance": "0x272e0528"
+ },
+ "0x0c2c51a0990aee1d73c1228de158688341557508": {
+ "balance": "0xde0b6b3a7640000"
+ }
+ },
+ "config": {
+ "chainId": 1337,
+ "homesteadBlock": 0,
+ "eip150Block": 0,
+ "eip155Block": 0,
+ "eip158Block": 0,
+ "byzantiumBlock": 0,
+ "constantinopleBlock": 0,
+ "petersburgBlock": 0,
+ "istanbulBlock": 0,
+ "muirGlacierBlock": 0,
+ "berlinBlock": 0,
+ "londonBlock": 0,
+ "arrowGlacierBlock": 0,
+ "grayGlacierBlock": 0,
+ "shanghaiTime": 0,
+ "cancunTime": 0,
+ "terminalTotalDifficulty": 0,
+ "terminalTotalDifficultyPassed": true
+ }
+ },
+ "context": {
+ "number": "316",
+ "difficulty": "0",
+ "timestamp": "1709626785",
+ "gasLimit": "15654443",
+ "miner": "0x0000000000000000000000000000000000000000",
+ "baseFeePerGas": "7"
+ },
+ "input": "0x03f8b1820539806485174876e800825208940c2c51a0990aee1d73c1228de1586883415575088080c083020000f842a00100c9fbdf97f747e85847b4f3fff408f89c26842f77c882858bf2c89923849aa00138e3896f3c27f2389147507f8bcec52028b0efca6ee842ed83c9158873943880a0dbac3f97a532c9b00e6239b29036245a5bfbb96940b9d848634661abee98b945a03eec8525f261c2e79798f7b45a5d6ccaefa24576d53ba5023e919b86841c0675",
+ "result": {
+ "from": "0x0c2c51a0990aee1d73c1228de158688341557508",
+ "gas": "0x5208",
+ "gasUsed": "0x5208",
+ "to": "0x0c2c51a0990aee1d73c1228de158688341557508",
+ "input": "0x",
+ "value": "0x0",
+ "type": "CALL"
+ }
+}
diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer/inner_revert_reason.json b/eth/tracers/internal/tracetest/testdata/call_tracer/inner_revert_reason.json
index ad0627ccd6..0108c93ae0 100644
--- a/eth/tracers/internal/tracetest/testdata/call_tracer/inner_revert_reason.json
+++ b/eth/tracers/internal/tracetest/testdata/call_tracer/inner_revert_reason.json
@@ -45,7 +45,8 @@
"difficulty": "2",
"timestamp": "1665537018",
"gasLimit": "11511229",
- "miner": "0x0000000000000000000000000000000000000000"
+ "miner": "0x0000000000000000000000000000000000000000",
+ "baseFeePerGas": "875000000"
},
"input": "0x02f9029d82053980849502f90085010c388d00832dc6c08080b90241608060405234801561001057600080fd5b50600060405161001f906100a2565b604051809103906000f08015801561003b573d6000803e3d6000fd5b5090508073ffffffffffffffffffffffffffffffffffffffff1663c04062266040518163ffffffff1660e01b815260040160006040518083038186803b15801561008457600080fd5b505afa158015610098573d6000803e3d6000fd5b50505050506100af565b610145806100fc83390190565b603f806100bd6000396000f3fe6080604052600080fdfea264697066735822122077f7dbd3450d6e817079cf3fe27107de5768bb3163a402b94e2206b468eb025664736f6c63430008070033608060405234801561001057600080fd5b50610125806100206000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063c040622614602d575b600080fd5b60336035565b005b60036002116076576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401606d906097565b60405180910390fd5b565b6000608360128360b5565b9150608c8260c6565b602082019050919050565b6000602082019050818103600083015260ae816078565b9050919050565b600082825260208201905092915050565b7f546869732063616c6c6564206661696c6564000000000000000000000000000060008201525056fea264697066735822122033f8d92e29d467e5ea08d0024eab0b36b86b8cdb3542c6e89dbaabeb8ffaa42064736f6c63430008070033c001a07566181071cabaf58b70fc41557eb813bfc7a24f5c58554e7fed0bf7c031f169a0420af50b5fe791a4d839e181a676db5250b415dfb35cb85d544db7a1475ae2cc",
"result": {
diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer_flat/callcode_precompiled_throw.json b/eth/tracers/internal/tracetest/testdata/call_tracer_flat/callcode_precompiled_throw.json
index 3c1e370f91..5e27261554 100644
--- a/eth/tracers/internal/tracetest/testdata/call_tracer_flat/callcode_precompiled_throw.json
+++ b/eth/tracers/internal/tracetest/testdata/call_tracer_flat/callcode_precompiled_throw.json
@@ -57,7 +57,7 @@
"gas": "0x1a034",
"init": "0x36600060003760406103e8366000600060095af26001556103e8516002556104085160035500"
},
- "error": "out of gas",
+ "error": "out of gas: not enough gas for reentrancy sentry",
"traceAddress": [],
"subtraces": 1,
"transactionPosition": 117,
diff --git a/eth/tracers/internal/tracetest/testdata/call_tracer_flat/nested_create_action_gas.json b/eth/tracers/internal/tracetest/testdata/call_tracer_flat/nested_create_action_gas.json
index 132b84df36..a00ea7a93b 100644
--- a/eth/tracers/internal/tracetest/testdata/call_tracer_flat/nested_create_action_gas.json
+++ b/eth/tracers/internal/tracetest/testdata/call_tracer_flat/nested_create_action_gas.json
@@ -57,7 +57,7 @@
"gas": "0x19ee4",
"init": "0x5a600055600060006000f0505a60015500"
},
- "error": "out of gas",
+ "error": "out of gas: not enough gas for reentrancy sentry",
"traceAddress": [],
"subtraces": 1,
"transactionPosition": 63,
diff --git a/eth/tracers/internal/tracetest/testdata/prestate_tracer/blob_tx.json b/eth/tracers/internal/tracetest/testdata/prestate_tracer/blob_tx.json
index 315481aff5..c3e7387f02 100644
--- a/eth/tracers/internal/tracetest/testdata/prestate_tracer/blob_tx.json
+++ b/eth/tracers/internal/tracetest/testdata/prestate_tracer/blob_tx.json
@@ -51,7 +51,8 @@
"difficulty": "0",
"timestamp": "1709626785",
"gasLimit": "15654443",
- "miner": "0x0000000000000000000000000000000000000000"
+ "miner": "0x0000000000000000000000000000000000000000",
+ "baseFeePerGas": "7"
},
"input": "0x03f8b1820539806485174876e800825208940c2c51a0990aee1d73c1228de1586883415575088080c083020000f842a00100c9fbdf97f747e85847b4f3fff408f89c26842f77c882858bf2c89923849aa00138e3896f3c27f2389147507f8bcec52028b0efca6ee842ed83c9158873943880a0dbac3f97a532c9b00e6239b29036245a5bfbb96940b9d848634661abee98b945a03eec8525f261c2e79798f7b45a5d6ccaefa24576d53ba5023e919b86841c0675",
"result": {
diff --git a/eth/tracers/internal/tracetest/testdata/prestate_tracer/create_create.json b/eth/tracers/internal/tracetest/testdata/prestate_tracer/create_create.json
index 909a1eabe3..893c604443 100644
--- a/eth/tracers/internal/tracetest/testdata/prestate_tracer/create_create.json
+++ b/eth/tracers/internal/tracetest/testdata/prestate_tracer/create_create.json
@@ -48,7 +48,8 @@
"difficulty": "0",
"timestamp": "1699617847",
"gasLimit": "11522469",
- "miner": "0x0000000000000000000000000000000000000000"
+ "miner": "0x0000000000000000000000000000000000000000",
+ "baseFeePerGas": "765625000"
},
"input": "0x02f902b48205398084b2d05e0085011b1f3f8083031ca88080b90258608060405234801561001057600080fd5b5060405161001d906100e3565b604051809103906000f080158015610039573d6000803e3d6000fd5b50600080546001600160a01b0319166001600160a01b039290921691821781556040517fc66247bafd1305823857fb4c3e651e684d918df8554ef560bbbcb025fdd017039190a26000546040516360fe47b160e01b8152600560048201526001600160a01b03909116906360fe47b190602401600060405180830381600087803b1580156100c657600080fd5b505af11580156100da573d6000803e3d6000fd5b505050506100ef565b60ca8061018e83390190565b6091806100fd6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c806380de699314602d575b600080fd5b600054603f906001600160a01b031681565b6040516001600160a01b03909116815260200160405180910390f3fea2646970667358221220dab781465e7f4cf20304cc388130a763508e20edd25b4bc8ea8f57743a0de8da64736f6c634300081700336080604052348015600f57600080fd5b5060ac8061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146049575b600080fd5b60476042366004605e565b600055565b005b60005460405190815260200160405180910390f35b600060208284031215606f57600080fd5b503591905056fea264697066735822122049e09da6320793487d58eaa7b97f802618a062cbc35f08ca1ce92c17349141f864736f6c63430008170033c080a01d4fce93ad08bf413052645721f20e6136830cf5a2759fa57e76a134e90899a7a0399a72832d52118991dc04c4f9e1c0fec3d5e441ad7d4b055f0cf03130d8f815",
"result": {
diff --git a/eth/tracers/internal/tracetest/testdata/prestate_tracer/create_post_eip158.json b/eth/tracers/internal/tracetest/testdata/prestate_tracer/create_post_eip158.json
index 205b472dab..fb85b31a48 100644
--- a/eth/tracers/internal/tracetest/testdata/prestate_tracer/create_post_eip158.json
+++ b/eth/tracers/internal/tracetest/testdata/prestate_tracer/create_post_eip158.json
@@ -48,7 +48,8 @@
"difficulty": "2",
"timestamp": "1709022197",
"gasLimit": "30000000",
- "miner": "0x2445e8c26a2bf3d1e59f1bb9b1d442caf90768e0"
+ "miner": "0x2445e8c26a2bf3d1e59f1bb9b1d442caf90768e0",
+ "baseFeePerGas": "7"
},
"input": "0x02f902af823039408459682f008459682f088302b3538080b90254608060405234801561001057600080fd5b50610234806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806309ce9ccb1461003b5780633fb5c1cb14610059575b600080fd5b610043610075565b60405161005091906100e2565b60405180910390f35b610073600480360381019061006e919061012e565b61007b565b005b60005481565b80600081905550600a8111156100c6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100bd906101de565b60405180910390fd5b50565b6000819050919050565b6100dc816100c9565b82525050565b60006020820190506100f760008301846100d3565b92915050565b600080fd5b61010b816100c9565b811461011657600080fd5b50565b60008135905061012881610102565b92915050565b600060208284031215610144576101436100fd565b5b600061015284828501610119565b91505092915050565b600082825260208201905092915050565b7f4e756d6265722069732067726561746572207468616e2031302c207472616e7360008201527f616374696f6e2072657665727465642e00000000000000000000000000000000602082015250565b60006101c860308361015b565b91506101d38261016c565b604082019050919050565b600060208201905081810360008301526101f7816101bb565b905091905056fea264697066735822122069018995fecf03bda91a88b6eafe41641709dee8b4a706fe301c8a569fe8c1b364736f6c63430008130033c001a0a8cf4729b7e4664687abb3e2559853d7d489eb441519be2a17493061fb4c3a03a04b5a904ba8a6e59c6c40049c4d14a73233aeb8a45b38403199f304630dc0d453",
"result": {
diff --git a/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/create_failed.json b/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/create_failed.json
index 561ead05b6..ae7f7e97f5 100644
--- a/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/create_failed.json
+++ b/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/create_failed.json
@@ -1,6 +1,6 @@
{
"genesis": {
- "baseFeePerGas": "51088069741",
+ "baseFeePerGas": "4573728117",
"difficulty": "14315558652874667",
"extraData": "0xd883010a10846765746888676f312e31362e35856c696e7578",
"gasLimit": "30058590",
@@ -64,7 +64,8 @@
"difficulty": "14322823549655084",
"timestamp": "1651623279",
"gasLimit": "30029237",
- "miner": "0x8f03f1a3f10c05e7cccf75c1fd10168e06659be7"
+ "miner": "0x8f03f1a3f10c05e7cccf75c1fd10168e06659be7",
+ "baseFeePerGas": "4002012103"
},
"input": "0x02f8b4018312acfc8459682f00851a46bcf47a8302b1a194ffa397285ce46fb78c588a9e993286aac68c37cd80b844fb90b3200000000000000000000000002a549b4af9ec39b03142da6dc32221fc390b553300000000000000000000000000000000000000000000000000000000000cb3d5c001a03002079d2873f7963c4278200c43aa71efad262b2150bc8524480acfc38b5faaa077d44aa09d56b9cf99443c7f55aaad1bbae9cfb5bbb9de31eaf7a8f9e623e980",
"tracerConfig": {
@@ -83,7 +84,7 @@
},
"post": {
"0x808b4da0be6c9512e948521452227efc619bea52": {
- "balance": "0x2cd987071ba2346b6",
+ "balance": "0x2cdb5f8e62cc9ad1c",
"nonce": 1223933
},
"0x8f03f1a3f10c05e7cccf75c1fd10168e06659be7": {
diff --git a/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/create_post_eip158.json b/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/create_post_eip158.json
index 83266f6669..f5adb1af65 100644
--- a/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/create_post_eip158.json
+++ b/eth/tracers/internal/tracetest/testdata/prestate_tracer_with_diff_mode/create_post_eip158.json
@@ -48,7 +48,8 @@
"difficulty": "2",
"timestamp": "1709022197",
"gasLimit": "30000000",
- "miner": "0x2445e8c26a2bf3d1e59f1bb9b1d442caf90768e0"
+ "miner": "0x2445e8c26a2bf3d1e59f1bb9b1d442caf90768e0",
+ "baseFeePerGas": "7"
},
"input": "0x02f902af823039408459682f008459682f088302b3538080b90254608060405234801561001057600080fd5b50610234806100206000396000f3fe608060405234801561001057600080fd5b50600436106100365760003560e01c806309ce9ccb1461003b5780633fb5c1cb14610059575b600080fd5b610043610075565b60405161005091906100e2565b60405180910390f35b610073600480360381019061006e919061012e565b61007b565b005b60005481565b80600081905550600a8111156100c6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016100bd906101de565b60405180910390fd5b50565b6000819050919050565b6100dc816100c9565b82525050565b60006020820190506100f760008301846100d3565b92915050565b600080fd5b61010b816100c9565b811461011657600080fd5b50565b60008135905061012881610102565b92915050565b600060208284031215610144576101436100fd565b5b600061015284828501610119565b91505092915050565b600082825260208201905092915050565b7f4e756d6265722069732067726561746572207468616e2031302c207472616e7360008201527f616374696f6e2072657665727465642e00000000000000000000000000000000602082015250565b60006101c860308361015b565b91506101d38261016c565b604082019050919050565b600060208201905081810360008301526101f7816101bb565b905091905056fea264697066735822122069018995fecf03bda91a88b6eafe41641709dee8b4a706fe301c8a569fe8c1b364736f6c63430008130033c001a0a8cf4729b7e4664687abb3e2559853d7d489eb441519be2a17493061fb4c3a03a04b5a904ba8a6e59c6c40049c4d14a73233aeb8a45b38403199f304630dc0d453",
"tracerConfig": {
diff --git a/eth/tracers/internal/tracetest/util.go b/eth/tracers/internal/tracetest/util.go
index 1913f352dd..a74a96f8a4 100644
--- a/eth/tracers/internal/tracetest/util.go
+++ b/eth/tracers/internal/tracetest/util.go
@@ -1,9 +1,16 @@
package tracetest
import (
+ "math/big"
"strings"
"unicode"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/math"
+ "github.com/ethereum/go-ethereum/consensus/misc/eip4844"
+ "github.com/ethereum/go-ethereum/core"
+ "github.com/ethereum/go-ethereum/core/vm"
+
// Force-load native and js packages, to trigger registration
_ "github.com/ethereum/go-ethereum/eth/tracers/js"
_ "github.com/ethereum/go-ethereum/eth/tracers/native"
@@ -17,3 +24,32 @@ func camel(str string) string {
}
return strings.Join(pieces, "")
}
+
+type callContext struct {
+ Number math.HexOrDecimal64 `json:"number"`
+ Difficulty *math.HexOrDecimal256 `json:"difficulty"`
+ Time math.HexOrDecimal64 `json:"timestamp"`
+ GasLimit math.HexOrDecimal64 `json:"gasLimit"`
+ Miner common.Address `json:"miner"`
+ BaseFee *math.HexOrDecimal256 `json:"baseFeePerGas"`
+}
+
+func (c *callContext) toBlockContext(genesis *core.Genesis) vm.BlockContext {
+ context := vm.BlockContext{
+ CanTransfer: core.CanTransfer,
+ Transfer: core.Transfer,
+ Coinbase: c.Miner,
+ BlockNumber: new(big.Int).SetUint64(uint64(c.Number)),
+ Time: uint64(c.Time),
+ Difficulty: (*big.Int)(c.Difficulty),
+ GasLimit: uint64(c.GasLimit),
+ }
+ if genesis.Config.IsLondon(context.BlockNumber) {
+ context.BaseFee = (*big.Int)(c.BaseFee)
+ }
+ if genesis.ExcessBlobGas != nil && genesis.BlobGasUsed != nil {
+ excessBlobGas := eip4844.CalcExcessBlobGas(*genesis.ExcessBlobGas, *genesis.BlobGasUsed)
+ context.BlobBaseFee = eip4844.CalcBlobFee(excessBlobGas)
+ }
+ return context
+}
diff --git a/eth/tracers/internal/util.go b/eth/tracers/internal/util.go
index 18a372d192..347af43d51 100644
--- a/eth/tracers/internal/util.go
+++ b/eth/tracers/internal/util.go
@@ -75,7 +75,7 @@ func MemoryPtr(m []byte, offset, size int64) []byte {
return nil
}
-// Back returns the n'th item in stack
+// StackBack returns the n'th item in stack
func StackBack(st []uint256.Int, n int) *uint256.Int {
return &st[len(st)-n-1]
}
diff --git a/eth/tracers/js/goja.go b/eth/tracers/js/goja.go
index 7e4930f81d..5290d4f709 100644
--- a/eth/tracers/js/goja.go
+++ b/eth/tracers/js/goja.go
@@ -21,6 +21,7 @@ import (
"errors"
"fmt"
"math/big"
+ "slices"
"github.com/dop251/goja"
"github.com/ethereum/go-ethereum/core/tracing"
@@ -529,13 +530,7 @@ func (t *jsTracer) setBuiltinFunctions() {
vm.Interrupt(err)
return false
}
- addr := common.BytesToAddress(a)
- for _, p := range t.activePrecompiles {
- if p == addr {
- return true
- }
- }
- return false
+ return slices.Contains(t.activePrecompiles, common.BytesToAddress(a))
})
vm.Set("slice", func(slice goja.Value, start, end int64) goja.Value {
b, err := t.fromBuf(vm, slice, false)
@@ -677,11 +672,11 @@ func (mo *memoryObj) Length() int {
return len(mo.memory)
}
-func (m *memoryObj) setupObject() *goja.Object {
- o := m.vm.NewObject()
- o.Set("slice", m.vm.ToValue(m.Slice))
- o.Set("getUint", m.vm.ToValue(m.GetUint))
- o.Set("length", m.vm.ToValue(m.Length))
+func (mo *memoryObj) setupObject() *goja.Object {
+ o := mo.vm.NewObject()
+ o.Set("slice", mo.vm.ToValue(mo.Slice))
+ o.Set("getUint", mo.vm.ToValue(mo.GetUint))
+ o.Set("length", mo.vm.ToValue(mo.Length))
return o
}
@@ -863,12 +858,12 @@ func (co *contractObj) GetInput() goja.Value {
return res
}
-func (c *contractObj) setupObject() *goja.Object {
- o := c.vm.NewObject()
- o.Set("getCaller", c.vm.ToValue(c.GetCaller))
- o.Set("getAddress", c.vm.ToValue(c.GetAddress))
- o.Set("getValue", c.vm.ToValue(c.GetValue))
- o.Set("getInput", c.vm.ToValue(c.GetInput))
+func (co *contractObj) setupObject() *goja.Object {
+ o := co.vm.NewObject()
+ o.Set("getCaller", co.vm.ToValue(co.GetCaller))
+ o.Set("getAddress", co.vm.ToValue(co.GetAddress))
+ o.Set("getValue", co.vm.ToValue(co.GetValue))
+ o.Set("getInput", co.vm.ToValue(co.GetInput))
return o
}
diff --git a/eth/tracers/js/tracer_test.go b/eth/tracers/js/tracer_test.go
index d643289a64..05adedf265 100644
--- a/eth/tracers/js/tracer_test.go
+++ b/eth/tracers/js/tracer_test.go
@@ -198,7 +198,7 @@ func TestHaltBetweenSteps(t *testing.T) {
}
}
-// testNoStepExec tests a regular value transfer (no exec), and accessing the statedb
+// TestNoStepExec tests a regular value transfer (no exec), and accessing the statedb
// in 'result'
func TestNoStepExec(t *testing.T) {
execTracer := func(code string) []byte {
diff --git a/eth/tracers/logger/access_list_tracer.go b/eth/tracers/logger/access_list_tracer.go
index fc7713b245..e8231461b0 100644
--- a/eth/tracers/logger/access_list_tracer.go
+++ b/eth/tracers/logger/access_list_tracer.go
@@ -17,6 +17,8 @@
package logger
import (
+ "maps"
+
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/types"
@@ -71,22 +73,14 @@ func (al accessList) equal(other accessList) bool {
// Accounts match, cross reference the storage slots too
for addr, slots := range al {
otherslots := other[addr]
-
- if len(slots) != len(otherslots) {
+ if !maps.Equal(slots, otherslots) {
return false
}
- // Given that len(slots) == len(otherslots), we only need to check that
- // all the items from slots are in otherslots.
- for hash := range slots {
- if _, ok := otherslots[hash]; !ok {
- return false
- }
- }
}
return true
}
-// accesslist converts the accesslist to a types.AccessList.
+// accessList converts the accesslist to a types.AccessList.
func (al accessList) accessList() types.AccessList {
acl := make(types.AccessList, 0, len(al))
for addr, slots := range al {
diff --git a/eth/tracers/logger/gen_callframe.go b/eth/tracers/logger/gen_callframe.go
new file mode 100644
index 0000000000..b7b2cc2881
--- /dev/null
+++ b/eth/tracers/logger/gen_callframe.go
@@ -0,0 +1,65 @@
+// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
+
+package logger
+
+import (
+ "encoding/json"
+ "math/big"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/common/math"
+)
+
+var _ = (*callFrameMarshaling)(nil)
+
+// MarshalJSON marshals as JSON.
+func (c callFrame) MarshalJSON() ([]byte, error) {
+ type callFrame struct {
+ From common.Address `json:"from"`
+ To common.Address `json:"to"`
+ Input hexutil.Bytes `json:"input,omitempty"`
+ Gas math.HexOrDecimal64 `json:"gas"`
+ Value *hexutil.Big `json:"value"`
+ Type string `json:"type"`
+ }
+ var enc callFrame
+ enc.From = c.From
+ enc.To = c.To
+ enc.Input = c.Input
+ enc.Gas = math.HexOrDecimal64(c.Gas)
+ enc.Value = (*hexutil.Big)(c.Value)
+ enc.Type = c.Type()
+ return json.Marshal(&enc)
+}
+
+// UnmarshalJSON unmarshals from JSON.
+func (c *callFrame) UnmarshalJSON(input []byte) error {
+ type callFrame struct {
+ From *common.Address `json:"from"`
+ To *common.Address `json:"to"`
+ Input *hexutil.Bytes `json:"input,omitempty"`
+ Gas *math.HexOrDecimal64 `json:"gas"`
+ Value *hexutil.Big `json:"value"`
+ }
+ var dec callFrame
+ if err := json.Unmarshal(input, &dec); err != nil {
+ return err
+ }
+ if dec.From != nil {
+ c.From = *dec.From
+ }
+ if dec.To != nil {
+ c.To = *dec.To
+ }
+ if dec.Input != nil {
+ c.Input = *dec.Input
+ }
+ if dec.Gas != nil {
+ c.Gas = uint64(*dec.Gas)
+ }
+ if dec.Value != nil {
+ c.Value = (*big.Int)(dec.Value)
+ }
+ return nil
+}
diff --git a/eth/tracers/logger/logger_json.go b/eth/tracers/logger/logger_json.go
index 6fac2d1159..d66b8c4b8a 100644
--- a/eth/tracers/logger/logger_json.go
+++ b/eth/tracers/logger/logger_json.go
@@ -19,14 +19,41 @@ package logger
import (
"encoding/json"
"io"
+ "math/big"
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/common/math"
"github.com/ethereum/go-ethereum/core/tracing"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/core/vm"
)
+//go:generate go run github.com/fjl/gencodec -type callFrame -field-override callFrameMarshaling -out gen_callframe.go
+
+// overrides for gencodec
+type callFrameMarshaling struct {
+ Input hexutil.Bytes
+ Gas math.HexOrDecimal64
+ Value *hexutil.Big
+ Type string `json:"type"` // adds call to Type() in MarshalJSON
+}
+
+// callFrame is emitted every call frame entered.
+type callFrame struct {
+ op vm.OpCode
+ From common.Address `json:"from"`
+ To common.Address `json:"to"`
+ Input []byte `json:"input,omitempty"`
+ Gas uint64 `json:"gas"`
+ Value *big.Int `json:"value"`
+}
+
+// Type formats the call type in a human-readable format.
+func (c *callFrame) Type() string {
+ return c.op.String()
+}
+
type jsonLogger struct {
encoder *json.Encoder
cfg *Config
@@ -48,6 +75,22 @@ func NewJSONLogger(cfg *Config, writer io.Writer) *tracing.Hooks {
}
}
+// NewJSONLoggerWithCallFrames creates a new EVM tracer that prints execution steps as JSON objects
+// into the provided stream. It also includes call frames in the output.
+func NewJSONLoggerWithCallFrames(cfg *Config, writer io.Writer) *tracing.Hooks {
+ l := &jsonLogger{encoder: json.NewEncoder(writer), cfg: cfg}
+ if l.cfg == nil {
+ l.cfg = &Config{}
+ }
+ return &tracing.Hooks{
+ OnTxStart: l.OnTxStart,
+ OnEnter: l.OnEnter,
+ OnExit: l.OnExit,
+ OnOpcode: l.OnOpcode,
+ OnFault: l.OnFault,
+ }
+}
+
func (l *jsonLogger) OnFault(pc uint64, op byte, gas uint64, cost uint64, scope tracing.OpContext, depth int, err error) {
// TODO: Add rData to this interface as well
l.OnOpcode(pc, op, gas, cost, scope, nil, depth, err)
@@ -79,10 +122,29 @@ func (l *jsonLogger) OnOpcode(pc uint64, op byte, gas, cost uint64, scope tracin
l.encoder.Encode(log)
}
-func (l *jsonLogger) OnExit(depth int, output []byte, gasUsed uint64, err error, reverted bool) {
+// OnEnter is not enabled by default.
+func (l *jsonLogger) OnEnter(depth int, typ byte, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+ frame := callFrame{
+ op: vm.OpCode(typ),
+ From: from,
+ To: to,
+ Gas: gas,
+ Value: value,
+ }
+ if l.cfg.EnableMemory {
+ frame.Input = input
+ }
+ l.encoder.Encode(frame)
+}
+
+func (l *jsonLogger) OnEnd(depth int, output []byte, gasUsed uint64, err error, reverted bool) {
if depth > 0 {
return
}
+ l.OnExit(depth, output, gasUsed, err, false)
+}
+
+func (l *jsonLogger) OnExit(depth int, output []byte, gasUsed uint64, err error, reverted bool) {
type endLog struct {
Output string `json:"output"`
GasUsed math.HexOrDecimal64 `json:"gasUsed"`
diff --git a/eth/tracers/native/call_flat.go b/eth/tracers/native/call_flat.go
index 37be64310c..f8d38ddd2d 100644
--- a/eth/tracers/native/call_flat.go
+++ b/eth/tracers/native/call_flat.go
@@ -21,6 +21,7 @@ import (
"errors"
"fmt"
"math/big"
+ "slices"
"strings"
"github.com/ethereum/go-ethereum/common"
@@ -228,12 +229,7 @@ func (t *flatCallTracer) Stop(err error) {
// isPrecompiled returns whether the addr is a precompile.
func (t *flatCallTracer) isPrecompiled(addr common.Address) bool {
- for _, p := range t.activePrecompiles {
- if p == addr {
- return true
- }
- }
- return false
+ return slices.Contains(t.activePrecompiles, addr)
}
func flatFromNested(input *callFrame, traceAddress []int, convertErrs bool, ctx *tracers.Context) (output []flatCallFrame, err error) {
diff --git a/ethclient/gethclient/gethclient_test.go b/ethclient/gethclient/gethclient_test.go
index d562bcda1f..1cd9c5389b 100644
--- a/ethclient/gethclient/gethclient_test.go
+++ b/ethclient/gethclient/gethclient_test.go
@@ -299,7 +299,7 @@ func testGetProofNonExistent(t *testing.T, client *rpc.Client) {
t.Fatalf("invalid nonce, want: %v got: %v", 0, result.Nonce)
}
// test balance
- if result.Balance.Cmp(big.NewInt(0)) != 0 {
+ if result.Balance.Sign() != 0 {
t.Fatalf("invalid balance, want: %v got: %v", 0, result.Balance)
}
// test storage
diff --git a/ethclient/simulated/backend.go b/ethclient/simulated/backend.go
index 0c2a0b453c..d6fb886ad8 100644
--- a/ethclient/simulated/backend.go
+++ b/ethclient/simulated/backend.go
@@ -17,6 +17,7 @@
package simulated
import (
+ "errors"
"time"
"github.com/ethereum/go-ethereum"
@@ -62,7 +63,7 @@ type simClient struct {
// Backend is a simulated blockchain. You can use it to test your contracts or
// other code that interacts with the Ethereum chain.
type Backend struct {
- eth *eth.Ethereum
+ node *node.Node
beacon *catalyst.SimulatedBeacon
client simClient
}
@@ -129,7 +130,7 @@ func newWithNode(stack *node.Node, conf *eth.Config, blockPeriod uint64) (*Backe
return nil, err
}
return &Backend{
- eth: backend,
+ node: stack,
beacon: beacon,
client: simClient{ethclient.NewClient(stack.Attach())},
}, nil
@@ -142,12 +143,16 @@ func (n *Backend) Close() error {
n.client.Close()
n.client = simClient{}
}
+ var err error
if n.beacon != nil {
- err := n.beacon.Stop()
+ err = n.beacon.Stop()
n.beacon = nil
- return err
}
- return nil
+ if n.node != nil {
+ err = errors.Join(err, n.node.Close())
+ n.node = nil
+ }
+ return err
}
// Commit seals a block and moves the chain forward to a new empty block.
diff --git a/ethclient/simulated/options.go b/ethclient/simulated/options.go
index 6db995c917..40bcb37bd1 100644
--- a/ethclient/simulated/options.go
+++ b/ethclient/simulated/options.go
@@ -46,7 +46,7 @@ func WithCallGasLimit(gaslimit uint64) func(nodeConf *node.Config, ethConf *ethc
// 0 is not possible as a live Geth node would reject that due to DoS protection,
// so the simulated backend will replicate that behavior for consistency.
func WithMinerMinTip(tip *big.Int) func(nodeConf *node.Config, ethConf *ethconfig.Config) {
- if tip == nil || tip.Cmp(new(big.Int)) <= 0 {
+ if tip == nil || tip.Sign() <= 0 {
panic("invalid miner minimum tip")
}
return func(nodeConf *node.Config, ethConf *ethconfig.Config) {
diff --git a/ethdb/dbtest/testsuite.go b/ethdb/dbtest/testsuite.go
index 29bd24364e..83a13c8cff 100644
--- a/ethdb/dbtest/testsuite.go
+++ b/ethdb/dbtest/testsuite.go
@@ -19,12 +19,11 @@ package dbtest
import (
"bytes"
"crypto/rand"
- "reflect"
+ "slices"
"sort"
"testing"
"github.com/ethereum/go-ethereum/ethdb"
- "golang.org/x/exp/slices"
)
// TestDatabaseSuite runs a suite of tests against a KeyValueStore database
@@ -149,7 +148,7 @@ func TestDatabaseSuite(t *testing.T, New func() ethdb.KeyValueStore) {
if err := it.Error(); err != nil {
t.Fatal(err)
}
- if !reflect.DeepEqual(got, want) {
+ if !slices.Equal(got, want) {
t.Errorf("Iterator: got: %s; want: %s", got, want)
}
}
@@ -160,7 +159,7 @@ func TestDatabaseSuite(t *testing.T, New func() ethdb.KeyValueStore) {
if err := it.Error(); err != nil {
t.Fatal(err)
}
- if !reflect.DeepEqual(got, want) {
+ if !slices.Equal(got, want) {
t.Errorf("IteratorWith(1,nil): got: %s; want: %s", got, want)
}
}
@@ -171,7 +170,7 @@ func TestDatabaseSuite(t *testing.T, New func() ethdb.KeyValueStore) {
if err := it.Error(); err != nil {
t.Fatal(err)
}
- if !reflect.DeepEqual(got, want) {
+ if !slices.Equal(got, want) {
t.Errorf("IteratorWith(5,nil): got: %s; want: %s", got, want)
}
}
@@ -182,7 +181,7 @@ func TestDatabaseSuite(t *testing.T, New func() ethdb.KeyValueStore) {
if err := it.Error(); err != nil {
t.Fatal(err)
}
- if !reflect.DeepEqual(got, want) {
+ if !slices.Equal(got, want) {
t.Errorf("IteratorWith(nil,2): got: %s; want: %s", got, want)
}
}
@@ -193,7 +192,7 @@ func TestDatabaseSuite(t *testing.T, New func() ethdb.KeyValueStore) {
if err := it.Error(); err != nil {
t.Fatal(err)
}
- if !reflect.DeepEqual(got, want) {
+ if !slices.Equal(got, want) {
t.Errorf("IteratorWith(nil,5): got: %s; want: %s", got, want)
}
}
@@ -262,7 +261,7 @@ func TestDatabaseSuite(t *testing.T, New func() ethdb.KeyValueStore) {
{
it := db.NewIterator(nil, nil)
- if got, want := iterateKeys(it), []string{"1", "2", "3", "4"}; !reflect.DeepEqual(got, want) {
+ if got, want := iterateKeys(it), []string{"1", "2", "3", "4"}; !slices.Equal(got, want) {
t.Errorf("got: %s; want: %s", got, want)
}
}
@@ -286,7 +285,7 @@ func TestDatabaseSuite(t *testing.T, New func() ethdb.KeyValueStore) {
{
it := db.NewIterator(nil, nil)
- if got, want := iterateKeys(it), []string{"2", "3", "4", "5", "6"}; !reflect.DeepEqual(got, want) {
+ if got, want := iterateKeys(it), []string{"2", "3", "4", "5", "6"}; !slices.Equal(got, want) {
t.Errorf("got: %s; want: %s", got, want)
}
}
@@ -314,7 +313,7 @@ func TestDatabaseSuite(t *testing.T, New func() ethdb.KeyValueStore) {
}
it := db.NewIterator(nil, nil)
- if got := iterateKeys(it); !reflect.DeepEqual(got, want) {
+ if got := iterateKeys(it); !slices.Equal(got, want) {
t.Errorf("got: %s; want: %s", got, want)
}
})
@@ -514,7 +513,7 @@ func iterateKeys(it ethdb.Iterator) []string {
return keys
}
-// randomHash generates a random blob of data and returns it as a hash.
+// randBytes generates a random blob of data.
func randBytes(len int) []byte {
buf := make([]byte, len)
if n, err := rand.Read(buf); n != len || err != nil {
diff --git a/ethstats/ethstats.go b/ethstats/ethstats.go
index 6e71666ec1..c845db1164 100644
--- a/ethstats/ethstats.go
+++ b/ethstats/ethstats.go
@@ -544,10 +544,13 @@ func (s *Service) reportLatency(conn *connWrapper) error {
return err
}
// Wait for the pong request to arrive back
+ timer := time.NewTimer(5 * time.Second)
+ defer timer.Stop()
+
select {
case <-s.pongCh:
// Pong delivered, report the latency
- case <-time.After(5 * time.Second):
+ case <-timer.C:
// Ping timeout, abort
return errors.New("ping timed out")
}
diff --git a/go.mod b/go.mod
index 15113972f5..ab268da068 100644
--- a/go.mod
+++ b/go.mod
@@ -67,7 +67,6 @@ require (
github.com/urfave/cli/v2 v2.25.7
go.uber.org/automaxprocs v1.5.2
golang.org/x/crypto v0.21.0
- golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa
golang.org/x/sync v0.5.0
golang.org/x/sys v0.18.0
golang.org/x/text v0.14.0
@@ -140,6 +139,7 @@ require (
github.com/tklauser/go-sysconf v0.3.12 // indirect
github.com/tklauser/numcpus v0.6.1 // indirect
github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
+ golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect
golang.org/x/mod v0.14.0 // indirect
golang.org/x/net v0.21.0 // indirect
google.golang.org/protobuf v1.33.0 // indirect
diff --git a/internal/build/util.go b/internal/build/util.go
index b41014a16f..aee8bf0fc8 100644
--- a/internal/build/util.go
+++ b/internal/build/util.go
@@ -27,7 +27,6 @@ import (
"log"
"os"
"os/exec"
- "path"
"path/filepath"
"strconv"
"strings"
@@ -112,7 +111,7 @@ func RunGit(args ...string) string {
// readGitFile returns content of file in .git directory.
func readGitFile(file string) string {
- content, err := os.ReadFile(path.Join(".git", file))
+ content, err := os.ReadFile(filepath.Join(".git", file))
if err != nil {
return ""
}
@@ -175,7 +174,7 @@ func UploadSFTP(identityFile, host, dir string, files []string) error {
}
in := io.MultiWriter(stdin, os.Stdout)
for _, f := range files {
- fmt.Fprintln(in, "put", f, path.Join(dir, filepath.Base(f)))
+ fmt.Fprintln(in, "put", f, filepath.Join(dir, filepath.Base(f)))
}
fmt.Fprintln(in, "exit")
// Some issue with the PPA sftp server makes it so the server does not
diff --git a/internal/debug/api.go b/internal/debug/api.go
index c262201e3b..5e93585bf8 100644
--- a/internal/debug/api.go
+++ b/internal/debug/api.go
@@ -24,7 +24,6 @@ import (
"bytes"
"errors"
"io"
- "log/slog"
"os"
"os/user"
"path/filepath"
@@ -57,7 +56,7 @@ type HandlerT struct {
// Verbosity sets the log verbosity ceiling. The verbosity of individual packages
// and source files can be raised using Vmodule.
func (*HandlerT) Verbosity(level int) {
- glogger.Verbosity(slog.Level(level))
+ glogger.Verbosity(log.FromLegacyLevel(level))
}
// Vmodule sets the log verbosity pattern. See package log for details on the
diff --git a/internal/debug/flags.go b/internal/debug/flags.go
index 19222c8325..361dc6fcca 100644
--- a/internal/debug/flags.go
+++ b/internal/debug/flags.go
@@ -231,9 +231,9 @@ func Setup(ctx *cli.Context) error {
case ctx.Bool(logjsonFlag.Name):
// Retain backwards compatibility with `--log.json` flag if `--log.format` not set
defer log.Warn("The flag '--log.json' is deprecated, please use '--log.format=json' instead")
- handler = log.JSONHandler(output)
+ handler = log.JSONHandlerWithLevel(output, log.LevelInfo)
case logFmtFlag == "json":
- handler = log.JSONHandler(output)
+ handler = log.JSONHandlerWithLevel(output, log.LevelInfo)
case logFmtFlag == "logfmt":
handler = log.LogfmtHandler(output)
case logFmtFlag == "", logFmtFlag == "terminal":
diff --git a/internal/era/era.go b/internal/era/era.go
index 22715a82e5..2b9e622901 100644
--- a/internal/era/era.go
+++ b/internal/era/era.go
@@ -239,7 +239,7 @@ func (e *Era) readOffset(n uint64) (int64, error) {
return blockIndexRecordOffset + int64(binary.LittleEndian.Uint64(e.buf[:])), nil
}
-// newReader returns a snappy.Reader for the e2store entry value at off.
+// newSnappyReader returns a snappy.Reader for the e2store entry value at off.
func newSnappyReader(e *e2store.Reader, expectedType uint16, off int64) (io.Reader, int64, error) {
r, n, err := e.ReaderAt(expectedType, off)
if err != nil {
diff --git a/internal/era/iterator.go b/internal/era/iterator.go
index d90e9586a4..cc4f27c201 100644
--- a/internal/era/iterator.go
+++ b/internal/era/iterator.go
@@ -18,7 +18,6 @@ package era
import (
"errors"
- "fmt"
"io"
"math/big"
@@ -80,7 +79,7 @@ func (it *Iterator) Block() (*types.Block, error) {
// Receipts returns the receipts for the iterator's current position.
func (it *Iterator) Receipts() (types.Receipts, error) {
if it.inner.Receipts == nil {
- return nil, fmt.Errorf("receipts must be non-nil")
+ return nil, errors.New("receipts must be non-nil")
}
var receipts types.Receipts
err := rlp.Decode(it.inner.Receipts, &receipts)
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index 6009d70031..f965c91375 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -1186,9 +1186,6 @@ func DoEstimateGas(ctx context.Context, b Backend, args TransactionArgs, blockNr
return 0, err
}
call := args.ToMessage(header.BaseFee)
- if err != nil {
- return 0, err
- }
// Run the gas estimation andwrap any revertals into a custom return
estimate, revert, err := gasestimator.Estimate(ctx, call, opts, gasCap)
if err != nil {
@@ -1500,7 +1497,7 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH
} else {
to = crypto.CreateAddress(args.from(), uint64(*args.Nonce))
}
- isPostMerge := header.Difficulty.Cmp(common.Big0) == 0
+ isPostMerge := header.Difficulty.Sign() == 0
// Retrieve the precompiles since they don't need to be added to the access list
precompiles := vm.ActivePrecompiles(b.ChainConfig().Rules(header.Number, isPostMerge, header.Time))
@@ -1519,9 +1516,6 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH
// Set the accesslist to the last al
args.AccessList = &accessList
msg := args.ToMessage(header.BaseFee)
- if err != nil {
- return nil, 0, nil, err
- }
// Apply the transaction with the access list tracer
tracer := logger.NewAccessListTracer(accessList, args.from(), to, precompiles)
@@ -1871,15 +1865,14 @@ type SignTransactionResult struct {
// The node needs to have the private key of the account corresponding with
// the given from address and it needs to be unlocked.
func (s *TransactionAPI) SignTransaction(ctx context.Context, args TransactionArgs) (*SignTransactionResult, error) {
+ args.blobSidecarAllowed = true
+
if args.Gas == nil {
return nil, errors.New("gas not specified")
}
if args.GasPrice == nil && (args.MaxPriorityFeePerGas == nil || args.MaxFeePerGas == nil) {
return nil, errors.New("missing gasPrice or maxFeePerGas/maxPriorityFeePerGas")
}
- if args.IsEIP4844() {
- return nil, errBlobTxNotSupported
- }
if args.Nonce == nil {
return nil, errors.New("nonce not specified")
}
@@ -1895,6 +1888,16 @@ func (s *TransactionAPI) SignTransaction(ctx context.Context, args TransactionAr
if err != nil {
return nil, err
}
+ // If the transaction-to-sign was a blob transaction, then the signed one
+ // no longer retains the blobs, only the blob hashes. In this step, we need
+ // to put back the blob(s).
+ if args.IsEIP4844() {
+ signed = signed.WithBlobTxSidecar(&types.BlobTxSidecar{
+ Blobs: args.Blobs,
+ Commitments: args.Commitments,
+ Proofs: args.Proofs,
+ })
+ }
data, err := signed.MarshalBinary()
if err != nil {
return nil, err
diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go
index 5636309589..6aad4097fe 100644
--- a/internal/ethapi/api_test.go
+++ b/internal/ethapi/api_test.go
@@ -28,6 +28,7 @@ import (
"os"
"path/filepath"
"reflect"
+ "slices"
"testing"
"time"
@@ -54,7 +55,6 @@ import (
"github.com/ethereum/go-ethereum/rpc"
"github.com/holiman/uint256"
"github.com/stretchr/testify/require"
- "golang.org/x/exp/slices"
)
func testTransactionMarshal(t *testing.T, tests []txData, config *params.ChainConfig) {
@@ -1037,11 +1037,8 @@ func TestSignBlobTransaction(t *testing.T) {
}
_, err = api.SignTransaction(context.Background(), argsFromTransaction(res.Tx, b.acc.Address))
- if err == nil {
- t.Fatalf("should fail on blob transaction")
- }
- if !errors.Is(err, errBlobTxNotSupported) {
- t.Errorf("error mismatch. Have: %v, want: %v", err, errBlobTxNotSupported)
+ if err != nil {
+ t.Fatalf("should not fail on blob transaction")
}
}
diff --git a/internal/ethapi/transaction_args.go b/internal/ethapi/transaction_args.go
index bef6082ead..f199f9d912 100644
--- a/internal/ethapi/transaction_args.go
+++ b/internal/ethapi/transaction_args.go
@@ -97,7 +97,7 @@ func (args *TransactionArgs) data() []byte {
// setDefaults fills in default values for unspecified tx fields.
func (args *TransactionArgs) setDefaults(ctx context.Context, b Backend, skipGasEstimation bool) error {
- if err := args.setBlobTxSidecar(ctx, b); err != nil {
+ if err := args.setBlobTxSidecar(ctx); err != nil {
return err
}
if err := args.setFeeDefaults(ctx, b); err != nil {
@@ -290,7 +290,7 @@ func (args *TransactionArgs) setLondonFeeDefaults(ctx context.Context, head *typ
}
// setBlobTxSidecar adds the blob tx
-func (args *TransactionArgs) setBlobTxSidecar(ctx context.Context, b Backend) error {
+func (args *TransactionArgs) setBlobTxSidecar(ctx context.Context) error {
// No blobs, we're done.
if args.Blobs == nil {
return nil
diff --git a/internal/jsre/jsre_test.go b/internal/jsre/jsre_test.go
index bb4ff5fa4f..18ef39e2f4 100644
--- a/internal/jsre/jsre_test.go
+++ b/internal/jsre/jsre_test.go
@@ -18,7 +18,7 @@ package jsre
import (
"os"
- "path"
+ "path/filepath"
"reflect"
"testing"
"time"
@@ -42,7 +42,7 @@ func (no *testNativeObjectBinding) TestMethod(call goja.FunctionCall) goja.Value
func newWithTestJS(t *testing.T, testjs string) *JSRE {
dir := t.TempDir()
if testjs != "" {
- if err := os.WriteFile(path.Join(dir, "test.js"), []byte(testjs), os.ModePerm); err != nil {
+ if err := os.WriteFile(filepath.Join(dir, "test.js"), []byte(testjs), os.ModePerm); err != nil {
t.Fatal("cannot create test.js:", err)
}
}
diff --git a/internal/version/version.go b/internal/version/version.go
index 0daea02b57..2cca54b20f 100644
--- a/internal/version/version.go
+++ b/internal/version/version.go
@@ -65,7 +65,7 @@ func ClientName(clientIdentifier string) string {
)
}
-// runtimeInfo returns build and platform information about the current binary.
+// Info returns build and platform information about the current binary.
//
// If the package that is currently executing is a prefixed by our go-ethereum
// module path, it will print out commit and date VCS information. Otherwise,
diff --git a/log/format.go b/log/format.go
index 515ae66e98..54c071b908 100644
--- a/log/format.go
+++ b/log/format.go
@@ -340,7 +340,7 @@ func writeTimeTermFormat(buf *bytes.Buffer, t time.Time) {
// writePosIntWidth writes non-negative integer i to the buffer, padded on the left
// by zeroes to the given width. Use a width of 0 to omit padding.
-// Adapted from golang.org/x/exp/slog/internal/buffer/buffer.go
+// Adapted from pkg.go.dev/log/slog/internal/buffer
func writePosIntWidth(b *bytes.Buffer, i, width int) {
// Cheap integer to fixed-width decimal ASCII.
// Copied from log/log.go.
diff --git a/log/handler.go b/log/handler.go
index 248e3813fc..c604a62301 100644
--- a/log/handler.go
+++ b/log/handler.go
@@ -115,8 +115,15 @@ func (l *leveler) Level() slog.Level {
// JSONHandler returns a handler which prints records in JSON format.
func JSONHandler(wr io.Writer) slog.Handler {
+ return JSONHandlerWithLevel(wr, levelMaxVerbosity)
+}
+
+// JSONHandlerWithLevel returns a handler which prints records in JSON format that are less than or equal to
+// the specified verbosity level.
+func JSONHandlerWithLevel(wr io.Writer, level slog.Level) slog.Handler {
return slog.NewJSONHandler(wr, &slog.HandlerOptions{
ReplaceAttr: builtinReplaceJSON,
+ Level: &leveler{level},
})
}
diff --git a/log/handler_glog.go b/log/handler_glog.go
index 608d955572..625a036403 100644
--- a/log/handler_glog.go
+++ b/log/handler_glog.go
@@ -21,6 +21,7 @@ import (
"errors"
"fmt"
"log/slog"
+ "maps"
"regexp"
"runtime"
"strconv"
@@ -145,10 +146,7 @@ func (h *GlogHandler) Enabled(ctx context.Context, lvl slog.Level) bool {
func (h *GlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
h.lock.RLock()
- siteCache := make(map[uintptr]slog.Level)
- for k, v := range h.siteCache {
- siteCache[k] = v
- }
+ siteCache := maps.Clone(h.siteCache)
h.lock.RUnlock()
patterns := []pattern{}
diff --git a/log/logger.go b/log/logger.go
index 5672344b0c..8b03b68fc8 100644
--- a/log/logger.go
+++ b/log/logger.go
@@ -156,7 +156,7 @@ func (l *logger) Handler() slog.Handler {
return l.inner.Handler()
}
-// write logs a message at the specified level:
+// Write logs a message at the specified level:
func (l *logger) Write(level slog.Level, msg string, attrs ...any) {
if !l.inner.Enabled(context.Background(), level) {
return
diff --git a/log/logger_test.go b/log/logger_test.go
index d23e16e572..2ea0858547 100644
--- a/log/logger_test.go
+++ b/log/logger_test.go
@@ -50,6 +50,25 @@ func TestTerminalHandlerWithAttrs(t *testing.T) {
}
}
+// Make sure the default json handler outputs debug log lines
+func TestJSONHandler(t *testing.T) {
+ out := new(bytes.Buffer)
+ handler := JSONHandler(out)
+ logger := slog.New(handler)
+ logger.Debug("hi there")
+ if len(out.String()) == 0 {
+ t.Error("expected non-empty debug log output from default JSON Handler")
+ }
+
+ out.Reset()
+ handler = JSONHandlerWithLevel(out, slog.LevelInfo)
+ logger = slog.New(handler)
+ logger.Debug("hi there")
+ if len(out.String()) != 0 {
+ t.Errorf("expected empty debug log output, but got: %v", out.String())
+ }
+}
+
func BenchmarkTraceLogging(b *testing.B) {
SetDefault(NewLogger(NewTerminalHandler(os.Stderr, true)))
b.ResetTimer()
diff --git a/metrics/gauge.go b/metrics/gauge.go
index 5933df3107..6d10bbf856 100644
--- a/metrics/gauge.go
+++ b/metrics/gauge.go
@@ -74,7 +74,7 @@ func (g *StandardGauge) Update(v int64) {
g.value.Store(v)
}
-// Update updates the gauge's value if v is larger then the current value.
+// UpdateIfGt updates the gauge's value if v is larger then the current value.
func (g *StandardGauge) UpdateIfGt(v int64) {
for {
exist := g.value.Load()
diff --git a/metrics/meter.go b/metrics/meter.go
index 22475ef6eb..432838f4ef 100644
--- a/metrics/meter.go
+++ b/metrics/meter.go
@@ -173,7 +173,7 @@ type meterArbiter struct {
var arbiter = meterArbiter{ticker: time.NewTicker(5 * time.Second), meters: make(map[*StandardMeter]struct{})}
-// Ticks meters on the scheduled interval
+// tick meters on the scheduled interval
func (ma *meterArbiter) tick() {
for range ma.ticker.C {
ma.tickMeters()
diff --git a/metrics/metrics.go b/metrics/metrics.go
index 9e0ac23dd5..c7fe5c7333 100644
--- a/metrics/metrics.go
+++ b/metrics/metrics.go
@@ -30,7 +30,7 @@ var enablerFlags = []string{"metrics"}
// enablerEnvVars is the env var names to use to enable metrics collections.
var enablerEnvVars = []string{"GETH_METRICS"}
-// Init enables or disables the metrics system. Since we need this to run before
+// init enables or disables the metrics system. Since we need this to run before
// any other code gets to create meters and timers, we'll actually do an ugly hack
// and peek into the command line args for the metrics flag.
func init() {
diff --git a/metrics/sample.go b/metrics/sample.go
index bb81e105cf..e4735fb6ff 100644
--- a/metrics/sample.go
+++ b/metrics/sample.go
@@ -3,10 +3,9 @@ package metrics
import (
"math"
"math/rand"
+ "slices"
"sync"
"time"
-
- "golang.org/x/exp/slices"
)
const rescaleThreshold = time.Hour
diff --git a/metrics/writer.go b/metrics/writer.go
index 098da45c27..c211c5046b 100644
--- a/metrics/writer.go
+++ b/metrics/writer.go
@@ -3,10 +3,9 @@ package metrics
import (
"fmt"
"io"
+ "slices"
"strings"
"time"
-
- "golang.org/x/exp/slices"
)
// Write sorts writes each metric in the given registry periodically to the
diff --git a/metrics/writer_test.go b/metrics/writer_test.go
index 8376bf8975..edcfe955ab 100644
--- a/metrics/writer_test.go
+++ b/metrics/writer_test.go
@@ -1,9 +1,8 @@
package metrics
import (
+ "slices"
"testing"
-
- "golang.org/x/exp/slices"
)
func TestMetricsSorting(t *testing.T) {
diff --git a/miner/worker.go b/miner/worker.go
index 9f8d9f663f..4924952478 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -75,7 +75,7 @@ type newPayloadResult struct {
receipts []*types.Receipt // Receipts collected during construction
}
-// generateParams wraps various of settings for generating sealing task.
+// generateParams wraps various settings for generating sealing task.
type generateParams struct {
timestamp uint64 // The timestamp for sealing task
forceTime bool // Flag whether the given timestamp is immutable or not
@@ -131,7 +131,7 @@ func (miner *Miner) prepareWork(genParams *generateParams) (*environment, error)
if genParams.parentHash != (common.Hash{}) {
block := miner.chain.GetBlockByHash(genParams.parentHash)
if block == nil {
- return nil, fmt.Errorf("missing parent")
+ return nil, errors.New("missing parent")
}
parent = block.Header()
}
diff --git a/node/node.go b/node/node.go
index dc27861309..bfeb04ddeb 100644
--- a/node/node.go
+++ b/node/node.go
@@ -25,6 +25,7 @@ import (
"os"
"path/filepath"
"reflect"
+ "slices"
"strings"
"sync"
@@ -282,16 +283,6 @@ func (n *Node) openEndpoints() error {
return err
}
-// containsLifecycle checks if 'lfs' contains 'l'.
-func containsLifecycle(lfs []Lifecycle, l Lifecycle) bool {
- for _, obj := range lfs {
- if obj == l {
- return true
- }
- }
- return false
-}
-
// stopServices terminates running services, RPC and p2p networking.
// It is the inverse of Start.
func (n *Node) stopServices(running []Lifecycle) error {
@@ -575,7 +566,7 @@ func (n *Node) RegisterLifecycle(lifecycle Lifecycle) {
if n.state != initializingState {
panic("can't register lifecycle on running/stopped node")
}
- if containsLifecycle(n.lifecycles, lifecycle) {
+ if slices.Contains(n.lifecycles, lifecycle) {
panic(fmt.Sprintf("attempt to register lifecycle %T more than once", lifecycle))
}
n.lifecycles = append(n.lifecycles, lifecycle)
diff --git a/node/node_auth_test.go b/node/node_auth_test.go
index 597cd8531f..900f53440c 100644
--- a/node/node_auth_test.go
+++ b/node/node_auth_test.go
@@ -22,7 +22,7 @@ import (
"fmt"
"net/http"
"os"
- "path"
+ "path/filepath"
"testing"
"time"
@@ -98,7 +98,7 @@ func TestAuthEndpoints(t *testing.T) {
t.Fatalf("failed to create jwt secret: %v", err)
}
// Geth must read it from a file, and does not support in-memory JWT secrets, so we create a temporary file.
- jwtPath := path.Join(t.TempDir(), "jwt_secret")
+ jwtPath := filepath.Join(t.TempDir(), "jwt_secret")
if err := os.WriteFile(jwtPath, []byte(hexutil.Encode(secret[:])), 0600); err != nil {
t.Fatalf("failed to prepare jwt secret file: %v", err)
}
diff --git a/node/node_test.go b/node/node_test.go
index 83fd57bf16..14294c6e56 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -23,6 +23,7 @@ import (
"net"
"net/http"
"reflect"
+ "slices"
"strings"
"testing"
@@ -116,7 +117,7 @@ func TestLifecycleRegistry_Successful(t *testing.T) {
noop := NewNoop()
stack.RegisterLifecycle(noop)
- if !containsLifecycle(stack.lifecycles, noop) {
+ if !slices.Contains(stack.lifecycles, Lifecycle(noop)) {
t.Fatalf("lifecycle was not properly registered on the node, %v", err)
}
}
diff --git a/node/rpcstack.go b/node/rpcstack.go
index c318c33067..609d9a69fd 100644
--- a/node/rpcstack.go
+++ b/node/rpcstack.go
@@ -603,7 +603,7 @@ func newIPCServer(log log.Logger, endpoint string) *ipcServer {
return &ipcServer{log: log, endpoint: endpoint}
}
-// Start starts the httpServer's http.Server
+// start starts the httpServer's http.Server
func (is *ipcServer) start(apis []rpc.API) error {
is.mu.Lock()
defer is.mu.Unlock()
diff --git a/p2p/discover/metrics.go b/p2p/discover/metrics.go
index 56aae24285..3cd0ab0414 100644
--- a/p2p/discover/metrics.go
+++ b/p2p/discover/metrics.go
@@ -44,7 +44,7 @@ func init() {
}
}
-// meteredConn is a wrapper around a net.UDPConn that meters both the
+// meteredUdpConn is a wrapper around a net.UDPConn that meters both the
// inbound and outbound network traffic.
type meteredUdpConn struct {
UDPConn
diff --git a/p2p/discover/ntp.go b/p2p/discover/ntp.go
index 3f9157808f..c8b82ef7e8 100644
--- a/p2p/discover/ntp.go
+++ b/p2p/discover/ntp.go
@@ -22,10 +22,10 @@ package discover
import (
"fmt"
"net"
+ "slices"
"time"
"github.com/ethereum/go-ethereum/log"
- "golang.org/x/exp/slices"
)
const (
diff --git a/p2p/discover/table_util_test.go b/p2p/discover/table_util_test.go
index d6309dfd6c..f5d4d39bdb 100644
--- a/p2p/discover/table_util_test.go
+++ b/p2p/discover/table_util_test.go
@@ -24,12 +24,12 @@ import (
"fmt"
"math/rand"
"net"
+ "slices"
"sync"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/enr"
- "golang.org/x/exp/slices"
)
var nullNode *enode.Node
diff --git a/p2p/discover/v4_lookup_test.go b/p2p/discover/v4_lookup_test.go
index 8867a5a8ac..5682f262be 100644
--- a/p2p/discover/v4_lookup_test.go
+++ b/p2p/discover/v4_lookup_test.go
@@ -20,13 +20,13 @@ import (
"crypto/ecdsa"
"fmt"
"net"
+ "slices"
"testing"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/p2p/discover/v4wire"
"github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/enr"
- "golang.org/x/exp/slices"
)
func TestUDPv4_Lookup(t *testing.T) {
@@ -285,7 +285,7 @@ func (tn *preminedTestnet) neighborsAtDistances(base *enode.Node, distances []ui
for i := range lookupTestnet.dists[d] {
n := lookupTestnet.node(d, i)
d := enode.LogDist(base.ID(), n.ID())
- if containsUint(uint(d), distances) {
+ if slices.Contains(distances, uint(d)) {
result = append(result, n)
if len(result) >= elems {
return result
diff --git a/p2p/discover/v5_udp.go b/p2p/discover/v5_udp.go
index 71f8d8dd08..20a8bccd05 100644
--- a/p2p/discover/v5_udp.go
+++ b/p2p/discover/v5_udp.go
@@ -25,6 +25,7 @@ import (
"fmt"
"io"
"net"
+ "slices"
"sync"
"time"
@@ -437,7 +438,7 @@ func (t *UDPv5) verifyResponseNode(c *callV5, r *enr.Record, distances []uint, s
}
if distances != nil {
nd := enode.LogDist(c.id, node.ID())
- if !containsUint(uint(nd), distances) {
+ if !slices.Contains(distances, uint(nd)) {
return nil, errors.New("does not match any requested distance")
}
}
@@ -448,15 +449,6 @@ func (t *UDPv5) verifyResponseNode(c *callV5, r *enr.Record, distances []uint, s
return node, nil
}
-func containsUint(x uint, xs []uint) bool {
- for _, v := range xs {
- if x == v {
- return true
- }
- }
- return false
-}
-
// callToNode sends the given call and sets up a handler for response packets (of message
// type responseType). Responses are dispatched to the call's response channel.
func (t *UDPv5) callToNode(n *enode.Node, responseType byte, req v5wire.Packet) *callV5 {
diff --git a/p2p/discover/v5_udp_test.go b/p2p/discover/v5_udp_test.go
index eaa969ea8b..4373ea8184 100644
--- a/p2p/discover/v5_udp_test.go
+++ b/p2p/discover/v5_udp_test.go
@@ -24,6 +24,7 @@ import (
"math/rand"
"net"
"reflect"
+ "slices"
"testing"
"time"
@@ -34,7 +35,6 @@ import (
"github.com/ethereum/go-ethereum/p2p/enr"
"github.com/ethereum/go-ethereum/rlp"
"github.com/stretchr/testify/require"
- "golang.org/x/exp/slices"
)
// Real sockets, real crypto: this test checks end-to-end connectivity for UDPv5.
diff --git a/p2p/dnsdisc/client_test.go b/p2p/dnsdisc/client_test.go
index abc35ddbd3..01912e1eab 100644
--- a/p2p/dnsdisc/client_test.go
+++ b/p2p/dnsdisc/client_test.go
@@ -20,6 +20,7 @@ import (
"context"
"crypto/ecdsa"
"errors"
+ "maps"
"reflect"
"testing"
"time"
@@ -214,7 +215,7 @@ func TestIteratorNodeUpdates(t *testing.T) {
// Ensure RandomNode returns the new nodes after the tree is updated.
updateSomeNodes(keys, nodes)
tree2, _ := makeTestTree("n", nodes, nil)
- resolver.clear()
+ clear(resolver)
resolver.add(tree2.ToTXT("n"))
t.Log("tree updated")
@@ -255,7 +256,7 @@ func TestIteratorRootRecheckOnFail(t *testing.T) {
// Ensure RandomNode returns the new nodes after the tree is updated.
updateSomeNodes(keys, nodes)
tree2, _ := makeTestTree("n", nodes, nil)
- resolver.clear()
+ clear(resolver)
resolver.add(tree2.ToTXT("n"))
t.Log("tree updated")
@@ -446,16 +447,8 @@ func newMapResolver(maps ...map[string]string) mapResolver {
return mr
}
-func (mr mapResolver) clear() {
- for k := range mr {
- delete(mr, k)
- }
-}
-
func (mr mapResolver) add(m map[string]string) {
- for k, v := range m {
- mr[k] = v
- }
+ maps.Copy(mr, m)
}
func (mr mapResolver) LookupTXT(ctx context.Context, name string) ([]string, error) {
diff --git a/p2p/dnsdisc/tree.go b/p2p/dnsdisc/tree.go
index dfac4fb372..a8295ac9eb 100644
--- a/p2p/dnsdisc/tree.go
+++ b/p2p/dnsdisc/tree.go
@@ -24,6 +24,7 @@ import (
"errors"
"fmt"
"io"
+ "slices"
"strings"
"github.com/ethereum/go-ethereum/crypto"
@@ -31,7 +32,6 @@ import (
"github.com/ethereum/go-ethereum/p2p/enr"
"github.com/ethereum/go-ethereum/rlp"
"golang.org/x/crypto/sha3"
- "golang.org/x/exp/slices"
)
// Tree is a merkle tree of node records.
diff --git a/p2p/enr/enr_test.go b/p2p/enr/enr_test.go
index b85ee209d5..4fccb0cce9 100644
--- a/p2p/enr/enr_test.go
+++ b/p2p/enr/enr_test.go
@@ -48,7 +48,7 @@ func TestGetSetID(t *testing.T) {
assert.Equal(t, id, id2)
}
-// TestGetSetIP4 tests encoding/decoding and setting/getting of the IP key.
+// TestGetSetIPv4 tests encoding/decoding and setting/getting of the IP key.
func TestGetSetIPv4(t *testing.T) {
ip := IPv4{192, 168, 0, 3}
var r Record
@@ -59,7 +59,7 @@ func TestGetSetIPv4(t *testing.T) {
assert.Equal(t, ip, ip2)
}
-// TestGetSetIP6 tests encoding/decoding and setting/getting of the IP6 key.
+// TestGetSetIPv6 tests encoding/decoding and setting/getting of the IP6 key.
func TestGetSetIPv6(t *testing.T) {
ip := IPv6{0x20, 0x01, 0x48, 0x60, 0, 0, 0x20, 0x01, 0, 0, 0, 0, 0, 0, 0x00, 0x68}
var r Record
diff --git a/p2p/metrics.go b/p2p/metrics.go
index a6e36b91a8..a2ae213b70 100644
--- a/p2p/metrics.go
+++ b/p2p/metrics.go
@@ -37,7 +37,9 @@ const (
)
var (
- activePeerGauge metrics.Gauge = metrics.NilGauge{}
+ activePeerGauge metrics.Gauge = metrics.NilGauge{}
+ activeInboundPeerGauge metrics.Gauge = metrics.NilGauge{}
+ activeOutboundPeerGauge metrics.Gauge = metrics.NilGauge{}
ingressTrafficMeter = metrics.NewRegisteredMeter("p2p/ingress", nil)
egressTrafficMeter = metrics.NewRegisteredMeter("p2p/egress", nil)
@@ -65,6 +67,8 @@ func init() {
}
activePeerGauge = metrics.NewRegisteredGauge("p2p/peers", nil)
+ activeInboundPeerGauge = metrics.NewRegisteredGauge("p2p/peers/inbound", nil)
+ activeOutboundPeerGauge = metrics.NewRegisteredGauge("p2p/peers/outbound", nil)
serveMeter = metrics.NewRegisteredMeter("p2p/serves", nil)
serveSuccessMeter = metrics.NewRegisteredMeter("p2p/serves/success", nil)
dialMeter = metrics.NewRegisteredMeter("p2p/dials", nil)
diff --git a/p2p/nodestate/nodestate.go b/p2p/nodestate/nodestate.go
index 1e1757559c..8052144465 100644
--- a/p2p/nodestate/nodestate.go
+++ b/p2p/nodestate/nodestate.go
@@ -823,7 +823,7 @@ func (ns *NodeStateMachine) addTimeout(n *enode.Node, mask bitMask, timeout time
}
}
-// removeTimeout removes node state timeouts associated to the given state flag(s).
+// removeTimeouts removes node state timeouts associated to the given state flag(s).
// If a timeout was associated to multiple flags which are not all included in the
// specified remove mask then only the included flags are de-associated and the timer
// stays active.
diff --git a/p2p/peer.go b/p2p/peer.go
index 65a7903f58..e4482deae9 100644
--- a/p2p/peer.go
+++ b/p2p/peer.go
@@ -21,6 +21,7 @@ import (
"fmt"
"io"
"net"
+ "slices"
"sync"
"time"
@@ -31,7 +32,6 @@ import (
"github.com/ethereum/go-ethereum/p2p/enode"
"github.com/ethereum/go-ethereum/p2p/enr"
"github.com/ethereum/go-ethereum/rlp"
- "golang.org/x/exp/slices"
)
var (
diff --git a/p2p/server.go b/p2p/server.go
index 5b7afb4565..5b9a4aa71f 100644
--- a/p2p/server.go
+++ b/p2p/server.go
@@ -24,6 +24,7 @@ import (
"errors"
"fmt"
"net"
+ "slices"
"sync"
"sync/atomic"
"time"
@@ -38,7 +39,6 @@ import (
"github.com/ethereum/go-ethereum/p2p/enr"
"github.com/ethereum/go-ethereum/p2p/nat"
"github.com/ethereum/go-ethereum/p2p/netutil"
- "golang.org/x/exp/slices"
)
const (
@@ -771,8 +771,10 @@ running:
if p.Inbound() {
inboundCount++
serveSuccessMeter.Mark(1)
+ activeInboundPeerGauge.Inc(1)
} else {
dialSuccessMeter.Mark(1)
+ activeOutboundPeerGauge.Inc(1)
}
activePeerGauge.Inc(1)
}
@@ -786,6 +788,9 @@ running:
srv.dialsched.peerRemoved(pd.rw)
if pd.Inbound() {
inboundCount--
+ activeInboundPeerGauge.Dec(1)
+ } else {
+ activeOutboundPeerGauge.Dec(1)
}
activePeerGauge.Dec(1)
}
diff --git a/p2p/simulations/adapters/exec.go b/p2p/simulations/adapters/exec.go
index 5df2d7649c..6307b90bf8 100644
--- a/p2p/simulations/adapters/exec.go
+++ b/p2p/simulations/adapters/exec.go
@@ -303,10 +303,13 @@ func (n *ExecNode) Stop() error {
go func() {
waitErr <- n.Cmd.Wait()
}()
+ timer := time.NewTimer(5 * time.Second)
+ defer timer.Stop()
+
select {
case err := <-waitErr:
return err
- case <-time.After(5 * time.Second):
+ case <-timer.C:
return n.Cmd.Process.Kill()
}
}
diff --git a/p2p/simulations/adapters/types.go b/p2p/simulations/adapters/types.go
index a26dff7a82..f34315f170 100644
--- a/p2p/simulations/adapters/types.go
+++ b/p2p/simulations/adapters/types.go
@@ -299,7 +299,7 @@ func RegisterLifecycles(lifecycles LifecycleConstructors) {
}
// adds the host part to the configuration's ENR, signs it
-// creates and the corresponding enode object to the configuration
+// creates and adds the corresponding enode object to the configuration
func (n *NodeConfig) initEnode(ip net.IP, tcpport int, udpport int) error {
enrIp := enr.IP(ip)
n.Record.Set(&enrIp)
diff --git a/p2p/simulations/http_test.go b/p2p/simulations/http_test.go
index 460ed72d7f..cd03e600f3 100644
--- a/p2p/simulations/http_test.go
+++ b/p2p/simulations/http_test.go
@@ -838,7 +838,7 @@ func TestMsgFilterPassSingle(t *testing.T) {
})
}
-// TestMsgFilterPassSingle tests streaming message events using an invalid
+// TestMsgFilterFailBadParams tests streaming message events using an invalid
// filter
func TestMsgFilterFailBadParams(t *testing.T) {
// start the server
diff --git a/p2p/simulations/mocker.go b/p2p/simulations/mocker.go
index 0dc04e65f9..8763df67ef 100644
--- a/p2p/simulations/mocker.go
+++ b/p2p/simulations/mocker.go
@@ -65,8 +65,13 @@ func startStop(net *Network, quit chan struct{}, nodeCount int) {
if err != nil {
panic("Could not startup node network for mocker")
}
- tick := time.NewTicker(10 * time.Second)
+ var (
+ tick = time.NewTicker(10 * time.Second)
+ timer = time.NewTimer(3 * time.Second)
+ )
defer tick.Stop()
+ defer timer.Stop()
+
for {
select {
case <-quit:
@@ -80,11 +85,12 @@ func startStop(net *Network, quit chan struct{}, nodeCount int) {
return
}
+ timer.Reset(3 * time.Second)
select {
case <-quit:
log.Info("Terminating simulation loop")
return
- case <-time.After(3 * time.Second):
+ case <-timer.C:
}
log.Debug("starting node", "id", id)
diff --git a/p2p/simulations/network.go b/p2p/simulations/network.go
index 4735e5cfa6..2eb8333cd6 100644
--- a/p2p/simulations/network.go
+++ b/p2p/simulations/network.go
@@ -535,7 +535,7 @@ func (net *Network) GetRandomUpNode(excludeIDs ...enode.ID) *Node {
return net.getRandomUpNode(excludeIDs...)
}
-// GetRandomUpNode returns a random node on the network, which is running.
+// getRandomUpNode returns a random node on the network, which is running.
func (net *Network) getRandomUpNode(excludeIDs ...enode.ID) *Node {
return net.getRandomNode(net.getUpNodeIDs(), excludeIDs)
}
@@ -1028,11 +1028,14 @@ func (net *Network) Load(snap *Snapshot) error {
}
}
+ timeout := time.NewTimer(snapshotLoadTimeout)
+ defer timeout.Stop()
+
select {
// Wait until all connections from the snapshot are established.
case <-allConnected:
// Make sure that we do not wait forever.
- case <-time.After(snapshotLoadTimeout):
+ case <-timeout.C:
return errors.New("snapshot connections not established")
}
return nil
diff --git a/rlp/decode.go b/rlp/decode.go
index 47801b2090..0fbca243ee 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -158,17 +158,17 @@ func makeDecoder(typ reflect.Type, tags rlpstruct.Tags) (dec decoder, err error)
switch {
case typ == rawValueType:
return decodeRawValue, nil
- case typ.AssignableTo(reflect.PtrTo(bigInt)):
+ case typ.AssignableTo(reflect.PointerTo(bigInt)):
return decodeBigInt, nil
case typ.AssignableTo(bigInt):
return decodeBigIntNoPtr, nil
- case typ == reflect.PtrTo(u256Int):
+ case typ == reflect.PointerTo(u256Int):
return decodeU256, nil
case typ == u256Int:
return decodeU256NoPtr, nil
case kind == reflect.Ptr:
return makePtrDecoder(typ, tags)
- case reflect.PtrTo(typ).Implements(decoderInterface):
+ case reflect.PointerTo(typ).Implements(decoderInterface):
return decodeDecoder, nil
case isUint(kind):
return decodeUint, nil
@@ -262,7 +262,7 @@ func decodeU256(s *Stream, val reflect.Value) error {
func makeListDecoder(typ reflect.Type, tag rlpstruct.Tags) (decoder, error) {
etype := typ.Elem()
- if etype.Kind() == reflect.Uint8 && !reflect.PtrTo(etype).Implements(decoderInterface) {
+ if etype.Kind() == reflect.Uint8 && !reflect.PointerTo(etype).Implements(decoderInterface) {
if typ.Kind() == reflect.Array {
return decodeByteArray, nil
}
@@ -474,7 +474,7 @@ func makeSimplePtrDecoder(etype reflect.Type, etypeinfo *typeinfo) decoder {
//
// This decoder is used for pointer-typed struct fields with struct tag "nil".
func makeNilPtrDecoder(etype reflect.Type, etypeinfo *typeinfo, ts rlpstruct.Tags) decoder {
- typ := reflect.PtrTo(etype)
+ typ := reflect.PointerTo(etype)
nilPtr := reflect.Zero(typ)
// Determine the value kind that results in nil pointer.
diff --git a/rlp/encode.go b/rlp/encode.go
index ffb42b2997..3645bbfda0 100644
--- a/rlp/encode.go
+++ b/rlp/encode.go
@@ -141,17 +141,17 @@ func makeWriter(typ reflect.Type, ts rlpstruct.Tags) (writer, error) {
switch {
case typ == rawValueType:
return writeRawValue, nil
- case typ.AssignableTo(reflect.PtrTo(bigInt)):
+ case typ.AssignableTo(reflect.PointerTo(bigInt)):
return writeBigIntPtr, nil
case typ.AssignableTo(bigInt):
return writeBigIntNoPtr, nil
- case typ == reflect.PtrTo(u256Int):
+ case typ == reflect.PointerTo(u256Int):
return writeU256IntPtr, nil
case typ == u256Int:
return writeU256IntNoPtr, nil
case kind == reflect.Ptr:
return makePtrWriter(typ, ts)
- case reflect.PtrTo(typ).Implements(encoderInterface):
+ case reflect.PointerTo(typ).Implements(encoderInterface):
return makeEncoderWriter(typ), nil
case isUint(kind):
return writeUint, nil
diff --git a/rlp/typecache.go b/rlp/typecache.go
index 3e37c9d2fc..eebf4cd611 100644
--- a/rlp/typecache.go
+++ b/rlp/typecache.go
@@ -18,6 +18,7 @@ package rlp
import (
"fmt"
+ "maps"
"reflect"
"sync"
"sync/atomic"
@@ -90,10 +91,7 @@ func (c *typeCache) generate(typ reflect.Type, tags rlpstruct.Tags) *typeinfo {
}
// Copy cur to next.
- c.next = make(map[typekey]*typeinfo, len(cur)+1)
- for k, v := range cur {
- c.next[k] = v
- }
+ c.next = maps.Clone(cur)
// Generate.
info := c.infoWhileGenerating(typ, tags)
diff --git a/rpc/handler.go b/rpc/handler.go
index 792581cbc0..7b8f64aa7b 100644
--- a/rpc/handler.go
+++ b/rpc/handler.go
@@ -388,7 +388,7 @@ func (h *handler) startCallProc(fn func(*callProc)) {
}()
}
-// handleResponse processes method call responses.
+// handleResponses processes method call responses.
func (h *handler) handleResponses(batch []*jsonrpcMessage, handleCall func(*jsonrpcMessage)) {
var resolvedops []*requestOp
handleResp := func(msg *jsonrpcMessage) {
diff --git a/rpc/ipc_unix.go b/rpc/ipc_unix.go
index 33c1cad549..588bf62605 100644
--- a/rpc/ipc_unix.go
+++ b/rpc/ipc_unix.go
@@ -25,14 +25,16 @@ import (
"net"
"os"
"path/filepath"
+ "syscall"
"github.com/ethereum/go-ethereum/log"
)
const (
- // On Linux, sun_path is 108 bytes in size
- // see http://man7.org/linux/man-pages/man7/unix.7.html
- maxPathSize = int(108)
+ // The limit of unix domain socket path diverse between OS, on Darwin it's 104 bytes
+ // but on Linux it's 108 byte, so we should depend on syscall.RawSockaddrUnix's
+ // definition dynamically
+ maxPathSize = len(syscall.RawSockaddrUnix{}.Path)
)
// ipcListen will create a Unix socket on the given endpoint.
diff --git a/rpc/json.go b/rpc/json.go
index 5557a80760..e932389d17 100644
--- a/rpc/json.go
+++ b/rpc/json.go
@@ -266,7 +266,7 @@ func (c *jsonCodec) close() {
})
}
-// Closed returns a channel which will be closed when Close is called
+// closed returns a channel which will be closed when Close is called
func (c *jsonCodec) closed() <-chan interface{} {
return c.closeCh
}
diff --git a/rpc/service.go b/rpc/service.go
index a180b8db93..c13b3c0af0 100644
--- a/rpc/service.go
+++ b/rpc/service.go
@@ -227,7 +227,7 @@ func isSubscriptionType(t reflect.Type) bool {
return t == subscriptionType
}
-// isPubSub tests whether the given method has as as first argument a context.Context and
+// isPubSub tests whether the given method's first argument is a context.Context and
// returns the pair (Subscription, error).
func isPubSub(methodType reflect.Type) bool {
// numIn(0) is the receiver type
diff --git a/rpc/subscription_test.go b/rpc/subscription_test.go
index 3a131c8e6b..a7dac705c9 100644
--- a/rpc/subscription_test.go
+++ b/rpc/subscription_test.go
@@ -235,10 +235,10 @@ func (c *mockConn) writeJSON(ctx context.Context, msg interface{}, isError bool)
return c.enc.Encode(msg)
}
-// Closed returns a channel which is closed when the connection is closed.
+// closed returns a channel which is closed when the connection is closed.
func (c *mockConn) closed() <-chan interface{} { return nil }
-// RemoteAddr returns the peer address of the connection.
+// remoteAddr returns the peer address of the connection.
func (c *mockConn) remoteAddr() string { return "" }
// BenchmarkNotify benchmarks the performance of notifying a subscription.
diff --git a/signer/core/api.go b/signer/core/api.go
index a32f24cb18..23ddcd0a20 100644
--- a/signer/core/api.go
+++ b/signer/core/api.go
@@ -590,7 +590,10 @@ func (api *SignerAPI) SignTransaction(ctx context.Context, args apitypes.SendTxA
return nil, err
}
// Convert fields into a real transaction
- var unsignedTx = result.Transaction.ToTransaction()
+ unsignedTx, err := result.Transaction.ToTransaction()
+ if err != nil {
+ return nil, err
+ }
// Get the password for the transaction
pw, err := api.lookupOrQueryPassword(acc.Address, "Account password",
fmt.Sprintf("Please enter the password for account %s", acc.Address.String()))
diff --git a/signer/core/apitypes/types.go b/signer/core/apitypes/types.go
index e28f059106..9113c091c5 100644
--- a/signer/core/apitypes/types.go
+++ b/signer/core/apitypes/types.go
@@ -18,12 +18,14 @@ package apitypes
import (
"bytes"
+ "crypto/sha256"
"encoding/json"
"errors"
"fmt"
"math/big"
"reflect"
"regexp"
+ "slices"
"sort"
"strconv"
"strings"
@@ -34,6 +36,8 @@ import (
"github.com/ethereum/go-ethereum/common/math"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
+ "github.com/ethereum/go-ethereum/crypto/kzg4844"
+ "github.com/holiman/uint256"
)
var typedDataReferenceTypeRegexp = regexp.MustCompile(`^[A-Za-z](\w*)(\[\])?$`)
@@ -92,12 +96,21 @@ type SendTxArgs struct {
// We accept "data" and "input" for backwards-compatibility reasons.
// "input" is the newer name and should be preferred by clients.
// Issue detail: https://github.com/ethereum/go-ethereum/issues/15628
- Data *hexutil.Bytes `json:"data"`
+ Data *hexutil.Bytes `json:"data,omitempty"`
Input *hexutil.Bytes `json:"input,omitempty"`
// For non-legacy transactions
AccessList *types.AccessList `json:"accessList,omitempty"`
ChainID *hexutil.Big `json:"chainId,omitempty"`
+
+ // For BlobTxType
+ BlobFeeCap *hexutil.Big `json:"maxFeePerBlobGas,omitempty"`
+ BlobHashes []common.Hash `json:"blobVersionedHashes,omitempty"`
+
+ // For BlobTxType transactions with blob sidecar
+ Blobs []kzg4844.Blob `json:"blobs,omitempty"`
+ Commitments []kzg4844.Commitment `json:"commitments,omitempty"`
+ Proofs []kzg4844.Proof `json:"proofs,omitempty"`
}
func (args SendTxArgs) String() string {
@@ -108,24 +121,56 @@ func (args SendTxArgs) String() string {
return err.Error()
}
+// data retrieves the transaction calldata. Input field is preferred.
+func (args *SendTxArgs) data() []byte {
+ if args.Input != nil {
+ return *args.Input
+ }
+ if args.Data != nil {
+ return *args.Data
+ }
+ return nil
+}
+
// ToTransaction converts the arguments to a transaction.
-func (args *SendTxArgs) ToTransaction() *types.Transaction {
+func (args *SendTxArgs) ToTransaction() (*types.Transaction, error) {
// Add the To-field, if specified
var to *common.Address
if args.To != nil {
dstAddr := args.To.Address()
to = &dstAddr
}
-
- var input []byte
- if args.Input != nil {
- input = *args.Input
- } else if args.Data != nil {
- input = *args.Data
+ if err := args.validateTxSidecar(); err != nil {
+ return nil, err
}
-
var data types.TxData
switch {
+ case args.BlobHashes != nil:
+ al := types.AccessList{}
+ if args.AccessList != nil {
+ al = *args.AccessList
+ }
+ data = &types.BlobTx{
+ To: *to,
+ ChainID: uint256.MustFromBig((*big.Int)(args.ChainID)),
+ Nonce: uint64(args.Nonce),
+ Gas: uint64(args.Gas),
+ GasFeeCap: uint256.MustFromBig((*big.Int)(args.MaxFeePerGas)),
+ GasTipCap: uint256.MustFromBig((*big.Int)(args.MaxPriorityFeePerGas)),
+ Value: uint256.MustFromBig((*big.Int)(&args.Value)),
+ Data: args.data(),
+ AccessList: al,
+ BlobHashes: args.BlobHashes,
+ BlobFeeCap: uint256.MustFromBig((*big.Int)(args.BlobFeeCap)),
+ }
+ if args.Blobs != nil {
+ data.(*types.BlobTx).Sidecar = &types.BlobTxSidecar{
+ Blobs: args.Blobs,
+ Commitments: args.Commitments,
+ Proofs: args.Proofs,
+ }
+ }
+
case args.MaxFeePerGas != nil:
al := types.AccessList{}
if args.AccessList != nil {
@@ -139,7 +184,7 @@ func (args *SendTxArgs) ToTransaction() *types.Transaction {
GasFeeCap: (*big.Int)(args.MaxFeePerGas),
GasTipCap: (*big.Int)(args.MaxPriorityFeePerGas),
Value: (*big.Int)(&args.Value),
- Data: input,
+ Data: args.data(),
AccessList: al,
}
case args.AccessList != nil:
@@ -150,7 +195,7 @@ func (args *SendTxArgs) ToTransaction() *types.Transaction {
Gas: uint64(args.Gas),
GasPrice: (*big.Int)(args.GasPrice),
Value: (*big.Int)(&args.Value),
- Data: input,
+ Data: args.data(),
AccessList: *args.AccessList,
}
default:
@@ -160,10 +205,81 @@ func (args *SendTxArgs) ToTransaction() *types.Transaction {
Gas: uint64(args.Gas),
GasPrice: (*big.Int)(args.GasPrice),
Value: (*big.Int)(&args.Value),
- Data: input,
+ Data: args.data(),
}
}
- return types.NewTx(data)
+
+ return types.NewTx(data), nil
+}
+
+// validateTxSidecar validates blob data, if present
+func (args *SendTxArgs) validateTxSidecar() error {
+ // No blobs, we're done.
+ if args.Blobs == nil {
+ return nil
+ }
+
+ n := len(args.Blobs)
+ // Assume user provides either only blobs (w/o hashes), or
+ // blobs together with commitments and proofs.
+ if args.Commitments == nil && args.Proofs != nil {
+ return errors.New(`blob proofs provided while commitments were not`)
+ } else if args.Commitments != nil && args.Proofs == nil {
+ return errors.New(`blob commitments provided while proofs were not`)
+ }
+
+ // len(blobs) == len(commitments) == len(proofs) == len(hashes)
+ if args.Commitments != nil && len(args.Commitments) != n {
+ return fmt.Errorf("number of blobs and commitments mismatch (have=%d, want=%d)", len(args.Commitments), n)
+ }
+ if args.Proofs != nil && len(args.Proofs) != n {
+ return fmt.Errorf("number of blobs and proofs mismatch (have=%d, want=%d)", len(args.Proofs), n)
+ }
+ if args.BlobHashes != nil && len(args.BlobHashes) != n {
+ return fmt.Errorf("number of blobs and hashes mismatch (have=%d, want=%d)", len(args.BlobHashes), n)
+ }
+
+ if args.Commitments == nil {
+ // Generate commitment and proof.
+ commitments := make([]kzg4844.Commitment, n)
+ proofs := make([]kzg4844.Proof, n)
+ for i, b := range args.Blobs {
+ c, err := kzg4844.BlobToCommitment(&b)
+ if err != nil {
+ return fmt.Errorf("blobs[%d]: error computing commitment: %v", i, err)
+ }
+ commitments[i] = c
+ p, err := kzg4844.ComputeBlobProof(&b, c)
+ if err != nil {
+ return fmt.Errorf("blobs[%d]: error computing proof: %v", i, err)
+ }
+ proofs[i] = p
+ }
+ args.Commitments = commitments
+ args.Proofs = proofs
+ } else {
+ for i, b := range args.Blobs {
+ if err := kzg4844.VerifyBlobProof(&b, args.Commitments[i], args.Proofs[i]); err != nil {
+ return fmt.Errorf("failed to verify blob proof: %v", err)
+ }
+ }
+ }
+
+ hashes := make([]common.Hash, n)
+ hasher := sha256.New()
+ for i, c := range args.Commitments {
+ hashes[i] = kzg4844.CalcBlobHashV1(hasher, &c)
+ }
+ if args.BlobHashes != nil {
+ for i, h := range hashes {
+ if h != args.BlobHashes[i] {
+ return fmt.Errorf("blob hash verification failed (have=%s, want=%s)", args.BlobHashes[i], h)
+ }
+ }
+ } else {
+ args.BlobHashes = hashes
+ }
+ return nil
}
type SigFormat struct {
@@ -271,16 +387,8 @@ func (typedData *TypedData) HashStruct(primaryType string, data TypedDataMessage
// Dependencies returns an array of custom types ordered by their hierarchical reference tree
func (typedData *TypedData) Dependencies(primaryType string, found []string) []string {
primaryType = strings.TrimSuffix(primaryType, "[]")
- includes := func(arr []string, str string) bool {
- for _, obj := range arr {
- if obj == str {
- return true
- }
- }
- return false
- }
- if includes(found, primaryType) {
+ if slices.Contains(found, primaryType) {
return found
}
if typedData.Types[primaryType] == nil {
@@ -289,7 +397,7 @@ func (typedData *TypedData) Dependencies(primaryType string, found []string) []s
found = append(found, primaryType)
for _, field := range typedData.Types[primaryType] {
for _, dep := range typedData.Dependencies(field.Type, found) {
- if !includes(found, dep) {
+ if !slices.Contains(found, dep) {
found = append(found, dep)
}
}
@@ -704,7 +812,7 @@ func formatPrimitiveValue(encType string, encValue interface{}) (string, error)
return "", fmt.Errorf("unhandled type %v", encType)
}
-// Validate checks if the types object is conformant to the specs
+// validate checks if the types object is conformant to the specs
func (t Types) validate() error {
for typeKey, typeArr := range t {
if len(typeKey) == 0 {
diff --git a/signer/core/apitypes/types_test.go b/signer/core/apitypes/types_test.go
index b5aa3d1e93..7ea32f298c 100644
--- a/signer/core/apitypes/types_test.go
+++ b/signer/core/apitypes/types_test.go
@@ -16,7 +16,16 @@
package apitypes
-import "testing"
+import (
+ "crypto/sha256"
+ "encoding/json"
+ "testing"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/crypto/kzg4844"
+ "github.com/holiman/uint256"
+)
func TestIsPrimitive(t *testing.T) {
t.Parallel()
@@ -39,3 +48,96 @@ func TestIsPrimitive(t *testing.T) {
}
}
}
+
+func TestTxArgs(t *testing.T) {
+ for i, tc := range []struct {
+ data []byte
+ want common.Hash
+ wantType uint8
+ }{
+ {
+ data: []byte(`{"from":"0x1b442286e32ddcaa6e2570ce9ed85f4b4fc87425","accessList":[],"blobVersionedHashes":["0x010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c444014"],"chainId":"0x7","gas":"0x124f8","gasPrice":"0x693d4ca8","input":"0x","maxFeePerBlobGas":"0x3b9aca00","maxFeePerGas":"0x6fc23ac00","maxPriorityFeePerGas":"0x3b9aca00","nonce":"0x0","r":"0x2a922afc784d07e98012da29f2f37cae1f73eda78aa8805d3df6ee5dbb41ec1","s":"0x4f1f75ae6bcdf4970b4f305da1a15d8c5ddb21f555444beab77c9af2baab14","to":"0x1b442286e32ddcaa6e2570ce9ed85f4b4fc87425","type":"0x1","v":"0x0","value":"0x0","yParity":"0x0"}`),
+ want: common.HexToHash("0x7d53234acc11ac5b5948632c901a944694e228795782f511887d36fd76ff15c4"),
+ wantType: types.BlobTxType,
+ },
+ {
+ // on input, we don't read the type, but infer the type from the arguments present
+ data: []byte(`{"from":"0x1b442286e32ddcaa6e2570ce9ed85f4b4fc87425","accessList":[],"chainId":"0x7","gas":"0x124f8","gasPrice":"0x693d4ca8","input":"0x","maxFeePerBlobGas":"0x3b9aca00","maxFeePerGas":"0x6fc23ac00","maxPriorityFeePerGas":"0x3b9aca00","nonce":"0x0","r":"0x2a922afc784d07e98012da29f2f37cae1f73eda78aa8805d3df6ee5dbb41ec1","s":"0x4f1f75ae6bcdf4970b4f305da1a15d8c5ddb21f555444beab77c9af2baab14","to":"0x1b442286e32ddcaa6e2570ce9ed85f4b4fc87425","type":"0x12","v":"0x0","value":"0x0","yParity":"0x0"}`),
+ want: common.HexToHash("0x7919e2b0b9b543cb87a137b6ff66491ec7ae937cb88d3c29db4d9b28073dce53"),
+ wantType: types.DynamicFeeTxType,
+ },
+ } {
+ var txArgs SendTxArgs
+ if err := json.Unmarshal(tc.data, &txArgs); err != nil {
+ t.Fatal(err)
+ }
+ tx, err := txArgs.ToTransaction()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if have := tx.Type(); have != tc.wantType {
+ t.Errorf("test %d, have type %d, want type %d", i, have, tc.wantType)
+ }
+ if have := tx.Hash(); have != tc.want {
+ t.Errorf("test %d: have %v, want %v", i, have, tc.want)
+ }
+ d2, err := json.Marshal(txArgs)
+ if err != nil {
+ t.Fatal(err)
+ }
+ var txArgs2 SendTxArgs
+ if err := json.Unmarshal(d2, &txArgs2); err != nil {
+ t.Fatal(err)
+ }
+ tx1, _ := txArgs.ToTransaction()
+ tx2, _ := txArgs2.ToTransaction()
+ if have, want := tx1.Hash(), tx2.Hash(); have != want {
+ t.Errorf("test %d: have %v, want %v", i, have, want)
+ }
+ }
+ /*
+ End to end testing:
+
+ $ go run ./cmd/clef --advanced --suppress-bootwarn
+
+ $ go run ./cmd/geth --nodiscover --maxpeers 0 --signer /home/user/.clef/clef.ipc console
+
+ > tx={"from":"0x1b442286e32ddcaa6e2570ce9ed85f4b4fc87425","to":"0x1b442286e32ddcaa6e2570ce9ed85f4b4fc87425","gas":"0x124f8","maxFeePerGas":"0x6fc23ac00","maxPriorityFeePerGas":"0x3b9aca00","value":"0x0","nonce":"0x0","input":"0x","accessList":[],"maxFeePerBlobGas":"0x3b9aca00","blobVersionedHashes":["0x010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c444014"]}
+ > eth.signTransaction(tx)
+ */
+}
+
+func TestBlobTxs(t *testing.T) {
+ blob := kzg4844.Blob{0x1}
+ commitment, err := kzg4844.BlobToCommitment(&blob)
+ if err != nil {
+ t.Fatal(err)
+ }
+ proof, err := kzg4844.ComputeBlobProof(&blob, commitment)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ hash := kzg4844.CalcBlobHashV1(sha256.New(), &commitment)
+ b := &types.BlobTx{
+ ChainID: uint256.NewInt(6),
+ Nonce: 8,
+ GasTipCap: uint256.NewInt(500),
+ GasFeeCap: uint256.NewInt(600),
+ Gas: 21000,
+ BlobFeeCap: uint256.NewInt(700),
+ BlobHashes: []common.Hash{hash},
+ Value: uint256.NewInt(100),
+ Sidecar: &types.BlobTxSidecar{
+ Blobs: []kzg4844.Blob{blob},
+ Commitments: []kzg4844.Commitment{commitment},
+ Proofs: []kzg4844.Proof{proof},
+ },
+ }
+ tx := types.NewTx(b)
+ data, err := json.Marshal(tx)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Logf("tx %v", string(data))
+}
diff --git a/signer/core/cliui.go b/signer/core/cliui.go
index b1bd3206ed..e04077865d 100644
--- a/signer/core/cliui.go
+++ b/signer/core/cliui.go
@@ -128,7 +128,7 @@ func (ui *CommandlineUI) ApproveTx(request *SignTxRequest) (SignTxResponse, erro
fmt.Printf("chainid: %v\n", chainId)
}
if list := request.Transaction.AccessList; list != nil {
- fmt.Printf("Accesslist\n")
+ fmt.Printf("Accesslist:\n")
for i, el := range *list {
fmt.Printf(" %d. %v\n", i, el.Address)
for j, slot := range el.StorageKeys {
@@ -136,6 +136,12 @@ func (ui *CommandlineUI) ApproveTx(request *SignTxRequest) (SignTxResponse, erro
}
}
}
+ if len(request.Transaction.BlobHashes) > 0 {
+ fmt.Printf("Blob hashes:\n")
+ for _, bh := range request.Transaction.BlobHashes {
+ fmt.Printf(" %v\n", bh)
+ }
+ }
if request.Transaction.Data != nil {
d := *request.Transaction.Data
if len(d) > 0 {
diff --git a/signer/core/signed_data_test.go b/signer/core/signed_data_test.go
index 1cf8b4bf38..d0637010ba 100644
--- a/signer/core/signed_data_test.go
+++ b/signer/core/signed_data_test.go
@@ -23,7 +23,7 @@ import (
"fmt"
"math/big"
"os"
- "path"
+ "path/filepath"
"strings"
"testing"
@@ -385,7 +385,7 @@ func TestJsonFiles(t *testing.T) {
continue
}
expectedFailure := strings.HasPrefix(fInfo.Name(), "expfail")
- data, err := os.ReadFile(path.Join("testdata", fInfo.Name()))
+ data, err := os.ReadFile(filepath.Join("testdata", fInfo.Name()))
if err != nil {
t.Errorf("Failed to read file %v: %v", fInfo.Name(), err)
continue
@@ -411,14 +411,14 @@ func TestJsonFiles(t *testing.T) {
// crashes or hangs.
func TestFuzzerFiles(t *testing.T) {
t.Parallel()
- corpusdir := path.Join("testdata", "fuzzing")
+ corpusdir := filepath.Join("testdata", "fuzzing")
testfiles, err := os.ReadDir(corpusdir)
if err != nil {
t.Fatalf("failed reading files: %v", err)
}
verbose := false
for i, fInfo := range testfiles {
- data, err := os.ReadFile(path.Join(corpusdir, fInfo.Name()))
+ data, err := os.ReadFile(filepath.Join(corpusdir, fInfo.Name()))
if err != nil {
t.Errorf("Failed to read file %v: %v", fInfo.Name(), err)
continue
@@ -671,7 +671,7 @@ func TestGnosisTypedDataWithChainId(t *testing.T) {
}
}
-// TestGnosisCustomData tests the scenario where a user submits only the gnosis-safe
+// TestGnosisCustomDataWithChainId tests the scenario where a user submits only the gnosis-safe
// specific data, and we fill the TypedData struct on our side
func TestGnosisCustomDataWithChainId(t *testing.T) {
t.Parallel()
diff --git a/signer/fourbyte/validation.go b/signer/fourbyte/validation.go
index 58111e8e00..8bff011925 100644
--- a/signer/fourbyte/validation.go
+++ b/signer/fourbyte/validation.go
@@ -20,7 +20,6 @@ import (
"bytes"
"errors"
"fmt"
- "math/big"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/signer/core/apitypes"
@@ -36,6 +35,11 @@ func (db *Database) ValidateTransaction(selector *string, tx *apitypes.SendTxArg
if tx.Data != nil && tx.Input != nil && !bytes.Equal(*tx.Data, *tx.Input) {
return nil, errors.New(`ambiguous request: both "data" and "input" are set and are not identical`)
}
+ // ToTransaction validates, among other things, that blob hashes match with blobs, and also
+ // populates the hashes if they were previously unset.
+ if _, err := tx.ToTransaction(); err != nil {
+ return nil, err
+ }
// Place data on 'data', and nil 'input'
var data []byte
if tx.Input != nil {
@@ -52,7 +56,7 @@ func (db *Database) ValidateTransaction(selector *string, tx *apitypes.SendTxArg
// e.g. https://github.com/ethereum/go-ethereum/issues/16106.
if len(data) == 0 {
// Prevent sending ether into black hole (show stopper)
- if tx.Value.ToInt().Cmp(big.NewInt(0)) > 0 {
+ if tx.Value.ToInt().Sign() > 0 {
return nil, errors.New("transaction will create a contract with value but empty code")
}
// No value submitted at least, critically Warn, but don't blow up
diff --git a/tests/block_test.go b/tests/block_test.go
index 1ba84f5f24..43e3d99b3e 100644
--- a/tests/block_test.go
+++ b/tests/block_test.go
@@ -64,6 +64,14 @@ func TestExecutionSpecBlocktests(t *testing.T) {
}
bt := new(testMatcher)
+ // These tests fail as of https://github.com/ethereum/go-ethereum/pull/28666, since we
+ // no longer delete "leftover storage" when deploying a contract.
+ bt.skipLoad(`^cancun/eip6780_selfdestruct/selfdestruct/self_destructing_initcode_create_tx.json`)
+ bt.skipLoad(`^cancun/eip6780_selfdestruct/selfdestruct/self_destructing_initcode.json`)
+ bt.skipLoad(`^cancun/eip6780_selfdestruct/selfdestruct/recreate_self_destructed_contract_different_txs.json`)
+ bt.skipLoad(`^cancun/eip6780_selfdestruct/selfdestruct/delegatecall_from_new_contract_to_pre_existing_contract.json`)
+ bt.skipLoad(`^cancun/eip6780_selfdestruct/selfdestruct/create_selfdestruct_same_tx.json`)
+
bt.walk(t, executionSpecBlockchainTestDir, func(t *testing.T, name string, test *BlockTest) {
execBlockTest(t, bt, test)
})
diff --git a/tests/fuzzers/bls12381/precompile_fuzzer.go b/tests/fuzzers/bls12381/precompile_fuzzer.go
index 763ed56e9f..4df4db73d1 100644
--- a/tests/fuzzers/bls12381/precompile_fuzzer.go
+++ b/tests/fuzzers/bls12381/precompile_fuzzer.go
@@ -25,15 +25,15 @@ import (
)
const (
- blsG1Add = byte(10)
- blsG1Mul = byte(11)
- blsG1MultiExp = byte(12)
- blsG2Add = byte(13)
- blsG2Mul = byte(14)
- blsG2MultiExp = byte(15)
- blsPairing = byte(16)
- blsMapG1 = byte(17)
- blsMapG2 = byte(18)
+ blsG1Add = byte(11)
+ blsG1Mul = byte(12)
+ blsG1MultiExp = byte(13)
+ blsG2Add = byte(14)
+ blsG2Mul = byte(15)
+ blsG2MultiExp = byte(16)
+ blsPairing = byte(17)
+ blsMapG1 = byte(18)
+ blsMapG2 = byte(19)
)
func checkInput(id byte, inputLen int) bool {
diff --git a/tests/fuzzers/rangeproof/rangeproof-fuzzer.go b/tests/fuzzers/rangeproof/rangeproof-fuzzer.go
index dcafebb265..4d94d31c0c 100644
--- a/tests/fuzzers/rangeproof/rangeproof-fuzzer.go
+++ b/tests/fuzzers/rangeproof/rangeproof-fuzzer.go
@@ -21,13 +21,13 @@ import (
"encoding/binary"
"fmt"
"io"
+ "slices"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/ethdb/memorydb"
"github.com/ethereum/go-ethereum/trie"
"github.com/ethereum/go-ethereum/triedb"
- "golang.org/x/exp/slices"
)
type kv struct {
diff --git a/tests/init_test.go b/tests/init_test.go
index e9bb99dc7d..effeec2b86 100644
--- a/tests/init_test.go
+++ b/tests/init_test.go
@@ -108,7 +108,7 @@ type testFailure struct {
reason string
}
-// skipShortMode skips tests matching when the -short flag is used.
+// slow adds expected slow tests matching the pattern.
func (tm *testMatcher) slow(pattern string) {
tm.slowpat = append(tm.slowpat, regexp.MustCompile(pattern))
}
diff --git a/tests/state_test.go b/tests/state_test.go
index 6ec5c9d857..6f53b88722 100644
--- a/tests/state_test.go
+++ b/tests/state_test.go
@@ -54,9 +54,22 @@ func initMatcher(st *testMatcher) {
// Uses 1GB RAM per tested fork
st.skipLoad(`^stStaticCall/static_Call1MB`)
+ // These tests fail as of https://github.com/ethereum/go-ethereum/pull/28666, since we
+ // no longer delete "leftover storage" when deploying a contract.
+ st.skipLoad(`^stSStoreTest/InitCollision\.json`)
+ st.skipLoad(`^stRevertTest/RevertInCreateInInit\.json`)
+ st.skipLoad(`^stExtCodeHash/dynamicAccountOverwriteEmpty\.json`)
+ st.skipLoad(`^stCreate2/create2collisionStorage\.json`)
+ st.skipLoad(`^stCreate2/RevertInCreateInInitCreate2\.json`)
+
// Broken tests:
// EOF is not part of cancun
st.skipLoad(`^stEOF/`)
+
+ // The tests under Pyspecs are the ones that are published as execution-spec tests.
+ // We run these tests separately, no need to _also_ run them as part of the
+ // reference tests.
+ st.skipLoad(`^Pyspecs/`)
}
func TestState(t *testing.T) {
diff --git a/tests/state_test_util.go b/tests/state_test_util.go
index 367688e57f..416bab9472 100644
--- a/tests/state_test_util.go
+++ b/tests/state_test_util.go
@@ -295,6 +295,14 @@ func (t *StateTest) RunNoVerify(subtest StateSubtest, vmconfig vm.Config, snapsh
}
evm := vm.NewEVM(context, txContext, st.StateDB, config, vmconfig)
+ if tracer := vmconfig.Tracer; tracer != nil && tracer.OnTxStart != nil {
+ tracer.OnTxStart(evm.GetVMContext(), nil, msg.From)
+ if evm.Config.Tracer.OnTxEnd != nil {
+ defer func() {
+ evm.Config.Tracer.OnTxEnd(nil, err)
+ }()
+ }
+ }
// Execute the message.
snapshot := st.StateDB.Snapshot()
gaspool := new(core.GasPool)
diff --git a/trie/proof_test.go b/trie/proof_test.go
index 5471d0efa6..fab3a97650 100644
--- a/trie/proof_test.go
+++ b/trie/proof_test.go
@@ -22,13 +22,13 @@ import (
"encoding/binary"
"fmt"
mrand "math/rand"
+ "slices"
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/rawdb"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/ethdb/memorydb"
- "golang.org/x/exp/slices"
)
// Prng is a pseudo random number generator seeded by strong randomness.
@@ -198,7 +198,7 @@ func TestRangeProof(t *testing.T) {
}
}
-// TestRangeProof tests normal range proof with two non-existent proofs.
+// TestRangeProofWithNonExistentProof tests normal range proof with two non-existent proofs.
// The test cases are generated randomly.
func TestRangeProofWithNonExistentProof(t *testing.T) {
trie, vals := randomTrie(4096)
diff --git a/trie/stacktrie_fuzzer_test.go b/trie/stacktrie_fuzzer_test.go
index 50b5c4de52..57a31d115f 100644
--- a/trie/stacktrie_fuzzer_test.go
+++ b/trie/stacktrie_fuzzer_test.go
@@ -20,6 +20,7 @@ import (
"bytes"
"encoding/binary"
"fmt"
+ "slices"
"testing"
"github.com/ethereum/go-ethereum/common"
@@ -28,7 +29,6 @@ import (
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/trie/trienode"
"golang.org/x/crypto/sha3"
- "golang.org/x/exp/slices"
)
func FuzzStackTrie(f *testing.F) {
diff --git a/trie/stacktrie_test.go b/trie/stacktrie_test.go
index 203ebd99a9..58115bc33a 100644
--- a/trie/stacktrie_test.go
+++ b/trie/stacktrie_test.go
@@ -20,6 +20,7 @@ import (
"bytes"
"math/big"
"math/rand"
+ "slices"
"testing"
"github.com/ethereum/go-ethereum/common"
@@ -27,7 +28,6 @@ import (
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/internal/testrand"
"github.com/stretchr/testify/assert"
- "golang.org/x/exp/slices"
)
func TestStackTrieInsertAndHash(t *testing.T) {
diff --git a/trie/sync_test.go b/trie/sync_test.go
index 7bc68c041f..7221b06f59 100644
--- a/trie/sync_test.go
+++ b/trie/sync_test.go
@@ -19,6 +19,7 @@ package trie
import (
"bytes"
"fmt"
+ "maps"
"math/rand"
"testing"
@@ -837,13 +838,6 @@ func testPivotMove(t *testing.T, scheme string, tiny bool) {
tr.Update(key, val)
states[string(key)] = common.CopyBytes(val)
}
- copyStates = func(states map[string][]byte) map[string][]byte {
- cpy := make(map[string][]byte)
- for k, v := range states {
- cpy[k] = v
- }
- return cpy
- }
)
stateA := make(map[string][]byte)
writeFn([]byte{0x01, 0x23}, nil, srcTrie, stateA)
@@ -866,7 +860,7 @@ func testPivotMove(t *testing.T, scheme string, tiny bool) {
checkTrieContents(t, destDisk, scheme, srcTrie.Hash().Bytes(), stateA, true)
// Delete element to collapse trie
- stateB := copyStates(stateA)
+ stateB := maps.Clone(stateA)
srcTrie, _ = New(TrieID(rootA), srcTrieDB)
deleteFn([]byte{0x02, 0x34}, srcTrie, stateB)
deleteFn([]byte{0x13, 0x44}, srcTrie, stateB)
@@ -883,7 +877,7 @@ func testPivotMove(t *testing.T, scheme string, tiny bool) {
checkTrieContents(t, destDisk, scheme, srcTrie.Hash().Bytes(), stateB, true)
// Add elements to expand trie
- stateC := copyStates(stateB)
+ stateC := maps.Clone(stateB)
srcTrie, _ = New(TrieID(rootB), srcTrieDB)
writeFn([]byte{0x01, 0x24}, stateA[string([]byte{0x01, 0x24})], srcTrie, stateC)
@@ -941,13 +935,6 @@ func testSyncAbort(t *testing.T, scheme string) {
tr.Update(key, val)
states[string(key)] = common.CopyBytes(val)
}
- copyStates = func(states map[string][]byte) map[string][]byte {
- cpy := make(map[string][]byte)
- for k, v := range states {
- cpy[k] = v
- }
- return cpy
- }
)
var (
stateA = make(map[string][]byte)
@@ -972,7 +959,7 @@ func testSyncAbort(t *testing.T, scheme string) {
checkTrieContents(t, destDisk, scheme, srcTrie.Hash().Bytes(), stateA, true)
// Delete the element from the trie
- stateB := copyStates(stateA)
+ stateB := maps.Clone(stateA)
srcTrie, _ = New(TrieID(rootA), srcTrieDB)
deleteFn(key, srcTrie, stateB)
@@ -999,7 +986,7 @@ func testSyncAbort(t *testing.T, scheme string) {
}})
// Add elements to expand trie
- stateC := copyStates(stateB)
+ stateC := maps.Clone(stateB)
srcTrie, _ = New(TrieID(rootB), srcTrieDB)
writeFn(key, val, srcTrie, stateC)
diff --git a/trie/trie_test.go b/trie/trie_test.go
index 920594fdd2..87a0785cfb 100644
--- a/trie/trie_test.go
+++ b/trie/trie_test.go
@@ -1066,7 +1066,7 @@ func TestCommitSequenceSmallRoot(t *testing.T) {
}
}
-// BenchmarkCommitAfterHashFixedSize benchmarks the Commit (after Hash) of a fixed number of updates to a trie.
+// BenchmarkHashFixedSize benchmarks the hash of a fixed number of updates to a trie.
// This benchmark is meant to capture the difference on efficiency of small versus large changes. Typically,
// storage tries are small (a couple of entries), whereas the full post-block account trie update is large (a couple
// of thousand entries)
diff --git a/trie/utils/verkle.go b/trie/utils/verkle.go
index ce059edc64..52e41f5243 100644
--- a/trie/utils/verkle.go
+++ b/trie/utils/verkle.go
@@ -206,9 +206,8 @@ func CodeSizeKey(address []byte) []byte {
func codeChunkIndex(chunk *uint256.Int) (*uint256.Int, byte) {
var (
- chunkOffset = new(uint256.Int).Add(codeOffset, chunk)
- treeIndex = new(uint256.Int).Div(chunkOffset, verkleNodeWidth)
- subIndexMod = new(uint256.Int).Mod(chunkOffset, verkleNodeWidth)
+ chunkOffset = new(uint256.Int).Add(codeOffset, chunk)
+ treeIndex, subIndexMod = new(uint256.Int).DivMod(chunkOffset, verkleNodeWidth, new(uint256.Int))
)
var subIndex byte
if len(subIndexMod) != 0 {
diff --git a/triedb/database.go b/triedb/database.go
index 939a21f147..261a47dcc2 100644
--- a/triedb/database.go
+++ b/triedb/database.go
@@ -108,12 +108,12 @@ func NewDatabase(diskdb ethdb.Database, config *Config) *Database {
log.Crit("Both 'hash' and 'path' mode are configured")
}
if config.PathDB != nil {
- db.backend = pathdb.New(diskdb, config.PathDB)
+ db.backend = pathdb.New(diskdb, config.PathDB, config.IsVerkle)
} else {
var resolver hashdb.ChildResolver
if config.IsVerkle {
// TODO define verkle resolver
- log.Crit("Verkle node resolver is not defined")
+ log.Crit("verkle does not use a hash db")
} else {
resolver = trie.MerkleResolver{}
}
diff --git a/triedb/pathdb/database.go b/triedb/pathdb/database.go
index 34941a274d..2e7c662804 100644
--- a/triedb/pathdb/database.go
+++ b/triedb/pathdb/database.go
@@ -59,11 +59,12 @@ var (
// layer is the interface implemented by all state layers which includes some
// public methods and some additional methods for internal usage.
type layer interface {
- // Node retrieves the trie node with the node info. An error will be returned
- // if the read operation exits abnormally. For example, if the layer is already
- // stale, or the associated state is regarded as corrupted. Notably, no error
- // will be returned if the requested node is not found in database.
- Node(owner common.Hash, path []byte, hash common.Hash) ([]byte, error)
+ // node retrieves the trie node with the node info. An error will be returned
+ // if the read operation exits abnormally. Specifically, if the layer is
+ // already stale.
+ //
+ // Note, no error will be returned if the requested node is not found in database.
+ node(owner common.Hash, path []byte, depth int) ([]byte, common.Hash, *nodeLoc, error)
// rootHash returns the root hash for which this layer was made.
rootHash() common.Hash
@@ -132,6 +133,7 @@ type Database struct {
// the shutdown to reject all following unexpected mutations.
readOnly bool // Flag if database is opened in read only mode
waitSync bool // Flag if database is deactivated due to initial state sync
+ isVerkle bool // Flag if database is used for verkle tree
bufferSize int // Memory allowance (in bytes) for caching dirty nodes
config *Config // Configuration for database
diskdb ethdb.Database // Persistent storage for matured trie nodes
@@ -143,7 +145,7 @@ type Database struct {
// New attempts to load an already existing layer from a persistent key-value
// store (with a number of memory layers from a journal). If the journal is not
// matched with the base persistent layer, all the recorded diff layers are discarded.
-func New(diskdb ethdb.Database, config *Config) *Database {
+func New(diskdb ethdb.Database, config *Config, isVerkle bool) *Database {
if config == nil {
config = Defaults
}
@@ -151,6 +153,7 @@ func New(diskdb ethdb.Database, config *Config) *Database {
db := &Database{
readOnly: config.ReadOnly,
+ isVerkle: isVerkle,
bufferSize: config.DirtyCacheSize,
config: config,
diskdb: diskdb,
@@ -208,15 +211,6 @@ func New(diskdb ethdb.Database, config *Config) *Database {
return db
}
-// Reader retrieves a layer belonging to the given state root.
-func (db *Database) Reader(root common.Hash) (layer, error) {
- l := db.tree.get(root)
- if l == nil {
- return nil, fmt.Errorf("state %#x is not available", root)
- }
- return l, nil
-}
-
// Update adds a new layer into the tree, if that can be linked to an existing
// old parent. It is disallowed to insert a disk layer (the origin of all). Apart
// from that this function will flatten the extra diff layers at bottom into disk
diff --git a/triedb/pathdb/database_test.go b/triedb/pathdb/database_test.go
index a41cf4268a..30edef2760 100644
--- a/triedb/pathdb/database_test.go
+++ b/triedb/pathdb/database_test.go
@@ -106,7 +106,7 @@ func newTester(t *testing.T, historyLimit uint64) *tester {
StateHistory: historyLimit,
CleanCacheSize: 16 * 1024,
DirtyCacheSize: 16 * 1024,
- })
+ }, false)
obj = &tester{
db: db,
preimages: make(map[common.Hash]common.Address),
@@ -305,7 +305,7 @@ func (t *tester) generate(parent common.Hash) (common.Hash, *trienode.MergedNode
return root, ctx.nodes, triestate.New(ctx.accountOrigin, ctx.storageOrigin)
}
-// lastRoot returns the latest root hash, or empty if nothing is cached.
+// lastHash returns the latest root hash, or empty if nothing is cached.
func (t *tester) lastHash() common.Hash {
if len(t.roots) == 0 {
return common.Hash{}
@@ -550,7 +550,7 @@ func TestJournal(t *testing.T) {
t.Errorf("Failed to journal, err: %v", err)
}
tester.db.Close()
- tester.db = New(tester.db.diskdb, nil)
+ tester.db = New(tester.db.diskdb, nil, false)
// Verify states including disk layer and all diff on top.
for i := 0; i < len(tester.roots); i++ {
@@ -588,7 +588,7 @@ func TestCorruptedJournal(t *testing.T) {
rawdb.WriteTrieJournal(tester.db.diskdb, blob)
// Verify states, all not-yet-written states should be discarded
- tester.db = New(tester.db.diskdb, nil)
+ tester.db = New(tester.db.diskdb, nil, false)
for i := 0; i < len(tester.roots); i++ {
if tester.roots[i] == root {
if err := tester.verifyState(root); err != nil {
@@ -625,7 +625,7 @@ func TestTailTruncateHistory(t *testing.T) {
defer tester.release()
tester.db.Close()
- tester.db = New(tester.db.diskdb, &Config{StateHistory: 10})
+ tester.db = New(tester.db.diskdb, &Config{StateHistory: 10}, false)
head, err := tester.db.freezer.Ancients()
if err != nil {
diff --git a/triedb/pathdb/difflayer.go b/triedb/pathdb/difflayer.go
index 10567715d2..6b87883482 100644
--- a/triedb/pathdb/difflayer.go
+++ b/triedb/pathdb/difflayer.go
@@ -95,10 +95,9 @@ func (dl *diffLayer) parentLayer() layer {
return dl.parent
}
-// node retrieves the node with provided node information. It's the internal
-// version of Node function with additional accessed layer tracked. No error
-// will be returned if node is not found.
-func (dl *diffLayer) node(owner common.Hash, path []byte, hash common.Hash, depth int) ([]byte, error) {
+// node implements the layer interface, retrieving the trie node blob with the
+// provided node information. No error will be returned if the node is not found.
+func (dl *diffLayer) node(owner common.Hash, path []byte, depth int) ([]byte, common.Hash, *nodeLoc, error) {
// Hold the lock, ensure the parent won't be changed during the
// state accessing.
dl.lock.RLock()
@@ -109,31 +108,14 @@ func (dl *diffLayer) node(owner common.Hash, path []byte, hash common.Hash, dept
if ok {
n, ok := subset[string(path)]
if ok {
- // If the trie node is not hash matched, or marked as removed,
- // bubble up an error here. It shouldn't happen at all.
- if n.Hash != hash {
- dirtyFalseMeter.Mark(1)
- log.Error("Unexpected trie node in diff layer", "owner", owner, "path", path, "expect", hash, "got", n.Hash)
- return nil, newUnexpectedNodeError("diff", hash, n.Hash, owner, path, n.Blob)
- }
dirtyHitMeter.Mark(1)
dirtyNodeHitDepthHist.Update(int64(depth))
dirtyReadMeter.Mark(int64(len(n.Blob)))
- return n.Blob, nil
+ return n.Blob, n.Hash, &nodeLoc{loc: locDiffLayer, depth: depth}, nil
}
}
// Trie node unknown to this layer, resolve from parent
- if diff, ok := dl.parent.(*diffLayer); ok {
- return diff.node(owner, path, hash, depth+1)
- }
- // Failed to resolve through diff layers, fallback to disk layer
- return dl.parent.Node(owner, path, hash)
-}
-
-// Node implements the layer interface, retrieving the trie node blob with the
-// provided node information. No error will be returned if the node is not found.
-func (dl *diffLayer) Node(owner common.Hash, path []byte, hash common.Hash) ([]byte, error) {
- return dl.node(owner, path, hash, 0)
+ return dl.parent.node(owner, path, depth+1)
}
// update implements the layer interface, creating a new layer on top of the
diff --git a/triedb/pathdb/difflayer_test.go b/triedb/pathdb/difflayer_test.go
index 75890b8a83..bf4c6502ef 100644
--- a/triedb/pathdb/difflayer_test.go
+++ b/triedb/pathdb/difflayer_test.go
@@ -29,7 +29,7 @@ import (
func emptyLayer() *diskLayer {
return &diskLayer{
- db: New(rawdb.NewMemoryDatabase(), nil),
+ db: New(rawdb.NewMemoryDatabase(), nil, false),
buffer: newNodeBuffer(DefaultBufferSize, nil, 0),
}
}
@@ -58,7 +58,6 @@ func BenchmarkSearch1Layer(b *testing.B) { benchmarkSearch(b, 127, 128) }
func benchmarkSearch(b *testing.B, depth int, total int) {
var (
npath []byte
- nhash common.Hash
nblob []byte
)
// First, we set up 128 diff layers, with 3K items each
@@ -75,7 +74,6 @@ func benchmarkSearch(b *testing.B, depth int, total int) {
if npath == nil && depth == index {
npath = common.CopyBytes(path)
nblob = common.CopyBytes(node.Blob)
- nhash = node.Hash
}
}
return newDiffLayer(parent, common.Hash{}, 0, 0, nodes, nil)
@@ -92,7 +90,7 @@ func benchmarkSearch(b *testing.B, depth int, total int) {
err error
)
for i := 0; i < b.N; i++ {
- have, err = layer.Node(common.Hash{}, npath, nhash)
+ have, _, _, err = layer.node(common.Hash{}, npath, 0)
if err != nil {
b.Fatal(err)
}
diff --git a/triedb/pathdb/disklayer.go b/triedb/pathdb/disklayer.go
index 777e4ec8a7..ec7c91bcac 100644
--- a/triedb/pathdb/disklayer.go
+++ b/triedb/pathdb/disklayer.go
@@ -58,7 +58,7 @@ func newDiskLayer(root common.Hash, id uint64, db *Database, cleans *fastcache.C
}
}
-// root implements the layer interface, returning root hash of corresponding state.
+// rootHash implements the layer interface, returning root hash of corresponding state.
func (dl *diskLayer) rootHash() common.Hash {
return dl.root
}
@@ -68,7 +68,7 @@ func (dl *diskLayer) stateID() uint64 {
return dl.id
}
-// parent implements the layer interface, returning nil as there's no layer
+// parentLayer implements the layer interface, returning nil as there's no layer
// below the disk.
func (dl *diskLayer) parentLayer() layer {
return nil
@@ -94,27 +94,25 @@ func (dl *diskLayer) markStale() {
dl.stale = true
}
-// Node implements the layer interface, retrieving the trie node with the
+// node implements the layer interface, retrieving the trie node with the
// provided node info. No error will be returned if the node is not found.
-func (dl *diskLayer) Node(owner common.Hash, path []byte, hash common.Hash) ([]byte, error) {
+func (dl *diskLayer) node(owner common.Hash, path []byte, depth int) ([]byte, common.Hash, *nodeLoc, error) {
dl.lock.RLock()
defer dl.lock.RUnlock()
if dl.stale {
- return nil, errSnapshotStale
+ return nil, common.Hash{}, nil, errSnapshotStale
}
// Try to retrieve the trie node from the not-yet-written
// node buffer first. Note the buffer is lock free since
// it's impossible to mutate the buffer before tagging the
// layer as stale.
- n, err := dl.buffer.node(owner, path, hash)
- if err != nil {
- return nil, err
- }
- if n != nil {
+ n, found := dl.buffer.node(owner, path)
+ if found {
dirtyHitMeter.Mark(1)
dirtyReadMeter.Mark(int64(len(n.Blob)))
- return n.Blob, nil
+ dirtyNodeHitDepthHist.Update(int64(depth))
+ return n.Blob, n.Hash, &nodeLoc{loc: locDirtyCache, depth: depth}, nil
}
dirtyMissMeter.Mark(1)
@@ -125,14 +123,9 @@ func (dl *diskLayer) Node(owner common.Hash, path []byte, hash common.Hash) ([]b
h := newHasher()
defer h.release()
- got := h.hash(blob)
- if got == hash {
- cleanHitMeter.Mark(1)
- cleanReadMeter.Mark(int64(len(blob)))
- return blob, nil
- }
- cleanFalseMeter.Mark(1)
- log.Error("Unexpected trie node in clean cache", "owner", owner, "path", path, "expect", hash, "got", got)
+ cleanHitMeter.Mark(1)
+ cleanReadMeter.Mark(int64(len(blob)))
+ return blob, h.hash(blob), &nodeLoc{loc: locCleanCache, depth: depth}, nil
}
cleanMissMeter.Mark(1)
}
@@ -146,16 +139,11 @@ func (dl *diskLayer) Node(owner common.Hash, path []byte, hash common.Hash) ([]b
} else {
nBlob, nHash = rawdb.ReadStorageTrieNode(dl.db.diskdb, owner, path)
}
- if nHash != hash {
- diskFalseMeter.Mark(1)
- log.Error("Unexpected trie node in disk", "owner", owner, "path", path, "expect", hash, "got", nHash)
- return nil, newUnexpectedNodeError("disk", hash, nHash, owner, path, nBlob)
- }
if dl.cleans != nil && len(nBlob) > 0 {
dl.cleans.Set(key, nBlob)
cleanWriteMeter.Mark(int64(len(nBlob)))
}
- return nBlob, nil
+ return nBlob, nHash, &nodeLoc{loc: locDiskLayer, depth: depth}, nil
}
// update implements the layer interface, returning a new diff layer on top
diff --git a/triedb/pathdb/errors.go b/triedb/pathdb/errors.go
index 78ee4459fe..bbf2c9e37c 100644
--- a/triedb/pathdb/errors.go
+++ b/triedb/pathdb/errors.go
@@ -16,13 +16,7 @@
package pathdb
-import (
- "errors"
- "fmt"
-
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
-)
+import "errors"
var (
// errDatabaseReadOnly is returned if the database is opened in read only mode
@@ -45,16 +39,4 @@ var (
// errStateUnrecoverable is returned if state is required to be reverted to
// a destination without associated state history available.
errStateUnrecoverable = errors.New("state is unrecoverable")
-
- // errUnexpectedNode is returned if the requested node with specified path is
- // not hash matched with expectation.
- errUnexpectedNode = errors.New("unexpected node")
)
-
-func newUnexpectedNodeError(loc string, expHash common.Hash, gotHash common.Hash, owner common.Hash, path []byte, blob []byte) error {
- blobHex := "nil"
- if len(blob) > 0 {
- blobHex = hexutil.Encode(blob)
- }
- return fmt.Errorf("%w, loc: %s, node: (%x %v), %x!=%x, blob: %s", errUnexpectedNode, loc, owner, path, expHash, gotHash, blobHex)
-}
diff --git a/triedb/pathdb/history.go b/triedb/pathdb/history.go
index 68fb4809f0..7099b2b381 100644
--- a/triedb/pathdb/history.go
+++ b/triedb/pathdb/history.go
@@ -21,6 +21,7 @@ import (
"encoding/binary"
"errors"
"fmt"
+ "slices"
"time"
"github.com/ethereum/go-ethereum/common"
@@ -28,7 +29,6 @@ import (
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/trie/triestate"
- "golang.org/x/exp/slices"
)
// State history records the state changes involved in executing a block. The
diff --git a/triedb/pathdb/metrics.go b/triedb/pathdb/metrics.go
index 9e2b1dcbf5..a250f703cb 100644
--- a/triedb/pathdb/metrics.go
+++ b/triedb/pathdb/metrics.go
@@ -33,6 +33,7 @@ var (
cleanFalseMeter = metrics.NewRegisteredMeter("pathdb/clean/false", nil)
dirtyFalseMeter = metrics.NewRegisteredMeter("pathdb/dirty/false", nil)
diskFalseMeter = metrics.NewRegisteredMeter("pathdb/disk/false", nil)
+ diffFalseMeter = metrics.NewRegisteredMeter("pathdb/diff/false", nil)
commitTimeTimer = metrics.NewRegisteredTimer("pathdb/commit/time", nil)
commitNodesMeter = metrics.NewRegisteredMeter("pathdb/commit/nodes", nil)
diff --git a/triedb/pathdb/nodebuffer.go b/triedb/pathdb/nodebuffer.go
index 8f84c2b442..4a13fcc44e 100644
--- a/triedb/pathdb/nodebuffer.go
+++ b/triedb/pathdb/nodebuffer.go
@@ -59,21 +59,16 @@ func newNodeBuffer(limit int, nodes map[common.Hash]map[string]*trienode.Node, l
}
// node retrieves the trie node with given node info.
-func (b *nodebuffer) node(owner common.Hash, path []byte, hash common.Hash) (*trienode.Node, error) {
+func (b *nodebuffer) node(owner common.Hash, path []byte) (*trienode.Node, bool) {
subset, ok := b.nodes[owner]
if !ok {
- return nil, nil
+ return nil, false
}
n, ok := subset[string(path)]
if !ok {
- return nil, nil
+ return nil, false
}
- if n.Hash != hash {
- dirtyFalseMeter.Mark(1)
- log.Error("Unexpected trie node in node buffer", "owner", owner, "path", path, "expect", hash, "got", n.Hash)
- return nil, newUnexpectedNodeError("dirty", hash, n.Hash, owner, path, n.Blob)
- }
- return n, nil
+ return n, true
}
// commit merges the dirty nodes into the nodebuffer. This operation won't take
diff --git a/triedb/pathdb/reader.go b/triedb/pathdb/reader.go
new file mode 100644
index 0000000000..54dc98a543
--- /dev/null
+++ b/triedb/pathdb/reader.go
@@ -0,0 +1,94 @@
+// Copyright 2024 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see
+
+package pathdb
+
+import (
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"
+ "github.com/ethereum/go-ethereum/log"
+ "github.com/ethereum/go-ethereum/triedb/database"
+)
+
+// The types of locations where the node is found.
+const (
+ locDirtyCache = "dirty" // dirty cache
+ locCleanCache = "clean" // clean cache
+ locDiskLayer = "disk" // persistent state
+ locDiffLayer = "diff" // diff layers
+)
+
+// nodeLoc is a helpful structure that contains the location where the node
+// is found, as it's useful for debugging purposes.
+type nodeLoc struct {
+ loc string
+ depth int
+}
+
+// string returns the string representation of node location.
+func (loc *nodeLoc) string() string {
+ return fmt.Sprintf("loc: %s, depth: %d", loc.loc, loc.depth)
+}
+
+// reader implements the database.Reader interface, providing the functionalities to
+// retrieve trie nodes by wrapping the internal state layer.
+type reader struct {
+ layer layer
+ noHashCheck bool
+}
+
+// Node implements database.Reader interface, retrieving the node with specified
+// node info. Don't modify the returned byte slice since it's not deep-copied
+// and still be referenced by database.
+func (r *reader) Node(owner common.Hash, path []byte, hash common.Hash) ([]byte, error) {
+ blob, got, loc, err := r.layer.node(owner, path, 0)
+ if err != nil {
+ return nil, err
+ }
+ // Error out if the local one is inconsistent with the target.
+ if !r.noHashCheck && got != hash {
+ // Location is always available even if the node
+ // is not found.
+ switch loc.loc {
+ case locCleanCache:
+ cleanFalseMeter.Mark(1)
+ case locDirtyCache:
+ dirtyFalseMeter.Mark(1)
+ case locDiffLayer:
+ diffFalseMeter.Mark(1)
+ case locDiskLayer:
+ diskFalseMeter.Mark(1)
+ }
+ blobHex := "nil"
+ if len(blob) > 0 {
+ blobHex = hexutil.Encode(blob)
+ }
+ log.Error("Unexpected trie node", "location", loc.loc, "owner", owner, "path", path, "expect", hash, "got", got, "blob", blobHex)
+ return nil, fmt.Errorf("unexpected node: (%x %v), %x!=%x, %s, blob: %s", owner, path, hash, got, loc.string(), blobHex)
+ }
+ return blob, nil
+}
+
+// Reader retrieves a layer belonging to the given state root.
+func (db *Database) Reader(root common.Hash) (database.Reader, error) {
+ layer := db.tree.get(root)
+ if layer == nil {
+ return nil, fmt.Errorf("state %#x is not available", root)
+ }
+ return &reader{layer: layer, noHashCheck: db.isVerkle}, nil
+}
diff --git a/triedb/pathdb/testutils.go b/triedb/pathdb/testutils.go
index 546cb819b8..0c99565b8e 100644
--- a/triedb/pathdb/testutils.go
+++ b/triedb/pathdb/testutils.go
@@ -19,13 +19,13 @@ package pathdb
import (
"bytes"
"fmt"
+ "slices"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/trie/trienode"
"github.com/ethereum/go-ethereum/trie/triestate"
- "golang.org/x/exp/slices"
)
// testHasher is a test utility for computing root hash of a batch of state