event

type BlockCounter interface {
	BlockCount() (res uint32, err error)
}

type BlockHandler func(*block.Block)

type Event interface {
	MorphEvent()
}

type ExpiredTXError struct {
	CurrentBlockHeight             uint32
	FallbackTXNotValidBeforeHeight uint32
}

type Handler func(Event)

type Listener interface {
	// Listen must start the event listener.
	//
	// Must listen to events with the parser installed.
	Listen(context.Context)

	// ListenWithError must start the event listener.
	//
	// Must listen to events with the parser installed.
	//
	// Must send error to channel if subscriber channel has been closed or
	// it could not be started.
	ListenWithError(context.Context, chan<- error)

	// SetNotificationParser must set the parser of particular contract event.
	//
	// Parser of each event must be set once. All parsers must be set before Listen call.
	//
	// Must ignore nil parsers and all calls after listener has been started.
	SetNotificationParser(NotificationParserInfo)

	// RegisterNotificationHandler must register the event handler for particular notification event of contract.
	//
	// The specified handler must be called after each capture and parsing of the event.
	//
	// Must ignore nil handlers.
	RegisterNotificationHandler(NotificationHandlerInfo)

	// EnableNotarySupport enables notary request listening. Passed hash is
	// notary mainTX signer. In practise, it means that listener will subscribe
	// for only notary requests that are going to be paid with passed hash.
	//
	// Must not be called after Listen or ListenWithError.
	EnableNotarySupport(util.Uint160, client.AlphabetKeys, BlockCounter)

	// SetNotaryParser must set the parser of particular notary request event.
	//
	// Parser of each event must be set once. All parsers must be set before Listen call.
	//
	// Must ignore nil parsers and all calls after listener has been started.
	//
	// Has no effect if EnableNotarySupport was not called before Listen or ListenWithError.
	SetNotaryParser(NotaryParserInfo)

	// RegisterNotaryHandler must register the event handler for particular notification event of contract.
	//
	// The specified handler must be called after each capture and parsing of the event.
	//
	// Must ignore nil handlers.
	//
	// Has no effect if EnableNotarySupport was not called before Listen or ListenWithError.
	RegisterNotaryHandler(NotaryHandlerInfo)

	// RegisterBlockHandler must register chain block handler.
	//
	// The specified handler must be called after each capture and parsing of the new block from chain.
	//
	// Must ignore nil handlers.
	RegisterBlockHandler(BlockHandler)

	// Stop must stop the event listener.
	Stop()
}

type ListenerParams struct {
	Logger *logger.Logger

	Subscriber subscriber.Subscriber

	WorkerPoolCapacity int
}

type NotaryEvent interface {
	ScriptHash() util.Uint160
	Type() NotaryType
	Params() []Op

	Raw() *payload.P2PNotaryRequest
}

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

type NotaryParser func(NotaryEvent) (Event, error)

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

type NotaryPreparator interface {
	Prepare(*payload.P2PNotaryRequest) (NotaryEvent, error)
}

type NotaryType string

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

type NotificationParser func(*state.ContainedNotificationEvent) (Event, error)

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

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

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

type PreparatorPrm struct {
	AlphaKeys client.AlphabetKeys

	// BlockCount must return block count of the network
	// from which notary requests are received.
	BlockCounter BlockCounter
}

type Type string