messages

Documentation

Index

• type ApprovalRequest
• type ApprovalResponse
• type BatchRequest
• type BlockProposal
• type BlockResponse
• type BlockVote
• type ChunkDataRequest
• type ChunkDataResponse
• type ClusterBlockProposal
• type ClusterBlockResponse
• type ClusterBlockVote
• type CollectionRequest
• type CollectionResponse
• type EntityRequest
• type EntityResponse
• type ExecutionStateDelta
  • func (b *ExecutionStateDelta) Checksum() flow.Identifier
  • func (b *ExecutionStateDelta) Height() uint64
  • func (b *ExecutionStateDelta) ID() flow.Identifier
  • func (b *ExecutionStateDelta) ParentID() flow.Identifier
• type ExecutionStateSyncRequest
• type RangeRequest
• type SubmitCollectionGuarantee
• type SyncRequest
• type SyncResponse

Types

type ApprovalRequest

type ApprovalRequest struct {
	Nonce      uint64
	ResultID   flow.Identifier
	ChunkIndex uint64
}

ApprovalRequest represents a request for a ResultApproval corresponding to a specific chunk.

type ApprovalResponse

type ApprovalResponse struct {
	Nonce    uint64
	Approval flow.ResultApproval
}

ApprovalResponse contains a response to an approval request.

type BatchRequest

type BatchRequest struct {
	Nonce    uint64
	BlockIDs []flow.Identifier
}

BatchRequest is part of the sychronization protocol and represents an active (pulling) attempt to synchronize with the consensus state of the network. It requests finalized or unfinalized blocks by a list of block IDs.

type BlockProposal

type BlockProposal struct {
	Header  *flow.Header
	Payload *flow.Payload
}

BlockProposal is part of the consensus protocol and represents the the leader of a consensus round pushing a new proposal to the network.

type BlockResponse

type BlockResponse struct {
	Nonce  uint64
	Blocks []*flow.Block
}

BlockResponse is part of the synchronization protocol and represents the reply to any active synchronization attempts. It contains a list of blocks that should correspond to the request.

type BlockVote

type BlockVote struct {
	BlockID flow.Identifier
	View    uint64
	SigData []byte
}

BlockVote is part of the consensus protocol and represents a consensus node voting on the proposal of the leader of a given round.

type ChunkDataRequest

type ChunkDataRequest struct {
	ChunkID flow.Identifier
	Nonce   uint64 // so that we aren't deduplicated by the network layer
}

ChunkDataRequest represents a request for the a chunk data pack which is specified by a chunk ID.

type ChunkDataResponse

type ChunkDataResponse struct {
	ChunkDataPack flow.ChunkDataPack
	Collection    flow.Collection
	Nonce         uint64 // so that we aren't deduplicated by the network layer
}

ChunkDataResponse is the response to a chunk data pack request. It contains the chunk data pack of the interest.

type ClusterBlockProposal

type ClusterBlockProposal struct {
	Header  *flow.Header
	Payload *cluster.Payload
}

ClusterBlockProposal is a proposal for a block in collection node cluster consensus. The header contains information about consensus state and the payload contains the proposed collection (may be empty).

type ClusterBlockResponse

type ClusterBlockResponse struct {
	Nonce  uint64
	Blocks []*cluster.Block
}

ClusterBlockResponse is the same thing as BlockResponse, but for cluster consensus.

type ClusterBlockVote

type ClusterBlockVote struct {
	BlockID flow.Identifier
	View    uint64
	SigData []byte
}

ClusterBlockVote is a vote for a proposed block in collection node cluster consensus; effectively a vote for a particular collection.

type CollectionRequest

type CollectionRequest struct {
	ID    flow.Identifier
	Nonce uint64 // so that we aren't deduplicated by the network layer
}

CollectionRequest request all transactions from a collection with the given fingerprint.

type CollectionResponse

type CollectionResponse struct {
	Collection flow.Collection
	Nonce      uint64 // so that we aren't deduplicated by the network layer
}

CollectionResponse is a response to a request for a collection.

type EntityRequest

type EntityRequest struct {
	Nonce     uint64
	EntityIDs []flow.Identifier
}

EntityRequest is a request for a set of entities, each keyed by an identifier. The relationship between the identifiers and the entity is not specified here. In the typical case, the identifier is simply the ID of the entity being requested, but more complex identifier-entity relationships can be used as well.

type EntityResponse

type EntityResponse struct {
	Nonce     uint64
	EntityIDs []flow.Identifier
	Blobs     [][]byte
}

EntityResponse is a response to an entity request, containing a set of serialized entities and the identifiers used to request them. The returned entity set may be empty or incomplete.

type ExecutionStateDelta

type ExecutionStateDelta struct {
	entity.ExecutableBlock
	StateInteractions  []*delta.Snapshot
	EndState           flow.StateCommitment
	Events             []flow.Event
	ServiceEvents      []flow.Event
	TransactionResults []flow.TransactionResult
}

func (*ExecutionStateDelta) Checksum

func (b *ExecutionStateDelta) Checksum() flow.Identifier

func (*ExecutionStateDelta) Height

func (b *ExecutionStateDelta) Height() uint64

func (*ExecutionStateDelta) ID

func (b *ExecutionStateDelta) ID() flow.Identifier

func (*ExecutionStateDelta) ParentID

func (b *ExecutionStateDelta) ParentID() flow.Identifier

type ExecutionStateSyncRequest

type ExecutionStateSyncRequest struct {
	FromHeight uint64
	ToHeight   uint64
}

ExecutionStateSyncRequest represents a request for state deltas between the block at the `FromHeight` and the block at the `ToHeight` since the state sync request only requests for sealed blocks, heights should be enough to specify the block deterministically.

type RangeRequest

type RangeRequest struct {
	Nonce      uint64
	FromHeight uint64
	ToHeight   uint64
}

RangeRequest is part of the synchronization protocol and represents an active (pulling) attempt to synchronize with the consensus state of the network. It requests finalized blocks by a range of block heights, including from and to heights.

type SubmitCollectionGuarantee

type SubmitCollectionGuarantee struct {
	Guarantee flow.CollectionGuarantee
}

SubmitCollectionGuarantee is a request to submit the given collection guarantee to consensus nodes. Only valid as a node-local message.

type SyncRequest

type SyncRequest struct {
	Nonce  uint64
	Height uint64
}

SyncRequest is part of the synchronization protocol and represents a node on the network sharing the height of its latest finalized block and requesting the same information from the recipient.

type SyncResponse

type SyncResponse struct {
	Nonce  uint64
	Height uint64
}

SyncResponse is part of the synchronization protocol and represents the reply to a synchronization request that contains the latest finalized block height of the responding node.