wit

type Backend interface {
	// Chain retrieves the blockchain object to serve data.
	Chain() *core.BlockChain

	// RunPeer is invoked when a peer joins on the `wit` protocol. The handler
	// should do any peer maintenance work, handshakes and validations. If all
	// is passed, control should be given back to the `handler` to process the
	// inbound messages going forward.
	RunPeer(peer *Peer, handler Handler) error

	// PeerInfo retrieves all known `wit` information about a peer.
	PeerInfo(id enode.ID) interface{}

	// Handle is a callback to be invoked when a data packet is received from
	// the remote peer. Only packets not consumed by the protocol handler will
	// be forwarded to the backend.
	Handle(peer *Peer, packet Packet) error
}

type Decoder interface {
	Decode(val interface{}) error
	Time() time.Time
}

type GetWitnessMetadataPacket struct {
	RequestId uint64
	*GetWitnessMetadataRequest
}

type GetWitnessMetadataRequest struct {
	Hashes []common.Hash // Block hashes to get metadata for
}

type GetWitnessPacket struct {
	RequestId uint64
	*GetWitnessRequest
}

type GetWitnessRequest struct {
	WitnessPages []WitnessPageRequest // Request by list of witness pages
}

type Handler func(peer *Peer) error

type KnownCache struct {
	// contains filtered or unexported fields
}

type NewWitnessHashesPacket struct {
	Hashes  []common.Hash
	Numbers []uint64
}

type NewWitnessPacket struct {
	Witness *stateless.Witness
}

type NodeInfo struct {
	Network    uint64              `json:"network"`    // Ethereum network ID (1=Mainnet, Holesky=17000)
	Difficulty *big.Int            `json:"difficulty"` // Total difficulty of the host's blockchain
	Genesis    common.Hash         `json:"genesis"`    // SHA3 hash of the host's genesis block
	Config     *params.ChainConfig `json:"config"`     // Chain configuration for the fork rules
	Head       common.Hash         `json:"head"`       // Hex hash of the host's best owned block
}

type Packet interface {
	Name() string // Name returns a string corresponding to the message type.
	Kind() byte   // Kind returns the message type.
}

type Peer struct {
	*p2p.Peer // The embedded P2P package peer
	// contains filtered or unexported fields
}

type Request struct {
	Peer string    // Demultiplexer if cross-peer requests are batched together
	Sent time.Time // Timestamp when the request was sent
	// contains filtered or unexported fields
}

type Response struct {
	Req  *Request      // Original request to cross-reference with
	Res  interface{}   // Remote response for the request query
	Meta interface{}   // Metadata generated locally on the receiver thread
	Time time.Duration // Time it took for the request to be served
	Done chan error    // Channel to signal message handling to the reader
	// contains filtered or unexported fields
}

type WitnessMetadataPacket struct {
	RequestId uint64
	Metadata  []WitnessMetadataResponse
}

type WitnessMetadataResponse struct {
	Hash        common.Hash
	TotalPages  uint64 // Total number of pages for this witness
	WitnessSize uint64 // Total witness size in bytes
	BlockNumber uint64 // Block number this witness belongs to
	Available   bool   // Whether witness exists in database
}

type WitnessPacketRLPPacket struct {
	RequestId uint64
	WitnessPacketResponse
}

type WitnessPacketResponse []WitnessPageResponse

type WitnessPageRequest struct {
	Hash common.Hash // BlockHash
	Page uint64      // Starts on 0
}

type WitnessPageResponse struct {
	Data       []byte
	Hash       common.Hash
	Page       uint64 // Starts on 0; If Page >= TotalPages means the request was invalid and the response is an empty data array
	TotalPages uint64 // Length of pages
}