crust_core 1.0.3

Core library to download, install and launch Minecraft (versions, assets, libraries, Java runtime, mod loaders)
Documentation
use std::time::Duration;

use serde::{Deserialize, Serialize};

use super::Error;
use crate::foundation::time;
use crate::network::HttpClient;
use crate::providers::microsoft::{DeviceCode, DeviceCodePoll, MicrosoftOAuth, TokenResponse};
use crate::providers::xbox::XboxLive;

const SLOW_DOWN_STEP_SECS: u64 = 5;

#[derive(Debug, Clone)]
pub struct MicrosoftAuthenticator {
    oauth: MicrosoftOAuth,
    xbox: XboxLive,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MicrosoftSession {
    pub access_token: String,
    pub refresh_token: Option<String>,
    pub expires_at: u64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct XboxSession {
    pub user_hash: String,
    pub xbl_token: String,
    pub xsts_token: String,
    pub not_after: String,
    pub xuid: Option<String>,
    pub gamertag: Option<String>,
    pub age_group: Option<String>,
}

impl MicrosoftAuthenticator {
    pub fn new(http: HttpClient, oauth: MicrosoftOAuth) -> Self {
        Self {
            oauth,
            xbox: XboxLive::new(http),
        }
    }

    pub fn oauth(&self) -> &MicrosoftOAuth {
        &self.oauth
    }

    pub fn xbox(&self) -> &XboxLive {
        &self.xbox
    }

    pub async fn request_device_code(&self) -> Result<DeviceCode, Error> {
        Ok(self.oauth.request_device_code().await?)
    }

    pub async fn wait_device_code(&self, code: &DeviceCode) -> Result<MicrosoftSession, Error> {
        let deadline = time::expires_at(code.expires_in);
        let mut interval = code.interval.max(1);
        loop {
            tokio::time::sleep(Duration::from_secs(interval)).await;
            match self.oauth.poll_device_code(&code.device_code).await? {
                DeviceCodePoll::Pending => {}
                DeviceCodePoll::SlowDown => interval += SLOW_DOWN_STEP_SECS,
                DeviceCodePoll::Declined => return Err(Error::DeviceCodeDeclined),
                DeviceCodePoll::Expired => return Err(Error::DeviceCodeExpired),
                DeviceCodePoll::Authorized(token) => return Ok(Self::session(token)),
            }
            if time::is_expired(deadline, 0) {
                return Err(Error::DeviceCodeExpired);
            }
        }
    }

    pub async fn exchange_code(
        &self,
        code: &str,
        redirect_uri: &str,
        code_verifier: Option<&str>,
    ) -> Result<MicrosoftSession, Error> {
        let token = self
            .oauth
            .exchange_code(code, redirect_uri, code_verifier)
            .await?;
        Ok(Self::session(token))
    }

    pub async fn refresh(&self, refresh_token: &str) -> Result<MicrosoftSession, Error> {
        let mut token = self.oauth.refresh_token(refresh_token).await?;
        if token.refresh_token.is_none() {
            token.refresh_token = Some(refresh_token.to_owned());
        }
        Ok(Self::session(token))
    }

    pub async fn xbox_session(&self, microsoft_access_token: &str) -> Result<XboxSession, Error> {
        let xbl = self.xbox.authenticate(microsoft_access_token).await?;
        let xsts = self.xbox.authorize_minecraft(&xbl.token).await?;
        let user_hash = xsts
            .user_hash()
            .or_else(|| xbl.user_hash())
            .ok_or(Error::MissingUserHash)?
            .to_owned();
        let account = self.xbox.authorize_xboxlive(&xbl.token).await?;
        let claim = account.display_claims.xui.first();
        Ok(XboxSession {
            user_hash,
            xbl_token: xbl.token,
            xsts_token: xsts.token,
            not_after: xsts.not_after,
            xuid: claim.and_then(|c| c.xid.clone()),
            gamertag: claim.and_then(|c| c.gtg.clone()),
            age_group: claim.and_then(|c| c.agg.clone()),
        })
    }

    fn session(token: TokenResponse) -> MicrosoftSession {
        MicrosoftSession {
            access_token: token.access_token,
            refresh_token: token.refresh_token,
            expires_at: time::expires_at(token.expires_in),
        }
    }
}