message

package
v0.6.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 22, 2024 License: GPL-3.0, LGPL-3.0 Imports: 17 Imported by: 0

Documentation

Index

Constants

View Source 
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 = 64 * units.KiB
)
View Source 
const MaxCodeHashesPerRequest = 5
View Source 
const (
	Version = uint16(0)
)

Variables

View Source 
var (
	Codec           codec.Manager
	CrossChainCodec codec.Manager
)

Functions

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 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.NodeID, 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 BlockSignatureRequest 

type BlockSignatureRequest struct {
	BlockID ids.ID `serialize:"true"`
}

BlockSignatureRequest is used to request a warp message's signature.

func (BlockSignatureRequest) Handle 

func (s BlockSignatureRequest) Handle(ctx context.Context, nodeID ids.NodeID, requestID uint32, handler RequestHandler) ([]byte, error)

func (BlockSignatureRequest) String 

func (s BlockSignatureRequest) String() string

type CodeRequest 

type CodeRequest struct {
	// Hashes is a list of contract code hashes
	Hashes []common.Hash `serialize:"true"`
}

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

func NewCodeRequest 

func NewCodeRequest(hashes []common.Hash) CodeRequest

func (CodeRequest) Handle 

func (c CodeRequest) Handle(ctx context.Context, nodeID ids.NodeID, 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 each element in Data is expected to equal the corresponding element in CodeRequest.Hashes handler: handlers.CodeRequestHandler

type CrossChainRequest 

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

	// Handle allows [CrossChainRequest] to call respective methods on handler to handle
	// this particular request type
	Handle(ctx context.Context, requestingChainID ids.ID, requestID uint32, handler CrossChainRequestHandler) ([]byte, error)
}

CrossChainRequest represents the interface a cross chain request should implement

type CrossChainRequestHandler 

type CrossChainRequestHandler interface {
	HandleEthCallRequest(ctx context.Context, requestingchainID ids.ID, requestID uint32, ethCallRequest EthCallRequest) ([]byte, error)
}

CrossChainRequestHandler interface handles incoming requests from another chain

func NewCrossChainHandler 

func NewCrossChainHandler(b ethapi.Backend, codec codec.Manager) CrossChainRequestHandler

NewCrossChainHandler creates and returns a new instance of CrossChainRequestHandler

type EthCallRequest 

type EthCallRequest struct {
	RequestArgs []byte `serialize:"true"`
}

EthCallRequest has the JSON Data necessary to execute a new EVM call on the blockchain

func (EthCallRequest) Handle 

func (e EthCallRequest) Handle(ctx context.Context, requestingChainID ids.ID, requestID uint32, handler CrossChainRequestHandler) ([]byte, error)

Handle returns the encoded EthCallResponse by executing EVM call with the given EthCallRequest

func (EthCallRequest) String 

func (e EthCallRequest) String() string

String converts EthCallRequest to a string

type EthCallResponse 

type EthCallResponse struct {
	ExecutionResult []byte `serialize:"true"`
}

EthCallResponse represents the JSON return value of the executed EVM call

type EthTxsGossip 

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

func (EthTxsGossip) Handle 

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

func (EthTxsGossip) String 

func (msg EthTxsGossip) String() string

type GossipHandler 

type GossipHandler interface {
	HandleEthTxs(nodeID ids.NodeID, 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.NodeID) error
}

func ParseGossipMessage 

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

type LeafsRequest 

type LeafsRequest struct {
	Root    common.Hash `serialize:"true"`
	Account common.Hash `serialize:"true"`
	Start   []byte      `serialize:"true"`
	End     []byte      `serialize:"true"`
	Limit   uint16      `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

func (LeafsRequest) Handle 

func (l LeafsRequest) Handle(ctx context.Context, nodeID ids.NodeID, 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

	// ProofVals contain the edge merkle-proofs for the range of keys included in the response.
	// The keys for the proof are simply the keccak256 hashes of the values, so they are not included in the response to save bandwidth.
	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.

ProofVals must be non-empty and contain a valid range proof unless the key-value pairs in the response are the entire trie. If the key-value pairs make up the entire trie, 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 MessageSignatureRequest 

type MessageSignatureRequest struct {
	MessageID ids.ID `serialize:"true"`
}

MessageSignatureRequest is used to request a warp message's signature.

func (MessageSignatureRequest) Handle 

func (s MessageSignatureRequest) Handle(ctx context.Context, nodeID ids.NodeID, requestID uint32, handler RequestHandler) ([]byte, error)

func (MessageSignatureRequest) String 

func (s MessageSignatureRequest) String() string

type NoopCrossChainRequestHandler 

type NoopCrossChainRequestHandler struct{}

func (NoopCrossChainRequestHandler) HandleEthCallRequest 

func (NoopCrossChainRequestHandler) HandleEthCallRequest(ctx context.Context, requestingchainID ids.ID, requestID uint32, ethCallRequest EthCallRequest) ([]byte, error)

type NoopMempoolGossipHandler 

type NoopMempoolGossipHandler struct{}

func (NoopMempoolGossipHandler) HandleEthTxs 

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

type NoopRequestHandler 

type NoopRequestHandler struct{}

func (NoopRequestHandler) HandleBlockRequest 

func (NoopRequestHandler) HandleBlockRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, request BlockRequest) ([]byte, error)

func (NoopRequestHandler) HandleBlockSignatureRequest 

func (NoopRequestHandler) HandleBlockSignatureRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, signatureRequest BlockSignatureRequest) ([]byte, error)

func (NoopRequestHandler) HandleCodeRequest 

func (NoopRequestHandler) HandleCodeRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, codeRequest CodeRequest) ([]byte, error)

func (NoopRequestHandler) HandleMessageSignatureRequest 

func (NoopRequestHandler) HandleMessageSignatureRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, signatureRequest MessageSignatureRequest) ([]byte, error)

func (NoopRequestHandler) HandleStateTrieLeafsRequest 

func (NoopRequestHandler) HandleStateTrieLeafsRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, leafsRequest LeafsRequest) ([]byte, 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.NodeID, 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.NodeID, requestID uint32, leafsRequest LeafsRequest) ([]byte, error)
	HandleBlockRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, request BlockRequest) ([]byte, error)
	HandleCodeRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, codeRequest CodeRequest) ([]byte, error)
	HandleMessageSignatureRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, signatureRequest MessageSignatureRequest) ([]byte, error)
	HandleBlockSignatureRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, signatureRequest BlockSignatureRequest) ([]byte, error)
}

RequestHandler interface handles incoming requests from peers Must have methods in format of handleType(context.Context, ids.NodeID, 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(response []byte) error
	// OnFailure is invoked when there was a failure in processing a request
	OnFailure() error
}

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

type SignatureResponse 

type SignatureResponse struct {
	Signature [bls.SignatureLen]byte `serialize:"true"`
}

SignatureResponse is the response to a BlockSignatureRequest or MessageSignatureRequest. The response contains a BLS signature of the requested message, signed by the responding node's BLS private key.

type SyncSummary 

type SyncSummary struct {
	BlockNumber uint64      `serialize:"true"`
	BlockHash   common.Hash `serialize:"true"`
	BlockRoot   common.Hash `serialize:"true"`
	// contains filtered or unexported fields
}

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

func NewSyncSummary 

func NewSyncSummary(blockHash common.Hash, blockNumber uint64, blockRoot common.Hash) (SyncSummary, error)

func NewSyncSummaryFromBytes 

func NewSyncSummaryFromBytes(summaryBytes []byte, acceptImpl func(SyncSummary) (block.StateSyncMode, error)) (SyncSummary, error)

func (SyncSummary) Accept 

func (s SyncSummary) Accept(context.Context) (block.StateSyncMode, error)

func (SyncSummary) Bytes 

func (s SyncSummary) Bytes() []byte

func (SyncSummary) Height 

func (s SyncSummary) Height() uint64

func (SyncSummary) ID 

func (s SyncSummary) ID() ids.ID

func (SyncSummary) String 

func (s SyncSummary) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.