Struct Service 

pub struct Service<N, A, R>
where
    N: NodeLifecycle,
    A: PeerApi,
    R: RpcApi,
{ /* private fields */ }

The top-level orchestration handle.

See the crate-level documentation for architecture + lifecycle diagram. Service owns the business-logic node and the peer / RPC API adapters; driving start() runs the full lifecycle.

Type parameters

• N — the NodeLifecycle implementation (the business core).
• A — the PeerApi implementation. Use () for binaries that don’t serve a peer surface (daemon, wallet).
• R — the RpcApi implementation. Use () for binaries that don’t serve RPC (introducer, relay).

Implementations

impl<N, A, R> Service<N, A, R>

where N: NodeLifecycle, A: PeerApi, R: RpcApi,

pub fn new(node: N, peer_api: A, rpc_api: R) -> Self

Construct a new service from its three components.

No runtime work happens here — ports are not bound, stores are not opened. All of that runs inside start().

pub fn handle(&self) -> ServiceHandle

Return a cloneable handle for out-of-process-lifetime commands (signal handlers, RPC admin methods).

The returned handle remains valid after Service is dropped — its operations simply become no-ops.

pub fn node(&self) -> &Arc<N>

Borrow the node. Mostly useful in tests; production callers should share state via the Arc<N> they constructed before Service::new.

pub fn peer_api(&self) -> &Arc<A>

Borrow the peer API.

pub fn rpc_api(&self) -> &Arc<R>

Borrow the RPC API.

pub fn shutdown_token(&self) -> &ShutdownToken

Borrow the shutdown token. Use this to give background tasks a way to notice shutdown has been requested.

pub fn tasks(&self) -> &TaskRegistry

Borrow the task registry.

pub fn request_shutdown(&self, reason: ShutdownReason)

Request a graceful shutdown. Idempotent — only the first reason is recorded.

pub async fn start(self) -> Result<ExitStatus>

Drive the full lifecycle: pre_start → on_start → run → on_stop → post_stop. Returns once run exits (graceful or error) OR a shutdown has been requested.

Error handling

• A failure in pre_start short-circuits without calling any later hook.
• A failure in on_start calls post_stop but skips run and on_stop.
• A failure in run still calls on_stop + post_stop.
• A failure in on_stop is recorded but does not block post_stop.
• Panics inside run are caught via scopeguard-style drop logic and reported as ExitReason::RunError.

Calling start twice on the same Service returns ServiceError::AlreadyRunning.