events

Documentation

Index

• type Backend
• type BlockHash
• type BlockStatus
• type EventSystem
  • func NewEventSystem(backend Backend) *EventSystem
  • func (es *EventSystem) SubscribeConsensusInfo(consensusInfo chan *types.MinimalEpochConsensusInfo, epoch uint64) *Subscription
  • func (es *EventSystem) SubscribeVerifiedSlotInfo(slotInfo chan *types.SlotInfoWithStatus) *Subscription
• type MockBackend
  • func (b *MockBackend) ConsensusInfoByEpochRange(fromEpoch uint64) []*eventTypes.MinimalEpochConsensusInfo
  • func (mb *MockBackend) GetSlotStatus(ctx context.Context, slot uint64, hash common.Hash, requestType bool) eventTypes.Status
  • func (mb *MockBackend) LatestEpoch() uint64
  • func (mb *MockBackend) LatestVerifiedSlot() uint64
  • func (mb *MockBackend) PendingPandoraHeaders() []*eth1Types.Header
  • func (b *MockBackend) SubscribeNewEpochEvent(ch chan<- *eventTypes.MinimalEpochConsensusInfo) event.Subscription
  • func (b *MockBackend) SubscribeNewVerifiedSlotInfoEvent(ch chan<- *eventTypes.SlotInfoWithStatus) event.Subscription
  • func (mb *MockBackend) VerifiedSlotInfos(fromSlot uint64) map[uint64]*eventTypes.SlotInfo
• type PublicFilterAPI
  • func NewPublicFilterAPI(backend Backend, timeout time.Duration) *PublicFilterAPI
  • func (api *PublicFilterAPI) ConfirmPanBlockHashes(ctx context.Context, requests []*BlockHash) ([]*BlockStatus, error)
  • func (api *PublicFilterAPI) ConfirmVanBlockHashes(ctx context.Context, requests []*BlockHash) (response []*BlockStatus, err error)
  • func (api *PublicFilterAPI) MinimalConsensusInfo(ctx context.Context, requestedEpoch uint64) (*rpc.Subscription, error)
  • func (api *PublicFilterAPI) SteamConfirmedPanBlockHashes(ctx context.Context, request *BlockHash) (*rpc.Subscription, error)
• type Subscription
  • func (sub *Subscription) Err() <-chan error
  • func (sub *Subscription) Unsubscribe()
• type Type

Types

type Backend

type Backend interface {
	ConsensusInfoByEpochRange(fromEpoch uint64) []*generalTypes.MinimalEpochConsensusInfo
	SubscribeNewEpochEvent(chan<- *generalTypes.MinimalEpochConsensusInfo) event.Subscription
	GetSlotStatus(ctx context.Context, slot uint64, hash common.Hash, requestFrom bool) generalTypes.Status
	LatestEpoch() uint64
	SubscribeNewVerifiedSlotInfoEvent(chan<- *generalTypes.SlotInfoWithStatus) event.Subscription
	VerifiedSlotInfos(fromSlot uint64) map[uint64]*generalTypes.SlotInfo
	LatestVerifiedSlot() uint64
	PendingPandoraHeaders() []*eth1Types.Header
}

type BlockHash

type BlockHash struct {
	Slot uint64      `json:"slot"`
	Hash common.Hash `json:"hash"`
}

type BlockStatus

type BlockStatus struct {
	BlockHash
	Status generalTypes.Status
}

type EventSystem

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

EventSystem creates subscriptions, processes events and broadcasts them to the subscription which match the subscription criteria.

func NewEventSystem

func NewEventSystem(backend Backend) *EventSystem

NewEventSystem creates a new manager that listens for event on the given mux, parses and filters them. It uses the all map to retrieve filter changes. The work loop holds its own index that is used to forward events to filters.

The returned manager has a loop that needs to be stopped with the Stop function or by stopping the given mux.

func (*EventSystem) SubscribeConsensusInfo

func (es *EventSystem) SubscribeConsensusInfo(consensusInfo chan *types.MinimalEpochConsensusInfo, epoch uint64) *Subscription

SubscribePendingTxs creates a subscription that writes transaction hashes for transactions that enter the transaction pool.

func (*EventSystem) SubscribeVerifiedSlotInfo

func (es *EventSystem) SubscribeVerifiedSlotInfo(slotInfo chan *types.SlotInfoWithStatus) *Subscription

SubscribeVerifiedSlotInfo

type MockBackend

type MockBackend struct {
	ConsensusInfoFeed event.Feed

	ConsensusInfos []*eventTypes.MinimalEpochConsensusInfo

	CurEpoch uint64
	// contains filtered or unexported fields
}

func (*MockBackend) ConsensusInfoByEpochRange

func (b *MockBackend) ConsensusInfoByEpochRange(fromEpoch uint64) []*eventTypes.MinimalEpochConsensusInfo

func (*MockBackend) GetSlotStatus

func (mb *MockBackend) GetSlotStatus(ctx context.Context, slot uint64, hash common.Hash, requestType bool) eventTypes.Status

func (*MockBackend) LatestEpoch

func (mb *MockBackend) LatestEpoch() uint64

func (*MockBackend) LatestVerifiedSlot

func (mb *MockBackend) LatestVerifiedSlot() uint64

func (*MockBackend) PendingPandoraHeaders

func (mb *MockBackend) PendingPandoraHeaders() []*eth1Types.Header

func (*MockBackend) SubscribeNewEpochEvent

func (b *MockBackend) SubscribeNewEpochEvent(ch chan<- *eventTypes.MinimalEpochConsensusInfo) event.Subscription

func (*MockBackend) SubscribeNewVerifiedSlotInfoEvent

func (b *MockBackend) SubscribeNewVerifiedSlotInfoEvent(ch chan<- *eventTypes.SlotInfoWithStatus) event.Subscription

func (*MockBackend) VerifiedSlotInfos

func (mb *MockBackend) VerifiedSlotInfos(fromSlot uint64) map[uint64]*eventTypes.SlotInfo

type PublicFilterAPI

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

PublicFilterAPI offers support to create and manage filters. This will allow external clients to retrieve various information related to the Ethereum protocol such als blocks, transactions and logs.

func NewPublicFilterAPI

func NewPublicFilterAPI(backend Backend, timeout time.Duration) *PublicFilterAPI

NewPublicFilterAPI returns a new PublicFilterAPI instance.

func (*PublicFilterAPI) ConfirmPanBlockHashes

func (api *PublicFilterAPI) ConfirmPanBlockHashes(
	ctx context.Context,
	requests []*BlockHash,
) ([]*BlockStatus, error)

ConfirmPanBlockHashes should be used to get the confirmation about known state of Pandora block hashes

func (*PublicFilterAPI) ConfirmVanBlockHashes

func (api *PublicFilterAPI) ConfirmVanBlockHashes(
	ctx context.Context,
	requests []*BlockHash,
) (response []*BlockStatus, err error)

ConfirmVanBlockHashes should be used to get the confirmation about known state of Vanguard block hashes

func (*PublicFilterAPI) MinimalConsensusInfo

func (api *PublicFilterAPI) MinimalConsensusInfo(ctx context.Context, requestedEpoch uint64) (*rpc.Subscription, error)

MinimalConsensusInfo

func (*PublicFilterAPI) SteamConfirmedPanBlockHashes

func (api *PublicFilterAPI) SteamConfirmedPanBlockHashes(
	ctx context.Context,
	request *BlockHash,
) (*rpc.Subscription, error)

SteamConfirmedPanBlockHashes

type Subscription

type Subscription struct {
	ID rpc.ID
	// contains filtered or unexported fields
}

Subscription is created when the client registers itself for a particular event.

func (*Subscription) Err

func (sub *Subscription) Err() <-chan error

Err returns a channel that is closed when unsubscribed.

func (*Subscription) Unsubscribe

func (sub *Subscription) Unsubscribe()

Unsubscribe uninstalls the subscription from the event broadcast loop.

type Type

type Type byte

Type determines the kind of filter and is used to put the filter in to the correct bucket when added.

const (
	// UnknownSubscription indicates an unknown subscription type
	UnknownSubscription Type = iota

	// MinConsensusInfoSubscription
	MinConsensusInfoSubscription

	// VerifiedSlotInfoSubscription triggers when new slot is verified
	VerifiedSlotInfoSubscription

	// LastSubscription keeps track of the last index
	LastIndexSubscription
)