smartbft

type AccessController interface {
	// Evaluate takes a set of SignedData and evaluates whether this set of signatures satisfies the policy
	Evaluate(signatureSet []*common.SignedData) error
}

type Assembler struct {
	Logger          *flogging.FabricLogger
	VerificationSeq func() uint64
	sync.RWMutex
	LastConfigBlockNum uint64
	LastBlock          *common.Block
}

type BFTChain struct {
	Config           smartbft.Configuration
	BlockPuller      BlockPuller
	Comm             cluster.Communicator
	SignerSerializer signerSerializer
	PolicyManager    policies.Manager
	RemoteNodes      []cluster.RemoteNode
	ID2Identities    NodeIdentitiesByID
	Logger           *flogging.FabricLogger
	WALDir           string

	Metrics *Metrics
	// contains filtered or unexported fields
}

type BlockPuller interface {
	PullBlock(seq uint64) *common.Block
	HeightsByEndpoints() (map[string]uint64, error)
	Close()
}

type Bundle interface {
	channelconfig.Resources
}

type ByteBufferTuple struct {
	A []byte
	B []byte
}

type ChainGetter interface {
	// GetChain obtains the ChainSupport for the given channel.
	// Returns nil, false when the ChainSupport for the given channel
	// isn't found.
	GetChain(chainID string) *multichannel.ChainSupport
}

type ChannelConfigTemplator interface {
	NewChannelConfig(env *common.Envelope) (channelconfig.Resources, error)
}

type ConfigBlockValidator struct {
	ChannelConfigTemplator ChannelConfigTemplator
	ConfigUpdateProposer   ConfigUpdateProposer
	ValidatingChannel      string
	Filters                Filters
	Logger                 *flogging.FabricLogger
}

type ConfigTxValidator interface {
	configtx.Validator
}

type ConfigUpdateProposer interface {
	ProposeConfigUpdate(channel string, configtx *common.Envelope) (*common.ConfigEnvelope, error)
}

type ConfigValidator interface {
	ValidateConfig(env *common.Envelope) error
}

type Consenter struct {
	GetPolicyManager PolicyManagerRetriever
	Logger           *flogging.FabricLogger
	Cert             []byte
	Comm             *cluster.Comm
	Chains           ChainGetter
	SignerSerializer signerSerializer
	Registrar        *multichannel.Registrar
	WALBaseDir       string
	ClusterDialer    *cluster.PredicateDialer
	Conf             *localconfig.TopLevel
	Metrics          *Metrics
}

type ConsenterCertificate []byte

type ConsenterVerifier interface {
	// Evaluate takes a set of SignedData and evaluates whether this set of signatures satisfies the policy
	Evaluate(signatureSet []*common.SignedData) error
}

type Egress struct {
	Channel string
	RPC     RPC
	Logger  PanicLogger
	// contains filtered or unexported fields
}

type Filters interface {
	ApplyFilters(channel string, env *common.Envelope) error
}

type Ingreess struct {
	Logger        WarningLogger
	ChainSelector ReceiverGetter
}

type Ledger interface {
	// Height returns the number of blocks in the ledger this channel is associated with.
	Height() uint64

	// Block returns a block with the given number,
	// or nil if such a block doesn't exist.
	Block(number uint64) *common.Block
}

type MessageReceiver interface {
	HandleMessage(sender uint64, m *protos.Message)
	HandleRequest(sender uint64, req []byte)
}

type Metrics struct {
	ClusterSize          metrics.Gauge
	CommittedBlockNumber metrics.Gauge
	IsLeader             metrics.Gauge
	LeaderID             metrics.Gauge
}

type NodeIdentitiesByID map[uint64][]byte

type PanicLogger interface {
	Panicf(template string, args ...interface{})
}

type PolicyManagerRetriever func(channel string) policies.Manager

type RPC interface {
	SendConsensus(dest uint64, msg *orderer.ConsensusRequest) error
	SendSubmit(dest uint64, request *orderer.SubmitRequest) error
}

type ReceiverGetter interface {
	// ReceiverByChain returns the MessageReceiver if it exists, or nil if it doesn't
	ReceiverByChain(channelID string) MessageReceiver
}

type RequestInspector struct {
	ValidateIdentityStructure func(identity *msp.SerializedIdentity) error
}

type Sequencer interface {
	Sequence() uint64
}

type Signature struct {
	SignatureHeader      []byte
	BlockHeader          []byte
	OrdererBlockMetadata []byte
}

type Signer struct {
	ID                 uint64
	SignerSerializer   SignerSerializer
	Logger             PanicLogger
	LastConfigBlockNum func(*common.Block) uint64
}

type SignerSerializer interface {
	crypto.Signer
	crypto.IdentitySerializer
}

type Synchronizer struct {
	BlockToDecision func(block *common.Block) *types.Decision
	UpdateLastHash  func(block *common.Block)
	Support         consensus.ConsenterSupport
	BlockPuller     BlockPuller
	ClusterSize     uint64
	Logger          *flogging.FabricLogger
}

type Verifier struct {
	ReqInspector           *RequestInspector
	Id2Identity            NodeIdentitiesByID
	ConsenterVerifier      ConsenterVerifier
	AccessController       AccessController
	VerificationSequencer  Sequencer
	Ledger                 Ledger
	LastCommittedBlockHash string
	LastConfigBlockNum     uint64
	Logger                 *flogging.FabricLogger

	ConfigValidator ConfigValidator
	// contains filtered or unexported fields
}

type WALConfig struct {
	WALDir            string // WAL data of <my-channel> is stored in WALDir/<my-channel>
	SnapDir           string // Snapshots of <my-channel> are stored in SnapDir/<my-channel>
	EvictionSuspicion string // Duration threshold that the node samples in order to suspect its eviction from the channel.
}

type WarningLogger interface {
	Warningf(template string, args ...interface{})
}