p2p

package
v1.9.7-0...-6086a97 Latest Latest
Warning

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

 Go to latest Published: Feb 24, 2025 License: LGPL-3.0 Imports: 32 Imported by: 0

Documentation

Overview

Package p2p is a generated GoMock package.

Package p2p is a generated GoMock package.

Index

Constants

This section is empty.

Variables

View Source 
var ErrInvalidFetchBlocksAmount = errors.New("invalid fetch blocks amount")
View Source 
var ErrPeerNotFound = errors.New("peer not found")

Functions

func PreservingPeerShuffle 

func PreservingPeerShuffle(_ []*PeerId)

func RandPeerShuffle 

func RandPeerShuffle(peerIds []*PeerId)

func WithPreservingPeerShuffle 

func WithPreservingPeerShuffle(pt *PeerTracker)

Types

type DecodedInboundMessage 

type DecodedInboundMessage[TPacket any] struct {
	*sentryproto.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 ErrMissingHeaderHash 

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

func (ErrMissingHeaderHash) Error 

func (e ErrMissingHeaderHash) Error() string

func (ErrMissingHeaderHash) Is 

func (e ErrMissingHeaderHash) Is(err error) bool

type ErrNonSequentialHeaderHashes 

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

func (ErrNonSequentialHeaderHashes) Error 

func (e ErrNonSequentialHeaderHashes) Error() string

func (ErrNonSequentialHeaderHashes) Is 

func (e ErrNonSequentialHeaderHashes) Is(err error) 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 ErrUnexpectedHeaderHash 

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

func (ErrUnexpectedHeaderHash) Error 

func (e ErrUnexpectedHeaderHash) Error() string

func (ErrUnexpectedHeaderHash) Is 

func (e ErrUnexpectedHeaderHash) 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,
		opts ...FetcherOption,
	) (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,
		opts ...FetcherOption,
	) (FetcherResponse[[]*types.Body], error)

	// FetchBlocksBackwardsByHash fetches a number of blocks backwards starting from a block hash. Max amount is 1024
	// blocks back. Blocks until data is received.
	FetchBlocksBackwardsByHash(
		ctx context.Context,
		hash common.Hash,
		amount uint64,
		peerId *PeerId,
		opts ...FetcherOption,
	) (FetcherResponse[[]*types.Block], error)
}

type FetcherBase 

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

func NewFetcher 

func NewFetcher(logger log.Logger, ml *MessageListener, ms *MessageSender, opts ...FetcherOption) *FetcherBase

func (*FetcherBase) FetchBlocksBackwardsByHash 

func (f *FetcherBase) FetchBlocksBackwardsByHash(
	ctx context.Context,
	hash common.Hash,
	amount uint64,
	peerId *PeerId,
	opts ...FetcherOption,
) (FetcherResponse[[]*types.Block], error)

func (*FetcherBase) FetchBodies 

func (f *FetcherBase) FetchBodies(
	ctx context.Context,
	headers []*types.Header,
	peerId *PeerId,
	opts ...FetcherOption,
) (FetcherResponse[[]*types.Body], error)

func (*FetcherBase) FetchHeaders 

func (f *FetcherBase) FetchHeaders(
	ctx context.Context,
	start uint64,
	end uint64,
	peerId *PeerId,
	opts ...FetcherOption,
) (FetcherResponse[[]*types.Header], error)

type FetcherConfig 

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

func (FetcherConfig) CopyWithOptions 

func (fc FetcherConfig) CopyWithOptions(opts ...FetcherOption) FetcherConfig

type FetcherOption 

type FetcherOption func(FetcherConfig) FetcherConfig

func WithMaxRetries 

func WithMaxRetries(maxRetries uint64) FetcherOption

func WithRequestIdGenerator 

func WithRequestIdGenerator(requestIdGenerator RequestIdGenerator) FetcherOption

func WithResponseTimeout 

func WithResponseTimeout(responseTimeout time.Duration) FetcherOption

func WithRetryBackOff 

func WithRetryBackOff(retryBackOff time.Duration) FetcherOption

type FetcherResponse 

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

type MessageListener 

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

func NewMessageListener 

func NewMessageListener(
	logger log.Logger,
	sentryClient sentryproto.SentryClient,
	statusDataFactory sentry.StatusDataFactory,
	peerPenalizer *PeerPenalizer,
) *MessageListener

func (*MessageListener) RegisterBlockBodiesObserver 

func (ml *MessageListener) RegisterBlockBodiesObserver(observer event.Observer[*DecodedInboundMessage[*eth.BlockBodiesPacket66]]) UnregisterFunc

func (*MessageListener) RegisterBlockHeadersObserver 

func (ml *MessageListener) RegisterBlockHeadersObserver(observer event.Observer[*DecodedInboundMessage[*eth.BlockHeadersPacket66]]) UnregisterFunc

func (*MessageListener) RegisterNewBlockHashesObserver 

func (ml *MessageListener) RegisterNewBlockHashesObserver(observer event.Observer[*DecodedInboundMessage[*eth.NewBlockHashesPacket]]) UnregisterFunc

func (*MessageListener) RegisterNewBlockObserver 

func (ml *MessageListener) RegisterNewBlockObserver(observer event.Observer[*DecodedInboundMessage[*eth.NewBlockPacket]]) UnregisterFunc

func (*MessageListener) RegisterPeerEventObserver 

func (ml *MessageListener) RegisterPeerEventObserver(observer event.Observer[*sentryproto.PeerEvent]) UnregisterFunc

func (*MessageListener) Run 

func (ml *MessageListener) Run(ctx context.Context) error

type MessageSender 

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

func NewMessageSender 

func NewMessageSender(sentryClient sentryproto.SentryClient) *MessageSender

func (*MessageSender) SendGetBlockBodies 

func (ms *MessageSender) SendGetBlockBodies(ctx context.Context, peerId *PeerId, req eth.GetBlockBodiesPacket66) error

func (*MessageSender) SendGetBlockHeaders 

func (ms *MessageSender) SendGetBlockHeaders(ctx context.Context, peerId *PeerId, req eth.GetBlockHeadersPacket66) error

func (*MessageSender) SendNewBlock 

func (ms *MessageSender) SendNewBlock(ctx context.Context, peerId *PeerId, req eth.NewBlockPacket) error

func (*MessageSender) SendNewBlockHashes 

func (ms *MessageSender) SendNewBlockHashes(ctx context.Context, peerId *PeerId, req eth.NewBlockHashesPacket) error

type MockpeerEventRegistrar 

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

MockpeerEventRegistrar is a mock of peerEventRegistrar interface.

func NewMockpeerEventRegistrar 

func NewMockpeerEventRegistrar(ctrl *gomock.Controller) *MockpeerEventRegistrar

NewMockpeerEventRegistrar creates a new mock instance.

func (*MockpeerEventRegistrar) EXPECT 

func (m *MockpeerEventRegistrar) EXPECT() *MockpeerEventRegistrarMockRecorder

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

func (*MockpeerEventRegistrar) RegisterNewBlockHashesObserver 

func (m *MockpeerEventRegistrar) RegisterNewBlockHashesObserver(observer event.Observer[*DecodedInboundMessage[*eth.NewBlockHashesPacket]]) UnregisterFunc

RegisterNewBlockHashesObserver mocks base method.

func (*MockpeerEventRegistrar) RegisterNewBlockObserver 

func (m *MockpeerEventRegistrar) RegisterNewBlockObserver(observer event.Observer[*DecodedInboundMessage[*eth.NewBlockPacket]]) UnregisterFunc

RegisterNewBlockObserver mocks base method.

func (*MockpeerEventRegistrar) RegisterPeerEventObserver 

func (m *MockpeerEventRegistrar) RegisterPeerEventObserver(observer event.Observer[*sentryproto.PeerEvent]) UnregisterFunc

RegisterPeerEventObserver mocks base method.

type MockpeerEventRegistrarMockRecorder 

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

MockpeerEventRegistrarMockRecorder is the mock recorder for MockpeerEventRegistrar.

func (*MockpeerEventRegistrarMockRecorder) RegisterNewBlockHashesObserver 

func (mr *MockpeerEventRegistrarMockRecorder) RegisterNewBlockHashesObserver(observer any) *MockpeerEventRegistrarRegisterNewBlockHashesObserverCall

RegisterNewBlockHashesObserver indicates an expected call of RegisterNewBlockHashesObserver.

func (*MockpeerEventRegistrarMockRecorder) RegisterNewBlockObserver 

func (mr *MockpeerEventRegistrarMockRecorder) RegisterNewBlockObserver(observer any) *MockpeerEventRegistrarRegisterNewBlockObserverCall

RegisterNewBlockObserver indicates an expected call of RegisterNewBlockObserver.

func (*MockpeerEventRegistrarMockRecorder) RegisterPeerEventObserver 

func (mr *MockpeerEventRegistrarMockRecorder) RegisterPeerEventObserver(observer any) *MockpeerEventRegistrarRegisterPeerEventObserverCall

RegisterPeerEventObserver indicates an expected call of RegisterPeerEventObserver.

type MockpeerEventRegistrarRegisterNewBlockHashesObserverCall 

type MockpeerEventRegistrarRegisterNewBlockHashesObserverCall struct {
	*gomock.Call
}

MockpeerEventRegistrarRegisterNewBlockHashesObserverCall wrap *gomock.Call

func (*MockpeerEventRegistrarRegisterNewBlockHashesObserverCall) Do 

func (c *MockpeerEventRegistrarRegisterNewBlockHashesObserverCall) Do(f func(event.Observer[*DecodedInboundMessage[*eth.NewBlockHashesPacket]]) UnregisterFunc) *MockpeerEventRegistrarRegisterNewBlockHashesObserverCall

Do rewrite *gomock.Call.Do

func (*MockpeerEventRegistrarRegisterNewBlockHashesObserverCall) DoAndReturn 

func (c *MockpeerEventRegistrarRegisterNewBlockHashesObserverCall) DoAndReturn(f func(event.Observer[*DecodedInboundMessage[*eth.NewBlockHashesPacket]]) UnregisterFunc) *MockpeerEventRegistrarRegisterNewBlockHashesObserverCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockpeerEventRegistrarRegisterNewBlockHashesObserverCall) Return 

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

Return rewrite *gomock.Call.Return

type MockpeerEventRegistrarRegisterNewBlockObserverCall 

type MockpeerEventRegistrarRegisterNewBlockObserverCall struct {
	*gomock.Call
}

MockpeerEventRegistrarRegisterNewBlockObserverCall wrap *gomock.Call

func (*MockpeerEventRegistrarRegisterNewBlockObserverCall) Do 

func (c *MockpeerEventRegistrarRegisterNewBlockObserverCall) Do(f func(event.Observer[*DecodedInboundMessage[*eth.NewBlockPacket]]) UnregisterFunc) *MockpeerEventRegistrarRegisterNewBlockObserverCall

Do rewrite *gomock.Call.Do

func (*MockpeerEventRegistrarRegisterNewBlockObserverCall) DoAndReturn 

func (c *MockpeerEventRegistrarRegisterNewBlockObserverCall) DoAndReturn(f func(event.Observer[*DecodedInboundMessage[*eth.NewBlockPacket]]) UnregisterFunc) *MockpeerEventRegistrarRegisterNewBlockObserverCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockpeerEventRegistrarRegisterNewBlockObserverCall) Return 

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

Return rewrite *gomock.Call.Return

type MockpeerEventRegistrarRegisterPeerEventObserverCall 

type MockpeerEventRegistrarRegisterPeerEventObserverCall struct {
	*gomock.Call
}

MockpeerEventRegistrarRegisterPeerEventObserverCall wrap *gomock.Call

func (*MockpeerEventRegistrarRegisterPeerEventObserverCall) Do 

func (c *MockpeerEventRegistrarRegisterPeerEventObserverCall) Do(f func(event.Observer[*sentryproto.PeerEvent]) UnregisterFunc) *MockpeerEventRegistrarRegisterPeerEventObserverCall

Do rewrite *gomock.Call.Do

func (*MockpeerEventRegistrarRegisterPeerEventObserverCall) DoAndReturn 

func (c *MockpeerEventRegistrarRegisterPeerEventObserverCall) DoAndReturn(f func(event.Observer[*sentryproto.PeerEvent]) UnregisterFunc) *MockpeerEventRegistrarRegisterPeerEventObserverCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockpeerEventRegistrarRegisterPeerEventObserverCall) Return 

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

Return rewrite *gomock.Call.Return

type MockpeerProvider 

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

MockpeerProvider is a mock of peerProvider interface.

func NewMockpeerProvider 

func NewMockpeerProvider(ctrl *gomock.Controller) *MockpeerProvider

NewMockpeerProvider creates a new mock instance.

func (*MockpeerProvider) EXPECT 

func (m *MockpeerProvider) EXPECT() *MockpeerProviderMockRecorder

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

func (*MockpeerProvider) Peers 

func (m *MockpeerProvider) Peers(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*sentryproto.PeersReply, error)

Peers mocks base method.

type MockpeerProviderMockRecorder 

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

MockpeerProviderMockRecorder is the mock recorder for MockpeerProvider.

func (*MockpeerProviderMockRecorder) Peers 

func (mr *MockpeerProviderMockRecorder) Peers(ctx, in any, opts ...any) *MockpeerProviderPeersCall

Peers indicates an expected call of Peers.

type MockpeerProviderPeersCall 

type MockpeerProviderPeersCall struct {
	*gomock.Call
}

MockpeerProviderPeersCall wrap *gomock.Call

func (*MockpeerProviderPeersCall) Do 

func (c *MockpeerProviderPeersCall) Do(f func(context.Context, *emptypb.Empty, ...grpc.CallOption) (*sentryproto.PeersReply, error)) *MockpeerProviderPeersCall

Do rewrite *gomock.Call.Do

func (*MockpeerProviderPeersCall) DoAndReturn 

func (c *MockpeerProviderPeersCall) DoAndReturn(f func(context.Context, *emptypb.Empty, ...grpc.CallOption) (*sentryproto.PeersReply, error)) *MockpeerProviderPeersCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockpeerProviderPeersCall) Return 

func (c *MockpeerProviderPeersCall) Return(arg0 *sentryproto.PeersReply, arg1 error) *MockpeerProviderPeersCall

Return rewrite *gomock.Call.Return

type PeerId 

type PeerId [64]byte

func PeerIdFromEnode 

func PeerIdFromEnode(url string) (*PeerId, error)

func PeerIdFromH512 

func PeerIdFromH512(h512 *typesproto.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() *typesproto.H512

func (*PeerId) String 

func (pid *PeerId) String() string

type PeerPenalizer 

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

func NewPeerPenalizer 

func NewPeerPenalizer(sentryClient sentryproto.SentryClient) *PeerPenalizer

func (PeerPenalizer) Penalize 

func (p PeerPenalizer) Penalize(ctx context.Context, peerId *PeerId) error

type PeerShuffle 

type PeerShuffle func(peerIds []*PeerId)

type PeerTracker 

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

func NewPeerTracker 

func NewPeerTracker(
	logger log.Logger,
	peerProvider peerProvider,
	peerEventRegistrar peerEventRegistrar,
	opts ...PeerTrackerOption,
) *PeerTracker

func (*PeerTracker) BlockHashPresent 

func (pt *PeerTracker) BlockHashPresent(peerId *PeerId, blockHash common.Hash)

func (*PeerTracker) BlockNumMissing 

func (pt *PeerTracker) BlockNumMissing(peerId *PeerId, blockNum uint64)

func (*PeerTracker) BlockNumPresent 

func (pt *PeerTracker) BlockNumPresent(peerId *PeerId, blockNum uint64)

func (*PeerTracker) ListPeersMayHaveBlockNum 

func (pt *PeerTracker) ListPeersMayHaveBlockNum(blockNum uint64) []*PeerId

func (*PeerTracker) ListPeersMayMissBlockHash 

func (pt *PeerTracker) ListPeersMayMissBlockHash(blockHash common.Hash) []*PeerId

func (*PeerTracker) PeerConnected 

func (pt *PeerTracker) PeerConnected(peerId *PeerId)

func (*PeerTracker) PeerDisconnected 

func (pt *PeerTracker) PeerDisconnected(peerId *PeerId)

func (*PeerTracker) Run 

func (pt *PeerTracker) Run(ctx context.Context) error

type PeerTrackerOption 

type PeerTrackerOption func(*PeerTracker)

type PenalizingFetcher 

type PenalizingFetcher struct {
	Fetcher
	// contains filtered or unexported fields
}

func NewPenalizingFetcher 

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

func (*PenalizingFetcher) FetchBlocksBackwardsByHash 

func (pf *PenalizingFetcher) FetchBlocksBackwardsByHash(
	ctx context.Context,
	hash common.Hash,
	amount uint64,
	peerId *PeerId,
	opts ...FetcherOption,
) (FetcherResponse[[]*types.Block], error)

func (*PenalizingFetcher) FetchBodies 

func (pf *PenalizingFetcher) FetchBodies(
	ctx context.Context,
	headers []*types.Header,
	peerId *PeerId,
	opts ...FetcherOption,
) (FetcherResponse[[]*types.Body], error)

func (*PenalizingFetcher) FetchHeaders 

func (pf *PenalizingFetcher) FetchHeaders(
	ctx context.Context,
	start uint64,
	end uint64,
	peerId *PeerId,
	opts ...FetcherOption,
) (FetcherResponse[[]*types.Header], error)

type Publisher 

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

Publisher manages block announcements according to the devp2p specs: https://github.com/ethereum/devp2p/blob/master/caps/eth.md#block-propagation

It co-operates with the PeerTracker to ensure that we do not publish block/block hash announcements to peers if: 1) we have already published a given block/block hash to this peer or 2) that peer has already notified us of the given block/block hash

It also handles the NewBlock publish requirement of only sending it to a small random portion (sqrt) of peers.

All publish tasks are done asynchronously by putting them on a queue. If the publisher is struggling to keep up then newly enqueued publish tasks will get dropped.

func NewPublisher 

func NewPublisher(logger log.Logger, messageSender *MessageSender, peerTracker *PeerTracker) *Publisher

func (Publisher) PublishNewBlock 

func (p Publisher) PublishNewBlock(block *types.Block, td *big.Int)

func (Publisher) PublishNewBlockHashes 

func (p Publisher) PublishNewBlockHashes(block *types.Block)

func (Publisher) Run 

func (p Publisher) Run(ctx context.Context) error

type RequestIdGenerator 

type RequestIdGenerator func() uint64

type Service 

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

func NewService 

func NewService(logger log.Logger, maxPeers int, sc sentryproto.SentryClient, sdf sentry.StatusDataFactory) *Service

func (*Service) FetchBlocksBackwardsByHash 

func (s *Service) FetchBlocksBackwardsByHash(ctx context.Context, hash libcommon.Hash, amount uint64, peerId *PeerId, opts ...FetcherOption) (FetcherResponse[[]*types.Block], error)

func (*Service) FetchBodies 

func (s *Service) FetchBodies(ctx context.Context, headers []*types.Header, peerId *PeerId, opts ...FetcherOption) (FetcherResponse[[]*types.Body], error)

func (*Service) FetchHeaders 

func (s *Service) FetchHeaders(ctx context.Context, start, end uint64, peerId *PeerId, opts ...FetcherOption) (FetcherResponse[[]*types.Header], error)

func (*Service) ListPeersMayHaveBlockNum 

func (s *Service) ListPeersMayHaveBlockNum(blockNum uint64) []*PeerId

func (*Service) MaxPeers 

func (s *Service) MaxPeers() int

func (*Service) Penalize 

func (s *Service) Penalize(ctx context.Context, peerId *PeerId) error

func (*Service) PublishNewBlock 

func (s *Service) PublishNewBlock(block *types.Block, td *big.Int)

func (*Service) PublishNewBlockHashes 

func (s *Service) PublishNewBlockHashes(block *types.Block)

func (*Service) RegisterNewBlockHashesObserver 

func (s *Service) RegisterNewBlockHashesObserver(o event.Observer[*DecodedInboundMessage[*eth.NewBlockHashesPacket]]) event.UnregisterFunc

func (*Service) RegisterNewBlockObserver 

func (s *Service) RegisterNewBlockObserver(o event.Observer[*DecodedInboundMessage[*eth.NewBlockPacket]]) event.UnregisterFunc

func (*Service) Run 

func (s *Service) Run(ctx context.Context) error

type TrackingFetcher 

type TrackingFetcher struct {
	Fetcher
	// contains filtered or unexported fields
}

func NewTrackingFetcher 

func NewTrackingFetcher(fetcher Fetcher, peerTracker *PeerTracker) *TrackingFetcher

func (*TrackingFetcher) FetchBodies 

func (tf *TrackingFetcher) FetchBodies(
	ctx context.Context,
	headers []*types.Header,
	peerId *PeerId,
	opts ...FetcherOption,
) (FetcherResponse[[]*types.Body], error)

func (*TrackingFetcher) FetchHeaders 

func (tf *TrackingFetcher) FetchHeaders(
	ctx context.Context,
	start uint64,
	end uint64,
	peerId *PeerId,
	opts ...FetcherOption,
) (FetcherResponse[[]*types.Header], error)

type UnregisterFunc 

type UnregisterFunc = event.UnregisterFunc

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.