rpc

type API struct {
	Namespace string
	Service   interface{}
}

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

type NodeInfoResponse struct {
	NetworkID           types.NetworkID       `json:"networkId"`       // hex encoded network identifier
	PartitionID         types.PartitionID     `json:"partitionId"`     // hex encoded partition identifier
	PartitionTypeID     types.PartitionTypeID `json:"partitionTypeId"` // hex encoded partition identifier
	PermissionedMode    bool                  `json:"permissionedMode"`
	FeelessMode         bool                  `json:"feelessMode"`
	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 PeerInfo struct {
	NodeID    string                `json:"nodeId"`
	Addresses []multiaddr.Multiaddr `json:"addresses"`
}

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

type RegistrarFunc func(r *mux.Router)

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

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

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-alive is 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 StateAPIOption func(*StateAPIOptions)

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

type TransactionRecordAndProof struct {
	TxRecordProof hex.Bytes `json:"txRecordProof"` // hex encoded CBOR of types.TxRecordProof
}

type Unit[T any] struct {
	NetworkID   types.NetworkID       `json:"networkId"`
	PartitionID types.PartitionID     `json:"partitionId"`
	UnitID      types.UnitID          `json:"unitId"`
	Data        T                     `json:"data"`
	StateProof  *types.UnitStateProof `json:"stateProof,omitempty"`
	StateLockTx hex.Bytes             `json:"stateLockTx,omitempty"`
}