Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

bft

package module

Go to main page

Versions in this module

v0

v0.1.6

May 17, 2026

v0.1.5

Jan 13, 2026

v0.1.4

Dec 29, 2025

v0.1.3

Dec 25, 2025

v0.1.2

Nov 11, 2025

v0.1.1

Nov 11, 2025

Changes in this version

+ const Version

+ const VersionMajor

+ const VersionMinor

+ const VersionPatch

+ func Orbit(round uint64, nodeIndex uint16, nodeCount uint16) uint64

+ type Blacklist struct

+ NodeCount uint16

+ SuspectedNodes SuspectedNodes

+ Updates BlacklistUpdates

+ func NewBlacklist(nodeCount uint16) Blacklist

+ func (bl *Blacklist) ApplyUpdates(updates []BlacklistUpdate, round uint64) Blacklist

+ func (bl *Blacklist) Bytes() []byte

+ func (bl *Blacklist) ComputeBlacklistUpdates(round uint64, nodeCount uint16, timedOut, redeemed map[uint16]uint64) []BlacklistUpdate

+ func (bl *Blacklist) Equals(b2 *Blacklist) bool

+ func (bl *Blacklist) FromBytes(buff []byte) error

+ func (bl *Blacklist) IsEmpty() bool

+ func (bl *Blacklist) IsNodeSuspected(nodeIndex uint16) bool

+ func (bl *Blacklist) String() string

+ func (bl *Blacklist) VerifyProposedBlacklist(candidateBlacklist Blacklist, round uint64) error

+ type BlacklistOpType uint8

+ const BlacklistOpType_NodeRedeemed

+ const BlacklistOpType_NodeSuspected

+ const BlacklistOpType_Undefined

+ type BlacklistUpdate struct

+ NodeIndex uint16

+ Type BlacklistOpType

+ func (bu *BlacklistUpdate) Equals(bu2 *BlacklistUpdate) bool

+ func (bu *BlacklistUpdate) String() string

+ type BlacklistUpdates []BlacklistUpdate

+ func (updates *BlacklistUpdates) FromBytes(buff []byte) error

+ func (updates BlacklistUpdates) Bytes() []byte

+ func (updates BlacklistUpdates) Len() int

+ type NotarizationTime struct

+ func NewNotarizationTime(finalizeVoteRebroadcastTimeout time.Duration, ...) NotarizationTime

+ func (nt *NotarizationTime) CheckForNotFinalizedNotarizedBlocks(now time.Time)

+ type SuspectedNode struct

+ NodeIndex uint16

+ OrbitSuspected uint64

+ OrbitToRedeem uint64

+ RedeemingCount uint16

+ SuspectingCount uint16

+ func (sn *SuspectedNode) Equals(sn2 *SuspectedNode) bool

+ func (sn *SuspectedNode) Len() int

+ func (sn *SuspectedNode) Read(buff []byte) (int, error)

+ func (sn *SuspectedNode) String() string

+ type SuspectedNodes []SuspectedNode

+ func (sns *SuspectedNodes) Bytes() []byte

+ func (sns *SuspectedNodes) FromBytes(buff []byte) error

+ func (sns *SuspectedNodes) Len() int

v0.1.0

Jul 26, 2025

Changes in this version

+ const BlockHeaderLen

+ const DefaultEmptyVoteRebroadcastTimeout

+ const DefaultMaxPendingBlocks

+ const DefaultMaxProposalWaitTime

+ const DefaultMaxRoundWindow

+ const DefaultReplicationRequestTimeout

+ const EmptyVoteTimeoutID

+ const ProtocolMetadataLen

+ var ErrAlreadyStarted = errors.New("epoch already started")

+ var ErrorInvalidFinalizationDigest = errors.New("finalization digests do not match")

+ var ErrorNoVotes = errors.New("no votes to notarize")

+ func BlockRecord(bh BlockHeader, blockData []byte) []byte

+ func IsFinalizationValid(eligibleSigners map[string]struct{}, finalization *Finalization, ...) bool

+ func NewEmptyNotarizationRecord(emptyNotarization *EmptyNotarization) []byte

+ func NewEmptyVoteRecord(emptyVote ToBeSignedEmptyVote) []byte

+ func NewQuorumRecord(qc []byte, rawVote []byte, recordType uint16) []byte

+ func NewScheduler(logger Logger) *scheduler

+ func Quorum(n int) int

+ type Block interface

+ BlockHeader func() BlockHeader

+ Verify func(ctx context.Context) (VerifiedBlock, error)

+ func BlockFromRecord(ctx context.Context, blockDeserializer BlockDeserializer, record []byte) (Block, error)

+ type BlockBuilder interface

+ BuildBlock func(ctx context.Context, metadata ProtocolMetadata) (VerifiedBlock, bool)

+ IncomingBlock func(ctx context.Context)

+ type BlockDeserializer interface

+ DeserializeBlock func(ctx context.Context, bytes []byte) (Block, error)

+ type BlockHeader struct

+ Digest Digest

+ func ParseBlockRecord(buff []byte) (BlockHeader, []byte, error)

+ func (bh *BlockHeader) Bytes() []byte

+ func (bh *BlockHeader) Equals(other *BlockHeader) bool

+ func (bh *BlockHeader) FromBytes(buff []byte) error

+ type BlockMessage struct

+ Block Block

+ Vote Vote

+ type Communication interface

+ Broadcast func(msg *Message)

+ Nodes func() []NodeID

+ Send func(msg *Message, destination NodeID)

+ type Digest [metadataDigestLen]byte

+ func (d Digest) String() string

+ type EmptyNotarization struct

+ QC QuorumCertificate

+ Vote ToBeSignedEmptyVote

+ func EmptyNotarizationFromRecord(record []byte, qd QCDeserializer) (EmptyNotarization, error)

+ func (en *EmptyNotarization) Verify() error

+ type EmptyVote struct

+ Signature Signature

+ Vote ToBeSignedEmptyVote

+ type EmptyVoteSet struct

+ type Epoch struct

+ func NewEpoch(conf EpochConfig) (*Epoch, error)

+ func (e *Epoch) AdvanceTime(t time.Time)

+ func (e *Epoch) HandleMessage(msg *Message, from NodeID) error

+ func (e *Epoch) Metadata() ProtocolMetadata

+ func (e *Epoch) Start() error

+ func (e *Epoch) Stop()

+ type EpochConfig struct

+ BlockBuilder BlockBuilder

+ BlockDeserializer BlockDeserializer

+ Comm Communication

+ Epoch uint64

+ ID NodeID

+ Logger Logger

+ MaxProposalWait time.Duration

+ MaxRebroadcastWait time.Duration

+ QCDeserializer QCDeserializer

+ ReplicationEnabled bool

+ SignatureAggregator SignatureAggregator

+ Signer Signer

+ StartTime time.Time

+ Storage Storage

+ Verifier SignatureVerifier

+ WAL WriteAheadLog

+ type Finalization struct

+ Finalization ToBeSignedFinalization

+ QC QuorumCertificate

+ func FinalizationFromRecord(record []byte, qd QCDeserializer) (Finalization, error)

+ func NewFinalization(logger Logger, signatureAggregator SignatureAggregator, ...) (Finalization, error)

+ func (f *Finalization) Verify() error

+ type FinalizeVote struct

+ Finalization ToBeSignedFinalization

+ Signature Signature

+ type Logger interface

+ Debug func(msg string, fields ...zap.Field)

+ Error func(msg string, fields ...zap.Field)

+ Fatal func(msg string, fields ...zap.Field)

+ Info func(msg string, fields ...zap.Field)

+ Trace func(msg string, fields ...zap.Field)

+ Verbo func(msg string, fields ...zap.Field)

+ Warn func(msg string, fields ...zap.Field)

+ type Message struct

+ BlockMessage *BlockMessage

+ EmptyNotarization *EmptyNotarization

+ EmptyVoteMessage *EmptyVote

+ Finalization *Finalization

+ FinalizeVote *FinalizeVote

+ Notarization *Notarization

+ ReplicationRequest *ReplicationRequest

+ ReplicationResponse *ReplicationResponse

+ VerifiedBlockMessage *VerifiedBlockMessage

+ VerifiedReplicationResponse *VerifiedReplicationResponse

+ VoteMessage *Vote

+ type Monitor struct

+ func NewMonitor(startTime time.Time, logger Logger) *Monitor

+ func (m *Monitor) AdvanceTime(t time.Time)

+ func (m *Monitor) CancelFutureTask()

+ func (m *Monitor) CancelTask()

+ func (m *Monitor) Close()

+ func (m *Monitor) FutureTask(timeout time.Duration, f func())

+ func (m *Monitor) RunTask(f func()) bool

+ type NodeID []byte

+ func LeaderForRound(nodes []NodeID, r uint64) NodeID

+ func (node NodeID) Equals(otherNode NodeID) bool

+ func (node NodeID) String() string

+ type NodeIDs []NodeID

+ func (nodes NodeIDs) Remove(targetNode NodeID) []NodeID

+ func (nodes NodeIDs) String() string

+ type Notarization struct

+ QC QuorumCertificate

+ Vote ToBeSignedVote

+ func NewNotarization(logger Logger, signatureAggregator SignatureAggregator, ...) (Notarization, error)

+ func NotarizationFromRecord(record []byte, qd QCDeserializer) (Notarization, error)

+ func (n *Notarization) Verify() error

+ type ProtocolMetadata struct

+ Epoch uint64

+ Prev Digest

+ Round uint64

+ Seq uint64

+ Version uint8

+ func ProtocolMetadataFromBytes(buff []byte) (*ProtocolMetadata, error)

+ func (md *ProtocolMetadata) Bytes() []byte

+ type QCDeserializer interface

+ DeserializeQuorumCertificate func(bytes []byte) (QuorumCertificate, error)

+ type QuorumCertificate interface

+ Bytes func() []byte

+ Signers func() []NodeID

+ Verify func(msg []byte) error

+ type QuorumRecord struct

+ QC []byte

+ Vote []byte

+ type QuorumRound struct

+ Block Block

+ EmptyNotarization *EmptyNotarization

+ Finalization *Finalization

+ Notarization *Notarization

+ func (q *QuorumRound) GetRound() uint64

+ func (q *QuorumRound) GetSequence() uint64

+ func (q *QuorumRound) IsWellFormed() error

+ func (q *QuorumRound) String() string

+ func (q *QuorumRound) Verify() error

+ type ReplicationRequest struct

+ LatestRound uint64

+ Seqs []uint64

+ type ReplicationResponse struct

+ Data []QuorumRound

+ LatestRound *QuorumRound

+ type ReplicationState struct

+ func NewReplicationState(logger Logger, comm Communication, id NodeID, maxRoundWindow uint64, ...) *ReplicationState

+ func (r *ReplicationState) AdvanceTime(now time.Time)

+ func (r *ReplicationState) GetFinalizedBlockForSequence(seq uint64) (Block, Finalization, bool)

+ func (r *ReplicationState) GetQuroumRoundWithSeq(seq uint64) *QuorumRound

+ func (r *ReplicationState) StoreQuorumRound(round QuorumRound)

+ type Round struct

+ func NewRound(block VerifiedBlock) *Round

+ func SetRound(block VerifiedBlock, notarization *Notarization, finalization *Finalization) *Round

+ type Segment struct

+ End uint64

+ Start uint64

+ func CompressSequences(missingSeqs []uint64) []Segment

+ func DistributeSequenceRequests(start, end uint64, numNodes int) []Segment

+ type Signature struct

+ Signer NodeID

+ Value []byte

+ type SignatureAggregator interface

+ Aggregate func([]Signature) (QuorumCertificate, error)

+ type SignatureVerifier interface

+ Verify func(message []byte, signature []byte, signer NodeID) error

+ type SignedMessage struct

+ Context string

+ Payload []byte

+ type Signer interface

+ Sign func(message []byte) ([]byte, error)

+ type Storage interface

+ Height func() uint64

+ Index func(ctx context.Context, block VerifiedBlock, certificate Finalization) error

+ Retrieve func(seq uint64) (VerifiedBlock, Finalization, bool)

+ type TaskHeap []*TimeoutTask

+ func (h *TaskHeap) Len() int

+ func (h *TaskHeap) Less(i, j int) bool

+ func (h *TaskHeap) Pop() any

+ func (h *TaskHeap) Push(x any)

+ func (h *TaskHeap) Swap(i, j int)

+ type TimeoutHandler struct

+ func NewTimeoutHandler(log Logger, startTime time.Time, nodes []NodeID) *TimeoutHandler

+ func (t *TimeoutHandler) AddTask(task *TimeoutTask)

+ func (t *TimeoutHandler) Close()

+ func (t *TimeoutHandler) GetTime() time.Time

+ func (t *TimeoutHandler) RemoveTask(nodeID NodeID, ID string)

+ func (t *TimeoutHandler) Tick(now time.Time)

+ type TimeoutTask struct

+ Deadline time.Time

+ End uint64

+ NodeID NodeID

+ Start uint64

+ Task func()

+ TaskID string

+ func FindReplicationTask(t *TimeoutHandler, node NodeID, seqs []uint64) *TimeoutTask

+ type ToBeSignedEmptyVote struct

+ func ParseEmptyNotarizationRecord(buff []byte) ([]byte, ToBeSignedEmptyVote, error)

+ func ParseEmptyVoteRecord(rawEmptyVote []byte) (ToBeSignedEmptyVote, error)

+ func (v *ToBeSignedEmptyVote) Bytes() []byte

+ func (v *ToBeSignedEmptyVote) FromBytes(buff []byte) error

+ func (v *ToBeSignedEmptyVote) Sign(signer Signer) ([]byte, error)

+ func (v *ToBeSignedEmptyVote) Verify(signature []byte, verifier SignatureVerifier, signers NodeID) error

+ type ToBeSignedFinalization struct

+ func (f *ToBeSignedFinalization) Sign(signer Signer) ([]byte, error)

+ func (f *ToBeSignedFinalization) Verify(signature []byte, verifier SignatureVerifier, signers NodeID) error

+ type ToBeSignedVote struct

+ func ParseNotarizationRecord(r []byte) ([]byte, ToBeSignedVote, error)

+ func (v *ToBeSignedVote) Sign(signer Signer) ([]byte, error)

+ func (v *ToBeSignedVote) Verify(signature []byte, verifier SignatureVerifier, signers NodeID) error

+ type VerifiedBlock interface

+ BlockHeader func() BlockHeader

+ Bytes func() ([]byte, error)

+ type VerifiedBlockMessage struct

+ VerifiedBlock VerifiedBlock

+ Vote Vote

+ type VerifiedFinalizedBlock struct

+ Finalization Finalization

+ VerifiedBlock VerifiedBlock

+ func RetrieveLastIndexFromStorage(s Storage) (*VerifiedFinalizedBlock, error)

+ type VerifiedQuorumRound struct

+ EmptyNotarization *EmptyNotarization

+ Finalization *Finalization

+ Notarization *Notarization

+ VerifiedBlock VerifiedBlock

+ func GetLatestVerifiedQuorumRound(round *Round, emptyNotarization *EmptyNotarization, ...) *VerifiedQuorumRound

+ func (q *VerifiedQuorumRound) GetRound() uint64

+ type VerifiedReplicationResponse struct

+ Data []VerifiedQuorumRound

+ LatestRound *VerifiedQuorumRound

+ type Vote struct

+ Signature Signature

+ Vote ToBeSignedVote

+ type WriteAheadLog interface

+ Append func([]byte) error

+ ReadAll func() ([][]byte, error)