mirror/erigon-pulse
1
0
Fork 0
mirror of https://gitlab.com/pulsechaincom/erigon-pulse.git synced 2024-12-22 03:30:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Caplin: under the hood block downloading (#8459)

Browse Source
This commit is contained in:
Giulio rebuffo 2023-10-16 15:35:26 +02:00 committed by GitHub
parent f265bd8bfc
commit 9e42b705ce
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 427 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Dockerfile
View File

@ -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/state /usr/local/bin/state
COPY --from=builder /app/build/bin/txpool /usr/local/bin/txpool 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/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 COPY --from=builder /app/build/bin/caplin-regression /usr/local/bin/caplin-regression

2
Dockerfile.debian
View File

@ -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/state /usr/local/bin/state
COPY --from=builder /app/build/bin/txpool /usr/local/bin/txpool 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/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 COPY --from=builder /app/build/bin/caplin-regression /usr/local/bin/caplin-regression
EXPOSE 8545 \ EXPOSE 8545 \

2
Makefile
View File

@ -119,7 +119,7 @@ COMMANDS += txpool
COMMANDS += verkle COMMANDS += verkle
COMMANDS += evm COMMANDS += evm
COMMANDS += sentinel COMMANDS += sentinel
COMMANDS += caplin-phase1 COMMANDS += caplin
COMMANDS += caplin-regression COMMANDS += caplin-regression

4
cl/persistence/block_saver_test.go
View File

@ -33,6 +33,10 @@ func (m *mockEngine) ForkChoiceUpdate(finalized libcommon.Hash, head libcommon.H
panic("unimplemented") panic("unimplemented")
} }
func (m *mockEngine) FrozenBlocks() uint64 {
panic("unimplemented")
}
func (m *mockEngine) NewPayload(payload *cltypes.Eth1Block, beaconParentRoot *libcommon.Hash) (bool, error) { func (m *mockEngine) NewPayload(payload *cltypes.Eth1Block, beaconParentRoot *libcommon.Hash) (bool, error) {
panic("unimplemented") panic("unimplemented")
} }

49
cl/persistence/snapshot_format/blocks.go
View File

@ -5,6 +5,7 @@ import (
"fmt" "fmt"
"io" "io"
"github.com/golang/snappy"
"github.com/ledgerwatch/erigon/cl/clparams" "github.com/ledgerwatch/erigon/cl/clparams"
"github.com/ledgerwatch/erigon/cl/cltypes" "github.com/ledgerwatch/erigon/cl/cltypes"
) )
@ -40,11 +41,11 @@ func writeExecutionBlockPtr(w io.Writer, p *cltypes.Eth1Block) error {
temp := make([]byte, 8) temp := make([]byte, 8)
binary.BigEndian.PutUint64(temp, p.BlockNumber) binary.BigEndian.PutUint64(temp, p.BlockNumber)
return writeChunk(w, temp, pointerDataType, false) return writeChunk(w, temp, pointerDataType)
} }
func readExecutionBlockPtr(r io.Reader) (uint64, error) { func readExecutionBlockPtr(r io.Reader) (uint64, error) {
b, dT, err := readChunk(r, false) b, dT, err := readChunk(r)
if err != nil { if err != nil {
return 0, err return 0, err
} }
@ -90,11 +91,15 @@ func WriteBlockForSnapshot(block *cltypes.SignedBeaconBlock, w io.Writer) error
currentChunkLength += uint64(body.AttesterSlashings.EncodingSizeSSZ()) currentChunkLength += uint64(body.AttesterSlashings.EncodingSizeSSZ())
// Write the chunk and chunk attestations // 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 return err
} }
encoded = encoded[currentChunkLength:] 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 return err
} }
encoded = encoded[body.Attestations.EncodingSizeSSZ():] 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.Deposits.EncodingSizeSSZ())
currentChunkLength += uint64(body.VoluntaryExits.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 return err
} }
// we are done if we are before altair // 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 { if version <= clparams.BellatrixVersion {
return nil 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) // Metadata section is just the current hardfork of the block. TODO(give it a useful purpose)
v, err := readMetadataForBlock(r) v, err := readMetadataForBlock(r)
if err != nil { if err != nil {
@ -128,31 +136,34 @@ func ReadBlockFromrSnapshot(r io.Reader, executionReader ExecutionBlockReaderByN
} }
// Read the first chunk // Read the first chunk
chunk1, dT1, err := readChunk(r, false) chunk1, dT1, err := readChunk(r)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if dT1 != chunkDataType { if dT1 != chunkDataType {
return nil, fmt.Errorf("malformed beacon block, invalid chunk 1 type %d, expected: %d", 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) // Read the attestation chunk (2nd chunk)
chunk2, dT2, err := readChunk(r, true) chunk2, dT2, err := readChunk(snappy.NewReader(r))
if err != nil { if err != nil {
return nil, err return nil, err
} }
if dT2 != chunkDataType { if dT2 != chunkDataType {
return nil, fmt.Errorf("malformed beacon block, invalid chunk 2 type %d, expected: %d", 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 // Read the 3rd chunk
chunk3, dT3, err := readChunk(r, false) chunk3, dT3, err := readChunk(r)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if dT3 != chunkDataType { if dT3 != chunkDataType {
return nil, fmt.Errorf("malformed beacon block, invalid chunk 3 type %d, expected: %d", 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 { 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 // Read the block pointer and retrieve chunk4 from the execution reader
blockPointer, err := readExecutionBlockPtr(r) blockPointer, err := readExecutionBlockPtr(r)
@ -168,28 +179,20 @@ func ReadBlockFromrSnapshot(r io.Reader, executionReader ExecutionBlockReaderByN
if err != nil { if err != nil {
return nil, err return nil, err
} }
plainSSZ = append(plainSSZ, chunk4...)
if v <= clparams.BellatrixVersion { if v <= clparams.BellatrixVersion {
return blockFromChunks(v, cfg, chunk1, chunk2, chunk3, chunk4) return block, block.DecodeSSZ(plainSSZ, int(v))
} }
// Read the 5h chunk // Read the 5h chunk
chunk5, dT5, err := readChunk(r, false) chunk5, dT5, err := readChunk(r)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if dT5 != chunkDataType { if dT5 != chunkDataType {
return nil, fmt.Errorf("malformed beacon block, invalid chunk 5 type %d, expected: %d", 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)) return block, block.DecodeSSZ(plainSSZ, int(v))
} }

2
cl/persistence/snapshot_format/blocks_test.go
View File

@ -59,7 +59,7 @@ func TestBlockSnapshotEncoding(t *testing.T) {
} }
var b bytes.Buffer var b bytes.Buffer
require.NoError(t, snapshot_format.WriteBlockForSnapshot(blk, &b)) 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) require.NoError(t, err)
_ = blk2 _ = blk2
hash1, err := blk.HashSSZ() hash1, err := blk.HashSSZ()

24
cl/persistence/snapshot_format/chunks.go
View File

@ -6,7 +6,6 @@ import (
"io" "io"
"github.com/ledgerwatch/erigon/cl/clparams" "github.com/ledgerwatch/erigon/cl/clparams"
"github.com/ledgerwatch/erigon/cl/utils"
) )
type dataType int type dataType int
@ -17,10 +16,7 @@ const (
) )
// writeChunk writes a chunk to the writer. // writeChunk writes a chunk to the writer.
func writeChunk(w io.Writer, buf []byte, t dataType, snappy bool) error { func writeChunk(w io.Writer, buf []byte, t dataType) error {
if snappy {
buf = utils.CompressSnappy(buf)
}
// prefix is type of chunk + length of chunk // prefix is type of chunk + length of chunk
prefix := make([]byte, 8) prefix := make([]byte, 8)
binary.BigEndian.PutUint64(prefix, uint64(len(buf))) 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 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) prefix := make([]byte, 8)
if _, err := r.Read(prefix); err != nil { fmt.Println("A")
return nil, dataType(0), err if _, err = r.Read(prefix); err != nil {
return
} }
t = dataType(prefix[0]) t = dataType(prefix[0])
prefix[0] = 0 prefix[0] = 0
fmt.Println(binary.BigEndian.Uint64(prefix))
buf = make([]byte, binary.BigEndian.Uint64(prefix)) buf = make([]byte, binary.BigEndian.Uint64(prefix))
if _, err := r.Read(buf); err != nil { if _, err = r.Read(buf); err != nil {
return nil, t, err return
} }
if snappy { return
buf, err = utils.DecompressSnappy(buf)
}
return buf, t, err
} }
func readMetadataForBlock(r io.Reader) (clparams.StateVersion, error) { func readMetadataForBlock(r io.Reader) (clparams.StateVersion, error) {

4
cl/phase1/execution_client/execution_client_direct.go
View File

@ -96,3 +96,7 @@ func (cc *ExecutionClientDirect) GetBodiesByRange(start, count uint64) ([]*types
func (cc *ExecutionClientDirect) GetBodiesByHashes(hashes []libcommon.Hash) ([]*types.RawBody, error) { func (cc *ExecutionClientDirect) GetBodiesByHashes(hashes []libcommon.Hash) ([]*types.RawBody, error) {
return cc.chainRW.GetBodiesByHases(hashes), nil return cc.chainRW.GetBodiesByHases(hashes), nil
} }
func (cc *ExecutionClientDirect) FrozenBlocks() uint64 {
return cc.chainRW.FrozenBlocks()
}

4
cl/phase1/execution_client/execution_client_rpc.go
View File

@ -224,3 +224,7 @@ func (cc *ExecutionClientRpc) GetBodiesByHashes(hashes []libcommon.Hash) ([]*typ
} }
return ret, nil return ret, nil
} }
func (cc *ExecutionClientRpc) FrozenBlocks() uint64 {
panic("unimplemented")
}

2
cl/phase1/execution_client/interface.go
View File

@ -22,4 +22,6 @@ type ExecutionEngine interface {
// Range methods // Range methods
GetBodiesByRange(start, count uint64) ([]*types.RawBody, error) GetBodiesByRange(start, count uint64) ([]*types.RawBody, error)
GetBodiesByHashes(hashes []libcommon.Hash) ([]*types.RawBody, error) GetBodiesByHashes(hashes []libcommon.Hash) ([]*types.RawBody, error)
// Snapshots
FrozenBlocks() uint64
} }

2
cl/phase1/network/gossip_manager.go
View File

@ -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 { if err := operationsContract[*cltypes.AttesterSlashing](ctx, g, l, data, int(version), "attester slashing", g.forkChoice.OnAttesterSlashing); err != nil {
return err 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 { if err := operationsContract[*cltypes.SignedBLSToExecutionChange](ctx, g, l, data, int(version), "bls to execution change", g.forkChoice.OnBlsToExecutionChange); err != nil {
return err return err
} }

21
cl/phase1/stages/clstages.go
View File

@ -46,6 +46,8 @@ type Args struct {
targetEpoch, seenEpoch uint64 targetEpoch, seenEpoch uint64
targetSlot, seenSlot uint64 targetSlot, seenSlot uint64
downloadedHistory bool
} }
func ClStagesCfg( func ClStagesCfg(
@ -93,11 +95,11 @@ const (
minPeersForDownload = uint64(4) minPeersForDownload = uint64(4)
) )
func MetaCatchingUp(args Args, hasDownloaded bool) StageName { func MetaCatchingUp(args Args) StageName {
if args.peers < minPeersForDownload { if args.peers < minPeersForDownload {
return WaitForPeers return WaitForPeers
} }
if !hasDownloaded { if !args.downloadedHistory {
return DownloadHistoricalBlocks return DownloadHistoricalBlocks
} }
if args.seenEpoch < args.targetEpoch { if args.seenEpoch < args.targetEpoch {
@ -188,6 +190,7 @@ func ConsensusClStages(ctx context.Context,
log.Error("failed to get sentinel peer count", "err", err) log.Error("failed to get sentinel peer count", "err", err)
args.peers = 0 args.peers = 0
} }
args.downloadedHistory = downloaded
args.seenSlot = cfg.forkChoice.HighestSeen() args.seenSlot = cfg.forkChoice.HighestSeen()
args.seenEpoch = args.seenSlot / cfg.beaconCfg.SlotsPerEpoch args.seenEpoch = args.seenSlot / cfg.beaconCfg.SlotsPerEpoch
args.targetSlot = utils.GetCurrentSlot(cfg.genesisCfg.GenesisTime, cfg.beaconCfg.SecondsPerSlot) args.targetSlot = utils.GetCurrentSlot(cfg.genesisCfg.GenesisTime, cfg.beaconCfg.SecondsPerSlot)
@ -199,7 +202,7 @@ func ConsensusClStages(ctx context.Context,
WaitForPeers: { WaitForPeers: {
Description: `wait for enough peers. This is also a safe stage to go to when unsure of what stage to use`, 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 { TransitionFunc: func(cfg *Cfg, args Args, err error) string {
if x := MetaCatchingUp(args, downloaded); x != "" { if x := MetaCatchingUp(args); x != "" {
return x return x
} }
return CatchUpBlocks return CatchUpBlocks
@ -232,7 +235,7 @@ func ConsensusClStages(ctx context.Context,
DownloadHistoricalBlocks: { DownloadHistoricalBlocks: {
Description: "Download historical blocks", Description: "Download historical blocks",
TransitionFunc: func(cfg *Cfg, args Args, err error) string { TransitionFunc: func(cfg *Cfg, args Args, err error) string {
if x := MetaCatchingUp(args, downloaded); x != "" { if x := MetaCatchingUp(args); x != "" {
return x return x
} }
return CatchUpBlocks return CatchUpBlocks
@ -256,7 +259,7 @@ func ConsensusClStages(ctx context.Context,
CatchUpEpochs: { CatchUpEpochs: {
Description: `if we are 1 or more epochs behind, we download in parallel by epoch`, Description: `if we are 1 or more epochs behind, we download in parallel by epoch`,
TransitionFunc: func(cfg *Cfg, args Args, err error) string { TransitionFunc: func(cfg *Cfg, args Args, err error) string {
if x := MetaCatchingUp(args, downloaded); x != "" { if x := MetaCatchingUp(args); x != "" {
return x return x
} }
return CatchUpBlocks return CatchUpBlocks
@ -321,7 +324,7 @@ func ConsensusClStages(ctx context.Context,
CatchUpBlocks: { CatchUpBlocks: {
Description: `if we are within the epoch but not at head, we run catchupblocks`, Description: `if we are within the epoch but not at head, we run catchupblocks`,
TransitionFunc: func(cfg *Cfg, args Args, err error) string { TransitionFunc: func(cfg *Cfg, args Args, err error) string {
if x := MetaCatchingUp(args, downloaded); x != "" { if x := MetaCatchingUp(args); x != "" {
return x return x
} }
return ForkChoice return ForkChoice
@ -378,7 +381,7 @@ func ConsensusClStages(ctx context.Context,
Description: `fork choice stage. We will send all fork choise things here 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`, also, we will wait up to delay seconds to deal with attestations + side forks`,
TransitionFunc: func(cfg *Cfg, args Args, err error) string { TransitionFunc: func(cfg *Cfg, args Args, err error) string {
if x := MetaCatchingUp(args, downloaded); x != "" { if x := MetaCatchingUp(args); x != "" {
return x return x
} }
return ListenForForks return ListenForForks
@ -466,7 +469,7 @@ func ConsensusClStages(ctx context.Context,
defer func() { defer func() {
shouldForkChoiceSinceReorg = false shouldForkChoiceSinceReorg = false
}() }()
if x := MetaCatchingUp(args, downloaded); x != "" { if x := MetaCatchingUp(args); x != "" {
return x return x
} }
if shouldForkChoiceSinceReorg { if shouldForkChoiceSinceReorg {
@ -512,7 +515,7 @@ func ConsensusClStages(ctx context.Context,
CleanupAndPruning: { CleanupAndPruning: {
Description: `cleanup and pruning is done here`, Description: `cleanup and pruning is done here`,
TransitionFunc: func(cfg *Cfg, args Args, err error) string { TransitionFunc: func(cfg *Cfg, args Args, err error) string {
if x := MetaCatchingUp(args, downloaded); x != "" { if x := MetaCatchingUp(args); x != "" {
return x return x
} }
return SleepForSlot return SleepForSlot

68
cl/phase1/stages/stage_history_download.go
View File

@ -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 // SpawnStageBeaconsForward spawn the beacon forward stage
func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Context, logger log.Logger) error { func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Context, logger log.Logger) error {
// Wait for execution engine to be ready. // Wait for execution engine to be ready.
if err := waitForExecutionEngineToBeReady(ctx, cfg.engine); err != nil { // if err := waitForExecutionEngineToBeReady(ctx, cfg.engine); err != nil {
return err // return err
} // }
blockRoot := cfg.startingRoot blockRoot := cfg.startingRoot
destinationSlot := uint64(0) destinationSlot := uint64(0)
currentSlot := cfg.startingSlot currentSlot := cfg.startingSlot
@ -90,16 +69,16 @@ func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Co
destinationSlot = currentSlot - cfg.dbCfg.PruneDepth 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() defer executionBlocksCollector.Close()
// Start the procedure // Start the procedure
logger.Info("Downloading History", "from", currentSlot) logger.Info("Starting downloading History", "from", currentSlot)
// Setup slot and block root // Setup slot and block root
cfg.downloader.SetSlotToDownload(currentSlot) cfg.downloader.SetSlotToDownload(currentSlot)
cfg.downloader.SetExpectedRoot(blockRoot) cfg.downloader.SetExpectedRoot(blockRoot)
foundLatestEth1ValidHash := false foundLatestEth1ValidBlock := false
if cfg.engine == nil || !cfg.engine.SupportInsertion() { 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 var currEth1Progress atomic.Int64
@ -114,7 +93,14 @@ func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Co
if blk.Version() >= clparams.BellatrixVersion { if blk.Version() >= clparams.BellatrixVersion {
currEth1Progress.Store(int64(blk.Block.Body.ExecutionPayload.BlockNumber)) 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 payload := blk.Block.Body.ExecutionPayload
encodedPayload, err := payload.EncodeSSZ(nil) encodedPayload, err := payload.EncodeSSZ(nil)
if err != 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 { 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) 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}) bodyChainHeader, err := cfg.engine.GetBodiesByHashes([]libcommon.Hash{payload.BlockHash})
if err != nil { if err != nil {
return false, fmt.Errorf("error retrieving whether execution payload is present: %s", err) 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 return slot <= destinationSlot && foundLatestEth1ValidBlock, nil
if destinationSlot <= blk.Block.Slot {
if err := cfg.db.WriteBlock(tx, ctx, blk, true); err != nil {
return false, err
}
}
return slot <= destinationSlot && foundLatestEth1ValidHash, nil
}) })
prevProgress := cfg.downloader.Progress() prevProgress := cfg.downloader.Progress()
@ -150,6 +133,15 @@ func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Co
for { for {
select { select {
case <-logInterval.C: 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{}{} logArgs := []interface{}{}
currProgress := cfg.downloader.Progress() currProgress := cfg.downloader.Progress()
speed := float64(prevProgress-currProgress) / float64(logIntervalTime/time.Second) speed := float64(prevProgress-currProgress) / float64(logIntervalTime/time.Second)
@ -187,6 +179,8 @@ func SpawnStageHistoryDownload(cfg StageHistoryReconstructionCfg, ctx context.Co
blockBatch := []*types.Block{} blockBatch := []*types.Block{}
blockBatchMaxSize := 1000 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 err := executionBlocksCollector.Load(tx2, kv.Headers, func(k, vComp []byte, _ etl.CurrentTableReader, next etl.LoadNextFunc) error {
if cfg.engine == nil || !cfg.engine.SupportInsertion() { if cfg.engine == nil || !cfg.engine.SupportInsertion() {
return next(k, nil, nil) return next(k, nil, nil)

2
cmd/caplin-phase1/caplin1/run.go → cmd/caplin/caplin1/run.go
View File

@ -111,7 +111,7 @@ func RunCaplinPhase1(ctx context.Context, sentinel sentinel.SentinelClient, engi
fmt.Println("A") fmt.Println("A")
{ // start ticking forkChoice { // start ticking forkChoice
go func() { go func() {
tickInterval := time.NewTicker(2 * time.Millisecond) tickInterval := time.NewTicker(50 * time.Millisecond)
for { for {
select { select {
case <-tickInterval.C: case <-tickInterval.C:

6
cmd/caplin-phase1/main.go → cmd/caplin/main.go
View File

@ -29,17 +29,17 @@ import (
"github.com/ledgerwatch/erigon/cl/cltypes" "github.com/ledgerwatch/erigon/cl/cltypes"
"github.com/ledgerwatch/erigon/cl/fork" "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" lcCli "github.com/ledgerwatch/erigon/cmd/sentinel/cli"
"github.com/ledgerwatch/erigon/cmd/sentinel/cli/flags" "github.com/ledgerwatch/erigon/cmd/sentinel/cli/flags"
"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel" "github.com/ledgerwatch/erigon/cmd/sentinel/sentinel"
"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel/service" "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" "github.com/ledgerwatch/erigon/turbo/debug"
) )
func main() { 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 { if err := app.Run(os.Args); err != nil {
_, printErr := fmt.Fprintln(os.Stderr, err) _, printErr := fmt.Fprintln(os.Stderr, err)
if printErr != nil { if printErr != nil {

2
cmd/sentinel/sentinel/service/service.go
View File

@ -283,7 +283,7 @@ func (s *SentinelServer) handleGossipPacket(pkt *pubsub.Message) error {
} else if strings.Contains(*pkt.Topic, string(sentinel.AttesterSlashingTopic)) { } else if strings.Contains(*pkt.Topic, string(sentinel.AttesterSlashingTopic)) {
s.gossipNotifier.notify(sentinelrpc.GossipType_AttesterSlashingGossipType, data, string(textPid)) s.gossipNotifier.notify(sentinelrpc.GossipType_AttesterSlashingGossipType, data, string(textPid))
} else if strings.Contains(*pkt.Topic, string(sentinel.BlsToExecutionChangeTopic)) { } 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)) { } else if strings.Contains(*pkt.Topic, string(sentinel.BlobSidecarTopic)) {
// extract the index // extract the index
s.gossipNotifier.notifyBlob(sentinelrpc.GossipType_BlobSidecarType, data, string(textPid), extractBlobSideCarIndex(*pkt.Topic)) s.gossipNotifier.notifyBlob(sentinelrpc.GossipType_BlobSidecarType, data, string(textPid), extractBlobSideCarIndex(*pkt.Topic))

4
erigon-lib/direct/execution_client.go
View File

@ -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) { func (s *ExecutionClientDirect) Ready(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*execution.ReadyResponse, error) {
return s.server.Ready(ctx, in) 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)
}

2
erigon-lib/go.mod
View File

@ -4,7 +4,7 @@ go 1.19
require ( require (
github.com/erigontech/mdbx-go v0.27.17 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/log/v3 v3.9.0
github.com/ledgerwatch/secp256k1 v1.0.0 github.com/ledgerwatch/secp256k1 v1.0.0
) )

4
erigon-lib/go.sum
View File

@ -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 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= 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/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-20231011121315-f58b806039f0 h1:7z6cyoCKP6qxtKSO74eAY6XiHWKaOi+melvPeMCXLl8=
github.com/ledgerwatch/interfaces v0.0.0-20230929215128-3300a167cce0/go.mod h1:ugQv1QllJzBny3cKZKxUrSnykkjkBgm27eQM6dnGAcc= 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 h1:iDwrXe0PVwBC68Dd94YSsHbMgQ3ufsgjzXtFNFVZFRk=
github.com/ledgerwatch/log/v3 v3.9.0/go.mod h1:EiAY6upmI/6LkNhOVxb4eVsmsP11HZCnZ3PlJMjYiqE= github.com/ledgerwatch/log/v3 v3.9.0/go.mod h1:EiAY6upmI/6LkNhOVxb4eVsmsP11HZCnZ3PlJMjYiqE=
github.com/ledgerwatch/secp256k1 v1.0.0 h1:Usvz87YoTG0uePIV8woOof5cQnLXGYa162rFf3YnwaQ= github.com/ledgerwatch/secp256k1 v1.0.0 h1:Usvz87YoTG0uePIV8woOof5cQnLXGYa162rFf3YnwaQ=

353
erigon-lib/gointerfaces/execution/execution.pb.go
View File

@ -1566,6 +1566,53 @@ func (x *ReadyResponse) GetReady() bool {
return false 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 protoreflect.FileDescriptor
var file_execution_execution_proto_rawDesc = []byte{ 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, 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, 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, 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, 0x64, 0x79, 0x22, 0x3b, 0x0a, 0x14, 0x46, 0x72, 0x6f, 0x7a, 0x65, 0x6e, 0x42, 0x6c, 0x6f, 0x63,
0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x6b, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x66, 0x72,
0x10, 0x00, 0x12, 0x0c, 0x0a, 0x08, 0x42, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x10, 0x01, 0x6f, 0x7a, 0x65, 0x6e, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28,
0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x6f, 0x6f, 0x46, 0x61, 0x72, 0x41, 0x77, 0x61, 0x79, 0x10, 0x02, 0x04, 0x52, 0x0c, 0x66, 0x72, 0x6f, 0x7a, 0x65, 0x6e, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x2a,
0x12, 0x12, 0x0a, 0x0e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x71, 0x0a, 0x0f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74,
0x6e, 0x74, 0x10, 0x03, 0x12, 0x15, 0x0a, 0x11, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x46, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x53, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x10, 0x00, 0x12,
0x6f, 0x72, 0x6b, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x10, 0x04, 0x12, 0x08, 0x0a, 0x04, 0x42, 0x0c, 0x0a, 0x08, 0x42, 0x61, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x10, 0x01, 0x12, 0x0e, 0x0a,
0x75, 0x73, 0x79, 0x10, 0x05, 0x32, 0xf6, 0x08, 0x0a, 0x09, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x0a, 0x54, 0x6f, 0x6f, 0x46, 0x61, 0x72, 0x41, 0x77, 0x61, 0x79, 0x10, 0x02, 0x12, 0x12, 0x0a,
0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x0c, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x0e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x10,
0x63, 0x6b, 0x73, 0x12, 0x1e, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x03, 0x12, 0x15, 0x0a, 0x11, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x46, 0x6f, 0x72, 0x6b,
0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, 0x63, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x10, 0x04, 0x12, 0x08, 0x0a, 0x04, 0x42, 0x75, 0x73, 0x79,
0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x10, 0x05, 0x32, 0xbf, 0x09, 0x0a, 0x09, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x12, 0x4a, 0x0a, 0x0c, 0x49, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73,
0x4b, 0x0a, 0x0d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x1e, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x49, 0x6e, 0x73,
0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x1a, 0x1a, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x49, 0x6e, 0x73,
0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x4b, 0x0a, 0x0d,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x12, 0x47, 0x0a, 0x10, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x65, 0x43, 0x68, 0x61, 0x69, 0x6e, 0x12, 0x1c, 0x2e,
0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61,
0x12, 0x15, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x46, 0x6f, 0x72, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x65, 0x78,
0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x1a, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
0x69, 0x6f, 0x6e, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x6f, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, 0x70, 0x74, 0x12, 0x47, 0x0a, 0x10, 0x55, 0x70, 0x64,
0x63, 0x65, 0x69, 0x70, 0x74, 0x12, 0x52, 0x0a, 0x0d, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x61, 0x74, 0x65, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x12, 0x15, 0x2e,
0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x1f, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68,
0x6f, 0x6e, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x6f, 0x69, 0x63, 0x65, 0x1a, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63, 0x65, 0x52, 0x65, 0x63, 0x65, 0x69,
0x69, 0x6f, 0x6e, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x70, 0x74, 0x12, 0x52, 0x0a, 0x0d, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c,
0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x6f, 0x63, 0x6b, 0x12, 0x1f, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e,
0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x23, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71,
0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x73, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x20, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x2e, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65,
0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5e, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x41, 0x73, 0x73,
0x47, 0x65, 0x74, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x23, 0x2e, 0x65, 0x78,
0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0d, 0x43, 0x75, 0x72, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x41, 0x73, 0x73, 0x65, 0x6d,
0x72, 0x65, 0x6e, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x1a, 0x24, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74,
0x74, 0x79, 0x1a, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x41, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x65,
0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0d, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e,
0x12, 0x3f, 0x0a, 0x05, 0x47, 0x65, 0x74, 0x54, 0x44, 0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65,
0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a,
0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48,
0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a,
0x65, 0x12, 0x47, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x1c, 0x05, 0x47, 0x65, 0x74, 0x54, 0x44, 0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69,
0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71,
0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x65, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x44, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47,
0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x07, 0x47, 0x65, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x65, 0x78,
0x74, 0x42, 0x6f, 0x64, 0x79, 0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65,
0x6e, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63,
0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52,
0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x07, 0x47, 0x65, 0x74, 0x42, 0x6f,
0x59, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x64, 0x79, 0x12, 0x1c, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47,
0x6e, 0x67, 0x65, 0x12, 0x22, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 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, 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, 0x12, 0x22, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74,
0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x61, 0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71,
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,
0x75, 0x65, 0x73, 0x74, 0x1a, 0x21, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 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, 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, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5b, 0x0a, 0x11, 0x47, 0x65, 0x74, 0x42, 0x6f,
0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x48, 0x61, 0x73, 0x68, 0x12, 0x0b, 0x2e, 0x74, 0x79, 0x70, 0x64, 0x69, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x12, 0x23, 0x2e, 0x65,
0x65, 0x73, 0x2e, 0x48, 0x32, 0x35, 0x36, 0x1a, 0x1e, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x42, 0x6f, 0x64, 0x69,
0x69, 0x6f, 0x6e, 0x2e, 0x49, 0x73, 0x43, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x42, 0x79, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x48, 0x65, 0x74, 0x1a, 0x21, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65,
0x61, 0x64, 0x65, 0x72, 0x48, 0x61, 0x73, 0x68, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x0b, 0x74, 0x42, 0x6f, 0x64, 0x69, 0x65, 0x73, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70,
0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e, 0x48, 0x32, 0x35, 0x36, 0x1a, 0x26, 0x2e, 0x65, 0x78, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0f, 0x49, 0x73, 0x43, 0x61, 0x6e, 0x6f, 0x6e, 0x69,
0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x63, 0x61, 0x6c, 0x48, 0x61, 0x73, 0x68, 0x12, 0x0b, 0x2e, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2e,
0x72, 0x48, 0x61, 0x73, 0x68, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x48, 0x32, 0x35, 0x36, 0x1a, 0x1e, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e,
0x6e, 0x73, 0x65, 0x12, 0x3e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x2e, 0x49, 0x73, 0x43, 0x61, 0x6e, 0x6f, 0x6e, 0x69, 0x63, 0x61, 0x6c, 0x52, 0x65, 0x73, 0x70,
0x6f, 0x69, 0x63, 0x65, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65,
0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x15, 0x2e, 0x65, 0x72, 0x48, 0x61, 0x73, 0x68, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x0b, 0x2e, 0x74, 0x79,
0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x70, 0x65, 0x73, 0x2e, 0x48, 0x32, 0x35, 0x36, 0x1a, 0x26, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75,
0x69, 0x63, 0x65, 0x12, 0x39, 0x0a, 0x05, 0x52, 0x65, 0x61, 0x64, 0x79, 0x12, 0x16, 0x2e, 0x67, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x47, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x48, 0x61,
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x73, 0x68, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
0x6d, 0x70, 0x74, 0x79, 0x1a, 0x18, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x46, 0x6f, 0x72, 0x6b, 0x43, 0x68, 0x6f, 0x69, 0x63,
0x2e, 0x52, 0x65, 0x61, 0x64, 0x79, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x17, 0x65, 0x12, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x5a, 0x15, 0x2e, 0x2f, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x65, 0x78, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x1a, 0x15, 0x2e, 0x65, 0x78, 0x65, 0x63,
0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 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 ( 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_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{}{ var file_execution_execution_proto_goTypes = []interface{}{
(ExecutionStatus)(0), // 0: execution.ExecutionStatus (ExecutionStatus)(0), // 0: execution.ExecutionStatus
(*ForkChoiceReceipt)(nil), // 1: execution.ForkChoiceReceipt (*ForkChoiceReceipt)(nil), // 1: execution.ForkChoiceReceipt
@ -1931,90 +1987,93 @@ var file_execution_execution_proto_goTypes = []interface{}{
(*GetBodiesByHashesRequest)(nil), // 22: execution.GetBodiesByHashesRequest (*GetBodiesByHashesRequest)(nil), // 22: execution.GetBodiesByHashesRequest
(*GetBodiesByRangeRequest)(nil), // 23: execution.GetBodiesByRangeRequest (*GetBodiesByRangeRequest)(nil), // 23: execution.GetBodiesByRangeRequest
(*ReadyResponse)(nil), // 24: execution.ReadyResponse (*ReadyResponse)(nil), // 24: execution.ReadyResponse
(*types.H256)(nil), // 25: types.H256 (*FrozenBlocksResponse)(nil), // 25: execution.FrozenBlocksResponse
(*types.H160)(nil), // 26: types.H160 (*types.H256)(nil), // 26: types.H256
(*types.H2048)(nil), // 27: types.H2048 (*types.H160)(nil), // 27: types.H160
(*types.Withdrawal)(nil), // 28: types.Withdrawal (*types.H2048)(nil), // 28: types.H2048
(*types.ExecutionPayload)(nil), // 29: types.ExecutionPayload (*types.Withdrawal)(nil), // 29: types.Withdrawal
(*types.BlobsBundleV1)(nil), // 30: types.BlobsBundleV1 (*types.ExecutionPayload)(nil), // 30: types.ExecutionPayload
(*emptypb.Empty)(nil), // 31: google.protobuf.Empty (*types.BlobsBundleV1)(nil), // 31: types.BlobsBundleV1
(*emptypb.Empty)(nil), // 32: google.protobuf.Empty
} }
var file_execution_execution_proto_depIdxs = []int32{ var file_execution_execution_proto_depIdxs = []int32{
0, // 0: execution.ForkChoiceReceipt.status:type_name -> execution.ExecutionStatus 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 0, // 2: execution.ValidationReceipt.validation_status:type_name -> execution.ExecutionStatus
25, // 3: execution.ValidationReceipt.latest_valid_hash:type_name -> types.H256 26, // 3: execution.ValidationReceipt.latest_valid_hash:type_name -> types.H256
25, // 4: execution.Header.parent_hash:type_name -> types.H256 26, // 4: execution.Header.parent_hash:type_name -> types.H256
26, // 5: execution.Header.coinbase:type_name -> types.H160 27, // 5: execution.Header.coinbase:type_name -> types.H160
25, // 6: execution.Header.state_root:type_name -> types.H256 26, // 6: execution.Header.state_root:type_name -> types.H256
25, // 7: execution.Header.receipt_root:type_name -> types.H256 26, // 7: execution.Header.receipt_root:type_name -> types.H256
27, // 8: execution.Header.logs_bloom:type_name -> types.H2048 28, // 8: execution.Header.logs_bloom:type_name -> types.H2048
25, // 9: execution.Header.prev_randao:type_name -> types.H256 26, // 9: execution.Header.prev_randao:type_name -> types.H256
25, // 10: execution.Header.difficulty:type_name -> types.H256 26, // 10: execution.Header.difficulty:type_name -> types.H256
25, // 11: execution.Header.block_hash:type_name -> types.H256 26, // 11: execution.Header.block_hash:type_name -> types.H256
25, // 12: execution.Header.ommer_hash:type_name -> types.H256 26, // 12: execution.Header.ommer_hash:type_name -> types.H256
25, // 13: execution.Header.transaction_hash:type_name -> types.H256 26, // 13: execution.Header.transaction_hash:type_name -> types.H256
25, // 14: execution.Header.base_fee_per_gas:type_name -> types.H256 26, // 14: execution.Header.base_fee_per_gas:type_name -> types.H256
25, // 15: execution.Header.withdrawal_hash:type_name -> types.H256 26, // 15: execution.Header.withdrawal_hash:type_name -> types.H256
25, // 16: execution.Header.parent_beacon_block_root:type_name -> types.H256 26, // 16: execution.Header.parent_beacon_block_root:type_name -> types.H256
25, // 17: execution.BlockBody.block_hash:type_name -> types.H256 26, // 17: execution.BlockBody.block_hash:type_name -> types.H256
4, // 18: execution.BlockBody.uncles:type_name -> execution.Header 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 4, // 20: execution.Block.header:type_name -> execution.Header
5, // 21: execution.Block.body:type_name -> execution.BlockBody 5, // 21: execution.Block.body:type_name -> execution.BlockBody
4, // 22: execution.GetHeaderResponse.header:type_name -> execution.Header 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 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 6, // 26: execution.InsertBlocksRequest.blocks:type_name -> execution.Block
25, // 27: execution.ForkChoice.head_block_hash:type_name -> types.H256 26, // 27: execution.ForkChoice.head_block_hash:type_name -> types.H256
25, // 28: execution.ForkChoice.finalized_block_hash:type_name -> types.H256 26, // 28: execution.ForkChoice.finalized_block_hash:type_name -> types.H256
25, // 29: execution.ForkChoice.safe_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 0, // 30: execution.InsertionResult.result:type_name -> execution.ExecutionStatus
25, // 31: execution.ValidationRequest.hash:type_name -> types.H256 26, // 31: execution.ValidationRequest.hash:type_name -> types.H256
25, // 32: execution.AssembleBlockRequest.parent_hash:type_name -> types.H256 26, // 32: execution.AssembleBlockRequest.parent_hash:type_name -> types.H256
25, // 33: execution.AssembleBlockRequest.prev_randao:type_name -> types.H256 26, // 33: execution.AssembleBlockRequest.prev_randao:type_name -> types.H256
26, // 34: execution.AssembleBlockRequest.suggested_fee_recipient:type_name -> types.H160 27, // 34: execution.AssembleBlockRequest.suggested_fee_recipient:type_name -> types.H160
28, // 35: execution.AssembleBlockRequest.withdrawals:type_name -> types.Withdrawal 29, // 35: execution.AssembleBlockRequest.withdrawals:type_name -> types.Withdrawal
25, // 36: execution.AssembleBlockRequest.parent_beacon_block_root:type_name -> types.H256 26, // 36: execution.AssembleBlockRequest.parent_beacon_block_root:type_name -> types.H256
29, // 37: execution.AssembledBlockData.execution_payload:type_name -> types.ExecutionPayload 30, // 37: execution.AssembledBlockData.execution_payload:type_name -> types.ExecutionPayload
25, // 38: execution.AssembledBlockData.block_value:type_name -> types.H256 26, // 38: execution.AssembledBlockData.block_value:type_name -> types.H256
30, // 39: execution.AssembledBlockData.blobs_bundle:type_name -> types.BlobsBundleV1 31, // 39: execution.AssembledBlockData.blobs_bundle:type_name -> types.BlobsBundleV1
19, // 40: execution.GetAssembledBlockResponse.data:type_name -> execution.AssembledBlockData 19, // 40: execution.GetAssembledBlockResponse.data:type_name -> execution.AssembledBlockData
5, // 41: execution.GetBodiesBatchResponse.bodies:type_name -> execution.BlockBody 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 12, // 43: execution.Execution.InsertBlocks:input_type -> execution.InsertBlocksRequest
15, // 44: execution.Execution.ValidateChain:input_type -> execution.ValidationRequest 15, // 44: execution.Execution.ValidateChain:input_type -> execution.ValidationRequest
13, // 45: execution.Execution.UpdateForkChoice:input_type -> execution.ForkChoice 13, // 45: execution.Execution.UpdateForkChoice:input_type -> execution.ForkChoice
16, // 46: execution.Execution.AssembleBlock:input_type -> execution.AssembleBlockRequest 16, // 46: execution.Execution.AssembleBlock:input_type -> execution.AssembleBlockRequest
18, // 47: execution.Execution.GetAssembledBlock:input_type -> execution.GetAssembledBlockRequest 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, // 49: execution.Execution.GetTD:input_type -> execution.GetSegmentRequest
11, // 50: execution.Execution.GetHeader:input_type -> execution.GetSegmentRequest 11, // 50: execution.Execution.GetHeader:input_type -> execution.GetSegmentRequest
11, // 51: execution.Execution.GetBody:input_type -> execution.GetSegmentRequest 11, // 51: execution.Execution.GetBody:input_type -> execution.GetSegmentRequest
23, // 52: execution.Execution.GetBodiesByRange:input_type -> execution.GetBodiesByRangeRequest 23, // 52: execution.Execution.GetBodiesByRange:input_type -> execution.GetBodiesByRangeRequest
22, // 53: execution.Execution.GetBodiesByHashes:input_type -> execution.GetBodiesByHashesRequest 22, // 53: execution.Execution.GetBodiesByHashes:input_type -> execution.GetBodiesByHashesRequest
25, // 54: execution.Execution.IsCanonicalHash:input_type -> types.H256 26, // 54: execution.Execution.IsCanonicalHash:input_type -> types.H256
25, // 55: execution.Execution.GetHeaderHashNumber:input_type -> types.H256 26, // 55: execution.Execution.GetHeaderHashNumber:input_type -> types.H256
31, // 56: execution.Execution.GetForkChoice:input_type -> google.protobuf.Empty 32, // 56: execution.Execution.GetForkChoice:input_type -> google.protobuf.Empty
31, // 57: execution.Execution.Ready:input_type -> google.protobuf.Empty 32, // 57: execution.Execution.Ready:input_type -> google.protobuf.Empty
14, // 58: execution.Execution.InsertBlocks:output_type -> execution.InsertionResult 32, // 58: execution.Execution.FrozenBlocks:input_type -> google.protobuf.Empty
2, // 59: execution.Execution.ValidateChain:output_type -> execution.ValidationReceipt 14, // 59: execution.Execution.InsertBlocks:output_type -> execution.InsertionResult
1, // 60: execution.Execution.UpdateForkChoice:output_type -> execution.ForkChoiceReceipt 2, // 60: execution.Execution.ValidateChain:output_type -> execution.ValidationReceipt
17, // 61: execution.Execution.AssembleBlock:output_type -> execution.AssembleBlockResponse 1, // 61: execution.Execution.UpdateForkChoice:output_type -> execution.ForkChoiceReceipt
20, // 62: execution.Execution.GetAssembledBlock:output_type -> execution.GetAssembledBlockResponse 17, // 62: execution.Execution.AssembleBlock:output_type -> execution.AssembleBlockResponse
7, // 63: execution.Execution.CurrentHeader:output_type -> execution.GetHeaderResponse 20, // 63: execution.Execution.GetAssembledBlock:output_type -> execution.GetAssembledBlockResponse
8, // 64: execution.Execution.GetTD:output_type -> execution.GetTDResponse 7, // 64: execution.Execution.CurrentHeader:output_type -> execution.GetHeaderResponse
7, // 65: execution.Execution.GetHeader:output_type -> execution.GetHeaderResponse 8, // 65: execution.Execution.GetTD:output_type -> execution.GetTDResponse
9, // 66: execution.Execution.GetBody:output_type -> execution.GetBodyResponse 7, // 66: execution.Execution.GetHeader:output_type -> execution.GetHeaderResponse
21, // 67: execution.Execution.GetBodiesByRange:output_type -> execution.GetBodiesBatchResponse 9, // 67: execution.Execution.GetBody:output_type -> execution.GetBodyResponse
21, // 68: execution.Execution.GetBodiesByHashes:output_type -> execution.GetBodiesBatchResponse 21, // 68: execution.Execution.GetBodiesByRange:output_type -> execution.GetBodiesBatchResponse
3, // 69: execution.Execution.IsCanonicalHash:output_type -> execution.IsCanonicalResponse 21, // 69: execution.Execution.GetBodiesByHashes:output_type -> execution.GetBodiesBatchResponse
10, // 70: execution.Execution.GetHeaderHashNumber:output_type -> execution.GetHeaderHashNumberResponse 3, // 70: execution.Execution.IsCanonicalHash:output_type -> execution.IsCanonicalResponse
13, // 71: execution.Execution.GetForkChoice:output_type -> execution.ForkChoice 10, // 71: execution.Execution.GetHeaderHashNumber:output_type -> execution.GetHeaderHashNumberResponse
24, // 72: execution.Execution.Ready:output_type -> execution.ReadyResponse 13, // 72: execution.Execution.GetForkChoice:output_type -> execution.ForkChoice
58, // [58:73] is the sub-list for method output_type 24, // 73: execution.Execution.Ready:output_type -> execution.ReadyResponse
43, // [43:58] is the sub-list for method input_type 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 type_name
43, // [43:43] is the sub-list for extension extendee 43, // [43:43] is the sub-list for extension extendee
0, // [0:43] is the sub-list for field type_name 0, // [0:43] is the sub-list for field type_name
@ -2314,6 +2373,18 @@ func file_execution_execution_proto_init() {
return nil 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[3].OneofWrappers = []interface{}{}
file_execution_execution_proto_msgTypes[6].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(), GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_execution_execution_proto_rawDesc, RawDescriptor: file_execution_execution_proto_rawDesc,
NumEnums: 1, NumEnums: 1,
NumMessages: 24, NumMessages: 25,
NumExtensions: 0, NumExtensions: 0,
NumServices: 1, NumServices: 1,
}, },

39
erigon-lib/gointerfaces/execution/execution_grpc.pb.go
View File

@ -36,6 +36,7 @@ const (
Execution_GetHeaderHashNumber_FullMethodName = "/execution.Execution/GetHeaderHashNumber" Execution_GetHeaderHashNumber_FullMethodName = "/execution.Execution/GetHeaderHashNumber"
Execution_GetForkChoice_FullMethodName = "/execution.Execution/GetForkChoice" Execution_GetForkChoice_FullMethodName = "/execution.Execution/GetForkChoice"
Execution_Ready_FullMethodName = "/execution.Execution/Ready" Execution_Ready_FullMethodName = "/execution.Execution/Ready"
Execution_FrozenBlocks_FullMethodName = "/execution.Execution/FrozenBlocks"
) )
// ExecutionClient is the client API for Execution service. // ExecutionClient is the client API for Execution service.
@ -66,6 +67,8 @@ type ExecutionClient interface {
// Misc // Misc
// We want to figure out whether we processed snapshots and cleanup sync cycles. // 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) 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 { type executionClient struct {
@ -211,6 +214,15 @@ func (c *executionClient) Ready(ctx context.Context, in *emptypb.Empty, opts ...
return out, nil 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. // ExecutionServer is the server API for Execution service.
// All implementations must embed UnimplementedExecutionServer // All implementations must embed UnimplementedExecutionServer
// for forward compatibility // for forward compatibility
@ -239,6 +251,8 @@ type ExecutionServer interface {
// Misc // Misc
// We want to figure out whether we processed snapshots and cleanup sync cycles. // We want to figure out whether we processed snapshots and cleanup sync cycles.
Ready(context.Context, *emptypb.Empty) (*ReadyResponse, error) 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() mustEmbedUnimplementedExecutionServer()
} }
@ -291,6 +305,9 @@ func (UnimplementedExecutionServer) GetForkChoice(context.Context, *emptypb.Empt
func (UnimplementedExecutionServer) Ready(context.Context, *emptypb.Empty) (*ReadyResponse, error) { func (UnimplementedExecutionServer) Ready(context.Context, *emptypb.Empty) (*ReadyResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Ready not implemented") 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() {} func (UnimplementedExecutionServer) mustEmbedUnimplementedExecutionServer() {}
// UnsafeExecutionServer may be embedded to opt out of forward compatibility for this service. // 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) 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. // Execution_ServiceDesc is the grpc.ServiceDesc for Execution service.
// It's only intended for direct use with grpc.RegisterService, // It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy) // and not to be introspected or modified (even as a copy)
@ -641,6 +676,10 @@ var Execution_ServiceDesc = grpc.ServiceDesc{
MethodName: "Ready", MethodName: "Ready",
Handler: _Execution_Ready_Handler, Handler: _Execution_Ready_Handler,
}, },
{
MethodName: "FrozenBlocks",
Handler: _Execution_FrozenBlocks_Handler,
},
}, },
Streams: []grpc.StreamDesc{}, Streams: []grpc.StreamDesc{},
Metadata: "execution/execution.proto", Metadata: "execution/execution.proto",

105
erigon-lib/gointerfaces/sentinel/sentinel.pb.go
View File

@ -25,13 +25,13 @@ type GossipType int32
const ( const (
// Global gossip topics. // Global gossip topics.
GossipType_BeaconBlockGossipType GossipType = 0 GossipType_BeaconBlockGossipType GossipType = 0
GossipType_AggregateAndProofGossipType GossipType = 1 GossipType_AggregateAndProofGossipType GossipType = 1
GossipType_VoluntaryExitGossipType GossipType = 2 GossipType_VoluntaryExitGossipType GossipType = 2
GossipType_ProposerSlashingGossipType GossipType = 3 GossipType_ProposerSlashingGossipType GossipType = 3
GossipType_AttesterSlashingGossipType GossipType = 4 GossipType_AttesterSlashingGossipType GossipType = 4
GossipType_BlobSidecarType GossipType = 5 GossipType_BlobSidecarType GossipType = 5
GossipType_BlsToExecutionChangeType GossipType = 6 GossipType_BlsToExecutionChangeGossipType GossipType = 6
) )
// Enum value maps for GossipType. // Enum value maps for GossipType.
@ -43,16 +43,16 @@ var (
3: "ProposerSlashingGossipType", 3: "ProposerSlashingGossipType",
4: "AttesterSlashingGossipType", 4: "AttesterSlashingGossipType",
5: "BlobSidecarType", 5: "BlobSidecarType",
6: "BlsToExecutionChangeType", 6: "BlsToExecutionChangeGossipType",
} }
GossipType_value = map[string]int32{ GossipType_value = map[string]int32{
"BeaconBlockGossipType": 0, "BeaconBlockGossipType": 0,
"AggregateAndProofGossipType": 1, "AggregateAndProofGossipType": 1,
"VoluntaryExitGossipType": 2, "VoluntaryExitGossipType": 2,
"ProposerSlashingGossipType": 3, "ProposerSlashingGossipType": 3,
"AttesterSlashingGossipType": 4, "AttesterSlashingGossipType": 4,
"BlobSidecarType": 5, "BlobSidecarType": 5,
"BlsToExecutionChangeType": 6, "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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 0x62, 0x53, 0x69, 0x64, 0x65, 0x63, 0x61, 0x72, 0x54, 0x79, 0x70, 0x65, 0x10, 0x05, 0x12, 0x22,
0x0a, 0x18, 0x42, 0x6c, 0x73, 0x54, 0x6f, 0x45, 0x78, 0x65, 0x63, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x0a, 0x1e, 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, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x54, 0x79, 0x70, 0x65,
0x08, 0x53, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x12, 0x41, 0x0a, 0x0f, 0x53, 0x75, 0x62, 0x10, 0x06, 0x32, 0x90, 0x04, 0x0a, 0x08, 0x53, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x12,
0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x12, 0x16, 0x2e, 0x73, 0x41, 0x0a, 0x0f, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x47, 0x6f, 0x73, 0x73,
0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x69, 0x70, 0x12, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d,
0x73, 0x61, 0x67, 0x65, 0x1a, 0x14, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x14, 0x2e, 0x73, 0x65, 0x6e,
0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x44, 0x61, 0x74, 0x61, 0x30, 0x01, 0x12, 0x3c, 0x0a, 0x0b, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x44, 0x61, 0x74, 0x61,
0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x15, 0x2e, 0x73, 0x65, 0x30, 0x01, 0x12, 0x3c, 0x0a, 0x0b, 0x53, 0x65, 0x6e, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x44, 0x61, 0x74, 0x12, 0x15, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x52, 0x65, 0x71,
0x74, 0x61, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x52, 0x65, 0x75, 0x65, 0x73, 0x74, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x44, 0x61, 0x74, 0x61, 0x12, 0x35, 0x0a, 0x09, 0x53, 0x65, 0x6e, 0x65, 0x6c, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x44, 0x61, 0x74, 0x61,
0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x10, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x12, 0x35, 0x0a, 0x09, 0x53, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x10, 0x2e,
0x65, 0x6c, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a,
0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79,
0x65, 0x12, 0x37, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x73, 0x12, 0x16, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x37, 0x0a, 0x08, 0x47, 0x65, 0x74, 0x50, 0x65,
0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x65, 0x72, 0x73, 0x12, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45,
0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x13, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x13, 0x2e, 0x73, 0x65,
0x2e, 0x50, 0x65, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x31, 0x0a, 0x07, 0x42, 0x61, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x43, 0x6f, 0x75, 0x6e, 0x74,
0x6e, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x12, 0x31, 0x0a, 0x07, 0x42, 0x61, 0x6e, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65,
0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x73, 0x65,
0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x33, 0x0a, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73,
0x09, 0x55, 0x6e, 0x62, 0x61, 0x6e, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x61, 0x67, 0x65, 0x12, 0x33, 0x0a, 0x09, 0x55, 0x6e, 0x62, 0x61, 0x6e, 0x50, 0x65, 0x65, 0x72,
0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72,
0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74,
0x67, 0x65, 0x12, 0x36, 0x0a, 0x0c, 0x50, 0x65, 0x6e, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x50, 0x65, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x36, 0x0a, 0x0c, 0x50, 0x65, 0x6e, 0x61,
0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x6c, 0x69, 0x7a, 0x65, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69,
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,
0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16, 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, 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, 0x12, 0x34, 0x0a, 0x0a, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x50, 0x65, 0x65, 0x72, 0x12, 0x0e,
0x70, 0x12, 0x14, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x47, 0x6f, 0x73, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x1a, 0x16,
0x73, 0x69, 0x70, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x16, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d,
0x65, 0x6c, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x42, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x3d, 0x0a, 0x0d, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x73,
0x15, 0x5a, 0x13, 0x2e, 0x2f, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x3b, 0x73, 0x65, 0x68, 0x47, 0x6f, 0x73, 0x73, 0x69, 0x70, 0x12, 0x14, 0x2e, 0x73, 0x65, 0x6e, 0x74, 0x69, 0x6e,
0x6e, 0x74, 0x69, 0x6e, 0x65, 0x6c, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 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 ( var (

3
eth/backend.go
View File

@ -82,7 +82,7 @@ import (
types2 "github.com/ledgerwatch/erigon-lib/types" types2 "github.com/ledgerwatch/erigon-lib/types"
clcore "github.com/ledgerwatch/erigon/cl/phase1/core" 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/rpcdaemon/cli"
"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel" "github.com/ledgerwatch/erigon/cmd/sentinel/sentinel"
"github.com/ledgerwatch/erigon/cmd/sentinel/sentinel/service" "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, inMemoryExecution := func(batch kv.RwTx, header *types.Header, body *types.RawBody, unwindPoint uint64, headersChain []*types.Header, bodiesChain []*types.RawBody,
notifications *shards.Notifications) error { notifications *shards.Notifications) error {
terseLogger := log.New() terseLogger := log.New()

8
turbo/execution/eth1/eth1_chain_reader.go/chain_reader.go
View File

@ -247,8 +247,12 @@ func (c ChainReaderWriterEth1) IsCanonicalHash(hash libcommon.Hash) (bool, error
return resp.Canonical, nil return resp.Canonical, nil
} }
func (ChainReaderWriterEth1) FrozenBlocks() uint64 { func (c ChainReaderWriterEth1) FrozenBlocks() uint64 {
panic("ChainReaderEth1.FrozenBlocks not implemented") ret, err := c.executionModule.FrozenBlocks(c.ctx, &emptypb.Empty{})
if err != nil {
panic(err)
}
return ret.FrozenBlocks
} }
const retryTimeout = 10 * time.Millisecond const retryTimeout = 10 * time.Millisecond

6
turbo/execution/eth1/getters.go
View File

@ -294,3 +294,9 @@ func (e *EthereumExecutionModule) GetForkChoice(ctx context.Context, _ *emptypb.
SafeBlockHash: gointerfaces.ConvertHashToH256(rawdb.ReadForkchoiceSafe(tx)), SafeBlockHash: gointerfaces.ConvertHashToH256(rawdb.ReadForkchoiceSafe(tx)),
}, nil }, nil
} }
func (e *EthereumExecutionModule) FrozenBlocks(ctx context.Context, _ *emptypb.Empty) (*execution.FrozenBlocksResponse, error) {
return &execution.FrozenBlocksResponse{
FrozenBlocks: e.blockReader.FrozenBlocks(),
}, nil
}