messages

type AsynchronousCommonSubsetMsg ¶

type AsynchronousCommonSubsetMsg struct {
	ProposedBatchesBin [][]byte
	SessionID          uint64
}

AsynchronousCommonSubsetMsg

type BlockMsg ¶

type BlockMsg struct {
	BlockBytes []byte
}

BlockMsg StateManager in response to GetBlockMsg sends block data to the querying node's StateManager StateManager -> StateManager

func NewBlockMsg(data []byte) (*BlockMsg, error)

func (msg *BlockMsg) Write(w io.Writer) error

type BlockMsgIn ¶ added in v0.2.3

type BlockMsgIn struct {
	BlockMsg
	SenderNetID string
}

type GetBlockMsg ¶

type GetBlockMsg struct {
	BlockIndex uint32
}

GetBlockMsg StateManager queries specific block data from another peer (access node) StateManager -> StateManager

func NewGetBlockMsg(data []byte) (*GetBlockMsg, error)

func (msg *GetBlockMsg) Write(w io.Writer) error

type GetBlockMsgIn ¶ added in v0.2.3

type GetBlockMsgIn struct {
	GetBlockMsg
	SenderNetID string
}

type InclusionStateMsg ¶

type InclusionStateMsg struct {
	TxID  ledgerstate.TransactionID
	State ledgerstate.InclusionState
}

InclusionStateMsg txstream plugin sends inclusions state of the transaction to ConsensusOld

type MissingRequestIDsMsg ¶

type MissingRequestIDsMsg struct {
	IDs []iscp.RequestID
}

func NewMissingRequestIDsMsg(data []byte) (*MissingRequestIDsMsg, error)

func (msg *MissingRequestIDsMsg) Bytes() []byte

type MissingRequestIDsMsgIn ¶ added in v0.2.3

type MissingRequestIDsMsgIn struct {
	MissingRequestIDsMsg
	SenderNetID string
}

type MissingRequestMsg ¶

type MissingRequestMsg struct {
	Request iscp.Request
}

func NewMissingRequestMsg(data []byte) (*MissingRequestMsg, error)

func (msg *MissingRequestMsg) Bytes() []byte

type OffLedgerRequestMsg ¶

type OffLedgerRequestMsg struct {
	ChainID *iscp.ChainID
	Req     *request.OffLedger
}

func NewOffLedgerRequestMsg(data []byte) (*OffLedgerRequestMsg, error)

func (msg *OffLedgerRequestMsg) Bytes() []byte

type OffLedgerRequestMsgIn ¶ added in v0.2.3

type OffLedgerRequestMsgIn struct {
	OffLedgerRequestMsg
	SenderNetID string
}

type RequestAckMsg ¶ added in v0.2.3

type RequestAckMsg struct {
	ReqID *iscp.RequestID
}

func NewRequestAckMsg(buf []byte) (*RequestAckMsg, error)

func (msg *RequestAckMsg) Bytes() []byte

type RequestAckMsgIn ¶ added in v0.2.3

type RequestAckMsgIn struct {
	RequestAckMsg
	SenderNetID string
}

type SignedResultAckMsg ¶

type SignedResultAckMsg struct {
	ChainInputID ledgerstate.OutputID
	EssenceHash  hashing.HashValue
}

Consensus -> Consensus

func NewSignedResultAckMsg(data []byte) (*SignedResultAckMsg, error)

func (msg *SignedResultAckMsg) Write(w io.Writer) error

type SignedResultAckMsgIn ¶ added in v0.2.3

type SignedResultAckMsgIn struct {
	SignedResultAckMsg
	SenderIndex uint16
}

type SignedResultMsg ¶

type SignedResultMsg struct {
	ChainInputID ledgerstate.OutputID
	EssenceHash  hashing.HashValue
	SigShare     tbls.SigShare
}

Consensus -> Consensus

func NewSignedResultMsg(data []byte) (*SignedResultMsg, error)

func (msg *SignedResultMsg) Write(w io.Writer) error

type SignedResultMsgIn ¶ added in v0.2.3

type SignedResultMsgIn struct {
	SignedResultMsg
	SenderIndex uint16
}

type StateCandidateMsg ¶

type StateCandidateMsg struct {
	State             state.VirtualStateAccess
	ApprovingOutputID ledgerstate.OutputID
}

StateCandidateMsg Consensus sends the finalized next state to StateManager

type StateMsg ¶

type StateMsg struct {
	ChainOutput *ledgerstate.AliasOutput
	Timestamp   time.Time
}

StateMsg txstream plugin sends the only existing AliasOutput in the chain's address to StateManager

type StateTransitionMsg ¶

type StateTransitionMsg struct {
	// new variable state
	State state.VirtualStateAccess
	// corresponding state transaction
	StateOutput *ledgerstate.AliasOutput
	//
	StateTimestamp time.Time
}

StateTransitionMsg Notifies chain about changed state

type TimerTick ¶

type TimerTick int

type VMResultMsg ¶

type VMResultMsg struct {
	Task *vm.VMTask
}

VMResultMsg Consensus -> Consensus. VM sends result of async task started by Consensus to itself