Erigon exits with exit 0 on error. it should exit with a non-zero exit code

.gitignore

@@ -112,4 +112,5 @@ mdbx.lck
 
 .my
 
-cover.out
+cover.out
+/erigon

cmd/utils/flags.go

@@ -1140,6 +1140,10 @@ var (
 		Usage: "EXPERIMENTAL: enables concurrent trie for commitment",
 		Value: false,
 	}
+	UseForkchoiceFinalityFlag = cli.BoolFlag{
+		Name:  "experimental.use-forkchoice-finality",
+		Usage: "Skip changeset generation for blocks finalized by forkchoice (e.g., Polygon milestones). Reduces overhead but requires chaindata reset if finality is reverted.",
+	}
 	GDBMeFlag = cli.BoolFlag{
 		Name:  "gdbme",
 		Usage: "restart erigon under gdb for debug purposes",

core/vm/contracts.go

@@ -195,6 +195,7 @@ var PrecompiledContractsPrague = map[common.Address]PrecompiledContract{
 	common.BytesToAddress([]byte{0x07}): &bn254ScalarMulIstanbul{},
 	common.BytesToAddress([]byte{0x08}): &bn254PairingIstanbul{},
 	common.BytesToAddress([]byte{0x09}): &blake2F{},
+	common.BytesToAddress([]byte{0x0a}): &pointEvaluation{},
 	common.BytesToAddress([]byte{0x0b}): &bls12381G1Add{},
 	common.BytesToAddress([]byte{0x0c}): &bls12381G1MultiExp{},
 	common.BytesToAddress([]byte{0x0d}): &bls12381G2Add{},
@@ -235,6 +236,7 @@ var PrecompiledContractsMadhugiri = map[common.Address]PrecompiledContract{
 	common.BytesToAddress([]byte{0x07}): &bn254ScalarMulIstanbul{},
 	common.BytesToAddress([]byte{0x08}): &bn254PairingIstanbul{},
 	common.BytesToAddress([]byte{0x09}): &blake2F{},
+	common.BytesToAddress([]byte{0x0a}): &pointEvaluation{},
 	common.BytesToAddress([]byte{0x0b}): &bls12381G1Add{},
 	common.BytesToAddress([]byte{0x0c}): &bls12381G1MultiExp{},
 	common.BytesToAddress([]byte{0x0d}): &bls12381G2Add{},
@@ -254,6 +256,7 @@ var PrecompiledContractsMadhugiriPro = map[common.Address]PrecompiledContract{
 	common.BytesToAddress([]byte{0x07}):       &bn254ScalarMulIstanbul{},
 	common.BytesToAddress([]byte{0x08}):       &bn254PairingIstanbul{},
 	common.BytesToAddress([]byte{0x09}):       &blake2F{},
+	common.BytesToAddress([]byte{0x0a}):       &pointEvaluation{},
 	common.BytesToAddress([]byte{0x0b}):       &bls12381G1Add{},
 	common.BytesToAddress([]byte{0x0c}):       &bls12381G1MultiExp{},
 	common.BytesToAddress([]byte{0x0d}):       &bls12381G2Add{},

core/vm/contracts_test.go

@@ -527,35 +527,73 @@ func TestLisovoCLZOpcode(t *testing.T) {
 	}
 }
 
-// TestPointEvaluationPrecompileRemoval verifies that the pointEvaluation (KZG) precompile
-// is present before LisovoPro and removed starting with LisovoPro.
-func TestPointEvaluationPrecompileRemoval(t *testing.T) {
+// TestPointEvaluationPrecompileAvailability verifies that the pointEvaluation (KZG)
+// precompile remains available through Lisovo and is only removed starting with LisovoPro.
+func TestPointEvaluationPrecompileAvailability(t *testing.T) {
 	t.Parallel()
 
 	pointEvaluationAddr := common.BytesToAddress([]byte{0x0a})
 
-	// Test Lisovo: should have pointEvaluation
-	lisovoRules := &chain.Rules{
-		IsLisovo:       true,
-		IsMadhugiriPro: true,
-		IsMadhugiri:    true,
-		IsBhilai:       true,
-	}
-	lisovoPrecompiles := Precompiles(lisovoRules)
-	if _, exists := lisovoPrecompiles[pointEvaluationAddr]; !exists {
-		t.Error("pointEvaluation (0x0a) should exist in Lisovo precompiles")
+	testCases := []struct {
+		name      string
+		rules     *chain.Rules
+		wantExist bool
+	}{
+		{
+			name: "Prague",
+			rules: &chain.Rules{
+				IsPrague: true,
+			},
+			wantExist: true,
+		},
+		{
+			name: "Madhugiri",
+			rules: &chain.Rules{
+				IsMadhugiri: true,
+				IsBhilai:    true,
+			},
+			wantExist: true,
+		},
+		{
+			name: "MadhugiriPro",
+			rules: &chain.Rules{
+				IsMadhugiriPro: true,
+				IsMadhugiri:    true,
+				IsBhilai:       true,
+			},
+			wantExist: true,
+		},
+		{
+			name: "Lisovo",
+			rules: &chain.Rules{
+				IsLisovo:       true,
+				IsMadhugiriPro: true,
+				IsMadhugiri:    true,
+				IsBhilai:       true,
+			},
+			wantExist: true,
+		},
+		{
+			name: "LisovoPro",
+			rules: &chain.Rules{
+				IsLisovoPro:    true,
+				IsLisovo:       true,
+				IsMadhugiriPro: true,
+				IsMadhugiri:    true,
+				IsBhilai:       true,
+			},
+			wantExist: false,
+		},
 	}
 
-	// Test LisovoPro: should not have pointEvaluation
-	lisovoProRules := &chain.Rules{
-		IsLisovoPro:    true,
-		IsLisovo:       true,
-		IsMadhugiriPro: true,
-		IsMadhugiri:    true,
-		IsBhilai:       true,
-	}
-	lisovoProPrecompiles := Precompiles(lisovoProRules)
-	if _, exists := lisovoProPrecompiles[pointEvaluationAddr]; exists {
-		t.Error("pointEvaluation (0x0a) should not exist in LisovoPro precompiles")
+	for _, testCase := range testCases {
+		testCase := testCase
+		t.Run(testCase.name, func(t *testing.T) {
+			precompiles := Precompiles(testCase.rules)
+			_, exists := precompiles[pointEvaluationAddr]
+			if exists != testCase.wantExist {
+				t.Fatalf("pointEvaluation (0x0a) existence = %t, want %t", exists, testCase.wantExist)
+			}
+		})
 	}
 }

db/rawdb/rawtemporaldb/accessors_commitment.go

@@ -15,7 +15,7 @@ func CanUnwindToBlockNum(tx kv.TemporalTx) (uint64, error) {
 		return 0, err
 	}
 	if minUnwindale == math.MaxUint64 { // no unwindable block found
-		log.Warn("no unwindable block found from changesets, falling back to latest with commitment")
+		log.Debug("no unwindable block found from changesets, falling back to latest with commitment")
 		return commitmentdb.LatestBlockNumWithCommitment(tx)
 	}
 	if minUnwindale > 0 {

db/state/aggregator.go

@@ -1019,15 +1019,6 @@ func (at *AggregatorRoTx) PruneSmallBatches(ctx context.Context, timeout time.Du
 	fullStat := newAggregatorPruneStat()
 
 	for {
-		if sptx, ok := tx.(kv.HasSpaceDirty); ok && !furiousPrune && !aggressivePrune {
-			spaceDirty, _, err := sptx.SpaceDirty()
-			if err != nil {
-				return false, err
-			}
-			if spaceDirty > uint64(statecfg.MaxNonFuriousDirtySpacePerTx) {
-				return false, nil
-			}
-		}
 		iterationStarted := time.Now()
 		// `context.Background()` is important here!
 		//     it allows keep DB consistent - prune all keys-related data or noting

db/state/statecfg/state_schema.go

@@ -64,7 +64,7 @@ func Configure(Schema SchemaGen, a AggSetters, dirs datadir.Dirs, salt *uint32,
 }
 
 const AggregatorSqueezeCommitmentValues = true
-const MaxNonFuriousDirtySpacePerTx = 64 * datasize.MB
+const MaxNonFuriousDirtySpacePerTx = 128 * datasize.MB
 
 var dbgCommBtIndex = dbg.EnvBool("AGG_COMMITMENT_BT", false)
 

eth/backend.go

@@ -228,6 +228,14 @@ type Ethereum struct {
 	heimdallService     *heimdall.Service
 	stopNode            func() error
 	bgComponentsEg      errgroup.Group
+	bgComponentMu       sync.Mutex
+	bgComponentErr      error
+}
+
+func (s *Ethereum) BgComponentError() error {
+	s.bgComponentMu.Lock()
+	defer s.bgComponentMu.Unlock()
+	return s.bgComponentErr
 }
 
 func splitAddrIntoHostAndPort(addr string) (host string, port int, err error) {
@@ -1824,11 +1832,20 @@ func (s *Ethereum) Stop() error {
 
 	if err := s.bgComponentsEg.Wait(); err != nil && !errors.Is(err, context.Canceled) {
 		s.logger.Error("background component error", "err", err)
+		s.bgComponentMu.Lock()
+		s.bgComponentErr = err
+		s.bgComponentMu.Unlock()
 	}
 
 	return nil
 }
 
+// BgComponentError returns the first non-context-canceled error from background
+// components, if any. It is safe to call after Stop() has returned.
+func (s *Ethereum) BgComponentError() error {
+	return s.bgComponentErr
+}
+
 func (s *Ethereum) ChainDB() kv.RwDB {
 	return s.chainDB
 }

eth/ethconfig/config.go

@@ -291,6 +291,7 @@ type Sync struct {
 
 	ChaosMonkey              bool
 	AlwaysGenerateChangesets bool
+	UseForkchoiceFinality    bool
 	MaxReorgDepth            uint64
 	KeepExecutionProofs      bool
 	PersistReceiptsCacheV2   bool

execution/eth1/forkchoice.go

@@ -486,6 +486,12 @@ func (e *EthereumExecutionModule) updateForkChoice(ctx context.Context, original
 		}
 	}
 
+	// Write finalized hash BEFORE execution so shouldGenerateChangeSets() can read it
+	// during execution stage. This enables the UseForkchoiceFinality optimization.
+	if finalizedHash != (common.Hash{}) {
+		rawdb.WriteForkchoiceFinalized(tx, finalizedHash)
+	}
+
 	firstCycle := false
 	loopIter := 0
 	for {

execution/stagedsync/exec3.go

@@ -467,9 +467,14 @@ func ExecV3(ctx context.Context,
 		lastFrozenTxNum = uint64((lastFrozenStep+1)*kv.Step(doms.StepSize())) - 1
 	}
 
+	var finalizedBlockNum uint64
+	if cfg.syncCfg.UseForkchoiceFinality {
+		finalizedBlockNum = getFinalizedBlockNum(applyTx)
+	}
+
 Loop:
 	for ; blockNum <= maxBlockNum; blockNum++ {
-		shouldGenerateChangesets := shouldGenerateChangeSets(cfg, blockNum, maxBlockNum, initialCycle)
+		shouldGenerateChangesets := shouldGenerateChangeSets(cfg, finalizedBlockNum, blockNum, maxBlockNum, initialCycle)
 		changeSet := &changeset2.StateChangeSet{}
 		if shouldGenerateChangesets && blockNum > 0 {
 			executor.domains().SetChangesetAccumulator(changeSet)
@@ -762,9 +767,15 @@ Loop:
 
 				timeStart := time.Now()
 
-				// allow greedy prune on non-chain-tip
+				// allow greedy prune on non-chain-tip or when not generating changesets
 				pruneTimeout := 250 * time.Millisecond
-				if initialCycle {
+				if initialCycle || !shouldGenerateChangesets {
+					// When not generating changesets (finalized blocks), we can afford longer pruning
+					// since we're generating less data overall
+					if !initialCycle {
+						logger.Debug(fmt.Sprintf("[%s] aggressive pruning via forkchoice finality", execStage.LogPrefix()),
+							"block", blockNum, "finalizedBlock", finalizedBlockNum)
+					}
 					pruneTimeout = 10 * time.Hour
 
 					if err = executor.tx().(kv.TemporalRwTx).GreedyPruneHistory(ctx, kv.CommitmentDomain); err != nil {
@@ -787,7 +798,9 @@ Loop:
 					errExhausted = &ErrLoopExhausted{From: startBlockNum, To: blockNum, Reason: "block batch is full"}
 					break Loop
 				}
-				if !initialCycle && canPrune {
+				// Skip pruning break if not generating changesets (finalized blocks via UseForkchoiceFinality)
+				// This allows larger batches similar to initialCycle behavior
+				if !initialCycle && canPrune && shouldGenerateChangesets {
 					errExhausted = &ErrLoopExhausted{From: startBlockNum, To: blockNum, Reason: "block batch can be pruned"}
 					break Loop
 				}
@@ -1021,7 +1034,21 @@ func blockWithSenders(ctx context.Context, db kv.RoDB, tx kv.Tx, blockReader ser
 	return b, err
 }
 
-func shouldGenerateChangeSets(cfg ExecuteBlockCfg, blockNum, maxBlockNum uint64, initialCycle bool) bool {
+// getFinalizedBlockNum returns the finalized block number from forkchoice state.
+// Returns 0 if no finalized block is set or if the hash cannot be resolved to a block number.
+func getFinalizedBlockNum(tx kv.Getter) uint64 {
+	finalizedHash := rawdb.ReadForkchoiceFinalized(tx)
+	if finalizedHash == (common.Hash{}) {
+		return 0
+	}
+	finalizedNum := rawdb.ReadHeaderNumber(tx, finalizedHash)
+	if finalizedNum == nil {
+		return 0
+	}
+	return *finalizedNum
+}
+
+func shouldGenerateChangeSets(cfg ExecuteBlockCfg, finalizedBlockNum, blockNum, maxBlockNum uint64, initialCycle bool) bool {
 	if cfg.syncCfg.AlwaysGenerateChangesets {
 		return true
 	}
@@ -1031,6 +1058,15 @@ func shouldGenerateChangeSets(cfg ExecuteBlockCfg, blockNum, maxBlockNum uint64,
 	if initialCycle {
 		return false
 	}
-	// once past the initial cycle, make sure to generate changesets for the last blocks that fall in the reorg window
+
+	// Use forkchoice finalized block if enabled and available (e.g., Polygon milestones).
+	// Blocks at or before the finalized block don't need changesets since they cannot be reorged.
+	// WARNING: If finality is later reverted (e.g., faulty milestone purged by hard fork),
+	// the node will require a chaindata reset to recover.
+	if cfg.syncCfg.UseForkchoiceFinality && finalizedBlockNum > 0 && blockNum <= finalizedBlockNum {
+		return false
+	}
+
+	// Fallback: generate changesets for blocks in the reorg window (last MaxReorgDepth blocks)
 	return blockNum+cfg.syncCfg.MaxReorgDepth >= maxBlockNum
 }