events

Documentation

Index

• Constants
• type Backend
• type BlockHash
• type BlockStatus
• type EventSystem
  • func NewEventSystem(backend Backend) *EventSystem
  • func (es *EventSystem) SubscribeConsensusInfo(consensusInfo chan *types.MinimalEpochConsensusInfo, epoch uint64) *Subscription
• type MockBackend
  • func (backend *MockBackend) ConsensusInfoByEpochRange(fromEpoch uint64) []*eventTypes.MinimalEpochConsensusInfo
  • func (backend *MockBackend) CurrentEpoch() uint64
  • func (b *MockBackend) SubscribeNewEpochEvent(ch chan<- *eventTypes.MinimalEpochConsensusInfo) event.Subscription
• type PublicFilterAPI
  • func NewPublicFilterAPI(backend Backend, timeout time.Duration) *PublicFilterAPI
  • func (api *PublicFilterAPI) ConfirmPanBlockHashes(ctx context.Context, request []*BlockHash) (response []*BlockStatus, err error)
  • func (api *PublicFilterAPI) ConfirmVanBlockHashes(ctx context.Context, request []*BlockHash) (response []*BlockStatus, err error)
  • func (api *PublicFilterAPI) MinimalConsensusInfo(ctx context.Context, epoch uint64) (*rpc.Subscription, error)
• type Status
• type Subscription
  • func (sub *Subscription) Err() <-chan error
  • func (sub *Subscription) Unsubscribe()
• type Type

Constants

const (
	MockedHashInvalid = "0xc9a190eb52c18df5ffcb1d817214ecb08f025f8583805cd12064d30e3f9bd9d5"
	MockedHashPending = "0xa99c69a301564970956edd897ff0590f4c0f1031daa464ded655af65ad0906df"
)

Types

type Backend

type Backend interface {
	CurrentEpoch() uint64
	ConsensusInfoByEpochRange(fromEpoch uint64) []*eventTypes.MinimalEpochConsensusInfo
	SubscribeNewEpochEvent(chan<- *eventTypes.MinimalEpochConsensusInfo) event.Subscription
}

type BlockHash

type BlockHash struct {
	Slot uint64
	Hash common.Hash
}

type BlockStatus

type BlockStatus struct {
	BlockHash
	Status 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.

type MockBackend

type MockBackend struct {
	ConsensusInfoFeed event.Feed
	ConsensusInfos    []*eventTypes.MinimalEpochConsensusInfo
	CurEpoch          uint64
}

func (*MockBackend) ConsensusInfoByEpochRange

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

func (*MockBackend) CurrentEpoch

func (backend *MockBackend) CurrentEpoch() uint64

func (*MockBackend) SubscribeNewEpochEvent

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

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,
	request []*BlockHash,
) (response []*BlockStatus, err error)

ConfirmPanBlockHashes

func (*PublicFilterAPI) ConfirmVanBlockHashes

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

ConfirmVanBlockHashes

func (*PublicFilterAPI) MinimalConsensusInfo

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

MinimalConsensusInfo

type Status

type Status int

const (
	Pending Status = iota
	Verified
	Invalid
)

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

	// LastSubscription keeps track of the last index
	LastIndexSubscription
)