A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::app_attest::{AgeFloor, AppAttestRejection, ChallengePurpose};
use crate::play_integrity::PlayIntegrityRejection;
use crate::pseudonym::pseudonym;
use fluxer_common::user_flags::AccountStanding;
#[cfg(test)]
use fluxer_common::user_flags::USER_FLAG_STAFF;
pub use fluxer_common::user_partial::ApiUserPartial;
use fluxer_common::user_partial::{
FLUXER_SYSTEM_USER_ID, UserPartialFields, default_instance_name,
};
use serde::{Deserialize, Deserializer, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "op")]
pub enum UserRequest {
GetPartialsByIds {
user_ids: Vec<i64>,
#[serde(default = "default_instance_name")]
instance_name: String,
},
GetApiPartialsByIds {
user_ids: Vec<String>,
#[serde(default = "default_instance_name")]
instance_name: String,
},
Invalidate {
#[serde(deserialize_with = "deserialize_i64_from_number_or_string")]
user_id: i64,
},
AppAttestCreateChallenge {
#[serde(deserialize_with = "deserialize_i64_from_number_or_string")]
user_id: i64,
purpose: ChallengePurpose,
},
AppAttestRegisterKey {
#[serde(deserialize_with = "deserialize_i64_from_number_or_string")]
user_id: i64,
key_id: String,
attestation_base64: String,
challenge: String,
},
AppAttestSubmitAge {
#[serde(deserialize_with = "deserialize_i64_from_number_or_string")]
user_id: i64,
key_id: String,
assertion_base64: String,
client_data_base64: String,
},
PlayIntegrityCreateChallenge {
#[serde(deserialize_with = "deserialize_i64_from_number_or_string")]
user_id: i64,
},
PlayIntegritySubmitAge {
#[serde(deserialize_with = "deserialize_i64_from_number_or_string")]
user_id: i64,
package_name: String,
integrity_token: String,
client_data_base64: String,
},
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[allow(clippy::large_enum_variant)]
pub enum UserResponse {
FoundPartials(Vec<UserPartial>),
FoundApiPartials(Vec<ApiUserPartial>),
Invalidated,
AppAttestChallenge {
challenge: String,
expires_at: String,
},
AppAttestKeyRegistered,
AppAttestAgeAccepted {
age_floor: AgeFloor,
attested_at: String,
},
AppAttestRejected {
code: AppAttestRejection,
},
PlayIntegrityRejected {
code: PlayIntegrityRejection,
},
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserPartial {
pub user_id: i64,
pub username: String,
pub discriminator: i32,
pub global_name: Option<String>,
pub avatar_hash: Option<String>,
pub bot: Option<bool>,
pub system: Option<bool>,
pub flags: Option<i64>,
pub banner_hash: Option<String>,
pub banner_color: Option<i32>,
pub accent_color: Option<i32>,
pub avatar_color: Option<i32>,
pub mention_flags: Option<i32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub content_hidden_since: Option<i64>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub hidden_profile_badges: Vec<String>,
}
impl UserPartial {
pub fn visible_to_others(self, standing: &AccountStanding, now_ms: i64) -> UserPartial {
if self.user_id == FLUXER_SYSTEM_USER_ID || !standing.profile_hidden(now_ms) {
return self;
}
let pseudonym = pseudonym(self.user_id);
UserPartial {
username: pseudonym.username,
discriminator: pseudonym.discriminator,
global_name: None,
avatar_hash: None,
banner_hash: None,
banner_color: None,
accent_color: None,
avatar_color: None,
..self
}
}
pub fn to_api_partial(&self) -> ApiUserPartial {
ApiUserPartial::from(UserPartialFields {
user_id: self.user_id,
username: self.username.clone(),
discriminator: self.discriminator,
global_name: self.global_name.clone(),
avatar_hash: self.avatar_hash.clone(),
avatar_color: self.avatar_color,
bot: self.bot,
system: self.system,
flags: self.flags,
hidden_profile_badges: self.hidden_profile_badges.clone(),
mention_flags: self.mention_flags,
})
}
}
fn deserialize_i64_from_number_or_string<'de, D>(deserializer: D) -> Result<i64, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum I64OrString {
Number(i64),
String(String),
}
match I64OrString::deserialize(deserializer)? {
I64OrString::Number(value) => Ok(value),
I64OrString::String(value) => value.parse::<i64>().map_err(serde::de::Error::custom),
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
fn partial_with_flags(user_id: i64, flags: i64) -> UserPartial {
UserPartial {
user_id,
username: "Ada".to_owned(),
discriminator: 7,
global_name: Some("Ada Lovelace".to_owned()),
avatar_hash: Some("avatar_hash".to_owned()),
bot: Some(false),
system: Some(false),
flags: Some(flags),
banner_hash: None,
banner_color: None,
accent_color: None,
avatar_color: Some(0x336699),
mention_flags: Some(0),
content_hidden_since: None,
hidden_profile_badges: Vec::new(),
}
}
#[test]
fn api_partial_requests_use_string_snowflakes() {
let request: UserRequest = serde_json::from_value(json!({
"op": "GetApiPartialsByIds",
"user_ids": ["9007199254740993", "9223372036854775807"],
"instance_name": "Example Chat"
}))
.unwrap();
match request {
UserRequest::GetApiPartialsByIds {
user_ids,
instance_name,
} => {
assert_eq!(user_ids, vec!["9007199254740993", "9223372036854775807"]);
assert_eq!(instance_name, "Example Chat");
}
other => panic!("unexpected request: {other:?}"),
}
}
#[test]
fn invalidate_accepts_number_or_string_snowflakes() {
let string_request: UserRequest =
serde_json::from_value(json!({"op": "Invalidate", "user_id": "9007199254740993"}))
.unwrap();
let numeric_request: UserRequest =
serde_json::from_value(json!({"op": "Invalidate", "user_id": 42})).unwrap();
assert!(matches!(
string_request,
UserRequest::Invalidate {
user_id: 9007199254740993
}
));
assert!(matches!(
numeric_request,
UserRequest::Invalidate { user_id: 42 }
));
}
#[test]
fn api_partial_response_serializes_for_the_api_client() {
let response = UserResponse::FoundApiPartials(vec![
partial_with_flags(123, USER_FLAG_STAFF).to_api_partial(),
]);
let serialized = serde_json::to_value(response).unwrap();
assert_eq!(
serialized,
json!({
"FoundApiPartials": [{
"id": "123",
"username": "Ada",
"discriminator": "0007",
"global_name": "Ada Lovelace",
"avatar": "avatar_hash",
"avatar_color": 0x336699,
"flags": 1
}]
})
);
}
#[test]
fn app_attest_messages_match_the_api_contract() {
let request: UserRequest = serde_json::from_value(json!({
"op": "AppAttestSubmitAge",
"user_id": "9007199254740993",
"key_id": "a2V5",
"assertion_base64": "YXNzZXJ0aW9u",
"client_data_base64": "e30="
}))
.unwrap();
assert!(matches!(
request,
UserRequest::AppAttestSubmitAge {
user_id: 9007199254740993,
..
}
));
let request: UserRequest = serde_json::from_value(json!({
"op": "AppAttestCreateChallenge",
"user_id": 42,
"purpose": "assert"
}))
.unwrap();
assert!(matches!(
request,
UserRequest::AppAttestCreateChallenge {
user_id: 42,
purpose: ChallengePurpose::Assert
}
));
assert_eq!(
serde_json::to_value(UserResponse::AppAttestAgeAccepted {
age_floor: AgeFloor::UnderMinimum,
attested_at: "2026-11-05T12:00:00.000Z".to_owned(),
})
.unwrap(),
json!({"AppAttestAgeAccepted": {"age_floor": "under_minimum", "attested_at": "2026-11-05T12:00:00.000Z"}})
);
assert_eq!(
serde_json::to_value(UserResponse::AppAttestKeyRegistered).unwrap(),
json!("AppAttestKeyRegistered")
);
assert_eq!(
serde_json::to_value(UserResponse::AppAttestRejected {
code: AppAttestRejection::NotConfigured,
})
.unwrap(),
json!({"AppAttestRejected": {"code": "not_configured"}})
);
}
}