Remove last synchronous from NewVM (#5556)

alarso16 · web-flow · commit d8a8473be281 · 2026-07-02T15:18:58.000Z
diff --git a/graft/coreth/core/blockchain.go b/graft/coreth/core/blockchain.go
@@ -530,6 +530,7 @@ func (bc *BlockChain) batchBlockAcceptedIndices(batch ethdb.Batch, b *types.Bloc
 	if err := customrawdb.WriteAcceptorTip(batch, b.Hash()); err != nil {
 		return fmt.Errorf("%w: failed to write acceptor tip key", err)
 	}
+	rawdb.WriteFinalizedBlockHash(batch, b.Hash())
 	return nil
 }
 
diff --git a/graft/coreth/core/genesis.go b/graft/coreth/core/genesis.go
@@ -393,12 +393,17 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *triedb.Database) (*types.Blo
 	if err := config.CheckConfigForkOrder(); err != nil {
 		return nil, err
 	}
-	rawdb.WriteBlock(db, block)
-	rawdb.WriteReceipts(db, block.Hash(), block.NumberU64(), nil)
-	rawdb.WriteCanonicalHash(db, block.Hash(), block.NumberU64())
-	rawdb.WriteHeadBlockHash(db, block.Hash())
-	rawdb.WriteHeadHeaderHash(db, block.Hash())
-	rawdb.WriteChainConfig(db, block.Hash(), config)
+	batch := db.NewBatch()
+	rawdb.WriteBlock(batch, block)
+	rawdb.WriteReceipts(batch, block.Hash(), block.NumberU64(), nil)
+	rawdb.WriteCanonicalHash(batch, block.Hash(), block.NumberU64())
+	rawdb.WriteHeadBlockHash(batch, block.Hash())
+	rawdb.WriteHeadHeaderHash(batch, block.Hash())
+	rawdb.WriteFinalizedBlockHash(batch, block.Hash())
+	rawdb.WriteChainConfig(batch, block.Hash(), config)
+	if err := batch.Write(); err != nil {
+		return nil, fmt.Errorf("failed to write genesis block: %w", err)
+	}
 	return block, nil
 }
 
diff --git a/graft/subnet-evm/core/blockchain.go b/graft/subnet-evm/core/blockchain.go
@@ -547,6 +547,7 @@ func (bc *BlockChain) batchBlockAcceptedIndices(batch ethdb.Batch, b *types.Bloc
 	if err := customrawdb.WriteAcceptorTip(batch, b.Hash()); err != nil {
 		return fmt.Errorf("%w: failed to write acceptor tip key", err)
 	}
+	rawdb.WriteFinalizedBlockHash(batch, b.Hash())
 	return nil
 }
 
diff --git a/graft/subnet-evm/core/genesis.go b/graft/subnet-evm/core/genesis.go
@@ -428,6 +428,7 @@ func (g *Genesis) Commit(db ethdb.Database, triedb *triedb.Database) (*types.Blo
 	rawdb.WriteCanonicalHash(batch, block.Hash(), block.NumberU64())
 	rawdb.WriteHeadBlockHash(batch, block.Hash())
 	rawdb.WriteHeadHeaderHash(batch, block.Hash())
+	rawdb.WriteFinalizedBlockHash(batch, block.Hash())
 	customrawdb.WriteChainConfig(batch, block.Hash(), config, params.GetExtra(config).UpgradeConfig)
 	if err := batch.Write(); err != nil {
 		return nil, fmt.Errorf("failed to write genesis block: %w", err)
diff --git a/vms/saevm/blocks/blockstest/BUILD.bazel b/vms/saevm/blocks/blockstest/BUILD.bazel
@@ -20,7 +20,6 @@ go_library(
         "//vms/saevm/saetest",
         "@com_github_ava_labs_libevm//common",
         "@com_github_ava_labs_libevm//core",
-        "@com_github_ava_labs_libevm//core/state",
         "@com_github_ava_labs_libevm//core/types",
         "@com_github_ava_labs_libevm//ethdb",
         "@com_github_ava_labs_libevm//event",
diff --git a/vms/saevm/blocks/blockstest/blocks.go b/vms/saevm/blocks/blockstest/blocks.go
@@ -15,7 +15,6 @@ import (
 
 	"github.com/ava-labs/libevm/common"
 	"github.com/ava-labs/libevm/core"
-	"github.com/ava-labs/libevm/core/state"
 	"github.com/ava-labs/libevm/core/types"
 	"github.com/ava-labs/libevm/ethdb"
 	"github.com/ava-labs/libevm/libevm/options"
@@ -133,10 +132,9 @@ func NewGenesis(tb testing.TB, db ethdb.Database, config *params.ChainConfig, al
 		BaseFee:   new(big.Int).SetUint64(conf.baseFee),
 	}
 
-	tdb := state.NewDatabaseWithConfig(db, conf.tdbConfig).TrieDB()
-	_, hash, err := core.SetupGenesisBlock(db, tdb, gen)
+	tdb := triedb.NewDatabase(db, conf.tdbConfig)
+	_, _, err := core.SetupGenesisBlock(db, tdb, gen)
 	require.NoError(tb, err, "core.SetupGenesisBlock()")
-	require.NoErrorf(tb, tdb.Commit(hash, true), "%T.Commit(core.SetupGenesisBlock(...))", tdb)
 
 	h := hookstest.NewStub(conf.gasTarget)
 	xdb := saetest.NewExecutionResultsDB()
diff --git a/vms/saevm/cchain/genesis.go b/vms/saevm/cchain/genesis.go
@@ -172,21 +172,21 @@ var (
 // It verifies that the genesis is compatible with any previously setup genesis
 // state by checking the genesis block hash along with the rules used to execute
 // the head block.
-func (g *genesis) setup(db ethdb.Database, trieConfig *triedb.Config) (_ *types.Block, retErr error) {
+func (g *genesis) setup(db ethdb.Database, trieConfig *triedb.Config) (retErr error) {
 	block, err := g.block()
 	if err != nil {
-		return nil, fmt.Errorf("constructing genesis block: %w", err)
+		return fmt.Errorf("constructing genesis block: %w", err)
 	}
 
 	// We can't exit early here. Even if the genesis block is on disk, the
 	// genesis state might not be.
 	hash := block.Hash()
 	if prev := rawdb.ReadCanonicalHash(db, genesisNumber); prev == (common.Hash{}) {
 		if err := writeGenesisBlock(db, block, g.Config); err != nil {
-			return nil, fmt.Errorf("writing block: %w", err)
+			return fmt.Errorf("writing block: %w", err)
 		}
 	} else if prev != hash {
-		return nil, &core.GenesisMismatchError{
+		return &core.GenesisMismatchError{
 			Stored: prev,
 			New:    hash,
 		}
@@ -197,18 +197,18 @@ func (g *genesis) setup(db ethdb.Database, trieConfig *triedb.Config) (_ *types.
 	{
 		prev := rawdb.ReadChainConfig(db, hash)
 		if prev == nil {
-			return nil, errNoStoredChainConfig
+			return errNoStoredChainConfig
 		}
 		head := rawdb.ReadHeadHeader(db)
 		if head == nil {
-			return nil, errNoHeadHeader
+			return errNoHeadHeader
 		}
 		height, timestamp := head.Number.Uint64(), head.Time
 		// TODO(JonathanOppenheimer): coreth exposes a `skip-upgrade-check` config
 		// that bypasses this compatibility check; we need to make such a check
 		// unnecessary for the c-chain.
 		if err := prev.CheckCompatible(g.Config, height, timestamp); err != nil {
-			return nil, fmt.Errorf("incompatible chain config: %w", err)
+			return fmt.Errorf("incompatible chain config: %w", err)
 		}
 		// We will be executing new blocks based on the new chain config, so we
 		// need to keep it up-to-date in the database for the next restart.
@@ -224,10 +224,10 @@ func (g *genesis) setup(db ethdb.Database, trieConfig *triedb.Config) (_ *types.
 	// the trie to determine if the genesis was previously initialized.
 	if !tdb.Initialized(block.Root()) {
 		if _, err := g.writeState(db, tdb); err != nil {
-			return nil, fmt.Errorf("writing genesis state: %w", err)
+			return fmt.Errorf("writing genesis state: %w", err)
 		}
 	}
-	return block, nil
+	return nil
 }
 
 func writeGenesisBlock(db ethdb.Database, block *types.Block, config *ethparams.ChainConfig) error {
diff --git a/vms/saevm/cchain/genesis_test.go b/vms/saevm/cchain/genesis_test.go
@@ -616,12 +616,11 @@ func TestSetupGenesis(t *testing.T) {
 			)
 			require.NoError(t, err, "parseGenesis(initial)")
 
-			block, err := g.setup(db, trieConfig)
-			require.NoErrorf(t, err, "%T.setup(initial)", g)
+			require.NoErrorf(t, g.setup(db, trieConfig), "%T.setup(initial)", g)
 
+			block, err := g.block()
+			require.NoErrorf(t, err, "%T.block()", g)
 			genesisHash := block.Hash()
-			require.Equal(t, genesisHash, rawdb.ReadCanonicalHash(db, 0), "rawdb.ReadCanonicalHash(initial)")
-
 			gotConfig := rawdb.ReadChainConfig(db, genesisHash)
 			cmpBaseConfig := cmp.Options{
 				cmpopts.IgnoreUnexported(corethparams.ChainConfig{}),
@@ -646,7 +645,7 @@ func TestSetupGenesis(t *testing.T) {
 			)
 			require.NoError(t, err, "parseGenesis(restart)")
 
-			block, err = g.setup(db, trieConfig)
+			err = g.setup(db, trieConfig)
 			if diff := testerr.Diff(err, tt.wantErr); diff != "" {
 				t.Fatalf("%T.setup(restart) error (-want +got)\n%s", g, diff)
 			}
@@ -655,7 +654,6 @@ func TestSetupGenesis(t *testing.T) {
 				return
 			}
 
-			require.Equal(t, genesisHash, block.Hash(), "%T.setup(restart).Hash()", g)
 			gotConfig = rawdb.ReadChainConfig(db, genesisHash)
 			if diff := cmp.Diff(g.Config, gotConfig, cmpBaseConfig); diff != "" {
 				t.Errorf("stored base config after restart (-want +got)\n%s", diff)
diff --git a/vms/saevm/cchain/vm.go b/vms/saevm/cchain/vm.go
@@ -109,8 +109,7 @@ func (vm *VM) Initialize(
 	vm.chainConfig = genesis.Config
 
 	saeConfig := userConfig.saeConfig(vm.now)
-	genesisBlock, err := genesis.setup(ethDB, saeConfig.DBConfig.TrieDBConfig)
-	if err != nil {
+	if err := genesis.setup(ethDB, saeConfig.DBConfig.TrieDBConfig); err != nil {
 		return fmt.Errorf("setting up genesis: %w", err)
 	}
 
@@ -133,7 +132,7 @@ func (vm *VM) Initialize(
 		vm.now,
 		userConfig.desired(),
 	)
-	vm.VM, err = sae.NewVM(ctx, hooks, saeConfig, snowCtx, vm.chainConfig, ethDB, genesisBlock, appSender)
+	vm.VM, err = sae.NewVM(ctx, hooks, saeConfig, snowCtx, vm.chainConfig, ethDB, appSender)
 	if err != nil {
 		return fmt.Errorf("creating SAE VM: %w", err)
 	}
diff --git a/vms/saevm/sae/BUILD.bazel b/vms/saevm/sae/BUILD.bazel
@@ -53,6 +53,7 @@ go_library(
         "@com_github_ava_labs_libevm//common",
         "@com_github_ava_labs_libevm//core",
         "@com_github_ava_labs_libevm//core/rawdb",
+        "@com_github_ava_labs_libevm//core/state",
         "@com_github_ava_labs_libevm//core/txpool",
         "@com_github_ava_labs_libevm//core/txpool/legacypool",
         "@com_github_ava_labs_libevm//core/types",
diff --git a/vms/saevm/sae/always.go b/vms/saevm/sae/always.go
@@ -9,14 +9,17 @@ import (
 	"fmt"
 
 	"github.com/ava-labs/libevm/core"
+	"github.com/ava-labs/libevm/core/rawdb"
 	"github.com/ava-labs/libevm/triedb"
 
 	"github.com/ava-labs/avalanchego/database"
 	"github.com/ava-labs/avalanchego/snow"
-	"github.com/ava-labs/avalanchego/snow/engine/common"
 	"github.com/ava-labs/avalanchego/vms/saevm/adaptor"
 	"github.com/ava-labs/avalanchego/vms/saevm/blocks"
 	"github.com/ava-labs/avalanchego/vms/saevm/hook"
+
+	snowcommon "github.com/ava-labs/avalanchego/snow/engine/common"
+	ethcommon "github.com/ava-labs/libevm/common"
 )
 
 var _ adaptor.ChainVM[*blocks.Block] = (*SinceGenesis[hook.Transaction])(nil)
@@ -48,8 +51,8 @@ func (vm *SinceGenesis[_]) Initialize(
 	genesisBytes []byte,
 	upgradeBytes []byte,
 	configBytes []byte,
-	fxs []*common.Fx,
-	appSender common.AppSender,
+	fxs []*snowcommon.Fx,
+	appSender snowcommon.AppSender,
 ) error {
 	db := newEthDB(avaDB)
 	tdb := triedb.NewDatabase(db, vm.config.DBConfig.TrieDBConfig)
@@ -58,12 +61,18 @@ func (vm *SinceGenesis[_]) Initialize(
 	if err := json.Unmarshal(genesisBytes, genesis); err != nil {
 		return fmt.Errorf("json.Unmarshal(%T): %v", genesis, err)
 	}
-	config, _, err := core.SetupGenesisBlock(db, tdb, genesis)
+	config, hash, err := core.SetupGenesisBlock(db, tdb, genesis)
 	if err != nil {
 		return fmt.Errorf("core.SetupGenesisBlock(...): %v", err)
 	}
 
-	inner, err := NewVM(ctx, vm.hooks, vm.config, snowCtx, config, db, genesis.ToBlock(), appSender)
+	// [NewVM] assumes that the genesis block is "finalized", which does not
+	// happen in [core.SetupGenesisBlock]. This MUST only happen once.
+	if rawdb.ReadFinalizedBlockHash(db) == (ethcommon.Hash{}) {
+		rawdb.WriteFinalizedBlockHash(db, hash)
+	}
+
+	inner, err := NewVM(ctx, vm.hooks, vm.config, snowCtx, config, db, appSender)
 	if err != nil {
 		return err
 	}
diff --git a/vms/saevm/sae/recovery.go b/vms/saevm/sae/recovery.go
@@ -5,12 +5,15 @@ package sae
 
 import (
 	"context"
+	"errors"
+	"fmt"
 	"iter"
 	"math"
 	"sync/atomic"
 
 	"github.com/ava-labs/libevm/common"
 	"github.com/ava-labs/libevm/core/rawdb"
+	"github.com/ava-labs/libevm/core/state"
 	"github.com/ava-labs/libevm/ethdb"
 	"github.com/ava-labs/libevm/params"
 
@@ -19,21 +22,19 @@ import (
 	"github.com/ava-labs/avalanchego/vms/saevm/blocks"
 	"github.com/ava-labs/avalanchego/vms/saevm/hook"
 	"github.com/ava-labs/avalanchego/vms/saevm/proxytime"
-	"github.com/ava-labs/avalanchego/vms/saevm/saedb"
 	"github.com/ava-labs/avalanchego/vms/saevm/saexec"
 	"github.com/ava-labs/avalanchego/vms/saevm/types"
 
 	saeparams "github.com/ava-labs/avalanchego/vms/saevm/params"
 )
 
 type recovery struct {
-	db              ethdb.Database
-	xdb             types.ExecutionResults
-	chainConfig     *params.ChainConfig
-	log             logging.Logger
-	hooks           hook.Points
-	config          Config
-	lastSynchronous *blocks.Block
+	db          ethdb.Database
+	xdb         types.ExecutionResults
+	chainConfig *params.ChainConfig
+	log         logging.Logger
+	hooks       hook.Points
+	config      Config
 }
 
 func (rec *recovery) newCanonicalBlock(num uint64, parent *blocks.Block) (*blocks.Block, error) {
@@ -44,23 +45,54 @@ func (rec *recovery) newCanonicalBlock(num uint64, parent *blocks.Block) (*block
 	return blocks.New(ethB, parent, nil, rec.log)
 }
 
-func (rec *recovery) lastCommittedBlock() (*blocks.Block, error) {
-	num := saedb.LastHeightWithExecutionRootCommitted(
-		rec.db,
-		rec.config.DBConfig,
-		rec.hooks,
-		rec.lastSynchronous.Height(),
-	)
-	if ls := rec.lastSynchronous; num == ls.Height() {
-		return ls, nil
+// lastCommittedBlock returns the highest settled block whose post-execution
+// state is available on disk. This is required because its post-execution state
+// is the basis for the worst-case checks needed for block verifications.
+func (rec *recovery) lastCommittedBlock() (_ *blocks.Block, retErr error) {
+	cache := state.NewDatabaseWithConfig(rec.db, rec.config.DBConfig.TrieDBConfig)
+	defer func() {
+		retErr = errors.Join(retErr, cache.TrieDB().Close())
+	}()
+
+	lastSettledHash := rawdb.ReadFinalizedBlockHash(rec.db)
+	if lastSettledHash == (common.Hash{}) {
+		return nil, errors.New("no finalized block recorded")
+	}
+	lastSettledHeight := rawdb.ReadHeaderNumber(rec.db, lastSettledHash)
+	if lastSettledHeight == nil {
+		return nil, fmt.Errorf("no height for finalized block %s", lastSettledHash)
 	}
 
-	ethB, err := canonicalBlock(rec.db, num)
-	if err != nil {
-		return nil, err
+	// Search for highest settled post-execution state
+	// Invariant: The state is written to disk AFTER the block is written to
+	// disk. Therefore, the state can only lag behind the block read.
+	// Additionally, we assume any block has been written atomically, so
+	// if the last settled height was found, the underlying block is present.
+	// At minimum, [NewVM] requires a genesis block to be written (which is
+	// synchronous by definition).
+	//
+	// There's no reasonable cap on how far back to search, since the distance
+	// between the settler and settled block is unbounded, and node crashes
+	// must be accounted for.
+	for height := *lastSettledHeight; ; height-- {
+		ethB, err := canonicalBlock(rec.db, height)
+		if err != nil {
+			return nil, err
+		}
+
+		b, err := blocks.RestoreSettledBlock(ethB, rec.hooks, rec.log, rec.db, rec.xdb, rec.chainConfig)
+		if err != nil {
+			return nil, err
+		}
+
+		if _, err := state.New(b.PostExecutionStateRoot(), cache, nil); err == nil { // if NO error
+			return b, nil
+		}
+
+		if b.Synchronous() {
+			return nil, fmt.Errorf("last synchronous block %d has no available post-execution state", height)
+		}
 	}
-	// We only commit settled execution results, so this block is guaranteed to be settled.
-	return blocks.RestoreSettledBlock(ethB, rec.hooks, rec.log, rec.db, rec.xdb, rec.chainConfig)
 }
 
 func (rec *recovery) canonicalAfter(parent *blocks.Block) iter.Seq2[*blocks.Block, error] {
@@ -133,9 +165,6 @@ func (rec *recovery) consensusCriticalBlocks(exec *saexec.Executor) (_ *syncMap[
 				}
 				return b.MarkSettled(blackhole)
 
-			case b.Height() == rec.lastSynchronous.Height()+1:
-				chain = append(chain, rec.lastSynchronous)
-
 			default:
 				parent, err := rec.newCanonicalBlock(b.Height()-1, nil)
 				if err != nil {
@@ -146,7 +175,7 @@ func (rec *recovery) consensusCriticalBlocks(exec *saexec.Executor) (_ *syncMap[
 				}
 				chain = append(chain, parent)
 
-				if !b.Settled() {
+				if !b.Settled() && !parent.Synchronous() {
 					continue
 				}
 				if err := parent.MarkSettled(blackhole); err != nil {
diff --git a/vms/saevm/sae/vm.go b/vms/saevm/sae/vm.go
diff --git a/vms/saevm/saedb/BUILD.bazel b/vms/saevm/saedb/BUILD.bazel
diff --git a/vms/saevm/saedb/tracker.go b/vms/saevm/saedb/tracker.go

Original file line number	Diff line number	Diff line change
`@@ -530,6 +530,7 @@ func (bc BlockChain) batchBlockAcceptedIndices(batch ethdb.Batch, b types.Bloc`
`530`	`530`	`if err := customrawdb.WriteAcceptorTip(batch, b.Hash()); err != nil {`
`531`	`531`	`return fmt.Errorf("%w: failed to write acceptor tip key", err)`
`532`	`532`	`}`
	`533`	`+ rawdb.WriteFinalizedBlockHash(batch, b.Hash())`
`533`	`534`	`return nil`
`534`	`535`	`}`
`535`	`536`
Original file line number	Diff line number	Diff line change
`@@ -547,6 +547,7 @@ func (bc BlockChain) batchBlockAcceptedIndices(batch ethdb.Batch, b types.Bloc`
`547`	`547`	`if err := customrawdb.WriteAcceptorTip(batch, b.Hash()); err != nil {`
`548`	`548`	`return fmt.Errorf("%w: failed to write acceptor tip key", err)`
`549`	`549`	`}`
	`550`	`+ rawdb.WriteFinalizedBlockHash(batch, b.Hash())`
`550`	`551`	`return nil`
`551`	`552`	`}`
`552`	`553`
Original file line number	Diff line number	Diff line change
`@@ -109,8 +109,7 @@ func (vm *VM) Initialize(`
`109`	`109`	`vm.chainConfig = genesis.Config`
`110`	`110`
`111`	`111`	`saeConfig := userConfig.saeConfig(vm.now)`
`112`		`- genesisBlock, err := genesis.setup(ethDB, saeConfig.DBConfig.TrieDBConfig)`
`113`		`- if err != nil {`
	`112`	`+ if err := genesis.setup(ethDB, saeConfig.DBConfig.TrieDBConfig); err != nil {`
`114`	`113`	`return fmt.Errorf("setting up genesis: %w", err)`
`115`	`114`	`}`
`116`	`115`
`@@ -133,7 +132,7 @@ func (vm *VM) Initialize(`
`133`	`132`	`vm.now,`
`134`	`133`	`userConfig.desired(),`
`135`	`134`	`)`
`136`		`- vm.VM, err = sae.NewVM(ctx, hooks, saeConfig, snowCtx, vm.chainConfig, ethDB, genesisBlock, appSender)`
	`135`	`+ vm.VM, err = sae.NewVM(ctx, hooks, saeConfig, snowCtx, vm.chainConfig, ethDB, appSender)`
`137`	`136`	`if err != nil {`
`138`	`137`	`return fmt.Errorf("creating SAE VM: %w", err)`
`139`	`138`	`}`