Eagerly transition to SAE for state sync (#5916)

Signed-off-by: Rahul Muttineni <rahul.muttineni@avalabs.org>
Co-authored-by: Austin Larson <78000745+alarso16@users.noreply.github.com>

Author: rahulmutt-ava

node/node.go

@@ -1246,6 +1246,7 @@ func (n *Node) initVMs() error {
 			// is around a second, so 10 seconds provides plenty of time to
 			// ensure this doesn't happen.
 			TransitionTime:  n.Config.UpgradeConfig.HeliconTime.Add(-10 * time.Second),
+			Now:             time.Now,
 			APIDrainTimeout: 15 * time.Second,
 		}),
 	)

vms/saevm/statesync/syncer.go

@@ -75,6 +75,10 @@ func (s *Syncer) ShouldAcceptSummary(summary *Summary) bool {
 	}
 
 	// If any blocks have been accepted, don't state sync.
+	//
+	// TransitionVM assumes that a node will state-sync if state-sync is enabled
+	// and the node is at the genesis block. Until transitionvm is removed, this
+	// check MUST NOT change.
 	hash := rawdb.ReadHeadFastBlockHash(s.db)
 	if hash == (common.Hash{}) {
 		s.snowCtx.Log.Warn("no last accepted hash")

vms/transitionvm/BUILD.bazel

@@ -26,6 +26,7 @@ go_library(
         "//snow/engine/snowman/block",
         "//snow/validators",
         "//utils",
+        "//utils/constants",
         "//utils/logging",
         "//utils/set",
         "//version",
@@ -57,6 +58,7 @@ go_test(
         "//snow/engine/snowman/block",
         "//snow/engine/snowman/block/blocktest",
         "//snow/snowtest",
+        "//utils/constants",
         "//utils/logging",
         "//utils/set",
         "//version",

vms/transitionvm/README.md

@@ -29,6 +29,7 @@ n.VMManager.RegisterFactory(context.TODO(), constants.EVMID, &transitionvm.Facto
     PreFactory:      &coreth.Factory{},
     PostFactory:     &saevm.Factory{},
     TransitionTime:  n.Config.UpgradeConfig.HeliconTime.Add(-10 * time.Second),
+    Now:             time.Now,
     APIDrainTimeout: 15 * time.Second,
 })
 ```
@@ -84,6 +85,50 @@ flowchart TD
     class E errCls;
 ```
 
+### Eager transition for state sync
+
+The engine runs state sync once, at startup, against the active VM — but a
+node starting after the transition faces peers that serve only the
+post-transition VM's summaries. So a node transitions *eagerly* during
+initialization when the wall clock is past the transition time, the network is
+a production network (Mainnet or Fuji), the chain is still at the genesis, and
+the node intends to state sync. The marker is written before the sync runs, so
+the commitment is **one-way**.
+
+Only production networks get the eager path. The real requirement is that the
+network sequenced at least one commit interval of blocks after the
+transition, so peers have a post-transition summary to serve; production
+networks are known to satisfy it, while a custom network may transition right
+at its genesis and strand an eagerly-committed node.
+
+The eager path requires of the VMs:
+
+- The **pre-transition VM reports during initialization whether the node will
+  state sync**.
+- The **post-transition VM state syncs a fresh database** whenever it can sync
+  at all: a node at the genesis cannot execute a chain with a synchronous
+  prefix. A node with accepted blocks is refused instead — it never
+  transitions eagerly, and bootstrap-executes to the transition block. A
+  summary at a pre-transition height is rejected once its fetched header
+  proves it synchronous, before any state is written.
+
+A committed node never falls back to executing pre-transition blocks, so it
+strands until a summary it accepts arrives — or forever:
+
+- **A wall-clock false positive** — a skewed clock, or a network that has not
+  yet built the transition block — strands the node until the network
+  transitions.
+- **No post-transition commit boundary yet**: nothing to sync to; resolves
+  itself.
+- **State sync disabled after the marker is written**: the engine skips state
+  sync entirely and falls into a bootstrap it cannot execute.
+- **State schemes that cannot sync** (Firewood): every summary is declined,
+  forever.
+
+To recover, delete the chain database and restart. For never-syncable
+configurations, also disable state sync in the new configuration; on the
+already-marked node the flag no longer helps.
+
 ### Swapping the VM underneath the node
 
 The consensus engine, network, and API server treat a chain's VM as one

vms/transitionvm/factory.go

@@ -20,6 +20,7 @@ type Factory struct {
 	PreFactory     vms.Factory
 	PostFactory    vms.Factory
 	TransitionTime time.Time
+	Now            func() time.Time
 	// APIDrainTimeout bounds how long the transition waits for in-flight API
 	// requests to the pre-transition chain to return before shutting it down.
 	APIDrainTimeout time.Duration
@@ -50,6 +51,7 @@ func (f *Factory) New(log logging.Logger) (interface{}, error) {
 		preTransitionChain:  pre,
 		postTransitionChain: post,
 		transitionTime:      f.TransitionTime,
+		now:                 f.Now,
 		apiDrainTimeout:     f.APIDrainTimeout,
 
 		// [VM.Version] and [VM.Shutdown] may be called before [VM.Initialize],

vms/transitionvm/vm.go

@@ -21,6 +21,7 @@ import (
 	"github.com/ava-labs/avalanchego/snow/consensus/snowman"
 	"github.com/ava-labs/avalanchego/snow/engine/common"
 	"github.com/ava-labs/avalanchego/utils"
+	"github.com/ava-labs/avalanchego/utils/constants"
 
 	smblock "github.com/ava-labs/avalanchego/snow/engine/snowman/block"
 )
@@ -44,6 +45,7 @@ type VM struct {
 	preTransitionChain  Chain
 	postTransitionChain Chain
 	transitionTime      time.Time
+	now                 func() time.Time
 	apiDrainTimeout     time.Duration
 
 	// chain parameters
@@ -142,7 +144,33 @@ func (vm *VM) Initialize(
 		return fmt.Errorf("loading last accepted block %s: %w", lastAcceptedID, err)
 	}
 	if lastAccepted.Timestamp().Before(vm.transitionTime) {
-		return nil
+		if vm.now().Before(vm.transitionTime) {
+			return nil
+		}
+		// Transitioning is only safe once the network has sequenced at least
+		// one commit interval of blocks after the transition, so peers have a
+		// post-transition summary to serve. The production networks are known
+		// to satisfy this; a custom network may not, so it waits for the
+		// transition block instead.
+		if !constants.ProductionNetworkIDs.Contains(preChainCtx.NetworkID) {
+			log.Info("past transition time on a non-production network; waiting for the transition block")
+			return nil
+		}
+		// The network is past the transition time, so peers only serve the
+		// post-transition chain's state summaries.
+		if lastAccepted.Height() > 0 {
+			log.Info("past transition time with accepted pre-transition blocks; waiting for the transition block")
+			return nil
+		}
+		enabled, err := vm.StateSyncEnabled(ctx)
+		if err != nil {
+			return fmt.Errorf("checking whether the node will state sync: %w", err)
+		}
+		if !enabled {
+			log.Info("past transition time but not state syncing; waiting for the transition block")
+			return nil
+		}
+		log.Info("transitioning eagerly to state sync as the post-transition chain")
 	}
 	return vm.transition(ctx, lastAccepted)
 }