sync: coreth PR #963,981,1009: sync package extension and related items

consensus/dummy/consensus.go

@@ -41,6 +41,32 @@ type Mode struct {
 }
 
 type (
+	OnFinalizeAndAssembleCallbackType = func(
+		header *types.Header,
+		parent *types.Header,
+		state *state.StateDB,
+		txs []*types.Transaction,
+	) (
+		extraData []byte,
+		blockFeeContribution *big.Int,
+		extDataGasUsed *big.Int,
+		err error,
+	)
+
+	OnExtraStateChangeType = func(
+		block *types.Block,
+		parent *types.Header,
+		statedb *state.StateDB,
+	) (
+		blockFeeContribution *big.Int,
+		extDataGasUsed *big.Int,
+		err error,
+	)
+
+	ConsensusCallbacks struct {
+		OnFinalizeAndAssemble OnFinalizeAndAssembleCallbackType
+		OnExtraStateChange    OnExtraStateChangeType
+	}
 	DummyEngine struct {
 		clock         *mockable.Clock
 		consensusMode Mode

plugin/evm/block.go

@@ -19,6 +19,7 @@ import (
 	"github.com/ava-labs/subnet-evm/params"
 	"github.com/ava-labs/subnet-evm/params/extras"
 	"github.com/ava-labs/subnet-evm/plugin/evm/header"
+	"github.com/ava-labs/subnet-evm/plugin/evm/sync"
 	"github.com/ava-labs/subnet-evm/precompile/precompileconfig"
 	"github.com/ava-labs/subnet-evm/predicate"
 
@@ -30,6 +31,7 @@ import (
 var (
 	_ snowman.Block           = (*Block)(nil)
 	_ block.WithVerifyContext = (*Block)(nil)
+	_ sync.EthBlockWrapper    = (*Block)(nil)
 )
 
 // Block implements the snowman.Block interface
@@ -273,3 +275,7 @@ func (b *Block) Bytes() []byte {
 }
 
 func (b *Block) String() string { return fmt.Sprintf("EVM block, ID = %s", b.ID()) }
+
+func (b *Block) GetEthBlock() *types.Block {
+	return b.ethBlock
+}

plugin/evm/config/config.go

@@ -191,7 +191,7 @@ type Config struct {
 	MaxOutboundActiveRequests int64 `json:"max-outbound-active-requests"`
 
 	// Sync settings
-	StateSyncEnabled         bool   `json:"state-sync-enabled"`
+	StateSyncEnabled         *bool  `json:"state-sync-enabled"`     // Pointer distinguishes false (no state sync) and not set (state sync only at genesis).
 	StateSyncSkipResume      bool   `json:"state-sync-skip-resume"` // Forces state sync to use the highest available summary block
 	StateSyncServerTrieCache int    `json:"state-sync-server-trie-cache"`
 	StateSyncIDs             string `json:"state-sync-ids"`

plugin/evm/config/config_test.go

@@ -13,6 +13,12 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+// newTrue returns a pointer to a bool that is true
+func newTrue() *bool {
+	b := true
+	return &b
+}
+
 func TestUnmarshalConfig(t *testing.T) {
 	tests := []struct {
 		name        string
@@ -62,7 +68,7 @@ func TestUnmarshalConfig(t *testing.T) {
 		{
 			"state sync enabled",
 			[]byte(`{"state-sync-enabled":true}`),
-			Config{StateSyncEnabled: true},
+			Config{StateSyncEnabled: newTrue()},
 			false,
 		},
 		{

plugin/evm/extension/config.go

@@ -0,0 +1,175 @@
+// Copyright (C) 2019-2025, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package extension
+
+import (
+	"context"
+	"errors"
+
+	"github.com/ava-labs/avalanchego/database"
+	"github.com/ava-labs/avalanchego/database/versiondb"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/network/p2p"
+	"github.com/ava-labs/avalanchego/snow/consensus/snowman"
+	avalanchecommon "github.com/ava-labs/avalanchego/snow/engine/common"
+	"github.com/ava-labs/avalanchego/utils/timer/mockable"
+
+	"github.com/ava-labs/avalanchego/snow/engine/snowman/block"
+	"github.com/prometheus/client_golang/prometheus"
+
+	"github.com/ava-labs/subnet-evm/consensus/dummy"
+	"github.com/ava-labs/subnet-evm/core"
+	"github.com/ava-labs/subnet-evm/params"
+	"github.com/ava-labs/subnet-evm/params/extras"
+	"github.com/ava-labs/subnet-evm/plugin/evm/config"
+	"github.com/ava-labs/subnet-evm/plugin/evm/message"
+	"github.com/ava-labs/subnet-evm/plugin/evm/sync"
+	"github.com/ava-labs/subnet-evm/sync/handlers"
+
+	"github.com/ava-labs/libevm/common"
+	"github.com/ava-labs/libevm/core/types"
+)
+
+var (
+	errNilConfig              = errors.New("nil extension config")
+	errNilSyncSummaryProvider = errors.New("nil sync summary provider")
+	errNilSyncableParser      = errors.New("nil syncable parser")
+	errNilClock               = errors.New("nil clock")
+)
+
+type ExtensibleVM interface {
+	// SetExtensionConfig sets the configuration for the VM extension
+	// Should be called before any other method and only once
+	SetExtensionConfig(config *Config) error
+	// NewClient returns a client to send messages with for the given protocol
+	NewClient(protocol uint64, options ...p2p.ClientOption) *p2p.Client
+	// AddHandler registers a server handler for an application protocol
+	AddHandler(protocol uint64, handler p2p.Handler) error
+	// GetExtendedBlock returns the VMBlock for the given ID or an error if the block is not found
+	GetExtendedBlock(context.Context, ids.ID) (ExtendedBlock, error)
+	// LastAcceptedExtendedBlock returns the last accepted VM block
+	LastAcceptedExtendedBlock() ExtendedBlock
+	// ChainConfig returns the chain config for the VM
+	ChainConfig() *params.ChainConfig
+	// P2PValidators returns the validators for the network
+	P2PValidators() *p2p.Validators
+	// Blockchain returns the blockchain client
+	Blockchain() *core.BlockChain
+	// Config returns the configuration for the VM
+	Config() config.Config
+	// MetricRegistry returns the metric registry for the VM
+	MetricRegistry() *prometheus.Registry
+	// ReadLastAccepted returns the last accepted block hash and height
+	ReadLastAccepted() (common.Hash, uint64, error)
+	// VersionDB returns the versioned database for the VM
+	VersionDB() *versiondb.Database
+}
+
+// InnerVM is the interface that must be implemented by the VM
+// that's being wrapped by the extension
+type InnerVM interface {
+	ExtensibleVM
+	avalanchecommon.VM
+	block.ChainVM
+	block.BuildBlockWithContextChainVM
+	block.StateSyncableVM
+}
+
+// ExtendedBlock is a block that can be used by the extension
+type ExtendedBlock interface {
+	snowman.Block
+	GetEthBlock() *types.Block
+	GetBlockExtension() BlockExtension
+}
+
+type BlockExtender interface {
+	// NewBlockExtension is called when a new block is created
+	NewBlockExtension(b ExtendedBlock) (BlockExtension, error)
+}
+
+// BlockExtension allows the VM extension to handle block processing events.
+type BlockExtension interface {
+	// SyntacticVerify verifies the block syntactically
+	// it can be implemented to extend inner block verification
+	SyntacticVerify(rules extras.Rules) error
+	// SemanticVerify verifies the block semantically
+	// it can be implemented to extend inner block verification
+	SemanticVerify() error
+	// CleanupVerified is called when a block has passed SemanticVerify and SynctacticVerify,
+	// and should be cleaned up due to error or verification runs under non-write mode. This
+	// does not return an error because the block has already been verified.
+	CleanupVerified()
+	// Accept is called when a block is accepted by the block manager. Accept takes a
+	// database.Batch that contains the changes that were made to the database as a result
+	// of accepting the block. The changes in the batch should be flushed to the database in this method.
+	Accept(acceptedBatch database.Batch) error
+	// Reject is called when a block is rejected by the block manager
+	Reject() error
+}
+
+// BuilderMempool is a mempool that's used in the block builder
+type BuilderMempool interface {
+	// PendingLen returns the number of pending transactions
+	// that are waiting to be included in a block
+	PendingLen() int
+	// SubscribePendingTxs returns a channel that's signaled when there are pending transactions
+	SubscribePendingTxs() <-chan struct{}
+}
+
+// LeafRequestConfig is the configuration to handle leaf requests
+// in the network and syncer
+type LeafRequestConfig struct {
+	// LeafType is the type of the leaf node
+	LeafType message.NodeType
+	// MetricName is the name of the metric to use for the leaf request
+	MetricName string
+	// Handler is the handler to use for the leaf request
+	Handler handlers.LeafRequestHandler
+}
+
+// Config is the configuration for the VM extension
+type Config struct {
+	// ConsensusCallbacks is the consensus callbacks to use
+	// for the VM to be used in consensus engine.
+	// Callback functions can be nil.
+	ConsensusCallbacks dummy.ConsensusCallbacks
+	// SyncSummaryProvider is the sync summary provider to use
+	// for the VM to be used in syncer.
+	// It's required and should be non-nil
+	SyncSummaryProvider sync.SummaryProvider
+	// SyncExtender can extend the syncer to handle custom sync logic.
+	// It's optional and can be nil
+	SyncExtender sync.Extender
+	// SyncableParser is to parse summary messages from the network.
+	// It's required and should be non-nil
+	SyncableParser message.SyncableParser
+	// BlockExtender allows the VM extension to create an extension to handle block processing events.
+	// It's optional and can be nil
+	BlockExtender BlockExtender
+	// ExtraSyncLeafHandlerConfig is the extra configuration to handle leaf requests
+	// in the network and syncer. It's optional and can be nil
+	ExtraSyncLeafHandlerConfig *LeafRequestConfig
+	// ExtraMempool is the mempool to be used in the block builder.
+	// It's optional and can be nil
+	ExtraMempool BuilderMempool
+	// Clock is the clock to use for time related operations.
+	// It's optional and can be nil
+	Clock *mockable.Clock
+}
+
+func (c *Config) Validate() error {
+	if c == nil {
+		return errNilConfig
+	}
+	if c.SyncSummaryProvider == nil {
+		return errNilSyncSummaryProvider
+	}
+	if c.SyncableParser == nil {
+		return errNilSyncableParser
+	}
+	if c.Clock == nil {
+		return errNilClock
+	}
+	return nil
+}

plugin/evm/message/codec.go

@@ -27,9 +27,9 @@ func init() {
 	c.SkipRegistrations(1)
 
 	errs := wrappers.Errs{}
+	// Gossip types and sync summary type removed from codec
+	c.SkipRegistrations(3)
 	errs.Add(
-		// Types for state sync frontier consensus
-		c.RegisterType(SyncSummary{}),
 
 		// state sync types
 		c.RegisterType(BlockRequest{}),

plugin/evm/message/handler.go

@@ -17,9 +17,8 @@ var (
 // Must have methods in format of handleType(context.Context, ids.NodeID, uint32, request Type) error
 // so that the Request object of relevant Type can invoke its respective handle method
 // on this struct.
-// Also see GossipHandler for implementation style.
 type RequestHandler interface {
-	HandleStateTrieLeafsRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, leafsRequest LeafsRequest) ([]byte, error)
+	HandleLeafsRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, leafsRequest LeafsRequest) ([]byte, error)
 	HandleBlockRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, request BlockRequest) ([]byte, error)
 	HandleCodeRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, codeRequest CodeRequest) ([]byte, error)
 }
@@ -35,7 +34,7 @@ type ResponseHandler interface {
 
 type NoopRequestHandler struct{}
 
-func (NoopRequestHandler) HandleStateTrieLeafsRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, leafsRequest LeafsRequest) ([]byte, error) {
+func (NoopRequestHandler) HandleLeafsRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, leafsRequest LeafsRequest) ([]byte, error) {
 	return nil, nil
 }
 

plugin/evm/message/leafs_request.go

@@ -15,25 +15,37 @@ const MaxCodeHashesPerRequest = 5
 
 var _ Request = LeafsRequest{}
 
+// NodeType outlines the trie that a leaf node belongs to
+// handlers.LeafsRequestHandler uses this information to determine
+// which trie type to fetch the information from
+type NodeType uint8
+
+const (
+	StateTrieNode      = NodeType(1)
+	StateTrieKeyLength = common.HashLength
+)
+
 // LeafsRequest is a request to receive trie leaves at specified Root within Start and End byte range
 // Limit outlines maximum number of leaves to returns starting at Start
+// NodeType outlines which trie to read from state/atomic.
 type LeafsRequest struct {
-	Root    common.Hash `serialize:"true"`
-	Account common.Hash `serialize:"true"`
-	Start   []byte      `serialize:"true"`
-	End     []byte      `serialize:"true"`
-	Limit   uint16      `serialize:"true"`
+	Root     common.Hash `serialize:"true"`
+	Account  common.Hash `serialize:"true"`
+	Start    []byte      `serialize:"true"`
+	End      []byte      `serialize:"true"`
+	Limit    uint16      `serialize:"true"`
+	NodeType NodeType    `serialize:"true"`
 }
 
 func (l LeafsRequest) String() string {
 	return fmt.Sprintf(
-		"LeafsRequest(Root=%s, Account=%s, Start=%s, End %s, Limit=%d)",
-		l.Root, l.Account, common.Bytes2Hex(l.Start), common.Bytes2Hex(l.End), l.Limit,
+		"LeafsRequest(Root=%s, Account=%s, Start=%s, End=%s, Limit=%d, NodeType=%d)",
+		l.Root, l.Account, common.Bytes2Hex(l.Start), common.Bytes2Hex(l.End), l.Limit, l.NodeType,
 	)
 }
 
 func (l LeafsRequest) Handle(ctx context.Context, nodeID ids.NodeID, requestID uint32, handler RequestHandler) ([]byte, error) {
-	return handler.HandleStateTrieLeafsRequest(ctx, nodeID, requestID, l)
+	return handler.HandleLeafsRequest(ctx, nodeID, requestID, l)
 }
 
 // LeafsResponse is a response to a LeafsRequest