message

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

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

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

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

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)
}

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

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

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

type GossipHandler interface {
	HandleTxs(nodeID ids.NodeID, msg TxsGossip) error
}

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
}

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"`
}

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"`
}

type NoopCrossChainRequestHandler struct{}

type NoopMempoolGossipHandler struct{}

type NoopRequestHandler struct{}

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)
}

type RequestHandler interface {
	HandleTrieLeafsRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, leafsRequest LeafsRequest) ([]byte, error)
	HandleBlockRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, blockRequest BlockRequest) ([]byte, error)
	HandleCodeRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, codeRequest CodeRequest) ([]byte, error)
	HandleSignatureRequest(ctx context.Context, nodeID ids.NodeID, requestID uint32, signatureRequest SignatureRequest) ([]byte, error)
}

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
}

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

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

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

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