messages

type AsynchronousCommonSubsetMsg ¶

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

AsynchronousCommonSubsetMsg

type BlockMsg ¶

type BlockMsg struct {
	SenderNetID string
	BlockBytes  []byte
}

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

func (msg *BlockMsg) Read(r io.Reader) error

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

type DismissChainMsg ¶

type DismissChainMsg struct {
	Reason string
}

DismissChainMsg sent by component to the chain core in case of major setback

type GetBlockMsg ¶

type GetBlockMsg struct {
	SenderNetID string
	BlockIndex  uint32
}

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

func (msg *GetBlockMsg) Read(r io.Reader) error

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

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 MissingRequestIDsMsgFromBytes(data []byte) (*MissingRequestIDsMsg, error)

func NewMissingRequestIDsMsg(missingIDs []iscp.RequestID) *MissingRequestIDsMsg

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

type MissingRequestMsg ¶

type MissingRequestMsg struct {
	Request iscp.Request
}

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

func NewMissingRequestMsg(req iscp.Request) *MissingRequestMsg

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

type OffLedgerRequestMsg ¶

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

func NewOffLedgerRequestMsg(chainID *iscp.ChainID, req *request.OffLedger) *OffLedgerRequestMsg

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

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

type RequestAcKMsg ¶

type RequestAcKMsg struct {
	ReqID *iscp.RequestID
}

func NewRequestAckMsg(reqID iscp.RequestID) *RequestAcKMsg

func RequestAckMsgFromBytes(buf []byte) (RequestAcKMsg, error)

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

type SignedResultAckMsg ¶

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

func (msg *SignedResultAckMsg) Read(r io.Reader) error

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

type SignedResultMsg ¶

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

func (msg *SignedResultMsg) Read(r io.Reader) error

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

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