feat(sync): decouple code syncer from state syncer and run concurrently

plugin/evm/atomic/sync/syncer.go

@@ -40,6 +40,12 @@ var (
 	_ syncclient.LeafSyncTask = (*syncerLeafTask)(nil)
 )
 
+// Name returns the human-readable name for this sync task.
+func (*syncer) Name() string { return "Atomic State Syncer" }
+
+// ID returns the stable identifier for this sync task.
+func (*syncer) ID() string { return "state_atomic_sync" }
+
 // Config holds the configuration for creating a new atomic syncer.
 type Config struct {
 	// TargetHeight is the target block height to sync to.

plugin/evm/vmsync/client.go

@@ -25,19 +25,13 @@ import (
 	"github.com/ava-labs/coreth/sync/blocksync"
 	"github.com/ava-labs/coreth/sync/statesync"
 
-	synccommon "github.com/ava-labs/coreth/sync"
+	syncpkg "github.com/ava-labs/coreth/sync"
 	syncclient "github.com/ava-labs/coreth/sync/client"
 )
 
-const (
-	// BlocksToFetch is the number of the block parents the state syncs to.
-	// The last 256 block hashes are necessary to support the BLOCKHASH opcode.
-	BlocksToFetch = 256
-
-	atomicStateSyncOperationName = "Atomic State Sync"
-	blockSyncOperationName       = "Block Sync"
-	evmStateSyncOperationName    = "EVM State Sync"
-)
+// BlocksToFetch is the number of the block parents the state syncs to.
+// The last 256 block hashes are necessary to support the BLOCKHASH opcode.
+const BlocksToFetch = 256
 
 var stateSyncSummaryKey = []byte("stateSyncSummary")
 
@@ -67,7 +61,7 @@ type ClientConfig struct {
 	Parser message.SyncableParser
 
 	// Extender is an optional extension point for the state sync process, and can be nil.
-	Extender      synccommon.Extender
+	Extender      syncpkg.Extender
 	Client        syncclient.Client
 	StateSyncDone chan struct{}
 
@@ -169,52 +163,82 @@ func (client *client) stateSync(ctx context.Context) error {
 
 func (client *client) registerSyncers(registry *SyncerRegistry) error {
 	// Register block syncer.
-	syncer, err := client.createBlockSyncer(client.summary.GetBlockHash(), client.summary.Height())
+	blockSyncer, err := client.createBlockSyncer(client.summary.GetBlockHash(), client.summary.Height())
 	if err != nil {
 		return fmt.Errorf("failed to create block syncer: %w", err)
 	}
-	if err := registry.Register(blockSyncOperationName, syncer); err != nil {
-		return fmt.Errorf("failed to register block syncer: %w", err)
+
+	codeQueue, err := client.createCodeQueue()
+	if err != nil {
+		return fmt.Errorf("failed to create code queue: %w", err)
 	}
 
-	// Register EVM state syncer.
-	evmSyncer, err := client.createEVMSyncer()
+	codeSyncer, err := client.createCodeSyncer(codeQueue.CodeHashes())
 	if err != nil {
-		return fmt.Errorf("failed to create EVM syncer: %w", err)
+		return fmt.Errorf("failed to create code syncer: %w", err)
 	}
 
-	if err := registry.Register(evmStateSyncOperationName, evmSyncer); err != nil {
-		return fmt.Errorf("failed to register EVM syncer: %w", err)
+	stateSyncer, err := client.createEVMSyncer(codeQueue)
+	if err != nil {
+		return fmt.Errorf("failed to create EVM state syncer: %w", err)
 	}
 
-	// Register atomic syncer.
+	var atomicSyncer syncpkg.Syncer
 	if client.Extender != nil {
-		atomicSyncer, err := client.createAtomicSyncer()
+		atomicSyncer, err = client.createAtomicSyncer()
 		if err != nil {
 			return fmt.Errorf("failed to create atomic syncer: %w", err)
 		}
+	}
 
-		if err := registry.Register(atomicStateSyncOperationName, atomicSyncer); err != nil {
-			return fmt.Errorf("failed to register atomic syncer: %w", err)
+	syncers := []syncpkg.Syncer{
+		blockSyncer,
+		codeSyncer,
+		stateSyncer,
+	}
+	if atomicSyncer != nil {
+		syncers = append(syncers, atomicSyncer)
+	}
+
+	for _, s := range syncers {
+		if err := registry.Register(s); err != nil {
+			return fmt.Errorf("failed to register %s syncer: %w", s.Name(), err)
 		}
 	}
 
 	return nil
 }
 
-func (client *client) createBlockSyncer(fromHash common.Hash, fromHeight uint64) (synccommon.Syncer, error) {
+func (client *client) createBlockSyncer(fromHash common.Hash, fromHeight uint64) (syncpkg.Syncer, error) {
 	return blocksync.NewSyncer(client.Client, client.ChainDB, blocksync.Config{
 		FromHash:      fromHash,
 		FromHeight:    fromHeight,
 		BlocksToFetch: BlocksToFetch,
 	})
 }
 
-func (client *client) createEVMSyncer() (synccommon.Syncer, error) {
-	return statesync.NewSyncer(client.Client, client.ChainDB, client.summary.GetBlockRoot(), statesync.NewDefaultConfig(client.RequestSize))
+func (client *client) createEVMSyncer(fetcher syncpkg.CodeRequestQueue) (syncpkg.Syncer, error) {
+	return statesync.NewSyncer(
+		client.Client,
+		client.ChainDB,
+		client.summary.GetBlockRoot(),
+		fetcher,
+		statesync.NewDefaultConfig(client.RequestSize),
+	)
+}
+
+func (client *client) createCodeQueue() (syncpkg.CodeRequestQueue, error) {
+	return statesync.NewCodeQueue(
+		client.ChainDB,
+		client.StateSyncDone,
+	)
+}
+
+func (client *client) createCodeSyncer(codeHashes <-chan common.Hash) (syncpkg.Syncer, error) {
+	return statesync.NewCodeSyncer(client.Client, client.ChainDB, codeHashes)
 }
 
-func (client *client) createAtomicSyncer() (synccommon.Syncer, error) {
+func (client *client) createAtomicSyncer() (syncpkg.Syncer, error) {
 	return client.Extender.CreateSyncer(client.Client, client.VerDB, client.summary)
 }
 

plugin/evm/vmsync/doubles_test.go

@@ -8,6 +8,8 @@ import (
 	"errors"
 	"sync"
 	"time"
+
+	syncpkg "github.com/ava-labs/coreth/sync"
 )
 
 // FuncSyncer adapts a function to the simple Syncer shape used in tests. It is
@@ -19,6 +21,12 @@ type FuncSyncer struct {
 // Sync calls the wrapped function and returns its result.
 func (f FuncSyncer) Sync(ctx context.Context) error { return f.fn(ctx) }
 
+// Name returns the provided name or a default if unspecified.
+func (FuncSyncer) Name() string { return "Test Name" }
+func (FuncSyncer) ID() string   { return "test_id" }
+
+var _ syncpkg.Syncer = FuncSyncer{}
+
 // NewBarrierSyncer returns a syncer that, upon entering Sync, calls wg.Done() to
 // signal it has started, then blocks until either:
 //   - `releaseCh` is closed, returning nil; or

plugin/evm/vmsync/registry.go

@@ -24,7 +24,7 @@ type SyncerTask struct {
 // SyncerRegistry manages a collection of syncers for sequential execution.
 type SyncerRegistry struct {
 	syncers         []SyncerTask
-	registeredNames map[string]bool // Track registered names to prevent duplicates.
+	registeredNames map[string]bool // Track registered IDs to prevent duplicates.
 }
 
 // NewSyncerRegistry creates a new empty syncer registry.
@@ -36,13 +36,14 @@ func NewSyncerRegistry() *SyncerRegistry {
 
 // Register adds a syncer to the registry.
 // Returns an error if a syncer with the same name is already registered.
-func (r *SyncerRegistry) Register(name string, syncer synccommon.Syncer) error {
-	if r.registeredNames[name] {
-		return fmt.Errorf("syncer with name '%s' is already registered", name)
+func (r *SyncerRegistry) Register(syncer synccommon.Syncer) error {
+	id := syncer.ID()
+	if r.registeredNames[id] {
+		return fmt.Errorf("syncer with id '%s' is already registered", id)
 	}
 
-	r.registeredNames[name] = true
-	r.syncers = append(r.syncers, SyncerTask{name, syncer})
+	r.registeredNames[id] = true
+	r.syncers = append(r.syncers, SyncerTask{syncer.Name(), syncer})
 
 	return nil
 }

plugin/evm/vmsync/registry_test.go

@@ -38,6 +38,19 @@ func (m *mockSyncer) Sync(context.Context) error {
 	return m.syncError
 }
 
+func (m *mockSyncer) Name() string { return m.name }
+func (m *mockSyncer) ID() string   { return m.name }
+
+// namedSyncer adapts an existing syncer with a provided name to satisfy Syncer with Name().
+type namedSyncer struct {
+	name   string
+	syncer syncpkg.Syncer
+}
+
+func (n *namedSyncer) Sync(ctx context.Context) error { return n.syncer.Sync(ctx) }
+func (n *namedSyncer) Name() string                   { return n.name }
+func (n *namedSyncer) ID() string                     { return n.name }
+
 // syncerConfig describes a test syncer setup for RunSyncerTasks table tests.
 type syncerConfig struct {
 	name      string
@@ -67,12 +80,12 @@ func TestSyncerRegistry_Register(t *testing.T) {
 			expectedCount: 2,
 		},
 		{
-			name: "duplicate name registration",
+			name: "duplicate id registration",
 			registrations: []*mockSyncer{
 				newMockSyncer("Syncer1", nil),
 				newMockSyncer("Syncer1", nil),
 			},
-			expectedError: "syncer with name 'Syncer1' is already registered",
+			expectedError: "syncer with id 'Syncer1' is already registered",
 			expectedCount: 1,
 		},
 		{
@@ -93,7 +106,7 @@ func TestSyncerRegistry_Register(t *testing.T) {
 
 			// Perform registrations.
 			for _, reg := range tt.registrations {
-				err := registry.Register(reg.name, reg)
+				err := registry.Register(reg)
 				if err != nil {
 					errLast = err
 					break
@@ -163,7 +176,7 @@ func TestSyncerRegistry_RunSyncerTasks(t *testing.T) {
 			for i, syncerConfig := range tt.syncers {
 				mockSyncer := newMockSyncer(syncerConfig.name, syncerConfig.syncError)
 				mockSyncers[i] = mockSyncer
-				require.NoError(t, registry.Register(syncerConfig.name, mockSyncer))
+				require.NoError(t, registry.Register(mockSyncer))
 			}
 
 			ctx, cancel := utilstest.NewTestContext(t)
@@ -200,8 +213,8 @@ func TestSyncerRegistry_ConcurrentStart(t *testing.T) {
 
 	for i := 0; i < numBarrierSyncers; i++ {
 		name := fmt.Sprintf("BarrierSyncer-%d", i)
-		syncer := NewBarrierSyncer(&allStartedWG, releaseCh)
-		require.NoError(t, registry.Register(name, syncer))
+		s := &namedSyncer{name: name, syncer: NewBarrierSyncer(&allStartedWG, releaseCh)}
+		require.NoError(t, registry.Register(s))
 	}
 
 	doneCh := make(chan error, 1)
@@ -224,7 +237,7 @@ func TestSyncerRegistry_ErrorPropagatesAndCancelsOthers(t *testing.T) {
 	// Error syncer
 	trigger := make(chan struct{})
 	errFirst := errors.New("test error")
-	require.NoError(t, registry.Register("ErrorSyncer-0", NewErrorSyncer(trigger, errFirst)))
+	require.NoError(t, registry.Register(&namedSyncer{name: "ErrorSyncer-0", syncer: NewErrorSyncer(trigger, errFirst)}))
 
 	// Cancel-aware syncers to verify cancellation propagation
 	const numCancelSyncers = 2
@@ -237,8 +250,7 @@ func TestSyncerRegistry_ErrorPropagatesAndCancelsOthers(t *testing.T) {
 		cancelChans = append(cancelChans, canceledCh)
 		startedChans = append(startedChans, startedCh)
 		name := fmt.Sprintf("CancelSyncer-%d", i)
-
-		require.NoError(t, registry.Register(name, NewCancelAwareSyncer(startedCh, canceledCh, 4*time.Second)))
+		require.NoError(t, registry.Register(&namedSyncer{name: name, syncer: NewCancelAwareSyncer(startedCh, canceledCh, 4*time.Second)}))
 	}
 
 	doneCh := make(chan error, 1)
@@ -280,7 +292,7 @@ func TestSyncerRegistry_FirstErrorWinsAcrossMany(t *testing.T) {
 			errFirst = errInstance
 		}
 		name := fmt.Sprintf("ErrorSyncer-%d", i)
-		require.NoError(t, registry.Register(name, NewErrorSyncer(trigger, errInstance)))
+		require.NoError(t, registry.Register(&namedSyncer{name: name, syncer: NewErrorSyncer(trigger, errInstance)}))
 	}
 
 	doneCh := make(chan error, 1)

scripts/lint.sh

@@ -148,9 +148,17 @@ function test_require_error_is_no_funcs_as_params {
 }
 
 function test_require_no_error_inline_func {
-  if grep -R -zo -P '\t+err :?= ((?!require|if).|\n)*require\.NoError\((t, )?err\)' "${DEFAULT_FILES[@]}"; then
+  # Flag only when a single variable whose name contains "err" or "Err"
+  # (e.g., err, myErr, parseError) is assigned from a call (:= or =), and later
+  # that same variable is passed to require.NoError(...). We explicitly require
+  # no commas on the LHS to avoid flagging multi-return assignments like
+  # "val, err := f()" or "err, val := f()".
+  #
+  # Capture the variable name and enforce it matches in the subsequent require.NoError.
+  local -r pattern='^\s*([A-Za-z_][A-Za-z0-9_]*[eE]rr[A-Za-z0-9_]*)\s*:?=\s*[^,\n]*\([^)]*\).*\n(?:(?!^\s*(?:if|require)).*\n)*^\s*require\.NoError\((?:t,\s*)?\1\)'
+  if grep -R -zo -P "$pattern" "${DEFAULT_FILES[@]}"; then
     echo ""
-    echo "Checking that a function with a single error return doesn't error should be done in-line."
+    echo "Checking that a function with a single error return doesn't error should be done in-line (single LHS var containing 'err')."
     echo ""
     return 1
   fi

sync/blocksync/syncer.go

@@ -20,6 +20,12 @@ const blocksPerRequest = 32
 
 var _ synccommon.Syncer = (*blockSyncer)(nil)
 
+// Name returns the human-readable name for this sync task.
+func (*blockSyncer) Name() string { return "Block Syncer" }
+
+// ID returns the stable identifier for this sync task.
+func (*blockSyncer) ID() string { return "state_block_sync" }
+
 type Config struct {
 	FromHash      common.Hash // `FromHash` is the most recent
 	FromHeight    uint64