Merge branch 'main' into no-transfer-syscall

Author: Sahil-4555

.github/README.md

@@ -217,6 +217,41 @@ Consider setting tighter defaults in the workflow matrix for jobs that are known
 be memory- or disk-heavy, rather than working around pressure by adjusting unrelated
 constraints like timeouts or GC tuning.
 
+## Checking benchmarks
+
+The purpose of `make test-bench` in CI is to verify that benchmarks compile and
+execute at least one iteration — not to produce meaningful performance numbers.
+
+### Why benchmarks are slow by default
+
+Many benchmarks are sized for profiling or comparison work: a single iteration can
+take minutes. Go's benchmark runner will execute exactly 1 iteration in that case
+(`-benchtime=1x`), so the `ns/op` figure is meaningless and the run just wastes
+time.
+
+The fix is to keep benchmark iteration work small enough to be loopable, and use
+`testing.Short()` to trim parameter sweeps when all we need is a smoke test:
+
+```go
+if testing.Short() {
+    totalSteps = 10        // instead of 200+
+    keyCount = 10_000      // instead of 1_000_000
+}
+```
+
+`make test-bench` passes `-short` so these guards are active in CI.
+
+### Why you cannot parallelize across packages
+
+`go test` forces benchmark packages to run **serially** regardless of the `-p` flag.
+The serialization is enforced at the action-graph level in `cmd/go` when `-bench` is
+set — each package run is added as a dependency of the previous one. Passing
+`-p N` only affects compilation parallelism, not execution order.
+
+The only way to reduce `make test-bench` wall time is to reduce the work done per
+benchmark iteration, which is why right-sizing benchmarks (via `testing.Short()`) is
+the correct approach rather than parallelizing the runner.
+
 ## Local reproducibility
 
 Every CI job should have a local equivalent so developers can pre-check before pushing.

.github/workflows/ci-gate.yml

@@ -81,7 +81,6 @@ jobs:
     secrets: inherit
 
   ci-gate:
-    name: Required
     if: always()
     needs:
       - lint

.gitignore

@@ -123,4 +123,4 @@ mdbx.lck
 
 # Prevent accidental commit of locally-built binaries
 /erigon
-
+.claude/worktrees/

Makefile

@@ -226,7 +226,7 @@ test-all: override GO_FLAGS := -timeout $(default_test_timeout) $(GO_FLAGS)
 test-all: test-filtered
 
 ## test-bench:                         check the benchmarks compile and run
-test-bench: override GO_FLAGS += -run=^$$ -bench=. -benchtime=1x
+test-bench: override GO_FLAGS += -run=^$$ -bench=. -benchtime=1x -short -timeout=5m
 test-bench:
 	$(GOTEST)
 

cl/phase1/core/checkpoint_sync/util.go

@@ -3,30 +3,71 @@ package checkpoint_sync
 import (
 	"context"
 	"fmt"
+	"path/filepath"
 
 	"github.com/spf13/afero"
 
 	"github.com/erigontech/erigon/cl/clparams"
 	"github.com/erigontech/erigon/cl/persistence/genesisdb"
 	"github.com/erigontech/erigon/cl/phase1/core/state"
+	"github.com/erigontech/erigon/cl/utils"
+	"github.com/erigontech/erigon/common/log/v3"
 	"github.com/erigontech/erigon/db/datadir"
 )
 
 // ReadOrFetchLatestBeaconState reads the latest beacon state from disk or fetches it from the network.
+// If remote checkpoint sync fails, it falls back to the local head state on disk.
+// If no local head state is available, it returns an error.
 func ReadOrFetchLatestBeaconState(ctx context.Context, dirs datadir.Dirs, beaconCfg *clparams.BeaconChainConfig, caplinConfig clparams.CaplinConfig, genesisDB genesisdb.GenesisDB) (*state.CachingBeaconState, error) {
-	var syncer CheckpointSyncer
 	remoteSync := !caplinConfig.DisabledCheckpointSync && !caplinConfig.IsDevnet()
 
 	if remoteSync {
-		syncer = NewRemoteCheckpointSync(beaconCfg, caplinConfig.NetworkId)
-	} else {
-		aferoFs := afero.NewOsFs()
+		syncer := NewRemoteCheckpointSync(beaconCfg, caplinConfig.NetworkId)
+		st, err := syncer.GetLatestBeaconState(ctx)
+		if err == nil {
+			return st, nil
+		}
+		log.Warn("[Checkpoint Sync] Remote checkpoint sync failed, attempting to read local head state", "err", err)
 
-		genesisState, err := genesisDB.ReadGenesisState()
-		if err != nil {
-			return nil, fmt.Errorf("could not read genesis state: %w", err)
+		// Fallback: try to read the local head state from disk
+		localState, localErr := ReadLocalHeadState(dirs, beaconCfg)
+		if localErr == nil {
+			log.Info("[Checkpoint Sync] Successfully loaded local head state", "slot", localState.Slot())
+			return localState, nil
 		}
-		syncer = NewLocalCheckpointSyncer(genesisState, afero.NewBasePathFs(aferoFs, dirs.CaplinLatest))
+		log.Error("[Checkpoint Sync] No local head state available either", "err", localErr)
+		return nil, fmt.Errorf("remote checkpoint sync failed: %w, and no local head state: %w", err, localErr)
+	}
+
+	// Non-remote sync path (disabled checkpoint sync or devnet)
+	aferoFs := afero.NewOsFs()
+	genesisState, err := genesisDB.ReadGenesisState()
+	if err != nil {
+		return nil, fmt.Errorf("could not read genesis state: %w", err)
 	}
+	syncer := NewLocalCheckpointSyncer(genesisState, afero.NewBasePathFs(aferoFs, dirs.CaplinLatest))
 	return syncer.GetLatestBeaconState(ctx)
 }
+
+// ReadLocalHeadState reads the head state directly from disk without falling back to genesis.
+func ReadLocalHeadState(dirs datadir.Dirs, beaconCfg *clparams.BeaconChainConfig) (*state.CachingBeaconState, error) {
+	statePath := filepath.Join(dirs.CaplinLatest, clparams.LatestStateFileName)
+	snappyEncoded, err := afero.ReadFile(afero.NewOsFs(), statePath)
+	if err != nil {
+		return nil, fmt.Errorf("could not read local head state file: %w", err)
+	}
+	decompressed, err := utils.DecompressSnappy(snappyEncoded, false)
+	if err != nil {
+		return nil, fmt.Errorf("local head state is corrupt: %w", err)
+	}
+	slot, err := utils.ExtractSlotFromSerializedBeaconState(decompressed)
+	if err != nil {
+		return nil, fmt.Errorf("could not extract slot from local head state: %w", err)
+	}
+	bs := state.New(beaconCfg)
+	epoch := slot / beaconCfg.SlotsPerEpoch
+	if err := bs.DecodeSSZ(decompressed, int(beaconCfg.GetCurrentStateVersion(epoch))); err != nil {
+		return nil, fmt.Errorf("could not decode local head state: %w", err)
+	}
+	return bs, nil
+}

db/datastruct/btindex/bpstree_bench_test.go

@@ -14,6 +14,9 @@ func BenchmarkBpsTreeSeek(t *testing.B) {
 	tmp := t.TempDir()
 	logger := log.New()
 	keyCount, M := 12_000_000, 256
+	if testing.Short() {
+		keyCount = 10_000
+	}
 	t.Logf("N: %d, M: %d skip since shard <= %d", keyCount, M, DefaultBtreeStartSkip)
 	compressFlags := seg.CompressKeys | seg.CompressVals
 

db/datastruct/btindex/btree_index_test.go

@@ -429,6 +429,9 @@ func TestNewBtIndex(t *testing.T) {
 
 func BenchmarkBtIndex_Get(b *testing.B) {
 	keyCount := 1_000_000
+	if testing.Short() {
+		keyCount = 10_000
+	}
 	compress := seg.CompressKeys
 
 	for _, M := range []uint64{256, 128, 64, 32} {

db/kv/kv_interface.go

@@ -449,6 +449,9 @@ type TemporalDebugTx interface {
 	// TraceKey returns stream of <txNum->value_after_txnum_change> for a given key
 	TraceKey(domain Domain, k []byte, fromTxNum, toTxNum uint64) (stream.U64V, error)
 
+	// HistoryKeyTxNumRange returns (key, txNum) pairs for every txNum at which a key changed in [fromTs, toTs)
+	HistoryKeyTxNumRange(name Domain, fromTs, toTs int, asc order.By, limit int) (it stream.KU64, err error)
+
 	DomainFiles(domain ...Domain) VisibleFiles
 	CurrentDomainVersion(domain Domain) version.Version
 	TxNumsInFiles(domains ...Domain) (minTxNum uint64)

db/kv/remotedb/kv_remote.go

@@ -261,6 +261,9 @@ func (tx *tx) GetLatestFromFiles(domain kv.Domain, k []byte, maxTxNum uint64) (v
 func (tx *tx) TraceKey(domain kv.Domain, k []byte, fromTxNum, toTxNum uint64) (stream.U64V, error) {
 	panic("not implemented")
 }
+func (tx *tx) HistoryKeyTxNumRange(name kv.Domain, fromTs, toTs int, asc order.By, limit int) (stream.KU64, error) {
+	panic("not implemented")
+}
 func (tx *tx) IIProgress(domain kv.InvertedIdx) uint64 { panic("not implemented") }
 func (tx *tx) RangeLatest(domain kv.Domain, from, to []byte, limit int) (stream.KV, error) {
 	panic("not implemented")

db/kv/temporal/kv_temporal.go

@@ -604,6 +604,23 @@ func (tx *RwTx) HistoryRange(name kv.Domain, fromTs, toTs int, asc order.By, lim
 	return tx.historyRange(name, tx.RwTx, fromTs, toTs, asc, limit)
 }
 
+func (tx *tx) historyKeyTxNumRange(name kv.Domain, dbTx kv.Tx, fromTs, toTs int, asc order.By, limit int) (stream.KU64, error) {
+	it, err := tx.aggtx.HistoryKeyTxNumRange(name, fromTs, toTs, asc, limit, dbTx)
+	if err != nil {
+		return nil, err
+	}
+	tx.resourcesToClose = append(tx.resourcesToClose, it)
+	return it, nil
+}
+
+func (tx *Tx) HistoryKeyTxNumRange(name kv.Domain, fromTs, toTs int, asc order.By, limit int) (stream.KU64, error) {
+	return tx.historyKeyTxNumRange(name, tx.Tx, fromTs, toTs, asc, limit)
+}
+
+func (tx *RwTx) HistoryKeyTxNumRange(name kv.Domain, fromTs, toTs int, asc order.By, limit int) (stream.KU64, error) {
+	return tx.historyKeyTxNumRange(name, tx.RwTx, fromTs, toTs, asc, limit)
+}
+
 // Write methods
 
 func (tx *tx) DomainPut(domain kv.Domain, k, v []byte, txNum uint64, prevVal []byte) error {