Merge branch 'develop' into icon-indexing

Signed-off-by: Tayou <31988415+TayouVR@users.noreply.github.com>

24 files changed, 269 insertions, 369 deletions

diff --git a/launcher/minecraft/auth/steps/EntitlementsStep.cpp b/launcher/minecraft/auth/steps/EntitlementsStep.cpp
index bd604292..e942db52 100644
--- a/launcher/minecraft/auth/steps/EntitlementsStep.cpp
+++ b/launcher/minecraft/auth/steps/EntitlementsStep.cpp
@@ -11,12 +11,13 @@ EntitlementsStep::EntitlementsStep(AccountData* data) : AuthStep(data) {}
 
 EntitlementsStep::~EntitlementsStep() noexcept = default;
 
-QString EntitlementsStep::describe() {
+QString EntitlementsStep::describe()
+{
     return tr("Determining game ownership.");
 }
 
-
-void EntitlementsStep::perform() {
+void EntitlementsStep::perform()
+{
     auto uuid = QUuid::createUuid();
     m_entitlementsRequestId = uuid.toString().remove('{').remove('}');
     auto url = "https://api.minecraftservices.com/entitlements/license?requestId=" + m_entitlementsRequestId;
@@ -24,22 +25,20 @@ void EntitlementsStep::perform() {
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
     request.setRawHeader("Accept", "application/json");
     request.setRawHeader("Authorization", QString("Bearer %1").arg(m_data->yggdrasilToken.token).toUtf8());
-    AuthRequest *requestor = new AuthRequest(this);
+    AuthRequest* requestor = new AuthRequest(this);
     connect(requestor, &AuthRequest::finished, this, &EntitlementsStep::onRequestDone);
     requestor->get(request);
     qDebug() << "Getting entitlements...";
 }
 
-void EntitlementsStep::rehydrate() {
+void EntitlementsStep::rehydrate()
+{
     // NOOP, for now. We only save bools and there's nothing to check.
 }
 
-void EntitlementsStep::onRequestDone(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+void EntitlementsStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+{
+    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
     requestor->deleteLater();
 
     qCDebug(authCredentials()) << data;
diff --git a/launcher/minecraft/auth/steps/EntitlementsStep.h b/launcher/minecraft/auth/steps/EntitlementsStep.h
index 9412ae79..be16bda1 100644
--- a/launcher/minecraft/auth/steps/EntitlementsStep.h
+++ b/launcher/minecraft/auth/steps/EntitlementsStep.h
@@ -4,12 +4,11 @@
 #include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
 
-
 class EntitlementsStep : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit EntitlementsStep(AccountData *data);
+   public:
+    explicit EntitlementsStep(AccountData* data);
     virtual ~EntitlementsStep() noexcept;
 
     void perform() override;
@@ -17,9 +16,9 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
 
-private:
+   private:
     QString m_entitlementsRequestId;
 };
diff --git a/launcher/minecraft/auth/steps/GetSkinStep.cpp b/launcher/minecraft/auth/steps/GetSkinStep.cpp
index 3521f8dc..52087702 100644
--- a/launcher/minecraft/auth/steps/GetSkinStep.cpp
+++ b/launcher/minecraft/auth/steps/GetSkinStep.cpp
@@ -6,34 +6,32 @@
 #include "minecraft/auth/AuthRequest.h"
 #include "minecraft/auth/Parsers.h"
 
-GetSkinStep::GetSkinStep(AccountData* data) : AuthStep(data) {
-
-}
+GetSkinStep::GetSkinStep(AccountData* data) : AuthStep(data) {}
 
 GetSkinStep::~GetSkinStep() noexcept = default;
 
-QString GetSkinStep::describe() {
+QString GetSkinStep::describe()
+{
     return tr("Getting skin.");
 }
 
-void GetSkinStep::perform() {
+void GetSkinStep::perform()
+{
     auto url = QUrl(m_data->minecraftProfile.skin.url);
     QNetworkRequest request = QNetworkRequest(url);
-    AuthRequest *requestor = new AuthRequest(this);
+    AuthRequest* requestor = new AuthRequest(this);
     connect(requestor, &AuthRequest::finished, this, &GetSkinStep::onRequestDone);
     requestor->get(request);
 }
 
-void GetSkinStep::rehydrate() {
+void GetSkinStep::rehydrate()
+{
     // NOOP, for now.
 }
 
-void GetSkinStep::onRequestDone(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+void GetSkinStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+{
+    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
     requestor->deleteLater();
 
     if (error == QNetworkReply::NoError) {
diff --git a/launcher/minecraft/auth/steps/GetSkinStep.h b/launcher/minecraft/auth/steps/GetSkinStep.h
index 6b97371e..105e497d 100644
--- a/launcher/minecraft/auth/steps/GetSkinStep.h
+++ b/launcher/minecraft/auth/steps/GetSkinStep.h
@@ -4,12 +4,11 @@
 #include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
 
-
 class GetSkinStep : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit GetSkinStep(AccountData *data);
+   public:
+    explicit GetSkinStep(AccountData* data);
     virtual ~GetSkinStep() noexcept;
 
     void perform() override;
@@ -17,6 +16,6 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
 };
diff --git a/launcher/minecraft/auth/steps/LauncherLoginStep.cpp b/launcher/minecraft/auth/steps/LauncherLoginStep.cpp
index 8a26cbe7..c57f5111 100644
--- a/launcher/minecraft/auth/steps/LauncherLoginStep.cpp
+++ b/launcher/minecraft/auth/steps/LauncherLoginStep.cpp
@@ -8,17 +8,17 @@
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
 
-LauncherLoginStep::LauncherLoginStep(AccountData* data) : AuthStep(data) {
-
-}
+LauncherLoginStep::LauncherLoginStep(AccountData* data) : AuthStep(data) {}
 
 LauncherLoginStep::~LauncherLoginStep() noexcept = default;
 
-QString LauncherLoginStep::describe() {
+QString LauncherLoginStep::describe()
+{
     return tr("Accessing Mojang services.");
 }
 
-void LauncherLoginStep::perform() {
+void LauncherLoginStep::perform()
+{
     auto requestURL = "https://api.minecraftservices.com/launcher/login";
     auto uhs = m_data->mojangservicesToken.extra["uhs"].toString();
     auto xToken = m_data->mojangservicesToken.token;
@@ -34,22 +34,20 @@ void LauncherLoginStep::perform() {
     QNetworkRequest request = QNetworkRequest(QUrl(requestURL));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
     request.setRawHeader("Accept", "application/json");
-    AuthRequest *requestor = new AuthRequest(this);
+    AuthRequest* requestor = new AuthRequest(this);
     connect(requestor, &AuthRequest::finished, this, &LauncherLoginStep::onRequestDone);
     requestor->post(request, requestBody.toUtf8());
     qDebug() << "Getting Minecraft access token...";
 }
 
-void LauncherLoginStep::rehydrate() {
+void LauncherLoginStep::rehydrate()
+{
     // TODO: check the token validity
 }
 
-void LauncherLoginStep::onRequestDone(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+void LauncherLoginStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+{
+    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
     requestor->deleteLater();
 
     qCDebug(authCredentials()) << data;
@@ -57,27 +55,17 @@ void LauncherLoginStep::onRequestDone(
         qWarning() << "Reply error:" << error;
         qCDebug(authCredentials()) << data;
         if (Net::isApplicationError(error)) {
-            emit finished(
-                AccountTaskState::STATE_FAILED_SOFT,
-                tr("Failed to get Minecraft access token: %1").arg(requestor->errorString_)
-            );
-        }
-        else {
-            emit finished(
-                AccountTaskState::STATE_OFFLINE,
-                tr("Failed to get Minecraft access token: %1").arg(requestor->errorString_)
-            );
+            emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Failed to get Minecraft access token: %1").arg(requestor->errorString_));
+        } else {
+            emit finished(AccountTaskState::STATE_OFFLINE, tr("Failed to get Minecraft access token: %1").arg(requestor->errorString_));
         }
         return;
     }
 
-    if(!Parsers::parseMojangResponse(data, m_data->yggdrasilToken)) {
+    if (!Parsers::parseMojangResponse(data, m_data->yggdrasilToken)) {
         qWarning() << "Could not parse login_with_xbox response...";
         qCDebug(authCredentials()) << data;
-        emit finished(
-            AccountTaskState::STATE_FAILED_SOFT,
-            tr("Failed to parse the Minecraft access token response.")
-        );
+        emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Failed to parse the Minecraft access token response."));
         return;
     }
     emit finished(AccountTaskState::STATE_WORKING, tr(""));
diff --git a/launcher/minecraft/auth/steps/LauncherLoginStep.h b/launcher/minecraft/auth/steps/LauncherLoginStep.h
index e06a306f..30c18e67 100644
--- a/launcher/minecraft/auth/steps/LauncherLoginStep.h
+++ b/launcher/minecraft/auth/steps/LauncherLoginStep.h
@@ -4,12 +4,11 @@
 #include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
 
-
 class LauncherLoginStep : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit LauncherLoginStep(AccountData *data);
+   public:
+    explicit LauncherLoginStep(AccountData* data);
     virtual ~LauncherLoginStep() noexcept;
 
     void perform() override;
@@ -17,6 +16,6 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
 };
diff --git a/launcher/minecraft/auth/steps/MSAStep.cpp b/launcher/minecraft/auth/steps/MSAStep.cpp
index 6fc8d468..1aa22765 100644
--- a/launcher/minecraft/auth/steps/MSAStep.cpp
+++ b/launcher/minecraft/auth/steps/MSAStep.cpp
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-only
 /*
- *  PolyMC - Minecraft Launcher
+ *  Prism Launcher - Minecraft Launcher
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
  *
  *  This program is free software: you can redistribute it and/or modify
@@ -47,7 +47,8 @@
 using OAuth2 = Katabasis::DeviceFlow;
 using Activity = Katabasis::Activity;
 
-MSAStep::MSAStep(AccountData* data, Action action) : AuthStep(data), m_action(action) {
+MSAStep::MSAStep(AccountData* data, Action action) : AuthStep(data), m_action(action)
+{
     m_clientId = APPLICATION->getMSAClientID();
     OAuth2::Options opts;
     opts.scope = "XboxLive.signin offline_access";
@@ -64,13 +65,14 @@ MSAStep::MSAStep(AccountData* data, Action action) : AuthStep(data), m_action(ac
 
 MSAStep::~MSAStep() noexcept = default;
 
-QString MSAStep::describe() {
+QString MSAStep::describe()
+{
     return tr("Logging in with Microsoft account.");
 }
 
-
-void MSAStep::rehydrate() {
-    switch(m_action) {
+void MSAStep::rehydrate()
+{
+    switch (m_action) {
         case Refresh: {
             // TODO: check the tokens and see if they are old (older than a day)
             return;
@@ -82,12 +84,14 @@ void MSAStep::rehydrate() {
     }
 }
 
-void MSAStep::perform() {
-    switch(m_action) {
+void MSAStep::perform()
+{
+    switch (m_action) {
         case Refresh: {
             if (m_data->msaClientID != m_clientId) {
                 emit hideVerificationUriAndCode();
-                emit finished(AccountTaskState::STATE_DISABLED, tr("Microsoft user authentication failed - client identification has changed."));
+                emit finished(AccountTaskState::STATE_DISABLED,
+                              tr("Microsoft user authentication failed - client identification has changed."));
             }
             m_oauth2->refresh();
             return;
@@ -105,8 +109,9 @@ void MSAStep::perform() {
     }
 }
 
-void MSAStep::onOAuthActivityChanged(Katabasis::Activity activity) {
-    switch(activity) {
+void MSAStep::onOAuthActivityChanged(Katabasis::Activity activity)
+{
+    switch (activity) {
         case Katabasis::Activity::Idle:
         case Katabasis::Activity::LoggingIn:
         case Katabasis::Activity::Refreshing:
diff --git a/launcher/minecraft/auth/steps/MSAStep.h b/launcher/minecraft/auth/steps/MSAStep.h
index e9a1524e..b6635d4a 100644
--- a/launcher/minecraft/auth/steps/MSAStep.h
+++ b/launcher/minecraft/auth/steps/MSAStep.h
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-only
 /*
- *  PolyMC - Minecraft Launcher
+ *  Prism Launcher - Minecraft Launcher
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
  *
  *  This program is free software: you can redistribute it and/or modify
@@ -43,13 +43,11 @@
 
 class MSAStep : public AuthStep {
     Q_OBJECT
-public:
-    enum Action {
-        Refresh,
-        Login
-    };
-public:
-    explicit MSAStep(AccountData *data, Action action);
+   public:
+    enum Action { Refresh, Login };
+
+   public:
+    explicit MSAStep(AccountData* data, Action action);
     virtual ~MSAStep() noexcept;
 
     void perform() override;
@@ -57,11 +55,11 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onOAuthActivityChanged(Katabasis::Activity activity);
 
-private:
-    Katabasis::DeviceFlow *m_oauth2 = nullptr;
+   private:
+    Katabasis::DeviceFlow* m_oauth2 = nullptr;
     Action m_action;
     QString m_clientId;
 };
diff --git a/launcher/minecraft/auth/steps/MigrationEligibilityStep.cpp b/launcher/minecraft/auth/steps/MigrationEligibilityStep.cpp
index f5b5637a..5ce953df 100644
--- a/launcher/minecraft/auth/steps/MigrationEligibilityStep.cpp
+++ b/launcher/minecraft/auth/steps/MigrationEligibilityStep.cpp
@@ -5,37 +5,37 @@
 #include "minecraft/auth/AuthRequest.h"
 #include "minecraft/auth/Parsers.h"
 
-MigrationEligibilityStep::MigrationEligibilityStep(AccountData* data) : AuthStep(data) {
-
-}
+MigrationEligibilityStep::MigrationEligibilityStep(AccountData* data) : AuthStep(data) {}
 
 MigrationEligibilityStep::~MigrationEligibilityStep() noexcept = default;
 
-QString MigrationEligibilityStep::describe() {
+QString MigrationEligibilityStep::describe()
+{
     return tr("Checking for migration eligibility.");
 }
 
-void MigrationEligibilityStep::perform() {
+void MigrationEligibilityStep::perform()
+{
     auto url = QUrl("https://api.minecraftservices.com/rollout/v1/msamigration");
     QNetworkRequest request = QNetworkRequest(url);
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
     request.setRawHeader("Authorization", QString("Bearer %1").arg(m_data->yggdrasilToken.token).toUtf8());
 
-    AuthRequest *requestor = new AuthRequest(this);
+    AuthRequest* requestor = new AuthRequest(this);
     connect(requestor, &AuthRequest::finished, this, &MigrationEligibilityStep::onRequestDone);
     requestor->get(request);
 }
 
-void MigrationEligibilityStep::rehydrate() {
+void MigrationEligibilityStep::rehydrate()
+{
     // NOOP, for now. We only save bools and there's nothing to check.
 }
 
-void MigrationEligibilityStep::onRequestDone(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+void MigrationEligibilityStep::onRequestDone(QNetworkReply::NetworkError error,
+                                             QByteArray data,
+                                             QList<QNetworkReply::RawHeaderPair> headers)
+{
+    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
     requestor->deleteLater();
 
     if (error == QNetworkReply::NoError) {
diff --git a/launcher/minecraft/auth/steps/MigrationEligibilityStep.h b/launcher/minecraft/auth/steps/MigrationEligibilityStep.h
index b1bf9cbf..8638975d 100644
--- a/launcher/minecraft/auth/steps/MigrationEligibilityStep.h
+++ b/launcher/minecraft/auth/steps/MigrationEligibilityStep.h
@@ -4,12 +4,11 @@
 #include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
 
-
 class MigrationEligibilityStep : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit MigrationEligibilityStep(AccountData *data);
+   public:
+    explicit MigrationEligibilityStep(AccountData* data);
     virtual ~MigrationEligibilityStep() noexcept;
 
     void perform() override;
@@ -17,6 +16,6 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
 };
diff --git a/launcher/minecraft/auth/steps/MinecraftProfileStep.cpp b/launcher/minecraft/auth/steps/MinecraftProfileStep.cpp
index 6cfa7c1c..7cdce23f 100644
--- a/launcher/minecraft/auth/steps/MinecraftProfileStep.cpp
+++ b/launcher/minecraft/auth/steps/MinecraftProfileStep.cpp
@@ -7,52 +7,46 @@
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
 
-MinecraftProfileStep::MinecraftProfileStep(AccountData* data) : AuthStep(data) {
-
-}
+MinecraftProfileStep::MinecraftProfileStep(AccountData* data) : AuthStep(data) {}
 
 MinecraftProfileStep::~MinecraftProfileStep() noexcept = default;
 
-QString MinecraftProfileStep::describe() {
+QString MinecraftProfileStep::describe()
+{
     return tr("Fetching the Minecraft profile.");
 }
 
-
-void MinecraftProfileStep::perform() {
+void MinecraftProfileStep::perform()
+{
     auto url = QUrl("https://api.minecraftservices.com/minecraft/profile");
     QNetworkRequest request = QNetworkRequest(url);
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
     request.setRawHeader("Authorization", QString("Bearer %1").arg(m_data->yggdrasilToken.token).toUtf8());
 
-    AuthRequest *requestor = new AuthRequest(this);
+    AuthRequest* requestor = new AuthRequest(this);
     connect(requestor, &AuthRequest::finished, this, &MinecraftProfileStep::onRequestDone);
     requestor->get(request);
 }
 
-void MinecraftProfileStep::rehydrate() {
+void MinecraftProfileStep::rehydrate()
+{
     // NOOP, for now. We only save bools and there's nothing to check.
 }
 
-void MinecraftProfileStep::onRequestDone(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+void MinecraftProfileStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+{
+    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
     requestor->deleteLater();
 
     qCDebug(authCredentials()) << data;
     if (error == QNetworkReply::ContentNotFoundError) {
         // NOTE: Succeed even if we do not have a profile. This is a valid account state.
-        if(m_data->type == AccountType::Mojang) {
+        if (m_data->type == AccountType::Mojang) {
             m_data->minecraftEntitlement.canPlayMinecraft = false;
             m_data->minecraftEntitlement.ownsMinecraft = false;
         }
         m_data->minecraftProfile = MinecraftProfile();
-        emit finished(
-            AccountTaskState::STATE_SUCCEEDED,
-            tr("Account has no Minecraft profile.")
-        );
+        emit finished(AccountTaskState::STATE_SUCCEEDED, tr("Account has no Minecraft profile."));
         return;
     }
     if (error != QNetworkReply::NoError) {
@@ -65,35 +59,24 @@ void MinecraftProfileStep::onRequestDone(
         qWarning() << QString::fromUtf8(data);
 
         if (Net::isApplicationError(error)) {
-            emit finished(
-                AccountTaskState::STATE_FAILED_SOFT,
-                tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_)
-            );
-        }
-        else {
-            emit finished(
-                AccountTaskState::STATE_OFFLINE,
-                tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_)
-            );
+            emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                          tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_));
+        } else {
+            emit finished(AccountTaskState::STATE_OFFLINE,
+                          tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_));
         }
         return;
     }
-    if(!Parsers::parseMinecraftProfile(data, m_data->minecraftProfile)) {
+    if (!Parsers::parseMinecraftProfile(data, m_data->minecraftProfile)) {
         m_data->minecraftProfile = MinecraftProfile();
-        emit finished(
-            AccountTaskState::STATE_FAILED_SOFT,
-            tr("Minecraft Java profile response could not be parsed")
-        );
+        emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Minecraft Java profile response could not be parsed"));
         return;
     }
 
-    if(m_data->type == AccountType::Mojang) {
+    if (m_data->type == AccountType::Mojang) {
         auto validProfile = m_data->minecraftProfile.validity == Katabasis::Validity::Certain;
         m_data->minecraftEntitlement.canPlayMinecraft = validProfile;
         m_data->minecraftEntitlement.ownsMinecraft = validProfile;
     }
-    emit finished(
-        AccountTaskState::STATE_WORKING,
-        tr("Minecraft Java profile acquisition succeeded.")
-    );
+    emit finished(AccountTaskState::STATE_WORKING, tr("Minecraft Java profile acquisition succeeded."));
 }
diff --git a/launcher/minecraft/auth/steps/MinecraftProfileStep.h b/launcher/minecraft/auth/steps/MinecraftProfileStep.h
index 8ef3395c..cb30dab2 100644
--- a/launcher/minecraft/auth/steps/MinecraftProfileStep.h
+++ b/launcher/minecraft/auth/steps/MinecraftProfileStep.h
@@ -4,12 +4,11 @@
 #include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
 
-
 class MinecraftProfileStep : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit MinecraftProfileStep(AccountData *data);
+   public:
+    explicit MinecraftProfileStep(AccountData* data);
     virtual ~MinecraftProfileStep() noexcept;
 
     void perform() override;
@@ -17,6 +16,6 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
 };
diff --git a/launcher/minecraft/auth/steps/MinecraftProfileStepMojang.cpp b/launcher/minecraft/auth/steps/MinecraftProfileStepMojang.cpp
index 8c378588..d035e39a 100644
--- a/launcher/minecraft/auth/steps/MinecraftProfileStepMojang.cpp
+++ b/launcher/minecraft/auth/steps/MinecraftProfileStepMojang.cpp
@@ -7,18 +7,17 @@
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
 
-MinecraftProfileStepMojang::MinecraftProfileStepMojang(AccountData* data) : AuthStep(data) {
-
-}
+MinecraftProfileStepMojang::MinecraftProfileStepMojang(AccountData* data) : AuthStep(data) {}
 
 MinecraftProfileStepMojang::~MinecraftProfileStepMojang() noexcept = default;
 
-QString MinecraftProfileStepMojang::describe() {
+QString MinecraftProfileStepMojang::describe()
+{
     return tr("Fetching the Minecraft profile.");
 }
 
-
-void MinecraftProfileStepMojang::perform() {
+void MinecraftProfileStepMojang::perform()
+{
     if (m_data->minecraftProfile.id.isEmpty()) {
         emit finished(AccountTaskState::STATE_FAILED_HARD, tr("A UUID is required to get the profile."));
         return;
@@ -27,35 +26,32 @@ void MinecraftProfileStepMojang::perform() {
     // use session server instead of profile due to profile endpoint being locked for locked Mojang accounts
     QUrl url = QUrl("https://sessionserver.mojang.com/session/minecraft/profile/" + m_data->minecraftProfile.id);
     QNetworkRequest req = QNetworkRequest(url);
-    AuthRequest *request = new AuthRequest(this);
+    AuthRequest* request = new AuthRequest(this);
     connect(request, &AuthRequest::finished, this, &MinecraftProfileStepMojang::onRequestDone);
     request->get(req);
 }
 
-void MinecraftProfileStepMojang::rehydrate() {
+void MinecraftProfileStepMojang::rehydrate()
+{
     // NOOP, for now. We only save bools and there's nothing to check.
 }
 
-void MinecraftProfileStepMojang::onRequestDone(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+void MinecraftProfileStepMojang::onRequestDone(QNetworkReply::NetworkError error,
+                                               QByteArray data,
+                                               QList<QNetworkReply::RawHeaderPair> headers)
+{
+    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
     requestor->deleteLater();
 
     qCDebug(authCredentials()) << data;
     if (error == QNetworkReply::ContentNotFoundError) {
         // NOTE: Succeed even if we do not have a profile. This is a valid account state.
-        if(m_data->type == AccountType::Mojang) {
+        if (m_data->type == AccountType::Mojang) {
             m_data->minecraftEntitlement.canPlayMinecraft = false;
             m_data->minecraftEntitlement.ownsMinecraft = false;
         }
         m_data->minecraftProfile = MinecraftProfile();
-        emit finished(
-            AccountTaskState::STATE_SUCCEEDED,
-            tr("Account has no Minecraft profile.")
-        );
+        emit finished(AccountTaskState::STATE_SUCCEEDED, tr("Account has no Minecraft profile."));
         return;
     }
     if (error != QNetworkReply::NoError) {
@@ -68,35 +64,24 @@ void MinecraftProfileStepMojang::onRequestDone(
         qWarning() << QString::fromUtf8(data);
 
         if (Net::isApplicationError(error)) {
-            emit finished(
-                AccountTaskState::STATE_FAILED_SOFT,
-                tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_)
-            );
-        }
-        else {
-            emit finished(
-                AccountTaskState::STATE_OFFLINE,
-                tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_)
-            );
+            emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                          tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_));
+        } else {
+            emit finished(AccountTaskState::STATE_OFFLINE,
+                          tr("Minecraft Java profile acquisition failed: %1").arg(requestor->errorString_));
         }
         return;
     }
-    if(!Parsers::parseMinecraftProfileMojang(data, m_data->minecraftProfile)) {
+    if (!Parsers::parseMinecraftProfileMojang(data, m_data->minecraftProfile)) {
         m_data->minecraftProfile = MinecraftProfile();
-        emit finished(
-            AccountTaskState::STATE_FAILED_SOFT,
-            tr("Minecraft Java profile response could not be parsed")
-        );
+        emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Minecraft Java profile response could not be parsed"));
         return;
     }
 
-    if(m_data->type == AccountType::Mojang) {
+    if (m_data->type == AccountType::Mojang) {
         auto validProfile = m_data->minecraftProfile.validity == Katabasis::Validity::Certain;
         m_data->minecraftEntitlement.canPlayMinecraft = validProfile;
         m_data->minecraftEntitlement.ownsMinecraft = validProfile;
     }
-    emit finished(
-        AccountTaskState::STATE_WORKING,
-        tr("Minecraft Java profile acquisition succeeded.")
-    );
+    emit finished(AccountTaskState::STATE_WORKING, tr("Minecraft Java profile acquisition succeeded."));
 }
diff --git a/launcher/minecraft/auth/steps/MinecraftProfileStepMojang.h b/launcher/minecraft/auth/steps/MinecraftProfileStepMojang.h
index e06b30ab..730ec3f6 100644
--- a/launcher/minecraft/auth/steps/MinecraftProfileStepMojang.h
+++ b/launcher/minecraft/auth/steps/MinecraftProfileStepMojang.h
@@ -4,12 +4,11 @@
 #include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
 
-
 class MinecraftProfileStepMojang : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit MinecraftProfileStepMojang(AccountData *data);
+   public:
+    explicit MinecraftProfileStepMojang(AccountData* data);
     virtual ~MinecraftProfileStepMojang() noexcept;
 
     void perform() override;
@@ -17,6 +16,6 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
 };
diff --git a/launcher/minecraft/auth/steps/OfflineStep.cpp b/launcher/minecraft/auth/steps/OfflineStep.cpp
index dc092bfd..bf111abe 100644
--- a/launcher/minecraft/auth/steps/OfflineStep.cpp
+++ b/launcher/minecraft/auth/steps/OfflineStep.cpp
@@ -5,14 +5,17 @@
 OfflineStep::OfflineStep(AccountData* data) : AuthStep(data) {}
 OfflineStep::~OfflineStep() noexcept = default;
 
-QString OfflineStep::describe() {
+QString OfflineStep::describe()
+{
     return tr("Creating offline account.");
 }
 
-void OfflineStep::rehydrate() {
+void OfflineStep::rehydrate()
+{
     // NOOP
 }
 
-void OfflineStep::perform() {
+void OfflineStep::perform()
+{
     emit finished(AccountTaskState::STATE_WORKING, tr("Created offline account."));
 }
diff --git a/launcher/minecraft/auth/steps/OfflineStep.h b/launcher/minecraft/auth/steps/OfflineStep.h
index 436597cd..3bf123d6 100644
--- a/launcher/minecraft/auth/steps/OfflineStep.h
+++ b/launcher/minecraft/auth/steps/OfflineStep.h
@@ -8,8 +8,8 @@
 
 class OfflineStep : public AuthStep {
     Q_OBJECT
-public:
-    explicit OfflineStep(AccountData *data);
+   public:
+    explicit OfflineStep(AccountData* data);
     virtual ~OfflineStep() noexcept;
 
     void perform() override;
diff --git a/launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp b/launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp
index b397b734..c33d7e62 100644
--- a/launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp
+++ b/launcher/minecraft/auth/steps/XboxAuthorizationStep.cpp
@@ -1,33 +1,32 @@
 #include "XboxAuthorizationStep.h"
 
-#include <QNetworkRequest>
-#include <QJsonParseError>
 #include <QJsonDocument>
+#include <QJsonParseError>
+#include <QNetworkRequest>
 
 #include "Logging.h"
 #include "minecraft/auth/AuthRequest.h"
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
 
-XboxAuthorizationStep::XboxAuthorizationStep(AccountData* data, Katabasis::Token *token, QString relyingParty, QString authorizationKind):
-    AuthStep(data),
-    m_token(token),
-    m_relyingParty(relyingParty),
-    m_authorizationKind(authorizationKind)
-{
-}
+XboxAuthorizationStep::XboxAuthorizationStep(AccountData* data, Katabasis::Token* token, QString relyingParty, QString authorizationKind)
+    : AuthStep(data), m_token(token), m_relyingParty(relyingParty), m_authorizationKind(authorizationKind)
+{}
 
 XboxAuthorizationStep::~XboxAuthorizationStep() noexcept = default;
 
-QString XboxAuthorizationStep::describe() {
+QString XboxAuthorizationStep::describe()
+{
     return tr("Getting authorization to access %1 services.").arg(m_authorizationKind);
 }
 
-void XboxAuthorizationStep::rehydrate() {
+void XboxAuthorizationStep::rehydrate()
+{
     // FIXME: check if the tokens are good?
 }
 
-void XboxAuthorizationStep::perform() {
+void XboxAuthorizationStep::perform()
+{
     QString xbox_auth_template = R"XXX(
 {
     "Properties": {
@@ -41,129 +40,98 @@ void XboxAuthorizationStep::perform() {
 }
 )XXX";
     auto xbox_auth_data = xbox_auth_template.arg(m_data->userToken.token, m_relyingParty);
-// http://xboxlive.com
+    // http://xboxlive.com
     QNetworkRequest request = QNetworkRequest(QUrl("https://xsts.auth.xboxlive.com/xsts/authorize"));
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
     request.setRawHeader("Accept", "application/json");
-    AuthRequest *requestor = new AuthRequest(this);
+    AuthRequest* requestor = new AuthRequest(this);
     connect(requestor, &AuthRequest::finished, this, &XboxAuthorizationStep::onRequestDone);
     requestor->post(request, xbox_auth_data.toUtf8());
     qDebug() << "Getting authorization token for " << m_relyingParty;
 }
 
-void XboxAuthorizationStep::onRequestDone(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+void XboxAuthorizationStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+{
+    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
     requestor->deleteLater();
 
     qCDebug(authCredentials()) << data;
     if (error != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << error;
         if (Net::isApplicationError(error)) {
-            if(!processSTSError(error, data, headers)) {
-                emit finished(
-                    AccountTaskState::STATE_FAILED_SOFT,
-                    tr("Failed to get authorization for %1 services. Error %2.").arg(m_authorizationKind, error)
-                );
-            }
-            else {
-                emit finished(
-                    AccountTaskState::STATE_FAILED_SOFT,
-                    tr("Unknown STS error for %1 services: %2").arg(m_authorizationKind, requestor->errorString_)
-                );
+            if (!processSTSError(error, data, headers)) {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("Failed to get authorization for %1 services. Error %2.").arg(m_authorizationKind, error));
+            } else {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("Unknown STS error for %1 services: %2").arg(m_authorizationKind, requestor->errorString_));
             }
-        }
-        else {
-            emit finished(
-                AccountTaskState::STATE_OFFLINE,
-                tr("Failed to get authorization for %1 services: %2").arg(m_authorizationKind, requestor->errorString_)
-            );
+        } else {
+            emit finished(AccountTaskState::STATE_OFFLINE,
+                          tr("Failed to get authorization for %1 services: %2").arg(m_authorizationKind, requestor->errorString_));
         }
         return;
     }
 
     Katabasis::Token temp;
-    if(!Parsers::parseXTokenResponse(data, temp, m_authorizationKind)) {
-        emit finished(
-            AccountTaskState::STATE_FAILED_SOFT,
-            tr("Could not parse authorization response for access to %1 services.").arg(m_authorizationKind)
-        );
+    if (!Parsers::parseXTokenResponse(data, temp, m_authorizationKind)) {
+        emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                      tr("Could not parse authorization response for access to %1 services.").arg(m_authorizationKind));
         return;
     }
 
-    if(temp.extra["uhs"] != m_data->userToken.extra["uhs"]) {
-        emit finished(
-            AccountTaskState::STATE_FAILED_SOFT,
-            tr("Server has changed %1 authorization user hash in the reply. Something is wrong.").arg(m_authorizationKind)
-        );
+    if (temp.extra["uhs"] != m_data->userToken.extra["uhs"]) {
+        emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                      tr("Server has changed %1 authorization user hash in the reply. Something is wrong.").arg(m_authorizationKind));
         return;
     }
-    auto & token = *m_token;
+    auto& token = *m_token;
     token = temp;
 
     emit finished(AccountTaskState::STATE_WORKING, tr("Got authorization to access %1").arg(m_relyingParty));
 }
 
-
-bool XboxAuthorizationStep::processSTSError(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    if(error == QNetworkReply::AuthenticationRequiredError) {
+bool XboxAuthorizationStep::processSTSError(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+{
+    if (error == QNetworkReply::AuthenticationRequiredError) {
         QJsonParseError jsonError;
         QJsonDocument doc = QJsonDocument::fromJson(data, &jsonError);
-        if(jsonError.error) {
+        if (jsonError.error) {
             qWarning() << "Cannot parse error XSTS response as JSON: " << jsonError.errorString();
-            emit finished(
-                AccountTaskState::STATE_FAILED_SOFT,
-                tr("Cannot parse %1 authorization error response as JSON: %2").arg(m_authorizationKind, jsonError.errorString())
-            );
+            emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                          tr("Cannot parse %1 authorization error response as JSON: %2").arg(m_authorizationKind, jsonError.errorString()));
             return true;
         }
 
         int64_t errorCode = -1;
         auto obj = doc.object();
-        if(!Parsers::getNumber(obj.value("XErr"), errorCode)) {
-            emit finished(
-                AccountTaskState::STATE_FAILED_SOFT,
-                tr("XErr element is missing from %1 authorization error response.").arg(m_authorizationKind)
-            );
+        if (!Parsers::getNumber(obj.value("XErr"), errorCode)) {
+            emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                          tr("XErr element is missing from %1 authorization error response.").arg(m_authorizationKind));
             return true;
         }
-        switch(errorCode) {
-            case 2148916233:{
-                emit finished(
-                    AccountTaskState::STATE_FAILED_SOFT,
-                    tr("This Microsoft account does not have an XBox Live profile. Buy the game on %1 first.")
-                        .arg("<a href=\"https://www.minecraft.net/en-us/store/minecraft-java-edition\">minecraft.net</a>")
-                );
+        switch (errorCode) {
+            case 2148916233: {
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("This Microsoft account does not have an XBox Live profile. Buy the game on %1 first.")
+                                  .arg("<a href=\"https://www.minecraft.net/en-us/store/minecraft-java-edition\">minecraft.net</a>"));
                 return true;
             }
             case 2148916235: {
                 // NOTE: this is the Grulovia error
-                emit finished(
-                    AccountTaskState::STATE_FAILED_SOFT,
-                    tr("XBox Live is not available in your country. You've been blocked.")
-                );
+                emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("XBox Live is not available in your country. You've been blocked."));
                 return true;
             }
             case 2148916238: {
                 emit finished(
                     AccountTaskState::STATE_FAILED_SOFT,
                     tr("This Microsoft account is underaged and is not linked to a family.\n\nPlease set up your account according to %1.")
-                        .arg("<a href=\"https://help.minecraft.net/hc/en-us/articles/4403181904525\">help.minecraft.net</a>")
-                );
+                        .arg("<a href=\"https://help.minecraft.net/hc/en-us/articles/4403181904525\">help.minecraft.net</a>"));
                 return true;
             }
             default: {
-                emit finished(
-                    AccountTaskState::STATE_FAILED_SOFT,
-                    tr("XSTS authentication ended with unrecognized error(s):\n\n%1").arg(errorCode)
-                );
+                emit finished(AccountTaskState::STATE_FAILED_SOFT,
+                              tr("XSTS authentication ended with unrecognized error(s):\n\n%1").arg(errorCode));
                 return true;
             }
         }
diff --git a/launcher/minecraft/auth/steps/XboxAuthorizationStep.h b/launcher/minecraft/auth/steps/XboxAuthorizationStep.h
index 31e43bf0..dee24c95 100644
--- a/launcher/minecraft/auth/steps/XboxAuthorizationStep.h
+++ b/launcher/minecraft/auth/steps/XboxAuthorizationStep.h
@@ -4,12 +4,11 @@
 #include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
 
-
 class XboxAuthorizationStep : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit XboxAuthorizationStep(AccountData *data, Katabasis::Token *token, QString relyingParty, QString authorizationKind);
+   public:
+    explicit XboxAuthorizationStep(AccountData* data, Katabasis::Token* token, QString relyingParty, QString authorizationKind);
     virtual ~XboxAuthorizationStep() noexcept;
 
     void perform() override;
@@ -17,18 +16,14 @@ public:
 
     QString describe() override;
 
-private:
-    bool processSTSError(
-        QNetworkReply::NetworkError error,
-        QByteArray data,
-        QList<QNetworkReply::RawHeaderPair> headers
-    );
+   private:
+    bool processSTSError(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers);
 
-private slots:
+   private slots:
     void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
 
-private:
-    Katabasis::Token *m_token;
+   private:
+    Katabasis::Token* m_token;
     QString m_relyingParty;
     QString m_authorizationKind;
 };
diff --git a/launcher/minecraft/auth/steps/XboxProfileStep.cpp b/launcher/minecraft/auth/steps/XboxProfileStep.cpp
index 644c419b..fd2b32cc 100644
--- a/launcher/minecraft/auth/steps/XboxProfileStep.cpp
+++ b/launcher/minecraft/auth/steps/XboxProfileStep.cpp
@@ -8,66 +8,56 @@
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
 
-XboxProfileStep::XboxProfileStep(AccountData* data) : AuthStep(data) {
-
-}
+XboxProfileStep::XboxProfileStep(AccountData* data) : AuthStep(data) {}
 
 XboxProfileStep::~XboxProfileStep() noexcept = default;
 
-QString XboxProfileStep::describe() {
+QString XboxProfileStep::describe()
+{
     return tr("Fetching Xbox profile.");
 }
 
-void XboxProfileStep::rehydrate() {
+void XboxProfileStep::rehydrate()
+{
     // NOOP, for now. We only save bools and there's nothing to check.
 }
 
-void XboxProfileStep::perform() {
+void XboxProfileStep::perform()
+{
     auto url = QUrl("https://profile.xboxlive.com/users/me/profile/settings");
     QUrlQuery q;
-    q.addQueryItem(
-        "settings",
-        "GameDisplayName,AppDisplayName,AppDisplayPicRaw,GameDisplayPicRaw,"
-        "PublicGamerpic,ShowUserAsAvatar,Gamerscore,Gamertag,ModernGamertag,ModernGamertagSuffix,"
-        "UniqueModernGamertag,AccountTier,TenureLevel,XboxOneRep,"
-        "PreferredColor,Location,Bio,Watermarks,"
-        "RealName,RealNameOverride,IsQuarantined"
-    );
+    q.addQueryItem("settings",
+                   "GameDisplayName,AppDisplayName,AppDisplayPicRaw,GameDisplayPicRaw,"
+                   "PublicGamerpic,ShowUserAsAvatar,Gamerscore,Gamertag,ModernGamertag,ModernGamertagSuffix,"
+                   "UniqueModernGamertag,AccountTier,TenureLevel,XboxOneRep,"
+                   "PreferredColor,Location,Bio,Watermarks,"
+                   "RealName,RealNameOverride,IsQuarantined");
     url.setQuery(q);
 
     QNetworkRequest request = QNetworkRequest(url);
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
     request.setRawHeader("Accept", "application/json");
     request.setRawHeader("x-xbl-contract-version", "3");
-    request.setRawHeader("Authorization", QString("XBL3.0 x=%1;%2").arg(m_data->userToken.extra["uhs"].toString(), m_data->xboxApiToken.token).toUtf8());
-    AuthRequest *requestor = new AuthRequest(this);
+    request.setRawHeader("Authorization",
+                         QString("XBL3.0 x=%1;%2").arg(m_data->userToken.extra["uhs"].toString(), m_data->xboxApiToken.token).toUtf8());
+    AuthRequest* requestor = new AuthRequest(this);
     connect(requestor, &AuthRequest::finished, this, &XboxProfileStep::onRequestDone);
     requestor->get(request);
     qDebug() << "Getting Xbox profile...";
 }
 
-void XboxProfileStep::onRequestDone(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+void XboxProfileStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+{
+    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
     requestor->deleteLater();
 
     if (error != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << error;
         qCDebug(authCredentials()) << data;
         if (Net::isApplicationError(error)) {
-            emit finished(
-                AccountTaskState::STATE_FAILED_SOFT,
-                tr("Failed to retrieve the Xbox profile: %1").arg(requestor->errorString_)
-            );
-        }
-        else {
-            emit finished(
-                AccountTaskState::STATE_OFFLINE,
-                tr("Failed to retrieve the Xbox profile: %1").arg(requestor->errorString_)
-            );
+            emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("Failed to retrieve the Xbox profile: %1").arg(requestor->errorString_));
+        } else {
+            emit finished(AccountTaskState::STATE_OFFLINE, tr("Failed to retrieve the Xbox profile: %1").arg(requestor->errorString_));
         }
         return;
     }
diff --git a/launcher/minecraft/auth/steps/XboxProfileStep.h b/launcher/minecraft/auth/steps/XboxProfileStep.h
index 7a0c5873..b8494b6e 100644
--- a/launcher/minecraft/auth/steps/XboxProfileStep.h
+++ b/launcher/minecraft/auth/steps/XboxProfileStep.h
@@ -4,12 +4,11 @@
 #include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
 
-
 class XboxProfileStep : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit XboxProfileStep(AccountData *data);
+   public:
+    explicit XboxProfileStep(AccountData* data);
     virtual ~XboxProfileStep() noexcept;
 
     void perform() override;
@@ -17,6 +16,6 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
 };
diff --git a/launcher/minecraft/auth/steps/XboxUserStep.cpp b/launcher/minecraft/auth/steps/XboxUserStep.cpp
index 842eb60f..61c33a18 100644
--- a/launcher/minecraft/auth/steps/XboxUserStep.cpp
+++ b/launcher/minecraft/auth/steps/XboxUserStep.cpp
@@ -6,22 +6,22 @@
 #include "minecraft/auth/Parsers.h"
 #include "net/NetUtils.h"
 
-XboxUserStep::XboxUserStep(AccountData* data) : AuthStep(data) {
-
-}
+XboxUserStep::XboxUserStep(AccountData* data) : AuthStep(data) {}
 
 XboxUserStep::~XboxUserStep() noexcept = default;
 
-QString XboxUserStep::describe() {
+QString XboxUserStep::describe()
+{
     return tr("Logging in as an Xbox user.");
 }
 
-
-void XboxUserStep::rehydrate() {
+void XboxUserStep::rehydrate()
+{
     // NOOP, for now. We only save bools and there's nothing to check.
 }
 
-void XboxUserStep::perform() {
+void XboxUserStep::perform()
+{
     QString xbox_auth_template = R"XXX(
 {
     "Properties": {
@@ -40,40 +40,31 @@ void XboxUserStep::perform() {
     request.setRawHeader("Accept", "application/json");
     // set contract-verison header (prevent err 400 bad-request?)
     // https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/reference/live/rest/additional/httpstandardheaders
-    request.setRawHeader("x-xbl-contract-version", "1"); 
+    request.setRawHeader("x-xbl-contract-version", "1");
 
-    auto *requestor = new AuthRequest(this);
+    auto* requestor = new AuthRequest(this);
     connect(requestor, &AuthRequest::finished, this, &XboxUserStep::onRequestDone);
     requestor->post(request, xbox_auth_data.toUtf8());
     qDebug() << "First layer of XBox auth ... commencing.";
 }
 
-void XboxUserStep::onRequestDone(
-    QNetworkReply::NetworkError error,
-    QByteArray data,
-    QList<QNetworkReply::RawHeaderPair> headers
-) {
-    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+void XboxUserStep::onRequestDone(QNetworkReply::NetworkError error, QByteArray data, QList<QNetworkReply::RawHeaderPair> headers)
+{
+    auto requestor = qobject_cast<AuthRequest*>(QObject::sender());
     requestor->deleteLater();
 
     if (error != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << error;
         if (Net::isApplicationError(error)) {
-            emit finished(AccountTaskState::STATE_FAILED_SOFT,
-                tr("XBox user authentication failed: %1").arg(requestor->errorString_)
-            );
-        }
-        else {
-            emit finished(
-                AccountTaskState::STATE_OFFLINE,
-                tr("XBox user authentication failed: %1").arg(requestor->errorString_)
-            );
+            emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("XBox user authentication failed: %1").arg(requestor->errorString_));
+        } else {
+            emit finished(AccountTaskState::STATE_OFFLINE, tr("XBox user authentication failed: %1").arg(requestor->errorString_));
         }
         return;
     }
 
     Katabasis::Token temp;
-    if(!Parsers::parseXTokenResponse(data, temp, "UToken")) {
+    if (!Parsers::parseXTokenResponse(data, temp, "UToken")) {
         qWarning() << "Could not parse user authentication response...";
         emit finished(AccountTaskState::STATE_FAILED_SOFT, tr("XBox user authentication response could not be understood."));
         return;
diff --git a/launcher/minecraft/auth/steps/XboxUserStep.h b/launcher/minecraft/auth/steps/XboxUserStep.h
index 83e9405f..e92727a4 100644
--- a/launcher/minecraft/auth/steps/XboxUserStep.h
+++ b/launcher/minecraft/auth/steps/XboxUserStep.h
@@ -4,12 +4,11 @@
 #include "QObjectPtr.h"
 #include "minecraft/auth/AuthStep.h"
 
-
 class XboxUserStep : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit XboxUserStep(AccountData *data);
+   public:
+    explicit XboxUserStep(AccountData* data);
     virtual ~XboxUserStep() noexcept;
 
     void perform() override;
@@ -17,6 +16,6 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
 };
diff --git a/launcher/minecraft/auth/steps/YggdrasilStep.cpp b/launcher/minecraft/auth/steps/YggdrasilStep.cpp
index e1d33172..fdcaa0d6 100644
--- a/launcher/minecraft/auth/steps/YggdrasilStep.cpp
+++ b/launcher/minecraft/auth/steps/YggdrasilStep.cpp
@@ -4,7 +4,8 @@
 #include "minecraft/auth/Parsers.h"
 #include "minecraft/auth/Yggdrasil.h"
 
-YggdrasilStep::YggdrasilStep(AccountData* data, QString password) : AuthStep(data), m_password(password) {
+YggdrasilStep::YggdrasilStep(AccountData* data, QString password) : AuthStep(data), m_password(password)
+{
     m_yggdrasil = new Yggdrasil(m_data, this);
 
     connect(m_yggdrasil, &Task::failed, this, &YggdrasilStep::onAuthFailed);
@@ -14,28 +15,32 @@ YggdrasilStep::YggdrasilStep(AccountData* data, QString password) : AuthStep(dat
 
 YggdrasilStep::~YggdrasilStep() noexcept = default;
 
-QString YggdrasilStep::describe() {
+QString YggdrasilStep::describe()
+{
     return tr("Logging in with Mojang account.");
 }
 
-void YggdrasilStep::rehydrate() {
+void YggdrasilStep::rehydrate()
+{
     // NOOP, for now.
 }
 
-void YggdrasilStep::perform() {
-    if(m_password.size()) {
+void YggdrasilStep::perform()
+{
+    if (m_password.size()) {
         m_yggdrasil->login(m_password);
-    }
-    else {
+    } else {
         m_yggdrasil->refresh();
     }
 }
 
-void YggdrasilStep::onAuthSucceeded() {
+void YggdrasilStep::onAuthSucceeded()
+{
     emit finished(AccountTaskState::STATE_WORKING, tr("Logged in with Mojang"));
 }
 
-void YggdrasilStep::onAuthFailed() {
+void YggdrasilStep::onAuthFailed()
+{
     // TODO: hook these in again, expand to MSA
     // m_error = m_yggdrasil->m_error;
     // m_aborted = m_yggdrasil->m_aborted;
@@ -44,7 +49,7 @@ void YggdrasilStep::onAuthFailed() {
     QString errorMessage = tr("Mojang user authentication failed.");
 
     // NOTE: soft error in the first step means 'offline'
-    if(state == AccountTaskState::STATE_FAILED_SOFT) {
+    if (state == AccountTaskState::STATE_FAILED_SOFT) {
         state = AccountTaskState::STATE_OFFLINE;
         errorMessage = tr("Mojang user authentication ended with a network error.");
     }
diff --git a/launcher/minecraft/auth/steps/YggdrasilStep.h b/launcher/minecraft/auth/steps/YggdrasilStep.h
index ebafb8e5..ef31f34d 100644
--- a/launcher/minecraft/auth/steps/YggdrasilStep.h
+++ b/launcher/minecraft/auth/steps/YggdrasilStep.h
@@ -9,8 +9,8 @@ class Yggdrasil;
 class YggdrasilStep : public AuthStep {
     Q_OBJECT
 
-public:
-    explicit YggdrasilStep(AccountData *data, QString password);
+   public:
+    explicit YggdrasilStep(AccountData* data, QString password);
     virtual ~YggdrasilStep() noexcept;
 
     void perform() override;
@@ -18,11 +18,11 @@ public:
 
     QString describe() override;
 
-private slots:
+   private slots:
     void onAuthSucceeded();
     void onAuthFailed();
 
-private:
-    Yggdrasil *m_yggdrasil = nullptr;
+   private:
+    Yggdrasil* m_yggdrasil = nullptr;
     QString m_password;
 };