events

Documentation

Index

• Constants
• type CheckFunc
• type EventAPI
• type EventHandler
• type Events
  • func NewEvents(ctx context.Context, api EventAPI) *Events
  • func NewEventsWithConfidence(ctx context.Context, api EventAPI, gcConfidence abi.ChainEpoch) *Events
  • func (e *Events) ChainAt(hnd HeightHandler, rev RevertHandler, confidence int, h abi.ChainEpoch) error
  • func (e *Events) Observe(obs TipSetObserver) error
• type HeightHandler
• type MsgHandler
• type MsgMatchFunc
• type RevertHandler
• type StateChange
• type StateChangeHandler
• type StateMatchFunc
• type TipSetObserver

Constants

const NoHeight = abi.ChainEpoch(-1)

const NoTimeout = math.MaxInt64

Types

type CheckFunc

type CheckFunc func(ts *types.TipSet) (done bool, more bool, err error)

CheckFunc is used for atomicity guarantees. If the condition the callbacks wait for has already happened in tipset `ts`

If `done` is true, timeout won't be triggered If `more` is false, no messages will be sent to EventHandler (RevertHandler

may still be called)

type EventAPI

type EventAPI interface {
	ChainNotify(context.Context) (<-chan []*api.HeadChange, error)
	ChainGetBlockMessages(context.Context, cid.Cid) (*api.BlockMessages, error)
	ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
	ChainHead(context.Context) (*types.TipSet, error)
	StateSearchMsg(ctx context.Context, from types.TipSetKey, msg cid.Cid, limit abi.ChainEpoch, allowReplaced bool) (*api.MsgLookup, error)
	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)

	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) // optional / for CalledMsg
}

type EventHandler

type EventHandler func(data eventData, prevTs, ts *types.TipSet, curH abi.ChainEpoch) (more bool, err error)

EventHandler arguments: `prevTs` is the previous tipset, eg the "from" tipset for a state change. `ts` is the event tipset, eg the tipset in which the `msg` is included. `curH`-`ts.Height` = `confidence`

type Events

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

func NewEvents

func NewEvents(ctx context.Context, api EventAPI) *Events

func NewEventsWithConfidence

func NewEventsWithConfidence(ctx context.Context, api EventAPI, gcConfidence abi.ChainEpoch) *Events

func (*Events) ChainAt

func (e *Events) ChainAt(hnd HeightHandler, rev RevertHandler, confidence int, h abi.ChainEpoch) error

ChainAt invokes the specified `HeightHandler` when the chain reaches the specified height+confidence threshold. If the chain is rolled-back under the specified height, `RevertHandler` will be called.

ts passed to handlers is the tipset at the specified, or above, if lower tipsets were null

func (*Events) Observe

func (e *Events) Observe(obs TipSetObserver) error

TODO: add a confidence level so we can have observers with difference levels of confidence

type HeightHandler

type HeightHandler func(ctx context.Context, ts *types.TipSet, curH abi.ChainEpoch) error

HeightHandler `curH`-`ts.Height` = `confidence`

type MsgHandler

type MsgHandler func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (more bool, err error)

MsgHandler arguments: `ts` is the tipset, in which the `msg` is included. `curH`-`ts.Height` = `confidence`

type MsgMatchFunc

type MsgMatchFunc func(msg *types.Message) (matched bool, err error)

type RevertHandler

type RevertHandler func(ctx context.Context, ts *types.TipSet) error

HeightHandler `curH`-`ts.Height` = `confidence`

type StateChange

type StateChange interface{}

StateChange represents a change in state

type StateChangeHandler

type StateChangeHandler func(oldTs, newTs *types.TipSet, states StateChange, curH abi.ChainEpoch) (more bool, err error)

StateChangeHandler arguments: `oldTs` is the state "from" tipset `newTs` is the state "to" tipset `states` is the change in state `curH`-`ts.Height` = `confidence`

type StateMatchFunc

type StateMatchFunc func(oldTs, newTs *types.TipSet) (bool, StateChange, error)

type TipSetObserver

type TipSetObserver interface {
	Apply(ctx context.Context, ts *types.TipSet) error
	Revert(ctx context.Context, ts *types.TipSet) error
}

A TipSetObserver receives notifications of tipsets