From 2cf7fa01748df4dba855a3e41b437edd3f99b8e4 Mon Sep 17 00:00:00 2001 From: Nishant Das Date: Tue, 7 Aug 2018 20:12:10 +0800 Subject: [PATCH] Check Last Finalized Epoch (#357) * Adding proto topics * Adding crystallized state request * Reverting shanges to proto * Adding db checks * get crystallised state * Finalize epoch for mapping * more changes * cleaning up main routine * adding tests * fix test * Adding ability to save blocks * Adding block fetcher * Another test for setting finalized epoch * adding final tests * finished tests * adding comments * gazelle * Making requested changes * Fixing lint * stop sync from exiting * fixing lint * lint * Adding new request type to proto * Making changes to block/state requests * Change tests * fixing error messages * gazelle and lint * adding back crystallised state * fix tests * Fixing merge conflicts * Addressing review comments * Changing back to one service * removing case --- beacon-chain/blockchain/core.go | 16 ++ beacon-chain/blockchain/service.go | 25 +++ beacon-chain/sync/service.go | 240 ++++++++++++++++++++++++--- beacon-chain/sync/service_test.go | 232 +++++++++++++++++++++++++- beacon-chain/types/block.go | 5 + beacon-chain/types/interfaces.go | 2 + proto/beacon/p2p/v1/messages.pb.go | 202 +++++++++++++--------- proto/beacon/p2p/v1/messages.proto | 4 + proto/sharding/p2p/v1/messages.pb.go | 158 +++++++++--------- proto/sharding/p2p/v1/messages.proto | 15 +- shared/p2p/topics.go | 25 +-- 11 files changed, 722 insertions(+), 202 deletions(-) diff --git a/beacon-chain/blockchain/core.go b/beacon-chain/blockchain/core.go index dddee302813..bdf5c475311 100644 --- a/beacon-chain/blockchain/core.go +++ b/beacon-chain/blockchain/core.go @@ -346,3 +346,19 @@ func (b *BeaconChain) resetAttesterBitfield() { newbitfields := make([]byte, b.CrystallizedState().ActiveValidatorsLength()/8) b.state.ActiveState.SetAttesterBitfield(newbitfields) } + +func (b *BeaconChain) saveBlock(block *types.Block) error { + encodedState, err := block.Marshal() + if err != nil { + return err + } + hash, err := block.Hash() + if err != nil { + return err + } + + return b.db.Put(hash[:], encodedState) +} + +// Slashing Condtions +// TODO: Implement all the conditions and add in the methods once the spec is updated diff --git a/beacon-chain/blockchain/service.go b/beacon-chain/blockchain/service.go index e4a87782148..1d2d340f01e 100644 --- a/beacon-chain/blockchain/service.go +++ b/beacon-chain/blockchain/service.go @@ -68,6 +68,25 @@ func (c *ChainService) Stop() error { return nil } +// HasStoredState checks if there is any Crystallized/Active State or blocks(not implemented) are +// persisted to the db. +func (c *ChainService) HasStoredState() (bool, error) { + + hasActive, err := c.beaconDB.DB().Has([]byte(activeStateLookupKey)) + if err != nil { + return false, err + } + hasCrystallized, err := c.beaconDB.DB().Has([]byte(crystallizedStateLookupKey)) + if err != nil { + return false, err + } + if !hasActive || !hasCrystallized { + return false, nil + } + + return true, nil +} + // ProcessedBlockHashes by the chain service. func (c *ChainService) ProcessedBlockHashes() [][32]byte { return c.processedBlockHashes @@ -100,6 +119,12 @@ func (c *ChainService) ProcessBlock(block *types.Block) error { return nil } +// SaveBlock is a mock which saves a block to the local db using the +// blockhash as the key. +func (c *ChainService) SaveBlock(block *types.Block) error { + return c.chain.saveBlock(block) +} + // ProcessCrystallizedState accepts a new crystallized state object for inclusion in the chain. func (c *ChainService) ProcessCrystallizedState(state *types.CrystallizedState) error { h, err := state.Hash() diff --git a/beacon-chain/sync/service.go b/beacon-chain/sync/service.go index 8d744651d4b..1975a4e8f3a 100644 --- a/beacon-chain/sync/service.go +++ b/beacon-chain/sync/service.go @@ -3,6 +3,7 @@ package sync import ( "context" "fmt" + "time" "github.com/prysmaticlabs/prysm/beacon-chain/types" pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1" @@ -25,16 +26,21 @@ var log = logrus.WithField("prefix", "sync") // * Drop peers that send invalid data // * Throttle incoming requests type Service struct { - ctx context.Context - cancel context.CancelFunc - p2p types.P2P - chainService types.ChainService - announceBlockHashBuf chan p2p.Message - blockBuf chan p2p.Message - announceCrystallizedHashBuf chan p2p.Message - crystallizedStateBuf chan p2p.Message - announceActiveHashBuf chan p2p.Message - activeStateBuf chan p2p.Message + ctx context.Context + cancel context.CancelFunc + p2p types.P2P + chainService types.ChainService + announceBlockHashBuf chan p2p.Message + blockBuf chan p2p.Message + announceCrystallizedHashBuf chan p2p.Message + crystallizedStateBuf chan p2p.Message + announceActiveHashBuf chan p2p.Message + activeStateBuf chan p2p.Message + syncMode Mode + currentSlotNumber uint64 + highestObservedSlot uint64 + syncPollingInterval time.Duration + initialCrystallizedStateHash [32]byte } // Config allows the channel's buffer sizes to be changed. @@ -45,11 +51,23 @@ type Config struct { ActiveStateBufferSize int CrystallizedStateHashBufferSize int CrystallizedStateBufferSize int + SyncMode Mode + CurrentSlotNumber uint64 + HighestObservedSlot uint64 + SyncPollingInterval time.Duration } +// Mode refers to the type for the sync mode of the client. +type Mode int + +// This specifies the different sync modes. +const ( + SyncModeInitial Mode = 0 + SyncModeDefault Mode = 1 +) + // DefaultConfig provides the default configuration for a sync service. func DefaultConfig() Config { - return Config{ BlockHashBufferSize: 100, BlockBufferSize: 100, @@ -57,30 +75,56 @@ func DefaultConfig() Config { ActiveStateBufferSize: 100, CrystallizedStateHashBufferSize: 100, CrystallizedStateBufferSize: 100, + SyncMode: SyncModeDefault, + CurrentSlotNumber: 0, + HighestObservedSlot: 0, + SyncPollingInterval: time.Second, } } // NewSyncService accepts a context and returns a new Service. func NewSyncService(ctx context.Context, cfg Config, beaconp2p types.P2P, cs types.ChainService) *Service { + ctx, cancel := context.WithCancel(ctx) + stored, err := cs.HasStoredState() + + if err != nil { + log.Errorf("error retrieving stored state: %v", err) + } + + if !stored { + cfg.SyncMode = SyncModeInitial + } + return &Service{ - ctx: ctx, - cancel: cancel, - p2p: beaconp2p, - chainService: cs, - announceBlockHashBuf: make(chan p2p.Message, cfg.BlockHashBufferSize), - blockBuf: make(chan p2p.Message, cfg.BlockBufferSize), - announceCrystallizedHashBuf: make(chan p2p.Message, cfg.ActiveStateHashBufferSize), - crystallizedStateBuf: make(chan p2p.Message, cfg.ActiveStateBufferSize), - announceActiveHashBuf: make(chan p2p.Message, cfg.CrystallizedStateHashBufferSize), - activeStateBuf: make(chan p2p.Message, cfg.CrystallizedStateBufferSize), + ctx: ctx, + cancel: cancel, + p2p: beaconp2p, + chainService: cs, + announceBlockHashBuf: make(chan p2p.Message, cfg.BlockHashBufferSize), + blockBuf: make(chan p2p.Message, cfg.BlockBufferSize), + announceCrystallizedHashBuf: make(chan p2p.Message, cfg.ActiveStateHashBufferSize), + crystallizedStateBuf: make(chan p2p.Message, cfg.ActiveStateBufferSize), + announceActiveHashBuf: make(chan p2p.Message, cfg.CrystallizedStateHashBufferSize), + activeStateBuf: make(chan p2p.Message, cfg.CrystallizedStateBufferSize), + syncMode: cfg.SyncMode, + currentSlotNumber: cfg.CurrentSlotNumber, + highestObservedSlot: cfg.HighestObservedSlot, + syncPollingInterval: cfg.SyncPollingInterval, + initialCrystallizedStateHash: [32]byte{}, } } // Start begins the block processing goroutine. func (ss *Service) Start() { - log.Info("Starting service") - go ss.run(ss.ctx.Done()) + switch ss.syncMode { + case 0: + log.Info("Starting initial sync") + go ss.initialSync(time.NewTicker(ss.syncPollingInterval).C, ss.ctx.Done()) + default: + go ss.run(ss.ctx.Done()) + + } } // Stop kills the block processing goroutine, but does not wait until the goroutine exits. @@ -197,6 +241,156 @@ func (ss *Service) ReceiveActiveState(data *pb.ActiveState) error { return nil } +// RequestCrystallizedStateFromPeer sends a request to a peer for the corresponding crystallized state +// for a beacon block. +func (ss *Service) RequestCrystallizedStateFromPeer(data *pb.BeaconBlockResponse, peer p2p.Peer) error { + block, err := types.NewBlock(data.Block) + if err != nil { + return fmt.Errorf("could not instantiate new block from proto: %v", err) + } + h := block.CrystallizedStateHash() + log.Debugf("Successfully processed incoming block with crystallized state hash: %x", h) + ss.p2p.Send(&pb.CrystallizedStateRequest{Hash: h[:]}, peer) + return nil +} + +// SetBlockForInitialSync sets the first received block as the base finalized +// block for initial sync. +func (ss *Service) SetBlockForInitialSync(data *pb.BeaconBlockResponse) error { + + block, err := types.NewBlock(data.Block) + if err != nil { + return fmt.Errorf("could not instantiate new block from proto: %v", err) + } + + h, err := block.Hash() + if err != nil { + return err + } + log.WithField("Block received with hash", fmt.Sprintf("0x%x", h)).Debug("Crystallized state hash exists locally") + + if err := ss.writeBlockToDB(block); err != nil { + return err + } + + ss.initialCrystallizedStateHash = block.CrystallizedStateHash() + + log.Infof("Saved block with hash 0%x for initial sync", h) + return nil +} + +// requestNextBlock broadcasts a request for a block with the next slotnumber. +func (ss *Service) requestNextBlock() { + ss.p2p.Broadcast(&pb.BeaconBlockRequestBySlotNumber{SlotNumber: (ss.currentSlotNumber + 1)}) +} + +// validateAndSaveNextBlock will validate whether blocks received from the blockfetcher +// routine can be added to the chain. +func (ss *Service) validateAndSaveNextBlock(data *pb.BeaconBlockResponse) error { + block, err := types.NewBlock(data.Block) + if err != nil { + return fmt.Errorf("could not instantiate new block from proto: %v", err) + } + + if ss.currentSlotNumber == uint64(0) { + return fmt.Errorf("invalid slot number for syncing") + } + + if (ss.currentSlotNumber + 1) == block.SlotNumber() { + + if err := ss.writeBlockToDB(block); err != nil { + return err + } + ss.currentSlotNumber = block.SlotNumber() + } + return nil +} + +// writeBlockToDB saves the corresponding block to the local DB. +func (ss *Service) writeBlockToDB(block *types.Block) error { + return ss.chainService.SaveBlock(block) +} + +func (ss *Service) initialSync(delaychan <-chan time.Time, done <-chan struct{}) { + blockSub := ss.p2p.Subscribe(pb.BeaconBlockResponse{}, ss.blockBuf) + crystallizedStateSub := ss.p2p.Subscribe(pb.CrystallizedStateResponse{}, ss.crystallizedStateBuf) + + defer blockSub.Unsubscribe() + defer crystallizedStateSub.Unsubscribe() + for { + select { + case <-done: + log.Infof("Exiting goroutine") + return + case <-delaychan: + if ss.highestObservedSlot == ss.currentSlotNumber { + log.Infof("Exiting initial sync and starting normal sync") + go ss.run(ss.ctx.Done()) + return + } + case msg := <-ss.blockBuf: + data, ok := msg.Data.(*pb.BeaconBlockResponse) + // TODO: Handle this at p2p layer. + if !ok { + log.Errorf("Received malformed beacon block p2p message") + continue + } + + if data.Block.GetSlotNumber() > ss.highestObservedSlot { + ss.highestObservedSlot = data.Block.GetSlotNumber() + } + + if ss.currentSlotNumber == 0 { + if ss.initialCrystallizedStateHash != [32]byte{} { + continue + } + if err := ss.SetBlockForInitialSync(data); err != nil { + log.Errorf("Could not set block for initial sync: %v", err) + } + if err := ss.RequestCrystallizedStateFromPeer(data, msg.Peer); err != nil { + log.Errorf("Could not request crystallized state from peer: %v", err) + } + + continue + } + + if data.Block.GetSlotNumber() != (ss.currentSlotNumber + 1) { + continue + } + + if err := ss.validateAndSaveNextBlock(data); err != nil { + log.Errorf("Unable to save block: %v", err) + } + ss.requestNextBlock() + case msg := <-ss.crystallizedStateBuf: + data, ok := msg.Data.(*pb.CrystallizedStateResponse) + // TODO: Handle this at p2p layer. + if !ok { + log.Errorf("Received malformed crystallized state p2p message") + continue + } + + if ss.initialCrystallizedStateHash == [32]byte{} { + continue + } + + crystallizedState := types.NewCrystallizedState(data.CrystallizedState) + hash, err := crystallizedState.Hash() + if err != nil { + log.Errorf("Unable to hash crytsallized state: %v", err) + } + + if hash != ss.initialCrystallizedStateHash { + continue + } + + ss.currentSlotNumber = crystallizedState.LastFinalizedEpoch() + ss.requestNextBlock() + crystallizedStateSub.Unsubscribe() + } + } +} + func (ss *Service) run(done <-chan struct{}) { announceBlockHashSub := ss.p2p.Subscribe(pb.BeaconBlockHashAnnounce{}, ss.announceBlockHashBuf) blockSub := ss.p2p.Subscribe(pb.BeaconBlockResponse{}, ss.blockBuf) diff --git a/beacon-chain/sync/service_test.go b/beacon-chain/sync/service_test.go index 08f1f2bcb4a..9964db53869 100644 --- a/beacon-chain/sync/service_test.go +++ b/beacon-chain/sync/service_test.go @@ -3,6 +3,7 @@ package sync import ( "context" "testing" + "time" "github.com/ethereum/go-ethereum/event" "github.com/prysmaticlabs/prysm/beacon-chain/types" @@ -13,7 +14,8 @@ import ( "golang.org/x/crypto/blake2b" ) -type mockP2P struct{} +type mockP2P struct { +} func (mp *mockP2P) Subscribe(msg interface{}, channel interface{}) event.Subscription { return new(event.Feed).Subscribe(channel) @@ -21,7 +23,8 @@ func (mp *mockP2P) Subscribe(msg interface{}, channel interface{}) event.Subscri func (mp *mockP2P) Broadcast(msg interface{}) {} -func (mp *mockP2P) Send(msg interface{}, peer p2p.Peer) {} +func (mp *mockP2P) Send(msg interface{}, peer p2p.Peer) { +} type mockChainService struct { processedBlockHashes [][32]byte @@ -107,6 +110,14 @@ func (ms *mockChainService) ProcessedCrystallizedStateHashes() [][32]byte { return ms.processedCrystallizedHashes } +func (ms *mockChainService) HasStoredState() (bool, error) { + return false, nil +} + +func (ms *mockChainService) SaveBlock(block *types.Block) error { + return nil +} + func TestProcessBlockHash(t *testing.T) { hook := logTest.NewGlobal() @@ -685,3 +696,220 @@ func TestProcessSameActiveState(t *testing.T) { hook.Reset() } + +func TestSetBlockForInitialSync(t *testing.T) { + hook := logTest.NewGlobal() + + cfg := Config{BlockBufferSize: 0, CrystallizedStateBufferSize: 0} + ms := &mockChainService{} + ss := NewSyncService(context.Background(), cfg, &mockP2P{}, ms) + + exitRoutine := make(chan bool) + delayChan := make(chan time.Time) + + go func() { + ss.initialSync(delayChan, ss.ctx.Done()) + exitRoutine <- true + }() + + generichash := make([]byte, 32) + generichash[0] = 'a' + + block := &pb.BeaconBlock{ + MainChainRef: []byte{1, 2, 3}, + ParentHash: generichash, + SlotNumber: uint64(20), + CrystallizedStateHash: generichash, + } + + blockResponse := &pb.BeaconBlockResponse{Block: block} + + msg1 := p2p.Message{ + Peer: p2p.Peer{}, + Data: blockResponse, + } + + ss.blockBuf <- msg1 + + ss.cancel() + <-exitRoutine + + var hash [32]byte + copy(hash[:], blockResponse.Block.CrystallizedStateHash) + + if hash != ss.initialCrystallizedStateHash { + t.Fatalf("Crystallized state hash not updated: %x", blockResponse.Block.CrystallizedStateHash) + } + + hook.Reset() + +} + +func TestSavingBlocksInSync(t *testing.T) { + hook := logTest.NewGlobal() + + cfg := Config{BlockBufferSize: 0, CrystallizedStateBufferSize: 0} + ms := &mockChainService{} + ss := NewSyncService(context.Background(), cfg, &mockP2P{}, ms) + + exitRoutine := make(chan bool) + delayChan := make(chan time.Time) + + go func() { + ss.initialSync(delayChan, ss.ctx.Done()) + exitRoutine <- true + }() + + generichash := make([]byte, 32) + generichash[0] = 'a' + + crystallizedState := &pb.CrystallizedState{ + LastFinalizedEpoch: 99, + } + + stateResponse := &pb.CrystallizedStateResponse{ + CrystallizedState: crystallizedState, + } + + incorrectState := &pb.CrystallizedState{ + LastFinalizedEpoch: 9, + LastJustifiedEpoch: 20, + } + + incorrectStateResponse := &pb.CrystallizedStateResponse{ + CrystallizedState: incorrectState, + } + + crystallizedStateHash, err := types.NewCrystallizedState(crystallizedState).Hash() + if err != nil { + t.Fatalf("unable to get hash of crystallized state: %v", err) + } + + block := &pb.BeaconBlock{ + MainChainRef: []byte{1, 2, 3}, + ParentHash: generichash, + SlotNumber: uint64(20), + CrystallizedStateHash: crystallizedStateHash[:], + } + + blockResponse := &pb.BeaconBlockResponse{ + Block: block, + } + + msg1 := p2p.Message{ + Peer: p2p.Peer{}, + Data: blockResponse, + } + + msg2 := p2p.Message{ + Peer: p2p.Peer{}, + Data: incorrectStateResponse, + } + + ss.blockBuf <- msg1 + ss.crystallizedStateBuf <- msg2 + + if ss.currentSlotNumber == incorrectStateResponse.CrystallizedState.LastFinalizedEpoch { + t.Fatalf("Crystallized state updated incorrectly: %x", ss.currentSlotNumber) + } + + msg2.Data = stateResponse + + ss.crystallizedStateBuf <- msg2 + + if crystallizedStateHash != ss.initialCrystallizedStateHash { + t.Fatalf("Crystallized state hash not updated: %x", blockResponse.Block.CrystallizedStateHash) + } + + blockResponse.Block.SlotNumber = 30 + msg1.Data = blockResponse + ss.blockBuf <- msg1 + + if stateResponse.CrystallizedState.GetLastFinalizedEpoch() != ss.currentSlotNumber { + t.Fatalf("slotnumber saved when it was not supposed too: %v", stateResponse.CrystallizedState.GetLastFinalizedEpoch()) + } + + blockResponse.Block.SlotNumber = 100 + ss.blockBuf <- msg1 + + ss.cancel() + <-exitRoutine + + if blockResponse.Block.GetSlotNumber() != ss.currentSlotNumber { + t.Fatalf("slotnumber not updated despite receiving a valid block: %v", ss.currentSlotNumber) + } + + hook.Reset() + +} + +func TestDelayChan(t *testing.T) { + hook := logTest.NewGlobal() + cfg := Config{BlockBufferSize: 0, CrystallizedStateBufferSize: 0} + ms := &mockChainService{} + ss := NewSyncService(context.Background(), cfg, &mockP2P{}, ms) + + exitRoutine := make(chan bool) + delayChan := make(chan time.Time) + + go func() { + ss.initialSync(delayChan, ss.ctx.Done()) + exitRoutine <- true + }() + + generichash := make([]byte, 32) + generichash[0] = 'a' + + crystallizedstate := &pb.CrystallizedState{ + LastFinalizedEpoch: 99, + } + + stateResponse := &pb.CrystallizedStateResponse{ + CrystallizedState: crystallizedstate, + } + + crystallizedStateHash, err := types.NewCrystallizedState(stateResponse.CrystallizedState).Hash() + if err != nil { + t.Fatalf("unable to get hash of crystallized state: %v", err) + } + + block := &pb.BeaconBlock{ + MainChainRef: []byte{1, 2, 3}, + ParentHash: generichash, + SlotNumber: uint64(20), + CrystallizedStateHash: crystallizedStateHash[:], + } + + blockResponse := &pb.BeaconBlockResponse{ + Block: block, + } + + msg1 := p2p.Message{ + Peer: p2p.Peer{}, + Data: blockResponse, + } + + msg2 := p2p.Message{ + Peer: p2p.Peer{}, + Data: stateResponse, + } + + ss.blockBuf <- msg1 + + ss.crystallizedStateBuf <- msg2 + + blockResponse.Block.SlotNumber = 100 + msg1.Data = blockResponse + + ss.blockBuf <- msg1 + + delayChan <- time.Time{} + + ss.cancel() + <-exitRoutine + + testutil.AssertLogsContain(t, hook, "Exiting initial sync and starting normal sync") + + hook.Reset() + +} diff --git a/beacon-chain/types/block.go b/beacon-chain/types/block.go index 1b6ba2643a6..a776fcd209e 100644 --- a/beacon-chain/types/block.go +++ b/beacon-chain/types/block.go @@ -50,6 +50,11 @@ func (b *Block) Proto() *pb.BeaconBlock { return b.data } +// Marshal encodes block object into the wire format. +func (b *Block) Marshal() ([]byte, error) { + return proto.Marshal(b.data) +} + // Hash generates the blake2b hash of the block func (b *Block) Hash() ([32]byte, error) { data, err := proto.Marshal(b.data) diff --git a/beacon-chain/types/interfaces.go b/beacon-chain/types/interfaces.go index 81e1b4b8ade..72b36d41547 100644 --- a/beacon-chain/types/interfaces.go +++ b/beacon-chain/types/interfaces.go @@ -29,6 +29,8 @@ type BlockChainService interface { ProcessedBlockHashes() [][32]byte ProcessBlock(b *Block) error ContainsBlock(h [32]byte) bool + HasStoredState() (bool, error) + SaveBlock(block *Block) error } // CrystallizedStateChainService is the interface for crystallized state related functions in local beacon chain. diff --git a/proto/beacon/p2p/v1/messages.pb.go b/proto/beacon/p2p/v1/messages.pb.go index d93439a2b32..fc849e0a5fc 100644 --- a/proto/beacon/p2p/v1/messages.pb.go +++ b/proto/beacon/p2p/v1/messages.pb.go @@ -30,7 +30,7 @@ func (m *BeaconBlockHashAnnounce) Reset() { *m = BeaconBlockHashAnnounce func (m *BeaconBlockHashAnnounce) String() string { return proto.CompactTextString(m) } func (*BeaconBlockHashAnnounce) ProtoMessage() {} func (*BeaconBlockHashAnnounce) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{0} + return fileDescriptor_messages_8d20a0b636f041ba, []int{0} } func (m *BeaconBlockHashAnnounce) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_BeaconBlockHashAnnounce.Unmarshal(m, b) @@ -68,7 +68,7 @@ func (m *BeaconBlockRequest) Reset() { *m = BeaconBlockRequest{} } func (m *BeaconBlockRequest) String() string { return proto.CompactTextString(m) } func (*BeaconBlockRequest) ProtoMessage() {} func (*BeaconBlockRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{1} + return fileDescriptor_messages_8d20a0b636f041ba, []int{1} } func (m *BeaconBlockRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_BeaconBlockRequest.Unmarshal(m, b) @@ -95,6 +95,44 @@ func (m *BeaconBlockRequest) GetHash() []byte { return nil } +type BeaconBlockRequestBySlotNumber struct { + SlotNumber uint64 `protobuf:"varint,1,opt,name=slot_number,json=slotNumber,proto3" json:"slot_number,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *BeaconBlockRequestBySlotNumber) Reset() { *m = BeaconBlockRequestBySlotNumber{} } +func (m *BeaconBlockRequestBySlotNumber) String() string { return proto.CompactTextString(m) } +func (*BeaconBlockRequestBySlotNumber) ProtoMessage() {} +func (*BeaconBlockRequestBySlotNumber) Descriptor() ([]byte, []int) { + return fileDescriptor_messages_8d20a0b636f041ba, []int{2} +} +func (m *BeaconBlockRequestBySlotNumber) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_BeaconBlockRequestBySlotNumber.Unmarshal(m, b) +} +func (m *BeaconBlockRequestBySlotNumber) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_BeaconBlockRequestBySlotNumber.Marshal(b, m, deterministic) +} +func (dst *BeaconBlockRequestBySlotNumber) XXX_Merge(src proto.Message) { + xxx_messageInfo_BeaconBlockRequestBySlotNumber.Merge(dst, src) +} +func (m *BeaconBlockRequestBySlotNumber) XXX_Size() int { + return xxx_messageInfo_BeaconBlockRequestBySlotNumber.Size(m) +} +func (m *BeaconBlockRequestBySlotNumber) XXX_DiscardUnknown() { + xxx_messageInfo_BeaconBlockRequestBySlotNumber.DiscardUnknown(m) +} + +var xxx_messageInfo_BeaconBlockRequestBySlotNumber proto.InternalMessageInfo + +func (m *BeaconBlockRequestBySlotNumber) GetSlotNumber() uint64 { + if m != nil { + return m.SlotNumber + } + return 0 +} + type BeaconBlockResponse struct { Block *BeaconBlock `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` @@ -106,7 +144,7 @@ func (m *BeaconBlockResponse) Reset() { *m = BeaconBlockResponse{} } func (m *BeaconBlockResponse) String() string { return proto.CompactTextString(m) } func (*BeaconBlockResponse) ProtoMessage() {} func (*BeaconBlockResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{2} + return fileDescriptor_messages_8d20a0b636f041ba, []int{3} } func (m *BeaconBlockResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_BeaconBlockResponse.Unmarshal(m, b) @@ -153,7 +191,7 @@ func (m *BeaconBlock) Reset() { *m = BeaconBlock{} } func (m *BeaconBlock) String() string { return proto.CompactTextString(m) } func (*BeaconBlock) ProtoMessage() {} func (*BeaconBlock) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{3} + return fileDescriptor_messages_8d20a0b636f041ba, []int{4} } func (m *BeaconBlock) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_BeaconBlock.Unmarshal(m, b) @@ -254,7 +292,7 @@ func (m *CrystallizedStateHashAnnounce) Reset() { *m = CrystallizedState func (m *CrystallizedStateHashAnnounce) String() string { return proto.CompactTextString(m) } func (*CrystallizedStateHashAnnounce) ProtoMessage() {} func (*CrystallizedStateHashAnnounce) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{4} + return fileDescriptor_messages_8d20a0b636f041ba, []int{5} } func (m *CrystallizedStateHashAnnounce) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CrystallizedStateHashAnnounce.Unmarshal(m, b) @@ -292,7 +330,7 @@ func (m *CrystallizedStateRequest) Reset() { *m = CrystallizedStateReque func (m *CrystallizedStateRequest) String() string { return proto.CompactTextString(m) } func (*CrystallizedStateRequest) ProtoMessage() {} func (*CrystallizedStateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{5} + return fileDescriptor_messages_8d20a0b636f041ba, []int{6} } func (m *CrystallizedStateRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CrystallizedStateRequest.Unmarshal(m, b) @@ -330,7 +368,7 @@ func (m *CrystallizedStateResponse) Reset() { *m = CrystallizedStateResp func (m *CrystallizedStateResponse) String() string { return proto.CompactTextString(m) } func (*CrystallizedStateResponse) ProtoMessage() {} func (*CrystallizedStateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{6} + return fileDescriptor_messages_8d20a0b636f041ba, []int{7} } func (m *CrystallizedStateResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CrystallizedStateResponse.Unmarshal(m, b) @@ -380,7 +418,7 @@ func (m *CrystallizedState) Reset() { *m = CrystallizedState{} } func (m *CrystallizedState) String() string { return proto.CompactTextString(m) } func (*CrystallizedState) ProtoMessage() {} func (*CrystallizedState) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{7} + return fileDescriptor_messages_8d20a0b636f041ba, []int{8} } func (m *CrystallizedState) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CrystallizedState.Unmarshal(m, b) @@ -502,7 +540,7 @@ func (m *ActiveStateHashAnnounce) Reset() { *m = ActiveStateHashAnnounce func (m *ActiveStateHashAnnounce) String() string { return proto.CompactTextString(m) } func (*ActiveStateHashAnnounce) ProtoMessage() {} func (*ActiveStateHashAnnounce) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{8} + return fileDescriptor_messages_8d20a0b636f041ba, []int{9} } func (m *ActiveStateHashAnnounce) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ActiveStateHashAnnounce.Unmarshal(m, b) @@ -540,7 +578,7 @@ func (m *ActiveStateRequest) Reset() { *m = ActiveStateRequest{} } func (m *ActiveStateRequest) String() string { return proto.CompactTextString(m) } func (*ActiveStateRequest) ProtoMessage() {} func (*ActiveStateRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{9} + return fileDescriptor_messages_8d20a0b636f041ba, []int{10} } func (m *ActiveStateRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ActiveStateRequest.Unmarshal(m, b) @@ -578,7 +616,7 @@ func (m *ActiveStateResponse) Reset() { *m = ActiveStateResponse{} } func (m *ActiveStateResponse) String() string { return proto.CompactTextString(m) } func (*ActiveStateResponse) ProtoMessage() {} func (*ActiveStateResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{10} + return fileDescriptor_messages_8d20a0b636f041ba, []int{11} } func (m *ActiveStateResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ActiveStateResponse.Unmarshal(m, b) @@ -617,7 +655,7 @@ func (m *ActiveState) Reset() { *m = ActiveState{} } func (m *ActiveState) String() string { return proto.CompactTextString(m) } func (*ActiveState) ProtoMessage() {} func (*ActiveState) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{11} + return fileDescriptor_messages_8d20a0b636f041ba, []int{12} } func (m *ActiveState) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ActiveState.Unmarshal(m, b) @@ -665,7 +703,7 @@ func (m *AggregateVote) Reset() { *m = AggregateVote{} } func (m *AggregateVote) String() string { return proto.CompactTextString(m) } func (*AggregateVote) ProtoMessage() {} func (*AggregateVote) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{12} + return fileDescriptor_messages_8d20a0b636f041ba, []int{13} } func (m *AggregateVote) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_AggregateVote.Unmarshal(m, b) @@ -729,7 +767,7 @@ func (m *ValidatorRecord) Reset() { *m = ValidatorRecord{} } func (m *ValidatorRecord) String() string { return proto.CompactTextString(m) } func (*ValidatorRecord) ProtoMessage() {} func (*ValidatorRecord) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_8f0ba6c06432bb45, []int{13} + return fileDescriptor_messages_8d20a0b636f041ba, []int{14} } func (m *ValidatorRecord) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_ValidatorRecord.Unmarshal(m, b) @@ -794,6 +832,7 @@ func (m *ValidatorRecord) GetSwitchDynasty() uint64 { func init() { proto.RegisterType((*BeaconBlockHashAnnounce)(nil), "ethereum.beacon.p2p.v1.BeaconBlockHashAnnounce") proto.RegisterType((*BeaconBlockRequest)(nil), "ethereum.beacon.p2p.v1.BeaconBlockRequest") + proto.RegisterType((*BeaconBlockRequestBySlotNumber)(nil), "ethereum.beacon.p2p.v1.BeaconBlockRequestBySlotNumber") proto.RegisterType((*BeaconBlockResponse)(nil), "ethereum.beacon.p2p.v1.BeaconBlockResponse") proto.RegisterType((*BeaconBlock)(nil), "ethereum.beacon.p2p.v1.BeaconBlock") proto.RegisterType((*CrystallizedStateHashAnnounce)(nil), "ethereum.beacon.p2p.v1.CrystallizedStateHashAnnounce") @@ -808,71 +847,72 @@ func init() { proto.RegisterType((*ValidatorRecord)(nil), "ethereum.beacon.p2p.v1.ValidatorRecord") } -func init() { proto.RegisterFile("messages.proto", fileDescriptor_messages_8f0ba6c06432bb45) } - -var fileDescriptor_messages_8f0ba6c06432bb45 = []byte{ - // 998 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x55, 0x5d, 0x6f, 0xdb, 0x36, - 0x14, 0x85, 0x1b, 0xa7, 0x69, 0xae, 0xed, 0x24, 0xa6, 0x9b, 0x45, 0x29, 0x50, 0xd4, 0x73, 0x56, - 0xd4, 0xdd, 0x50, 0x65, 0x4b, 0xb1, 0x61, 0xdb, 0x9b, 0x93, 0xae, 0xd8, 0x17, 0x86, 0x42, 0x2e, - 0x8a, 0xed, 0x61, 0x10, 0x68, 0xe9, 0x5a, 0xe2, 0x22, 0x89, 0xaa, 0x48, 0x39, 0xf5, 0x9e, 0xf6, - 0x53, 0xf6, 0x8f, 0xf6, 0x77, 0xf6, 0x38, 0x90, 0x94, 0x6c, 0x6a, 0x4e, 0x52, 0xf4, 0x25, 0x88, - 0xcf, 0x39, 0xf7, 0x88, 0xba, 0xba, 0x97, 0x07, 0xf6, 0x52, 0x14, 0x82, 0x46, 0x28, 0xdc, 0xbc, - 0xe0, 0x92, 0x93, 0x8f, 0x50, 0xc6, 0x58, 0x60, 0x99, 0xba, 0x33, 0xa4, 0x01, 0xcf, 0xdc, 0xfc, - 0x2c, 0x77, 0x17, 0x5f, 0x3c, 0x78, 0x14, 0x71, 0x1e, 0x25, 0x78, 0xaa, 0x55, 0xb3, 0x72, 0x7e, - 0x2a, 0x59, 0x8a, 0x42, 0xd2, 0x34, 0x37, 0x85, 0xa3, 0x67, 0x70, 0x74, 0xae, 0x2b, 0xce, 0x13, - 0x1e, 0x5c, 0x7e, 0x4f, 0x45, 0x3c, 0xc9, 0x32, 0x5e, 0x66, 0x01, 0x12, 0x02, 0xed, 0x98, 0x8a, - 0xd8, 0x69, 0x0d, 0x5b, 0xe3, 0xae, 0xa7, 0xff, 0x1f, 0x8d, 0x81, 0x58, 0x72, 0x0f, 0xdf, 0x96, - 0x28, 0xe4, 0xb5, 0xca, 0x57, 0x30, 0x68, 0x28, 0x45, 0xce, 0x33, 0x81, 0xe4, 0x1b, 0xd8, 0x9e, - 0x29, 0x40, 0x6b, 0x3b, 0x67, 0x27, 0xee, 0xf5, 0x07, 0x77, 0xed, 0x5a, 0x53, 0x31, 0xfa, 0xab, - 0x0d, 0x1d, 0x0b, 0x26, 0x8f, 0xa0, 0x93, 0xd3, 0x02, 0x33, 0xe9, 0x5b, 0x0f, 0x07, 0x03, 0xa9, - 0x17, 0x51, 0x02, 0x91, 0x70, 0xe9, 0x67, 0x65, 0x3a, 0xc3, 0xc2, 0xb9, 0x33, 0x6c, 0x8d, 0xdb, - 0x1e, 0x28, 0xe8, 0x17, 0x8d, 0x90, 0x13, 0xe8, 0x15, 0x34, 0x0b, 0x29, 0xf7, 0x0b, 0x5c, 0x20, - 0x4d, 0x9c, 0x2d, 0xed, 0xd1, 0x35, 0xa0, 0xa7, 0x31, 0x72, 0x0a, 0x03, 0x2a, 0xa5, 0x6a, 0x9a, - 0x64, 0x3c, 0xf3, 0x67, 0x4c, 0xa6, 0x54, 0x5c, 0x3a, 0x6d, 0x2d, 0x25, 0x16, 0x75, 0x6e, 0x18, - 0xf2, 0x2d, 0x1c, 0xdb, 0x05, 0x34, 0x8a, 0x0a, 0x8c, 0xa8, 0x44, 0x5f, 0xb0, 0xc8, 0xd9, 0x1e, - 0x6e, 0x8d, 0x7b, 0xde, 0x91, 0x25, 0x98, 0xd4, 0xfc, 0x94, 0x45, 0xe4, 0x37, 0x38, 0x14, 0x31, - 0x2d, 0x42, 0xab, 0x6a, 0xc1, 0x25, 0x0a, 0xe7, 0xee, 0x70, 0x6b, 0xdc, 0x39, 0x7b, 0x7c, 0x53, - 0xbb, 0x56, 0x26, 0x6f, 0xb8, 0x44, 0x6f, 0xa0, 0x3d, 0x1a, 0x98, 0x20, 0x9f, 0xc0, 0x5e, 0x4a, - 0x59, 0xe6, 0x07, 0xb1, 0xfa, 0x5b, 0xe0, 0xdc, 0xd9, 0x31, 0x6f, 0xab, 0xd0, 0x0b, 0x05, 0x7a, - 0x38, 0x27, 0x9f, 0x42, 0x9f, 0x06, 0x92, 0x2d, 0xd0, 0x57, 0xc7, 0x43, 0xd3, 0xda, 0x7b, 0x5a, - 0xb8, 0x6f, 0x88, 0xa9, 0xc2, 0x75, 0x7f, 0xbf, 0x82, 0xa3, 0xa0, 0x58, 0x0a, 0x49, 0x93, 0x84, - 0xfd, 0x89, 0xa1, 0x5d, 0xb1, 0xab, 0x2b, 0x0e, 0x6d, 0x7a, 0x5d, 0xf7, 0x35, 0xec, 0xae, 0xc6, - 0xd0, 0x01, 0x3d, 0x07, 0x0f, 0x5c, 0x33, 0xa8, 0x6e, 0x3d, 0xa8, 0xee, 0xeb, 0x5a, 0xe1, 0xad, - 0xc5, 0xa3, 0xe7, 0xf0, 0xf0, 0xe2, 0x3a, 0xcb, 0x5b, 0x67, 0xd6, 0x05, 0x67, 0xa3, 0xe8, 0xb6, - 0xc9, 0x2d, 0xe1, 0xf8, 0x1a, 0x7d, 0x35, 0xbf, 0xbf, 0x02, 0xd9, 0x7c, 0xe7, 0x6a, 0x98, 0x9f, - 0xde, 0xf4, 0x75, 0x36, 0xed, 0xfa, 0x1b, 0x9d, 0x19, 0xfd, 0xb3, 0x0d, 0xfd, 0x0d, 0x21, 0x79, - 0xbd, 0xfa, 0x1e, 0x0b, 0x9a, 0xb0, 0x90, 0x4a, 0x5e, 0x08, 0xa7, 0xa5, 0x87, 0xe1, 0xc9, 0x4d, - 0x8f, 0x7b, 0x53, 0x2b, 0x3d, 0x0c, 0x78, 0x11, 0x7a, 0x07, 0xc6, 0x61, 0x05, 0x0b, 0xe5, 0xfa, - 0xb6, 0xc4, 0x12, 0x43, 0xdb, 0xf5, 0xce, 0x07, 0xba, 0x1a, 0x87, 0xa6, 0x2b, 0xbe, 0x63, 0xb2, - 0xe9, 0xba, 0xf5, 0x81, 0xae, 0xc6, 0xc1, 0x72, 0x55, 0x53, 0x56, 0x16, 0x7a, 0xcf, 0x31, 0xe7, - 0x41, 0xec, 0x8b, 0xb8, 0x9c, 0xcf, 0x13, 0x96, 0x45, 0x4e, 0x7b, 0xb8, 0x35, 0x6e, 0x7b, 0x87, - 0x15, 0xfd, 0x9d, 0x62, 0xa7, 0x35, 0xa9, 0x96, 0xbb, 0x51, 0xe7, 0x6c, 0xeb, 0xfd, 0xef, 0xda, - 0x6a, 0xf2, 0x39, 0xdc, 0x4f, 0xa8, 0x90, 0xfe, 0x1f, 0xa5, 0x90, 0x6c, 0xce, 0x30, 0xac, 0xb4, - 0x77, 0xb5, 0x96, 0x28, 0xee, 0xc7, 0x9a, 0x6a, 0x56, 0xcc, 0x59, 0x46, 0xcd, 0x08, 0x98, 0x8a, - 0x9d, 0x75, 0xc5, 0xcb, 0x9a, 0x32, 0x15, 0x4f, 0x60, 0xbf, 0x3e, 0x48, 0xb8, 0xcc, 0xa8, 0x90, - 0x4b, 0xbd, 0x50, 0x6d, 0x6f, 0xaf, 0x82, 0x5f, 0x18, 0x94, 0x3c, 0x04, 0xc8, 0xf0, 0x9d, 0xf4, - 0xf5, 0xf6, 0xea, 0x15, 0x6a, 0x7b, 0xbb, 0x0a, 0x99, 0x2a, 0x80, 0xb8, 0x30, 0xa8, 0x7d, 0x82, - 0x18, 0x83, 0x4b, 0x3f, 0xe7, 0x2c, 0x93, 0x7a, 0x81, 0xba, 0x5e, 0xbf, 0xa2, 0x2e, 0x14, 0xf3, - 0x4a, 0x11, 0xe4, 0x31, 0xec, 0x49, 0x2e, 0x69, 0xe2, 0x87, 0x98, 0x73, 0xc1, 0xa4, 0x70, 0x3a, - 0xda, 0xb2, 0xa7, 0xd1, 0x17, 0x15, 0x48, 0x3e, 0x86, 0x6e, 0x75, 0x2c, 0x5f, 0x20, 0x86, 0x4e, - 0x57, 0xfb, 0x75, 0x2a, 0x6c, 0x8a, 0x18, 0x92, 0x2f, 0xe1, 0xc8, 0x96, 0xf8, 0xba, 0x01, 0x05, - 0x0a, 0x94, 0x4e, 0x4f, 0x5b, 0xde, 0xb7, 0xd4, 0x3f, 0x53, 0x21, 0x3d, 0xc5, 0xa9, 0x6c, 0x99, - 0x34, 0xaf, 0x8c, 0xf7, 0x65, 0x8b, 0x25, 0xbf, 0x6d, 0x43, 0x7f, 0x87, 0x41, 0x43, 0x59, 0xed, - 0xe6, 0x4b, 0xe8, 0xda, 0x77, 0xd7, 0xfb, 0x22, 0xc6, 0xb6, 0xe8, 0x58, 0x77, 0xdb, 0xa8, 0x80, - 0x8e, 0xc5, 0xa9, 0x01, 0x34, 0x7d, 0x34, 0x97, 0x36, 0x16, 0xeb, 0x86, 0xb6, 0xf4, 0xdb, 0x1f, - 0x6a, 0x7a, 0x52, 0xb1, 0xab, 0xc6, 0x7e, 0x06, 0xfd, 0x55, 0xc5, 0x8c, 0xc9, 0x39, 0xc3, 0x24, - 0xd4, 0x21, 0xd4, 0xf5, 0x0e, 0x6a, 0xe2, 0xbc, 0xc2, 0x47, 0x7f, 0xb7, 0xa0, 0xd7, 0xb8, 0xb0, - 0xc9, 0x31, 0xdc, 0x33, 0x51, 0xc0, 0x42, 0xfd, 0x9c, 0x9e, 0xb7, 0xa3, 0x7f, 0xff, 0x10, 0x92, - 0x31, 0x1c, 0x18, 0x4a, 0x07, 0xa3, 0xb9, 0x71, 0x8d, 0xf1, 0x9e, 0xc6, 0x57, 0x59, 0xae, 0x66, - 0x40, 0xb0, 0x28, 0x33, 0x27, 0xd0, 0xb9, 0x65, 0x22, 0xae, 0x67, 0xd0, 0x3a, 0xb2, 0x4e, 0xa0, - 0xd7, 0x8c, 0xa9, 0xb6, 0x8e, 0xa9, 0x2e, 0xb5, 0xb2, 0x69, 0xf4, 0x6f, 0x0b, 0xf6, 0xff, 0xb7, - 0xae, 0x6a, 0x64, 0xf3, 0x72, 0x96, 0xb0, 0xc0, 0xbf, 0xc4, 0x65, 0xd5, 0x8e, 0x5d, 0x83, 0xfc, - 0x84, 0x4b, 0xf2, 0x14, 0x0e, 0xae, 0x98, 0x8c, 0xc3, 0x82, 0x5e, 0xd1, 0xa4, 0x9a, 0x6b, 0x13, - 0xc3, 0xfb, 0x6b, 0xdc, 0x4c, 0xf7, 0x33, 0x20, 0x96, 0x94, 0x86, 0x61, 0x81, 0x42, 0x54, 0xa7, - 0xed, 0xaf, 0x99, 0x89, 0x21, 0x54, 0x73, 0xab, 0xe8, 0x0e, 0x78, 0x9a, 0x32, 0x99, 0x62, 0x26, - 0xab, 0x4c, 0x3e, 0x30, 0xc4, 0xc5, 0x0a, 0x27, 0x0e, 0xec, 0xcc, 0x68, 0x42, 0xb3, 0x00, 0xab, - 0x4b, 0xa0, 0xfe, 0xa9, 0xfb, 0x73, 0xc5, 0x64, 0x10, 0xaf, 0x56, 0xd3, 0x6c, 0x7e, 0xcf, 0xa0, - 0xd5, 0x66, 0xce, 0xee, 0xea, 0x58, 0x7a, 0xfe, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x5c, 0xef, - 0x38, 0xb4, 0x77, 0x09, 0x00, 0x00, +func init() { proto.RegisterFile("messages.proto", fileDescriptor_messages_8d20a0b636f041ba) } + +var fileDescriptor_messages_8d20a0b636f041ba = []byte{ + // 1012 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0x5f, 0x6f, 0xdb, 0x36, + 0x10, 0x47, 0x1a, 0xa7, 0x69, 0xce, 0x76, 0x12, 0x33, 0xcd, 0xa2, 0x14, 0xe8, 0x9a, 0x39, 0x2b, + 0xea, 0x6e, 0xa8, 0xb2, 0xa5, 0xd8, 0xb0, 0xed, 0xcd, 0x49, 0x57, 0xec, 0x1f, 0x86, 0x42, 0x2e, + 0x8a, 0xed, 0x61, 0x10, 0x68, 0xe9, 0x2c, 0x71, 0x91, 0x44, 0x55, 0xa4, 0x9c, 0x7a, 0x4f, 0xfb, + 0x28, 0xfb, 0x46, 0xfb, 0x3a, 0x7b, 0x1c, 0x48, 0x4a, 0x32, 0x15, 0x27, 0x29, 0xfa, 0x12, 0x44, + 0xbf, 0x7f, 0xa6, 0xce, 0x77, 0x3c, 0xc3, 0x76, 0x8a, 0x42, 0xd0, 0x08, 0x85, 0x9b, 0x17, 0x5c, + 0x72, 0xf2, 0x11, 0xca, 0x18, 0x0b, 0x2c, 0x53, 0x77, 0x8a, 0x34, 0xe0, 0x99, 0x9b, 0x9f, 0xe6, + 0xee, 0xfc, 0xcb, 0x07, 0x8f, 0x22, 0xce, 0xa3, 0x04, 0x4f, 0xb4, 0x6a, 0x5a, 0xce, 0x4e, 0x24, + 0x4b, 0x51, 0x48, 0x9a, 0xe6, 0xc6, 0x38, 0x7c, 0x06, 0x07, 0x67, 0xda, 0x71, 0x96, 0xf0, 0xe0, + 0xe2, 0x07, 0x2a, 0xe2, 0x71, 0x96, 0xf1, 0x32, 0x0b, 0x90, 0x10, 0xe8, 0xc4, 0x54, 0xc4, 0xce, + 0xda, 0xd1, 0xda, 0xa8, 0xe7, 0xe9, 0xff, 0x87, 0x23, 0x20, 0x96, 0xdc, 0xc3, 0xb7, 0x25, 0x0a, + 0x79, 0xad, 0x72, 0x0c, 0x1f, 0xaf, 0x2a, 0xcf, 0x16, 0x93, 0x84, 0xcb, 0x5f, 0xcb, 0x74, 0x8a, + 0x05, 0x79, 0x04, 0x5d, 0x91, 0x70, 0xe9, 0x67, 0xfa, 0x51, 0x9b, 0x3b, 0x1e, 0x88, 0x46, 0x30, + 0x7c, 0x05, 0x7b, 0xad, 0x08, 0x91, 0xf3, 0x4c, 0x20, 0xf9, 0x16, 0x36, 0xa6, 0x0a, 0xd0, 0x8e, + 0xee, 0xe9, 0xb1, 0x7b, 0xfd, 0xbb, 0xbb, 0xb6, 0xd7, 0x38, 0x86, 0x7f, 0x77, 0xa0, 0x6b, 0xc1, + 0xea, 0x08, 0x39, 0x2d, 0x30, 0x93, 0xbe, 0x75, 0x7e, 0x30, 0x90, 0xaa, 0xc5, 0xd5, 0x33, 0xde, + 0xb9, 0x7a, 0x46, 0x72, 0x0c, 0xfd, 0x82, 0x66, 0x21, 0xe5, 0x7e, 0x81, 0x73, 0xa4, 0x89, 0xb3, + 0xae, 0x33, 0x7a, 0x06, 0xf4, 0x34, 0x46, 0x4e, 0x60, 0x8f, 0x4a, 0xa9, 0xea, 0x2e, 0x19, 0xcf, + 0xfc, 0x29, 0x93, 0x29, 0x15, 0x17, 0x4e, 0x47, 0x4b, 0x89, 0x45, 0x9d, 0x19, 0x86, 0x7c, 0x07, + 0x87, 0xb6, 0x81, 0x46, 0x51, 0x81, 0x11, 0x95, 0xe8, 0x0b, 0x16, 0x39, 0x1b, 0x47, 0xeb, 0xa3, + 0xbe, 0x77, 0x60, 0x09, 0xc6, 0x35, 0x3f, 0x61, 0x11, 0xf9, 0x1d, 0xf6, 0x45, 0x4c, 0x8b, 0xd0, + 0x72, 0xcd, 0xb9, 0x44, 0xe1, 0xdc, 0x3d, 0x5a, 0x1f, 0x75, 0x4f, 0x1f, 0xdf, 0x54, 0xae, 0x26, + 0xe4, 0x0d, 0x97, 0xe8, 0xed, 0xe9, 0x8c, 0x16, 0x26, 0xc8, 0xa7, 0xb0, 0x9d, 0x52, 0x96, 0xf9, + 0x41, 0xac, 0xfe, 0x16, 0x38, 0x73, 0x36, 0xcd, 0xdb, 0x2a, 0xf4, 0x5c, 0x81, 0x1e, 0xce, 0xc8, + 0x67, 0x30, 0xa0, 0x81, 0x64, 0x73, 0xf4, 0xd5, 0xf1, 0xd0, 0x94, 0xf6, 0x9e, 0x16, 0xee, 0x18, + 0x62, 0xa2, 0x70, 0x5d, 0xdf, 0xaf, 0xe1, 0x20, 0x28, 0x16, 0x42, 0xd2, 0x24, 0x61, 0x7f, 0x61, + 0x68, 0x3b, 0xb6, 0xb4, 0x63, 0xdf, 0xa6, 0x97, 0xbe, 0x6f, 0x60, 0xab, 0xe9, 0x64, 0x07, 0x74, + 0x1f, 0x3c, 0x70, 0x4d, 0xaf, 0xbb, 0x75, 0xaf, 0xbb, 0xaf, 0x6b, 0x85, 0xb7, 0x14, 0x0f, 0x9f, + 0xc3, 0xc3, 0xf3, 0xeb, 0x22, 0x6f, 0x6d, 0x7b, 0x17, 0x9c, 0x15, 0xd3, 0x6d, 0xcd, 0x5f, 0xc2, + 0xe1, 0x35, 0xfa, 0xaa, 0x7f, 0x7f, 0x03, 0xb2, 0xfa, 0xce, 0x55, 0x33, 0x3f, 0xbd, 0xe9, 0xdb, + 0x59, 0x8d, 0x1b, 0xac, 0x54, 0x66, 0xf8, 0xef, 0x06, 0x0c, 0x56, 0x84, 0xe4, 0x75, 0xf3, 0x7d, + 0xcc, 0x69, 0xc2, 0x42, 0x2a, 0x79, 0x21, 0x9c, 0x35, 0xdd, 0x0c, 0x4f, 0x6e, 0xfa, 0xb8, 0x37, + 0xb5, 0xd2, 0xc3, 0x80, 0x17, 0xa1, 0xb7, 0x6b, 0x12, 0x1a, 0x58, 0xa8, 0xd4, 0xb7, 0x25, 0x96, + 0x18, 0xda, 0xa9, 0x77, 0x3e, 0x30, 0xd5, 0x24, 0xb4, 0x53, 0xf1, 0x1d, 0x93, 0xed, 0xd4, 0xf5, + 0x0f, 0x4c, 0x35, 0x09, 0x56, 0xaa, 0xea, 0xb2, 0xb2, 0xd0, 0x73, 0x8e, 0x39, 0x0f, 0x62, 0x5f, + 0xc4, 0xe5, 0x6c, 0x96, 0xb0, 0x2c, 0x72, 0x3a, 0x47, 0xeb, 0xa3, 0x8e, 0xb7, 0x5f, 0xd1, 0xdf, + 0x2b, 0x76, 0x52, 0x93, 0x6a, 0xb8, 0x5b, 0x3e, 0x67, 0x43, 0xcf, 0x7f, 0xcf, 0x56, 0x93, 0x2f, + 0xe0, 0x7e, 0x42, 0x85, 0xf4, 0xff, 0x2c, 0x85, 0x64, 0x33, 0x86, 0x61, 0xa5, 0xbd, 0xab, 0xb5, + 0x44, 0x71, 0x3f, 0xd5, 0x54, 0xdb, 0x31, 0x63, 0x19, 0x35, 0x2d, 0x60, 0x1c, 0x9b, 0x4b, 0xc7, + 0xcb, 0x9a, 0x32, 0x8e, 0x27, 0xb0, 0x53, 0x1f, 0x24, 0x5c, 0x64, 0x54, 0xc8, 0x85, 0x1e, 0xa8, + 0x8e, 0xb7, 0x5d, 0xc1, 0x2f, 0x0c, 0x4a, 0x1e, 0x02, 0x64, 0xf8, 0x4e, 0xfa, 0x7a, 0x7a, 0xf5, + 0x08, 0x75, 0xbc, 0x2d, 0x85, 0x4c, 0x14, 0x40, 0x5c, 0xd8, 0xab, 0x73, 0x82, 0x18, 0x83, 0x0b, + 0x3f, 0xe7, 0x2c, 0x93, 0x7a, 0x80, 0x7a, 0xde, 0xa0, 0xa2, 0xce, 0x15, 0xf3, 0x4a, 0x11, 0xe4, + 0x31, 0x6c, 0x4b, 0x2e, 0x69, 0xe2, 0x87, 0x98, 0x73, 0xc1, 0xa4, 0x70, 0xba, 0x3a, 0xb2, 0xaf, + 0xd1, 0x17, 0x15, 0x48, 0x3e, 0x81, 0x5e, 0x75, 0x2c, 0x5f, 0x20, 0x86, 0x4e, 0x4f, 0xe7, 0x75, + 0x2b, 0x6c, 0x82, 0x18, 0x92, 0xaf, 0xe0, 0xc0, 0x96, 0xf8, 0xba, 0x00, 0x05, 0x0a, 0x94, 0x4e, + 0x5f, 0x47, 0xde, 0xb7, 0xd4, 0xbf, 0x50, 0x21, 0x3d, 0xc5, 0xa9, 0xf5, 0x34, 0x6e, 0x5f, 0x19, + 0xef, 0x5b, 0x4f, 0x96, 0xfc, 0xb6, 0x09, 0xfd, 0x03, 0xf6, 0x5a, 0xca, 0x6a, 0x36, 0x5f, 0x42, + 0xcf, 0xbe, 0xbb, 0xde, 0xb7, 0x62, 0xec, 0x88, 0xae, 0x75, 0xb7, 0x0d, 0x0b, 0xe8, 0x5a, 0x9c, + 0x6a, 0x40, 0x53, 0x47, 0x73, 0x69, 0x63, 0xb1, 0x2c, 0xa8, 0x59, 0x7b, 0xfb, 0x9a, 0x1e, 0x57, + 0x6c, 0x53, 0xd8, 0xcf, 0x61, 0xd0, 0x38, 0xa6, 0x4c, 0xce, 0x18, 0x26, 0xa1, 0x5e, 0x42, 0x3d, + 0x6f, 0xb7, 0x26, 0xce, 0x2a, 0x7c, 0xf8, 0xcf, 0x1a, 0xf4, 0x5b, 0x17, 0x36, 0x39, 0x84, 0x7b, + 0x66, 0x15, 0xb0, 0x50, 0x7f, 0x4e, 0xdf, 0xdb, 0xd4, 0xcf, 0x3f, 0x86, 0x64, 0x04, 0xbb, 0x86, + 0xd2, 0x8b, 0xd1, 0xdc, 0xb8, 0x26, 0x78, 0x5b, 0xe3, 0xcd, 0xcf, 0x01, 0xd5, 0x03, 0x82, 0x45, + 0x99, 0x39, 0x81, 0xde, 0x5b, 0x66, 0xc5, 0xf5, 0x0d, 0x5a, 0xaf, 0xac, 0x63, 0xe8, 0xb7, 0xd7, + 0x54, 0x47, 0xaf, 0xa9, 0x1e, 0xb5, 0x76, 0xd3, 0xf0, 0xbf, 0x35, 0xd8, 0xb9, 0x32, 0xae, 0xaa, + 0x65, 0xf3, 0x72, 0x9a, 0xb0, 0xc0, 0xbf, 0xc0, 0x45, 0x55, 0x8e, 0x2d, 0x83, 0xfc, 0x8c, 0x0b, + 0xf2, 0x14, 0x76, 0x2f, 0x99, 0x8c, 0xc3, 0x82, 0x5e, 0xd2, 0xa4, 0xea, 0x6b, 0xb3, 0x86, 0x77, + 0x96, 0xb8, 0xe9, 0xee, 0x67, 0x40, 0x2c, 0x29, 0x0d, 0xc3, 0x02, 0x85, 0xa8, 0x4e, 0x3b, 0x58, + 0x32, 0x63, 0x43, 0xa8, 0xe2, 0x56, 0xab, 0x3b, 0xe0, 0x69, 0xca, 0x64, 0x8a, 0x99, 0xac, 0x76, + 0xf2, 0xae, 0x21, 0xce, 0x1b, 0x9c, 0x38, 0xb0, 0x39, 0xa5, 0x09, 0xcd, 0x02, 0xac, 0x2e, 0x81, + 0xfa, 0x51, 0xd7, 0xe7, 0x92, 0xc9, 0x20, 0x6e, 0x46, 0xd3, 0x4c, 0x7e, 0xdf, 0xa0, 0xd5, 0x64, + 0x4e, 0xef, 0xea, 0xb5, 0xf4, 0xfc, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7d, 0x3d, 0x00, 0xf3, + 0xba, 0x09, 0x00, 0x00, } diff --git a/proto/beacon/p2p/v1/messages.proto b/proto/beacon/p2p/v1/messages.proto index 20a4d9e18ad..c34309d2211 100644 --- a/proto/beacon/p2p/v1/messages.proto +++ b/proto/beacon/p2p/v1/messages.proto @@ -12,6 +12,10 @@ message BeaconBlockRequest { bytes hash = 1; } +message BeaconBlockRequestBySlotNumber{ + uint64 slot_number = 1; +} + message BeaconBlockResponse { BeaconBlock block = 1; } diff --git a/proto/sharding/p2p/v1/messages.pb.go b/proto/sharding/p2p/v1/messages.pb.go index b69190352fe..642b312ccf3 100644 --- a/proto/sharding/p2p/v1/messages.pb.go +++ b/proto/sharding/p2p/v1/messages.pb.go @@ -22,19 +22,20 @@ const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package type Topic int32 const ( - Topic_UNKNOWN Topic = 0 - Topic_COLLATION_BODY_REQUEST Topic = 1 - Topic_COLLATION_BODY_RESPONSE Topic = 2 - Topic_TRANSACTIONS Topic = 3 - Topic_BEACON_BLOCK_HASH_ANNOUNCE Topic = 4 - Topic_BEACON_BLOCK_REQUEST Topic = 5 - Topic_BEACON_BLOCK_RESPONSE Topic = 6 - Topic_CRYSTALLIZED_STATE_HASH_ANNOUNCE Topic = 7 - Topic_CRYSTALLIZED_STATE_REQUEST Topic = 8 - Topic_CRYSTALLIZED_STATE_RESPONSE Topic = 9 - Topic_ACTIVE_STATE_HASH_ANNOUNCE Topic = 10 - Topic_ACTIVE_STATE_REQUEST Topic = 11 - Topic_ACTIVE_STATE_RESPONSE Topic = 12 + Topic_UNKNOWN Topic = 0 + Topic_COLLATION_BODY_REQUEST Topic = 1 + Topic_COLLATION_BODY_RESPONSE Topic = 2 + Topic_TRANSACTIONS Topic = 3 + Topic_BEACON_BLOCK_HASH_ANNOUNCE Topic = 4 + Topic_BEACON_BLOCK_REQUEST Topic = 5 + Topic_BEACON_BLOCK_REQUEST_BY_SLOT_NUMBER Topic = 6 + Topic_BEACON_BLOCK_RESPONSE Topic = 7 + Topic_CRYSTALLIZED_STATE_HASH_ANNOUNCE Topic = 8 + Topic_CRYSTALLIZED_STATE_REQUEST Topic = 9 + Topic_CRYSTALLIZED_STATE_RESPONSE Topic = 10 + Topic_ACTIVE_STATE_HASH_ANNOUNCE Topic = 11 + Topic_ACTIVE_STATE_REQUEST Topic = 12 + Topic_ACTIVE_STATE_RESPONSE Topic = 13 ) var Topic_name = map[int32]string{ @@ -44,35 +45,37 @@ var Topic_name = map[int32]string{ 3: "TRANSACTIONS", 4: "BEACON_BLOCK_HASH_ANNOUNCE", 5: "BEACON_BLOCK_REQUEST", - 6: "BEACON_BLOCK_RESPONSE", - 7: "CRYSTALLIZED_STATE_HASH_ANNOUNCE", - 8: "CRYSTALLIZED_STATE_REQUEST", - 9: "CRYSTALLIZED_STATE_RESPONSE", - 10: "ACTIVE_STATE_HASH_ANNOUNCE", - 11: "ACTIVE_STATE_REQUEST", - 12: "ACTIVE_STATE_RESPONSE", + 6: "BEACON_BLOCK_REQUEST_BY_SLOT_NUMBER", + 7: "BEACON_BLOCK_RESPONSE", + 8: "CRYSTALLIZED_STATE_HASH_ANNOUNCE", + 9: "CRYSTALLIZED_STATE_REQUEST", + 10: "CRYSTALLIZED_STATE_RESPONSE", + 11: "ACTIVE_STATE_HASH_ANNOUNCE", + 12: "ACTIVE_STATE_REQUEST", + 13: "ACTIVE_STATE_RESPONSE", } var Topic_value = map[string]int32{ - "UNKNOWN": 0, - "COLLATION_BODY_REQUEST": 1, - "COLLATION_BODY_RESPONSE": 2, - "TRANSACTIONS": 3, - "BEACON_BLOCK_HASH_ANNOUNCE": 4, - "BEACON_BLOCK_REQUEST": 5, - "BEACON_BLOCK_RESPONSE": 6, - "CRYSTALLIZED_STATE_HASH_ANNOUNCE": 7, - "CRYSTALLIZED_STATE_REQUEST": 8, - "CRYSTALLIZED_STATE_RESPONSE": 9, - "ACTIVE_STATE_HASH_ANNOUNCE": 10, - "ACTIVE_STATE_REQUEST": 11, - "ACTIVE_STATE_RESPONSE": 12, + "UNKNOWN": 0, + "COLLATION_BODY_REQUEST": 1, + "COLLATION_BODY_RESPONSE": 2, + "TRANSACTIONS": 3, + "BEACON_BLOCK_HASH_ANNOUNCE": 4, + "BEACON_BLOCK_REQUEST": 5, + "BEACON_BLOCK_REQUEST_BY_SLOT_NUMBER": 6, + "BEACON_BLOCK_RESPONSE": 7, + "CRYSTALLIZED_STATE_HASH_ANNOUNCE": 8, + "CRYSTALLIZED_STATE_REQUEST": 9, + "CRYSTALLIZED_STATE_RESPONSE": 10, + "ACTIVE_STATE_HASH_ANNOUNCE": 11, + "ACTIVE_STATE_REQUEST": 12, + "ACTIVE_STATE_RESPONSE": 13, } func (x Topic) String() string { return proto.EnumName(Topic_name, int32(x)) } func (Topic) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_messages_923b4f96a23fc196, []int{0} + return fileDescriptor_messages_2d61a34a4bdb49bc, []int{0} } type CollationBodyRequest struct { @@ -90,7 +93,7 @@ func (m *CollationBodyRequest) Reset() { *m = CollationBodyRequest{} } func (m *CollationBodyRequest) String() string { return proto.CompactTextString(m) } func (*CollationBodyRequest) ProtoMessage() {} func (*CollationBodyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_923b4f96a23fc196, []int{0} + return fileDescriptor_messages_2d61a34a4bdb49bc, []int{0} } func (m *CollationBodyRequest) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CollationBodyRequest.Unmarshal(m, b) @@ -157,7 +160,7 @@ func (m *CollationBodyResponse) Reset() { *m = CollationBodyResponse{} } func (m *CollationBodyResponse) String() string { return proto.CompactTextString(m) } func (*CollationBodyResponse) ProtoMessage() {} func (*CollationBodyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_923b4f96a23fc196, []int{1} + return fileDescriptor_messages_2d61a34a4bdb49bc, []int{1} } func (m *CollationBodyResponse) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_CollationBodyResponse.Unmarshal(m, b) @@ -208,7 +211,7 @@ func (m *Transaction) Reset() { *m = Transaction{} } func (m *Transaction) String() string { return proto.CompactTextString(m) } func (*Transaction) ProtoMessage() {} func (*Transaction) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_923b4f96a23fc196, []int{2} + return fileDescriptor_messages_2d61a34a4bdb49bc, []int{2} } func (m *Transaction) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Transaction.Unmarshal(m, b) @@ -290,7 +293,7 @@ func (m *Signature) Reset() { *m = Signature{} } func (m *Signature) String() string { return proto.CompactTextString(m) } func (*Signature) ProtoMessage() {} func (*Signature) Descriptor() ([]byte, []int) { - return fileDescriptor_messages_923b4f96a23fc196, []int{3} + return fileDescriptor_messages_2d61a34a4bdb49bc, []int{3} } func (m *Signature) XXX_Unmarshal(b []byte) error { return xxx_messageInfo_Signature.Unmarshal(m, b) @@ -339,43 +342,44 @@ func init() { proto.RegisterEnum("ethereum.sharding.p2p.v1.Topic", Topic_name, Topic_value) } -func init() { proto.RegisterFile("messages.proto", fileDescriptor_messages_923b4f96a23fc196) } - -var fileDescriptor_messages_923b4f96a23fc196 = []byte{ - // 549 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x53, 0xcb, 0x6e, 0xd3, 0x4c, - 0x18, 0xfd, 0xdd, 0xe6, 0xd2, 0x7c, 0xb1, 0x7e, 0xac, 0x51, 0x5b, 0xdc, 0x06, 0x68, 0x14, 0x58, - 0x04, 0x16, 0x96, 0x28, 0xe2, 0x01, 0x1c, 0xd7, 0x52, 0xa2, 0x5a, 0x76, 0xb1, 0x1d, 0x50, 0xd9, - 0x58, 0x53, 0x7b, 0x14, 0x8f, 0x48, 0x3c, 0x66, 0xc6, 0x8e, 0xd4, 0xc7, 0xe2, 0xb5, 0x58, 0xf1, - 0x08, 0x68, 0x7c, 0x29, 0x6d, 0x08, 0xbb, 0x9c, 0x8b, 0xce, 0xf9, 0xce, 0x44, 0x86, 0xff, 0x37, - 0x44, 0x08, 0xbc, 0x22, 0xc2, 0xc8, 0x39, 0x2b, 0x18, 0xd2, 0x49, 0x91, 0x12, 0x4e, 0xca, 0x8d, - 0x21, 0x52, 0xcc, 0x13, 0x9a, 0xad, 0x8c, 0xfc, 0x32, 0x37, 0xb6, 0xef, 0x27, 0x3f, 0x14, 0x38, - 0xb6, 0xd8, 0x7a, 0x8d, 0x0b, 0xca, 0xb2, 0x19, 0x4b, 0xee, 0x7d, 0xf2, 0xbd, 0x24, 0xa2, 0x40, - 0x67, 0x70, 0x54, 0x79, 0x23, 0x9a, 0xe8, 0xca, 0x58, 0x99, 0x76, 0xfc, 0x7e, 0x85, 0x17, 0x09, - 0x3a, 0x85, 0x5e, 0x4e, 0x38, 0x65, 0x89, 0x7e, 0x50, 0x09, 0x0d, 0x42, 0x2f, 0x01, 0xe2, 0xb4, - 0xcc, 0xbe, 0x45, 0x9c, 0xb1, 0x42, 0x3f, 0x1c, 0x2b, 0x53, 0xd5, 0x1f, 0x54, 0x8c, 0xcf, 0x58, - 0x81, 0xde, 0x82, 0x96, 0x73, 0x96, 0x33, 0x41, 0x78, 0x84, 0x93, 0x84, 0x13, 0x21, 0xf4, 0x4e, - 0x65, 0x7a, 0xd6, 0xf2, 0x66, 0x4d, 0xa3, 0x17, 0x30, 0x10, 0x74, 0x95, 0xe1, 0xa2, 0xe4, 0x44, - 0xef, 0xd6, 0x41, 0x0f, 0xc4, 0xc4, 0x81, 0x93, 0x9d, 0x93, 0x45, 0xce, 0x32, 0x41, 0xd0, 0x05, - 0x0c, 0x53, 0x82, 0x13, 0xc2, 0xa3, 0x14, 0x8b, 0xb4, 0x3a, 0x5b, 0xf5, 0xa1, 0xa6, 0xe6, 0x58, - 0xa4, 0x08, 0x41, 0xe7, 0x8e, 0x25, 0xf7, 0xd5, 0xdd, 0xaa, 0x5f, 0xfd, 0x9e, 0xfc, 0x54, 0x60, - 0x18, 0x72, 0x9c, 0x09, 0x1c, 0xcb, 0x40, 0x74, 0x0c, 0xdd, 0x8c, 0x65, 0x31, 0x69, 0x56, 0xd7, - 0x00, 0x8d, 0x60, 0xb0, 0xc2, 0x22, 0xca, 0x39, 0x8d, 0x49, 0x33, 0xfb, 0x68, 0x85, 0xc5, 0x8d, - 0xc4, 0xad, 0xb8, 0xa6, 0x1b, 0x5a, 0xef, 0xae, 0x45, 0x47, 0x62, 0xb9, 0x85, 0x93, 0x98, 0xe6, - 0x94, 0x64, 0x45, 0xb3, 0xf7, 0x0f, 0x21, 0xdb, 0xb6, 0x78, 0x5d, 0xd6, 0x2b, 0x3b, 0x7e, 0x0d, - 0x24, 0x4b, 0xb3, 0xbc, 0x2c, 0xf4, 0x5e, 0xe5, 0xaf, 0x01, 0x32, 0x1f, 0xbf, 0x4a, 0x7f, 0xac, - 0x4c, 0x87, 0x97, 0xaf, 0x8d, 0x7f, 0xfd, 0xb3, 0x46, 0xd0, 0x5a, 0x1f, 0x3f, 0xdd, 0x47, 0x18, - 0x3c, 0xf0, 0x48, 0x05, 0x65, 0xdb, 0xac, 0x54, 0xb6, 0x12, 0xf1, 0x66, 0x99, 0xc2, 0x25, 0x12, - 0xcd, 0x14, 0x45, 0xbc, 0xfb, 0x75, 0x00, 0xdd, 0x90, 0xe5, 0x34, 0x46, 0x43, 0xe8, 0x2f, 0xdd, - 0x6b, 0xd7, 0xfb, 0xe2, 0x6a, 0xff, 0xa1, 0x73, 0x38, 0xb5, 0x3c, 0xc7, 0x31, 0xc3, 0x85, 0xe7, - 0x46, 0x33, 0xef, 0xea, 0x36, 0xf2, 0xed, 0x4f, 0x4b, 0x3b, 0x08, 0x35, 0x05, 0x8d, 0xe0, 0xf9, - 0x5f, 0x5a, 0x70, 0xe3, 0xb9, 0x81, 0xad, 0x1d, 0x20, 0x0d, 0xd4, 0xd0, 0x37, 0xdd, 0xc0, 0xb4, - 0xa4, 0x1c, 0x68, 0x87, 0xe8, 0x15, 0x9c, 0xcf, 0x6c, 0xd3, 0x92, 0x5e, 0xc7, 0xb3, 0xae, 0xa3, - 0xb9, 0x19, 0xcc, 0x23, 0xd3, 0x75, 0xbd, 0xa5, 0x6b, 0xd9, 0x5a, 0x07, 0xe9, 0x70, 0xfc, 0x44, - 0x6f, 0x8b, 0xba, 0xe8, 0x0c, 0x4e, 0x76, 0x94, 0xa6, 0xa6, 0x87, 0xde, 0xc0, 0xd8, 0xf2, 0x6f, - 0x83, 0xd0, 0x74, 0x9c, 0xc5, 0x57, 0xfb, 0x2a, 0x0a, 0x42, 0x33, 0xb4, 0x77, 0xa2, 0xfb, 0xb2, - 0x7a, 0x8f, 0xab, 0x2d, 0x38, 0x42, 0x17, 0x30, 0xda, 0xab, 0x37, 0x35, 0x03, 0x19, 0x20, 0x87, - 0x7c, 0xb6, 0xf7, 0x16, 0x80, 0xbc, 0xfd, 0x89, 0xde, 0x46, 0x0f, 0xe5, 0xed, 0x3b, 0x4a, 0x13, - 0xaa, 0xde, 0xf5, 0xaa, 0x2f, 0xf7, 0xc3, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x79, 0xf0, 0x6f, - 0x03, 0xcb, 0x03, 0x00, 0x00, +func init() { proto.RegisterFile("messages.proto", fileDescriptor_messages_2d61a34a4bdb49bc) } + +var fileDescriptor_messages_2d61a34a4bdb49bc = []byte{ + // 569 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x53, 0xed, 0x4e, 0xd4, 0x4c, + 0x18, 0x7d, 0x0b, 0xfb, 0xc1, 0x3e, 0xdb, 0x57, 0x9b, 0x09, 0x60, 0x01, 0x95, 0x0d, 0x98, 0x88, + 0xfe, 0x68, 0x22, 0xc6, 0x0b, 0xe8, 0x96, 0x26, 0x10, 0x6a, 0x8b, 0x6d, 0x57, 0x83, 0x7f, 0x26, + 0x43, 0x3b, 0xd9, 0x4e, 0x5c, 0x3a, 0x75, 0xa6, 0xdd, 0x84, 0x4b, 0xf1, 0x32, 0xbc, 0x2d, 0xaf, + 0xc2, 0x4c, 0x3f, 0x10, 0xd6, 0xf5, 0xdf, 0x9e, 0x8f, 0x9c, 0xe7, 0x9c, 0xd9, 0x14, 0x9e, 0xdc, + 0x52, 0x29, 0xc9, 0x9c, 0x4a, 0xab, 0x10, 0xbc, 0xe4, 0xc8, 0xa4, 0x65, 0x46, 0x05, 0xad, 0x6e, + 0x2d, 0x99, 0x11, 0x91, 0xb2, 0x7c, 0x6e, 0x15, 0xa7, 0x85, 0xb5, 0x7c, 0x77, 0xf4, 0x53, 0x83, + 0x6d, 0x87, 0x2f, 0x16, 0xa4, 0x64, 0x3c, 0x9f, 0xf2, 0xf4, 0x2e, 0xa4, 0xdf, 0x2b, 0x2a, 0x4b, + 0xb4, 0x07, 0x5b, 0xb5, 0x17, 0xb3, 0xd4, 0xd4, 0x26, 0xda, 0x49, 0x2f, 0x1c, 0xd6, 0xf8, 0x22, + 0x45, 0xbb, 0x30, 0x28, 0xa8, 0x60, 0x3c, 0x35, 0x37, 0x6a, 0xa1, 0x45, 0xe8, 0x05, 0x40, 0x92, + 0x55, 0xf9, 0x37, 0x2c, 0x38, 0x2f, 0xcd, 0xcd, 0x89, 0x76, 0xa2, 0x87, 0xa3, 0x9a, 0x09, 0x39, + 0x2f, 0xd1, 0x1b, 0x30, 0x0a, 0xc1, 0x0b, 0x2e, 0xa9, 0xc0, 0x24, 0x4d, 0x05, 0x95, 0xd2, 0xec, + 0xd5, 0xa6, 0xa7, 0x1d, 0x6f, 0x37, 0x34, 0x7a, 0x0e, 0x23, 0xc9, 0xe6, 0x39, 0x29, 0x2b, 0x41, + 0xcd, 0x7e, 0x13, 0x74, 0x4f, 0x1c, 0x79, 0xb0, 0xb3, 0x52, 0x59, 0x16, 0x3c, 0x97, 0x14, 0x1d, + 0xc2, 0x38, 0xa3, 0x24, 0xa5, 0x02, 0x67, 0x44, 0x66, 0x75, 0x6d, 0x3d, 0x84, 0x86, 0x3a, 0x27, + 0x32, 0x43, 0x08, 0x7a, 0x37, 0x3c, 0xbd, 0xab, 0x7b, 0xeb, 0x61, 0xfd, 0xfb, 0xe8, 0x97, 0x06, + 0xe3, 0x58, 0x90, 0x5c, 0x92, 0x44, 0x05, 0xa2, 0x6d, 0xe8, 0xe7, 0x3c, 0x4f, 0x68, 0xbb, 0xba, + 0x01, 0xe8, 0x00, 0x46, 0x73, 0x22, 0x71, 0x21, 0x58, 0x42, 0xdb, 0xd9, 0x5b, 0x73, 0x22, 0xaf, + 0x14, 0xee, 0xc4, 0x05, 0xbb, 0x65, 0xcd, 0xee, 0x46, 0xf4, 0x14, 0x56, 0x5b, 0x04, 0x4d, 0x58, + 0xc1, 0x68, 0x5e, 0xb6, 0x7b, 0xff, 0x10, 0xea, 0xda, 0x92, 0x2c, 0xaa, 0x66, 0x65, 0x2f, 0x6c, + 0x80, 0x62, 0x59, 0x5e, 0x54, 0xa5, 0x39, 0xa8, 0xfd, 0x0d, 0x40, 0xf6, 0xc3, 0x57, 0x19, 0x4e, + 0xb4, 0x93, 0xf1, 0xe9, 0xb1, 0xf5, 0xaf, 0x7f, 0xd6, 0x8a, 0x3a, 0xeb, 0xc3, 0xa7, 0xfb, 0x00, + 0xa3, 0x7b, 0x1e, 0xe9, 0xa0, 0x2d, 0xdb, 0x95, 0xda, 0x52, 0x21, 0xd1, 0x2e, 0xd3, 0x84, 0x42, + 0xb2, 0x9d, 0xa2, 0xc9, 0xb7, 0x3f, 0x36, 0xa1, 0x1f, 0xf3, 0x82, 0x25, 0x68, 0x0c, 0xc3, 0x99, + 0x7f, 0xe9, 0x07, 0x5f, 0x7c, 0xe3, 0x3f, 0xb4, 0x0f, 0xbb, 0x4e, 0xe0, 0x79, 0x76, 0x7c, 0x11, + 0xf8, 0x78, 0x1a, 0x9c, 0x5d, 0xe3, 0xd0, 0xfd, 0x34, 0x73, 0xa3, 0xd8, 0xd0, 0xd0, 0x01, 0x3c, + 0xfb, 0x4b, 0x8b, 0xae, 0x02, 0x3f, 0x72, 0x8d, 0x0d, 0x64, 0x80, 0x1e, 0x87, 0xb6, 0x1f, 0xd9, + 0x8e, 0x92, 0x23, 0x63, 0x13, 0xbd, 0x84, 0xfd, 0xa9, 0x6b, 0x3b, 0xca, 0xeb, 0x05, 0xce, 0x25, + 0x3e, 0xb7, 0xa3, 0x73, 0x6c, 0xfb, 0x7e, 0x30, 0xf3, 0x1d, 0xd7, 0xe8, 0x21, 0x13, 0xb6, 0x1f, + 0xe9, 0xdd, 0xa1, 0x3e, 0x7a, 0x0d, 0xc7, 0xeb, 0x14, 0x3c, 0xbd, 0xc6, 0x91, 0x17, 0xc4, 0xd8, + 0x9f, 0x7d, 0x9c, 0xba, 0xa1, 0x31, 0x40, 0x7b, 0xb0, 0xb3, 0x62, 0x6c, 0xfb, 0x0c, 0xd1, 0x2b, + 0x98, 0x38, 0xe1, 0x75, 0x14, 0xdb, 0x9e, 0x77, 0xf1, 0xd5, 0x3d, 0xc3, 0x51, 0x6c, 0xc7, 0xee, + 0x4a, 0x87, 0x2d, 0xd5, 0x71, 0x8d, 0xab, 0x6b, 0x32, 0x42, 0x87, 0x70, 0xb0, 0x56, 0x6f, 0xcf, + 0x80, 0x0a, 0x50, 0x8b, 0x3f, 0xbb, 0x6b, 0x0f, 0x8c, 0xd5, 0xc8, 0x47, 0x7a, 0x17, 0xad, 0xab, + 0xee, 0x2b, 0x4a, 0x1b, 0xfa, 0xff, 0xcd, 0xa0, 0xfe, 0xc4, 0xdf, 0xff, 0x0e, 0x00, 0x00, 0xff, + 0xff, 0xdb, 0xf5, 0x43, 0x2a, 0xf4, 0x03, 0x00, 0x00, } diff --git a/proto/sharding/p2p/v1/messages.proto b/proto/sharding/p2p/v1/messages.proto index 28ab815dd34..e9f8761e2fb 100644 --- a/proto/sharding/p2p/v1/messages.proto +++ b/proto/sharding/p2p/v1/messages.proto @@ -10,13 +10,14 @@ enum Topic { TRANSACTIONS = 3; BEACON_BLOCK_HASH_ANNOUNCE = 4; BEACON_BLOCK_REQUEST = 5; - BEACON_BLOCK_RESPONSE = 6; - CRYSTALLIZED_STATE_HASH_ANNOUNCE = 7; - CRYSTALLIZED_STATE_REQUEST = 8; - CRYSTALLIZED_STATE_RESPONSE = 9; - ACTIVE_STATE_HASH_ANNOUNCE = 10; - ACTIVE_STATE_REQUEST = 11; - ACTIVE_STATE_RESPONSE = 12; + BEACON_BLOCK_REQUEST_BY_SLOT_NUMBER = 6; + BEACON_BLOCK_RESPONSE = 7; + CRYSTALLIZED_STATE_HASH_ANNOUNCE = 8; + CRYSTALLIZED_STATE_REQUEST = 9; + CRYSTALLIZED_STATE_RESPONSE = 10; + ACTIVE_STATE_HASH_ANNOUNCE = 11; + ACTIVE_STATE_REQUEST = 12; + ACTIVE_STATE_RESPONSE = 13; } message CollationBodyRequest { diff --git a/shared/p2p/topics.go b/shared/p2p/topics.go index a91ac0e2966..1cacf1ef349 100644 --- a/shared/p2p/topics.go +++ b/shared/p2p/topics.go @@ -9,18 +9,19 @@ import ( // Mapping of message topic enums to protobuf types. var topicTypeMapping = map[shardpb.Topic]reflect.Type{ - shardpb.Topic_BEACON_BLOCK_HASH_ANNOUNCE: reflect.TypeOf(beaconpb.BeaconBlockHashAnnounce{}), - shardpb.Topic_BEACON_BLOCK_REQUEST: reflect.TypeOf(beaconpb.BeaconBlockRequest{}), - shardpb.Topic_BEACON_BLOCK_RESPONSE: reflect.TypeOf(beaconpb.BeaconBlockResponse{}), - shardpb.Topic_COLLATION_BODY_REQUEST: reflect.TypeOf(shardpb.CollationBodyRequest{}), - shardpb.Topic_COLLATION_BODY_RESPONSE: reflect.TypeOf(shardpb.CollationBodyResponse{}), - shardpb.Topic_TRANSACTIONS: reflect.TypeOf(shardpb.Transaction{}), - shardpb.Topic_CRYSTALLIZED_STATE_HASH_ANNOUNCE: reflect.TypeOf(beaconpb.CrystallizedStateHashAnnounce{}), - shardpb.Topic_CRYSTALLIZED_STATE_REQUEST: reflect.TypeOf(beaconpb.CrystallizedStateRequest{}), - shardpb.Topic_CRYSTALLIZED_STATE_RESPONSE: reflect.TypeOf(beaconpb.CrystallizedStateResponse{}), - shardpb.Topic_ACTIVE_STATE_HASH_ANNOUNCE: reflect.TypeOf(beaconpb.ActiveStateHashAnnounce{}), - shardpb.Topic_ACTIVE_STATE_REQUEST: reflect.TypeOf(beaconpb.ActiveStateRequest{}), - shardpb.Topic_ACTIVE_STATE_RESPONSE: reflect.TypeOf(beaconpb.ActiveStateResponse{}), + shardpb.Topic_BEACON_BLOCK_HASH_ANNOUNCE: reflect.TypeOf(beaconpb.BeaconBlockHashAnnounce{}), + shardpb.Topic_BEACON_BLOCK_REQUEST: reflect.TypeOf(beaconpb.BeaconBlockRequest{}), + shardpb.Topic_BEACON_BLOCK_REQUEST_BY_SLOT_NUMBER: reflect.TypeOf(beaconpb.BeaconBlockRequestBySlotNumber{}), + shardpb.Topic_BEACON_BLOCK_RESPONSE: reflect.TypeOf(beaconpb.BeaconBlockResponse{}), + shardpb.Topic_COLLATION_BODY_REQUEST: reflect.TypeOf(shardpb.CollationBodyRequest{}), + shardpb.Topic_COLLATION_BODY_RESPONSE: reflect.TypeOf(shardpb.CollationBodyResponse{}), + shardpb.Topic_TRANSACTIONS: reflect.TypeOf(shardpb.Transaction{}), + shardpb.Topic_CRYSTALLIZED_STATE_HASH_ANNOUNCE: reflect.TypeOf(beaconpb.CrystallizedStateHashAnnounce{}), + shardpb.Topic_CRYSTALLIZED_STATE_REQUEST: reflect.TypeOf(beaconpb.CrystallizedStateRequest{}), + shardpb.Topic_CRYSTALLIZED_STATE_RESPONSE: reflect.TypeOf(beaconpb.CrystallizedStateResponse{}), + shardpb.Topic_ACTIVE_STATE_HASH_ANNOUNCE: reflect.TypeOf(beaconpb.ActiveStateHashAnnounce{}), + shardpb.Topic_ACTIVE_STATE_REQUEST: reflect.TypeOf(beaconpb.ActiveStateRequest{}), + shardpb.Topic_ACTIVE_STATE_RESPONSE: reflect.TypeOf(beaconpb.ActiveStateResponse{}), } // Mapping of message types to topic enums.