chain

Documentation

Index

• Constants
• func LogGovernanceTransition(msg *ChainTransitionEventData, log *logger.Logger)
• func LogStateTransition(msg *ChainTransitionEventData, reqids []iscp.RequestID, log *logger.Logger)
• func PublishGovernanceTransition(stateOutput *ledgerstate.AliasOutput)
• func PublishRequestsSettled(chainID *iscp.ChainID, stateIndex uint32, reqids []iscp.RequestID)
• func PublishStateTransition(chainID *iscp.ChainID, stateOutput *ledgerstate.AliasOutput, reqIDsLength int)
• type AsynchronousCommonSubsetRunner
• type Chain
• type ChainCore
• type ChainEntry
• type ChainEvents
• type ChainRequests
• type ChainTransitionEventData
• type Committee
• type CommitteeInfo
• type Consensus
• type ConsensusInfo
• type Mempool
• type MempoolInfo
• type NodeConnection
• type PeerStatus
  • func (p *PeerStatus) String() string
• type ReadyListRecord
• type RequestProcessingStatus
• type StateManager
• type SyncInfo

Constants

const (
	RequestProcessingStatusUnknown = RequestProcessingStatus(iota)
	RequestProcessingStatusBacklog
	RequestProcessingStatusCompleted
)

const (
	// TimerTickPeriod time tick for consensus and state manager objects
	TimerTickPeriod = 100 * time.Millisecond
)

Functions

func LogGovernanceTransition

func LogGovernanceTransition(msg *ChainTransitionEventData, log *logger.Logger)

LogGovernanceTransition

func LogStateTransition

func LogStateTransition(msg *ChainTransitionEventData, reqids []iscp.RequestID, log *logger.Logger)

LogStateTransition also used in testing

func PublishGovernanceTransition

func PublishGovernanceTransition(stateOutput *ledgerstate.AliasOutput)

func PublishRequestsSettled

func PublishRequestsSettled(chainID *iscp.ChainID, stateIndex uint32, reqids []iscp.RequestID)

func PublishStateTransition

func PublishStateTransition(chainID *iscp.ChainID, stateOutput *ledgerstate.AliasOutput, reqIDsLength int)

Types

type AsynchronousCommonSubsetRunner

type AsynchronousCommonSubsetRunner interface {
	RunACSConsensus(value []byte, sessionID uint64, stateIndex uint32, callback func(sessionID uint64, acs [][]byte))
	TryHandleMessage(recv *peering.RecvEvent) bool
	Close()
}

type Chain

type Chain interface {
	ChainCore
	ChainRequests
	ChainEntry
}

type ChainCore

type ChainCore interface {
	ID() *iscp.ChainID
	GetCommitteeInfo() *CommitteeInfo
	ReceiveMessage(interface{})
	Events() ChainEvents
	Processors() *processors.Cache
	GlobalStateSync() coreutil.ChainStateSync
	GetStateReader() state.OptimisticStateReader
	Log() *logger.Logger
}

type ChainEntry

type ChainEntry interface {
	ReceiveTransaction(*ledgerstate.Transaction)
	ReceiveInclusionState(ledgerstate.TransactionID, ledgerstate.InclusionState)
	ReceiveState(stateOutput *ledgerstate.AliasOutput, timestamp time.Time)
	ReceiveOutput(output ledgerstate.Output)
	ReceiveOffLedgerRequest(req *request.OffLedger, senderNetID string)

	Dismiss(reason string)
	IsDismissed() bool
}

ChainEntry interface to access chain from the chain registry side

type ChainEvents

type ChainEvents interface {
	RequestProcessed() *events.Event
	ChainTransition() *events.Event
}

type ChainRequests

type ChainRequests interface {
	GetRequestProcessingStatus(id iscp.RequestID) RequestProcessingStatus
	EventRequestProcessed() *events.Event
}

ChainRequests is an interface to query status of the request

type ChainTransitionEventData

type ChainTransitionEventData struct {
	VirtualState    state.VirtualStateAccess
	ChainOutput     *ledgerstate.AliasOutput
	OutputTimestamp time.Time
}

type Committee

type Committee interface {
	Address() ledgerstate.Address
	Size() uint16
	Quorum() uint16
	OwnPeerIndex() uint16
	DKShare() *tcrypto.DKShare
	SendMsg(targetPeerIndex uint16, msgType byte, msgData []byte) error
	SendMsgToPeers(msgType byte, msgData []byte, ts int64, except ...uint16)
	IsAlivePeer(peerIndex uint16) bool
	QuorumIsAlive(quorum ...uint16) bool
	PeerStatus() []*PeerStatus
	Attach(chain ChainCore)
	IsReady() bool
	Close()
	RunACSConsensus(value []byte, sessionID uint64, stateIndex uint32, callback func(sessionID uint64, acs [][]byte))
	GetOtherValidatorsPeerIDs() []string
	GetRandomValidators(upToN int) []string
}

Committee is ordered (indexed 0..size-1) list of peers which run the consensus

type CommitteeInfo

type CommitteeInfo struct {
	Address       ledgerstate.Address
	Size          uint16
	Quorum        uint16
	QuorumIsAlive bool
	PeerStatus    []*PeerStatus
}

type Consensus

type Consensus interface {
	EventStateTransitionMsg(*messages.StateTransitionMsg)
	EventSignedResultMsg(*messages.SignedResultMsg)
	EventSignedResultAckMsg(*messages.SignedResultAckMsg)
	EventInclusionsStateMsg(*messages.InclusionStateMsg)
	EventAsynchronousCommonSubsetMsg(msg *messages.AsynchronousCommonSubsetMsg)
	EventVMResultMsg(msg *messages.VMResultMsg)
	EventTimerMsg(messages.TimerTick)
	IsReady() bool
	Close()
	GetStatusSnapshot() *ConsensusInfo
	ShouldReceiveMissingRequest(req iscp.Request) bool
}

type ConsensusInfo

type ConsensusInfo struct {
	StateIndex uint32
	Mempool    MempoolInfo
	TimerTick  int
}

type Mempool

type Mempool interface {
	ReceiveRequests(reqs ...iscp.Request)
	ReceiveRequest(req iscp.Request) bool
	RemoveRequests(reqs ...iscp.RequestID)
	ReadyNow(nowis ...time.Time) []iscp.Request
	ReadyFromIDs(nowis time.Time, reqIDs ...iscp.RequestID) ([]iscp.Request, []int, bool)
	HasRequest(id iscp.RequestID) bool
	GetRequest(id iscp.RequestID) iscp.Request
	Info() MempoolInfo
	WaitRequestInPool(reqid iscp.RequestID, timeout ...time.Duration) bool // for testing
	WaitInBufferEmpty(timeout ...time.Duration) bool                       // for testing
	Close()
}

type MempoolInfo

type MempoolInfo struct {
	TotalPool      int
	ReadyCounter   int
	InBufCounter   int
	OutBufCounter  int
	InPoolCounter  int
	OutPoolCounter int
}

type NodeConnection

type NodeConnection interface {
	PullBacklog(addr *ledgerstate.AliasAddress)
	PullState(addr *ledgerstate.AliasAddress)
	PullConfirmedTransaction(addr ledgerstate.Address, txid ledgerstate.TransactionID)
	PullTransactionInclusionState(addr ledgerstate.Address, txid ledgerstate.TransactionID)
	PullConfirmedOutput(addr ledgerstate.Address, outputID ledgerstate.OutputID)
	PostTransaction(tx *ledgerstate.Transaction)
}

type PeerStatus

type PeerStatus struct {
	Index     int
	PeeringID string
	IsSelf    bool
	Connected bool
}

func (*PeerStatus) String

func (p *PeerStatus) String() string

type ReadyListRecord

type ReadyListRecord struct {
	Request iscp.Request
	Seen    map[uint16]bool
}

type RequestProcessingStatus

type RequestProcessingStatus int

type StateManager

type StateManager interface {
	Ready() *ready.Ready
	EventGetBlockMsg(msg *messages.GetBlockMsg)
	EventBlockMsg(msg *messages.BlockMsg)
	EventStateMsg(msg *messages.StateMsg)
	EventOutputMsg(msg ledgerstate.Output)
	EventStateCandidateMsg(msg *messages.StateCandidateMsg)
	EventTimerMsg(msg messages.TimerTick)
	GetStatusSnapshot() *SyncInfo
	Close()
}

type SyncInfo

type SyncInfo struct {
	Synced                bool
	SyncedBlockIndex      uint32
	SyncedStateHash       hashing.HashValue
	SyncedStateTimestamp  time.Time
	StateOutputBlockIndex uint32
	StateOutputID         ledgerstate.OutputID
	StateOutputHash       hashing.HashValue
	StateOutputTimestamp  time.Time
}