node

type Config struct {
	Core     core.Config
	P2P      p2p.Config
	RPC      rpc.Config
	Services services.Config
}

type ConfigLoader func() (*Config, error)

type Node struct {
	Type   Type
	Config *Config

	// CoreClient provides access to a Core node process.
	CoreClient core.Client `optional:"true"`

	// RPCServer provides access to Node's exposed APIs.
	RPCServer *rpc.Server `optional:"true"`

	// p2p components
	Host         host.Host
	ConnGater    connmgr.ConnectionGater
	Routing      routing.PeerRouting
	DataExchange exchange.Interface
	DAG          format.DAGService
	// p2p protocols
	PubSub *pubsub.PubSub
	// BlockService provides access to the node's Block Service
	// TODO @renaynay: I don't like the concept of storing individual services on the node,
	// TODO maybe create a struct in full.go that contains `FullServices` (all expected services to be running on a
	// TODO full node) and in light, same thing `LightServices` (all expected services to be running in a light node.
	// TODO `FullServices` can include `LightServices` + other services.
	BlockServ  *block.Service  `optional:"true"`
	ShareServ  share.Service   // not optional
	HeaderServ *header.Service // not optional

	DASer *das.DASer `optional:"true"`
	// contains filtered or unexported fields
}

type Option func(*Config)

type Repository interface {
	// Path reports the FileSystem path of Repository.
	Path() string

	// Keystore provides a Keystore to access keys.
	Keystore() (keystore.Keystore, error)

	// Datastore provides a Datastore - a KV store for arbitrary data to be stored on disk.
	Datastore() (datastore.Batching, error)

	// Core provides an access to Core's Repository.
	Core() (core.Repository, error)

	// Config loads the stored Node config.
	Config() (*Config, error)

	// PutConfig alters the stored Node config.
	PutConfig(*Config) error

	// Close closes the Repository freeing up acquired resources and locks.
	Close() error
}

type Type uint8