consensus

type Acceptor interface {
	// Accept returns true if the replica should accept the command, false otherwise.
	Accept(Command) bool
	// Proposed tells the acceptor that the propose phase for the given command succeeded, and it should no longer be
	// accepted in the future.
	Proposed(Command)
}

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

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

type BlockChain interface {
	// Store stores a block in the blockchain.
	Store(*Block)

	// Get retrieves a block given its hash, attempting to fetching it from other replicas if necessary.
	Get(Hash) (*Block, bool)

	// LocalGet retrieves a block given its hash, without fetching it from other replicas.
	LocalGet(Hash) (*Block, bool)

	// Extends checks if the given block extends the branch of the target hash.
	Extends(block, target *Block) bool

	// Prunes blocks from the in-memory tree up to the specified height.
	// Returns a set of forked blocks (blocks that were on a different branch, and thus not committed).
	PruneToHeight(height View) (forkedBlocks []*Block)
}

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

type Command string

type CommandQueue interface {
	// Get returns the next command to be proposed.
	// It may run until the context is cancelled.
	// If no command is available, the 'ok' return value should be false.
	Get(ctx context.Context) (cmd Command, ok bool)
}

type CommitEvent struct {
	Commands int
}

type Configuration interface {
	// Replicas returns all of the replicas in the configuration.
	Replicas() map[hotstuff.ID]Replica
	// Replica returns a replica if present in the configuration.
	Replica(hotstuff.ID) (replica Replica, ok bool)
	// Len returns the number of replicas in the configuration.
	Len() int
	// QuorumSize returns the size of a quorum.
	QuorumSize() int
	// Propose sends the block to all replicas in the configuration.
	Propose(proposal ProposeMsg)
	// Timeout sends the timeout message to all replicas.
	Timeout(msg TimeoutMsg)
	// Fetch requests a block from all the replicas in the configuration.
	Fetch(ctx context.Context, hash Hash) (block *Block, ok bool)
}

type Consensus interface {
	// StopVoting ensures that no voting happens in a view earlier than `view`.
	StopVoting(view View)
	// Propose starts a new proposal. The command is fetched from the command queue.
	Propose(cert SyncInfo)
	// CommittedBlock returns the most recently committed block.
	CommittedBlock() *Block
}

type Crypto interface {
	CryptoImpl
	// CreatePartialCert signs a single block and returns the partial certificate.
	CreatePartialCert(block *Block) (cert PartialCert, err error)
	// CreateQuorumCert creates a quorum certificate from a list of partial certificates.
	CreateQuorumCert(block *Block, signatures []PartialCert) (cert QuorumCert, err error)
	// CreateTimeoutCert creates a timeout certificate from a list of timeout messages.
	CreateTimeoutCert(view View, timeouts []TimeoutMsg) (cert TimeoutCert, err error)
	// CreateAggregateQC creates an AggregateQC from the given timeout messages.
	CreateAggregateQC(view View, timeouts []TimeoutMsg) (aggQC AggregateQC, err error)
	// VerifyPartialCert verifies a single partial certificate.
	VerifyPartialCert(cert PartialCert) bool
	// VerifyQuorumCert verifies a quorum certificate.
	VerifyQuorumCert(qc QuorumCert) bool
	// VerifyTimeoutCert verifies a timeout certificate.
	VerifyTimeoutCert(tc TimeoutCert) bool
	// VerifyAggregateQC verifies an AggregateQC.
	VerifyAggregateQC(aggQC AggregateQC) (ok bool, highQC QuorumCert)
}

type CryptoImpl interface {
	// Sign signs a hash.
	Sign(hash Hash) (sig Signature, err error)
	// Verify verifies a signature given a hash.
	Verify(sig Signature, hash Hash) bool
	// CreateThresholdSignature creates a threshold signature from the given partial signatures.
	CreateThresholdSignature(partialSignatures []Signature, hash Hash) (ThresholdSignature, error)
	// CreateThresholdSignatureForMessageSet creates a threshold signature where each partial signature has signed a
	// different message hash.
	CreateThresholdSignatureForMessageSet(partialSignatures []Signature, hashes map[hotstuff.ID]Hash) (ThresholdSignature, error)
	// VerifyThresholdSignature verifies a threshold signature.
	VerifyThresholdSignature(signature ThresholdSignature, hash Hash) bool
	// VerifyThresholdSignatureForMessageSet verifies a threshold signature against a set of message hashes.
	VerifyThresholdSignatureForMessageSet(signature ThresholdSignature, hashes map[hotstuff.ID]Hash) bool
}

type Executor interface {
	// Exec executes the command.
	Exec(cmd Command)
}

type ExecutorExt interface {
	// Exec executes the command in the block.
	Exec(block *Block)
}

type ForkHandler interface {
	// Fork handles the command from a forked block.
	Fork(cmd Command)
}

type ForkHandlerExt interface {
	// Fork handles the forked block.
	Fork(block *Block)
}

type Hash [32]byte

type IDSet interface {
	// Add adds an ID to the set.
	Add(id hotstuff.ID)
	// Contains returns true if the set contains the ID.
	Contains(id hotstuff.ID) bool
	// ForEach calls f for each ID in the set.
	ForEach(f func(hotstuff.ID))
}

type LeaderRotation interface {
	// GetLeader returns the id of the leader in the given view.
	GetLeader(View) hotstuff.ID
}

type Module interface {
	// InitConsensusModule gives the module a reference to the Modules object.
	// It also allows the module to set module options using the OptionsBuilder.
	InitConsensusModule(mods *Modules, _ *OptionsBuilder)
}

type Modules struct {
	// we embed a modules.Modules object so that we can use those modules too.
	*modules.Modules
	// contains filtered or unexported fields
}

type NewViewMsg struct {
	ID       hotstuff.ID // The ID of the replica who sent the message.
	SyncInfo SyncInfo    // The highest QC / TC.
}

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

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

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

type PrivateKey interface {
	// Public returns the public key associated with this private key.
	Public() PublicKey
}

type ProposeMsg struct {
	ID          hotstuff.ID  // The ID of the replica who sent the message.
	Block       *Block       // The block that is proposed.
	AggregateQC *AggregateQC // Optional AggregateQC
}

type ProposeRuler interface {
	// ProposeRule creates a new proposal.
	ProposeRule(cert SyncInfo, cmd Command) (proposal ProposeMsg, ok bool)
}

type PublicKey = crypto.PublicKey

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

type Replica interface {
	// ID returns the replica's id.
	ID() hotstuff.ID
	// PublicKey returns the replica's public key.
	PublicKey() PublicKey
	// Vote sends the partial certificate to the other replica.
	Vote(cert PartialCert)
	// NewView sends the quorum certificate to the other replica.
	NewView(SyncInfo)
}

type Rules interface {
	// VoteRule decides whether to vote for the block.
	VoteRule(proposal ProposeMsg) bool
	// CommitRule decides whether any ancestor of the block can be committed.
	// Returns the youngest ancestor of the block that can be committed.
	CommitRule(*Block) *Block
}

type Signature interface {
	ToBytes
	// Signer returns the ID of the replica that created the signature.
	Signer() hotstuff.ID
}

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

type Synchronizer interface {
	// AdvanceView attempts to advance to the next view using the given QC.
	// qc must be either a regular quorum certificate, or a timeout certificate.
	AdvanceView(SyncInfo)
	// UpdateHighQC attempts to update HighQC using the given QC.
	UpdateHighQC(QuorumCert)
	// View returns the current view.
	View() View
	// ViewContext returns a context that is cancelled at the end of the view.
	ViewContext() context.Context
	// HighQC returns the highest known QC.
	HighQC() QuorumCert
	// LeafBlock returns the current leaf block.
	LeafBlock() *Block
	// Start starts the synchronizer with the given context.
	Start(context.Context)
}

type ThresholdSignature interface {
	ToBytes
	// Participants returns the IDs of replicas who participated in the threshold signature.
	Participants() IDSet
}

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

type TimeoutMsg struct {
	ID            hotstuff.ID // The ID of the replica who sent the message.
	View          View        // The view that the replica wants to enter.
	ViewSignature Signature   // A signature of the view
	MsgSignature  Signature   // A signature of the view, QC.BlockHash, and the replica ID
	SyncInfo      SyncInfo    // The highest QC/TC known to the sender.
}

type ToBytes interface {
	// ToBytes returns the object as bytes.
	ToBytes() []byte
}

type View uint64

type VoteMsg struct {
	ID          hotstuff.ID // the ID of the replica who sent the message.
	PartialCert PartialCert // The partial certificate.
	Deferred    bool
}

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