rpc

type API struct {
	Namespace string
	Service   interface{}
}

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

type AdminNode interface {
	SystemIdentifier() types.SystemID
}

type NodeInfoResponse struct {
	SystemID            types.SystemID `json:"systemId"` // hex encoded system identifier
	Name                string         `json:"name"`     // one of [money node | tokens node | evm node]
	Self                PeerInfo       `json:"self"`     // information about this peer
	BootstrapNodes      []PeerInfo     `json:"bootstrapNodes"`
	RootValidators      []PeerInfo     `json:"rootValidators"`
	PartitionValidators []PeerInfo     `json:"partitionValidators"`
	OpenConnections     []PeerInfo     `json:"openConnections"` // all libp2p connections to other peers in the network

}

type Observability interface {
	Meter(name string, opts ...metric.MeterOption) metric.Meter
	PrometheusRegisterer() prometheus.Registerer
	Logger() *slog.Logger
}

type Option func(*Options)

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

type PeerInfo struct {
	Identifier string                `json:"identifier"`
	Addresses  []multiaddr.Multiaddr `json:"addresses"`
}

type Registrar interface {
	Register(r *mux.Router)
}

type RegistrarFunc func(r *mux.Router)

type ServerConfiguration struct {
	// Address specifies the TCP address for the server to listen on, in the form "host:port".
	// REST server isn't initialised if Address is empty.
	Address string

	// ReadTimeout is the maximum duration for reading the entire request, including the body. A zero or negative
	// value means there will be no timeout.
	ReadTimeout time.Duration

	// ReadHeaderTimeout is the amount of time allowed to read request headers. If ReadHeaderTimeout is zero, the
	// value of ReadTimeout is used. If both are zero, there is no timeout.
	ReadHeaderTimeout time.Duration

	// WriteTimeout is the maximum duration before timing out writes of the response. A zero or negative value means
	// there will be no timeout.
	WriteTimeout time.Duration

	// IdleTimeout is the maximum amount of time to wait for the next request when keep-alives are enabled. If
	// IdleTimeout is zero, the value of ReadTimeout is used. If both are zero, there is no timeout.
	IdleTimeout time.Duration

	// MaxHeaderBytes controls the maximum number of bytes the server will read parsing the request header's keys
	// and values, including the request line. It does not limit the size of the request body. If zero,
	// http.DefaultMaxHeaderBytes is used.
	MaxHeaderBytes int

	// MaxHeaderBytes controls the maximum number of bytes the server will read parsing the request body. If zero,
	// MaxBodyBytes is used.
	MaxBodyBytes int64

	// BatchItemLimit is the maximum number of requests in a batch.
	BatchItemLimit int

	// BatchResponseSizeLimit is the maximum number of response bytes across all requests in a batch.
	BatchResponseSizeLimit int

	Router Registrar

	// APIs contains is an array of enabled RPC services.
	APIs []API
}

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

type TransactionRecordAndProof struct {
	TxRecord types.Bytes `json:"txRecord"`
	TxProof  types.Bytes `json:"txProof"`
}

type Unit[T any] struct {
	UnitID         types.UnitID          `json:"unitId"`
	Data           T                     `json:"data"`
	OwnerPredicate types.Bytes           `json:"ownerPredicate,omitempty"`
	StateProof     *types.UnitStateProof `json:"stateProof,omitempty"`
}