From 9e42b705ceab0e22d6b539852effec363c2cd47a Mon Sep 17 00:00:00 2001
From: Giulio rebuffo <giulio.rebuffo@gmail.com>
Date: Mon, 16 Oct 2023 15:35:26 +0200
Subject: [PATCH] Caplin: under the hood block downloading (#8459)

---
 Dockerfile                                    |   2 +-
 Dockerfile.debian                             |   2 +-
 Makefile                                      |   2 +-
 cl/persistence/block_saver_test.go            |   4 +
 cl/persistence/snapshot_format/blocks.go      |  49 +--
 cl/persistence/snapshot_format/blocks_test.go |   2 +-
 cl/persistence/snapshot_format/chunks.go      |  24 +-
 .../execution_client_direct.go                |   4 +
 .../execution_client/execution_client_rpc.go  |   4 +
 cl/phase1/execution_client/interface.go       |   2 +
 cl/phase1/network/gossip_manager.go           |   2 +-
 cl/phase1/stages/clstages.go                  |  21 +-
 cl/phase1/stages/stage_history_download.go    |  68 ++--
 cmd/{caplin-phase1 => caplin}/caplin1/run.go  |   2 +-
 cmd/{caplin-phase1 => caplin}/main.go         |   6 +-
 cmd/sentinel/sentinel/service/service.go      |   2 +-
 erigon-lib/direct/execution_client.go         |   4 +
 erigon-lib/go.mod                             |   2 +-
 erigon-lib/go.sum                             |   4 +-
 .../gointerfaces/execution/execution.pb.go    | 353 +++++++++++-------
 .../execution/execution_grpc.pb.go            |  39 ++
 .../gointerfaces/sentinel/sentinel.pb.go      | 105 +++---
 eth/backend.go                                |   3 +-
 .../eth1/eth1_chain_reader.go/chain_reader.go |   8 +-
 turbo/execution/eth1/getters.go               |   6 +
 25 files changed, 427 insertions(+), 293 deletions(-)
 rename cmd/{caplin-phase1 => caplin}/caplin1/run.go (98%)
 rename cmd/{caplin-phase1 => caplin}/main.go (95%)

diff --git a/Dockerfile b/Dockerfile
index 0d6c3dd96..77a7ddca2 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -78,7 +78,7 @@ COPY --from=builder /app/build/bin/sentry /usr/local/bin/sentry
 COPY --from=builder /app/build/bin/state /usr/local/bin/state
 COPY --from=builder /app/build/bin/txpool /usr/local/bin/txpool
 COPY --from=builder /app/build/bin/verkle /usr/local/bin/verkle
-COPY --from=builder /app/build/bin/caplin-phase1 /usr/local/bin/caplin-phase1
+COPY --from=builder /app/build/bin/caplin /usr/local/bin/caplin
 COPY --from=builder /app/build/bin/caplin-regression /usr/local/bin/caplin-regression
 
 
diff --git a/Dockerfile.debian b/Dockerfile.debian
index 5d7d4e549..ece8587c1 100644
--- a/Dockerfile.debian
+++ b/Dockerfile.debian
@@ -74,7 +74,7 @@ COPY --from=builder /app/build/bin/sentry /usr/local/bin/sentry
 COPY --from=builder /app/build/bin/state /usr/local/bin/state
 COPY --from=builder /app/build/bin/txpool /usr/local/bin/txpool
 COPY --from=builder /app/build/bin/verkle /usr/local/bin/verkle
-COPY --from=builder /app/build/bin/caplin-phase1 /usr/local/bin/caplin-phase1
+COPY --from=builder /app/build/bin/caplin /usr/local/bin/caplin
 COPY --from=builder /app/build/bin/caplin-regression /usr/local/bin/caplin-regression
 
 EXPOSE 8545 \
diff --git a/Makefile b/Makefile
index e3249efbb..7994a2fae 100644
--- a/Makefile
+++ b/Makefile
@@ -119,7 +119,7 @@ COMMANDS += txpool
 COMMANDS += verkle
 COMMANDS += evm
 COMMANDS += sentinel
-COMMANDS += caplin-phase1
+COMMANDS += caplin
 COMMANDS += caplin-regression
 
 
diff --git a/cl/persistence/block_saver_test.go b/cl/persistence/block_saver_test.go
index b94aa02ae..c502780e2 100644
--- a/cl/persistence/block_saver_test.go
+++ b/cl/persistence/block_saver_test.go
@@ -33,6 +33,10 @@ func (m *mockEngine) ForkChoiceUpdate(finalized libcommon.Hash, head libcommon.H
 	panic("unimplemented")
 }
 
+func (m *mockEngine) FrozenBlocks() uint64 {
+	panic("unimplemented")
+}
+
 func (m *mockEngine) NewPayload(payload *cltypes.Eth1Block, beaconParentRoot *libcommon.Hash) (bool, error) {
 	panic("unimplemented")
 }
diff --git a/cl/persistence/snapshot_format/blocks.go b/cl/persistence/snapshot_format/blocks.go
index 84624162a..e61dfca61 100644
--- a/cl/persistence/snapshot_format/blocks.go
+++ b/cl/persistence/snapshot_format/blocks.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 
+	"github.com/golang/snappy"
 	"github.com/ledgerwatch/erigon/cl/clparams"
 	"github.com/ledgerwatch/erigon/cl/cltypes"
 )
@@ -40,11 +41,11 @@ func writeExecutionBlockPtr(w io.Writer, p *cltypes.Eth1Block) error {
 	temp := make([]byte, 8)
 	binary.BigEndian.PutUint64(temp, p.BlockNumber)
 
-	return writeChunk(w, temp, pointerDataType, false)
+	return writeChunk(w, temp, pointerDataType)
 }
 
 func readExecutionBlockPtr(r io.Reader) (uint64, error) {
-	b, dT, err := readChunk(r, false)
+	b, dT, err := readChunk(r)
 	if err != nil {
 		return 0, err
 	}
@@ -90,11 +91,15 @@ func WriteBlockForSnapshot(block *cltypes.SignedBeaconBlock, w io.Writer) error
 	currentChunkLength += uint64(body.AttesterSlashings.EncodingSizeSSZ())
 
 	// Write the chunk and chunk attestations
-	if err := writeChunk(w, encoded[:currentChunkLength], chunkDataType, false); err != nil {
+	if err := writeChunk(w, encoded[:currentChunkLength], chunkDataType); err != nil {
 		return err
 	}
 	encoded = encoded[currentChunkLength:]
-	if err := writeChunk(w, encoded[:uint64(body.Attestations.EncodingSizeSSZ())], chunkDataType, true); err != nil {
+	snappyWriter := snappy.NewBufferedWriter(w)
+	if err := writeChunk(snappyWriter, encoded[:uint64(body.Attestations.EncodingSizeSSZ())], chunkDataType); err != nil {
+		return err
+	}
+	if err := snappyWriter.Close(); err != nil {
 		return err
 	}
 	encoded = encoded[body.Attestations.EncodingSizeSSZ():]
@@ -103,7 +108,7 @@ func WriteBlockForSnapshot(block *cltypes.SignedBeaconBlock, w io.Writer) error
 	currentChunkLength += uint64(body.Deposits.EncodingSizeSSZ())
 	currentChunkLength += uint64(body.VoluntaryExits.EncodingSizeSSZ())
 
-	if err := writeChunk(w, encoded[:currentChunkLength], chunkDataType, false); err != nil {
+	if err := writeChunk(w, encoded[:currentChunkLength], chunkDataType); err != nil {
 		return err
 	}
 	// we are done if we are before altair
@@ -117,10 +122,13 @@ func WriteBlockForSnapshot(block *cltypes.SignedBeaconBlock, w io.Writer) error
 	if version <= clparams.BellatrixVersion {
 		return nil
 	}
-	return writeChunk(w, encoded, chunkDataType, false)
+	return writeChunk(w, encoded, chunkDataType)
 }
 
-func ReadBlockFromrSnapshot(r io.Reader, executionReader ExecutionBlockReaderByNumber, cfg *clparams.BeaconChainConfig) (*cltypes.SignedBeaconBlock, error) {
+func ReadBlockFromSnapshot(r io.Reader, executionReader ExecutionBlockReaderByNumber, cfg *clparams.BeaconChainConfig) (*cltypes.SignedBeaconBlock, error) {
+	plainSSZ := []byte{}
+
+	block := cltypes.NewSignedBeaconBlock(cfg)
 	// Metadata section is just the current hardfork of the block. TODO(give it a useful purpose)
 	v, err := readMetadataForBlock(r)
 	if err != nil {
@@ -128,31 +136,34 @@ func ReadBlockFromrSnapshot(r io.Reader, executionReader ExecutionBlockReaderByN
 	}
 
 	// Read the first chunk
-	chunk1, dT1, err := readChunk(r, false)
+	chunk1, dT1, err := readChunk(r)
 	if err != nil {
 		return nil, err
 	}
 	if dT1 != chunkDataType {
 		return nil, fmt.Errorf("malformed beacon block, invalid chunk 1 type %d, expected: %d", dT1, chunkDataType)
 	}
+	plainSSZ = append(plainSSZ, chunk1...)
 	// Read the attestation chunk (2nd chunk)
-	chunk2, dT2, err := readChunk(r, true)
+	chunk2, dT2, err := readChunk(snappy.NewReader(r))
 	if err != nil {
 		return nil, err
 	}
 	if dT2 != chunkDataType {
 		return nil, fmt.Errorf("malformed beacon block, invalid chunk 2 type %d, expected: %d", dT2, chunkDataType)
 	}
+	plainSSZ = append(plainSSZ, chunk2...)
 	// Read the 3rd chunk
-	chunk3, dT3, err := readChunk(r, false)
+	chunk3, dT3, err := readChunk(r)
 	if err != nil {
 		return nil, err
 	}
 	if dT3 != chunkDataType {
 		return nil, fmt.Errorf("malformed beacon block, invalid chunk 3 type %d, expected: %d", dT3, chunkDataType)
 	}
+	plainSSZ = append(plainSSZ, chunk3...)
 	if v <= clparams.AltairVersion {
-		return blockFromChunks(v, cfg, chunk1, chunk2, chunk3)
+		return block, block.DecodeSSZ(plainSSZ, int(v))
 	}
 	// Read the block pointer and retrieve chunk4 from the execution reader
 	blockPointer, err := readExecutionBlockPtr(r)
@@ -168,28 +179,20 @@ func ReadBlockFromrSnapshot(r io.Reader, executionReader ExecutionBlockReaderByN
 	if err != nil {
 		return nil, err
 	}
+	plainSSZ = append(plainSSZ, chunk4...)
 	if v <= clparams.BellatrixVersion {
-		return blockFromChunks(v, cfg, chunk1, chunk2, chunk3, chunk4)
+		return block, block.DecodeSSZ(plainSSZ, int(v))
 	}
 
 	// Read the 5h chunk
-	chunk5, dT5, err := readChunk(r, false)
+	chunk5, dT5, err := readChunk(r)
 	if err != nil {
 		return nil, err
 	}
 	if dT5 != chunkDataType {
 		return nil, fmt.Errorf("malformed beacon block, invalid chunk 5 type %d, expected: %d", dT5, chunkDataType)
 	}
+	plainSSZ = append(plainSSZ, chunk5...)
 
-	return blockFromChunks(v, cfg, chunk1, chunk2, chunk3, chunk4, chunk5)
-}
-
-func blockFromChunks(v clparams.StateVersion, cfg *clparams.BeaconChainConfig, chunks ...[]byte) (*cltypes.SignedBeaconBlock, error) {
-	block := cltypes.NewSignedBeaconBlock(cfg)
-	plainSSZ := []byte{}
-	for _, chunk := range chunks {
-		plainSSZ = append(plainSSZ, chunk...)
-	}
 	return block, block.DecodeSSZ(plainSSZ, int(v))
-
 }
diff --git a/cl/persistence/snapshot_format/blocks_test.go b/cl/persistence/snapshot_format/blocks_test.go
index 55f3c7b55..8eac555a9 100644
--- a/cl/persistence/snapshot_format/blocks_test.go
+++ b/cl/persistence/snapshot_format/blocks_test.go
@@ -59,7 +59,7 @@ func TestBlockSnapshotEncoding(t *testing.T) {
 		}
 		var b bytes.Buffer
 		require.NoError(t, snapshot_format.WriteBlockForSnapshot(blk, &b))
-		blk2, err := snapshot_format.ReadBlockFromrSnapshot(&b, &br, &clparams.MainnetBeaconConfig)
+		blk2, err := snapshot_format.ReadBlockFromSnapshot(&b, &br, &clparams.MainnetBeaconConfig)
 		require.NoError(t, err)
 		_ = blk2
 		hash1, err := blk.HashSSZ()
diff --git a/cl/persistence/snapshot_format/chunks.go b/cl/persistence/snapshot_format/chunks.go
index bf9960f4c..bdc349885 100644
--- a/cl/persistence/snapshot_format/chunks.go
+++ b/cl/persistence/snapshot_format/chunks.go
@@ -6,7 +6,6 @@ import (
 	"io"
 
 	"github.com/ledgerwatch/erigon/cl/clparams"
-	"github.com/ledgerwatch/erigon/cl/utils"
 )
 
 type dataType int
@@ -17,10 +16,7 @@ const (
 )
 
 // writeChunk writes a chunk to the writer.
-func writeChunk(w io.Writer, buf []byte, t dataType, snappy bool) error {
-	if snappy {
-		buf = utils.CompressSnappy(buf)
-	}
+func writeChunk(w io.Writer, buf []byte, t dataType) error {
 	// prefix is type of chunk + length of chunk
 	prefix := make([]byte, 8)
 	binary.BigEndian.PutUint64(prefix, uint64(len(buf)))
@@ -34,22 +30,20 @@ func writeChunk(w io.Writer, buf []byte, t dataType, snappy bool) error {
 	return nil
 }
 
-func readChunk(r io.Reader, snappy bool) (buf []byte, t dataType, err error) {
+func readChunk(r io.Reader) (buf []byte, t dataType, err error) {
 	prefix := make([]byte, 8)
-	if _, err := r.Read(prefix); err != nil {
-		return nil, dataType(0), err
+	fmt.Println("A")
+	if _, err = r.Read(prefix); err != nil {
+		return
 	}
+
 	t = dataType(prefix[0])
 	prefix[0] = 0
-	fmt.Println(binary.BigEndian.Uint64(prefix))
 	buf = make([]byte, binary.BigEndian.Uint64(prefix))
-	if _, err := r.Read(buf); err != nil {
-		return nil, t, err
+	if _, err = r.Read(buf); err != nil {
+		return
 	}
-	if snappy {
-		buf, err = utils.DecompressSnappy(buf)
-	}
-	return buf, t, err
+	return
 }
 
 func readMetadataForBlock(r io.Reader) (clparams.StateVersion, error) {
diff --git a/cl/phase1/execution_client/execution_client_direct.go b/cl/phase1/execution_client/execution_client_direct.go
index dc4674fb2..1d817dfca 100644
--- a/cl/phase1/execution_client/execution_client_direct.go
+++ b/cl/phase1/execution_client/execution_client_direct.go
@@ -96,3 +96,7 @@ func (cc *ExecutionClientDirect) GetBodiesByRange(start, count uint64) ([]*types
 func (cc *ExecutionClientDirect) GetBodiesByHashes(hashes []libcommon.Hash) ([]*types.RawBody, error) {
 	return cc.chainRW.GetBodiesByHases(hashes), nil
 }
+
+func (cc *ExecutionClientDirect) FrozenBlocks() uint64 {
+	return cc.chainRW.FrozenBlocks()
+}
diff --git a/cl/phase1/execution_client/execution_client_rpc.go b/cl/phase1/execution_client/execution_client_rpc.go
index 20c5fb835..a43348b2e 100644
--- a/cl/phase1/execution_client/execution_client_rpc.go
+++ b/cl/phase1/execution_client/execution_client_rpc.go
@@ -224,3 +224,7 @@ func (cc *ExecutionClientRpc) GetBodiesByHashes(hashes []libcommon.Hash) ([]*typ
 	}
 	return ret, nil
 }
+
+func (cc *ExecutionClientRpc) FrozenBlocks() uint64 {
+	panic("unimplemented")
+}
diff --git a/cl/phase1/execution_client/interface.go b/cl/phase1/execution_client/interface.go
index e6aad186e..a83c60c94 100644
--- a/cl/phase1/execution_client/interface.go
+++ b/cl/phase1/execution_client/interface.go
@@ -22,4 +22,6 @@ type ExecutionEngine interface {
 	// Range methods
 	GetBodiesByRange(start, count uint64) ([]*types.RawBody, error)
 	GetBodiesByHashes(hashes []libcommon.Hash) ([]*types.RawBody, error)
+	// Snapshots
+	FrozenBlocks() uint64
 }
diff --git a/cl/phase1/network/gossip_manager.go b/cl/phase1/network/gossip_manager.go
index 10b61af83..d040def8c 100644
--- a/cl/phase1/network/gossip_manager.go
+++ b/cl/phase1/network/gossip_manager.go
@@ -154,7 +154,7 @@ func (g *GossipManager) onRecv(ctx context.Context, data *sentinel.GossipData, l
 		if err := operationsContract[*cltypes.AttesterSlashing](ctx, g, l, data, int(version), "attester slashing", g.forkChoice.OnAttesterSlashing); err != nil {
 			return err
 		}
-	case sentinel.GossipType_BlsToExecutionChangeType:
+	case sentinel.GossipType_BlsToExecutionChangeGossipType:
 		if err := operationsContract[*cltypes.SignedBLSToExecutionChange](ctx, g, l, data, int(version), "bls to execution change", g.forkChoice.OnBlsToExecutionChange); err != nil {
 			return err
 		}
diff --git a/cl/phase1/stages/clstages.go b/cl/phase1/stages/clstages.go
index 05e0514fd..bbcee3d87 100644
--- a/cl/phase1/stages/clstages.go
+++ b/cl/phase1/stages/clstages.go
@@ -46,6 +46,8 @@ type Args struct {
 
 	targetEpoch, seenEpoch uint64
 	targetSlot, seenSlot   uint64
+
+	downloadedHistory bool
 }
 
 func ClStagesCfg(
@@ -93,11 +95,11 @@ const (
 	minPeersForDownload = uint64(4)
 )
 
-func MetaCatchingUp(args Args, hasDownloaded bool) StageName {
+func MetaCatchingUp(args Args) StageName {
 	if args.peers < minPeersForDownload {
 		return WaitForPeers
 	}
-	if !hasDownloaded {
+	if !args.downloadedHistory {
 		return DownloadHistoricalBlocks
 	}
 	if args.seenEpoch < args.targetEpoch {
@@ -188,6 +190,7 @@ func ConsensusClStages(ctx context.Context,
 				log.Error("failed to get sentinel peer count", "err", err)
 				args.peers = 0
 			}
+			args.downloadedHistory = downloaded
 			args.seenSlot = cfg.forkChoice.HighestSeen()
 			args.seenEpoch = args.seenSlot / cfg.beaconCfg.SlotsPerEpoch
 			args.targetSlot = utils.GetCurrentSlot(cfg.genesisCfg.GenesisTime, cfg.beaconCfg.SecondsPerSlot)
@@ -199,7 +202,7 @@ func ConsensusClStages(ctx context.Context,
 			WaitForPeers: {
 				Description: `wait for enough peers. This is also a safe stage to go to when unsure of what stage to use`,
 				TransitionFunc: func(cfg *Cfg, args Args, err error) string {
-					if x := MetaCatchingUp(args, downloaded); x != "" {
+					if x := MetaCatchingUp(args); x != "" {
 						return x
 					}
 					return CatchUpBlocks
@@ -232,7 +235,7 @@ func ConsensusClStages(ctx context.Context,
 			DownloadHistoricalBlocks: {
 				Description: "Download historical blocks",
 				TransitionFunc: func(cfg *Cfg, args Args, err error) string {
-					if x := MetaCatchingUp(args, downloaded); x != "" {
+					if x := MetaCatchingUp(args); x != "" {
 						return x
 					}
 					return CatchUpBlocks
@@ -256,7 +259,7 @@ func ConsensusClStages(ctx context.Context,
 			CatchUpEpochs: {
 				Description: `if we are 1 or more epochs behind, we download in parallel by epoch`,
 				TransitionFunc: func(cfg *Cfg, args Args, err error) string {
-					if x := MetaCatchingUp(args, downloaded); x != "" {
+					if x := MetaCatchingUp(args); x != "" {
 						return x
 					}
 					return CatchUpBlocks
@@ -321,7 +324,7 @@ func ConsensusClStages(ctx context.Context,
 			CatchUpBlocks: {
 				Description: `if we are within the epoch but not at head, we run catchupblocks`,
 				TransitionFunc: func(cfg *Cfg, args Args, err error) string {
-					if x := MetaCatchingUp(args, downloaded); x != "" {
+					if x := MetaCatchingUp(args); x != "" {
 						return x
 					}
 					return ForkChoice
@@ -378,7 +381,7 @@ func ConsensusClStages(ctx context.Context,
 				Description: `fork choice stage. We will send all fork choise things here
 			also, we will wait up to delay seconds to deal with attestations + side forks`,
 				TransitionFunc: func(cfg *Cfg, args Args, err error) string {
-					if x := MetaCatchingUp(args, downloaded); x != "" {
+					if x := MetaCatchingUp(args); x != "" {
 						return x
 					}
 					return ListenForForks
@@ -466,7 +469,7 @@ func ConsensusClStages(ctx context.Context,
 					defer func() {
 						shouldForkChoiceSinceReorg = false
 					}()
-					if x := MetaCatchingUp(args, downloaded); x != "" {
+					if x := MetaCatchingUp(args); x != "" {
 						return x
 					}
 					if shouldForkChoiceSinceReorg {
@@ -512,7 +515,7 @@ func ConsensusClStages(ctx context.Context,
 			CleanupAndPruning: {
 				Description: `cleanup and pruning is done here`,
 				TransitionFunc: func(cfg *Cfg, args Args, err error) string {
-					if x := MetaCatchingUp(args, downloaded); x != "" {
+					if x := MetaCatchingUp(args); x != "" {
 						return x
 					}
 					return SleepForSlot
diff --git a/cl/phase1/stages/stage_history_download.go b/cl/phase1/stages/stage_history_download.go
index 36bad848a..9bc710055 100644
--- a/cl/phase1/stages/stage_history_download.go
+++ b/cl/phase1/stages/stage_history_download.go
@@ -56,33 +56,12 @@ func StageHistoryReconstruction(downloader *network.BackwardBeaconDownloader, db
 	}
 }
 
-func waitForExecutionEngineToBeReady(ctx context.Context, engine execution_client.ExecutionEngine) error {
-	if engine == nil {
-		return nil
-	}
-	checkInterval := time.NewTicker(200 * time.Millisecond)
-	for {
-		select {
-		case <-checkInterval.C:
-			ready, err := engine.Ready()
-			if err != nil {
-				return err
-			}
-			if ready {
-				return nil
-			}
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	}
-}
-
 // SpawnStageBeaconsForward spawn the beacon forward stage
 func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Context, logger log.Logger) error {
 	// Wait for execution engine to be ready.
-	if err := waitForExecutionEngineToBeReady(ctx, cfg.engine); err != nil {
-		return err
-	}
+	// if err := waitForExecutionEngineToBeReady(ctx, cfg.engine); err != nil {
+	// 	return err
+	// }
 	blockRoot := cfg.startingRoot
 	destinationSlot := uint64(0)
 	currentSlot := cfg.startingSlot
@@ -90,16 +69,16 @@ func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Co
 		destinationSlot = currentSlot - cfg.dbCfg.PruneDepth
 	}
 
-	executionBlocksCollector := etl.NewCollector("SpawnStageHistoryDownload", cfg.tmpdir, etl.NewSortableBuffer(etl.BufferOptimalSize), logger)
+	executionBlocksCollector := etl.NewCollector("HistoryDownload", cfg.tmpdir, etl.NewSortableBuffer(etl.BufferOptimalSize), logger)
 	defer executionBlocksCollector.Close()
 	// Start the procedure
-	logger.Info("Downloading History", "from", currentSlot)
+	logger.Info("Starting downloading History", "from", currentSlot)
 	// Setup slot and block root
 	cfg.downloader.SetSlotToDownload(currentSlot)
 	cfg.downloader.SetExpectedRoot(blockRoot)
-	foundLatestEth1ValidHash := false
+	foundLatestEth1ValidBlock := false
 	if cfg.engine == nil || !cfg.engine.SupportInsertion() {
-		foundLatestEth1ValidHash = true // skip this if we are not using an engine supporting direct insertion
+		foundLatestEth1ValidBlock = true // skip this if we are not using an engine supporting direct insertion
 	}
 
 	var currEth1Progress atomic.Int64
@@ -114,7 +93,14 @@ func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Co
 		if blk.Version() >= clparams.BellatrixVersion {
 			currEth1Progress.Store(int64(blk.Block.Body.ExecutionPayload.BlockNumber))
 		}
-		if !foundLatestEth1ValidHash {
+
+		slot := blk.Block.Slot
+		if destinationSlot <= blk.Block.Slot {
+			if err := cfg.db.WriteBlock(tx, ctx, blk, true); err != nil {
+				return false, err
+			}
+		}
+		if !foundLatestEth1ValidBlock {
 			payload := blk.Block.Body.ExecutionPayload
 			encodedPayload, err := payload.EncodeSSZ(nil)
 			if err != nil {
@@ -125,21 +111,18 @@ func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Co
 			if err := executionBlocksCollector.Collect(dbutils.BlockBodyKey(payload.BlockNumber, payload.BlockHash), encodedPayload); err != nil {
 				return false, fmt.Errorf("error collecting execution payload during download: %s", err)
 			}
+			if currEth1Progress.Load()%100 == 0 {
+				return false, nil
+			}
 
 			bodyChainHeader, err := cfg.engine.GetBodiesByHashes([]libcommon.Hash{payload.BlockHash})
 			if err != nil {
 				return false, fmt.Errorf("error retrieving whether execution payload is present: %s", err)
 			}
-			foundLatestEth1ValidHash = len(bodyChainHeader) > 0
+			foundLatestEth1ValidBlock = len(bodyChainHeader) > 0 || cfg.engine.FrozenBlocks() > payload.BlockNumber
 		}
 
-		slot := blk.Block.Slot
-		if destinationSlot <= blk.Block.Slot {
-			if err := cfg.db.WriteBlock(tx, ctx, blk, true); err != nil {
-				return false, err
-			}
-		}
-		return slot <= destinationSlot && foundLatestEth1ValidHash, nil
+		return slot <= destinationSlot && foundLatestEth1ValidBlock, nil
 	})
 	prevProgress := cfg.downloader.Progress()
 
@@ -150,6 +133,15 @@ func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Co
 		for {
 			select {
 			case <-logInterval.C:
+				if cfg.engine.SupportInsertion() {
+					if ready, err := cfg.engine.Ready(); !ready {
+						if err != nil {
+							log.Warn("could not log progress", "err", err)
+						}
+						continue
+					}
+
+				}
 				logArgs := []interface{}{}
 				currProgress := cfg.downloader.Progress()
 				speed := float64(prevProgress-currProgress) / float64(logIntervalTime/time.Second)
@@ -187,6 +179,8 @@ func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Co
 	blockBatch := []*types.Block{}
 	blockBatchMaxSize := 1000
 
+	cfg.logger.Info("Ready to insert history, waiting for sync cycle to finish")
+
 	if err := executionBlocksCollector.Load(tx2, kv.Headers, func(k, vComp []byte, _ etl.CurrentTableReader, next etl.LoadNextFunc) error {
 		if cfg.engine == nil || !cfg.engine.SupportInsertion() {
 			return next(k, nil, nil)
diff --git a/cmd/caplin-phase1/caplin1/run.go b/cmd/caplin/caplin1/run.go
similarity index 98%
rename from cmd/caplin-phase1/caplin1/run.go
rename to cmd/caplin/caplin1/run.go
index b7a877de3..0afecad8b 100644
--- a/cmd/caplin-phase1/caplin1/run.go
+++ b/cmd/caplin/caplin1/run.go
@@ -111,7 +111,7 @@ func RunCaplinPhase1(ctx context.Context, sentinel sentinel.SentinelClient, engi
 	fmt.Println("A")
 	{ // start ticking forkChoice
 		go func() {
-			tickInterval := time.NewTicker(2 * time.Millisecond)
+			tickInterval := time.NewTicker(50 * time.Millisecond)
 			for {
 				select {
 				case <-tickInterval.C:
diff --git a/cmd/caplin-phase1/main.go b/cmd/caplin/main.go
similarity index 95%
rename from cmd/caplin-phase1/main.go
rename to cmd/caplin/main.go
index d6d2b1732..e6ea1c53f 100644
--- a/cmd/caplin-phase1/main.go
+++ b/cmd/caplin/main.go
@@ -29,17 +29,17 @@ import (
 
 	"github.com/ledgerwatch/erigon/cl/cltypes"
 	"github.com/ledgerwatch/erigon/cl/fork"
-	"github.com/ledgerwatch/erigon/cmd/caplin-phase1/caplin1"
+	"github.com/ledgerwatch/erigon/cmd/caplin/caplin1"
 	lcCli "github.com/ledgerwatch/erigon/cmd/sentinel/cli"
 	"github.com/ledgerwatch/erigon/cmd/sentinel/cli/flags"
 	"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel"
 	"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel/service"
-	lightclientapp "github.com/ledgerwatch/erigon/turbo/app"
+	app "github.com/ledgerwatch/erigon/turbo/app"
 	"github.com/ledgerwatch/erigon/turbo/debug"
 )
 
 func main() {
-	app := lightclientapp.MakeApp("caplin-phase1", runCaplinNode, flags.CLDefaultFlags)
+	app := app.MakeApp("caplin", runCaplinNode, flags.CLDefaultFlags)
 	if err := app.Run(os.Args); err != nil {
 		_, printErr := fmt.Fprintln(os.Stderr, err)
 		if printErr != nil {
diff --git a/cmd/sentinel/sentinel/service/service.go b/cmd/sentinel/sentinel/service/service.go
index df2a068d8..2644a0450 100644
--- a/cmd/sentinel/sentinel/service/service.go
+++ b/cmd/sentinel/sentinel/service/service.go
@@ -283,7 +283,7 @@ func (s *SentinelServer) handleGossipPacket(pkt *pubsub.Message) error {
 	} else if strings.Contains(*pkt.Topic, string(sentinel.AttesterSlashingTopic)) {
 		s.gossipNotifier.notify(sentinelrpc.GossipType_AttesterSlashingGossipType, data, string(textPid))
 	} else if strings.Contains(*pkt.Topic, string(sentinel.BlsToExecutionChangeTopic)) {
-		s.gossipNotifier.notify(sentinelrpc.GossipType_BlsToExecutionChangeType, data, string(textPid))
+		s.gossipNotifier.notify(sentinelrpc.GossipType_BlsToExecutionChangeGossipType, data, string(textPid))
 	} else if strings.Contains(*pkt.Topic, string(sentinel.BlobSidecarTopic)) {
 		// extract the index
 		s.gossipNotifier.notifyBlob(sentinelrpc.GossipType_BlobSidecarType, data, string(textPid), extractBlobSideCarIndex(*pkt.Topic))
diff --git a/erigon-lib/direct/execution_client.go b/erigon-lib/direct/execution_client.go
index d5899815e..e2e8d8da1 100644
--- a/erigon-lib/direct/execution_client.go
+++ b/erigon-lib/direct/execution_client.go
@@ -96,3 +96,7 @@ func (s *ExecutionClientDirect) GetForkChoice(ctx context.Context, in *emptypb.E
 func (s *ExecutionClientDirect) Ready(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*execution.ReadyResponse, error) {
 	return s.server.Ready(ctx, in)
 }
+
+func (s *ExecutionClientDirect) FrozenBlocks(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*execution.FrozenBlocksResponse, error) {
+	return s.server.FrozenBlocks(ctx, in)
+}
diff --git a/erigon-lib/go.mod b/erigon-lib/go.mod
index 3cb99621a..7d69503cb 100644
--- a/erigon-lib/go.mod
+++ b/erigon-lib/go.mod
@@ -4,7 +4,7 @@ go 1.19
 
 require (
 	github.com/erigontech/mdbx-go v0.27.17
-	github.com/ledgerwatch/interfaces v0.0.0-20230929215128-3300a167cce0
+	github.com/ledgerwatch/interfaces v0.0.0-20231011121315-f58b806039f0
 	github.com/ledgerwatch/log/v3 v3.9.0
 	github.com/ledgerwatch/secp256k1 v1.0.0
 )
diff --git a/erigon-lib/go.sum b/erigon-lib/go.sum
index 66779c0bc..4ed1a5fc6 100644
--- a/erigon-lib/go.sum
+++ b/erigon-lib/go.sum
@@ -241,8 +241,8 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
-github.com/ledgerwatch/interfaces v0.0.0-20230929215128-3300a167cce0 h1:pCLKf3lanroMo1SpA/idi5RyGOIBwvwVRLNwV0suHQU=
-github.com/ledgerwatch/interfaces v0.0.0-20230929215128-3300a167cce0/go.mod h1:ugQv1QllJzBny3cKZKxUrSnykkjkBgm27eQM6dnGAcc=
+github.com/ledgerwatch/interfaces v0.0.0-20231011121315-f58b806039f0 h1:7z6cyoCKP6qxtKSO74eAY6XiHWKaOi+melvPeMCXLl8=
+github.com/ledgerwatch/interfaces v0.0.0-20231011121315-f58b806039f0/go.mod h1:ugQv1QllJzBny3cKZKxUrSnykkjkBgm27eQM6dnGAcc=
 github.com/ledgerwatch/log/v3 v3.9.0 h1:iDwrXe0PVwBC68Dd94YSsHbMgQ3ufsgjzXtFNFVZFRk=
 github.com/ledgerwatch/log/v3 v3.9.0/go.mod h1:EiAY6upmI/6LkNhOVxb4eVsmsP11HZCnZ3PlJMjYiqE=
 github.com/ledgerwatch/secp256k1 v1.0.0 h1:Usvz87YoTG0uePIV8woOof5cQnLXGYa162rFf3YnwaQ=
diff --git a/erigon-lib/gointerfaces/execution/execution.pb.go b/erigon-lib/gointerfaces/execution/execution.pb.go
index 5c2effd51..c33156849 100644
--- a/erigon-lib/gointerfaces/execution/execution.pb.go
+++ b/erigon-lib/gointerfaces/execution/execution.pb.go
@@ -1566,6 +1566,53 @@ func (x *ReadyResponse) GetReady() bool {
 	return false
 }
 
+type FrozenBlocksResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	FrozenBlocks uint64 `protobuf:"varint,1,opt,name=frozen_blocks,json=frozenBlocks,proto3" json:"frozen_blocks,omitempty"`
+}
+
+func (x *FrozenBlocksResponse) Reset() {
+	*x = FrozenBlocksResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_execution_execution_proto_msgTypes[24]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *FrozenBlocksResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FrozenBlocksResponse) ProtoMessage() {}
+
+func (x *FrozenBlocksResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_execution_execution_proto_msgTypes[24]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use FrozenBlocksResponse.ProtoReflect.Descriptor instead.
+func (*FrozenBlocksResponse) Descriptor() ([]byte, []int) {
+	return file_execution_execution_proto_rawDescGZIP(), []int{24}
+}
+
+func (x *FrozenBlocksResponse) GetFrozenBlocks() uint64 {
+	if x != nil {
+		return x.FrozenBlocks
+	}
+	return 0
+}
+
 var File_execution_execution_proto protoreflect.FileDescriptor
 
 var file_execution_execution_proto_rawDesc = []byte{
@@ -1808,87 +1855,96 @@ var file_execution_execution_proto_rawDesc = []byte{
 	0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x25, 0x0a, 0x0d, 0x52,
 	0x65, 0x61, 0x64, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05,
 	0x72, 0x65, 0x61, 0x64, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x72, 0x65, 0x61,
-	0x64, 0x79, 0x2a, 0x71, 0x0a, 0x0f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x53,
-	0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73,
-	0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x42, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x10, 0x01,
-	0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x6f, 0x6f, 0x46, 0x61, 0x72, 0x41, 0x77, 0x61, 0x79, 0x10, 0x02,
-	0x12, 0x12, 0x0a, 0x0e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65,
-	0x6e, 0x74, 0x10, 0x03, 0x12, 0x15, 0x0a, 0x11, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x46,
-	0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x10, 0x04, 0x12, 0x08, 0x0a, 0x04, 0x42,
-	0x75, 0x73, 0x79, 0x10, 0x05, 0x32, 0xf6, 0x08, 0x0a, 0x09, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74,
-	0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x0c, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f,
-	0x63, 0x6b, 0x73, 0x12, 0x1e, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
-	0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
-	0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12,
-	0x4b, 0x0a, 0x0d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e,
-	0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c,
-	0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x12, 0x47, 0x0a, 0x10,
-	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65,
-	0x12, 0x15, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x46, 0x6f, 0x72,
-	0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x1a, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74,
-	0x69, 0x6f, 0x6e, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65,
-	0x63, 0x65, 0x69, 0x70, 0x74, 0x12, 0x52, 0x0a, 0x0d, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c,
-	0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x1f, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69,
-	0x6f, 0x6e, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74,
-	0x69, 0x6f, 0x6e, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63,
-	0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x11, 0x47, 0x65, 0x74,
-	0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x23,
-	0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x73,
-	0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
-	0x47, 0x65, 0x74, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63,
-	0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0d, 0x43, 0x75, 0x72,
-	0x72, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f,
-	0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70,
-	0x74, 0x79, 0x1a, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47,
-	0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x12, 0x3f, 0x0a, 0x05, 0x47, 0x65, 0x74, 0x54, 0x44, 0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63,
-	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74,
-	0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x12, 0x47, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x1c,
-	0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65,
-	0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x65,
-	0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64,
-	0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x07, 0x47, 0x65,
-	0x74, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f,
-	0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
-	0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x59, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61,
-	0x6e, 0x67, 0x65, 0x12, 0x22, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
+	0x64, 0x79, 0x22, 0x3b, 0x0a, 0x14, 0x46, 0x72, 0x6f, 0x7a, 0x65, 0x6e, 0x42, 0x6c, 0x6f, 0x63,
+	0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x72,
+	0x6f, 0x7a, 0x65, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x04, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x7a, 0x65, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2a,
+	0x71, 0x0a, 0x0f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74,
+	0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x10, 0x00, 0x12,
+	0x0c, 0x0a, 0x08, 0x42, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x10, 0x01, 0x12, 0x0e, 0x0a,
+	0x0a, 0x54, 0x6f, 0x6f, 0x46, 0x61, 0x72, 0x41, 0x77, 0x61, 0x79, 0x10, 0x02, 0x12, 0x12, 0x0a,
+	0x0e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x10,
+	0x03, 0x12, 0x15, 0x0a, 0x11, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x46, 0x6f, 0x72, 0x6b,
+	0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x10, 0x04, 0x12, 0x08, 0x0a, 0x04, 0x42, 0x75, 0x73, 0x79,
+	0x10, 0x05, 0x32, 0xbf, 0x09, 0x0a, 0x09, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
+	0x12, 0x4a, 0x0a, 0x0c, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73,
+	0x12, 0x1e, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x49, 0x6e, 0x73,
+	0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x1a, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x49, 0x6e, 0x73,
+	0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x4b, 0x0a, 0x0d,
+	0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x1c, 0x2e,
+	0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x65, 0x78,
+	0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x12, 0x47, 0x0a, 0x10, 0x55, 0x70, 0x64,
+	0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x12, 0x15, 0x2e,
+	0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68,
+	0x6f, 0x69, 0x63, 0x65, 0x1a, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
+	0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69,
+	0x70, 0x74, 0x12, 0x52, 0x0a, 0x0d, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c,
+	0x6f, 0x63, 0x6b, 0x12, 0x1f, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
+	0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
+	0x2e, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x41, 0x73, 0x73,
+	0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x23, 0x2e, 0x65, 0x78,
+	0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x73, 0x73, 0x65, 0x6d,
+	0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x24, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74,
+	0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0d, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e,
+	0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
+	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a,
+	0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48,
+	0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a,
+	0x05, 0x47, 0x65, 0x74, 0x54, 0x44, 0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69,
+	0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
+	0x2e, 0x47, 0x65, 0x74, 0x54, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47,
+	0x0a, 0x09, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x65, 0x78,
+	0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65,
+	0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63,
+	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x42, 0x6f,
+	0x64, 0x79, 0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47,
+	0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x1a, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74,
+	0x42, 0x6f, 0x64, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x59, 0x0a, 0x10,
 	0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74,
-	0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x61, 0x74,
-	0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5b, 0x0a, 0x11, 0x47, 0x65,
-	0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x12,
-	0x23, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x42,
-	0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x52, 0x65, 0x71,
+	0x12, 0x22, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74,
+	0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71,
 	0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
 	0x2e, 0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0f, 0x49, 0x73, 0x43, 0x61, 0x6e,
-	0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x48, 0x61, 0x73, 0x68, 0x12, 0x0b, 0x2e, 0x74, 0x79, 0x70,
-	0x65, 0x73, 0x2e, 0x48, 0x32, 0x35, 0x36, 0x1a, 0x1e, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74,
-	0x69, 0x6f, 0x6e, 0x2e, 0x49, 0x73, 0x43, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x52,
-	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x48, 0x65,
-	0x61, 0x64, 0x65, 0x72, 0x48, 0x61, 0x73, 0x68, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x0b,
-	0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x48, 0x32, 0x35, 0x36, 0x1a, 0x26, 0x2e, 0x65, 0x78,
-	0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65,
-	0x72, 0x48, 0x61, 0x73, 0x68, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68,
-	0x6f, 0x69, 0x63, 0x65, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x15, 0x2e, 0x65,
-	0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f,
-	0x69, 0x63, 0x65, 0x12, 0x39, 0x0a, 0x05, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x16, 0x2e, 0x67,
-	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45,
-	0x6d, 0x70, 0x74, 0x79, 0x1a, 0x18, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
-	0x2e, 0x52, 0x65, 0x61, 0x64, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x17,
-	0x5a, 0x15, 0x2e, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x65, 0x78,
-	0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5b, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x42, 0x6f,
+	0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x12, 0x23, 0x2e, 0x65,
+	0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x69,
+	0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x21, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65,
+	0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0f, 0x49, 0x73, 0x43, 0x61, 0x6e, 0x6f, 0x6e, 0x69,
+	0x63, 0x61, 0x6c, 0x48, 0x61, 0x73, 0x68, 0x12, 0x0b, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e,
+	0x48, 0x32, 0x35, 0x36, 0x1a, 0x1e, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
+	0x2e, 0x49, 0x73, 0x43, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65,
+	0x72, 0x48, 0x61, 0x73, 0x68, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x0b, 0x2e, 0x74, 0x79,
+	0x70, 0x65, 0x73, 0x2e, 0x48, 0x32, 0x35, 0x36, 0x1a, 0x26, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75,
+	0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x48, 0x61,
+	0x73, 0x68, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x3e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63,
+	0x65, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
+	0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x15, 0x2e, 0x65, 0x78, 0x65, 0x63,
+	0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65,
+	0x12, 0x39, 0x0a, 0x05, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
+	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x1a, 0x18, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x52, 0x65,
+	0x61, 0x64, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0c, 0x46,
+	0x72, 0x6f, 0x7a, 0x65, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x12, 0x16, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x1a, 0x1f, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
+	0x46, 0x72, 0x6f, 0x7a, 0x65, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x42, 0x17, 0x5a, 0x15, 0x2e, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74,
+	0x69, 0x6f, 0x6e, 0x3b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x06, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -1904,7 +1960,7 @@ func file_execution_execution_proto_rawDescGZIP() []byte {
 }
 
 var file_execution_execution_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_execution_execution_proto_msgTypes = make([]protoimpl.MessageInfo, 24)
+var file_execution_execution_proto_msgTypes = make([]protoimpl.MessageInfo, 25)
 var file_execution_execution_proto_goTypes = []interface{}{
 	(ExecutionStatus)(0),                // 0: execution.ExecutionStatus
 	(*ForkChoiceReceipt)(nil),           // 1: execution.ForkChoiceReceipt
@@ -1931,90 +1987,93 @@ var file_execution_execution_proto_goTypes = []interface{}{
 	(*GetBodiesByHashesRequest)(nil),    // 22: execution.GetBodiesByHashesRequest
 	(*GetBodiesByRangeRequest)(nil),     // 23: execution.GetBodiesByRangeRequest
 	(*ReadyResponse)(nil),               // 24: execution.ReadyResponse
-	(*types.H256)(nil),                  // 25: types.H256
-	(*types.H160)(nil),                  // 26: types.H160
-	(*types.H2048)(nil),                 // 27: types.H2048
-	(*types.Withdrawal)(nil),            // 28: types.Withdrawal
-	(*types.ExecutionPayload)(nil),      // 29: types.ExecutionPayload
-	(*types.BlobsBundleV1)(nil),         // 30: types.BlobsBundleV1
-	(*emptypb.Empty)(nil),               // 31: google.protobuf.Empty
+	(*FrozenBlocksResponse)(nil),        // 25: execution.FrozenBlocksResponse
+	(*types.H256)(nil),                  // 26: types.H256
+	(*types.H160)(nil),                  // 27: types.H160
+	(*types.H2048)(nil),                 // 28: types.H2048
+	(*types.Withdrawal)(nil),            // 29: types.Withdrawal
+	(*types.ExecutionPayload)(nil),      // 30: types.ExecutionPayload
+	(*types.BlobsBundleV1)(nil),         // 31: types.BlobsBundleV1
+	(*emptypb.Empty)(nil),               // 32: google.protobuf.Empty
 }
 var file_execution_execution_proto_depIdxs = []int32{
 	0,  // 0: execution.ForkChoiceReceipt.status:type_name -> execution.ExecutionStatus
-	25, // 1: execution.ForkChoiceReceipt.latest_valid_hash:type_name -> types.H256
+	26, // 1: execution.ForkChoiceReceipt.latest_valid_hash:type_name -> types.H256
 	0,  // 2: execution.ValidationReceipt.validation_status:type_name -> execution.ExecutionStatus
-	25, // 3: execution.ValidationReceipt.latest_valid_hash:type_name -> types.H256
-	25, // 4: execution.Header.parent_hash:type_name -> types.H256
-	26, // 5: execution.Header.coinbase:type_name -> types.H160
-	25, // 6: execution.Header.state_root:type_name -> types.H256
-	25, // 7: execution.Header.receipt_root:type_name -> types.H256
-	27, // 8: execution.Header.logs_bloom:type_name -> types.H2048
-	25, // 9: execution.Header.prev_randao:type_name -> types.H256
-	25, // 10: execution.Header.difficulty:type_name -> types.H256
-	25, // 11: execution.Header.block_hash:type_name -> types.H256
-	25, // 12: execution.Header.ommer_hash:type_name -> types.H256
-	25, // 13: execution.Header.transaction_hash:type_name -> types.H256
-	25, // 14: execution.Header.base_fee_per_gas:type_name -> types.H256
-	25, // 15: execution.Header.withdrawal_hash:type_name -> types.H256
-	25, // 16: execution.Header.parent_beacon_block_root:type_name -> types.H256
-	25, // 17: execution.BlockBody.block_hash:type_name -> types.H256
+	26, // 3: execution.ValidationReceipt.latest_valid_hash:type_name -> types.H256
+	26, // 4: execution.Header.parent_hash:type_name -> types.H256
+	27, // 5: execution.Header.coinbase:type_name -> types.H160
+	26, // 6: execution.Header.state_root:type_name -> types.H256
+	26, // 7: execution.Header.receipt_root:type_name -> types.H256
+	28, // 8: execution.Header.logs_bloom:type_name -> types.H2048
+	26, // 9: execution.Header.prev_randao:type_name -> types.H256
+	26, // 10: execution.Header.difficulty:type_name -> types.H256
+	26, // 11: execution.Header.block_hash:type_name -> types.H256
+	26, // 12: execution.Header.ommer_hash:type_name -> types.H256
+	26, // 13: execution.Header.transaction_hash:type_name -> types.H256
+	26, // 14: execution.Header.base_fee_per_gas:type_name -> types.H256
+	26, // 15: execution.Header.withdrawal_hash:type_name -> types.H256
+	26, // 16: execution.Header.parent_beacon_block_root:type_name -> types.H256
+	26, // 17: execution.BlockBody.block_hash:type_name -> types.H256
 	4,  // 18: execution.BlockBody.uncles:type_name -> execution.Header
-	28, // 19: execution.BlockBody.withdrawals:type_name -> types.Withdrawal
+	29, // 19: execution.BlockBody.withdrawals:type_name -> types.Withdrawal
 	4,  // 20: execution.Block.header:type_name -> execution.Header
 	5,  // 21: execution.Block.body:type_name -> execution.BlockBody
 	4,  // 22: execution.GetHeaderResponse.header:type_name -> execution.Header
-	25, // 23: execution.GetTDResponse.td:type_name -> types.H256
+	26, // 23: execution.GetTDResponse.td:type_name -> types.H256
 	5,  // 24: execution.GetBodyResponse.body:type_name -> execution.BlockBody
-	25, // 25: execution.GetSegmentRequest.block_hash:type_name -> types.H256
+	26, // 25: execution.GetSegmentRequest.block_hash:type_name -> types.H256
 	6,  // 26: execution.InsertBlocksRequest.blocks:type_name -> execution.Block
-	25, // 27: execution.ForkChoice.head_block_hash:type_name -> types.H256
-	25, // 28: execution.ForkChoice.finalized_block_hash:type_name -> types.H256
-	25, // 29: execution.ForkChoice.safe_block_hash:type_name -> types.H256
+	26, // 27: execution.ForkChoice.head_block_hash:type_name -> types.H256
+	26, // 28: execution.ForkChoice.finalized_block_hash:type_name -> types.H256
+	26, // 29: execution.ForkChoice.safe_block_hash:type_name -> types.H256
 	0,  // 30: execution.InsertionResult.result:type_name -> execution.ExecutionStatus
-	25, // 31: execution.ValidationRequest.hash:type_name -> types.H256
-	25, // 32: execution.AssembleBlockRequest.parent_hash:type_name -> types.H256
-	25, // 33: execution.AssembleBlockRequest.prev_randao:type_name -> types.H256
-	26, // 34: execution.AssembleBlockRequest.suggested_fee_recipient:type_name -> types.H160
-	28, // 35: execution.AssembleBlockRequest.withdrawals:type_name -> types.Withdrawal
-	25, // 36: execution.AssembleBlockRequest.parent_beacon_block_root:type_name -> types.H256
-	29, // 37: execution.AssembledBlockData.execution_payload:type_name -> types.ExecutionPayload
-	25, // 38: execution.AssembledBlockData.block_value:type_name -> types.H256
-	30, // 39: execution.AssembledBlockData.blobs_bundle:type_name -> types.BlobsBundleV1
+	26, // 31: execution.ValidationRequest.hash:type_name -> types.H256
+	26, // 32: execution.AssembleBlockRequest.parent_hash:type_name -> types.H256
+	26, // 33: execution.AssembleBlockRequest.prev_randao:type_name -> types.H256
+	27, // 34: execution.AssembleBlockRequest.suggested_fee_recipient:type_name -> types.H160
+	29, // 35: execution.AssembleBlockRequest.withdrawals:type_name -> types.Withdrawal
+	26, // 36: execution.AssembleBlockRequest.parent_beacon_block_root:type_name -> types.H256
+	30, // 37: execution.AssembledBlockData.execution_payload:type_name -> types.ExecutionPayload
+	26, // 38: execution.AssembledBlockData.block_value:type_name -> types.H256
+	31, // 39: execution.AssembledBlockData.blobs_bundle:type_name -> types.BlobsBundleV1
 	19, // 40: execution.GetAssembledBlockResponse.data:type_name -> execution.AssembledBlockData
 	5,  // 41: execution.GetBodiesBatchResponse.bodies:type_name -> execution.BlockBody
-	25, // 42: execution.GetBodiesByHashesRequest.hashes:type_name -> types.H256
+	26, // 42: execution.GetBodiesByHashesRequest.hashes:type_name -> types.H256
 	12, // 43: execution.Execution.InsertBlocks:input_type -> execution.InsertBlocksRequest
 	15, // 44: execution.Execution.ValidateChain:input_type -> execution.ValidationRequest
 	13, // 45: execution.Execution.UpdateForkChoice:input_type -> execution.ForkChoice
 	16, // 46: execution.Execution.AssembleBlock:input_type -> execution.AssembleBlockRequest
 	18, // 47: execution.Execution.GetAssembledBlock:input_type -> execution.GetAssembledBlockRequest
-	31, // 48: execution.Execution.CurrentHeader:input_type -> google.protobuf.Empty
+	32, // 48: execution.Execution.CurrentHeader:input_type -> google.protobuf.Empty
 	11, // 49: execution.Execution.GetTD:input_type -> execution.GetSegmentRequest
 	11, // 50: execution.Execution.GetHeader:input_type -> execution.GetSegmentRequest
 	11, // 51: execution.Execution.GetBody:input_type -> execution.GetSegmentRequest
 	23, // 52: execution.Execution.GetBodiesByRange:input_type -> execution.GetBodiesByRangeRequest
 	22, // 53: execution.Execution.GetBodiesByHashes:input_type -> execution.GetBodiesByHashesRequest
-	25, // 54: execution.Execution.IsCanonicalHash:input_type -> types.H256
-	25, // 55: execution.Execution.GetHeaderHashNumber:input_type -> types.H256
-	31, // 56: execution.Execution.GetForkChoice:input_type -> google.protobuf.Empty
-	31, // 57: execution.Execution.Ready:input_type -> google.protobuf.Empty
-	14, // 58: execution.Execution.InsertBlocks:output_type -> execution.InsertionResult
-	2,  // 59: execution.Execution.ValidateChain:output_type -> execution.ValidationReceipt
-	1,  // 60: execution.Execution.UpdateForkChoice:output_type -> execution.ForkChoiceReceipt
-	17, // 61: execution.Execution.AssembleBlock:output_type -> execution.AssembleBlockResponse
-	20, // 62: execution.Execution.GetAssembledBlock:output_type -> execution.GetAssembledBlockResponse
-	7,  // 63: execution.Execution.CurrentHeader:output_type -> execution.GetHeaderResponse
-	8,  // 64: execution.Execution.GetTD:output_type -> execution.GetTDResponse
-	7,  // 65: execution.Execution.GetHeader:output_type -> execution.GetHeaderResponse
-	9,  // 66: execution.Execution.GetBody:output_type -> execution.GetBodyResponse
-	21, // 67: execution.Execution.GetBodiesByRange:output_type -> execution.GetBodiesBatchResponse
-	21, // 68: execution.Execution.GetBodiesByHashes:output_type -> execution.GetBodiesBatchResponse
-	3,  // 69: execution.Execution.IsCanonicalHash:output_type -> execution.IsCanonicalResponse
-	10, // 70: execution.Execution.GetHeaderHashNumber:output_type -> execution.GetHeaderHashNumberResponse
-	13, // 71: execution.Execution.GetForkChoice:output_type -> execution.ForkChoice
-	24, // 72: execution.Execution.Ready:output_type -> execution.ReadyResponse
-	58, // [58:73] is the sub-list for method output_type
-	43, // [43:58] is the sub-list for method input_type
+	26, // 54: execution.Execution.IsCanonicalHash:input_type -> types.H256
+	26, // 55: execution.Execution.GetHeaderHashNumber:input_type -> types.H256
+	32, // 56: execution.Execution.GetForkChoice:input_type -> google.protobuf.Empty
+	32, // 57: execution.Execution.Ready:input_type -> google.protobuf.Empty
+	32, // 58: execution.Execution.FrozenBlocks:input_type -> google.protobuf.Empty
+	14, // 59: execution.Execution.InsertBlocks:output_type -> execution.InsertionResult
+	2,  // 60: execution.Execution.ValidateChain:output_type -> execution.ValidationReceipt
+	1,  // 61: execution.Execution.UpdateForkChoice:output_type -> execution.ForkChoiceReceipt
+	17, // 62: execution.Execution.AssembleBlock:output_type -> execution.AssembleBlockResponse
+	20, // 63: execution.Execution.GetAssembledBlock:output_type -> execution.GetAssembledBlockResponse
+	7,  // 64: execution.Execution.CurrentHeader:output_type -> execution.GetHeaderResponse
+	8,  // 65: execution.Execution.GetTD:output_type -> execution.GetTDResponse
+	7,  // 66: execution.Execution.GetHeader:output_type -> execution.GetHeaderResponse
+	9,  // 67: execution.Execution.GetBody:output_type -> execution.GetBodyResponse
+	21, // 68: execution.Execution.GetBodiesByRange:output_type -> execution.GetBodiesBatchResponse
+	21, // 69: execution.Execution.GetBodiesByHashes:output_type -> execution.GetBodiesBatchResponse
+	3,  // 70: execution.Execution.IsCanonicalHash:output_type -> execution.IsCanonicalResponse
+	10, // 71: execution.Execution.GetHeaderHashNumber:output_type -> execution.GetHeaderHashNumberResponse
+	13, // 72: execution.Execution.GetForkChoice:output_type -> execution.ForkChoice
+	24, // 73: execution.Execution.Ready:output_type -> execution.ReadyResponse
+	25, // 74: execution.Execution.FrozenBlocks:output_type -> execution.FrozenBlocksResponse
+	59, // [59:75] is the sub-list for method output_type
+	43, // [43:59] is the sub-list for method input_type
 	43, // [43:43] is the sub-list for extension type_name
 	43, // [43:43] is the sub-list for extension extendee
 	0,  // [0:43] is the sub-list for field type_name
@@ -2314,6 +2373,18 @@ func file_execution_execution_proto_init() {
 				return nil
 			}
 		}
+		file_execution_execution_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*FrozenBlocksResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 	}
 	file_execution_execution_proto_msgTypes[3].OneofWrappers = []interface{}{}
 	file_execution_execution_proto_msgTypes[6].OneofWrappers = []interface{}{}
@@ -2330,7 +2401,7 @@ func file_execution_execution_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_execution_execution_proto_rawDesc,
 			NumEnums:      1,
-			NumMessages:   24,
+			NumMessages:   25,
 			NumExtensions: 0,
 			NumServices:   1,
 		},
diff --git a/erigon-lib/gointerfaces/execution/execution_grpc.pb.go b/erigon-lib/gointerfaces/execution/execution_grpc.pb.go
index b3779a0b1..065a305e8 100644
--- a/erigon-lib/gointerfaces/execution/execution_grpc.pb.go
+++ b/erigon-lib/gointerfaces/execution/execution_grpc.pb.go
@@ -36,6 +36,7 @@ const (
 	Execution_GetHeaderHashNumber_FullMethodName = "/execution.Execution/GetHeaderHashNumber"
 	Execution_GetForkChoice_FullMethodName       = "/execution.Execution/GetForkChoice"
 	Execution_Ready_FullMethodName               = "/execution.Execution/Ready"
+	Execution_FrozenBlocks_FullMethodName        = "/execution.Execution/FrozenBlocks"
 )
 
 // ExecutionClient is the client API for Execution service.
@@ -66,6 +67,8 @@ type ExecutionClient interface {
 	// Misc
 	// We want to figure out whether we processed snapshots and cleanup sync cycles.
 	Ready(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ReadyResponse, error)
+	// Frozen blocks are how many blocks are in snapshots .seg files.
+	FrozenBlocks(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*FrozenBlocksResponse, error)
 }
 
 type executionClient struct {
@@ -211,6 +214,15 @@ func (c *executionClient) Ready(ctx context.Context, in *emptypb.Empty, opts ...
 	return out, nil
 }
 
+func (c *executionClient) FrozenBlocks(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*FrozenBlocksResponse, error) {
+	out := new(FrozenBlocksResponse)
+	err := c.cc.Invoke(ctx, Execution_FrozenBlocks_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // ExecutionServer is the server API for Execution service.
 // All implementations must embed UnimplementedExecutionServer
 // for forward compatibility
@@ -239,6 +251,8 @@ type ExecutionServer interface {
 	// Misc
 	// We want to figure out whether we processed snapshots and cleanup sync cycles.
 	Ready(context.Context, *emptypb.Empty) (*ReadyResponse, error)
+	// Frozen blocks are how many blocks are in snapshots .seg files.
+	FrozenBlocks(context.Context, *emptypb.Empty) (*FrozenBlocksResponse, error)
 	mustEmbedUnimplementedExecutionServer()
 }
 
@@ -291,6 +305,9 @@ func (UnimplementedExecutionServer) GetForkChoice(context.Context, *emptypb.Empt
 func (UnimplementedExecutionServer) Ready(context.Context, *emptypb.Empty) (*ReadyResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Ready not implemented")
 }
+func (UnimplementedExecutionServer) FrozenBlocks(context.Context, *emptypb.Empty) (*FrozenBlocksResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method FrozenBlocks not implemented")
+}
 func (UnimplementedExecutionServer) mustEmbedUnimplementedExecutionServer() {}
 
 // UnsafeExecutionServer may be embedded to opt out of forward compatibility for this service.
@@ -574,6 +591,24 @@ func _Execution_Ready_Handler(srv interface{}, ctx context.Context, dec func(int
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Execution_FrozenBlocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(emptypb.Empty)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ExecutionServer).FrozenBlocks(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Execution_FrozenBlocks_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ExecutionServer).FrozenBlocks(ctx, req.(*emptypb.Empty))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // Execution_ServiceDesc is the grpc.ServiceDesc for Execution service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -641,6 +676,10 @@ var Execution_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Ready",
 			Handler:    _Execution_Ready_Handler,
 		},
+		{
+			MethodName: "FrozenBlocks",
+			Handler:    _Execution_FrozenBlocks_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "execution/execution.proto",
diff --git a/erigon-lib/gointerfaces/sentinel/sentinel.pb.go b/erigon-lib/gointerfaces/sentinel/sentinel.pb.go
index 78267b9fd..0fc32fe89 100644
--- a/erigon-lib/gointerfaces/sentinel/sentinel.pb.go
+++ b/erigon-lib/gointerfaces/sentinel/sentinel.pb.go
@@ -25,13 +25,13 @@ type GossipType int32
 
 const (
 	// Global gossip topics.
-	GossipType_BeaconBlockGossipType       GossipType = 0
-	GossipType_AggregateAndProofGossipType GossipType = 1
-	GossipType_VoluntaryExitGossipType     GossipType = 2
-	GossipType_ProposerSlashingGossipType  GossipType = 3
-	GossipType_AttesterSlashingGossipType  GossipType = 4
-	GossipType_BlobSidecarType             GossipType = 5
-	GossipType_BlsToExecutionChangeType    GossipType = 6
+	GossipType_BeaconBlockGossipType          GossipType = 0
+	GossipType_AggregateAndProofGossipType    GossipType = 1
+	GossipType_VoluntaryExitGossipType        GossipType = 2
+	GossipType_ProposerSlashingGossipType     GossipType = 3
+	GossipType_AttesterSlashingGossipType     GossipType = 4
+	GossipType_BlobSidecarType                GossipType = 5
+	GossipType_BlsToExecutionChangeGossipType GossipType = 6
 )
 
 // Enum value maps for GossipType.
@@ -43,16 +43,16 @@ var (
 		3: "ProposerSlashingGossipType",
 		4: "AttesterSlashingGossipType",
 		5: "BlobSidecarType",
-		6: "BlsToExecutionChangeType",
+		6: "BlsToExecutionChangeGossipType",
 	}
 	GossipType_value = map[string]int32{
-		"BeaconBlockGossipType":       0,
-		"AggregateAndProofGossipType": 1,
-		"VoluntaryExitGossipType":     2,
-		"ProposerSlashingGossipType":  3,
-		"AttesterSlashingGossipType":  4,
-		"BlobSidecarType":             5,
-		"BlsToExecutionChangeType":    6,
+		"BeaconBlockGossipType":          0,
+		"AggregateAndProofGossipType":    1,
+		"VoluntaryExitGossipType":        2,
+		"ProposerSlashingGossipType":     3,
+		"AttesterSlashingGossipType":     4,
+		"BlobSidecarType":                5,
+		"BlsToExecutionChangeGossipType": 6,
 	}
 )
 
@@ -528,7 +528,7 @@ var file_p2psentinel_sentinel_proto_rawDesc = []byte{
 	0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x22, 0x0a,
 	0x04, 0x70, 0x65, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x73, 0x65,
 	0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x52, 0x04, 0x70, 0x65, 0x65,
-	0x72, 0x2a, 0xd8, 0x01, 0x0a, 0x0a, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x54, 0x79, 0x70, 0x65,
+	0x72, 0x2a, 0xde, 0x01, 0x0a, 0x0a, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x54, 0x79, 0x70, 0x65,
 	0x12, 0x19, 0x0a, 0x15, 0x42, 0x65, 0x61, 0x63, 0x6f, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x47,
 	0x6f, 0x73, 0x73, 0x69, 0x70, 0x54, 0x79, 0x70, 0x65, 0x10, 0x00, 0x12, 0x1f, 0x0a, 0x1b, 0x41,
 	0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x41, 0x6e, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66,
@@ -539,44 +539,45 @@ var file_p2psentinel_sentinel_proto_rawDesc = []byte{
 	0x73, 0x69, 0x70, 0x54, 0x79, 0x70, 0x65, 0x10, 0x03, 0x12, 0x1e, 0x0a, 0x1a, 0x41, 0x74, 0x74,
 	0x65, 0x73, 0x74, 0x65, 0x72, 0x53, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x47, 0x6f, 0x73,
 	0x73, 0x69, 0x70, 0x54, 0x79, 0x70, 0x65, 0x10, 0x04, 0x12, 0x13, 0x0a, 0x0f, 0x42, 0x6c, 0x6f,
-	0x62, 0x53, 0x69, 0x64, 0x65, 0x63, 0x61, 0x72, 0x54, 0x79, 0x70, 0x65, 0x10, 0x05, 0x12, 0x1c,
-	0x0a, 0x18, 0x42, 0x6c, 0x73, 0x54, 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
-	0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x54, 0x79, 0x70, 0x65, 0x10, 0x06, 0x32, 0x90, 0x04, 0x0a,
-	0x08, 0x53, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x12, 0x41, 0x0a, 0x0f, 0x53, 0x75, 0x62,
-	0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x12, 0x16, 0x2e, 0x73,
-	0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x1a, 0x14, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e,
-	0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x44, 0x61, 0x74, 0x61, 0x30, 0x01, 0x12, 0x3c, 0x0a, 0x0b,
-	0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x15, 0x2e, 0x73, 0x65,
-	0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x44, 0x61,
-	0x74, 0x61, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x44, 0x61, 0x74, 0x61, 0x12, 0x35, 0x0a, 0x09, 0x53, 0x65,
-	0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x10, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e,
-	0x65, 0x6c, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74,
-	0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x65, 0x12, 0x37, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x16, 0x2e,
-	0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
-	0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x13, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c,
-	0x2e, 0x50, 0x65, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x31, 0x0a, 0x07, 0x42, 0x61,
-	0x6e, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c,
-	0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c,
-	0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x33, 0x0a,
-	0x09, 0x55, 0x6e, 0x62, 0x61, 0x6e, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e,
-	0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e,
-	0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x12, 0x36, 0x0a, 0x0c, 0x50, 0x65, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x50, 0x65,
-	0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65,
-	0x65, 0x72, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d,
-	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x0a, 0x52, 0x65,
-	0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69,
+	0x62, 0x53, 0x69, 0x64, 0x65, 0x63, 0x61, 0x72, 0x54, 0x79, 0x70, 0x65, 0x10, 0x05, 0x12, 0x22,
+	0x0a, 0x1e, 0x42, 0x6c, 0x73, 0x54, 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
+	0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x54, 0x79, 0x70, 0x65,
+	0x10, 0x06, 0x32, 0x90, 0x04, 0x0a, 0x08, 0x53, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x12,
+	0x41, 0x0a, 0x0f, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x47, 0x6f, 0x73, 0x73,
+	0x69, 0x70, 0x12, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d,
+	0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x14, 0x2e, 0x73, 0x65, 0x6e,
+	0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x44, 0x61, 0x74, 0x61,
+	0x30, 0x01, 0x12, 0x3c, 0x0a, 0x0b, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x12, 0x15, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69,
+	0x6e, 0x65, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x44, 0x61, 0x74, 0x61,
+	0x12, 0x35, 0x0a, 0x09, 0x53, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x10, 0x2e,
+	0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a,
+	0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x50, 0x65,
+	0x65, 0x72, 0x73, 0x12, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45,
+	0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x13, 0x2e, 0x73, 0x65,
+	0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74,
+	0x12, 0x31, 0x0a, 0x07, 0x42, 0x61, 0x6e, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65,
+	0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x73, 0x65,
+	0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x33, 0x0a, 0x09, 0x55, 0x6e, 0x62, 0x61, 0x6e, 0x50, 0x65, 0x65, 0x72,
+	0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72,
+	0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74,
+	0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x36, 0x0a, 0x0c, 0x50, 0x65, 0x6e, 0x61,
+	0x6c, 0x69, 0x7a, 0x65, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69,
 	0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69,
 	0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x12, 0x3d, 0x0a, 0x0d, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73, 0x68, 0x47, 0x6f, 0x73, 0x73, 0x69,
-	0x70, 0x12, 0x14, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x47, 0x6f, 0x73,
-	0x73, 0x69, 0x70, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e,
-	0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42,
-	0x15, 0x5a, 0x13, 0x2e, 0x2f, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x3b, 0x73, 0x65,
-	0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x12, 0x34, 0x0a, 0x0a, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e,
+	0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16,
+	0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
+	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x3d, 0x0a, 0x0d, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73,
+	0x68, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x12, 0x14, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e,
+	0x65, 0x6c, 0x2e, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x16, 0x2e,
+	0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x15, 0x5a, 0x13, 0x2e, 0x2f, 0x73, 0x65, 0x6e, 0x74, 0x69,
+	0x6e, 0x65, 0x6c, 0x3b, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x62, 0x06, 0x70, 0x72,
+	0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
diff --git a/eth/backend.go b/eth/backend.go
index c409ee3cf..da2fabf1a 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -82,7 +82,7 @@ import (
 	types2 "github.com/ledgerwatch/erigon-lib/types"
 
 	clcore "github.com/ledgerwatch/erigon/cl/phase1/core"
-	"github.com/ledgerwatch/erigon/cmd/caplin-phase1/caplin1"
+	"github.com/ledgerwatch/erigon/cmd/caplin/caplin1"
 	"github.com/ledgerwatch/erigon/cmd/rpcdaemon/cli"
 	"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel"
 	"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel/service"
@@ -483,6 +483,7 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger
 		}
 	}
 
+	fmt.Println(blockReader.FrozenBlocks())
 	inMemoryExecution := func(batch kv.RwTx, header *types.Header, body *types.RawBody, unwindPoint uint64, headersChain []*types.Header, bodiesChain []*types.RawBody,
 		notifications *shards.Notifications) error {
 		terseLogger := log.New()
diff --git a/turbo/execution/eth1/eth1_chain_reader.go/chain_reader.go b/turbo/execution/eth1/eth1_chain_reader.go/chain_reader.go
index 153241771..c538c2802 100644
--- a/turbo/execution/eth1/eth1_chain_reader.go/chain_reader.go
+++ b/turbo/execution/eth1/eth1_chain_reader.go/chain_reader.go
@@ -247,8 +247,12 @@ func (c ChainReaderWriterEth1) IsCanonicalHash(hash libcommon.Hash) (bool, error
 	return resp.Canonical, nil
 }
 
-func (ChainReaderWriterEth1) FrozenBlocks() uint64 {
-	panic("ChainReaderEth1.FrozenBlocks not implemented")
+func (c ChainReaderWriterEth1) FrozenBlocks() uint64 {
+	ret, err := c.executionModule.FrozenBlocks(c.ctx, &emptypb.Empty{})
+	if err != nil {
+		panic(err)
+	}
+	return ret.FrozenBlocks
 }
 
 const retryTimeout = 10 * time.Millisecond
diff --git a/turbo/execution/eth1/getters.go b/turbo/execution/eth1/getters.go
index 3ba9d136d..b282bce4e 100644
--- a/turbo/execution/eth1/getters.go
+++ b/turbo/execution/eth1/getters.go
@@ -294,3 +294,9 @@ func (e *EthereumExecutionModule) GetForkChoice(ctx context.Context, _ *emptypb.
 		SafeBlockHash:      gointerfaces.ConvertHashToH256(rawdb.ReadForkchoiceSafe(tx)),
 	}, nil
 }
+
+func (e *EthereumExecutionModule) FrozenBlocks(ctx context.Context, _ *emptypb.Empty) (*execution.FrozenBlocksResponse, error) {
+	return &execution.FrozenBlocksResponse{
+		FrozenBlocks: e.blockReader.FrozenBlocks(),
+	}, nil
+}