dkg

Documentation

Index

• Constants
• type MessagingEngine
  • func NewMessagingEngine(logger zerolog.Logger, net network.Network, me module.Local, ...) (*MessagingEngine, error)
  • func (e *MessagingEngine) Done() <-chan struct{}
  • func (e *MessagingEngine) Process(_ channels.Channel, originID flow.Identifier, event interface{}) error
  • func (e *MessagingEngine) ProcessLocal(event interface{}) error
  • func (e *MessagingEngine) Ready() <-chan struct{}
  • func (e *MessagingEngine) Submit(_ channels.Channel, originID flow.Identifier, event interface{})
  • func (e *MessagingEngine) SubmitLocal(event interface{})
• type ReactorEngine
  • func NewReactorEngine(log zerolog.Logger, me module.Local, state protocol.State, ...) *ReactorEngine
  • func (e *ReactorEngine) Done() <-chan struct{}
  • func (e *ReactorEngine) EpochCommittedPhaseStarted(currentEpochCounter uint64, first *flow.Header)
  • func (e *ReactorEngine) EpochSetupPhaseStarted(currentEpochCounter uint64, first *flow.Header)
  • func (e *ReactorEngine) Ready() <-chan struct{}

Constants

const DefaultPollStep = 10

DefaultPollStep specifies the default number of views that separate two calls to the DKG smart-contract to read broadcast messages.

Types

type MessagingEngine

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

MessagingEngine is a network engine that enables DKG nodes to exchange private messages over the network.

func NewMessagingEngine

func NewMessagingEngine(
	logger zerolog.Logger,
	net network.Network,
	me module.Local,
	tunnel *dkg.BrokerTunnel) (*MessagingEngine, error)

NewMessagingEngine returns a new engine.

func (*MessagingEngine) Done

func (e *MessagingEngine) Done() <-chan struct{}

Done implements the module ReadyDoneAware interface. It returns a channel that will close when the engine has successfully stopped.

func (*MessagingEngine) Process

func (e *MessagingEngine) Process(_ channels.Channel, originID flow.Identifier, event interface{}) error

Process implements the network Engine interface

func (*MessagingEngine) ProcessLocal

func (e *MessagingEngine) ProcessLocal(event interface{}) error

ProcessLocal implements the network Engine interface

func (*MessagingEngine) Ready

func (e *MessagingEngine) Ready() <-chan struct{}

Ready implements the module ReadyDoneAware interface. It returns a channel that will close when the engine has successfully started.

func (*MessagingEngine) Submit

func (e *MessagingEngine) Submit(_ channels.Channel, originID flow.Identifier, event interface{})

Submit implements the network Engine interface

func (*MessagingEngine) SubmitLocal

func (e *MessagingEngine) SubmitLocal(event interface{})

SubmitLocal implements the network Engine interface

type ReactorEngine

type ReactorEngine struct {
	events.Noop

	State protocol.State
	// contains filtered or unexported fields
}

ReactorEngine is an engine that reacts to chain events to start new DKG runs, and manage subsequent phase transitions. Any unexpected error triggers a panic as it would undermine the security of the protocol.

func NewReactorEngine

func NewReactorEngine(
	log zerolog.Logger,
	me module.Local,
	state protocol.State,
	dkgState storage.DKGState,
	controllerFactory module.DKGControllerFactory,
	viewEvents events.Views,
) *ReactorEngine

NewReactorEngine return a new ReactorEngine.

func (*ReactorEngine) Done

func (e *ReactorEngine) Done() <-chan struct{}

Done implements the module ReadyDoneAware interface. It returns a channel that will close when the engine has successfully stopped.

func (*ReactorEngine) EpochCommittedPhaseStarted

func (e *ReactorEngine) EpochCommittedPhaseStarted(currentEpochCounter uint64, first *flow.Header)

EpochCommittedPhaseStarted handles the EpochCommittedPhaseStarted protocol event by checking the consistency of our locally computed key share.

func (*ReactorEngine) EpochSetupPhaseStarted

func (e *ReactorEngine) EpochSetupPhaseStarted(currentEpochCounter uint64, first *flow.Header)

EpochSetupPhaseStarted handles the EpochSetupPhaseStarted protocol event by starting the DKG process.

func (*ReactorEngine) Ready

func (e *ReactorEngine) Ready() <-chan struct{}

Ready implements the module ReadyDoneAware interface. It returns a channel that will close when the engine has successfully started.