Add migration for sepolia

migration/migration.go

@@ -3,13 +3,15 @@ package migration
 import (
 	"bytes"
 	"context"
+	_ "embed"
 	"encoding/binary"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"maps"
 	"runtime"
 	"sync"
+	"time"
 
 	"github.com/NethermindEth/juno/adapters/sn2core"
 	"github.com/NethermindEth/juno/blockchain"
@@ -66,6 +68,7 @@ var defaultMigrations = []Migration{
 	NewBucketMover(db.Temporary, db.ContractStorage),
 	NewBucketMigrator(db.StateUpdatesByBlockNumber, changeStateDiffStruct).WithBatchSize(100), //nolint:mnd
 	NewBucketMigrator(db.Class, migrateCairo1CompiledClass).WithBatchSize(1_000),              //nolint:mnd
+	MigrationFunc(updatePre0132Blocks),
 }
 
 var ErrCallWithNewTransaction = errors.New("call with new transaction")
@@ -718,3 +721,82 @@ func migrateCairo1CompiledClass(txn db.Transaction, key, value []byte, _ *utils.
 
 	return txn.Set(key, value)
 }
+
+//go:embed sepolia_block_hashes.bin
+var sepoliaBlockHashes []byte
+
+const first0132SepoliaBlock = 86311
+
+func updatePre0132Blocks(txn db.Transaction, network *utils.Network) error {
+	// TODO: remove when possible
+	if network != &utils.Sepolia {
+		return nil
+	}
+
+	timeToSetBytes := time.Duration(0)
+	timeToStoreP2PHash := time.Duration(0)
+
+	p2pHash := new(felt.Felt)
+	var start time.Time
+	for blockNumber := uint64(0); blockNumber < first0132SepoliaBlock; blockNumber++ {
+		offset := blockNumber * 32
+		start = time.Now()
+		p2pHash.SetBytes(sepoliaBlockHashes[offset : offset+32])
+		timeToSetBytes += time.Since(start)
+		start = time.Now()
+		if err := blockchain.StoreP2PHash(txn, blockNumber, p2pHash); err != nil {
+			return err
+		}
+		timeToStoreP2PHash += time.Since(start)
+	}
+
+	fmt.Printf("Time to set bytes: %v\n", timeToSetBytes)
+	fmt.Printf("Time to store p2p hash: %v\n", timeToStoreP2PHash)
+
+	timeToGetBlock := time.Duration(0)
+	timeToGetStateUpdate := time.Duration(0)
+	timeToPost0132Hash := time.Duration(0)
+	timeToStoreBlockCommitments := time.Duration(0)
+
+	for blockNumber := uint64(0); blockNumber < first0132SepoliaBlock; blockNumber++ {
+		start = time.Now()
+		block, err := blockchain.BlockByNumber(txn, blockNumber)
+		if err != nil {
+			if errors.Is(err, db.ErrKeyNotFound) {
+				break
+			}
+			return err
+		}
+		timeToGetBlock += time.Since(start)
+
+		start = time.Now()
+		stateUpdate, err := blockchain.StateUpdateByNumber(txn, blockNumber)
+		if err != nil {
+			if errors.Is(err, db.ErrKeyNotFound) {
+				break
+			}
+			return err
+		}
+		timeToGetStateUpdate += time.Since(start)
+
+		start = time.Now()
+		_, commitments, err := core.Post0132Hash(block, stateUpdate.StateDiff)
+		if err != nil {
+			return err
+		}
+		timeToPost0132Hash += time.Since(start)
+
+		start = time.Now()
+		if err := blockchain.StoreBlockCommitments(txn, blockNumber, commitments); err != nil {
+			return err
+		}
+		timeToStoreBlockCommitments += time.Since(start)
+	}
+
+	fmt.Printf("Time to get block: %v\n", timeToGetBlock)
+	fmt.Printf("Time to get state update: %v\n", timeToGetStateUpdate)
+	fmt.Printf("Time to post 0132 hash: %v\n", timeToPost0132Hash)
+	fmt.Printf("Time to store block commitments: %v\n", timeToStoreBlockCommitments)
+
+	return nil
+}

migration/migration_pkg_test.go

@@ -678,6 +678,67 @@ func TestChangeStateDiffStruct(t *testing.T) {
 	}))
 }
 
+func TestUpdatePre0132BlocksMainnet(t *testing.T) {
+	testDB := pebble.NewMemTest(t)
+	txn, err := testDB.NewTransaction(true)
+	require.NoError(t, err)
+
+	// TODO: Add test for mainnet when possible
+	require.NoError(t, updatePre0132Blocks(txn, &utils.Mainnet))
+	require.ErrorIs(t, txn.Get(db.P2PHash.Key(core.MarshalBlockNumber(0)), func(val []byte) error {
+		return nil
+	}), db.ErrKeyNotFound)
+}
+
+func TestUpdatePre0132BlocksSepoliaEmptyDB(t *testing.T) {
+	testDB := pebble.NewMemTest(t)
+	txn, err := testDB.NewTransaction(true)
+	require.NoError(t, err)
+
+	require.NoError(t, updatePre0132Blocks(txn, &utils.Sepolia))
+	for blockNumber := uint64(0); blockNumber < first0132SepoliaBlock; blockNumber++ {
+		offset := 32 * blockNumber
+		require.NoError(t, txn.Get(db.P2PHash.Key(core.MarshalBlockNumber(blockNumber)), func(val []byte) error {
+			require.Equal(t, val, sepoliaBlockHashes[offset:offset+32])
+			return nil
+		}))
+	}
+}
+
+func TestUpdatePre0132BlocksSepoliaNonEmptyDB(t *testing.T) {
+	testDB := pebble.NewMemTest(t)
+	chain := blockchain.New(testDB, &utils.Sepolia)
+	client := feeder.NewTestClient(t, &utils.Sepolia)
+	gw := adaptfeeder.New(client)
+
+	for blockNumber := uint64(0); blockNumber < 3; blockNumber++ {
+		b, err := gw.BlockByNumber(context.Background(), blockNumber)
+		require.NoError(t, err)
+		su, err := gw.StateUpdate(context.Background(), blockNumber)
+		require.NoError(t, err)
+		require.NoError(t, chain.Store(b, &core.BlockCommitments{}, su, nil))
+	}
+
+	require.NoError(t, testDB.Update(func(txn db.Transaction) error {
+		return updatePre0132Blocks(txn, &utils.Sepolia)
+	}))
+
+	for blockNumber := uint64(0); blockNumber < 3; blockNumber++ {
+		b, err := chain.BlockByNumber(blockNumber)
+		require.NoError(t, err)
+		stateUpdate, err := chain.StateUpdateByNumber(blockNumber)
+		require.NoError(t, err)
+		blockCommiments, err := chain.BlockCommitmentsByNumber(blockNumber)
+		require.NoError(t, err)
+		hash, post0132commiments, err := core.Post0132Hash(b, stateUpdate.StateDiff)
+		require.NoError(t, err)
+		require.Equal(t, post0132commiments, blockCommiments)
+		p2phash, err := chain.BlockP2PHashByNumber(blockNumber)
+		require.NoError(t, err)
+		require.Equal(t, hash, p2phash)
+	}
+}
+
 func randSlice(t *testing.T) []*felt.Felt {
 	n := rand.Intn(10)
 	sl := make([]*felt.Felt, n)