message

Documentation

Index

• Constants
• func BuildCodec() (codec.Manager, error)
• func BuildGossipMessage(codec codec.Manager, msg GossipMessage) ([]byte, error)
• func RequestToBytes(codec codec.Manager, request Request) ([]byte, error)
• type AtomicTxGossip
  • func (msg AtomicTxGossip) Handle(handler GossipHandler, nodeID ids.ShortID) error
  • func (msg AtomicTxGossip) String() string
• type BlockRequest
  • func (b BlockRequest) Handle(ctx context.Context, nodeID ids.ShortID, requestID uint32, ...) ([]byte, error)
  • func (b BlockRequest) String() string
• type BlockResponse
• type CodeRequest
  • func NewCodeRequest(hash common.Hash) CodeRequest
  • func (c CodeRequest) Handle(ctx context.Context, nodeID ids.ShortID, requestID uint32, ...) ([]byte, error)
  • func (c CodeRequest) String() string
• type CodeResponse
• type EthTxsGossip
  • func (msg EthTxsGossip) Handle(handler GossipHandler, nodeID ids.ShortID) error
  • func (msg EthTxsGossip) String() string
• type GossipHandler
• type GossipMessage
  • func ParseGossipMessage(codec codec.Manager, bytes []byte) (GossipMessage, error)
• type LeafsRequest
  • func (l LeafsRequest) Handle(ctx context.Context, nodeID ids.ShortID, requestID uint32, ...) ([]byte, error)
  • func (l LeafsRequest) String() string
• type LeafsResponse
• type NodeType
  • func (nt NodeType) String() string
• type NoopMempoolGossipHandler
  • func (NoopMempoolGossipHandler) HandleAtomicTx(nodeID ids.ShortID, msg AtomicTxGossip) error
  • func (NoopMempoolGossipHandler) HandleEthTxs(nodeID ids.ShortID, msg EthTxsGossip) error
• type Request
  • func BytesToRequest(codec codec.Manager, requestBytes []byte) (Request, error)
• type RequestHandler
• type ResponseHandler
• type SerializedMap
• type SyncableBlock
  • func (s SyncableBlock) String() string

Constants

const (
	// EthMsgSoftCapSize is the ideal size of encoded transaction bytes we send in
	// any [EthTxsGossip] or [AtomicTxGossip] message. We do not limit inbound messages to
	// this size, however. Max inbound message size is enforced by the codec
	// (512KB).
	EthMsgSoftCapSize = common.StorageSize(64 * units.KiB)
)

const Version = uint16(0)

Functions

func BuildCodec

func BuildCodec() (codec.Manager, error)

func BuildGossipMessage

func BuildGossipMessage(codec codec.Manager, msg GossipMessage) ([]byte, error)

func RequestToBytes

func RequestToBytes(codec codec.Manager, request Request) ([]byte, error)

RequestToBytes marshals the given request object into bytes

Types

type AtomicTxGossip

type AtomicTxGossip struct {
	Tx []byte `serialize:"true"`
}

func (AtomicTxGossip) Handle

func (msg AtomicTxGossip) Handle(handler GossipHandler, nodeID ids.ShortID) error

func (AtomicTxGossip) String

func (msg AtomicTxGossip) String() string

type BlockRequest

type BlockRequest struct {
	Hash    common.Hash `serialize:"true"`
	Height  uint64      `serialize:"true"`
	Parents uint16      `serialize:"true"`
}

BlockRequest is a request to retrieve Parents number of blocks starting from Hash from newest-oldest manner

func (BlockRequest) Handle

func (b BlockRequest) Handle(ctx context.Context, nodeID ids.ShortID, requestID uint32, handler RequestHandler) ([]byte, error)

func (BlockRequest) String

func (b BlockRequest) String() string

type BlockResponse

type BlockResponse struct {
	Blocks [][]byte `serialize:"true"`
}

BlockResponse is a response to a BlockRequest Blocks is slice of RLP encoded blocks starting with the block requested in BlockRequest.Hash. The next block is the parent, etc. handler: handlers.BlockRequestHandler

type CodeRequest

type CodeRequest struct {
	// Hash is the contract code hash
	Hash common.Hash `serialize:"true"`
}

CodeRequest is a request to retrieve a contract code with specified Hash

func NewCodeRequest

func NewCodeRequest(hash common.Hash) CodeRequest

func (CodeRequest) Handle

func (c CodeRequest) Handle(ctx context.Context, nodeID ids.ShortID, requestID uint32, handler RequestHandler) ([]byte, error)

func (CodeRequest) String

func (c CodeRequest) String() string

type CodeResponse

type CodeResponse struct {
	Data []byte `serialize:"true"`
}

CodeResponse is a response to a CodeRequest crypto.Keccak256Hash of Data is expected to equal CodeRequest.Hash handler: handlers.CodeRequestHandler

type EthTxsGossip

type EthTxsGossip struct {
	Txs []byte `serialize:"true"`
}

func (EthTxsGossip) Handle

func (msg EthTxsGossip) Handle(handler GossipHandler, nodeID ids.ShortID) error

func (EthTxsGossip) String

func (msg EthTxsGossip) String() string

type GossipHandler

type GossipHandler interface {
	HandleAtomicTx(nodeID ids.ShortID, msg AtomicTxGossip) error
	HandleEthTxs(nodeID ids.ShortID, msg EthTxsGossip) error
}

GossipHandler handles incoming gossip messages

type GossipMessage

type GossipMessage interface {
	// types implementing GossipMessage should also implement fmt.Stringer for logging purposes.
	fmt.Stringer

	// Handle this gossip message with the gossip handler.
	Handle(handler GossipHandler, nodeID ids.ShortID) error
}

func ParseGossipMessage

func ParseGossipMessage(codec codec.Manager, bytes []byte) (GossipMessage, error)

type LeafsRequest

type LeafsRequest struct {
	Root     common.Hash `serialize:"true"`
	Start    []byte      `serialize:"true"`
	End      []byte      `serialize:"true"`
	Limit    uint16      `serialize:"true"`
	NodeType NodeType    `serialize:"true"`
}

LeafsRequest is a request to receive trie leaves at specified Root within Start and End byte range Limit outlines maximum number of leaves to returns starting at Start NodeType outlines which trie to read from state/atomic.

func (LeafsRequest) Handle

func (l LeafsRequest) Handle(ctx context.Context, nodeID ids.ShortID, requestID uint32, handler RequestHandler) ([]byte, error)

func (LeafsRequest) String

func (l LeafsRequest) String() string

type LeafsResponse

type LeafsResponse struct {
	// Keys and Vals provides the key-value pairs in the trie in the response.
	Keys [][]byte `serialize:"true"`
	Vals [][]byte `serialize:"true"`

	// More indicates if there are more leaves to the right of the last value in this response.
	//
	// This is not serialized since it is set in the client after verifying the response via
	// VerifyRangeProof and determining if there are in fact more leaves to the right of the
	// last value in this response.
	More bool

	// ProofKeys and ProofVals are the key-value pairs used in the range proof of the provided key-value
	// pairs.
	ProofKeys [][]byte `serialize:"true"`
	ProofVals [][]byte `serialize:"true"`
}

LeafsResponse is a response to a LeafsRequest Keys must be within LeafsRequest.Start and LeafsRequest.End and sorted in lexicographical order.

ProofKeys and ProofVals are expected to be non-nil and valid range proofs if the key-value pairs in the response are not the entire trie. If the key-value pairs make up the entire trie, ProofKeys and ProofVals should be empty since the root will be sufficient to prove that the leaves are included in the trie.

More is a flag set in the client after verifying the response, which indicates if the last key-value pair in the response has any more elements to its right within the trie.

type NodeType

type NodeType uint8

NodeType outlines the trie that a leaf node belongs to handlers.LeafsRequestHandler uses this information to determine which of the two tries (state/atomic) to fetch the information from

const (
	// StateTrieNode represents a leaf node that belongs to the coreth State trie
	StateTrieNode NodeType = iota + 1
	// AtomicTrieNode represents a leaf node that belongs to the coreth evm.AtomicTrie
	AtomicTrieNode
)

func (NodeType) String

func (nt NodeType) String() string

type NoopMempoolGossipHandler

type NoopMempoolGossipHandler struct{}

func (NoopMempoolGossipHandler) HandleAtomicTx

func (NoopMempoolGossipHandler) HandleAtomicTx(nodeID ids.ShortID, msg AtomicTxGossip) error

func (NoopMempoolGossipHandler) HandleEthTxs

func (NoopMempoolGossipHandler) HandleEthTxs(nodeID ids.ShortID, msg EthTxsGossip) error

type Request

type Request interface {
	// Requests should implement String() for logging.
	fmt.Stringer

	// Handle allows `Request` to call respective methods on handler to handle
	// this particular request type
	Handle(ctx context.Context, nodeID ids.ShortID, requestID uint32, handler RequestHandler) ([]byte, error)
}

Request represents a Network request type

func BytesToRequest

func BytesToRequest(codec codec.Manager, requestBytes []byte) (Request, error)

BytesToRequest unmarshals the given requestBytes into Request object

type RequestHandler

type RequestHandler interface {
	HandleStateTrieLeafsRequest(ctx context.Context, nodeID ids.ShortID, requestID uint32, leafsRequest LeafsRequest) ([]byte, error)
	HandleAtomicTrieLeafsRequest(ctx context.Context, nodeID ids.ShortID, requestID uint32, leafsRequest LeafsRequest) ([]byte, error)
	HandleBlockRequest(ctx context.Context, nodeID ids.ShortID, requestID uint32, request BlockRequest) ([]byte, error)
	HandleCodeRequest(ctx context.Context, nodeID ids.ShortID, requestID uint32, codeRequest CodeRequest) ([]byte, error)
}

RequestHandler interface handles incoming requests from peers Must have methods in format of handleType(context.Context, ids.ShortID, uint32, request Type) error so that the Request object of relevant Type can invoke its respective handle method on this struct. Also see GossipHandler for implementation style.

type ResponseHandler

type ResponseHandler interface {
	// OnResponse is invoked when the peer responded to a request
	OnResponse(nodeID ids.ShortID, requestID uint32, response []byte) error
	// OnFailure is invoked when there was a failure in processing a request
	// The FailureReason outlines the underlying cause.
	OnFailure(nodeID ids.ShortID, requestID uint32) error
}

ResponseHandler handles response for a sent request Only one of OnResponse or OnFailure is called for a given requestID, not both

type SerializedMap

type SerializedMap struct {
	Keys []common.Hash `serialize:"true"`
	Vals []common.Hash `serialize:"true"`
}

SerializedMap is map of Keys and Vals to track leaf sync progress

type SyncableBlock

type SyncableBlock struct {
	BlockNumber uint64      `serialize:"true"`
	BlockRoot   common.Hash `serialize:"true"`
	AtomicRoot  common.Hash `serialize:"true"`
	BlockHash   common.Hash `serialize:"true"`
}

SyncableBlock provides the information necessary to sync a node starting at the given block.

func (SyncableBlock) String

func (s SyncableBlock) String() string