ava-labs · powerslider · Mar 5, 2026 · Mar 5, 2026 · Mar 5, 2026 · Mar 5, 2026
@@ -2,7 +2,7 @@ diff --git a/BUILD.bazel b/BUILD.bazel
 new file mode 100644
 --- /dev/null
 +++ b/BUILD.bazel
-@@ -0,0 +1,59 @@
+@@ -0,0 +1,      59 @@
 +# gazelle:ignore
 +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 +

@@ -2,7 +2,7 @@ diff --git a/crypto/secp256k1/BUILD.bazel b/crypto/secp256k1/BUILD.bazel
 new file mode 100644
 --- /dev/null
 +++ b/crypto/secp256k1/BUILD.bazel
-@@ -0,0 +1,27 @@
+@@ -0,0 +1,      27 @@
 +# gazelle:ignore
 +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 +
@@ -34,7 +34,7 @@ diff --git a/crypto/secp256k1/libsecp256k1/BUILD.bazel b/crypto/secp256k1/libsec
 new file mode 100644
 --- /dev/null
 +++ b/crypto/secp256k1/libsecp256k1/BUILD.bazel
-@@ -0,0 +1,9 @@
+@@ -0,0 +1,       9 @@
 +# gazelle:ignore
 +cc_library(
 +    name = "libsecp256k1",

@@ -2,7 +2,7 @@ diff --git a/bindings/BUILD.bazel b/bindings/BUILD.bazel
 new file mode 100644
 --- /dev/null
 +++ b/bindings/BUILD.bazel
-@@ -0,0 +1,9 @@
+@@ -0,0 +1,       9 @@
 +# gazelle:ignore
 +# Header library for blst C bindings
 +
@@ -16,7 +16,7 @@ diff --git a/bindings/go/BUILD.bazel b/bindings/go/BUILD.bazel
 new file mode 100644
 --- /dev/null
 +++ b/bindings/go/BUILD.bazel
-@@ -0,0 +1,60 @@
+@@ -0,0 +1,      60 @@
 +# gazelle:ignore
 +# Go bindings for blst library
 +#
@@ -81,7 +81,7 @@ diff --git a/bindings/vectors/BUILD.bazel b/bindings/vectors/BUILD.bazel
 new file mode 100644
 --- /dev/null
 +++ b/bindings/vectors/BUILD.bazel
-@@ -0,0 +1,8 @@
+@@ -0,0 +1,       8 @@
 +# gazelle:ignore
 +# Test vectors for blst
 +
@@ -94,7 +94,7 @@ diff --git a/build/BUILD.bazel b/build/BUILD.bazel
 new file mode 100644
 --- /dev/null
 +++ b/build/BUILD.bazel
-@@ -0,0 +1,20 @@
+@@ -0,0 +1,      20 @@
 +# gazelle:ignore
 +# Assembly and build file library for blst
 +#
@@ -119,7 +119,7 @@ diff --git a/src/BUILD.bazel b/src/BUILD.bazel
 new file mode 100644
 --- /dev/null
 +++ b/src/BUILD.bazel
-@@ -0,0 +1,10 @@
+@@ -0,0 +1,      10 @@
 +# gazelle:ignore
 +# Source library for blst - headers and C files for unity build
 +

@@ -2163,6 +2163,12 @@ func (bc *BlockChain) ResetToStateSyncedBlock(block *types.Block) error {
 	bc.chainmu.Lock()
 	defer bc.chainmu.Unlock()
 
+	// Persist the block to the raw DB. During dynamic sync the commit-target
+	// block may not have been fetched by the block syncer if the target
+	// advanced beyond its initial fetch window.
+	rawdb.WriteBlock(bc.db, block)
+	rawdb.WriteCanonicalHash(bc.db, block.Hash(), block.NumberU64())
+
 	// Update head block and snapshot pointers on disk
 	batch := bc.db.NewBatch()
 	if err := bc.batchBlockAcceptedIndices(batch, block); err != nil {

@@ -238,6 +238,13 @@ func (a *AtomicTrie) LastAcceptedRoot() common.Hash {
 	return a.lastAcceptedRoot
 }
 
+// ResetToLastCommitted resets lastAcceptedRoot to the last committed root.
+// Called between dynamic syncer sessions to clear stale references from a
+// cancelled session.
+func (a *AtomicTrie) ResetToLastCommitted() {
+	a.lastAcceptedRoot = a.lastCommittedRoot
+}
+
 func (a *AtomicTrie) InsertTrie(nodes *trienode.NodeSet, root common.Hash) error {
 	if nodes != nil {
 		if err := a.trieDB.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil); err != nil {

@@ -32,6 +32,7 @@ go_library(
         "@com_github_ava_labs_libevm//core/types",
         "@com_github_ava_labs_libevm//crypto",
         "@com_github_ava_labs_libevm//libevm/options",
+        "@com_github_ava_labs_libevm//log",
         "@com_github_ava_labs_libevm//metrics",
         "@com_github_ava_labs_libevm//trie",
         "@com_github_ava_labs_libevm//triedb",

@@ -0,0 +1,100 @@
+// Copyright (C) 2019, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package sync
+
+import (
+	"context"
+
+	"github.com/ava-labs/libevm/common"
+	"github.com/ava-labs/libevm/log"
+
+	"github.com/ava-labs/avalanchego/database/versiondb"
+	"github.com/ava-labs/avalanchego/graft/evm/sync/types"
+
+	atomicstate "github.com/ava-labs/avalanchego/graft/coreth/plugin/evm/atomic/state"
+)
+
+const (
+	atomicDynamicSyncerName = "Atomic State Syncer (dynamic)"
+	atomicDynamicSyncerID   = "state_atomic_sync"
+)
+
+var _ types.PivotSession = (*atomicPivotSession)(nil)
+
+// atomicPivotSession implements types.PivotSession for atomic trie sync.
+type atomicPivotSession struct {
+	inner      *Syncer
+	client     types.LeafClient
+	db         *versiondb.Database
+	atomicTrie *atomicstate.AtomicTrie
+	opts       []SyncerOption
+}
+
+func (s *atomicPivotSession) Run(ctx context.Context) error {
+	return s.inner.Sync(ctx)
+}
+
+func (*atomicPivotSession) ShouldPivot(common.Hash) bool {
+	// Always returns true because the incoming root is a block root
+	// (proxy), not the actual atomic root, so comparing it is meaningless.
+	return true
+}
+
+func (s *atomicPivotSession) Rebuild(newRoot common.Hash, newHeight uint64) (types.PivotSession, error) {
+	log.Info("atomic syncer pivoting", "newHeight", newHeight, "newRoot", newRoot)
+
+	if err := s.inner.Finalize(); err != nil {
+		log.Error("failed to flush atomic syncer during pivot", "err", err)
+	}
+	s.atomicTrie.ResetToLastCommitted()
+
+	newInner, err := NewSyncer(s.client, s.db, s.atomicTrie, newRoot, newHeight, s.opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &atomicPivotSession{
+		inner:      newInner,
+		client:     s.client,
+		db:         s.db,
+		atomicTrie: s.atomicTrie,
+		opts:       s.opts,
+	}, nil
+}
+
+func (*atomicPivotSession) OnSessionComplete() error {
+	return nil
+}
+
+// Finalize flushes the inner syncer's in-progress work.
+func (s *atomicPivotSession) Finalize() error {
+	return s.inner.Finalize()
+}
+
+// NewAtomicDynamicSyncer creates a DynamicSyncer backed by an
+// atomicPivotSession. The returned syncer supports pivoting to new
+// targets during sync.
+func NewAtomicDynamicSyncer(
+	inner *Syncer,
+	client types.LeafClient,
+	db *versiondb.Database,
+	atomicTrie *atomicstate.AtomicTrie,
+	initialRoot common.Hash,
+	initialHeight uint64,
+	opts ...SyncerOption,
+) *types.DynamicSyncer {
+	session := &atomicPivotSession{
+		inner:      inner,
+		client:     client,
+		db:         db,
+		atomicTrie: atomicTrie,
+		opts:       opts,
+	}
+	return types.NewDynamicSyncer(
+		atomicDynamicSyncerName,
+		atomicDynamicSyncerID,
+		session,
+		initialRoot,
+		initialHeight,
+	)
+}
@@ -0,0 +1,51 @@
+// Copyright (C) 2019, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package sync
+
+import (
+	"math/rand"
+	"testing"
+
+	"github.com/ava-labs/libevm/common"
+	"github.com/ava-labs/libevm/core/rawdb"
+	"github.com/ava-labs/libevm/triedb"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/graft/coreth/plugin/evm/atomic/state"
+	"github.com/ava-labs/avalanchego/graft/evm/sync/synctest"
+	"github.com/ava-labs/avalanchego/graft/evm/sync/types"
+)
+
+// TestAtomicDynamicSyncer_CompletesWithoutPivot verifies that the dynamic
+// wrapper completes a full sync when no pivot is triggered.
+func TestAtomicDynamicSyncer_CompletesWithoutPivot(t *testing.T) {
+	targetHeight := 2 * uint64(testCommitInterval)
+	r := rand.New(rand.NewSource(1))
+	serverTrieDB := triedb.NewDatabase(rawdb.NewMemoryDatabase(), nil)
+	root, _, _ := synctest.GenerateIndependentTrie(t, r, serverTrieDB, int(targetHeight), state.TrieKeyLength)
+
+	ctx, mockClient, atomicBackend, clientDB := setupTestInfrastructure(t, serverTrieDB)
+	atomicTrie := atomicBackend.AtomicTrie()
+
+	inner, err := NewSyncer(mockClient, clientDB, atomicTrie, root, targetHeight)
+	require.NoError(t, err)
+
+	ds := NewAtomicDynamicSyncer(inner, mockClient, clientDB, atomicTrie, root, targetHeight)
+
+	require.NoError(t, ds.Sync(ctx))
+	require.Equal(t, targetHeight, ds.TargetHeight())
+}
+
+// TestAtomicDynamicSyncer_UpdateTarget_StaleIgnored verifies that UpdateTarget
+// with a height at or below the current desired height is a no-op.
+func TestAtomicDynamicSyncer_UpdateTarget_StaleIgnored(t *testing.T) {
+	ds := types.NewDynamicSyncer("test", "test", &synctest.PivotSession{}, common.Hash{1}, 100)
+
+	require.NoError(t, ds.UpdateTarget(&synctest.SyncTarget{BlockRoot: common.Hash{2}, BlockHeight: 100}))
+	require.Equal(t, common.Hash{1}, ds.DesiredRoot())
+
+	require.NoError(t, ds.UpdateTarget(&synctest.SyncTarget{BlockRoot: common.Hash{3}, BlockHeight: 50}))
+	require.Equal(t, common.Hash{1}, ds.DesiredRoot())
+	require.Equal(t, uint64(100), ds.TargetHeight())
+}
@@ -6,6 +6,8 @@ package sync
 import (
 	"fmt"
 
+	"github.com/ava-labs/libevm/log"
+
 	"github.com/ava-labs/avalanchego/database/versiondb"
 	"github.com/ava-labs/avalanchego/graft/coreth/plugin/evm/atomic/state"
 	"github.com/ava-labs/avalanchego/graft/evm/message"
@@ -14,37 +16,49 @@ import (
 
 // Extender is the sync extender for the atomic VM.
 type Extender struct {
-	backend     *state.AtomicBackend
-	trie        *state.AtomicTrie
-	requestSize uint16 // maximum number of leaves to sync in a single request
+	backend        *state.AtomicBackend
+	trie           *state.AtomicTrie
+	requestSize    uint16 // maximum number of leaves to sync in a single request
+	dynamicEnabled bool   // whether to create a dynamic syncer that supports pivoting
 }
 
 // Initialize initializes the sync extender with the backend and trie and request size.
-func (e *Extender) Initialize(backend *state.AtomicBackend, trie *state.AtomicTrie, requestSize uint16) {
+func (e *Extender) Initialize(backend *state.AtomicBackend, trie *state.AtomicTrie, requestSize uint16, dynamicEnabled bool) {
 	e.backend = backend
 	e.trie = trie
 	e.requestSize = requestSize
+	e.dynamicEnabled = dynamicEnabled
 }
 
 // CreateSyncer creates the atomic syncer with the given client and verDB.
+// When dynamic mode is enabled, wraps the static syncer in an
+// AtomicDynamicSyncer that supports pivoting to new targets.
 func (e *Extender) CreateSyncer(client types.LeafClient, verDB *versiondb.Database, summary message.Syncable) (types.Syncer, error) {
 	atomicSummary, ok := summary.(*Summary)
 	if !ok {
 		return nil, fmt.Errorf("atomic sync extender: expected *Summary, got %T", summary)
 	}
 
+	opts := []SyncerOption{WithRequestSize(e.requestSize)}
 	syncer, err := NewSyncer(
 		client,
 		verDB,
 		e.trie,
 		atomicSummary.AtomicRoot,
 		atomicSummary.BlockNumber,
-		WithRequestSize(e.requestSize),
+		opts...,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("atomic.NewSyncer failed: %w", err)
 	}
-	return syncer, nil
+	if !e.dynamicEnabled {
+		return syncer, nil
+	}
+	return NewAtomicDynamicSyncer(
+		syncer, client, verDB, e.trie,
+		atomicSummary.AtomicRoot, atomicSummary.BlockNumber,
+		opts...,
+	), nil
 }
 
 // OnFinishBeforeCommit implements the sync.Extender interface by marking the previously last accepted block for the shared memory cursor.
@@ -61,12 +75,28 @@ func (e *Extender) OnFinishBeforeCommit(lastAcceptedHeight uint64, summary messa
 
 // OnFinishAfterCommit implements the sync.Extender interface by applying the atomic trie to the shared memory.
 func (e *Extender) OnFinishAfterCommit(summaryHeight uint64) error {
-	// the chain state is already restored, and, from this point on,
-	// the block synced to is the accepted block. The last operation
-	// is updating shared memory with the atomic trie.
-	// ApplyToSharedMemory does this, and, even if the VM is stopped
-	// (gracefully or ungracefully), since MarkApplyToSharedMemoryCursor
-	// is called, VM will resume ApplyToSharedMemory on Initialize.
+	// Check if the atomic trie has complete data up to summaryHeight.
+	// During dynamic sync the coordinator's commitTarget may be ahead of the
+	// atomic syncer's fixed target. In that case the trie only covers up to
+	// the atomic syncer's target, so we must skip ApplyToSharedMemory and
+	// keep the cursor alive. The gap is filled during batch replay (each
+	// replayed block's Accept applies atomic ops to shared memory inline)
+	// and the cursor is cleaned up on the next VM restart via
+	// NewAtomicBackend -> ApplyToSharedMemory(lastAcceptedHeight).
+	_, lastCommittedHeight := e.trie.LastCommitted()
+	if lastCommittedHeight < summaryHeight {
+		log.Info(
+			"skipping ApplyToSharedMemory: atomic trie has partial data",
+			"lastCommittedHeight", lastCommittedHeight,
+			"summaryHeight", summaryHeight,
+		)
+		return nil
+	}
+
+	// The atomic trie covers the full range. Apply to shared memory now.
+	// Even if the VM is stopped (gracefully or ungracefully), since
+	// MarkApplyToSharedMemoryCursor was called in OnFinishBeforeCommit,
+	// the VM will resume ApplyToSharedMemory on Initialize.
 	if err := e.backend.ApplyToSharedMemory(summaryHeight); err != nil {
 		return fmt.Errorf("failed to apply atomic trie to shared memory after commit: %w", err)
 	}

@@ -23,10 +23,10 @@ func TestMarshalSummary(t *testing.T) {
 	require.Equal(t, uint64(2), atomicSummary.Height())
 	require.Equal(t, common.Hash{3}, atomicSummary.GetBlockRoot())
 
-	expectedBase64Bytes := "AAAAAAAAAAAAAgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
-	require.Equal(t, expectedBase64Bytes, base64.StdEncoding.EncodeToString(atomicSummary.Bytes()))
-	expectedID := ids.FromStringOrPanic("256pj4a3SBG5kervhxKfeKpNRcVR1xk5BzTpkTkybkM8uMPu6Q")
-	require.Equal(t, expectedID, atomicSummary.ID())
+	wantBase64Bytes := "AAAAAAAAAAAAAgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="
+	require.Equal(t, wantBase64Bytes, base64.StdEncoding.EncodeToString(atomicSummary.Bytes()))
+	wantID := ids.FromStringOrPanic("256pj4a3SBG5kervhxKfeKpNRcVR1xk5BzTpkTkybkM8uMPu6Q")
+	require.Equal(t, wantID, atomicSummary.ID())
 
 	provider := &SummaryProvider{}
 	called := false

@@ -147,6 +147,13 @@ func (s *Syncer) Sync(ctx context.Context) error {
 	return s.syncer.Sync(ctx)
 }
 
+func (*Syncer) UpdateTarget(message.Syncable) error {
+	// The atomic syncer does not pivot. It syncs to the initial target from
+	// the peer summary and relies on batch replay to fill the gap between
+	// its target and the coordinator's commitTarget.
+	return nil
+}
+
 // Finalize commits any pending database changes to disk.
 // This ensures that even if the sync is cancelled or fails, we preserve
 // the progress up to the last fully synced height.