Struct MessagingService 

pub struct MessagingService { /* private fields */ }

High-level messaging service that coordinates all messaging components

Implementations

impl MessagingService

pub async fn new( identity: FourWordAddress, dht_client: DhtClient, ) -> Result<Self>

Create a new messaging service with default configuration

Uses OS-assigned port (port 0) by default to avoid port conflicts. This is the recommended way to create a MessagingService for most use cases.

Example

let dht = DhtClient::new()?;
let address = FourWordAddress("test-user-one-alpha".to_string());
let service = MessagingService::new(address, dht).await?;

// Get actual bound port
let addrs = service.listen_addrs().await;
println!("Listening on: {:?}", addrs);

pub async fn new_with_config( identity: FourWordAddress, dht_client: DhtClient, config: NetworkConfig, ) -> Result<Self>

Create a new messaging service with custom network configuration

This allows fine-grained control over port binding, IP mode, and retry behavior.

Arguments

• identity - Four-word address for this node
• dht_client - DHT client for distributed operations
• config - Network configuration (port, IP mode, retry behavior)

Example with OS-Assigned Port

let dht = DhtClient::new()?;
let address = FourWordAddress("test-user-one-alpha".to_string());

// Use default config (OS-assigned port)
let config = NetworkConfig::default();
let service = MessagingService::new_with_config(address, dht, config).await?;

Example with Explicit Port

let dht = DhtClient::new()?;
let address = FourWordAddress("test-user-two-alpha".to_string());

// Use explicit port
let config = NetworkConfig {
    port: PortConfig::Explicit(12345),
    ip_mode: IpMode::IPv4Only,
    retry_behavior: RetryBehavior::FailFast,
};
let service = MessagingService::new_with_config(address, dht, config).await?;

Note

Currently, only PortConfig::OsAssigned and PortConfig::Explicit are fully supported. Full configuration support (port ranges, dual-stack separate ports) requires ant-quic 0.10.0.

pub async fn enable_restart_management( &self, restart_manager: Arc<RestartManager>, )

Enable restart management for this service

This integrates the RestartManager to handle network rejections and identity regeneration.

pub async fn send_message( &self, recipients: Vec<FourWordAddress>, content: MessageContent, channel_id: ChannelId, options: SendOptions, ) -> Result<(MessageId, DeliveryReceipt)>

Send a message to recipients

pub async fn send_message_to_channel( &self, channel_id: ChannelId, content: MessageContent, options: SendOptions, ) -> Result<(MessageId, DeliveryReceipt)>

Send a message to a channel

pub async fn subscribe_messages( &self, channel_filter: Option<ChannelId>, ) -> Receiver<ReceivedMessage>

Subscribe to incoming messages

pub async fn get_message_status( &self, message_id: MessageId, ) -> Result<DeliveryStatus>

Get message delivery status

pub async fn get_message(&self, message_id: MessageId) -> Result<RichMessage>

Retrieve a message by ID

pub async fn get_channel_messages( &self, channel_id: ChannelId, limit: usize, before: Option<DateTime<Utc>>, ) -> Result<Vec<RichMessage>>

Get messages for a channel with pagination

Arguments

• channel_id - The channel to retrieve messages from
• limit - Maximum number of messages to return
• before - Optional timestamp to get messages before (for pagination)

Returns

Vector of messages ordered by creation time (newest first)

pub async fn get_thread_messages( &self, thread_id: ThreadId, ) -> Result<Vec<RichMessage>>

Get all messages in a thread

Arguments

• thread_id - The thread to retrieve messages from

Returns

Vector of all messages in the thread

pub async fn mark_user_online(&self, user: FourWordAddress) -> Result<()>

Mark a user as online

pub async fn mark_delivered( &self, message_id: MessageId, recipient: FourWordAddress, ) -> Result<()>

Mark message as delivered

pub async fn process_message_queue(&self) -> Result<()>

Process queued messages

pub async fn encrypt_message( &self, recipient: FourWordAddress, channel_id: ChannelId, content: MessageContent, ) -> Result<EncryptedMessage>

Encrypt a message for a recipient

pub async fn decrypt_message( &self, encrypted: EncryptedMessage, ) -> Result<RichMessage>

Decrypt a message

pub async fn listen_addrs(&self) -> Vec<SocketAddr>

Get the local network address(es) this node is listening on

pub async fn connected_peers(&self) -> Vec<String>

Get the list of currently connected peer IDs

pub async fn peer_count(&self) -> usize

Get the count of currently connected peers

pub async fn is_running(&self) -> bool

Check if the P2P node is running

pub async fn connect_peer(&self, address: &str) -> Result<String>

Connect to a peer via their network address

Arguments

• address - Network address in format “ip:port” or “[ipv6]:port”

Returns

The peer ID of the connected peer

pub async fn disconnect_peer(&self, peer_id: &str) -> Result<()>

Disconnect from a specific peer

Arguments

• peer_id - The peer ID to disconnect from