crust_core 1.0.3

Core library to download, install and launch Minecraft (versions, assets, libraries, Java runtime, mod loaders)
Documentation
use super::{Account, AccountMeta, AccountProfile, AccountType, Error};
use crate::network::HttpClient;
use crate::providers::yggdrasil::{Session, YggdrasilClient};

#[derive(Debug, Clone)]
pub struct Yggdrasil {
    client: YggdrasilClient,
}

impl Yggdrasil {
    pub fn new(http: HttpClient) -> Self {
        Self {
            client: YggdrasilClient::new(http),
        }
    }

    pub fn with_api(http: HttpClient, api_url: impl Into<String>) -> Self {
        Self {
            client: YggdrasilClient::with_api(http, api_url),
        }
    }

    pub fn client(&self) -> &YggdrasilClient {
        &self.client
    }

    pub fn offline(username: &str) -> Account {
        let id = random_hex();
        Account {
            access_token: id.clone(),
            client_token: id.clone(),
            uuid: id,
            name: username.to_owned(),
            refresh_token: None,
            user_properties: "{}".to_owned(),
            meta: AccountMeta::offline(AccountType::Mojang, false),
            xbox_account: None,
            profile: AccountProfile::default(),
            client_id: None,
            user_info: None,
        }
    }

    pub async fn login(&self, username: &str, password: Option<&str>) -> Result<Account, Error> {
        let Some(password) = password.filter(|p| !p.is_empty()) else {
            return Ok(Self::offline(username));
        };
        let client_token = random_hex();
        let session = self
            .client
            .authenticate(username, password, &client_token)
            .await?;
        Ok(account_from(session))
    }

    pub async fn refresh(&self, account: &Account) -> Result<Account, Error> {
        let session = self
            .client
            .refresh(&account.access_token, &account.client_token)
            .await?;
        Ok(account_from(session))
    }

    pub async fn validate(&self, account: &Account) -> Result<bool, Error> {
        Ok(self
            .client
            .validate(&account.access_token, &account.client_token)
            .await?)
    }

    pub async fn signout(&self, account: &Account) -> Result<bool, Error> {
        Ok(self
            .client
            .invalidate(&account.access_token, &account.client_token)
            .await?)
    }
}

fn account_from(session: Session) -> Account {
    Account {
        access_token: session.access_token,
        client_token: session.client_token,
        uuid: session.uuid,
        name: session.name,
        refresh_token: None,
        user_properties: "{}".to_owned(),
        meta: AccountMeta::offline(AccountType::Mojang, true),
        xbox_account: None,
        profile: AccountProfile::default(),
        client_id: None,
        user_info: None,
    }
}

fn random_hex() -> String {
    let mut bytes = [0u8; 16];
    rand::fill(&mut bytes);
    bytes.iter().map(|b| format!("{b:02x}")).collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn offline_account_matches_node_shape() {
        let account = Yggdrasil::offline("Steve");
        assert_eq!(account.name, "Steve");
        assert_eq!(account.uuid.len(), 32);
        assert!(account.uuid.chars().all(|c| c.is_ascii_hexdigit()));
        assert_eq!(account.access_token, account.uuid);
        assert_eq!(account.client_token, account.uuid);
        assert_eq!(account.meta.kind, AccountType::Mojang);
        assert_eq!(account.meta.online, Some(false));
        assert!(!account.is_expired());

        let json = serde_json::to_value(&account).unwrap();
        assert_eq!(json["meta"]["type"], "Mojang");
        assert_eq!(json["meta"]["online"], false);
        assert!(json.get("refresh_token").is_none());
        assert!(json.get("xboxAccount").is_none());
        assert_eq!(json["user_properties"], "{}");
        assert_ne!(Yggdrasil::offline("Steve").uuid, account.uuid);
    }

    #[test]
    fn online_session_maps_to_account() {
        let account = account_from(Session {
            access_token: "a".into(),
            client_token: "c".into(),
            uuid: "id".into(),
            name: "Alex".into(),
        });
        assert_eq!(account.meta.online, Some(true));
        assert_eq!(account.meta.kind, AccountType::Mojang);
        assert_eq!(account.uuid, "id");
    }
}