core

Documentation

Overview

Package core implements IBFT consensus backend.go defines interfaces of backend, that performs detailed procedure rather than consensus

Index

• type Backend
• type IBFT
  • func NewIBFT(log Logger, backend Backend, transport Transport) *IBFT
  • func (i *IBFT) AddMessage(message *proto.Message)
  • func (i *IBFT) ExtendRoundTimeout(amount time.Duration)
  • func (i *IBFT) RunSequence(ctx context.Context, h uint64)
• type Logger
• type MessageConstructor
• type Messages
• type Transport
• type Verifier

Types

type Backend

type Backend interface {
	MessageConstructor
	Verifier

	// BuildProposal builds a new proposal for the given view (height and round)
	BuildProposal(view *proto.View) []byte

	// InsertProposal inserts a proposal with the specified committed seals
	// the reason why we are including round here is because a single committedSeal
	// has signed the tuple of (rawProposal, round)
	InsertProposal(proposal *proto.Proposal, committedSeals []*messages.CommittedSeal)

	// ID returns the validator's ID
	ID() []byte

	// HasQuorum returns true if the quorum is reached
	// for the specified height.
	HasQuorum(height uint64, msgs []*proto.Message, msgType proto.MessageType) bool
}

Backend defines an interface all backend implementations need to implement

type IBFT

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

IBFT represents a single instance of the IBFT state machine

func NewIBFT

func NewIBFT(
	log Logger,
	backend Backend,
	transport Transport,
) *IBFT

NewIBFT creates a new instance of the IBFT consensus protocol

func (*IBFT) AddMessage

func (i *IBFT) AddMessage(message *proto.Message)

AddMessage adds a new message to the IBFT message system

func (*IBFT) ExtendRoundTimeout

func (i *IBFT) ExtendRoundTimeout(amount time.Duration)

ExtendRoundTimeout extends each round's timer by the specified amount.

func (*IBFT) RunSequence

func (i *IBFT) RunSequence(ctx context.Context, h uint64)

RunSequence runs the IBFT sequence for the specified height

type Logger

type Logger interface {
	Info(msg string, args ...interface{})
	Debug(msg string, args ...interface{})
	Error(msg string, args ...interface{})
}

Logger represents the logger behaviour

type MessageConstructor

type MessageConstructor interface {
	// BuildPrePrepareMessage builds a PREPREPARE message based on the passed in view and proposal
	BuildPrePrepareMessage(
		rawProposal []byte,
		certificate *proto.RoundChangeCertificate,
		view *proto.View,
	) *proto.Message

	// BuildPrepareMessage builds a PREPARE message based on the passed in view and proposal hash
	BuildPrepareMessage(proposalHash []byte, view *proto.View) *proto.Message

	// BuildCommitMessage builds a COMMIT message based on the passed in view and proposal hash
	// Must create a committed seal for proposal hash and include it into the message
	BuildCommitMessage(proposalHash []byte, view *proto.View) *proto.Message

	// BuildRoundChangeMessage builds a ROUND_CHANGE message based on the passed in view,
	// latest prepared proposal, and latest prepared certificate
	BuildRoundChangeMessage(
		proposal *proto.Proposal,
		certificate *proto.PreparedCertificate,
		view *proto.View,
	) *proto.Message
}

MessageConstructor defines a message constructor interface All constructed messages must be signed by a validator for the whole message

type Messages

type Messages interface {
	// Messages modifiers //
	AddMessage(message *proto.Message)
	PruneByHeight(height uint64)

	SignalEvent(message *proto.Message)

	// Messages fetchers //
	GetValidMessages(
		view *proto.View,
		messageType proto.MessageType,
		isValid func(*proto.Message) bool,
	) []*proto.Message
	GetExtendedRCC(
		height uint64,
		isValidMessage func(message *proto.Message) bool,
		isValidRCC func(round uint64, msgs []*proto.Message) bool,
	) []*proto.Message
	GetMostRoundChangeMessages(minRound, height uint64) []*proto.Message

	// Messages subscription handlers //
	Subscribe(details messages.SubscriptionDetails) *messages.Subscription
	Unsubscribe(id messages.SubscriptionID)
}

Messages represents the message managing behaviour

type Transport

type Transport interface {
	// Multicast multicasts the message to other peers
	Multicast(message *proto.Message)
}

Transport defines an interface the node uses to communicate with other peers

type Verifier

type Verifier interface {
	// IsValidProposal checks if the proposal is valid
	IsValidProposal(rawProposal []byte) bool

	// IsValidValidator checks if a signature in message is signed by sender
	// Must check the following things:
	// (1) recover the signature and the signer matches from address in message
	// (2) the signer address is one of the validators at the height in message
	IsValidValidator(msg *proto.Message) bool

	// IsProposer checks if the passed in ID is the Proposer for current view (sequence, round)
	IsProposer(id []byte, height, round uint64) bool

	// IsValidProposalHash checks if the hash matches the proposal
	IsValidProposalHash(proposal *proto.Proposal, hash []byte) bool

	// IsValidCommittedSeal checks
	// if signature for proposal hash in committed seal is signed by a validator
	IsValidCommittedSeal(proposalHash []byte, committedSeal *messages.CommittedSeal) bool
}

Verifier defines the verifier interface