Merge branch 'main' into perf-pure-go-cairo0-class-hash

Author: RafaelGranza

db/memory/batch.go

@@ -132,12 +132,18 @@ func (b *batch) DeleteRange(start, end []byte) error {
 		return errBatchClosed
 	}
 
-	it, err := b.NewIterator(start, false)
+	// Range-based, matching pebble's DeleteRange semantics: delete every
+	// key in [start, end). We iterate with a nil prefix (all keys), Seek
+	// to start, and stop at end. Prefix-bounded iteration would miss keys
+	// whose first bytes only partially share `start` — e.g. a chunk
+	// spanning multiple per-block entries under one address prefix.
+	it, err := b.NewIterator(nil, false)
 	if err != nil {
 		return err
 	}
+	defer it.Close()
 
-	for it.Next() {
+	for ok := it.Seek(start); ok; ok = it.Next() {
 		if bytes.Compare(it.Key(), end) >= 0 {
 			break
 		}

db/testutil.go

@@ -571,64 +571,89 @@ func TestKeyValueStoreSuite(t *testing.T, newDB func() KeyValueStore) {
 		database := newDB()
 		defer database.Close()
 
-		// Helper to add a range of keys
-		addRange := func(start, stop int) {
-			for i := start; i <= stop; i++ {
-				key := strconv.Itoa(i)
-				value := "value-" + key
-				err := database.Put([]byte(key), []byte(value))
-				require.NoError(t, err, "Put operation failed for key %s", key)
-			}
-		}
-
-		// Helper to check if a range of keys exists
-		checkRange := func(start, stop int, expected bool) {
-			for i := start; i <= stop; i++ {
-				key := []byte(strconv.Itoa(i))
-				has, err := database.Has(key)
-				require.NoError(t, err, "Has operation failed for key %s", key)
-				if expected {
-					require.True(t, has, "key %s should exist", key)
-				} else {
-					require.False(t, has, "key %s should not exist", key)
-				}
-			}
-		}
-
-		addRange(1, 9)
+		addRange(t, database, 9)
 		require.NoError(t, database.DeleteRange([]byte("9"), []byte("1"))) // no-op
-		checkRange(1, 9, true)
+		checkRange(t, database, 1, 9, true)
 		require.NoError(t, database.DeleteRange([]byte("5"), []byte("5"))) // no-op, exclusive end
-		checkRange(1, 9, true)
+		checkRange(t, database, 1, 9, true)
 		require.NoError(t, database.DeleteRange([]byte("5"), []byte("50"))) // delete only key 5
-		checkRange(1, 4, true)
-		checkRange(5, 5, false)
-		checkRange(6, 9, true)
+		checkRange(t, database, 1, 4, true)
+		checkRange(t, database, 5, 5, false)
+		checkRange(t, database, 6, 9, true)
 		require.NoError(t, database.DeleteRange([]byte(""), []byte("a"))) // delete all
-		checkRange(1, 9, false)
+		checkRange(t, database, 1, 9, false)
 
-		addRange(1, 999)
+		addRange(t, database, 999)
 		require.NoError(t, database.DeleteRange([]byte("12345"), []byte("54321")))
-		checkRange(1, 1, true)
-		checkRange(2, 5, false)
-		checkRange(6, 12, true)
-		checkRange(13, 54, false)
-		checkRange(55, 123, true)
-		checkRange(124, 543, false)
-		checkRange(544, 999, true)
-
-		addRange(1, 999)
+		checkRange(t, database, 1, 1, true)
+		checkRange(t, database, 2, 5, false)
+		checkRange(t, database, 6, 12, true)
+		checkRange(t, database, 13, 54, false)
+		checkRange(t, database, 55, 123, true)
+		checkRange(t, database, 124, 543, false)
+		checkRange(t, database, 544, 999, true)
+
+		addRange(t, database, 999)
 		require.NoError(t, database.DeleteRange([]byte("3"), []byte("7")))
-		checkRange(1, 2, true)
-		checkRange(3, 6, false)
-		checkRange(7, 29, true)
-		checkRange(30, 69, false)
-		checkRange(70, 299, true)
-		checkRange(300, 699, false)
-		checkRange(700, 999, true)
+		checkRange(t, database, 1, 2, true)
+		checkRange(t, database, 3, 6, false)
+		checkRange(t, database, 7, 29, true)
+		checkRange(t, database, 30, 69, false)
+		checkRange(t, database, 70, 299, true)
+		checkRange(t, database, 300, 699, false)
+		checkRange(t, database, 700, 999, true)
 
 		require.NoError(t, database.DeleteRange([]byte(""), []byte("a")))
-		checkRange(1, 999, false)
+		checkRange(t, database, 1, 999, false)
+	})
+
+	// Mirrors the DeleteRange subtest above but routes every DeleteRange
+	// through a Batch + Write, pinning batch and direct paths to the same
+	// behavior across backends.
+	t.Run("BatchDeleteRange", func(t *testing.T) {
+		database := newDB()
+		defer database.Close()
+
+		deleteRangeViaBatch := func(start, end []byte) {
+			batch := database.NewBatch()
+			require.NoError(t, batch.DeleteRange(start, end))
+			require.NoError(t, batch.Write())
+		}
+
+		addRange(t, database, 9)
+		deleteRangeViaBatch([]byte("9"), []byte("1"))
+		checkRange(t, database, 1, 9, true)
+		deleteRangeViaBatch([]byte("5"), []byte("5"))
+		checkRange(t, database, 1, 9, true)
+		deleteRangeViaBatch([]byte("5"), []byte("50"))
+		checkRange(t, database, 1, 4, true)
+		checkRange(t, database, 5, 5, false)
+		checkRange(t, database, 6, 9, true)
+		deleteRangeViaBatch([]byte(""), []byte("a"))
+		checkRange(t, database, 1, 9, false)
+
+		addRange(t, database, 999)
+		deleteRangeViaBatch([]byte("12345"), []byte("54321"))
+		checkRange(t, database, 1, 1, true)
+		checkRange(t, database, 2, 5, false)
+		checkRange(t, database, 6, 12, true)
+		checkRange(t, database, 13, 54, false)
+		checkRange(t, database, 55, 123, true)
+		checkRange(t, database, 124, 543, false)
+		checkRange(t, database, 544, 999, true)
+
+		addRange(t, database, 999)
+		deleteRangeViaBatch([]byte("3"), []byte("7"))
+		checkRange(t, database, 1, 2, true)
+		checkRange(t, database, 3, 6, false)
+		checkRange(t, database, 7, 29, true)
+		checkRange(t, database, 30, 69, false)
+		checkRange(t, database, 70, 299, true)
+		checkRange(t, database, 300, 699, false)
+		checkRange(t, database, 700, 999, true)
+
+		deleteRangeViaBatch([]byte(""), []byte("a"))
+		checkRange(t, database, 1, 999, false)
 	})
 
 	t.Run("Snapshot", func(t *testing.T) {
@@ -797,6 +822,30 @@ func TestKeyValueStoreSuite(t *testing.T, newDB func() KeyValueStore) {
 	})
 }
 
+// Helper to add keys 1..stop.
+func addRange(t *testing.T, database KeyValueStore, stop int) {
+	for i := 1; i <= stop; i++ {
+		key := strconv.Itoa(i)
+		value := "value-" + key
+		err := database.Put([]byte(key), []byte(value))
+		require.NoError(t, err, "Put operation failed for key %s", key)
+	}
+}
+
+// Helper to check if a range of keys exists
+func checkRange(t *testing.T, database KeyValueStore, start, stop int, expected bool) {
+	for i := start; i <= stop; i++ {
+		key := []byte(strconv.Itoa(i))
+		has, err := database.Has(key)
+		require.NoError(t, err, "Has operation failed for key %s", key)
+		if expected {
+			require.True(t, has, "key %s should exist", key)
+		} else {
+			require.False(t, has, "key %s should not exist", key)
+		}
+	}
+}
+
 func assertIteratorErrorsAfterClose(t *testing.T, it Iterator) {
 	t.Helper()
 	require.NoError(t, it.Close(), "iterator close should succeed")

l1/l1.go

@@ -167,6 +167,17 @@ func (c *Client) Run(ctx context.Context) error {
 	return c.watchL1StateUpdates(ctx)
 }
 
+// CatchUpL1Head verifies the chain ID then writes the L1 head to the
+// database, without entering the live subscription loop. Closes the
+// underlying Subscriber on return; the Client must not be reused.
+func (c *Client) CatchUpL1Head(ctx context.Context) error {
+	defer c.l1.Close()
+	if err := c.checkChainID(ctx); err != nil {
+		return err
+	}
+	return c.catchUpL1HeadUpdates(ctx)
+}
+
 func (c *Client) watchL1StateUpdates(ctx context.Context) error {
 	buffer := 128
 

l1/l1_test.go

@@ -281,6 +281,74 @@ func TestEventListenerCatchUp(t *testing.T) {
 	require.Equal(t, *want, persisted)
 }
 
+// TestCatchUpL1Head is the regression for the history-pruning migration
+// bootstrap (node/migration.go). The migration crashes with a bare "key
+// not found" if it runs before any L1 head is on disk; the fix calls
+// Client.CatchUpL1Head in node/migration.go to write one up front. This
+// test pins the contract that CatchUpL1Head used by that path actually
+// persists the head — if a future change drops the setL1Head call inside
+// catchUpL1HeadUpdates, or short-circuits Client.CatchUpL1Head before it
+// reaches catch-up, chain.L1Head() below fails and the bug returns.
+func TestCatchUpL1Head(t *testing.T) {
+	t.Parallel()
+
+	ctrl := gomock.NewController(t)
+	nopLog := log.NewNopZapLogger()
+	network := networks.Mainnet
+	chain := blockchain.New(
+		memory.New(),
+		&network,
+		blockchain.WithNewState(statetestutils.UseNewState()),
+	)
+
+	subscriber := mocks.NewMockSubscriber(ctrl)
+	subscriber.EXPECT().ChainID(gomock.Any()).Return(network.L1ChainID, nil).AnyTimes()
+	subscriber.EXPECT().LatestHeight(gomock.Any()).Return(uint64(10), nil).AnyTimes()
+	subscriber.EXPECT().FinalisedHeight(gomock.Any()).Return(uint64(5), nil).AnyTimes()
+	subscriber.
+		EXPECT().
+		FilterLogStateUpdate(gomock.Any(), uint64(0), uint64(10)).
+		Return([]*contract.StarknetLogStateUpdate{{
+			BlockNumber: new(big.Int).SetUint64(7),
+			BlockHash:   new(big.Int).SetUint64(7),
+			GlobalRoot:  new(big.Int).SetUint64(7),
+			Raw:         types.Log{BlockNumber: 3},
+		}}, nil).
+		AnyTimes()
+	subscriber.EXPECT().Close().AnyTimes()
+
+	client := l1.NewClient(subscriber, chain, nopLog)
+	require.NoError(t, client.CatchUpL1Head(t.Context()))
+
+	persisted, err := chain.L1Head()
+	require.NoError(t, err)
+	require.Equal(t, core.L1Head{
+		BlockNumber: 7,
+		BlockHash:   new(felt.Felt).SetUint64(7),
+		StateRoot:   new(felt.Felt).SetUint64(7),
+	}, persisted)
+}
+
+func TestCatchUpL1Head_ChainIDMismatch(t *testing.T) {
+	t.Parallel()
+
+	ctrl := gomock.NewController(t)
+	nopLog := log.NewNopZapLogger()
+	network := networks.Mainnet
+	chain := blockchain.New(
+		memory.New(),
+		&network,
+		blockchain.WithNewState(statetestutils.UseNewState()),
+	)
+
+	subscriber := mocks.NewMockSubscriber(ctrl)
+	subscriber.EXPECT().ChainID(gomock.Any()).Return(big.NewInt(999), nil)
+	subscriber.EXPECT().Close()
+
+	err := l1.NewClient(subscriber, chain, nopLog).CatchUpL1Head(t.Context())
+	require.ErrorContains(t, err, "mismatched L1 and L2 networks")
+}
+
 func newTestL1Client(service service) *rpc.Server {
 	server := rpc.NewServer()
 	if err := server.RegisterName("eth", service); err != nil {

node/migration.go

@@ -2,8 +2,11 @@ package node
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
+	"github.com/NethermindEth/juno/blockchain"
+	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/db"
 	"github.com/NethermindEth/juno/migration"
 	"github.com/NethermindEth/juno/migration/blocktransactions"
@@ -32,26 +35,34 @@ func registerMigrations(cfg *Config) *migration.Registry {
 // migration progress via health check endpoints.
 func migrateIfNeeded(
 	ctx context.Context,
-	db db.KeyValueStore,
+	database db.KeyValueStore,
 	config *Config,
+	chain *blockchain.Blockchain,
 	logger log.Logger,
 ) error {
 	migrateFn := func() error {
 		// Run deprecated migrations first
 		if err := deprecated.MigrateIfNeeded(
 			ctx,
-			db,
+			database,
 			&config.Network,
 			logger,
 		); err != nil {
 			return fmt.Errorf("deprecated migration failed: %w", err)
 		}
 
+		// Make sure there is an available L1 head before starting pruning migration
+		if config.Prune {
+			if err := fetchL1HeadIfMissing(ctx, database, config, chain, logger); err != nil {
+				return fmt.Errorf("fetch L1 head for pruning: %w", err)
+			}
+		}
+
 		// Run new migrations
 		registry := registerMigrations(config)
 		runner, err := migration.NewRunner(
 			registry,
-			db,
+			database,
 			&config.Network,
 			logger,
 		)
@@ -73,3 +84,38 @@ func migrateIfNeeded(
 
 	return migrateFn()
 }
+
+// fetchL1HeadIfMissing writes an L1 head to disk before the history pruning
+// migration reads it. No-op when one is already stored.
+func fetchL1HeadIfMissing(
+	ctx context.Context,
+	database db.KeyValueStore,
+	config *Config,
+	chain *blockchain.Blockchain,
+	logger log.StructuredLogger,
+) error {
+	_, err := core.GetL1Head(database)
+	if err == nil {
+		return nil
+	}
+	if !errors.Is(err, db.ErrKeyNotFound) {
+		return err
+	}
+
+	logger.Info("Fetching the L1 head before running the prune migration")
+	client, err := newL1Client(config.EthNode, config.Metrics, chain, logger)
+	if err != nil {
+		return fmt.Errorf("creating a new L1 client: %w", err)
+	}
+	if err := client.CatchUpL1Head(ctx); err != nil {
+		return err
+	}
+
+	if _, err := core.GetL1Head(database); err != nil {
+		if errors.Is(err, db.ErrKeyNotFound) {
+			return errors.New("couldn't find a finalized Starknet state update on L1")
+		}
+		return err
+	}
+	return nil
+}