Struct Signal 

pub struct Signal<'a> { /* private fields */ }

Feature handle for Signal protocol operations.

Implementations

impl<'a> Signal<'a>

pub async fn install_prekey_bundle( &self, jid: &Jid, bundle: &PreKeyBundle, ) -> Result<IdentityChange, SignalError>

Install a supplied pairwise pre-key bundle and durably expose the new session before returning.

pub async fn process_sender_key_distribution( &self, group_jid: &Jid, sender_jid: &Jid, distribution: &[u8], ) -> Result<(), SignalError>

Process a sender-key distribution and durably expose it before return.

pub async fn sender_key_distribution( &self, group_jid: &Jid, sender_jid: &Jid, ) -> Result<Vec<u8>, SignalError>

Create the current sender-key distribution for a group.

pub async fn has_sender_key( &self, group_jid: &Jid, sender_jid: &Jid, ) -> Result<bool, SignalError>

Check whether sender-key state exists for a group and sender.

pub async fn delete_sender_key( &self, group_jid: &Jid, sender_jid: &Jid, ) -> Result<(), SignalError>

Delete one sender-key chain and make the removal durable before returning.

pub async fn session_info( &self, jid: &Jid, ) -> Result<Option<SignalSessionInfo>, SignalError>

Inspect the currently open pairwise session for a JID.

pub async fn migrate_sessions( &self, from: &Jid, to: &Jid, ) -> Result<SignalSessionMigration, SignalError>

Move pairwise session state from a phone-number namespace to its linked identifier namespace across known device slots.

pub async fn encrypt_message( &self, jid: &Jid, plaintext: &[u8], ) -> Result<(EncType, Vec<u8>), SignalError>

Encrypt plaintext for a single recipient using the Signal protocol.

Returns (EncType, ciphertext_bytes). The caller is responsible for padding if needed; this method encrypts raw bytes.

PN JIDs are resolved to LID, with a legacy PN session migrated lazily if the resolved lookup misses.

pub async fn decrypt_message( &self, jid: &Jid, enc_type: EncType, ciphertext: &[u8], ) -> Result<Vec<u8>, SignalError>

Decrypt a Signal protocol message from a sender.

Returns raw padded plaintext. Use MessageUtils::unpad_message_ref with the stanza’s v attribute if WhatsApp message unpadding is needed.

PN JIDs are resolved to LID, with a legacy PN session migrated lazily if the resolved lookup misses.

pub async fn encrypt_group_message( &self, group_jid: &Jid, plaintext: &[u8], ) -> Result<(Option<Vec<u8>>, Vec<u8>), SignalError>

Encrypt plaintext for a group using sender keys.

Returns (Option<skdm_bytes>, ciphertext_bytes). The SKDM is Some while a new sender key still requires distribution (first encrypt for this group, after key rotation, or a retry whose earlier durability gate failed). Callers must distribute the SKDM to all group participants when present.

Concurrent calls for the same (group, sender) are serialized on the sender-key chain, so the SKDM and the skmsg can’t be split across keys.

pub async fn decrypt_group_message( &self, group_jid: &Jid, sender_jid: &Jid, ciphertext: &[u8], ) -> Result<Vec<u8>, SignalError>

Decrypt a group (sender-key) message.

Returns raw padded plaintext. Use MessageUtils::unpad_message_ref with the stanza’s v attribute if WhatsApp message unpadding is needed.

Concurrent mutations of the same sender-key chain are serialized.

pub async fn validate_session(&self, jid: &Jid) -> Result<bool, SignalError>

Check whether a Signal session exists for jid.

PN JIDs are resolved to LID when a LID mapping exists, matching the encrypt/decrypt paths.

pub async fn delete_sessions(&self, jids: &[Jid]) -> Result<(), SignalError>

Delete Signal sessions and identity keys for the given JIDs.

Matches WA Web’s deleteRemoteSession which removes both session and identity as a paired operation. Changes are flushed to the persistent backend before returning.

When a supplied PN JID resolves to LID, both namespace representations are removed so legacy PN state cannot be migrated back after deletion.

pub async fn create_participant_nodes( &self, recipient_jids: &[Jid], message: &Message, ) -> Result<(Vec<Node>, bool), SignalError>

Create encrypted participant <to> nodes for the given recipient JIDs.

Resolves devices, ensures Signal sessions, encrypts the message for each device, and returns the resulting XML nodes.

Returns (nodes, should_include_device_identity).

pub async fn assert_sessions(&self, jids: &[Jid]) -> Result<(), SignalError>

Ensure E2E sessions exist for the given JIDs.

pub async fn get_user_devices( &self, jids: &[Jid], ) -> Result<Vec<Jid>, SignalError>

Get all known device JIDs for the given user JIDs via usync.