message

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

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 {
	// Hash is the contract code hash
	Hash common.Hash `serialize:"true"`
}

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

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

type GossipHandler interface {
	HandleAtomicTx(nodeID ids.ShortID, msg AtomicTxGossip) error
	HandleEthTxs(nodeID ids.ShortID, msg EthTxsGossip) 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.ShortID) error
}

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

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

type NodeType uint8

type NoopMempoolGossipHandler 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.ShortID, requestID uint32, handler RequestHandler) ([]byte, error)
}

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

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
}

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

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