Introduce EventPublisher trait.

The LDK Server needs a flexible and reliable mechanism to publish informational
events (e.g., transaction updates, channel status changes) to external messaging
systems to integration with other external services in a decoupled manner.

To achieve this, we introduce the EventPublisher trait, which defines a
consistent, asynchronous interface for event publishing. This allows the daemon
to support multiple messaging backends (e.g., RabbitMQ, Kafka, AWS SQS) via
feature flags.

Since underlying messaging systems are expected to support durable buffering,
this keeps the LDK Server decoupled from event storage and handling, while
enabling multiple consumers to process events independently.

This is in contrast with in-memory event queues, polling, or WebSockets, since
they either lack durability, tightly couple the daemon to consumers, or require
constant connectivity. In-memory queues risk losing events on restart, polling
burdens the daemon with service calls from each consumer, and WebSockets demand
real-time client availability—none of which support multiple consumers
efficiently.

Author: G8XSU

Cargo.lock

@@ -17,3 +17,4 @@ bytes = { version = "1.4.0", default-features = false }
 hex = { package = "hex-conservative", version = "0.2.1", default-features = false }
 rusqlite = { version = "0.31.0", features = ["bundled"] }
 rand = { version = "0.8.5", default-features = false }
+async-trait = { version = "0.1.85", default-features = false }

ldk-server/Cargo.toml

@@ -0,0 +1,42 @@
+use crate::api::error::LdkServerError;
+use async_trait::async_trait;
+use ldk_server_protos::events::EventEnvelope;
+
+/// A trait for publishing events or notifications from the LDK Server.
+///
+/// Implementors of this trait define how events are sent to various messaging
+/// systems. It provides a consistent, asynchronous interface for event publishing, while allowing
+/// each implementation to manage  its own initialization and configuration, typically sourced from
+/// the `ldk-server.config` file. A no-op implementation is included by default,
+/// with specific implementations enabled via feature flags.
+///
+/// Events are represented as [`EventEnvelope`] messages, which are Protocol Buffers
+/// ([protobuf](https://protobuf.dev/)) objects defined in [`ldk_server_protos::events`].
+/// These events are serialized to bytes by the publisher before transmission, and consumers can
+/// deserialize them using the protobuf definitions.
+///
+/// The underlying messaging system is expected to support durably buffered events,
+/// enabling easy decoupling between the LDK Server and event consumers.
+#[async_trait]
+pub trait EventPublisher {
+	/// Publishes an event to the underlying messaging system.
+	///
+	/// # Arguments
+	/// * `event` - The event message to publish, provided as an [`EventEnvelope`]
+	///             defined in [`ldk_server_protos::events`]. Implementors must serialize
+	///             the whole [`EventEnvelope`] to bytes before publishing.
+	///
+	/// In order to ensure no events are lost, implementors of this trait must publish events
+	/// durably to underlying messaging system. An event is considered published when
+	/// [`EventPublisher::publish`] returns `Ok(())`, thus implementors MUST durably persist/publish events *before*
+	/// returning `Ok(())`.
+	///
+	/// # Errors
+	/// May return an [`LdkServerErrorCode::InternalServerError`] if the event cannot be published,
+	/// such as due to network failures, misconfiguration, or transport-specific issues.
+	/// If event publishing fails, the LDK Server will retry publishing the event indefinitely, which
+	/// may degrade performance until the underlying messaging system is operational again.
+	///
+	/// [`LdkServerErrorCode::InternalServerError`]: crate::api::error::LdkServerErrorCode
+	async fn publish(&self, event: EventEnvelope) -> Result<(), LdkServerError>;
+}

ldk-server/src/io/events/event_publisher.rs

@@ -0,0 +1 @@
+pub(crate) mod event_publisher;

ldk-server/src/io/events/mod.rs

@@ -1,2 +1,3 @@
+pub(crate) mod events;
 pub(crate) mod persist;
 pub(crate) mod utils;