blockchain

type Block interface {
	Message

	ImplementsBlock()

	GetParentBlockSn() BlockSn
	GetHash() Hash
	// GetNumber() returns the number (height) of this block.
	GetNumber() uint32
	GetNotarizations() []Notarization
	Compare(other Block) int

	// GetBodyString() returns a string to represent the block.
	// This is used for logging/testing/debugging.
	GetBodyString() string
}

type BlockAndEvent struct {
	Block Block
	Event *FinalizedChainExtendedEvent
}

type BlockChain interface {
	// ContainsBlock returns true if the block(s) exists.
	// Expect this is more efficient compared to using GetBlock() == nil.
	ContainsBlock(s BlockSn) bool
	// GetBlock returns nil if there is no such value.
	GetBlock(s BlockSn) Block
	GetGenesisBlock() Block
	// GetNotarization returns nil if there is no such value.
	GetNotarization(s BlockSn) Notarization
	// GetFreshestNotarizedChain() returns the last block of the freshest notarized chain
	// decided by the all received notarizations.
	GetFreshestNotarizedChain() Block
	// GetFinalizedChain() returns the last block of the finalized chain.
	// Unlike the freshest notarized chain, we use notarizations in blocks to decide the finalized
	// chain. In other words, notarizations received from AddNotarization() are not used.
	// This constraint makes the finality stronger in practice.
	// When the freshest notarized chain contains 2K consecutive normal blocks,
	// the finalize chain is the one without the last 2k blocks. Note that it is possible
	// that the finalized chain doesn't grow while the freshest notarized chain keeps growing.
	// NOTE: To simplify the implementation, the notarizations in a timeout block doesn't finalize
	// any new block in current design. We can remove this constraint later.
	GetFinalizedChain() Block

	// InsertBlock returns error if:
	// * |b| already exists.
	// * |b|'s parent doesn't exist in the chain.
	// * notarizations in |b| doesn't follow the rules. See rules above BlockChain.
	// * Any other invalid block format based on the implementation definition.
	// The error may support IsTemporary().
	// If the error is temporary, the caller should catch up previous blocks and then insert
	// the block again. During the call, the finalized chain may be updated.
	InsertBlock(b Block) error

	// StartCreatingNewBlocks returns a channel with buffer size = |K|.
	// The first new block's BlockSn is {|epoch|,1} and its parent is the freshest notarized block.
	// BlockAndEvent.Event is set if the new block extends the finalized chain.
	// This fits the stability-favoring approach in PaLa.
	StartCreatingNewBlocks(epoch Epoch) (chan BlockAndEvent, error)
	// StopCreatingNewBlocks stops the creation. However, there may be some blocks in the channel returned
	// by StartCreatingNewBlocks(). The call returns after the worker goroutine ends.
	// It's safe to call this without calling StartCreatingNewBlocks().
	StopCreatingNewBlocks() error
	// IsCreatingBlock() returns true if the worker goroutine keeps trying to create new blocks.
	IsCreatingBlock() bool
	// AddNotarization may update the freshest notarized chain and/or continue creating a new block
	// if StartCreatingNewBlocks() is called before. Return error if:
	// * the corresponding block does not exist.
	// * the parent block's notarization does not exist.
	// Note that the notarization can be stored anywhere (even in memory) and may be lost
	// after we recreate the BlockChain object.
	AddNotarization(n Notarization) error

	// NewNotificationChannel creates a new channel used to notify events such as
	// FreshestNotarizedChainExtendedEvent and FinalizedChainExtendedEvent.
	NewNotificationChannel() <-chan interface{}
	// RemoveNotificationChannel removes the returned channel from NewNotificationChannel.
	RemoveNotificationChannel(target <-chan interface{})
}

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

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

type BlockSn struct {
	Epoch Epoch
	S     uint32
}

type BlockSnGetter interface {
	GetBlockSn() BlockSn
}

type ByBlockSn []Message

type ClockMsg interface {
	Message

	ImplementsClockMsg()

	GetEpoch() Epoch
	GetVoterId() string
}

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

type ClockMsgNota interface {
	Message

	ImplementsClockMsgNota()

	GetEpoch() Epoch
	GetNVote() uint16
}

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

type Config struct {
}

type DataUnmarshaller interface {
	// UnmarshalBlock receives Block.GetBody() and returns Block and the rest of the bytes.
	UnmarshalBlock([]byte) (Block, []byte, error)
	// UnmarshalProposal receives Proposal.GetBody() and returns Proposal and the rest of the bytes.
	UnmarshalProposal([]byte) (Proposal, []byte, error)
	// UnmarshalVote receives Vote.GetBody() and returns Vote and the rest of the bytes.
	UnmarshalVote([]byte) (Vote, []byte, error)
	// UnmarshalNotarization receives Notarization.GetBody() and returns Notarization and
	// the rest of the bytes.
	UnmarshalNotarization([]byte) (Notarization, []byte, error)
	// UnmarshalClockMsg receives ClockMsg.GetBody() and returns ClockMsg and the rest of the bytes.
	UnmarshalClockMsg([]byte) (ClockMsg, []byte, error)
	// UnmarshalClockMsgNota receives ClockMsgNota.GetBody()
	// and returns ClockMsgNota and the rest of the bytes.
	UnmarshalClockMsgNota([]byte) (ClockMsgNota, []byte, error)
}

type DataUnmarshallerFake struct {
}

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

type Epoch uint32

type FinalizedChainExtendedEvent struct {
	Sn BlockSn
	// This field is set when there is a reconfiguration.
	ReconfFinalizedByBlockSn BlockSn
}

type FreshestNotarizedChainExtendedEvent struct {
	Sn BlockSn
}

type Hash []byte

type Message interface {
	GetType() Type
	GetBody() []byte
	GetBlockSn() BlockSn
	GetDebugString() string
}

type Notarization interface {
	Message

	ImplementsNotarization()

	GetNVote() uint16
	GetBlockHash() Hash
}

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

type Proposal interface {
	Message

	ImplementsProposal()

	GetBlock() Block
	GetProposerId() string
}

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

type Type uint8

type Verifier interface {
	Propose(b Block) (Proposal, error)
	// VerifyProposal verifies |p| is signed by the eligible proposer
	// and |p|'s block should contain valid notarizations of ancestor blocks.
	// See the rule above BlockChain for details.
	VerifyProposal(p Proposal) error
	Vote(p Proposal) (Vote, error)
	VerifyVote(v Vote) error
	Notarize(votes []Vote) (Notarization, error)
	VerifyNotarization(n Notarization) error
	NewClockMsg(e Epoch) (ClockMsg, error)
	VerifyClockMsg(c ClockMsg) error
	NewClockMsgNota(clocks []ClockMsg) (ClockMsgNota, error)
	VerifyClockMsgNota(cn ClockMsgNota) error

	// Used for verifying the other end's role (challenge-response)
	Sign(id string, bytes []byte) ([]byte, error)
	VerifySignature(id string, signature []byte, expected []byte) error
}

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

type Vote interface {
	Message

	ImplementsVote()

	GetVoterId() string
}

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