p2p

package
v1.9.7-0...-06ccbb3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 7, 2025 License: GPL-3.0 Imports: 24 Imported by: 0

Documentation

Overview

Package p2p is a generated GoMock package.

Index

Constants

This section is empty.

Variables

View Source 
var ErrPeerNotFound = errors.New("peer not found")

Functions

func PreservingPeerShuffle 

func PreservingPeerShuffle(_ []*PeerId)

func RandPeerShuffle 

func RandPeerShuffle(peerIds []*PeerId)

Types

type DecodedInboundMessage 

type DecodedInboundMessage[TPacket any] struct {
	*sentry.InboundMessage
	Decoded TPacket
	PeerId  *PeerId
}

type ErrIncompleteHeaders 

type ErrIncompleteHeaders struct {
	// contains filtered or unexported fields
}

func (ErrIncompleteHeaders) Error 

func (e ErrIncompleteHeaders) Error() string

func (ErrIncompleteHeaders) Is 

func (e ErrIncompleteHeaders) Is(err error) bool

func (ErrIncompleteHeaders) LowestMissingBlockNum 

func (e ErrIncompleteHeaders) LowestMissingBlockNum() uint64

type ErrInvalidFetchHeadersRange 

type ErrInvalidFetchHeadersRange struct {
	// contains filtered or unexported fields
}

func (ErrInvalidFetchHeadersRange) Error 

func (e ErrInvalidFetchHeadersRange) Error() string

func (ErrInvalidFetchHeadersRange) Is 

func (e ErrInvalidFetchHeadersRange) Is(err error) bool

type ErrMissingBodies 

type ErrMissingBodies struct {
	// contains filtered or unexported fields
}

func NewErrMissingBodies 

func NewErrMissingBodies(headers []*types.Header) *ErrMissingBodies

func (ErrMissingBodies) Error 

func (e ErrMissingBodies) Error() string

func (ErrMissingBodies) Is 

func (e ErrMissingBodies) Is(err error) bool

func (ErrMissingBodies) LowestMissingBlockNum 

func (e ErrMissingBodies) LowestMissingBlockNum() (uint64, bool)

type ErrNonSequentialHeaderNumbers 

type ErrNonSequentialHeaderNumbers struct {
	// contains filtered or unexported fields
}

func (ErrNonSequentialHeaderNumbers) Error 

func (e ErrNonSequentialHeaderNumbers) Error() string

func (ErrNonSequentialHeaderNumbers) Is 

func (e ErrNonSequentialHeaderNumbers) Is(err error) bool

type ErrTooManyBodies 

type ErrTooManyBodies struct {
	// contains filtered or unexported fields
}

func (ErrTooManyBodies) Error 

func (e ErrTooManyBodies) Error() string

func (ErrTooManyBodies) Is 

func (e ErrTooManyBodies) Is(err error) bool

type ErrTooManyHeaders 

type ErrTooManyHeaders struct {
	// contains filtered or unexported fields
}

func (ErrTooManyHeaders) Error 

func (e ErrTooManyHeaders) Error() string

func (ErrTooManyHeaders) Is 

func (e ErrTooManyHeaders) Is(err error) bool

type Fetcher 

type Fetcher interface {
	// FetchHeaders fetches [start,end) headers from a peer. Blocks until data is received.
	FetchHeaders(ctx context.Context, start uint64, end uint64, peerId *PeerId) (FetcherResponse[[]*types.Header], error)
	// FetchBodies fetches block bodies for the given headers from a peer. Blocks until data is received.
	FetchBodies(ctx context.Context, headers []*types.Header, peerId *PeerId) (FetcherResponse[[]*types.Body], error)
	// FetchBlocks fetches headers and bodies for a given [start, end) range from a peer and
	// assembles them into blocks. Blocks until data is received.
	FetchBlocks(ctx context.Context, start uint64, end uint64, peerId *PeerId) (FetcherResponse[[]*types.Block], error)
}

func NewFetcher 

func NewFetcher(
	config FetcherConfig,
	messageListener MessageListener,
	messageSender MessageSender,
	requestIdGenerator RequestIdGenerator,
) Fetcher

func NewPenalizingFetcher 

func NewPenalizingFetcher(logger log.Logger, fetcher Fetcher, peerPenalizer PeerPenalizer) Fetcher

func NewTrackingFetcher 

func NewTrackingFetcher(fetcher Fetcher, peerTracker PeerTracker) Fetcher

type FetcherConfig 

type FetcherConfig struct {
	// contains filtered or unexported fields
}

type FetcherResponse 

type FetcherResponse[T any] struct {
	Data      T
	TotalSize int
}

type MessageListener 

type MessageListener interface {
	Run(ctx context.Context)
	RegisterNewBlockObserver(observer MessageObserver[*DecodedInboundMessage[*eth.NewBlockPacket]]) UnregisterFunc
	RegisterNewBlockHashesObserver(observer MessageObserver[*DecodedInboundMessage[*eth.NewBlockHashesPacket]]) UnregisterFunc
	RegisterBlockHeadersObserver(observer MessageObserver[*DecodedInboundMessage[*eth.BlockHeadersPacket66]]) UnregisterFunc
	RegisterBlockBodiesObserver(observer MessageObserver[*DecodedInboundMessage[*eth.BlockBodiesPacket66]]) UnregisterFunc
	RegisterPeerEventObserver(observer MessageObserver[*sentry.PeerEvent]) UnregisterFunc
}

func NewMessageListener 

func NewMessageListener(
	logger log.Logger,
	sentryClient direct.SentryClient,
	statusDataFactory sentrymulticlient.StatusDataFactory,
	peerPenalizer PeerPenalizer,
) MessageListener

type MessageObserver 

type MessageObserver[TMessage any] func(message TMessage)

func NewPeerEventObserver 

func NewPeerEventObserver(logger log.Logger, peerTracker PeerTracker) MessageObserver[*sentry.PeerEvent]

type MessageSender 

type MessageSender interface {
	SendGetBlockHeaders(ctx context.Context, peerId *PeerId, req eth.GetBlockHeadersPacket66) error
	SendGetBlockBodies(ctx context.Context, peerId *PeerId, req eth.GetBlockBodiesPacket66) error
}

func NewMessageSender 

func NewMessageSender(sentryClient direct.SentryClient) MessageSender

type MockService 

type MockService struct {
	// contains filtered or unexported fields
}

MockService is a mock of Service interface.

func NewMockService 

func NewMockService(ctrl *gomock.Controller) *MockService

NewMockService creates a new mock instance.

func (*MockService) BlockNumMissing 

func (m *MockService) BlockNumMissing(peerId *PeerId, blockNum uint64)

BlockNumMissing mocks base method.

func (*MockService) BlockNumPresent 

func (m *MockService) BlockNumPresent(peerId *PeerId, blockNum uint64)

BlockNumPresent mocks base method.

func (*MockService) EXPECT 

func (m *MockService) EXPECT() *MockServiceMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockService) FetchBlocks 

func (m *MockService) FetchBlocks(ctx context.Context, start, end uint64, peerId *PeerId) (FetcherResponse[[]*types.Block], error)

FetchBlocks mocks base method.

func (*MockService) FetchBodies 

func (m *MockService) FetchBodies(ctx context.Context, headers []*types.Header, peerId *PeerId) (FetcherResponse[[]*types.Body], error)

FetchBodies mocks base method.

func (*MockService) FetchHeaders 

func (m *MockService) FetchHeaders(ctx context.Context, start, end uint64, peerId *PeerId) (FetcherResponse[[]*types.Header], error)

FetchHeaders mocks base method.

func (*MockService) ListPeersMayHaveBlockNum 

func (m *MockService) ListPeersMayHaveBlockNum(blockNum uint64) []*PeerId

ListPeersMayHaveBlockNum mocks base method.

func (*MockService) MaxPeers 

func (m *MockService) MaxPeers() int

MaxPeers mocks base method.

func (*MockService) PeerConnected 

func (m *MockService) PeerConnected(peerId *PeerId)

PeerConnected mocks base method.

func (*MockService) PeerDisconnected 

func (m *MockService) PeerDisconnected(peerId *PeerId)

PeerDisconnected mocks base method.

func (*MockService) Penalize 

func (m *MockService) Penalize(ctx context.Context, peerId *PeerId) error

Penalize mocks base method.

func (*MockService) RegisterBlockBodiesObserver 

func (m *MockService) RegisterBlockBodiesObserver(observer MessageObserver[*DecodedInboundMessage[*eth.BlockBodiesPacket66]]) UnregisterFunc

RegisterBlockBodiesObserver mocks base method.

func (*MockService) RegisterBlockHeadersObserver 

func (m *MockService) RegisterBlockHeadersObserver(observer MessageObserver[*DecodedInboundMessage[*eth.BlockHeadersPacket66]]) UnregisterFunc

RegisterBlockHeadersObserver mocks base method.

func (*MockService) RegisterNewBlockHashesObserver 

func (m *MockService) RegisterNewBlockHashesObserver(observer MessageObserver[*DecodedInboundMessage[*eth.NewBlockHashesPacket]]) UnregisterFunc

RegisterNewBlockHashesObserver mocks base method.

func (*MockService) RegisterNewBlockObserver 

func (m *MockService) RegisterNewBlockObserver(observer MessageObserver[*DecodedInboundMessage[*eth.NewBlockPacket]]) UnregisterFunc

RegisterNewBlockObserver mocks base method.

func (*MockService) RegisterPeerEventObserver 

func (m *MockService) RegisterPeerEventObserver(observer MessageObserver[*sentry.PeerEvent]) UnregisterFunc

RegisterPeerEventObserver mocks base method.

func (*MockService) Run 

func (m *MockService) Run(ctx context.Context)

Run mocks base method.

type MockServiceBlockNumMissingCall 

type MockServiceBlockNumMissingCall struct {
	*gomock.Call
}

MockServiceBlockNumMissingCall wrap *gomock.Call

func (*MockServiceBlockNumMissingCall) Do 

func (c *MockServiceBlockNumMissingCall) Do(f func(*PeerId, uint64)) *MockServiceBlockNumMissingCall

Do rewrite *gomock.Call.Do

func (*MockServiceBlockNumMissingCall) DoAndReturn 

func (c *MockServiceBlockNumMissingCall) DoAndReturn(f func(*PeerId, uint64)) *MockServiceBlockNumMissingCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceBlockNumMissingCall) Return 

func (c *MockServiceBlockNumMissingCall) Return() *MockServiceBlockNumMissingCall

Return rewrite *gomock.Call.Return

type MockServiceBlockNumPresentCall 

type MockServiceBlockNumPresentCall struct {
	*gomock.Call
}

MockServiceBlockNumPresentCall wrap *gomock.Call

func (*MockServiceBlockNumPresentCall) Do 

func (c *MockServiceBlockNumPresentCall) Do(f func(*PeerId, uint64)) *MockServiceBlockNumPresentCall

Do rewrite *gomock.Call.Do

func (*MockServiceBlockNumPresentCall) DoAndReturn 

func (c *MockServiceBlockNumPresentCall) DoAndReturn(f func(*PeerId, uint64)) *MockServiceBlockNumPresentCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceBlockNumPresentCall) Return 

func (c *MockServiceBlockNumPresentCall) Return() *MockServiceBlockNumPresentCall

Return rewrite *gomock.Call.Return

type MockServiceFetchBlocksCall 

type MockServiceFetchBlocksCall struct {
	*gomock.Call
}

MockServiceFetchBlocksCall wrap *gomock.Call

func (*MockServiceFetchBlocksCall) Do 

func (c *MockServiceFetchBlocksCall) Do(f func(context.Context, uint64, uint64, *PeerId) (FetcherResponse[[]*types.Block], error)) *MockServiceFetchBlocksCall

Do rewrite *gomock.Call.Do

func (*MockServiceFetchBlocksCall) DoAndReturn 

func (c *MockServiceFetchBlocksCall) DoAndReturn(f func(context.Context, uint64, uint64, *PeerId) (FetcherResponse[[]*types.Block], error)) *MockServiceFetchBlocksCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceFetchBlocksCall) Return 

func (c *MockServiceFetchBlocksCall) Return(arg0 FetcherResponse[[]*types.Block], arg1 error) *MockServiceFetchBlocksCall

Return rewrite *gomock.Call.Return

type MockServiceFetchBodiesCall 

type MockServiceFetchBodiesCall struct {
	*gomock.Call
}

MockServiceFetchBodiesCall wrap *gomock.Call

func (*MockServiceFetchBodiesCall) Do 

func (c *MockServiceFetchBodiesCall) Do(f func(context.Context, []*types.Header, *PeerId) (FetcherResponse[[]*types.Body], error)) *MockServiceFetchBodiesCall

Do rewrite *gomock.Call.Do

func (*MockServiceFetchBodiesCall) DoAndReturn 

func (c *MockServiceFetchBodiesCall) DoAndReturn(f func(context.Context, []*types.Header, *PeerId) (FetcherResponse[[]*types.Body], error)) *MockServiceFetchBodiesCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceFetchBodiesCall) Return 

func (c *MockServiceFetchBodiesCall) Return(arg0 FetcherResponse[[]*types.Body], arg1 error) *MockServiceFetchBodiesCall

Return rewrite *gomock.Call.Return

type MockServiceFetchHeadersCall 

type MockServiceFetchHeadersCall struct {
	*gomock.Call
}

MockServiceFetchHeadersCall wrap *gomock.Call

func (*MockServiceFetchHeadersCall) Do 

func (c *MockServiceFetchHeadersCall) Do(f func(context.Context, uint64, uint64, *PeerId) (FetcherResponse[[]*types.Header], error)) *MockServiceFetchHeadersCall

Do rewrite *gomock.Call.Do

func (*MockServiceFetchHeadersCall) DoAndReturn 

func (c *MockServiceFetchHeadersCall) DoAndReturn(f func(context.Context, uint64, uint64, *PeerId) (FetcherResponse[[]*types.Header], error)) *MockServiceFetchHeadersCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceFetchHeadersCall) Return 

func (c *MockServiceFetchHeadersCall) Return(arg0 FetcherResponse[[]*types.Header], arg1 error) *MockServiceFetchHeadersCall

Return rewrite *gomock.Call.Return

type MockServiceListPeersMayHaveBlockNumCall 

type MockServiceListPeersMayHaveBlockNumCall struct {
	*gomock.Call
}

MockServiceListPeersMayHaveBlockNumCall wrap *gomock.Call

func (*MockServiceListPeersMayHaveBlockNumCall) Do 

func (c *MockServiceListPeersMayHaveBlockNumCall) Do(f func(uint64) []*PeerId) *MockServiceListPeersMayHaveBlockNumCall

Do rewrite *gomock.Call.Do

func (*MockServiceListPeersMayHaveBlockNumCall) DoAndReturn 

func (c *MockServiceListPeersMayHaveBlockNumCall) DoAndReturn(f func(uint64) []*PeerId) *MockServiceListPeersMayHaveBlockNumCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceListPeersMayHaveBlockNumCall) Return 

func (c *MockServiceListPeersMayHaveBlockNumCall) Return(arg0 []*PeerId) *MockServiceListPeersMayHaveBlockNumCall

Return rewrite *gomock.Call.Return

type MockServiceMaxPeersCall 

type MockServiceMaxPeersCall struct {
	*gomock.Call
}

MockServiceMaxPeersCall wrap *gomock.Call

func (*MockServiceMaxPeersCall) Do 

func (c *MockServiceMaxPeersCall) Do(f func() int) *MockServiceMaxPeersCall

Do rewrite *gomock.Call.Do

func (*MockServiceMaxPeersCall) DoAndReturn 

func (c *MockServiceMaxPeersCall) DoAndReturn(f func() int) *MockServiceMaxPeersCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceMaxPeersCall) Return 

func (c *MockServiceMaxPeersCall) Return(arg0 int) *MockServiceMaxPeersCall

Return rewrite *gomock.Call.Return

type MockServiceMockRecorder 

type MockServiceMockRecorder struct {
	// contains filtered or unexported fields
}

MockServiceMockRecorder is the mock recorder for MockService.

func (*MockServiceMockRecorder) BlockNumMissing 

func (mr *MockServiceMockRecorder) BlockNumMissing(peerId, blockNum any) *MockServiceBlockNumMissingCall

BlockNumMissing indicates an expected call of BlockNumMissing.

func (*MockServiceMockRecorder) BlockNumPresent 

func (mr *MockServiceMockRecorder) BlockNumPresent(peerId, blockNum any) *MockServiceBlockNumPresentCall

BlockNumPresent indicates an expected call of BlockNumPresent.

func (*MockServiceMockRecorder) FetchBlocks 

func (mr *MockServiceMockRecorder) FetchBlocks(ctx, start, end, peerId any) *MockServiceFetchBlocksCall

FetchBlocks indicates an expected call of FetchBlocks.

func (*MockServiceMockRecorder) FetchBodies 

func (mr *MockServiceMockRecorder) FetchBodies(ctx, headers, peerId any) *MockServiceFetchBodiesCall

FetchBodies indicates an expected call of FetchBodies.

func (*MockServiceMockRecorder) FetchHeaders 

func (mr *MockServiceMockRecorder) FetchHeaders(ctx, start, end, peerId any) *MockServiceFetchHeadersCall

FetchHeaders indicates an expected call of FetchHeaders.

func (*MockServiceMockRecorder) ListPeersMayHaveBlockNum 

func (mr *MockServiceMockRecorder) ListPeersMayHaveBlockNum(blockNum any) *MockServiceListPeersMayHaveBlockNumCall

ListPeersMayHaveBlockNum indicates an expected call of ListPeersMayHaveBlockNum.

func (*MockServiceMockRecorder) MaxPeers 

func (mr *MockServiceMockRecorder) MaxPeers() *MockServiceMaxPeersCall

MaxPeers indicates an expected call of MaxPeers.

func (*MockServiceMockRecorder) PeerConnected 

func (mr *MockServiceMockRecorder) PeerConnected(peerId any) *MockServicePeerConnectedCall

PeerConnected indicates an expected call of PeerConnected.

func (*MockServiceMockRecorder) PeerDisconnected 

func (mr *MockServiceMockRecorder) PeerDisconnected(peerId any) *MockServicePeerDisconnectedCall

PeerDisconnected indicates an expected call of PeerDisconnected.

func (*MockServiceMockRecorder) Penalize 

func (mr *MockServiceMockRecorder) Penalize(ctx, peerId any) *MockServicePenalizeCall

Penalize indicates an expected call of Penalize.

func (*MockServiceMockRecorder) RegisterBlockBodiesObserver 

func (mr *MockServiceMockRecorder) RegisterBlockBodiesObserver(observer any) *MockServiceRegisterBlockBodiesObserverCall

RegisterBlockBodiesObserver indicates an expected call of RegisterBlockBodiesObserver.

func (*MockServiceMockRecorder) RegisterBlockHeadersObserver 

func (mr *MockServiceMockRecorder) RegisterBlockHeadersObserver(observer any) *MockServiceRegisterBlockHeadersObserverCall

RegisterBlockHeadersObserver indicates an expected call of RegisterBlockHeadersObserver.

func (*MockServiceMockRecorder) RegisterNewBlockHashesObserver 

func (mr *MockServiceMockRecorder) RegisterNewBlockHashesObserver(observer any) *MockServiceRegisterNewBlockHashesObserverCall

RegisterNewBlockHashesObserver indicates an expected call of RegisterNewBlockHashesObserver.

func (*MockServiceMockRecorder) RegisterNewBlockObserver 

func (mr *MockServiceMockRecorder) RegisterNewBlockObserver(observer any) *MockServiceRegisterNewBlockObserverCall

RegisterNewBlockObserver indicates an expected call of RegisterNewBlockObserver.

func (*MockServiceMockRecorder) RegisterPeerEventObserver 

func (mr *MockServiceMockRecorder) RegisterPeerEventObserver(observer any) *MockServiceRegisterPeerEventObserverCall

RegisterPeerEventObserver indicates an expected call of RegisterPeerEventObserver.

func (*MockServiceMockRecorder) Run 

func (mr *MockServiceMockRecorder) Run(ctx any) *MockServiceRunCall

Run indicates an expected call of Run.

type MockServicePeerConnectedCall 

type MockServicePeerConnectedCall struct {
	*gomock.Call
}

MockServicePeerConnectedCall wrap *gomock.Call

func (*MockServicePeerConnectedCall) Do 

func (c *MockServicePeerConnectedCall) Do(f func(*PeerId)) *MockServicePeerConnectedCall

Do rewrite *gomock.Call.Do

func (*MockServicePeerConnectedCall) DoAndReturn 

func (c *MockServicePeerConnectedCall) DoAndReturn(f func(*PeerId)) *MockServicePeerConnectedCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServicePeerConnectedCall) Return 

func (c *MockServicePeerConnectedCall) Return() *MockServicePeerConnectedCall

Return rewrite *gomock.Call.Return

type MockServicePeerDisconnectedCall 

type MockServicePeerDisconnectedCall struct {
	*gomock.Call
}

MockServicePeerDisconnectedCall wrap *gomock.Call

func (*MockServicePeerDisconnectedCall) Do 

func (c *MockServicePeerDisconnectedCall) Do(f func(*PeerId)) *MockServicePeerDisconnectedCall

Do rewrite *gomock.Call.Do

func (*MockServicePeerDisconnectedCall) DoAndReturn 

func (c *MockServicePeerDisconnectedCall) DoAndReturn(f func(*PeerId)) *MockServicePeerDisconnectedCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServicePeerDisconnectedCall) Return 

func (c *MockServicePeerDisconnectedCall) Return() *MockServicePeerDisconnectedCall

Return rewrite *gomock.Call.Return

type MockServicePenalizeCall 

type MockServicePenalizeCall struct {
	*gomock.Call
}

MockServicePenalizeCall wrap *gomock.Call

func (*MockServicePenalizeCall) Do 

func (c *MockServicePenalizeCall) Do(f func(context.Context, *PeerId) error) *MockServicePenalizeCall

Do rewrite *gomock.Call.Do

func (*MockServicePenalizeCall) DoAndReturn 

func (c *MockServicePenalizeCall) DoAndReturn(f func(context.Context, *PeerId) error) *MockServicePenalizeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServicePenalizeCall) Return 

func (c *MockServicePenalizeCall) Return(arg0 error) *MockServicePenalizeCall

Return rewrite *gomock.Call.Return

type MockServiceRegisterBlockBodiesObserverCall 

type MockServiceRegisterBlockBodiesObserverCall struct {
	*gomock.Call
}

MockServiceRegisterBlockBodiesObserverCall wrap *gomock.Call

func (*MockServiceRegisterBlockBodiesObserverCall) Do 

func (c *MockServiceRegisterBlockBodiesObserverCall) Do(f func(MessageObserver[*DecodedInboundMessage[*eth.BlockBodiesPacket66]]) UnregisterFunc) *MockServiceRegisterBlockBodiesObserverCall

Do rewrite *gomock.Call.Do

func (*MockServiceRegisterBlockBodiesObserverCall) DoAndReturn 

func (c *MockServiceRegisterBlockBodiesObserverCall) DoAndReturn(f func(MessageObserver[*DecodedInboundMessage[*eth.BlockBodiesPacket66]]) UnregisterFunc) *MockServiceRegisterBlockBodiesObserverCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceRegisterBlockBodiesObserverCall) Return 

func (c *MockServiceRegisterBlockBodiesObserverCall) Return(arg0 UnregisterFunc) *MockServiceRegisterBlockBodiesObserverCall

Return rewrite *gomock.Call.Return

type MockServiceRegisterBlockHeadersObserverCall 

type MockServiceRegisterBlockHeadersObserverCall struct {
	*gomock.Call
}

MockServiceRegisterBlockHeadersObserverCall wrap *gomock.Call

func (*MockServiceRegisterBlockHeadersObserverCall) Do 

func (c *MockServiceRegisterBlockHeadersObserverCall) Do(f func(MessageObserver[*DecodedInboundMessage[*eth.BlockHeadersPacket66]]) UnregisterFunc) *MockServiceRegisterBlockHeadersObserverCall

Do rewrite *gomock.Call.Do

func (*MockServiceRegisterBlockHeadersObserverCall) DoAndReturn 

func (c *MockServiceRegisterBlockHeadersObserverCall) DoAndReturn(f func(MessageObserver[*DecodedInboundMessage[*eth.BlockHeadersPacket66]]) UnregisterFunc) *MockServiceRegisterBlockHeadersObserverCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceRegisterBlockHeadersObserverCall) Return 

func (c *MockServiceRegisterBlockHeadersObserverCall) Return(arg0 UnregisterFunc) *MockServiceRegisterBlockHeadersObserverCall

Return rewrite *gomock.Call.Return

type MockServiceRegisterNewBlockHashesObserverCall 

type MockServiceRegisterNewBlockHashesObserverCall struct {
	*gomock.Call
}

MockServiceRegisterNewBlockHashesObserverCall wrap *gomock.Call

func (*MockServiceRegisterNewBlockHashesObserverCall) Do 

func (c *MockServiceRegisterNewBlockHashesObserverCall) Do(f func(MessageObserver[*DecodedInboundMessage[*eth.NewBlockHashesPacket]]) UnregisterFunc) *MockServiceRegisterNewBlockHashesObserverCall

Do rewrite *gomock.Call.Do

func (*MockServiceRegisterNewBlockHashesObserverCall) DoAndReturn 

func (c *MockServiceRegisterNewBlockHashesObserverCall) DoAndReturn(f func(MessageObserver[*DecodedInboundMessage[*eth.NewBlockHashesPacket]]) UnregisterFunc) *MockServiceRegisterNewBlockHashesObserverCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceRegisterNewBlockHashesObserverCall) Return 

func (c *MockServiceRegisterNewBlockHashesObserverCall) Return(arg0 UnregisterFunc) *MockServiceRegisterNewBlockHashesObserverCall

Return rewrite *gomock.Call.Return

type MockServiceRegisterNewBlockObserverCall 

type MockServiceRegisterNewBlockObserverCall struct {
	*gomock.Call
}

MockServiceRegisterNewBlockObserverCall wrap *gomock.Call

func (*MockServiceRegisterNewBlockObserverCall) Do 

func (c *MockServiceRegisterNewBlockObserverCall) Do(f func(MessageObserver[*DecodedInboundMessage[*eth.NewBlockPacket]]) UnregisterFunc) *MockServiceRegisterNewBlockObserverCall

Do rewrite *gomock.Call.Do

func (*MockServiceRegisterNewBlockObserverCall) DoAndReturn 

func (c *MockServiceRegisterNewBlockObserverCall) DoAndReturn(f func(MessageObserver[*DecodedInboundMessage[*eth.NewBlockPacket]]) UnregisterFunc) *MockServiceRegisterNewBlockObserverCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceRegisterNewBlockObserverCall) Return 

func (c *MockServiceRegisterNewBlockObserverCall) Return(arg0 UnregisterFunc) *MockServiceRegisterNewBlockObserverCall

Return rewrite *gomock.Call.Return

type MockServiceRegisterPeerEventObserverCall 

type MockServiceRegisterPeerEventObserverCall struct {
	*gomock.Call
}

MockServiceRegisterPeerEventObserverCall wrap *gomock.Call

func (*MockServiceRegisterPeerEventObserverCall) Do 

func (c *MockServiceRegisterPeerEventObserverCall) Do(f func(MessageObserver[*sentry.PeerEvent]) UnregisterFunc) *MockServiceRegisterPeerEventObserverCall

Do rewrite *gomock.Call.Do

func (*MockServiceRegisterPeerEventObserverCall) DoAndReturn 

func (c *MockServiceRegisterPeerEventObserverCall) DoAndReturn(f func(MessageObserver[*sentry.PeerEvent]) UnregisterFunc) *MockServiceRegisterPeerEventObserverCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceRegisterPeerEventObserverCall) Return 

func (c *MockServiceRegisterPeerEventObserverCall) Return(arg0 UnregisterFunc) *MockServiceRegisterPeerEventObserverCall

Return rewrite *gomock.Call.Return

type MockServiceRunCall 

type MockServiceRunCall struct {
	*gomock.Call
}

MockServiceRunCall wrap *gomock.Call

func (*MockServiceRunCall) Do 

func (c *MockServiceRunCall) Do(f func(context.Context)) *MockServiceRunCall

Do rewrite *gomock.Call.Do

func (*MockServiceRunCall) DoAndReturn 

func (c *MockServiceRunCall) DoAndReturn(f func(context.Context)) *MockServiceRunCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockServiceRunCall) Return 

func (c *MockServiceRunCall) Return() *MockServiceRunCall

Return rewrite *gomock.Call.Return

type PeerId 

type PeerId [64]byte

func PeerIdFromH512 

func PeerIdFromH512(h512 *erigonlibtypes.H512) *PeerId

func PeerIdFromUint64 

func PeerIdFromUint64(num uint64) *PeerId

PeerIdFromUint64 is useful for testing and that is its main intended purpose

func (*PeerId) Equal 

func (pid *PeerId) Equal(other *PeerId) bool

func (*PeerId) H512 

func (pid *PeerId) H512() *erigonlibtypes.H512

func (*PeerId) String 

func (pid *PeerId) String() string

type PeerPenalizer 

type PeerPenalizer interface {
	Penalize(ctx context.Context, peerId *PeerId) error
}

func NewPeerPenalizer 

func NewPeerPenalizer(sentryClient direct.SentryClient) PeerPenalizer

type PeerShuffle 

type PeerShuffle func(peerIds []*PeerId)

type PeerTracker 

type PeerTracker interface {
	ListPeersMayHaveBlockNum(blockNum uint64) []*PeerId
	BlockNumPresent(peerId *PeerId, blockNum uint64)
	BlockNumMissing(peerId *PeerId, blockNum uint64)
	PeerConnected(peerId *PeerId)
	PeerDisconnected(peerId *PeerId)
}

func NewPeerTracker 

func NewPeerTracker() PeerTracker

type RequestIdGenerator 

type RequestIdGenerator func() uint64

type Service 

type Service interface {
	Fetcher
	MessageListener
	PeerTracker
	PeerPenalizer
	MaxPeers() int
}

func NewService 

func NewService(
	maxPeers int,
	logger log.Logger,
	sentryClient direct.SentryClient,
	statusDataFactory sentrymulticlient.StatusDataFactory,
) Service

type UnregisterFunc 

type UnregisterFunc func()

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.