diff --git a/beacon-chain/p2p/peers/status.go b/beacon-chain/p2p/peers/status.go index 63ebd286c06..3adf3eb33da 100644 --- a/beacon-chain/p2p/peers/status.go +++ b/beacon-chain/p2p/peers/status.go @@ -369,8 +369,21 @@ func (p *Status) Connected() []peer.ID { return peers } -// Inbound returns the current batch of inbound peers that are connected. +// Inbound returns the current batch of inbound peers. func (p *Status) Inbound() []peer.ID { + p.store.RLock() + defer p.store.RUnlock() + peers := make([]peer.ID, 0) + for pid, peerData := range p.store.Peers() { + if peerData.Direction == network.DirInbound { + peers = append(peers, pid) + } + } + return peers +} + +// InboundConnected returns the current batch of inbound peers that are connected. +func (p *Status) InboundConnected() []peer.ID { p.store.RLock() defer p.store.RUnlock() peers := make([]peer.ID, 0) @@ -382,8 +395,21 @@ func (p *Status) Inbound() []peer.ID { return peers } -// Outbound returns the current batch of outbound peers that are connected. +// Outbound returns the current batch of outbound peers. func (p *Status) Outbound() []peer.ID { + p.store.RLock() + defer p.store.RUnlock() + peers := make([]peer.ID, 0) + for pid, peerData := range p.store.Peers() { + if peerData.Direction == network.DirOutbound { + peers = append(peers, pid) + } + } + return peers +} + +// OutboundConnected returns the current batch of outbound peers that are connected. +func (p *Status) OutboundConnected() []peer.ID { p.store.RLock() defer p.store.RUnlock() peers := make([]peer.ID, 0) diff --git a/beacon-chain/p2p/peers/status_test.go b/beacon-chain/p2p/peers/status_test.go index f8240efc519..f74c0580bc5 100644 --- a/beacon-chain/p2p/peers/status_test.go +++ b/beacon-chain/p2p/peers/status_test.go @@ -690,7 +690,7 @@ func TestPrunePeers(t *testing.T) { } // Set up bad scores for inbound peers. - inboundPeers := p.Inbound() + inboundPeers := p.InboundConnected() for i, pid := range inboundPeers { modulo := i % 5 // Increment bad scores for peers. @@ -950,6 +950,44 @@ func TestStatus_CurrentEpoch(t *testing.T) { assert.Equal(t, uint64(5), p.HighestEpoch(), "Expected current epoch to be 5") } +func TestInbound(t *testing.T) { + p := peers.NewStatus(context.Background(), &peers.StatusConfig{ + PeerLimit: 30, + ScorerParams: &scorers.Config{ + BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{ + Threshold: 0, + }, + }, + }) + addr, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/33333") + require.NoError(t, err) + inbound := createPeer(t, p, addr, network.DirInbound, peers.PeerConnected) + createPeer(t, p, addr, network.DirOutbound, peers.PeerConnected) + + result := p.Inbound() + require.Equal(t, 1, len(result)) + assert.Equal(t, inbound.Pretty(), result[0].Pretty()) +} + +func TestOutbound(t *testing.T) { + p := peers.NewStatus(context.Background(), &peers.StatusConfig{ + PeerLimit: 30, + ScorerParams: &scorers.Config{ + BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{ + Threshold: 0, + }, + }, + }) + addr, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/33333") + require.NoError(t, err) + createPeer(t, p, addr, network.DirInbound, peers.PeerConnected) + outbound := createPeer(t, p, addr, network.DirOutbound, peers.PeerConnected) + + result := p.Outbound() + require.Equal(t, 1, len(result)) + assert.Equal(t, outbound.Pretty(), result[0].Pretty()) +} + // addPeer is a helper to add a peer with a given connection state) func addPeer(t *testing.T, p *peers.Status, state peerdata.PeerConnectionState) peer.ID { // Set up some peers with different states diff --git a/beacon-chain/p2p/service.go b/beacon-chain/p2p/service.go index ec0e03d7b32..3b1aad1ed44 100644 --- a/beacon-chain/p2p/service.go +++ b/beacon-chain/p2p/service.go @@ -234,8 +234,8 @@ func (s *Service) Start() { }) runutil.RunEvery(s.ctx, 1*time.Minute, func() { log.WithFields(logrus.Fields{ - "inbound": len(s.peers.Inbound()), - "outbound": len(s.peers.Outbound()), + "inbound": len(s.peers.InboundConnected()), + "outbound": len(s.peers.OutboundConnected()), "activePeers": len(s.peers.Active()), }).Info("Peer summary") }) diff --git a/beacon-chain/p2p/testing/mock_peersprovider.go b/beacon-chain/p2p/testing/mock_peersprovider.go index e421d0935d6..959c7143117 100644 --- a/beacon-chain/p2p/testing/mock_peersprovider.go +++ b/beacon-chain/p2p/testing/mock_peersprovider.go @@ -22,6 +22,20 @@ type MockPeersProvider struct { peers *peers.Status } +// ClearPeers removes all known peers. +func (m *MockPeersProvider) ClearPeers() { + m.lock.Lock() + defer m.lock.Unlock() + m.peers = peers.NewStatus(context.Background(), &peers.StatusConfig{ + PeerLimit: 30, + ScorerParams: &scorers.Config{ + BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{ + Threshold: 5, + }, + }, + }) +} + // Peers provides access the peer status. func (m *MockPeersProvider) Peers() *peers.Status { m.lock.Lock() diff --git a/beacon-chain/rpc/nodev1/BUILD.bazel b/beacon-chain/rpc/nodev1/BUILD.bazel index 30c835b99e9..666b298160c 100644 --- a/beacon-chain/rpc/nodev1/BUILD.bazel +++ b/beacon-chain/rpc/nodev1/BUILD.bazel @@ -13,6 +13,7 @@ go_library( "//beacon-chain/blockchain:go_default_library", "//beacon-chain/db:go_default_library", "//beacon-chain/p2p:go_default_library", + "//beacon-chain/p2p/peers:go_default_library", "//beacon-chain/p2p/peers/peerdata:go_default_library", "//beacon-chain/sync:go_default_library", "//shared/version:go_default_library", @@ -37,6 +38,7 @@ go_test( deps = [ "//beacon-chain/blockchain/testing:go_default_library", "//beacon-chain/p2p:go_default_library", + "//beacon-chain/p2p/peers:go_default_library", "//beacon-chain/p2p/testing:go_default_library", "//beacon-chain/sync/initial-sync/testing:go_default_library", "//proto/beacon/p2p/v1:go_default_library", diff --git a/beacon-chain/rpc/nodev1/node.go b/beacon-chain/rpc/nodev1/node.go index cf255f039ac..9f7eca92fb4 100644 --- a/beacon-chain/rpc/nodev1/node.go +++ b/beacon-chain/rpc/nodev1/node.go @@ -4,12 +4,14 @@ import ( "context" "fmt" "runtime" + "strings" ptypes "github.com/gogo/protobuf/types" "github.com/libp2p/go-libp2p-core/peer" "github.com/pkg/errors" ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1" "github.com/prysmaticlabs/prysm/beacon-chain/p2p" + "github.com/prysmaticlabs/prysm/beacon-chain/p2p/peers" "github.com/prysmaticlabs/prysm/beacon-chain/p2p/peers/peerdata" "github.com/prysmaticlabs/prysm/shared/version" "go.opencensus.io/trace" @@ -17,6 +19,15 @@ import ( "google.golang.org/grpc/status" ) +var ( + stateConnecting = ethpb.ConnectionState_CONNECTING.String() + stateConnected = ethpb.ConnectionState_CONNECTED.String() + stateDisconnecting = ethpb.ConnectionState_DISCONNECTING.String() + stateDisconnected = ethpb.ConnectionState_DISCONNECTED.String() + directionInbound = ethpb.PeerDirection_INBOUND.String() + directionOutbound = ethpb.PeerDirection_OUTBOUND.String() +) + // GetIdentity retrieves data about the node's network presence. func (ns *Server) GetIdentity(ctx context.Context, _ *ptypes.Empty) (*ethpb.IdentityResponse, error) { ctx, span := trace.StartSpan(ctx, "nodeV1.GetIdentity") @@ -88,7 +99,7 @@ func (ns *Server) GetPeer(ctx context.Context, req *ethpb.PeerRequest) (*ethpb.P } state, err := peerStatus.ConnectionState(id) if err != nil { - return nil, status.Errorf(codes.Internal, "Could not obtain state: %v", err) + return nil, status.Errorf(codes.Internal, "Could not obtain connection state: %v", err) } direction, err := peerStatus.Direction(id) if err != nil { @@ -107,7 +118,99 @@ func (ns *Server) GetPeer(ctx context.Context, req *ethpb.PeerRequest) (*ethpb.P } // ListPeers retrieves data about the node's network peers. -func (ns *Server) ListPeers(ctx context.Context, _ *ptypes.Empty) (*ethpb.PeersResponse, error) { +func (ns *Server) ListPeers(ctx context.Context, req *ethpb.PeersRequest) (*ethpb.PeersResponse, error) { + ctx, span := trace.StartSpan(ctx, "nodev1.ListPeers") + defer span.End() + + peerStatus := ns.PeersFetcher.Peers() + emptyStateFilter, emptyDirectionFilter := ns.handleEmptyFilters(req, peerStatus) + + if emptyStateFilter && emptyDirectionFilter { + allIds := peerStatus.All() + allPeers := make([]*ethpb.Peer, 0, len(allIds)) + for _, id := range allIds { + p, err := peerInfo(peerStatus, id) + if err != nil { + return nil, err + } + allPeers = append(allPeers, p) + } + return ðpb.PeersResponse{Data: allPeers}, nil + } + + var stateIds []peer.ID + if emptyStateFilter { + stateIds = peerStatus.All() + } else { + for _, stateFilter := range req.State { + normalized := strings.ToUpper(stateFilter) + if normalized == stateConnecting { + ids := peerStatus.Connecting() + stateIds = append(stateIds, ids...) + continue + } + if normalized == stateConnected { + ids := peerStatus.Connected() + stateIds = append(stateIds, ids...) + continue + } + if normalized == stateDisconnecting { + ids := peerStatus.Disconnecting() + stateIds = append(stateIds, ids...) + continue + } + if normalized == stateDisconnected { + ids := peerStatus.Disconnected() + stateIds = append(stateIds, ids...) + continue + } + } + } + + var directionIds []peer.ID + if emptyDirectionFilter { + directionIds = peerStatus.All() + } else { + for _, directionFilter := range req.Direction { + normalized := strings.ToUpper(directionFilter) + if normalized == directionInbound { + ids := peerStatus.Inbound() + directionIds = append(directionIds, ids...) + continue + } + if normalized == directionOutbound { + ids := peerStatus.Outbound() + directionIds = append(directionIds, ids...) + continue + } + } + } + + var filteredIds []peer.ID + for _, stateId := range stateIds { + for _, directionId := range directionIds { + if stateId.Pretty() == directionId.Pretty() { + filteredIds = append(filteredIds, stateId) + break + } + } + } + filteredPeers := make([]*ethpb.Peer, 0, len(filteredIds)) + for _, id := range filteredIds { + p, err := peerInfo(peerStatus, id) + if err != nil { + return nil, err + } + filteredPeers = append(filteredPeers, p) + } + return ðpb.PeersResponse{Data: filteredPeers}, nil +} + +// PeerCount retrieves retrieves number of known peers. +func (ns *Server) PeerCount(ctx context.Context, _ *ptypes.Empty) (*ethpb.PeerCountResponse, error) { + ctx, span := trace.StartSpan(ctx, "nodev1.PeerCount") + defer span.End() + return nil, errors.New("unimplemented") } @@ -127,7 +230,10 @@ func (ns *Server) GetVersion(ctx context.Context, _ *ptypes.Empty) (*ethpb.Versi // GetSyncStatus requests the beacon node to describe if it's currently syncing or not, and // if it is, what block it is up to. -func (ns *Server) GetSyncStatus(_ context.Context, _ *ptypes.Empty) (*ethpb.SyncingResponse, error) { +func (ns *Server) GetSyncStatus(ctx context.Context, _ *ptypes.Empty) (*ethpb.SyncingResponse, error) { + ctx, span := trace.StartSpan(ctx, "nodev1.GetSyncStatus") + defer span.End() + headSlot := ns.HeadFetcher.HeadSlot() return ðpb.SyncingResponse{ Data: ðpb.SyncInfo{ @@ -154,3 +260,60 @@ func (ns *Server) GetHealth(ctx context.Context, _ *ptypes.Empty) (*ptypes.Empty } return &ptypes.Empty{}, status.Error(codes.Internal, "Node not initialized or having issues") } + +func (ns *Server) handleEmptyFilters(req *ethpb.PeersRequest, peerStatus *peers.Status) (emptyState, emptyDirection bool) { + emptyState = true + for _, stateFilter := range req.State { + normalized := strings.ToUpper(stateFilter) + filterValid := normalized == stateConnecting || normalized == stateConnected || + normalized == stateDisconnecting || normalized == stateDisconnected + if filterValid { + emptyState = false + break + } + } + + emptyDirection = true + for _, directionFilter := range req.Direction { + normalized := strings.ToUpper(directionFilter) + filterValid := normalized == directionInbound || normalized == directionOutbound + if filterValid { + emptyDirection = false + break + } + } + + return emptyState, emptyDirection +} + +func peerInfo(peerStatus *peers.Status, id peer.ID) (*ethpb.Peer, error) { + enr, err := peerStatus.ENR(id) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not obtain ENR: %v", err) + } + serializedEnr, err := p2p.SerializeENR(enr) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not serialize ENR: %v", err) + } + address, err := peerStatus.Address(id) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not obtain address: %v", err) + } + connectionState, err := peerStatus.ConnectionState(id) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not obtain connection state: %v", err) + } + direction, err := peerStatus.Direction(id) + if err != nil { + return nil, status.Errorf(codes.Internal, "Could not obtain direction: %v", err) + } + p := ethpb.Peer{ + PeerId: id.Pretty(), + Enr: "enr:" + serializedEnr, + Address: address.String(), + State: ethpb.ConnectionState(connectionState), + Direction: ethpb.PeerDirection(direction), + } + + return &p, nil +} diff --git a/beacon-chain/rpc/nodev1/node_test.go b/beacon-chain/rpc/nodev1/node_test.go index b35055326d2..667e141486e 100644 --- a/beacon-chain/rpc/nodev1/node_test.go +++ b/beacon-chain/rpc/nodev1/node_test.go @@ -4,6 +4,7 @@ import ( "context" "fmt" "runtime" + "strconv" "strings" "testing" @@ -12,12 +13,13 @@ import ( ptypes "github.com/gogo/protobuf/types" "github.com/libp2p/go-libp2p-core/network" "github.com/libp2p/go-libp2p-core/peer" - "github.com/libp2p/go-libp2p-peerstore/test" + libp2ptest "github.com/libp2p/go-libp2p-peerstore/test" ma "github.com/multiformats/go-multiaddr" ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1" "github.com/prysmaticlabs/go-bitfield" mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing" "github.com/prysmaticlabs/prysm/beacon-chain/p2p" + "github.com/prysmaticlabs/prysm/beacon-chain/p2p/peers" mockp2p "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing" syncmock "github.com/prysmaticlabs/prysm/beacon-chain/sync/initial-sync/testing" pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1" @@ -201,8 +203,183 @@ func TestGetPeer(t *testing.T) { }) t.Run("Peer not found", func(t *testing.T) { - generatedId := string(test.GeneratePeerIDs(1)[0]) + generatedId := string(libp2ptest.GeneratePeerIDs(1)[0]) _, err = s.GetPeer(ctx, ðpb.PeerRequest{PeerId: generatedId}) assert.ErrorContains(t, "Peer not found", err) }) } + +func TestListPeers(t *testing.T) { + ids := libp2ptest.GeneratePeerIDs(8) + peerFetcher := &mockp2p.MockPeersProvider{} + peerFetcher.ClearPeers() + peerStatus := peerFetcher.Peers() + + for i, id := range ids { + enrRecord := &enr.Record{} + err := enrRecord.SetSig(dummyIdentity{1}, []byte{42}) + require.NoError(t, err) + enrRecord.Set(enr.IPv4{127, 0, 0, byte(i)}) + err = enrRecord.SetSig(dummyIdentity{}, []byte{}) + require.NoError(t, err) + var p2pAddr = "/ip4/127.0.0." + strconv.Itoa(i) + "/udp/30303/p2p/QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N" + p2pMultiAddr, err := ma.NewMultiaddr(p2pAddr) + require.NoError(t, err) + + var direction network.Direction + if i%2 == 0 { + direction = network.DirInbound + } else { + direction = network.DirOutbound + } + peerStatus.Add(enrRecord, id, p2pMultiAddr, direction) + + switch i { + case 0, 1: + peerStatus.SetConnectionState(id, peers.PeerConnecting) + case 2, 3: + peerStatus.SetConnectionState(id, peers.PeerConnected) + case 4, 5: + peerStatus.SetConnectionState(id, peers.PeerDisconnecting) + case 6, 7: + peerStatus.SetConnectionState(id, peers.PeerDisconnected) + default: + t.Fatalf("Failed to set connection state for peer") + } + } + + s := Server{PeersFetcher: peerFetcher} + + t.Run("Peer data OK", func(t *testing.T) { + // We will check the first peer from the list. + expectedId := ids[0] + + resp, err := s.ListPeers(context.Background(), ðpb.PeersRequest{ + State: []string{ethpb.ConnectionState_CONNECTING.String()}, + Direction: []string{ethpb.PeerDirection_INBOUND.String()}, + }) + require.NoError(t, err) + require.Equal(t, 1, len(resp.Data)) + returnedPeer := resp.Data[0] + assert.Equal(t, expectedId.Pretty(), returnedPeer.PeerId) + expectedEnr, err := peerStatus.ENR(expectedId) + require.NoError(t, err) + serializedEnr, err := p2p.SerializeENR(expectedEnr) + require.NoError(t, err) + assert.Equal(t, "enr:"+serializedEnr, returnedPeer.Enr) + expectedP2PAddr, err := peerStatus.Address(expectedId) + require.NoError(t, err) + assert.Equal(t, expectedP2PAddr.String(), returnedPeer.Address) + assert.Equal(t, ethpb.ConnectionState_CONNECTING, returnedPeer.State) + assert.Equal(t, ethpb.PeerDirection_INBOUND, returnedPeer.Direction) + }) + + filterTests := []struct { + name string + states []string + directions []string + wantIds []peer.ID + }{ + { + name: "No filters - return all peers", + states: []string{}, + directions: []string{}, + wantIds: ids, + }, + { + name: "State filter empty - return peers for all states", + states: []string{}, + directions: []string{ethpb.PeerDirection_INBOUND.String()}, + wantIds: []peer.ID{ids[0], ids[2], ids[4], ids[6]}, + }, + { + name: "Direction filter empty - return peers for all directions", + states: []string{ethpb.ConnectionState_CONNECTED.String()}, + directions: []string{}, + wantIds: []peer.ID{ids[2], ids[3]}, + }, + { + name: "One state and direction", + states: []string{ethpb.ConnectionState_DISCONNECTED.String()}, + directions: []string{ethpb.PeerDirection_INBOUND.String()}, + wantIds: []peer.ID{ids[6]}, + }, + { + name: "Multiple states and directions", + states: []string{ethpb.ConnectionState_CONNECTING.String(), ethpb.ConnectionState_DISCONNECTING.String()}, + directions: []string{ethpb.PeerDirection_INBOUND.String(), ethpb.PeerDirection_OUTBOUND.String()}, + wantIds: []peer.ID{ids[0], ids[1], ids[4], ids[5]}, + }, + { + name: "Unknown filter is ignored", + states: []string{ethpb.ConnectionState_CONNECTED.String(), "foo"}, + directions: []string{ethpb.PeerDirection_OUTBOUND.String(), "bar"}, + wantIds: []peer.ID{ids[3]}, + }, + { + name: "Only unknown filters - return all peers", + states: []string{"foo"}, + directions: []string{"bar"}, + wantIds: ids, + }, + { + name: "Letter case does not matter", + states: []string{strings.ToLower(ethpb.ConnectionState_DISCONNECTED.String())}, + directions: []string{strings.ToLower(ethpb.PeerDirection_OUTBOUND.String())}, + wantIds: []peer.ID{ids[7]}, + }, + } + for _, tt := range filterTests { + t.Run(tt.name, func(t *testing.T) { + resp, err := s.ListPeers(context.Background(), ðpb.PeersRequest{ + State: tt.states, + Direction: tt.directions, + }) + require.NoError(t, err) + assert.Equal(t, len(tt.wantIds), len(resp.Data), "Wrong number of peers returned") + for _, id := range tt.wantIds { + expectedId := id.Pretty() + found := false + for _, returnedPeer := range resp.Data { + if returnedPeer.PeerId == expectedId { + found = true + break + } + } + if !found { + t.Errorf("Expected ID '" + expectedId + "' not found") + } + } + }) + } +} + +func BenchmarkListPeers(b *testing.B) { + // We simulate having a lot of peers. + ids := libp2ptest.GeneratePeerIDs(2000) + peerFetcher := &mockp2p.MockPeersProvider{} + + for _, id := range ids { + enrRecord := &enr.Record{} + err := enrRecord.SetSig(dummyIdentity{1}, []byte{42}) + require.NoError(b, err) + enrRecord.Set(enr.IPv4{7, 7, 7, 7}) + err = enrRecord.SetSig(dummyIdentity{}, []byte{}) + require.NoError(b, err) + const p2pAddr = "/ip4/7.7.7.7/udp/30303/p2p/QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N" + p2pMultiAddr, err := ma.NewMultiaddr(p2pAddr) + require.NoError(b, err) + peerFetcher.Peers().Add(enrRecord, id, p2pMultiAddr, network.DirInbound) + } + + s := Server{PeersFetcher: peerFetcher} + + b.ResetTimer() + for i := 0; i < b.N; i++ { + _, err := s.ListPeers(context.Background(), ðpb.PeersRequest{ + State: []string{}, + Direction: []string{}, + }) + require.NoError(b, err) + } +} diff --git a/deps.bzl b/deps.bzl index 3ce14b05694..5de89dbcbb6 100644 --- a/deps.bzl +++ b/deps.bzl @@ -2580,8 +2580,8 @@ def prysm_deps(): name = "com_github_prysmaticlabs_ethereumapis", build_file_generation = "off", importpath = "github.com/prysmaticlabs/ethereumapis", - sum = "h1:69URSziUFhCVzHIDtPGMwYeP1G3JWhuBdB3enLRne6Y=", - version = "v0.0.0-20210105190001-13193818c0df", + sum = "h1:roqXwVG8cKjq6sOCbB+T5Kh+dYr1wpkk00c7/DdrqLg=", + version = "v0.0.0-20210115110118-c595a4e0c0a5", ) go_repository( name = "com_github_prysmaticlabs_go_bitfield", diff --git a/go.mod b/go.mod index 45e16e28d56..f32a6e1b46a 100644 --- a/go.mod +++ b/go.mod @@ -84,7 +84,7 @@ require ( github.com/prometheus/client_golang v1.9.0 github.com/prometheus/tsdb v0.10.0 // indirect github.com/protolambda/zssz v0.1.5 - github.com/prysmaticlabs/ethereumapis v0.0.0-20210105190001-13193818c0df + github.com/prysmaticlabs/ethereumapis v0.0.0-20210115110118-c595a4e0c0a5 github.com/prysmaticlabs/go-bitfield v0.0.0-20210120104942-c3214972eb2e github.com/prysmaticlabs/go-ssz v0.0.0-20200612203617-6d5c9aa213ae github.com/prysmaticlabs/prombbolt v0.0.0-20200324184628-09789ef63796 diff --git a/go.sum b/go.sum index 5b9e60c09e4..d83469307a9 100644 --- a/go.sum +++ b/go.sum @@ -1107,8 +1107,8 @@ github.com/protolambda/zssz v0.1.5 h1:7fjJjissZIIaa2QcvmhS/pZISMX21zVITt49sW1oue github.com/protolambda/zssz v0.1.5/go.mod h1:a4iwOX5FE7/JkKA+J/PH0Mjo9oXftN6P8NZyL28gpag= github.com/prysmaticlabs/bazel-go-ethereum v0.0.0-20201126065335-1fb46e307951 h1:Jncuyb/nIJgXbEe0iGz3MN5JmijPVGzwk3G5FR01phI= github.com/prysmaticlabs/bazel-go-ethereum v0.0.0-20201126065335-1fb46e307951/go.mod h1:JIfVb6esrqALTExdz9hRYvrP0xBDf6wCncIu1hNwHpM= -github.com/prysmaticlabs/ethereumapis v0.0.0-20210105190001-13193818c0df h1:69URSziUFhCVzHIDtPGMwYeP1G3JWhuBdB3enLRne6Y= -github.com/prysmaticlabs/ethereumapis v0.0.0-20210105190001-13193818c0df/go.mod h1:k7b2dxy6RppCG6kmOJkNOXzRpEoTdsPygc2aQhsUsZk= +github.com/prysmaticlabs/ethereumapis v0.0.0-20210115110118-c595a4e0c0a5 h1:roqXwVG8cKjq6sOCbB+T5Kh+dYr1wpkk00c7/DdrqLg= +github.com/prysmaticlabs/ethereumapis v0.0.0-20210115110118-c595a4e0c0a5/go.mod h1:k7b2dxy6RppCG6kmOJkNOXzRpEoTdsPygc2aQhsUsZk= github.com/prysmaticlabs/go-bitfield v0.0.0-20200322041314-62c2aee71669 h1:cX6YRZnZ9sgMqM5U14llxUiXVNJ3u07Res1IIjTOgtI= github.com/prysmaticlabs/go-bitfield v0.0.0-20200322041314-62c2aee71669/go.mod h1:hCwmef+4qXWjv0jLDbQdWnL0Ol7cS7/lCSS26WR+u6s= github.com/prysmaticlabs/go-bitfield v0.0.0-20210120104942-c3214972eb2e h1:teHQyJxTD1ZOLmdnIgNYFBruxZX9Cjo/NlSU2AmumwI=