disc

type APIClient interface {
	EntryReader
	EntryWriter
	AllEntries(ctx context.Context) ([]string, error)
	AllClientsByServer(ctx context.Context) (map[string][]*Entry, error)
	ClientsByServer(ctx context.Context, serverPK cipher.PubKey) ([]*Entry, error)
}

type Client struct {
	// DelegatedServers contains a list of delegated servers represented by their public keys.
	DelegatedServers []cipher.PubKey `json:"delegated_servers"`
}

type Entry struct {
	// The data structure's version.
	Version string `json:"version"`

	// An Entry of a given public key may need to iterate. This is the iteration sequence.
	Sequence uint64 `json:"sequence"`

	// Timestamp of the current iteration.
	Timestamp int64 `json:"timestamp"`

	// Static public key of an instance.
	Static cipher.PubKey `json:"static"`

	// Contains the instance's client meta if it's to be advertised as a DMSG Client.
	Client *Client `json:"client,omitempty"`

	// ClientType the instance's client_type meta if it's to be advertised as a DMSG Client.
	ClientType string `json:"client_type,omitempty"`

	// Contains the instance's server meta if it's to be advertised as a DMSG Server.
	Server *Server `json:"server,omitempty"`

	// Signature for proving authenticity of an Entry.
	Signature string `json:"signature,omitempty"`

	// Protocol is the lib that use for multiplexing.
	Protocol string `json:"protocol,omitempty"`
}

type EntryReader interface {
	Entry(context.Context, cipher.PubKey) (*Entry, error)
	AvailableServers(context.Context) ([]*Entry, error)
	AllServers(context.Context) ([]*Entry, error)
}

type EntryValidationError struct {
	Cause string
}

type EntryWriter interface {
	PostEntry(context.Context, *Entry) error
	PutEntry(context.Context, cipher.SecKey, *Entry) error
	DelEntry(context.Context, *Entry) error
}

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

type HTTPMessage struct {
	Message string `json:"message"`
	Code    int    `json:"code"`
}

type Server struct {
	// Address is the DMSG Server's reachable endpoint ("host:port").
	// Historically an IPv4 or IPv6 address could go in this field
	// either-or; with the dual-stack-within-record design (see #1525)
	// Address now canonically carries the IPv4 endpoint and
	// AddressV6 carries the IPv6 counterpart. Servers listening on
	// only one family leave the other blank; servers listening on
	// both populate both. Dialers prefer v6 with v4 fallback per
	// RFC 8305.
	Address string `json:"address"`

	// AddressV6 is the optional IPv6 ("[host]:port") endpoint for
	// dual-stack DMSG servers. Empty when the server is v4-only.
	// Backward-compat: older servers omit this field; older clients
	// ignore it; either side absent the field falls through to
	// Address as today.
	AddressV6 string `json:"address_v6,omitempty"`

	// AddressUDP / AddressUDPV6 are the optional QUIC (UDP) endpoints a
	// server also listens on (#2607 dmsg-over-QUIC). A QUIC-speaking server
	// populates these alongside the TCP Address(es) and advertises
	// Entry.Protocol="quic"; QUIC-capable clients dial these for a session
	// with native QUIC stream multiplexing + an unreliable datagram channel,
	// while clients/servers that don't know QUIC ignore the fields and use
	// the TCP Address as today. Fully backward-compatible (omitempty +
	// dual-listen). The UDP port may share the TCP port number.
	AddressUDP   string `json:"address_udp,omitempty"`
	AddressUDPV6 string `json:"address_udp_v6,omitempty"`

	// AddressWS is the optional WebSocket endpoint a server also listens on
	// (dmsg-over-WebSocket). It carries a full ws:// or wss:// URL including
	// path (e.g. "wss://dmsg1.skywire.skycoin.com/dmsg"). A WS connection is
	// a net.Conn, so the session runs the SAME Noise+yamux stack as the TCP
	// Address — WS is purely a browser-reachable / CDN-frontable / restrictive-
	// network transport, orthogonal to Protocol (which still selects the mux).
	// The primary consumer is a dmsg client compiled to js/wasm, which cannot
	// open a raw TCP or UDP socket and so can only reach the mesh over WS.
	// Backward-compatible: omitempty + older clients/servers ignore it.
	AddressWS string `json:"address_ws,omitempty"`

	// AddressWT is the optional WebTransport (HTTP/3-over-QUIC) endpoint a server
	// also listens on (dmsg-over-WebTransport). It carries a full https:// URL
	// including path (e.g. "https://1.2.3.4:8443/dmsg"). Like AddressWS it is a
	// net.Conn-style single stream carrying the SAME Noise+yamux stack — the
	// session is identical, only the underlying transport differs. WebTransport's
	// value over WS is that a browser can reach it by BARE IP with no CA-issued
	// certificate: the browser pins CertHashWT (below) in its WebTransport
	// serverCertificateHashes constructor. Backward-compatible: omitempty + older
	// clients/servers ignore it.
	AddressWT string `json:"address_wt,omitempty"`

	// CertHashWT is the lowercase-hex SHA-256 of the DER of the self-signed ECDSA
	// certificate served on AddressWT. It is the value a browser pins in the
	// WebTransport serverCertificateHashes option to reach AddressWT with no CA.
	// The server rotates its cert (<=14-day validity, browser-enforced) and
	// re-advertises this hash. Empty unless AddressWT is set.
	CertHashWT string `json:"cert_hash_wt,omitempty"`

	// CertHashWTNext is the hash of the certificate the server will serve
	// after its next rotation. A browser pins both, so it keeps connecting
	// across the rotation without looking the server up again. Empty from
	// older servers and when AddressWT is unset.
	CertHashWTNext string `json:"cert_hash_wt_next,omitempty"`

	// AvailableSessions is the number of available sessions that the server can currently accept.
	AvailableSessions int `json:"availableSessions"`

	// ServerType of DMSG Server, be `official` of `community`
	ServerType string `json:"serverType,omitempty"`

	// DHTBootstrap indicates this server runs a DHT full node on port 100
	// and can be used as a Kademlia bootstrap peer by visors.
	DHTBootstrap bool `json:"dht_bootstrap,omitempty"`
}

type ServersFunc func(ctx context.Context) ([]*Entry, bool)