Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  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
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

tbft_engine

package module

Go to main page

Versions in this module

v1

v1.0.2

Oct 30, 2023

Changes in this version

+ type ConsensusEngine struct

+ CommitFinishC chan interface{}

+ Id string

+ ProposeOptimal bool

+ ProposeOptimalTimer *time.Timer

+ TimeoutPropose time.Duration

+ TimeoutProposeDelta time.Duration

+ TimeoutProposeOptimal time.Duration

+ func (consensus *ConsensusEngine) AddTimeout(duration time.Duration, height uint64, round int32, step tbftpb.Step)

+ func (consensus *ConsensusEngine) CommitTimeout(round int32) time.Duration

+ func (consensus *ConsensusEngine) Data() interface{}

+ func (consensus *ConsensusEngine) GetConsensusStateJSON() ([]byte, error)

+ func (consensus *ConsensusEngine) GetLastHeight() uint64

+ func (consensus *ConsensusEngine) GetValidators() ([]string, error)

+ func (consensus *ConsensusEngine) InitConsistentEngine()

+ func (consensus *ConsensusEngine) NewTBFTProposal(proposal *Proposal, marshal bool) *TBFTProposal

+ func (consensus *ConsensusEngine) PrecommitTimeout(round int32) time.Duration

+ func (consensus *ConsensusEngine) PrevoteTimeout(round int32) time.Duration

+ func (consensus *ConsensusEngine) ProposeState() <-chan bool

+ func (consensus *ConsensusEngine) ProposeTimeout(round int32) time.Duration

+ func (consensus *ConsensusEngine) RegisterCommitter(committer Committer) error

+ func (consensus *ConsensusEngine) RegisterInterpreter(batchMsgInterpreter BatchMsgInterpreter) error

+ func (consensus *ConsensusEngine) RegisterLogger(logger Logger) error

+ func (consensus *ConsensusEngine) RegisterNetHandler(netHandler NetHandler) error

+ func (consensus *ConsensusEngine) RegisterParamsHandler(paramsHandler ParamsHandler) error

+ func (consensus *ConsensusEngine) RegisterProposalCoder(proposalHandler Coder) error

+ func (consensus *ConsensusEngine) RegisterVerifyHandler(verifier Verifier) error

+ func (consensus *ConsensusEngine) RegisterWalHandler(walHandler WalHandler) error

+ func (consensus *ConsensusEngine) RollBack() <-chan *ConsensusRollBack

+ func (consensus *ConsensusEngine) Start(ctx context.Context) error

+ func (consensus *ConsensusEngine) StartConsistentEngine() error

+ func (consensus *ConsensusEngine) Status() *tbftpb.Status

+ func (consensus *ConsensusEngine) Stop() error

+ func (consensus *ConsensusEngine) ToProto() *tbftpb.ConsensusState

+ func (consensus *ConsensusEngine) Type() int8

+ func (consensus *ConsensusEngine) Update(state Status)

+ type CtxKey string

+ const ContextStartHeight

type VerifyFailTxs

+ BlockHash []byte

v1.0.1

Dec 23, 2022

Changes in this version

+ const DefaultBlocksPerProposer

+ const InterceptorTbft

+ const MessageBufferSize

+ const StatusBroadcasterTbft

+ const TimeDisconnet

+ const TimeoutCommit

+ const TimeoutPrecommit

+ const TimeoutPrecommitDelta

+ const TimeoutPrevote

+ const TimeoutPrevoteDelta

+ const TimerInterval

+ const TypeLocalTBFTState

+ const TypeRemoteTBFTState

+ var ErrInvalidIndex = errors.New("invalid index")

+ var ErrInvalidValidator = errors.New("invalid validator")

+ var ErrUnexceptedStep = errors.New("unexpected step")

+ var ErrVoteForDifferentHash = errors.New("vote for different hash")

+ var ErrVoteNil = errors.New("nil vote")

+ var ErrorBroadcasterExist = errors.New("broadcaster exist")

+ var ErrorDecoderExist = errors.New("decoder exist")

+ var ErrorInterceptorExist = errors.New("interceptor exist")

+ var ErrorInvalidParameter = errors.New("invalid parameter")

+ var ErrorNetHandlerExist = errors.New("netHandler exist")

+ var ErrorNotRunning = errors.New("not running")

+ var ErrorRemoterEqualLocal = errors.New("remoter equal local")

+ var ErrorRemoterExist = errors.New("remoter exist")

+ var ErrorRemoterNotExist = errors.New("remoter not exist")

+ var ErrorRunRepeatedly = errors.New("run repeatedly")

+ func CurrentTimeMillisSeconds() int64

+ func IsNil(i interface{}) bool

+ func NewValidatorSet(logger Logger, validators []string, blocksPerProposer uint64) *validatorSet

+ func NewVote(typ tbftpb.VoteType, voter string, height uint64, round int32, hash []byte) *tbftpb.Vote

+ func VerifyRoundQc(logger Logger, verifier Verifier, validators *validatorSet, ...) error

+ type BatchMsg interface

+ GetSetSignature func() interface{}

+ Key func() []byte

+ Sequence func() uint64

+ SetSignature func(interface{})

+ type BatchMsgInterpreter interface

+ PrepareBatchMsg func() <-chan *ProposalBatchMsg

+ type BlockVotes struct

+ Sum uint64

+ Votes map[string]*tbftpb.Vote

+ func NewBlockVotes() *BlockVotes

+ func (bv *BlockVotes) ToProto() *tbftpb.BlockVotes

+ type Broadcast func(*Node, *Node) (interface{}, error)

+ type Coder interface

+ MarshalProposal func(*Proposal) ([]byte, error)

+ UnmarshalProposal func([]byte) (*Proposal, error)

+ type Committer interface

+ Commit func(BatchMsg, *tbftpb.VoteSet) error

+ CommitDone func() <-chan uint64

+ type ConsensusFutureMsg struct

+ Proposal map[int32]*Proposal

+ func NewConsensusFutureMsg(logger Logger, height uint64, round int32, validators *validatorSet) *ConsensusFutureMsg

+ type ConsensusFutureMsgCache struct

+ type ConsensusMsg struct

+ Msg interface{}

+ Type tbftpb.TBFTMsgType

+ type ConsensusRollBack struct

+ Proposal *Proposal

+ Sequence uint64

+ VerifyFailTxs *VerifyFailTxs

+ type ConsensusState struct

+ Height uint64

+ Id string

+ LockedProposal *Proposal

+ LockedRound int32

+ Proposal *TBFTProposal

+ Round int32

+ Step tbftpb.Step

+ ValidProposal *Proposal

+ ValidRound int32

+ VerifingProposal *TBFTProposal

+ func NewConsensusState(logger Logger, id string) *ConsensusState

+ type ConsensusTBFTImpl struct

+ CommitFinishC chan interface{}

+ Id string

+ ProposeOptimal bool

+ ProposeOptimalTimer *time.Timer

+ TimeoutPropose time.Duration

+ TimeoutProposeDelta time.Duration

+ TimeoutProposeOptimal time.Duration

+ func NewNode(logger Logger, id, chainId string, height uint64, validators []string) (*ConsensusTBFTImpl, error)

+ func (consensus *ConsensusTBFTImpl) AddTimeout(duration time.Duration, height uint64, round int32, step tbftpb.Step)

+ func (consensus *ConsensusTBFTImpl) CommitTimeout(round int32) time.Duration

+ func (consensus *ConsensusTBFTImpl) Data() interface{}

+ func (consensus *ConsensusTBFTImpl) GetConsensusStateJSON() ([]byte, error)

+ func (consensus *ConsensusTBFTImpl) GetLastHeight() uint64

+ func (consensus *ConsensusTBFTImpl) GetValidators() ([]string, error)

+ func (consensus *ConsensusTBFTImpl) NewTBFTProposal(proposal *Proposal, marshal bool) *TBFTProposal

+ func (consensus *ConsensusTBFTImpl) PrecommitTimeout(round int32) time.Duration

+ func (consensus *ConsensusTBFTImpl) PrevoteTimeout(round int32) time.Duration

+ func (consensus *ConsensusTBFTImpl) ProposeState() <-chan bool

+ func (consensus *ConsensusTBFTImpl) ProposeTimeout(round int32) time.Duration

+ func (consensus *ConsensusTBFTImpl) RegisterCommitter(committer Committer) error

+ func (consensus *ConsensusTBFTImpl) RegisterInterpreter(batchMsgInterpreter BatchMsgInterpreter) error

+ func (consensus *ConsensusTBFTImpl) RegisterLogger(logger Logger) error

+ func (consensus *ConsensusTBFTImpl) RegisterNetHandler(netHandler NetHandler) error

+ func (consensus *ConsensusTBFTImpl) RegisterParamsHandler(paramsHandler ParamsHandler) error

+ func (consensus *ConsensusTBFTImpl) RegisterProposalCoder(proposalHandler Coder) error

+ func (consensus *ConsensusTBFTImpl) RegisterVerifyHandler(verifier Verifier) error

+ func (consensus *ConsensusTBFTImpl) RegisterWalHandler(walHandler WalHandler) error

+ func (consensus *ConsensusTBFTImpl) RollBack() <-chan *ConsensusRollBack

+ func (consensus *ConsensusTBFTImpl) Start(ctx context.Context) error

+ func (consensus *ConsensusTBFTImpl) StartConsistentEngine()

+ func (consensus *ConsensusTBFTImpl) Status() *tbftpb.Status

+ func (consensus *ConsensusTBFTImpl) Stop() error

+ func (consensus *ConsensusTBFTImpl) ToProto() *tbftpb.ConsensusState

+ func (consensus *ConsensusTBFTImpl) Type() int8

+ func (consensus *ConsensusTBFTImpl) Update(state Status)

+ type ConsistentEngine interface

+ AddBroadcaster func(id string, broadcast *StatusBroadcaster) error

+ PutRemoter func(id string, node *Node) error

+ RegisterNetHandle func(netHandler NetHandler) error

+ RegisterStatusCoder func(decoderType int8, decoder *StatusDecoder) error

+ RegisterStatusInterceptor func(interceptorType int8, interceptor *StatusInterceptor) error

+ RemoveRemoter func(id string) error

+ Start func(ctx context.Context) error

+ Stop func(ctx context.Context) error

+ UpdateNodeStatus func(id string, node *Node) error

+ type Logger interface

+ Debug func(args ...interface{})

+ Debugf func(format string, args ...interface{})

+ Debugw func(msg string, keysAndValues ...interface{})

+ Error func(args ...interface{})

+ Errorf func(format string, args ...interface{})

+ Errorw func(msg string, keysAndValues ...interface{})

+ Fatal func(args ...interface{})

+ Fatalf func(format string, args ...interface{})

+ Fatalw func(msg string, keysAndValues ...interface{})

+ Info func(args ...interface{})

+ Infof func(format string, args ...interface{})

+ Infow func(msg string, keysAndValues ...interface{})

+ Warn func(args ...interface{})

+ Warnf func(format string, args ...interface{})

+ Warnw func(msg string, keysAndValues ...interface{})

+ type Message interface

+ AddNetMsg func(interface{})

+ Receive func() interface{}

+ Send func(payload interface{})

+ type NetHandler interface

+ BroadCastNetMsg func([]byte, string) error

+ Listen func() <-chan interface{}

+ type Node struct

+ func (l *Node) ID() string

+ func (l *Node) Statuses() map[int8]Status

+ func (l *Node) UpdateStatus(s Status)

+ type ParamsHandler interface

+ GetLastBlockProposer func() string

+ GetNewParams func() (validators []string, timeoutPropose time.Duration, ...)

+ type Proposal struct

+ Content BatchMsg

+ Key []byte

+ Proposer string

+ Qc []*tbftpb.Vote

+ Round int32

+ Sequence uint64

+ Signature interface{}

+ TxsRwSet interface{}

+ func NewProposal(voter string, height uint64, round int32, key []byte, content BatchMsg) *Proposal

+ type ProposalBatchMsg struct

+ BatchMsg BatchMsg

+ CutBatchMsg BatchMsg

+ TxsRwSet interface{}

+ type RemoteState struct

+ Height uint64

+ Id string

+ LockedProposal *tbftpb.Proposal

+ LockedRound int32

+ Proposal []byte

+ Round int32

+ RoundVoteSet *roundVoteSet

+ Step tbftpb.Step

+ ValidProposal *tbftpb.Proposal

+ ValidRound int32

+ VerifingProposal []byte

+ func (r *RemoteState) Data() interface{}

+ func (r *RemoteState) Type() int8

+ func (r *RemoteState) Update(state Status)

+ type Status interface

+ Data func() interface{}

+ Type func() int8

+ Update func(status Status)

+ type StatusBroadcaster struct

+ func NewTBFTStatusBroadcaster(log Logger) *StatusBroadcaster

+ func (tsb *StatusBroadcaster) ID() string

+ func (tsb *StatusBroadcaster) IsRunning() bool

+ func (tsb *StatusBroadcaster) PreBroadcaster() Broadcast

+ func (tsb *StatusBroadcaster) Start() error

+ func (tsb *StatusBroadcaster) Stop() error

+ func (tsb *StatusBroadcaster) TimePattern() interface{}

+ type StatusConsistentEngine struct

+ func NewConsistentService(local *Node, msg Message, log Logger) *StatusConsistentEngine

+ func (e *StatusConsistentEngine) AddBroadcaster(id string, broadcaster *StatusBroadcaster) error

+ func (e *StatusConsistentEngine) PutRemoter(id string, node *Node) error

+ func (e *StatusConsistentEngine) RegisterNetHandle(netHandler NetHandler) error

+ func (e *StatusConsistentEngine) RegisterStatusCoder(decoder *StatusDecoder) error

+ func (e *StatusConsistentEngine) RegisterStatusInterceptor(interceptorType int8, interceptor *StatusInterceptor) error

+ func (e *StatusConsistentEngine) RemoveRemoter(id string) error

+ func (e *StatusConsistentEngine) Start(ctx context.Context) error

+ func (e *StatusConsistentEngine) Stop(ctx context.Context) error

+ func (e *StatusConsistentEngine) UpdateNodeStatus(id string, node *Node) error

+ type StatusDecoder struct

+ func (tD *StatusDecoder) Decode(d interface{}) interface{}

+ type StatusInterceptor struct

+ func (tsb *StatusInterceptor) Handle(status Status) error

+ type TBFTConsensuEngine interface

+ ProposeState func() <-chan bool

+ RegisterCommitter func(Committer) error

+ RegisterInterpreter func(BatchMsgInterpreter) error

+ RegisterLogger func(Logger) error

+ RegisterNetHandler func(NetHandler) error

+ RegisterParamsHandler func(ParamsHandler) error

+ RegisterProposalCoder func(Coder) error

+ RegisterVerifyHandler func(Verifier) error

+ RegisterWalHandler func(WalHandler) error

+ RollBack func() <-chan *ConsensusRollBack

+ Start func(ctx context.Context) error

+ Status func() *tbftpb.Status

+ Stop func() error

+ type TBFTProposal struct

+ Bytes []byte

+ PbMsg *Proposal

+ type TbftConsistentMessage struct

+ func NewTbftConsistentMessage(log Logger, netHandler NetHandler) *TbftConsistentMessage

+ func (m *TbftConsistentMessage) AddNetMsg(payload interface{})

+ func (m *TbftConsistentMessage) OnQuit()

+ func (m *TbftConsistentMessage) Receive() interface{}

+ func (m *TbftConsistentMessage) Send(payload interface{})

+ type Verifier interface

+ SignBatchMsg func(BatchMsg) (interface{}, error)

+ SignProposal func(*Proposal) (interface{}, error)

+ SignVote func(*tbftpb.Vote) ([]byte, error)

+ VerifyBatchMsg func(BatchMsg) (*VerifyResult, error)

+ VerifyBlockWithRwSets func(BatchMsg, interface{}, *tbftpb.VoteSet) error

+ VerifyProposal func(*Proposal) error

+ VerifyVote func(*tbftpb.Vote) error

+ type VerifyFailTxs struct

+ Sequence uint64

+ TxIds []string

+ type VerifyResult struct

+ Code tbftpb.VerifyResult_Code

+ Msg string

+ TxsRwSet interface{}

+ VerifiedBatchMsg BatchMsg

+ VerifyFailTxs []string

+ type VoteSet struct

+ Height uint64

+ Maj23 []byte

+ Round int32

+ Sum uint64

+ Type tbftpb.VoteType

+ Votes map[string]*tbftpb.Vote

+ VotesByBlock map[string]*BlockVotes

+ func NewVoteSet(logger Logger, voteType tbftpb.VoteType, height uint64, round int32, ...) *VoteSet

+ func NewVoteSetFromProto(logger Logger, vsProto *tbftpb.VoteSet, validators *validatorSet) *VoteSet

+ func VerifyQcFromVotes(logger Logger, verifier Verifier, vs []*tbftpb.Vote, validators *validatorSet, ...) (*VoteSet, error)

+ func (vs *VoteSet) AddVote(vote *tbftpb.Vote, countInvalidTx bool) (added bool, err error)

+ func (vs *VoteSet) AddVoteForConsistent(vote *tbftpb.Vote) (added bool, err error)

+ func (vs *VoteSet) HasTwoThirdsMajority() (majority bool)

+ func (vs *VoteSet) Size() int32

+ func (vs *VoteSet) String() string

+ func (vs *VoteSet) ToProto() *tbftpb.VoteSet

+ type WalEntry struct

+ Proposal *Proposal

+ Sequence uint64

+ WalEntryType tbftpb.WalEntryType

+ type WalHandler interface

+ ReadLast func() (*WalEntry, error)

+ Write func(*WalEntry) error

v1.0.0

Dec 21, 2022