Struct SignalWebSocket 

pub struct SignalWebSocket<C: WebSocketType> { /* private fields */ }

A dispatching web socket client for the Signal web socket API.

This structure can be freely cloned, since this acts as a facade for multiple entry and exit points.

Implementations

impl SignalWebSocket<Identified>

pub async fn whoami(&mut self) -> Result<WhoAmIResponse, ServiceError>

Method used to check our own UUID

pub async fn set_account_attributes( &mut self, attributes: AccountAttributes, ) -> Result<(), ServiceError>

pub async fn unregister_account(&mut self) -> Result<(), ServiceError>

Unregister and delete the account from Signal servers.

This permanently deletes the account and all associated data (groups, contacts, messages). After calling this, the phone number can be re-registered with a fresh account.

CAUTION: This is irreversible. All account data will be lost.

impl SignalWebSocket<Identified>

pub async fn discover_contacts( &mut self, lookup_request: LookupRequest, ) -> Result<Vec<(E164, Option<ServiceId>)>, ServiceError>

Resolve phone numbers (with possible extra information) to accounts.

Uses Contact Discovery Service (CDSI) via libsignal-net. The phone numbers are looked up inside an SGX enclave for privacy.

Arguments

• lookup_request - The CDSI lookup request containing phone numbers and other parameters

Returns

• Ok(Vec<Option<ServiceId>>) - Vector of resolved ServiceIds (None if not found)
• Err(ServiceError) - Network or protocol error

pub async fn discover_contact_by_phone_number( &mut self, phone_number: impl TryIntoE164, ) -> Result<Option<ServiceId>, ServiceError>

Resolve a single phone number (E.164 format, e.g., “+15551234567”) to a ServiceId.

Convenience wrapper that looks up a single phone number using CDSI.

Arguments

• phone_number - Phone number in E.164 format (e.g., “+15551234567”)

Returns

• Ok(Option<ServiceId>) - The resolved ServiceId (None if not found)
• Err(ServiceError) - Network or protocol error

impl SignalWebSocket<Identified>

pub async fn get_pre_key_status( &mut self, service_id_kind: ServiceIdKind, ) -> Result<PreKeyStatus, ServiceError>

pub async fn check_pre_keys( &mut self, service_id_kind: ServiceIdKind, digest: &[u8; 32], ) -> Result<bool, ServiceError>

Checks for consistency of the repeated-use keys

Supply the digest as follows: SHA256(identityKeyBytes || signedEcPreKeyId || signedEcPreKeyIdBytes || lastResortKeyId || lastResortKeyBytes)

The IDs are represented as 8-byte big endian ints.

Retuns Ok(true) if the view is consistent, Ok(false) if the view is inconsistent.

pub async fn register_pre_keys( &mut self, service_id_kind: ServiceIdKind, pre_key_state: PreKeyState, ) -> Result<(), ServiceError>

pub async fn get_pre_key( &mut self, destination: &ServiceId, device_id: DeviceId, ) -> Result<PreKeyBundle, ServiceError>

pub async fn get_sender_certificate( &mut self, ) -> Result<SenderCertificate, ServiceError>

pub async fn get_uuid_only_sender_certificate( &mut self, ) -> Result<SenderCertificate, ServiceError>

pub async fn distribute_pni_keys( &mut self, pni_identity_key: &IdentityKey, device_messages: Vec<OutgoingPushMessage>, device_pni_signed_prekeys: HashMap<String, SignedPreKeyEntity>, device_pni_last_resort_kyber_prekeys: HashMap<String, KyberPreKeyEntity>, pni_registration_ids: HashMap<String, u32>, signature_valid_on_each_signed_pre_key: bool, ) -> Result<VerifyAccountResponse, ServiceError>

impl SignalWebSocket<Identified>

pub async fn unlink_device(&mut self, id: DeviceId) -> Result<(), ServiceError>

impl SignalWebSocket<Identified>

pub async fn retrieve_profile_by_id( &mut self, address: Aci, profile_key: Option<ProfileKey>, ) -> Result<SignalServiceProfile, ServiceError>

pub async fn write_profile<'s, C, S>( &mut self, version: &ProfileKeyVersion, name: &[u8], about: &[u8], emoji: &[u8], commitment: &ProfileKeyCommitment, avatar: AvatarWrite<&mut C>, ) -> Result<Option<String>, ServiceError>

where C: Read + Send + 's, S: AsRef<str>,

Writes a profile and returns the avatar URL, if one was provided.

The name, about and emoji fields are encrypted with an ProfileCipher. See AccountManager for a convenience method.

Java equivalent: writeProfile

impl SignalWebSocket<Unidentified>

pub async fn retrieve_profile_avatar( &mut self, path: &str, ) -> Result<impl AsyncRead + Send + Unpin, ServiceError>

pub async fn retrieve_groups_v2_profile_avatar( &mut self, path: &str, ) -> Result<impl AsyncRead + Send + Unpin, ServiceError>

impl SignalWebSocket<Unidentified>

pub async fn create_verification_session<'a>( &mut self, number: &'a str, push_token: Option<&'a str>, mcc: Option<&'a str>, mnc: Option<&'a str>, ) -> Result<RegistrationSessionMetadataResponse, ServiceError>

pub async fn patch_verification_session<'a>( &mut self, session_id: &'a str, push_token: Option<&'a str>, mcc: Option<&'a str>, mnc: Option<&'a str>, captcha: Option<&'a str>, push_challenge: Option<&'a str>, ) -> Result<RegistrationSessionMetadataResponse, ServiceError>

pub async fn request_verification_code( &mut self, session_id: &str, client: &str, transport: VerificationTransport, ) -> Result<RegistrationSessionMetadataResponse, ServiceError>

Request a verification code.

Signal requires a client type, and they use these three strings internally:

• “android-2021-03”
• “android”
• “ios”

“android-2021-03” allegedly implies FCM support, whereas the other strings don’t. In principle, they will consider any string as “unknown”, so other strings may work too.

impl SignalWebSocket<Identified>

pub async fn submit_registration_request( &mut self, registration_method: RegistrationMethod<'_>, account_attributes: AccountAttributes, skip_device_transfer: bool, aci_identity_key: &IdentityKey, pni_identity_key: &IdentityKey, device_activation_request: DeviceActivationRequest, ) -> Result<VerifyAccountResponse, ServiceError>

pub async fn submit_verification_code( &mut self, session_id: &str, verification_code: &str, ) -> Result<RegistrationSessionMetadataResponse, ServiceError>

impl<C: WebSocketType> SignalWebSocket<C>

pub async fn send_messages( &mut self, messages: OutgoingPushMessages, ) -> Result<SendMessageResponse, ServiceError>

pub async fn send_messages_unidentified( &mut self, messages: OutgoingPushMessages, access: &UnidentifiedAccess, ) -> Result<SendMessageResponse, ServiceError>

impl<C: WebSocketType> SignalWebSocket<C>

pub async fn get_sticker_pack_manifest( &mut self, id: &str, ) -> Result<impl AsyncRead + Send + Unpin, ServiceError>

pub async fn get_sticker( &mut self, pack_id: &str, sticker_id: u32, ) -> Result<impl AsyncRead + Send + Unpin, ServiceError>

impl SignalWebSocket<Unidentified>

pub async fn look_up_username( &mut self, username: &Username, ) -> Result<Option<Aci>, ServiceError>

pub async fn look_up_username_hash( &mut self, hash: &[u8], ) -> Result<Option<Aci>, ServiceError>

pub async fn look_up_username_link( &mut self, uuid: Uuid, entropy: &[u8; 32], ) -> Result<Option<Username>, ServiceError>

impl<C: WebSocketType> SignalWebSocket<C>

pub fn new( ws: WebSocket, keep_alive_path: String, unidentified_push_service: PushService, ) -> (Self, impl Future<Output = ()>)

pub fn servers(&self) -> SignalServers

pub fn is_closed(&self) -> bool

pub fn is_used(&self) -> bool

pub async fn with_request_stream<R: 'static, F: FnOnce(&mut SignalRequestStream) -> R>( &mut self, f: F, ) -> R

pub fn request( &mut self, r: WebSocketRequestMessage, ) -> impl Future<Output = Result<WebSocketResponseMessage, ServiceError>>

Trait Implementations

impl<C: Clone + WebSocketType> Clone for SignalWebSocket<C>

fn clone(&self) -> SignalWebSocket<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.