diff --git a/.idea/gradle.xml b/.idea/gradle.xml
index 728dbe2e..25956e96 100644
--- a/.idea/gradle.xml
+++ b/.idea/gradle.xml
@@ -4,11 +4,25 @@
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
+        <compositeConfiguration>
+          <compositeBuild compositeDefinitionSource="SCRIPT">
+            <builds>
+              <build path="$PROJECT_DIR$/buildSrc" name="buildSrc">
+                <projects>
+                  <project path="$PROJECT_DIR$/buildSrc" />
+                </projects>
+              </build>
+            </builds>
+          </compositeBuild>
+        </compositeConfiguration>
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="gradleJvm" value="#JAVA_HOME" />
+        <option name="gradleJvm" value="21" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
+            <option value="$PROJECT_DIR$/buildSrc" />
+            <option value="$PROJECT_DIR$/integration" />
+            <option value="$PROJECT_DIR$/integration/ajqueue" />
             <option value="$PROJECT_DIR$/navauth-api" />
             <option value="$PROJECT_DIR$/navauth-api-examples" />
             <option value="$PROJECT_DIR$/navauth-common" />
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 00000000..49eb1daa
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,45 @@
+
+## 0.2.0
+
+### Changes
+```diff
++ Encryption queue (backpressure especially for Argon2 and BCrypt hashing methods which can lead to OOM killer)
++ Argon2 configuration settings
++ Mojang profile API order (API fallback)
++ MineTools profile API support (preferred one by default)
++ NavAuthAPI.isAuthenticated(UUID) method for checking player auth state
++ AjQueue integration plugin
+```
+
+### Fixes
+- fix register command always using BCrypt instead of the selected algo
+- fix different letter case same username migration
+
+### API
+```diff
++ NavAuthAPI#isAuthenticated(UUID)
+```
+
+### Config
+**General** config:
+```diff
++ encryptionQueueConfig
++ mojangAPIConfig
++ Argon2 settings
+```
+
+**Messages** config:
+```diff
++ unexpectedErrorOccurred
++ processAlreadyInProgressError
++ alreadyTryingToLoginError
++ registeringInfo
++ loggingInInfo
+```
+
+### New integration for AjQueue (as a separate plugin)
+- Automatically adds authenticated players to a configurable AjQueue queue
+- Optionally cancel AjQueue `PreQueueEvent` for unauthenticated players
+
+### Docs
+- AjQueue integration info
diff --git a/README.md b/README.md
index 3689492a..849e5af6 100644
--- a/README.md
+++ b/README.md
@@ -38,6 +38,11 @@ We are working on additional configuration options and other improvements to pre
 - **[Multification](https://navio1430.github.io/NavAuth/docs/configuration/multification.html)**
 - [Migration from other plugins](https://navio1430.github.io/NavAuth/docs/migration/migration.html)
 - [Database type migrations](https://navio1430.github.io/NavAuth/docs/migration/database-type-migration.html)
+- Configurable encryption queue
+- Configurable external Mojang profile API usage
+
+### 🧩 Integrations
+- AjQueue integration 
 
 ### 🔒 In NavAuth password cracking takes more than TWELVE TRILLION (1.2 × 10^13) times longer than in the worst login plugins.
 Cracking the whole database of a bad plugin takes less than a **FEW MINUTES**.
diff --git a/build.gradle.kts b/build.gradle.kts
index 47ca1fb2..8d479c78 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -11,7 +11,7 @@ repositories {
 
 allprojects {
   group = "pl.spcode.navauth"
-  version = "0.1.6-SNAPSHOT"
+  version = "0.2.0-SNAPSHOT"
 }
 
 tasks.register("formatAll") {
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
new file mode 100644
index 00000000..25a82b5a
--- /dev/null
+++ b/buildSrc/build.gradle.kts
@@ -0,0 +1,13 @@
+plugins {
+  `kotlin-dsl`
+  `java-library`
+}
+
+repositories {
+  gradlePluginPortal()
+  mavenCentral()
+}
+
+dependencies {
+  implementation("com.gradleup.shadow:shadow-gradle-plugin:9.2.0")
+}
diff --git a/buildSrc/src/main/kotlin/navauth-shadow.gradle.kts b/buildSrc/src/main/kotlin/navauth-shadow.gradle.kts
new file mode 100644
index 00000000..975abaa9
--- /dev/null
+++ b/buildSrc/src/main/kotlin/navauth-shadow.gradle.kts
@@ -0,0 +1,50 @@
+package buildsrc
+
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
+plugins {
+  id("com.gradleup.shadow")
+}
+
+val relocatePrefix = "pl.spcode.navauth.lib"
+
+tasks.named<ShadowJar>("shadowJar") {
+  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+
+  fun relocatePrefixed(pkg: String) {
+    relocate(pkg, "$relocatePrefix.$pkg")
+  }
+
+  relocate("com.google", "$relocatePrefix.com.google") {
+    exclude("com/google/inject/**")
+    exclude("com/google/gson/**")
+  }
+
+  exclude("com/google/inject/**")
+  exclude("com/google/gson/**")
+
+  exclude("org/slf4j/**")
+
+  relocatePrefixed("kotlin")
+  relocatePrefixed("org.bstats")
+  relocatePrefixed("at.favre")
+  relocatePrefixed("com.eternalcode")
+  relocatePrefixed("com.j256")
+  relocatePrefixed("com.mysql")
+  relocatePrefixed("com.zaxxer")
+  relocatePrefixed("dev.rollczi")
+  relocatePrefixed("eu.okaeri")
+  relocatePrefixed("google.protobuf")
+  relocatePrefixed("jakarta.inject")
+  relocatePrefixed("javax.annotation")
+  relocatePrefixed("org.aopalliance")
+  relocatePrefixed("org.bouncycastle")
+  relocatePrefixed("org.checkerframework")
+  relocatePrefixed("org.h2")
+  relocatePrefixed("org.intellij")
+  relocatePrefixed("org.jetbrains")
+  relocatePrefixed("org.postgresql")
+  // todo make sure we relocate this or something
+//  relocatePrefixed("org.sqlite")
+  relocatePrefixed("org.yaml")
+}
diff --git a/docs/docs/integrations/ajqueue.md b/docs/docs/integrations/ajqueue.md
new file mode 100644
index 00000000..b8eca615
--- /dev/null
+++ b/docs/docs/integrations/ajqueue.md
@@ -0,0 +1,25 @@
+# AjQueue Integration
+
+NavAuth provides a separate plugin that integrates with [AjQueue](https://www.spigotmc.org/resources/ajqueue.99086/), a popular queue management system for Velocity proxy.
+
+## How it Works
+
+The integration plugin listens for NavAuth's `UserAuthenticatedEvent`. When a player successfully authenticates, the plugin automatically adds them to a configurable AjQueue queue.
+
+Additionally, it can optionally cancel AjQueue's `PreQueueEvent` for players who are **not yet authenticated**, preventing unauthenticated players from joining a server through the queue.
+
+## Features
+
+- Automatically adds authenticated players to a specified AjQueue queue
+- Optionally block queue join for unauthenticated players
+- Configurable failure handling (message + optional kick)
+
+## Download
+
+The integration plugin jar is available on the [GitHub releases page](https://github.com/Navio1430/NavAuth).
+
+## Installation
+
+1. Place the `navauth-ajqueue-integration-XXX.jar` in your Velocity server's `plugins/` directory
+2. Ensure both **NavAuth** and **AjQueue** are installed
+3. Restart your proxy
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c7297a4d..5a63b546 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -3,7 +3,7 @@
 velocity-api = "3.4.0-SNAPSHOT"
 # plugins
 shadow = "9.2.0"
-blossom = "1.2.0"
+blossom = "2.2.0"
 spotless = "8.0.0"
 litecommands = "3.10.6"
 
diff --git a/integration/ajqueue/build.gradle.kts b/integration/ajqueue/build.gradle.kts
new file mode 100644
index 00000000..8b5da775
--- /dev/null
+++ b/integration/ajqueue/build.gradle.kts
@@ -0,0 +1,47 @@
+plugins {
+  id("buildsrc.navauth-shadow")
+  id("net.kyori.blossom") version "2.2.0"
+  kotlin("jvm")
+  kotlin("kapt")
+}
+
+val projectName = "navauth-ajqueue-integration"
+
+group = "pl.spcode.navauth"
+version = "1.0.0-SNAPSHOT"
+
+val requiredMinNavAuthVersion = "0.2.0" // always X.Y.Z format
+
+sourceSets {
+  main {
+    blossom {
+      kotlinSources {
+        property("version", project.version.toString())
+        property("requiredMinNavAuthVersion", requiredMinNavAuthVersion)
+      }
+    }
+  }
+}
+
+tasks.shadowJar {
+  destinationDirectory.set(file("../../target"))
+
+  archiveBaseName.set(projectName)
+  archiveClassifier = null
+
+  exclude("kotlin/**")
+  exclude("META-INF/**")
+  exclude("org/jetbrains/**")
+  exclude("org/intellij/**")
+}
+
+repositories {
+  maven { url = uri("https://repo.ajg0702.us/releases") }
+}
+
+dependencies {
+  compileOnly(project(":navauth-common"))
+  compileOnly(libs.velocitypowered.velocity.api)
+  kapt(libs.velocitypowered.velocity.api)
+  compileOnly("us.ajg0702.queue.api:api:2.9.1")
+}
diff --git a/integration/ajqueue/src/main/kotlin-templates/pl/spcode/navauth.integration.ajqueue/BuildParameters.kt.peb b/integration/ajqueue/src/main/kotlin-templates/pl/spcode/navauth.integration.ajqueue/BuildParameters.kt.peb
new file mode 100644
index 00000000..f19e87b4
--- /dev/null
+++ b/integration/ajqueue/src/main/kotlin-templates/pl/spcode/navauth.integration.ajqueue/BuildParameters.kt.peb
@@ -0,0 +1,8 @@
+package pl.spcode.navauth.integration.ajqueue
+
+class BuildParameters {
+  companion object {
+    const val VERSION = "{{ version }}"
+    const val REQUIRED_MIN_NAVAUTH_VERSION = "{{ requiredMinNavAuthVersion }}"
+  }
+}
diff --git a/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/AjQueueIntegrationPlugin.kt b/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/AjQueueIntegrationPlugin.kt
new file mode 100644
index 00000000..8e28365f
--- /dev/null
+++ b/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/AjQueueIntegrationPlugin.kt
@@ -0,0 +1,102 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.integration.ajqueue
+
+import com.google.inject.Inject
+import com.google.inject.Injector
+import com.velocitypowered.api.event.Subscribe
+import com.velocitypowered.api.event.proxy.ProxyInitializeEvent
+import com.velocitypowered.api.plugin.Dependency
+import com.velocitypowered.api.plugin.Plugin
+import com.velocitypowered.api.plugin.annotation.DataDirectory
+import com.velocitypowered.api.proxy.ProxyServer
+import java.nio.file.Path
+import net.kyori.adventure.text.Component
+import org.slf4j.Logger
+import pl.spcode.navauth.api.NavAuthAPI
+import pl.spcode.navauth.common.module.YamlConfigModule
+import pl.spcode.navauth.common.shared.utils.VersionUtils
+import pl.spcode.navauth.integration.ajqueue.config.GeneralConfig
+import pl.spcode.navauth.integration.ajqueue.listener.AjQueueListeners
+import pl.spcode.navauth.integration.ajqueue.listener.NavAuthListeners
+
+@Plugin(
+  id = "navauth-ajqueue",
+  name = "NavAuth AJQueue Integration",
+  version = BuildParameters.VERSION,
+  dependencies = [Dependency(id = "navauth"), Dependency(id = "ajqueue")],
+  authors = ["Navio1430"],
+)
+class AjQueueIntegrationPlugin
+@Inject
+constructor(
+  val parentInjector: Injector,
+  @param:DataDirectory val dataDirectory: Path,
+  val logger: Logger,
+  val proxyServer: ProxyServer,
+) {
+
+  @Subscribe
+  fun onProxyInitializeEvent(event: ProxyInitializeEvent) {
+    try {
+      logger.info("Initializing NavAuth AJQueue integration...")
+
+      val navAuthVersion =
+        VersionUtils.parseVersion(
+          proxyServer.pluginManager
+            .getPlugin("navauth")
+            .orElseThrow { RuntimeException("NavAuth plugin not found") }
+            .description
+            .version
+            .get()
+        )
+      val requiredVersion = VersionUtils.parseVersion(BuildParameters.REQUIRED_MIN_NAVAUTH_VERSION)
+
+      if (VersionUtils.isVersionOlderThan(navAuthVersion, requiredVersion)) {
+        logger.error(
+          """
+          |NavAuth version {} is too old. Required minimum version is {}.
+          |Please update NavAuth to at least version {}.
+          |Download the latest version from: https://github.com/Navio1430/NavAuth"""
+            .trimMargin(),
+          navAuthVersion,
+          requiredVersion,
+          requiredVersion,
+        )
+        return
+      }
+
+      val configModule =
+        YamlConfigModule(GeneralConfig::class, dataDirectory.resolve("config.yml").toFile())
+
+      val childInjector = parentInjector.createChildInjector(configModule)
+
+      val eventBus = NavAuthAPI.getInstance().eventBus
+      eventBus.register(childInjector.getInstance(NavAuthListeners::class.java))
+
+      val ajQueueListeners = childInjector.getInstance(AjQueueListeners::class.java)
+      ajQueueListeners.registerAll()
+
+      logger.info("NavAuth AJQueue integration initialized successfully")
+    } catch (ex: Exception) {
+      logger.error("Failed to initialize NavAuth AJQueue integration", ex)
+      proxyServer.shutdown(Component.text("Failed to initialize NavAuth AJQueue integration"))
+    }
+  }
+}
diff --git a/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/config/GeneralConfig.kt b/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/config/GeneralConfig.kt
new file mode 100644
index 00000000..8b034fd4
--- /dev/null
+++ b/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/config/GeneralConfig.kt
@@ -0,0 +1,38 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.integration.ajqueue.config
+
+import eu.okaeri.configs.OkaeriConfig
+import eu.okaeri.configs.annotation.Comment
+import pl.spcode.navauth.common.component.TextComponent
+
+class GeneralConfig : OkaeriConfig() {
+
+  @Comment("Name of the ajQueue queue to send authenticated players to")
+  var queueName: String = "lobby"
+
+  @Comment("Message sent when adding player to queue fails")
+  var queueAddFailMessage: TextComponent = TextComponent("<red>Failed to add you to the queue!")
+
+  @Comment("Whether to kick the player if adding them to the queue fails")
+  var kickOnQueueAddFail: Boolean = false
+
+  @Comment("Whether to cancel the AjQueue PreQueueEvent if the player is not authenticated yet")
+  var cancelQueueJoinEventIfNotAuth: Boolean = false
+}
diff --git a/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/listener/AjQueueListeners.kt b/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/listener/AjQueueListeners.kt
new file mode 100644
index 00000000..622f3cfb
--- /dev/null
+++ b/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/listener/AjQueueListeners.kt
@@ -0,0 +1,47 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.integration.ajqueue.listener
+
+import com.google.inject.Inject
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import pl.spcode.navauth.api.NavAuthAPI
+import pl.spcode.navauth.integration.ajqueue.config.GeneralConfig
+import us.ajg0702.queue.api.AjQueueAPI
+import us.ajg0702.queue.api.events.PreQueueEvent
+
+class AjQueueListeners @Inject constructor(val config: GeneralConfig) {
+
+  private val logger: Logger = LoggerFactory.getLogger(javaClass)
+
+  fun registerAll() {
+    registerAjQueuePreQueueListener()
+  }
+
+  private fun registerAjQueuePreQueueListener() {
+    AjQueueAPI.getInstance().listen(PreQueueEvent::class.java) { event ->
+      if (!config.cancelQueueJoinEventIfNotAuth) return@listen
+
+      if (!NavAuthAPI.getInstance().isAuthenticated(event.player.uniqueId)) {
+        event.isCancelled = true
+        logger.debug("Cancelled PreQueueEvent for unauthenticated player {}", event.player.name)
+      }
+    }
+  }
+}
diff --git a/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/listener/NavAuthListeners.kt b/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/listener/NavAuthListeners.kt
new file mode 100644
index 00000000..8dcc8b72
--- /dev/null
+++ b/integration/ajqueue/src/main/kotlin/pl/spcode/navauth/integration/ajqueue/listener/NavAuthListeners.kt
@@ -0,0 +1,61 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.integration.ajqueue.listener
+
+import com.google.inject.Inject
+import com.velocitypowered.api.proxy.ProxyServer
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import pl.spcode.navauth.api.event.NavAuthEventListener
+import pl.spcode.navauth.api.event.Subscribe
+import pl.spcode.navauth.api.event.user.UserAuthenticatedEvent
+import pl.spcode.navauth.integration.ajqueue.config.GeneralConfig
+import us.ajg0702.queue.api.AjQueueAPI
+
+class NavAuthListeners
+@Inject
+constructor(val config: GeneralConfig, val proxyServer: ProxyServer) : NavAuthEventListener {
+
+  private val logger: Logger = LoggerFactory.getLogger(javaClass)
+
+  @Subscribe
+  fun onUserAuthenticatedEvent(event: UserAuthenticatedEvent) {
+    val authPlayer = event.player
+    val player = proxyServer.getPlayer(authPlayer.identifier).get()
+    val queueName = config.queueName
+
+    if (queueName.isBlank()) {
+      return
+    }
+
+    val api = AjQueueAPI.getInstance()
+    val adaptedPlayer = api.platformMethods.getPlayer(authPlayer.identifier)
+
+    val added = api.queueManager.addToQueue(adaptedPlayer, queueName)
+
+    if (!added) {
+      logger.warn("Failed to add player {} to queue {}", player, queueName)
+      player.sendMessage(config.queueAddFailMessage.toComponent())
+
+      if (config.kickOnQueueAddFail) {
+        player.disconnect(config.queueAddFailMessage.toComponent())
+      }
+    }
+  }
+}
diff --git a/navauth-api/src/main/java/pl/spcode/navauth/api/NavAuthAPI.java b/navauth-api/src/main/java/pl/spcode/navauth/api/NavAuthAPI.java
index c90d3638..8d4f5db5 100644
--- a/navauth-api/src/main/java/pl/spcode/navauth/api/NavAuthAPI.java
+++ b/navauth-api/src/main/java/pl/spcode/navauth/api/NavAuthAPI.java
@@ -18,6 +18,7 @@
 
 package pl.spcode.navauth.api;
 
+import java.util.UUID;
 import pl.spcode.navauth.api.event.NavAuthEventBus;
 
 public abstract class NavAuthAPI {
@@ -30,6 +31,8 @@ public NavAuthEventBus getEventBus() {
     return provideEventBus();
   }
 
+  public abstract boolean isAuthenticated(UUID playerUuid);
+
   public static NavAuthAPI getInstance() {
     return instance;
   }
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/auth/username/UsernameResolutionService.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/auth/username/UsernameResolutionService.kt
index 6d200dc9..6a0043e8 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/auth/username/UsernameResolutionService.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/auth/username/UsernameResolutionService.kt
@@ -19,7 +19,7 @@
 package pl.spcode.navauth.common.application.auth.username
 
 import com.google.inject.Inject
-import pl.spcode.navauth.common.application.mojang.MojangProfileService
+import pl.spcode.navauth.common.application.mojang.ProfileService
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.application.user.UsernameAlreadyTakenException
 import pl.spcode.navauth.common.domain.auth.handshake.EncryptionType
@@ -28,10 +28,7 @@ import pl.spcode.navauth.common.domain.user.Username
 
 class UsernameResolutionService
 @Inject
-constructor(
-  private val userService: UserService,
-  private val profileService: MojangProfileService,
-) {
+constructor(private val userService: UserService, private val profileService: ProfileService) {
 
   fun resolveUsernameConflicts(
     connUsername: Username,
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/CredentialsHasher.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/CredentialsHasher.kt
similarity index 90%
rename from navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/CredentialsHasher.kt
rename to navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/CredentialsHasher.kt
index 96cb7a9b..6357081f 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/CredentialsHasher.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/CredentialsHasher.kt
@@ -1,6 +1,6 @@
 /*
  * NavAuth
- * Copyright © 2025 Oliwier Fijas (Navio1430)
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
  *
  * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
  * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
@@ -16,7 +16,7 @@
  *
  */
 
-package pl.spcode.navauth.common.infra.crypto.hasher
+package pl.spcode.navauth.common.application.credentials
 
 import pl.spcode.navauth.common.infra.crypto.HashedPassword
 import pl.spcode.navauth.common.infra.crypto.PasswordHash
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/CredentialsHasherFactory.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/CredentialsHasherFactory.kt
index 89558d8e..843036cc 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/CredentialsHasherFactory.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/CredentialsHasherFactory.kt
@@ -23,7 +23,6 @@ import pl.spcode.navauth.common.config.PasswordsConfig
 import pl.spcode.navauth.common.domain.credentials.HashingAlgorithm
 import pl.spcode.navauth.common.infra.crypto.hasher.Argon2CredentialsHasher
 import pl.spcode.navauth.common.infra.crypto.hasher.BCryptCredentialsHasher
-import pl.spcode.navauth.common.infra.crypto.hasher.CredentialsHasher
 import pl.spcode.navauth.common.infra.crypto.hasher.LibreLoginSHACredentialsHasher
 import pl.spcode.navauth.common.infra.crypto.hasher.SHACredentialsHasher
 
@@ -32,19 +31,30 @@ class CredentialsHasherFactory @Inject constructor(val passwordsConfig: Password
   fun createDefaultHasher(): CredentialsHasher {
     return when (passwordsConfig.hashingAlgorithm) {
       HashingAlgorithm.BCRYPT -> BCryptCredentialsHasher()
-      HashingAlgorithm.ARGON2 -> Argon2CredentialsHasher()
-      else -> throw IllegalArgumentException()
+      HashingAlgorithm.ARGON2 -> argon2Hasher()
+      else ->
+        throw IllegalArgumentException(
+          "Hashing algorithm not supported: ${passwordsConfig.hashingAlgorithm}! Supported hashing algorithms: ${HashingAlgorithm.entries.joinToString(", ")}"
+        )
     }
   }
 
   fun createHasher(algo: HashingAlgorithm): CredentialsHasher {
     return when (algo) {
       HashingAlgorithm.BCRYPT -> BCryptCredentialsHasher()
-      HashingAlgorithm.ARGON2 -> Argon2CredentialsHasher()
+      HashingAlgorithm.ARGON2 -> argon2Hasher()
       HashingAlgorithm.SHA256,
       HashingAlgorithm.SHA512 -> SHACredentialsHasher()
       HashingAlgorithm.LIBRELOGIN_SHA256,
       HashingAlgorithm.LIBRELOGIN_SHA512 -> LibreLoginSHACredentialsHasher()
     }
   }
+
+  private fun argon2Hasher() =
+    Argon2CredentialsHasher(
+      hashLength = passwordsConfig.argon2.hashLength,
+      memoryKb = passwordsConfig.argon2.memoryKb,
+      iterations = passwordsConfig.argon2.iterations,
+      parallelism = passwordsConfig.argon2.parallelism,
+    )
 }
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/UserCredentialsService.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/UserCredentialsService.kt
index b86ab1e4..a1632650 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/UserCredentialsService.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/UserCredentialsService.kt
@@ -20,6 +20,12 @@ package pl.spcode.navauth.common.application.credentials
 
 import com.google.inject.Inject
 import com.google.inject.Singleton
+import java.util.UUID
+import java.util.concurrent.CancellationException
+import java.util.concurrent.CompletableFuture
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionQueueService
 import pl.spcode.navauth.common.domain.common.TransactionService
 import pl.spcode.navauth.common.domain.credentials.UserCredentials
 import pl.spcode.navauth.common.domain.credentials.UserCredentialsRepository
@@ -34,8 +40,11 @@ constructor(
   val credentialsRepository: UserCredentialsRepository,
   val transactionService: TransactionService,
   val credentialsHasherFactory: CredentialsHasherFactory,
+  val encryptionQueueService: EncryptionQueueService,
 ) {
 
+  private val logger: Logger = LoggerFactory.getLogger(javaClass)
+
   fun findCredentials(user: User): UserCredentials? {
     return credentialsRepository.findByUser(user)
   }
@@ -72,18 +81,75 @@ constructor(
     credentialsRepository.deleteByUser(user)
   }
 
-  /** @param password the raw (not hashed) password */
-  fun verifyPassword(credentials: UserCredentials, password: String): Boolean {
-    require(credentials.hashedPassword != null) { "credentials do not have a password hash" }
+  /**
+   * @param password the raw (not hashed) password
+   * @throws
+   *   pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
+   *   if task is already queued
+   */
+  fun enqueueVerifyPassword(
+    credentials: UserCredentials,
+    password: String,
+    playerId: UUID,
+  ): CompletableFuture<Boolean> {
+    require(credentials.hashedPassword != null) { "credentials must have password hash" }
 
     val passwordHash = credentials.hashedPassword.passwordHash
     val hasher = credentialsHasherFactory.createHasher(credentials.hashedPassword.algo)
 
-    return hasher.verify(password, passwordHash)
+    val future = CompletableFuture<Boolean>()
+    encryptionQueueService.submitTask(
+      playerId = playerId,
+      operation = {
+        try {
+          val result = hasher.verify(password, passwordHash)
+          future.complete(result)
+        } catch (ex: Exception) {
+          logger.error(
+            "Unexpected error occurred while trying to verify user id='${playerId}' password",
+            ex,
+          )
+          future.completeExceptionally(ex)
+        }
+      },
+      onCancelled = {
+        future.completeExceptionally(
+          CancellationException("Password verification task was cancelled")
+        )
+      },
+    )
+    return future
   }
 
-  fun hashPassword(password: String): HashedPassword {
-    return credentialsHasherFactory.createDefaultHasher().hash(password)
+  /**
+   * @param password the raw (not hashed) password
+   * @param playerId the id of the player for queue tracking
+   * @throws
+   *   pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
+   *   if task is already queued
+   */
+  fun enqueueHashPassword(password: String, playerId: UUID): CompletableFuture<HashedPassword> {
+    val hasher = credentialsHasherFactory.createDefaultHasher()
+    val future = CompletableFuture<HashedPassword>()
+    encryptionQueueService.submitTask(
+      playerId = playerId,
+      operation = {
+        try {
+          val result = hasher.hash(password)
+          future.complete(result)
+        } catch (ex: Exception) {
+          logger.error(
+            "Unexpected error occurred while trying to hash password for player id='${playerId}'",
+            ex,
+          )
+          future.completeExceptionally(ex)
+        }
+      },
+      onCancelled = {
+        future.completeExceptionally(CancellationException("Password hash task was cancelled"))
+      },
+    )
+    return future
   }
 
   fun verifyCode(credentials: UserCredentials, code: String): Boolean {
@@ -99,12 +165,12 @@ constructor(
    * @param newPassword the new raw password to be hashed and stored
    */
   fun updatePassword(user: User, newPassword: String) {
+    val hashedPassword = enqueueHashPassword(newPassword, user.uuid.value).join()
+
     transactionService.inTransaction {
       val credentials = findCredentials(user)
       require(credentials != null) { "user does not have credentials" }
 
-      val hasher = credentialsHasherFactory.createDefaultHasher()
-      val hashedPassword = hasher.hash(newPassword)
       val newCredentials = credentials.withNewPassword(hashedPassword)
       storeUserCredentials(user, newCredentials)
     }
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/queue/EncryptionQueueService.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/queue/EncryptionQueueService.kt
new file mode 100644
index 00000000..a6c2d906
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/queue/EncryptionQueueService.kt
@@ -0,0 +1,34 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.application.credentials.queue
+
+import java.util.UUID
+
+interface EncryptionQueueService {
+
+  /**
+   * @param onCancelled called when the task is dequeued before execution
+   * @throws EncryptionTaskAlreadyQueuedException if player has existing task queued
+   */
+  fun submitTask(playerId: UUID, operation: () -> Unit, onCancelled: () -> Unit)
+
+  fun dequeueTask(playerId: UUID): Boolean
+
+  fun isTaskQueued(playerId: UUID): Boolean
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/queue/EncryptionTask.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/queue/EncryptionTask.kt
new file mode 100644
index 00000000..9e65a717
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/queue/EncryptionTask.kt
@@ -0,0 +1,39 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.application.credentials.queue
+
+import java.util.UUID
+
+class EncryptionTask(
+  val playerId: UUID?,
+  private val operation: () -> Unit,
+  val onCancelled: () -> Unit,
+) : Runnable {
+
+  @Volatile var cancelled = false
+
+  override fun run() {
+    if (cancelled) {
+      onCancelled.invoke()
+      return
+    }
+
+    operation()
+  }
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/queue/EncryptionTaskAlreadyQueuedException.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/queue/EncryptionTaskAlreadyQueuedException.kt
new file mode 100644
index 00000000..326c9b8a
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/credentials/queue/EncryptionTaskAlreadyQueuedException.kt
@@ -0,0 +1,21 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.application.credentials.queue
+
+class EncryptionTaskAlreadyQueuedException : Exception()
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/mojang/ProfileService.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/mojang/ProfileService.kt
new file mode 100644
index 00000000..ad27cca4
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/mojang/ProfileService.kt
@@ -0,0 +1,26 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.application.mojang
+
+import pl.spcode.navauth.common.domain.mojang.MojangProfile
+import pl.spcode.navauth.common.domain.user.Username
+
+interface ProfileService {
+  fun fetchProfileInfo(usernameCaseIgnored: Username): MojangProfile?
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/user/UserService.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/user/UserService.kt
index 2d2c9711..fe86d18f 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/user/UserService.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/user/UserService.kt
@@ -25,7 +25,7 @@ import pl.spcode.navauth.api.event.user.UserNonPremiumMigrationEvent
 import pl.spcode.navauth.api.event.user.UserPremiumMigrationEvent
 import pl.spcode.navauth.api.event.user.UserUsernameMigrationEvent
 import pl.spcode.navauth.common.application.credentials.UserCredentialsService
-import pl.spcode.navauth.common.application.mojang.MojangProfileService
+import pl.spcode.navauth.common.application.mojang.ProfileService
 import pl.spcode.navauth.common.domain.common.TransactionService
 import pl.spcode.navauth.common.domain.credentials.TOTPSecret
 import pl.spcode.navauth.common.domain.credentials.UserCredentials
@@ -43,7 +43,7 @@ class UserService
 constructor(
   val userRepository: UserRepository,
   val userCredentialsService: UserCredentialsService,
-  val profileService: MojangProfileService,
+  val profileService: ProfileService,
   val txService: TransactionService,
   val eventBus: NavAuthEventBus,
 ) {
@@ -105,10 +105,7 @@ constructor(
         val requireCredentials = credentials.isTwoFactorEnabled
         val premiumUser = User.premium(user.uuid, user.username, mojangId, requireCredentials)
 
-        val status = userRepository.save(premiumUser)
-        status.isCreated
-        status.isUpdated
-        status.numLinesChanged
+        userRepository.save(premiumUser)
         if (requireCredentials) {
           val newCredentials = credentials.withoutPassword()
           userCredentialsService.storeUserCredentials(premiumUser, newCredentials)
@@ -220,7 +217,8 @@ constructor(
     if (user.username == newUsername) throw IllegalArgumentException("username cannot be the same")
 
     val conflictingUser = userRepository.findByUsernameIgnoreCase(newUsername.value)
-    if (conflictingUser != null) throw UsernameAlreadyTakenException("username already taken")
+    if (conflictingUser != null && conflictingUser.uuid != user.uuid)
+      throw UsernameAlreadyTakenException("username already taken")
 
     val newUser = user.withNewUsername(newUsername)
     userRepository.save(newUser)
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/EncryptionQueueConfig.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/EncryptionQueueConfig.kt
new file mode 100644
index 00000000..cfd094fa
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/EncryptionQueueConfig.kt
@@ -0,0 +1,39 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.config
+
+import eu.okaeri.configs.OkaeriConfig
+import eu.okaeri.configs.annotation.Comment
+
+class EncryptionQueueConfig : OkaeriConfig() {
+
+  @Comment(
+    "Minimum (core) number of threads kept alive in the encryption thread pool even when idle.",
+    "These threads handle password hashing and verification.",
+    "(Bcrypt and Argon2 are very memory-intensive. 2-4 is a safe range.)",
+  )
+  var encryptionQueueMinThreads: Int = 2
+
+  @Comment(
+    "Maximum number of threads the encryption pool can grow to under load.",
+    "Extra threads are created only when the work queue is full.",
+    "Set higher if you have a powerful server with many concurrent registrations/logins.",
+  )
+  var encryptionQueueMaxThreads: Int = 4
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/GeneralConfig.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/GeneralConfig.kt
index a9c70b87..6336db34 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/GeneralConfig.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/GeneralConfig.kt
@@ -70,6 +70,11 @@ open class GeneralConfig : OkaeriConfig() {
 
   @Comment("Passwords config") var passwordsConfig: PasswordsConfig = PasswordsConfig()
 
+  @Comment(
+    "Encryption queue config - limits concurrent encryption operations (especially bcrypt/argon2) to prevent OOM"
+  )
+  var encryptionQueueConfig: EncryptionQueueConfig = EncryptionQueueConfig()
+
   @Comment(
     "When a non-premium user tries to join with a premium nickname,",
     "an 'invalid session' error occurs. This is default Minecraft behavior.",
@@ -86,6 +91,9 @@ open class GeneralConfig : OkaeriConfig() {
   )
   var descriptiveInvalidSessionCacheTimeMs = 8000
 
+  @Comment("Mojang API and profile resolution config")
+  var mojangAPIConfig: MojangAPIConfig = MojangAPIConfig()
+
   var sessionsConfig = SessionsConfig()
 
   @Variable("CONFIG_VERSION")
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/MessagesConfig.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/MessagesConfig.kt
index 20611a33..021898c6 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/MessagesConfig.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/MessagesConfig.kt
@@ -87,6 +87,10 @@ open class MessagesConfig : OkaeriConfig() {
 
   class NoticesConfig : OkaeriConfig() {
 
+    val unexpectedErrorOccurred: Notice = Notice.chat("<red>An unexpected error occurred.")
+    var processAlreadyInProgressError: Notice =
+      Notice.chat("<red>Process is already in progress. Please wait...")
+
     var passwordRequiredError: Notice = Notice.chat("<red>Please provide your current password.")
     var twoFactorAlreadyEnabledError: Notice =
       Notice.chat("<red>Your account has 2FA enabled already!")
@@ -107,6 +111,11 @@ open class MessagesConfig : OkaeriConfig() {
     var accountAlreadyPremiumError: Notice =
       Notice.chat("<red>Account is already set as a premium one.")
 
+    var alreadyTryingToLoginError: Notice =
+      Notice.chat(
+        "<red>You're already trying to login, please wait for login result before next retry."
+      )
+
     var registerPasswordInvalidError: Notice =
       Notice.chat(
         "<red>The password is invalid. It must be at least 5 characters long and contain at least one uppercase letter and one digit."
@@ -119,9 +128,11 @@ open class MessagesConfig : OkaeriConfig() {
       Notice.chat("<green>Please login using \"/2fa <code>\" command.</green>")
     var loginPasswordAndTwoFactorInstruction: Notice =
       Notice.chat("<green>Please login using \"/login <password> <2fa_code>\" command.</green>")
+    var loggingInInfo: Notice = Notice.chat("<yellow>Logging in, please wait...</yellow>")
 
     var registerInstruction: Notice =
       Notice.chat("<green>Please register using /register command.</green>")
+    var registeringInfo: Notice = Notice.chat("<yellow>Registering, please wait...</yellow>")
 
     var loginSuccess: Notice =
       Notice.chat("<green>You have been authenticated successfully.</green>")
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/MojangAPIConfig.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/MojangAPIConfig.kt
new file mode 100644
index 00000000..6ccbb71d
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/MojangAPIConfig.kt
@@ -0,0 +1,39 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.config
+
+import eu.okaeri.configs.OkaeriConfig
+import eu.okaeri.configs.annotation.Comment
+import java.time.Duration
+import pl.spcode.navauth.common.domain.mojang.MojangProfileApi
+
+class MojangAPIConfig : OkaeriConfig() {
+
+  @Comment("How long to cache resolved Mojang profiles before re-fetching")
+  var profileCacheTTL: Duration = Duration.ofMinutes(5)
+
+  @Comment(
+    "Order of API providers to use when resolving a Mojang profile.",
+    "Available providers: MINETOOLS, MOJANG",
+    "The first provider in this list that returns a result will be used.",
+  )
+  var apiOrder: List<MojangProfileApi> = listOf(MojangProfileApi.MINETOOLS, MojangProfileApi.MOJANG)
+
+  @Comment("Timeout for each individual API call") var apiTimeout: Duration = Duration.ofSeconds(5)
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/PasswordsConfig.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/PasswordsConfig.kt
index 63781c68..316d6a8e 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/PasswordsConfig.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/config/PasswordsConfig.kt
@@ -31,6 +31,25 @@ class PasswordsConfig : OkaeriConfig() {
   )
   var hashingAlgorithm: HashingAlgorithm = HashingAlgorithm.BCRYPT
 
+  @Comment(
+    "Argon2 settings — used only when hashingAlgorithm is set to ARGON2.",
+    "Leave these unchanged unless you know what you're doing.",
+    "Changing any of these properties can significantly increase CPU usage or reduce security.",
+    "Default Argon version: Argon2ID",
+    "Default salt bytes: 16",
+  )
+  var argon2: Argon2Config = Argon2Config()
+
+  class Argon2Config : OkaeriConfig() {
+    @Comment("Hash length in bytes", "default: 16") var hashLength: Int = 16
+
+    @Comment("Memory cost in KB", "default: 65536 = 64 MiB") var memoryKb: Int = 65536
+
+    @Comment("Time cost (iterations)", "default: 3") var iterations: Int = 3
+
+    @Comment("Parallelism (threads)", "default: 4") var parallelism: Int = 4
+  }
+
   @Comment("Minimum length") var minLength: Int = 5
 
   @Comment("Require uppercase letters?") var requireUppercase: Boolean = false
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/domain/auth/session/AuthSession.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/domain/auth/session/AuthSession.kt
index 50a625a5..73b445b5 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/domain/auth/session/AuthSession.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/domain/auth/session/AuthSession.kt
@@ -40,6 +40,7 @@ abstract class AuthSession<T : PlayerAdapter>(val playerAdapter: T, val eventBus
     private set
 
   fun authenticate() {
+    if (!playerAdapter.isOnline()) return
     isAuthenticated = true
     state = AuthSessionState.AUTHENTICATED
     eventBus as NavAuthEventBusInternal
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/domain/mojang/MojangProfile.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/domain/mojang/MojangProfile.kt
index 747f4726..93f23bbb 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/domain/mojang/MojangProfile.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/domain/mojang/MojangProfile.kt
@@ -22,3 +22,8 @@ import pl.spcode.navauth.common.domain.user.MojangId
 import pl.spcode.navauth.common.domain.user.Username
 
 data class MojangProfile(val uuid: MojangId, val name: Username)
+
+enum class MojangProfileApi {
+  MINETOOLS,
+  MOJANG,
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/auth/LoginAuthSession.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/auth/LoginAuthSession.kt
index 15d38797..557c8bbd 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/auth/LoginAuthSession.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/auth/LoginAuthSession.kt
@@ -18,9 +18,11 @@
 
 package pl.spcode.navauth.common.infra.auth
 
+import java.util.concurrent.CompletableFuture
 import pl.spcode.navauth.api.domain.auth.AuthSessionType
 import pl.spcode.navauth.api.event.NavAuthEventBus
 import pl.spcode.navauth.common.application.credentials.UserCredentialsService
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
 import pl.spcode.navauth.common.domain.auth.session.AuthSession
 import pl.spcode.navauth.common.domain.credentials.UserCredentials
 import pl.spcode.navauth.common.domain.player.DisconnectReason
@@ -29,7 +31,7 @@ import pl.spcode.navauth.common.domain.player.PlayerAdapter
 open class LoginAuthSession<T : PlayerAdapter>(
   playerAdapter: T,
   val userCredentials: UserCredentials,
-  val userCredentialsService: UserCredentialsService,
+  private val userCredentialsService: UserCredentialsService,
   maxLoginAttempts: Int,
   eventBus: NavAuthEventBus,
 ) : AuthSession<T>(playerAdapter, eventBus) {
@@ -47,43 +49,88 @@ open class LoginAuthSession<T : PlayerAdapter>(
   }
 
   /**
-   * Authenticates a user using a combination of password and two-factor authentication code if
-   * required.
+   * Authenticates the session owner using a combination of password and two-factor authentication
+   * code if required.
    *
    * @param password the raw (not hashed) password to authenticate the user, can be null if not
    *   required
    * @param twoFactorCode the two-factor authentication code, can be null if 2FA is not enabled
-   * @return true if the authentication is successful, otherwise false
+   * @return CompletableFuture with AuthTaskResult
    * @throws IllegalArgumentException if `password` or `twoFactorCode` is required by the user
    *   credentials but not provided
+   * @throws EncryptionTaskAlreadyQueuedException if an encryption task is already queued
    */
-  fun auth(password: String?, twoFactorCode: String?): Boolean {
-    val result = tryAuth(password, twoFactorCode)
-    if (!result) {
-      attemptsLeft -= 1
-      if (attemptsLeft <= 0) {
-        onTooManyLoginAttempts()
+  fun enqueueAuthTask(
+    password: String?,
+    twoFactorCode: String?,
+  ): CompletableFuture<AuthTaskResult> {
+    return tryAuth(password, twoFactorCode).thenApply { result ->
+      when (result) {
+        AuthTaskResult.WrongCredentials -> {
+          attemptsLeft -= 1
+          if (attemptsLeft <= 0) {
+            onTooManyLoginAttempts()
+            return@thenApply AuthTaskResult.FailedTooManyAttempts
+          }
+        }
+        AuthTaskResult.Success -> {
+          authenticate()
+        }
+        else -> {}
       }
+      return@thenApply result
     }
-    return result
   }
 
-  private fun tryAuth(password: String?, twoFactorCode: String?): Boolean {
+  /**
+   * Validates credentials and enqueues password verification if required.
+   *
+   * @param password the raw password, can be null if not required
+   * @param twoFactorCode the 2FA code, can be null if not required
+   * @return CompletableFuture with AuthTaskResult
+   * @throws IllegalArgumentException if `password` or `twoFactorCode` is required but not provided
+   * @throws EncryptionTaskAlreadyQueuedException if an encryption task is already queued
+   */
+  private fun tryAuth(
+    password: String?,
+    twoFactorCode: String?,
+  ): CompletableFuture<AuthTaskResult> {
     if (userCredentials.isTwoFactorEnabled) {
       require(twoFactorCode != null) { "twoFactorCode parameter is required by user credentials" }
       if (!userCredentialsService.verifyCode(userCredentials, twoFactorCode)) {
-        return false
+        return CompletableFuture.completedFuture(AuthTaskResult.WrongCredentials)
       }
     }
 
     if (userCredentials.isPasswordRequired) {
+      val future = CompletableFuture<AuthTaskResult>()
       require(password != null) { "password parameter is required by user credentials" }
-      if (!userCredentialsService.verifyPassword(userCredentials, password)) {
-        return false
-      }
+      userCredentialsService
+        .enqueueVerifyPassword(userCredentials, password, playerAdapter.identifier)
+        .whenComplete { isCorrect, throwable ->
+          if (throwable != null) {
+            future.completeExceptionally(throwable)
+            return@whenComplete
+          }
+          if (isCorrect) {
+            future.complete(AuthTaskResult.Success)
+          } else {
+            future.complete(AuthTaskResult.WrongCredentials)
+          }
+        }
+
+      return future
     }
 
-    authenticate()
-    return true
+    // 2fa was the only one required and it passed successfully
+    return CompletableFuture.completedFuture(AuthTaskResult.Success)
+  }
+
+  sealed class AuthTaskResult {
+    object WrongCredentials : AuthTaskResult()
+
+    object Success : AuthTaskResult()
+
+    object FailedTooManyAttempts : AuthTaskResult()
   }
 }
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/Argon2CredentialsHasher.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/Argon2CredentialsHasher.kt
index e6f0e19e..ad9e6839 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/Argon2CredentialsHasher.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/Argon2CredentialsHasher.kt
@@ -20,23 +20,23 @@ package pl.spcode.navauth.common.infra.crypto.hasher
 
 import java.nio.charset.StandardCharsets
 import java.security.MessageDigest
-import java.security.SecureRandom
 import org.bouncycastle.crypto.generators.Argon2BytesGenerator
 import org.bouncycastle.crypto.params.Argon2Parameters
+import pl.spcode.navauth.common.application.credentials.CredentialsHasher
 import pl.spcode.navauth.common.domain.credentials.HashingAlgorithm
 import pl.spcode.navauth.common.infra.crypto.CryptoUtils
 import pl.spcode.navauth.common.infra.crypto.HashedPassword
 import pl.spcode.navauth.common.infra.crypto.PasswordHash
 
-class Argon2CredentialsHasher : CredentialsHasher {
+class Argon2CredentialsHasher(
+  private val hashLength: Int = 16,
+  private val memoryKb: Int = 65536,
+  private val iterations: Int = 3,
+  private val parallelism: Int = 4,
+) : CredentialsHasher {
 
   companion object {
-    private val random = SecureRandom()
-    private const val SALT_LENGTH = 16
-    private const val HASH_LENGTH = 16
-    private const val MEMORY_KB = 65536 // 64MiB
-    private const val ITERATIONS = 3
-    private const val PARALLELISM = 4
+    private const val SALT_LENGTH: Int = 16
   }
 
   override fun hash(password: String): HashedPassword {
@@ -44,16 +44,18 @@ class Argon2CredentialsHasher : CredentialsHasher {
     val params =
       Argon2Parameters.Builder(Argon2Parameters.ARGON2_id)
         .withSalt(salt)
-        .withIterations(ITERATIONS)
-        .withMemoryAsKB(MEMORY_KB)
-        .withParallelism(PARALLELISM)
+        .withIterations(iterations)
+        .withMemoryAsKB(memoryKb)
+        .withParallelism(parallelism)
         .build()
 
+    val version = params.version
+
     val generator = Argon2BytesGenerator()
     generator.init(params)
 
     val passwordBytes = password.toByteArray(StandardCharsets.UTF_8)
-    val hash = ByteArray(HASH_LENGTH)
+    val hash = ByteArray(hashLength)
     generator.generateBytes(passwordBytes, hash)
 
     val saltB64 = CryptoUtils.base64EncodeToString(salt)
@@ -62,10 +64,10 @@ class Argon2CredentialsHasher : CredentialsHasher {
     // PHC-style: $argon2id$v=19$m=65536,t=3,p=4$<salt_b64>$<hash_b64>
     val encoded = buildString {
       append($$"$argon2id")
-      append($$"$v=19")
-      append($$"$m=").append(MEMORY_KB)
-      append(",t=").append(ITERATIONS)
-      append(",p=").append(PARALLELISM)
+      append($$"$v=").append(version)
+      append($$"$m=").append(memoryKb)
+      append(",t=").append(iterations)
+      append(",p=").append(parallelism)
       append("$").append(saltB64)
       append("$").append(hashB64)
     }
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/BCryptCredentialsHasher.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/BCryptCredentialsHasher.kt
index cab05783..15224082 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/BCryptCredentialsHasher.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/BCryptCredentialsHasher.kt
@@ -19,6 +19,7 @@
 package pl.spcode.navauth.common.infra.crypto.hasher
 
 import at.favre.lib.crypto.bcrypt.BCrypt
+import pl.spcode.navauth.common.application.credentials.CredentialsHasher
 import pl.spcode.navauth.common.domain.credentials.HashingAlgorithm
 import pl.spcode.navauth.common.infra.crypto.HashedPassword
 import pl.spcode.navauth.common.infra.crypto.PasswordHash
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/LibreLoginSHACredentialsHasher.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/LibreLoginSHACredentialsHasher.kt
index 8b041ba4..653524da 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/LibreLoginSHACredentialsHasher.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/LibreLoginSHACredentialsHasher.kt
@@ -22,6 +22,7 @@ import java.math.BigInteger
 import java.security.MessageDigest
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
+import pl.spcode.navauth.common.application.credentials.CredentialsHasher
 import pl.spcode.navauth.common.domain.credentials.HashingAlgorithm
 import pl.spcode.navauth.common.infra.crypto.HashedPassword
 import pl.spcode.navauth.common.infra.crypto.PasswordHash
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/SHACredentialsHasher.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/SHACredentialsHasher.kt
index c0d15e37..9490fe54 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/SHACredentialsHasher.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/hasher/SHACredentialsHasher.kt
@@ -24,6 +24,7 @@ import org.bouncycastle.crypto.digests.SHA256Digest
 import org.bouncycastle.crypto.digests.SHA512Digest
 import org.bouncycastle.crypto.generators.PKCS5S2ParametersGenerator
 import org.bouncycastle.crypto.params.KeyParameter
+import pl.spcode.navauth.common.application.credentials.CredentialsHasher
 import pl.spcode.navauth.common.domain.credentials.HashingAlgorithm
 import pl.spcode.navauth.common.infra.crypto.CryptoUtils
 import pl.spcode.navauth.common.infra.crypto.HashedPassword
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/queue/EncryptionQueueServiceImpl.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/queue/EncryptionQueueServiceImpl.kt
new file mode 100644
index 00000000..75992055
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/crypto/queue/EncryptionQueueServiceImpl.kt
@@ -0,0 +1,115 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.infra.crypto.queue
+
+import com.google.inject.Inject
+import com.google.inject.Singleton
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executors
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.RejectedExecutionException
+import java.util.concurrent.ThreadPoolExecutor
+import java.util.concurrent.TimeUnit
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionQueueService
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionTask
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
+import pl.spcode.navauth.common.config.EncryptionQueueConfig
+
+@Singleton
+class EncryptionQueueServiceImpl @Inject constructor(private val config: EncryptionQueueConfig) :
+  EncryptionQueueService {
+
+  private val logger: Logger = LoggerFactory.getLogger(javaClass)
+
+  private val workQueue = LinkedBlockingQueue<Runnable>()
+  private val activeTasks = ConcurrentHashMap<UUID, EncryptionTask>()
+
+  private val executor: ThreadPoolExecutor =
+    ThreadPoolExecutor(
+      config.encryptionQueueMinThreads,
+      config.encryptionQueueMaxThreads,
+      60,
+      TimeUnit.SECONDS,
+      workQueue,
+      Executors.defaultThreadFactory(),
+    ) { runnable, _ ->
+      val runner = runnable as EncryptionTaskRunner
+      try {
+        workQueue.put(runner)
+      } catch (e: InterruptedException) {
+        activeTasks.remove(runner.task.playerId)
+        Thread.currentThread().interrupt()
+        throw RejectedExecutionException("Interrupted while waiting for queue slot", e)
+      }
+    }
+
+  init {
+    executor.allowCoreThreadTimeOut(true)
+  }
+
+  /** @throws EncryptionTaskAlreadyQueuedException if task is already queued */
+  override fun submitTask(playerId: UUID, operation: () -> Unit, onCancelled: () -> Unit) {
+    val task = EncryptionTask(playerId, operation, onCancelled)
+
+    if (activeTasks.containsKey(playerId)) {
+      throw EncryptionTaskAlreadyQueuedException()
+    }
+    activeTasks[playerId] = task
+
+    executor.execute(EncryptionTaskRunner(playerId, task, activeTasks, logger))
+  }
+
+  override fun isTaskQueued(playerId: UUID): Boolean {
+    return activeTasks.containsKey(playerId)
+  }
+
+  override fun dequeueTask(playerId: UUID): Boolean {
+    val cancelledFromQueue =
+      workQueue.removeIf { it is EncryptionTaskRunner && it.playerId == playerId }
+
+    val task = activeTasks.remove(playerId)
+    if (task != null) {
+      task.cancelled = true
+      if (cancelledFromQueue) {
+        task.onCancelled.invoke()
+      }
+      return true
+    }
+
+    return false
+  }
+
+  private class EncryptionTaskRunner(
+    val playerId: UUID,
+    val task: EncryptionTask,
+    private val activeTasks: ConcurrentHashMap<UUID, EncryptionTask>,
+    private val logger: Logger,
+  ) : Runnable {
+    override fun run() {
+      val result = runCatching { task.run() }
+      if (result.isFailure) {
+        logger.warn("Player id='${playerId}' EncryptionTask failed", result.exceptionOrNull())
+      }
+      activeTasks.remove(playerId)
+    }
+  }
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/CompositeProfileService.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/CompositeProfileService.kt
new file mode 100644
index 00000000..c3efad7c
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/CompositeProfileService.kt
@@ -0,0 +1,66 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.infra.mojang
+
+import com.google.inject.Inject
+import com.google.inject.Singleton
+import pl.spcode.navauth.common.application.mojang.ProfileService
+import pl.spcode.navauth.common.config.MojangAPIConfig
+import pl.spcode.navauth.common.domain.mojang.MojangProfile
+import pl.spcode.navauth.common.domain.mojang.MojangProfileApi
+import pl.spcode.navauth.common.domain.user.Username
+
+@Singleton
+class CompositeProfileService
+@Inject
+constructor(
+  private val config: MojangAPIConfig,
+  private val mojangProfileService: MojangProfileServiceImpl,
+  private val mineToolsProfileService: MineToolsProfileService,
+  private val profileCache: ProfileCache,
+) : ProfileService {
+
+  override fun fetchProfileInfo(usernameCaseIgnored: Username): MojangProfile? {
+    profileCache.get(usernameCaseIgnored)?.let {
+      return it
+    }
+
+    var lastError: Exception? = null
+
+    for (api in config.apiOrder) {
+      try {
+        val profile =
+          when (api) {
+            MojangProfileApi.MINETOOLS ->
+              mineToolsProfileService.fetchProfileInfo(usernameCaseIgnored)
+            MojangProfileApi.MOJANG -> mojangProfileService.fetchProfileInfo(usernameCaseIgnored)
+          }
+        if (profile != null) {
+          profileCache.put(usernameCaseIgnored, profile)
+          return profile
+        }
+      } catch (e: Exception) {
+        lastError = e
+      }
+    }
+
+    if (lastError != null) throw lastError
+    return null
+  }
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/MineToolsProfileService.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/MineToolsProfileService.kt
new file mode 100644
index 00000000..ed556fe5
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/MineToolsProfileService.kt
@@ -0,0 +1,56 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.infra.mojang
+
+import com.google.gson.Gson
+import com.google.inject.Inject
+import com.google.inject.Singleton
+import java.net.URI
+import java.net.http.HttpClient
+import java.net.http.HttpRequest
+import java.net.http.HttpResponse
+import pl.spcode.navauth.common.application.mojang.ProfileService
+import pl.spcode.navauth.common.config.MojangAPIConfig
+import pl.spcode.navauth.common.domain.mojang.MojangProfile
+import pl.spcode.navauth.common.domain.user.MojangId
+import pl.spcode.navauth.common.domain.user.Username
+import pl.spcode.navauth.common.shared.utils.UuidUtils
+
+@Singleton
+class MineToolsProfileService
+@Inject
+constructor(val httpClient: HttpClient, val gson: Gson, val config: MojangAPIConfig) :
+  ProfileService {
+
+  private data class MineToolsProfileDto(val id: String?, val name: String?, val status: String?)
+
+  override fun fetchProfileInfo(usernameCaseIgnored: Username): MojangProfile? {
+    val requestUri = URI.create("https://api.minetools.eu/uuid/${usernameCaseIgnored.value}")
+    val request = HttpRequest.newBuilder(requestUri).timeout(config.apiTimeout).GET().build()
+    val response = httpClient.send(request, HttpResponse.BodyHandlers.ofString())
+
+    val dto = gson.fromJson(response.body(), MineToolsProfileDto::class.java)
+
+    if (dto.status != "OK" || dto.id == null || dto.name == null) {
+      return null
+    }
+
+    return MojangProfile(MojangId(UuidUtils.from32(dto.id)), Username(dto.name))
+  }
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/mojang/MojangProfileService.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/MojangProfileServiceImpl.kt
similarity index 78%
rename from navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/mojang/MojangProfileService.kt
rename to navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/MojangProfileServiceImpl.kt
index 39ae6657..85ecfbf2 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/application/mojang/MojangProfileService.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/MojangProfileServiceImpl.kt
@@ -1,6 +1,6 @@
 /*
  * NavAuth
- * Copyright © 2025 Oliwier Fijas (Navio1430)
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
  *
  * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
  * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
@@ -16,7 +16,7 @@
  *
  */
 
-package pl.spcode.navauth.common.application.mojang
+package pl.spcode.navauth.common.infra.mojang
 
 import com.google.gson.Gson
 import com.google.gson.annotations.SerializedName
@@ -26,6 +26,8 @@ import java.net.URI
 import java.net.http.HttpClient
 import java.net.http.HttpRequest
 import java.net.http.HttpResponse
+import pl.spcode.navauth.common.application.mojang.ProfileService
+import pl.spcode.navauth.common.config.MojangAPIConfig
 import pl.spcode.navauth.common.domain.mojang.MojangProfile
 import pl.spcode.navauth.common.domain.user.MojangId
 import pl.spcode.navauth.common.domain.user.Username
@@ -33,9 +35,10 @@ import pl.spcode.navauth.common.shared.http.HttpStatusCodes
 import pl.spcode.navauth.common.shared.utils.UuidUtils
 
 @Singleton
-class MojangProfileService @Inject constructor(val httpClient: HttpClient) {
-
-  val gson: Gson = Gson()
+class MojangProfileServiceImpl
+@Inject
+constructor(val httpClient: HttpClient, val gson: Gson, val config: MojangAPIConfig) :
+  ProfileService {
 
   data class MojangProfileDto(
     @SerializedName(value = "id") val uuidWithoutDashes: String,
@@ -47,12 +50,12 @@ class MojangProfileService @Inject constructor(val httpClient: HttpClient) {
     }
   }
 
-  fun fetchProfileInfo(usernameCaseIgnored: Username): MojangProfile? {
+  override fun fetchProfileInfo(usernameCaseIgnored: Username): MojangProfile? {
     val requestUri =
       URI.create(
         "https://api.minecraftservices.com/minecraft/profile/lookup/name/${usernameCaseIgnored.value}"
       )
-    val request = HttpRequest.newBuilder(requestUri).GET().build()
+    val request = HttpRequest.newBuilder(requestUri).timeout(config.apiTimeout).GET().build()
 
     val response = httpClient.send(request, HttpResponse.BodyHandlers.ofString())
 
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/ProfileCache.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/ProfileCache.kt
new file mode 100644
index 00000000..72665a10
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/infra/mojang/ProfileCache.kt
@@ -0,0 +1,46 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.infra.mojang
+
+import com.google.common.cache.Cache
+import com.google.common.cache.CacheBuilder
+import com.google.inject.Inject
+import com.google.inject.Singleton
+import pl.spcode.navauth.common.config.MojangAPIConfig
+import pl.spcode.navauth.common.domain.mojang.MojangProfile
+import pl.spcode.navauth.common.domain.user.Username
+
+@Singleton
+class ProfileCache @Inject constructor(config: MojangAPIConfig) {
+
+  private val cache: Cache<String, MojangProfile> =
+    CacheBuilder.newBuilder().expireAfterWrite(config.profileCacheTTL).build()
+
+  fun get(username: Username): MojangProfile? {
+    return cache.getIfPresent(username.value)
+  }
+
+  fun put(username: Username, profile: MojangProfile) {
+    cache.put(username.value, profile)
+  }
+
+  fun invalidate(username: Username) {
+    cache.invalidate(username.value)
+  }
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/module/GsonModule.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/module/GsonModule.kt
new file mode 100644
index 00000000..df29843a
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/module/GsonModule.kt
@@ -0,0 +1,31 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package pl.spcode.navauth.common.module
+
+import com.google.gson.Gson
+import com.google.inject.AbstractModule
+import com.google.inject.Provides
+
+class GsonModule : AbstractModule() {
+
+  @Provides
+  fun provideGson(): Gson {
+    return Gson()
+  }
+}
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/module/ServicesModule.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/module/ServicesModule.kt
index c0b33957..df755370 100644
--- a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/module/ServicesModule.kt
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/module/ServicesModule.kt
@@ -23,20 +23,32 @@ import pl.spcode.navauth.common.application.auth.handshake.AuthHandshakeSessionS
 import pl.spcode.navauth.common.application.auth.session.AuthSessionService
 import pl.spcode.navauth.common.application.auth.username.UsernameResolutionService
 import pl.spcode.navauth.common.application.credentials.UserCredentialsService
-import pl.spcode.navauth.common.application.mojang.MojangProfileService
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionQueueService
+import pl.spcode.navauth.common.application.mojang.ProfileService
 import pl.spcode.navauth.common.application.user.UserActivitySessionService
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.domain.common.TransactionService
+import pl.spcode.navauth.common.infra.crypto.queue.EncryptionQueueServiceImpl
+import pl.spcode.navauth.common.infra.mojang.CompositeProfileService
+import pl.spcode.navauth.common.infra.mojang.MineToolsProfileService
+import pl.spcode.navauth.common.infra.mojang.MojangProfileServiceImpl
+import pl.spcode.navauth.common.infra.mojang.ProfileCache
 import pl.spcode.navauth.common.infra.persistence.ormlite.TransactionServiceImpl
 
 class ServicesModule : AbstractModule() {
 
   override fun configure() {
+    bind(EncryptionQueueService::class.java).to(EncryptionQueueServiceImpl::class.java)
+
     bind(TransactionService::class.java).to(TransactionServiceImpl::class.java)
 
     bind(UsernameResolutionService::class.java)
 
-    bind(MojangProfileService::class.java)
+    bind(ProfileCache::class.java)
+    bind(MojangProfileServiceImpl::class.java)
+    bind(MineToolsProfileService::class.java)
+    bind(ProfileService::class.java).to(CompositeProfileService::class.java)
+
     bind(AuthHandshakeSessionService::class.java)
 
     bind(UserCredentialsService::class.java)
diff --git a/navauth-common/src/main/kotlin/pl/spcode/navauth/common/shared/utils/VersionUtils.kt b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/shared/utils/VersionUtils.kt
new file mode 100644
index 00000000..edce9f9d
--- /dev/null
+++ b/navauth-common/src/main/kotlin/pl/spcode/navauth/common/shared/utils/VersionUtils.kt
@@ -0,0 +1,24 @@
+package pl.spcode.navauth.common.shared.utils
+
+class VersionUtils {
+
+  companion object {
+    private val semverRegex = Regex("""(\d+\.\d+\.\d+)""")
+
+    fun parseVersion(version: String): String {
+      return semverRegex.find(version)?.value ?: version
+    }
+
+    fun isVersionOlderThan(version: String, minimum: String): Boolean {
+      val versionParts = parseVersion(version).split(".").map { it.toIntOrNull() ?: 0 }
+      val minParts = parseVersion(minimum).split(".").map { it.toIntOrNull() ?: 0 }
+
+      if (versionParts.size < 3 || minParts.size < 3) return true
+      if (versionParts[0] < minParts[0]) return true
+      if (versionParts[0] == minParts[0] && versionParts[1] < minParts[1]) return true
+      return versionParts[0] == minParts[0] &&
+        versionParts[1] == minParts[1] &&
+        versionParts[2] < minParts[2]
+    }
+  }
+}
diff --git a/navauth-common/src/test/kotlin/extension/app/UsernameResolutionTestExtension.kt b/navauth-common/src/test/kotlin/extension/app/UsernameResolutionTestExtension.kt
new file mode 100644
index 00000000..4f1cde2d
--- /dev/null
+++ b/navauth-common/src/test/kotlin/extension/app/UsernameResolutionTestExtension.kt
@@ -0,0 +1,67 @@
+/*
+ * NavAuth
+ * Copyright © 2025 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package extension.app
+
+import com.google.inject.AbstractModule
+import com.google.inject.Guice
+import com.google.inject.Injector
+import com.google.inject.util.Modules
+import fake.FakeProfileService
+import module.TestsConfigModule
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.junit.jupiter.api.extension.TestInstancePostProcessor
+import pl.spcode.navauth.common.application.mojang.ProfileService
+import pl.spcode.navauth.common.infra.database.DatabaseManager
+import pl.spcode.navauth.common.module.DataPersistenceModule
+import pl.spcode.navauth.common.module.EventsModule
+import pl.spcode.navauth.common.module.HttpClientModule
+import pl.spcode.navauth.common.module.ServicesModule
+import utils.GuiceUtils
+
+class UsernameResolutionTestExtension : TestInstancePostProcessor {
+
+  private val fakeProfileService = FakeProfileService()
+
+  var injector: Injector =
+    Guice.createInjector(
+      Modules.override(
+          EventsModule(),
+          TestsConfigModule(),
+          HttpClientModule(),
+          DataPersistenceModule(),
+          ServicesModule(),
+        )
+        .with(
+          object : AbstractModule() {
+            override fun configure() {
+              bind(FakeProfileService::class.java).toInstance(fakeProfileService)
+              bind(ProfileService::class.java).toInstance(fakeProfileService)
+            }
+          }
+        )
+    )
+
+  init {
+    injector.getInstance(DatabaseManager::class.java).connectAndInit()
+  }
+
+  override fun postProcessTestInstance(testInstance: Any, context: ExtensionContext) {
+    GuiceUtils.Companion.injectToDeclaredFields(testInstance, injector)
+  }
+}
diff --git a/navauth-common/src/test/kotlin/fake/FakeProfileService.kt b/navauth-common/src/test/kotlin/fake/FakeProfileService.kt
new file mode 100644
index 00000000..1099f3e1
--- /dev/null
+++ b/navauth-common/src/test/kotlin/fake/FakeProfileService.kt
@@ -0,0 +1,39 @@
+/*
+ * NavAuth
+ * Copyright © 2025 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package fake
+
+import pl.spcode.navauth.common.application.mojang.ProfileService
+import pl.spcode.navauth.common.domain.mojang.MojangProfile
+import pl.spcode.navauth.common.domain.user.Username
+
+class FakeProfileService : ProfileService {
+  private val profiles = mutableMapOf<Username, MojangProfile>()
+
+  fun addProfile(username: Username, profile: MojangProfile) {
+    profiles[username] = profile
+  }
+
+  override fun fetchProfileInfo(usernameCaseIgnored: Username): MojangProfile? {
+    return profiles[usernameCaseIgnored]
+  }
+
+  fun reset() {
+    profiles.clear()
+  }
+}
diff --git a/navauth-common/src/test/kotlin/integration/auth/UsernameResolutionServiceIntegrationTests.kt b/navauth-common/src/test/kotlin/integration/auth/UsernameResolutionServiceIntegrationTests.kt
new file mode 100644
index 00000000..0e886dd1
--- /dev/null
+++ b/navauth-common/src/test/kotlin/integration/auth/UsernameResolutionServiceIntegrationTests.kt
@@ -0,0 +1,271 @@
+/*
+ * NavAuth
+ * Copyright © 2025 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package integration.auth
+
+import com.google.inject.Inject
+import extension.app.UsernameResolutionTestExtension
+import fake.FakeProfileService
+import java.util.UUID
+import kotlin.test.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+import pl.spcode.navauth.common.application.auth.username.PostUsernameResolutionState
+import pl.spcode.navauth.common.application.auth.username.UsernameResFailureReason
+import pl.spcode.navauth.common.application.auth.username.UsernameResResult
+import pl.spcode.navauth.common.application.auth.username.UsernameResolutionService
+import pl.spcode.navauth.common.application.user.UserService
+import pl.spcode.navauth.common.domain.auth.handshake.EncryptionType
+import pl.spcode.navauth.common.domain.mojang.MojangProfile
+import pl.spcode.navauth.common.domain.user.MojangId
+import pl.spcode.navauth.common.domain.user.User
+import pl.spcode.navauth.common.domain.user.UserRepository
+import pl.spcode.navauth.common.domain.user.UserUuid
+import pl.spcode.navauth.common.domain.user.Username
+import utils.generateRandomString
+import utils.invertCase
+
+@ExtendWith(UsernameResolutionTestExtension::class)
+class UsernameResolutionServiceIntegrationTests {
+
+  @Inject private lateinit var fakeProfileService: FakeProfileService
+  @Inject private lateinit var usernameResolutionService: UsernameResolutionService
+  @Inject private lateinit var userService: UserService
+  @Inject private lateinit var userRepository: UserRepository
+
+  @BeforeEach
+  fun setUp() {
+    fakeProfileService.reset()
+  }
+
+  @Test
+  fun `new premium user returns success premium encryption type`() {
+    val username = Username(generateRandomString(10))
+    fakeProfileService.addProfile(username, MojangProfile(MojangId(UUID.randomUUID()), username))
+
+    val result = usernameResolutionService.resolveUsernameConflicts(username, null)
+
+    assertEquals(
+      UsernameResResult.Success(
+        EncryptionType.ENFORCE_PREMIUM,
+        PostUsernameResolutionState.NEW_ACCOUNT,
+      ),
+      result,
+    )
+  }
+
+  @Test
+  fun `new nonpremium user returns success none encryption type`() {
+    val username = Username(generateRandomString(10))
+
+    val result = usernameResolutionService.resolveUsernameConflicts(username, null)
+
+    assertEquals(
+      UsernameResResult.Success(EncryptionType.NONE, PostUsernameResolutionState.NEW_ACCOUNT),
+      result,
+    )
+  }
+
+  @Test
+  fun `existing premium user same connection username returns success premium encryption`() {
+    val username = Username(generateRandomString(10))
+    val mojangId = MojangId(UUID.randomUUID())
+    val userUuid = UserUuid(UUID.randomUUID())
+    userRepository.save(User.premium(userUuid, username, mojangId))
+    fakeProfileService.addProfile(username, MojangProfile(mojangId, username))
+
+    val existingUser = userService.findUserByUsernameIgnoreCase(username.value)!!
+    val result = usernameResolutionService.resolveUsernameConflicts(username, existingUser)
+
+    assertEquals(
+      UsernameResResult.Success(
+        EncryptionType.ENFORCE_PREMIUM,
+        PostUsernameResolutionState.NO_CHANGE,
+      ),
+      result,
+    )
+  }
+
+  @Test
+  fun `existing nonpremium user same connection username returns success none encryption`() {
+    val username = Username(generateRandomString(10))
+    userRepository.save(User.nonPremium(UserUuid(UUID.randomUUID()), username))
+
+    val existingUser = userService.findUserByUsernameIgnoreCase(username.value)!!
+    val result = usernameResolutionService.resolveUsernameConflicts(username, existingUser)
+
+    assertEquals(
+      UsernameResResult.Success(EncryptionType.NONE, PostUsernameResolutionState.NO_CHANGE),
+      result,
+    )
+  }
+
+  @Test
+  fun `existing nonpremium user conflict with different case premium username returns failure`() {
+    val username = Username(generateRandomString(10))
+    val premiumUsername = Username(invertCase(username.value))
+    val premiumProfile = MojangProfile(MojangId(UUID.randomUUID()), premiumUsername)
+    fakeProfileService.addProfile(username, premiumProfile)
+    userRepository.save(User.nonPremium(UserUuid(UUID.randomUUID()), username))
+
+    val existingUser = userService.findUserByUsernameIgnoreCase(username.value)!!
+    val result = usernameResolutionService.resolveUsernameConflicts(username, existingUser)
+
+    assertEquals(
+      UsernameResResult.Failure(
+        UsernameResFailureReason.NonPremiumWithPremiumConflict(premiumUsername.value)
+      ),
+      result,
+    )
+  }
+
+  @Test
+  fun `premium username with existing nonpremium user and same username returns success`() {
+    val username = Username(generateRandomString(10))
+    fakeProfileService.addProfile(username, MojangProfile(MojangId(UUID.randomUUID()), username))
+    userRepository.save(User.nonPremium(UserUuid(UUID.randomUUID()), username))
+
+    val existingUser = userService.findUserByUsernameIgnoreCase(username.value)!!
+    val result = usernameResolutionService.resolveUsernameConflicts(username, existingUser)
+
+    assertEquals(
+      UsernameResResult.Success(
+        EncryptionType.NONE,
+        PostUsernameResolutionState.NONPREMIUM_WITH_SAME_PREMIUM_NICKNAME,
+      ),
+      result,
+    )
+  }
+
+  @Test
+  fun `existing nonpremium user different connection username failure`() {
+    val username = Username(generateRandomString(10))
+    val connUsername = Username(generateRandomString(10))
+    userRepository.save(User.nonPremium(UserUuid(UUID.randomUUID()), username))
+
+    val existingUser = userService.findUserByUsernameIgnoreCase(username.value)!!
+    val result = usernameResolutionService.resolveUsernameConflicts(connUsername, existingUser)
+
+    assertEquals(
+      UsernameResResult.Failure(
+        UsernameResFailureReason.NonPremiumUsernameNotIdentical(username.value)
+      ),
+      result,
+    )
+  }
+
+  @Test
+  fun `existing premium user different connection username failure`() {
+    val username = Username(generateRandomString(10))
+    val connUsername = Username(generateRandomString(10))
+    val mojangId = MojangId(UUID.randomUUID())
+    userRepository.save(User.premium(UserUuid(UUID.randomUUID()), username, mojangId))
+    fakeProfileService.addProfile(
+      connUsername,
+      MojangProfile(MojangId(UUID.randomUUID()), connUsername),
+    )
+
+    val existingUser = userService.findUserByUsernameIgnoreCase(username.value)!!
+    val result = usernameResolutionService.resolveUsernameConflicts(connUsername, existingUser)
+
+    assertEquals(
+      UsernameResResult.Failure(
+        UsernameResFailureReason.PremiumUsernameNotIdentical(username.value)
+      ),
+      result,
+    )
+  }
+
+  @Test
+  fun `migrates successfully with existing premium user and different mojang username`() {
+    val mojangId = MojangId(UUID.randomUUID())
+    val existingUsername = Username(generateRandomString(10))
+    val newUsername = Username(generateRandomString(10))
+    userRepository.save(User.premium(UserUuid(UUID.randomUUID()), existingUsername, mojangId))
+    fakeProfileService.addProfile(newUsername, MojangProfile(mojangId, newUsername))
+
+    val result = usernameResolutionService.resolveUsernameConflicts(newUsername, null)
+
+    assertEquals(
+      UsernameResResult.Success(
+        EncryptionType.ENFORCE_PREMIUM,
+        PostUsernameResolutionState.PREMIUM_USERNAME_MIGRATED,
+      ),
+      result,
+    )
+  }
+
+  @Test
+  fun `migrates successfully with existing premium user and different letter case mojang username`() {
+    val mojangId = MojangId(UUID.randomUUID())
+    val existingUsername = Username(generateRandomString(10))
+    val newUsername = Username(invertCase(existingUsername.value))
+    userRepository.save(User.premium(UserUuid(UUID.randomUUID()), existingUsername, mojangId))
+    fakeProfileService.addProfile(newUsername, MojangProfile(mojangId, newUsername))
+
+    val result = usernameResolutionService.resolveUsernameConflicts(newUsername, null)
+
+    assertEquals(
+      UsernameResResult.Success(
+        EncryptionType.ENFORCE_PREMIUM,
+        PostUsernameResolutionState.PREMIUM_USERNAME_MIGRATED,
+      ),
+      result,
+    )
+  }
+
+  @Test
+  fun `existing nonpremium user with premium player who renamed to same name`() {
+    val nonPremiumUuid = UserUuid(UUID.randomUUID())
+    val username = Username(generateRandomString(10))
+    fakeProfileService.addProfile(username, MojangProfile(MojangId(UUID.randomUUID()), username))
+    userRepository.save(User.nonPremium(nonPremiumUuid, username))
+
+    val existingUser = userService.findUserByUsernameIgnoreCase(username.value)!!
+    val result = usernameResolutionService.resolveUsernameConflicts(username, existingUser)
+
+    assertEquals(
+      UsernameResResult.Success(
+        EncryptionType.NONE,
+        PostUsernameResolutionState.NONPREMIUM_WITH_SAME_PREMIUM_NICKNAME,
+      ),
+      result,
+    )
+  }
+
+  @Test
+  fun `existing premium user with different case mojang username found by case-insensitive lookup migrates successfully`() {
+    val mojangId = MojangId(UUID.randomUUID())
+    val existingUsername = Username(generateRandomString(10))
+    val newUsername = Username(invertCase(existingUsername.value))
+    userRepository.save(User.premium(UserUuid(UUID.randomUUID()), existingUsername, mojangId))
+    fakeProfileService.addProfile(newUsername, MojangProfile(mojangId, newUsername))
+
+    val existingUser = userService.findUserByUsernameIgnoreCase(newUsername.value)!!
+    val result = usernameResolutionService.resolveUsernameConflicts(newUsername, existingUser)
+
+    assertEquals(
+      UsernameResResult.Success(
+        EncryptionType.ENFORCE_PREMIUM,
+        PostUsernameResolutionState.PREMIUM_USERNAME_MIGRATED,
+      ),
+      result,
+    )
+  }
+}
diff --git a/navauth-common/src/test/kotlin/integration/service/MojangProfileServiceTests.kt b/navauth-common/src/test/kotlin/integration/service/MojangProfileServiceTests.kt
index cf2b556c..af1450e2 100644
--- a/navauth-common/src/test/kotlin/integration/service/MojangProfileServiceTests.kt
+++ b/navauth-common/src/test/kotlin/integration/service/MojangProfileServiceTests.kt
@@ -28,15 +28,15 @@ import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import org.junit.jupiter.api.extension.ExtendWith
-import pl.spcode.navauth.common.application.mojang.MojangProfileService
 import pl.spcode.navauth.common.domain.user.MojangId
 import pl.spcode.navauth.common.domain.user.Username
+import pl.spcode.navauth.common.infra.mojang.MojangProfileServiceImpl
 import utils.generateRandomString
 
 @ExtendWith(ApplicationTestExtension::class)
 class MojangProfileServiceTests {
 
-  @Inject lateinit var mojangProfileService: MojangProfileService
+  @Inject lateinit var mojangProfileService: MojangProfileServiceImpl
 
   @Test
   fun `test mojang profile fetch`() {
diff --git a/navauth-common/src/test/kotlin/module/TestsConfigModule.kt b/navauth-common/src/test/kotlin/module/TestsConfigModule.kt
index 8c3ec367..fa0cf94a 100644
--- a/navauth-common/src/test/kotlin/module/TestsConfigModule.kt
+++ b/navauth-common/src/test/kotlin/module/TestsConfigModule.kt
@@ -20,6 +20,7 @@ package module
 
 import com.google.inject.AbstractModule
 import config.TestConfig
+import eu.okaeri.configs.OkaeriConfig
 import kotlin.io.path.Path
 import pl.spcode.navauth.common.config.GeneralConfig
 import pl.spcode.navauth.common.module.PluginDirectoryModule
@@ -27,8 +28,29 @@ import pl.spcode.navauth.common.module.PluginDirectoryModule
 class TestsConfigModule : AbstractModule() {
 
   override fun configure() {
-    bind(GeneralConfig::class.java).toInstance(TestConfig())
+    val testConfig = TestConfig()
+
+    bind(GeneralConfig::class.java).toInstance(testConfig)
+    bindSubconfigsRecursively(testConfig)
 
     install(PluginDirectoryModule(Path("")))
   }
+
+  private fun bindSubconfigsRecursively(parentConfig: Any) {
+    val fields = mutableListOf<java.lang.reflect.Field>()
+    var clazz: Class<*>? = parentConfig.javaClass
+    while (clazz != null && clazz != Any::class.java) {
+      clazz.declaredFields.forEach { fields.add(it) }
+      clazz = clazz.superclass
+    }
+
+    fields.forEach { field ->
+      field.isAccessible = true
+      val value = field.get(parentConfig)
+      if (value is OkaeriConfig && value != parentConfig) {
+        @Suppress("UNCHECKED_CAST") bind(field.type as Class<OkaeriConfig>).toInstance(value)
+        bindSubconfigsRecursively(value)
+      }
+    }
+  }
 }
diff --git a/navauth-common/src/test/kotlin/unit/auth/UsernameResolutionServiceTests.kt b/navauth-common/src/test/kotlin/unit/auth/UsernameResolutionServiceTests.kt
index 3afe8a80..b09c20e8 100644
--- a/navauth-common/src/test/kotlin/unit/auth/UsernameResolutionServiceTests.kt
+++ b/navauth-common/src/test/kotlin/unit/auth/UsernameResolutionServiceTests.kt
@@ -28,7 +28,6 @@ import pl.spcode.navauth.common.application.auth.username.PostUsernameResolution
 import pl.spcode.navauth.common.application.auth.username.UsernameResFailureReason
 import pl.spcode.navauth.common.application.auth.username.UsernameResResult
 import pl.spcode.navauth.common.application.auth.username.UsernameResolutionService
-import pl.spcode.navauth.common.application.mojang.MojangProfileService
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.domain.auth.handshake.EncryptionType
 import pl.spcode.navauth.common.domain.mojang.MojangProfile
@@ -36,13 +35,14 @@ import pl.spcode.navauth.common.domain.user.MojangId
 import pl.spcode.navauth.common.domain.user.User
 import pl.spcode.navauth.common.domain.user.UserUuid
 import pl.spcode.navauth.common.domain.user.Username
+import pl.spcode.navauth.common.infra.mojang.MojangProfileServiceImpl
 import utils.generateRandomString
 import utils.invertCase
 
 class UsernameResolutionServiceTests :
   FunSpec({
     lateinit var mockUserService: UserService
-    lateinit var mockProfileService: MojangProfileService
+    lateinit var mockProfileService: MojangProfileServiceImpl
     lateinit var service: UsernameResolutionService
 
     beforeTest {
diff --git a/navauth-common/src/test/kotlin/unit/crypto/Argon2CredentialsHasherTests.kt b/navauth-common/src/test/kotlin/unit/crypto/Argon2CredentialsHasherTests.kt
index 62d08ad2..2b20e8cd 100644
--- a/navauth-common/src/test/kotlin/unit/crypto/Argon2CredentialsHasherTests.kt
+++ b/navauth-common/src/test/kotlin/unit/crypto/Argon2CredentialsHasherTests.kt
@@ -19,6 +19,7 @@
 package unit.crypto
 
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 import pl.spcode.navauth.common.infra.crypto.PasswordHash
@@ -26,23 +27,56 @@ import pl.spcode.navauth.common.infra.crypto.hasher.Argon2CredentialsHasher
 
 class Argon2CredentialsHasherTests {
 
-  private val hasher = Argon2CredentialsHasher()
+  @Test
+  fun `default hasher produces PHC with correct properties`() {
+    val hasher = Argon2CredentialsHasher()
+    val phc = hasher.hash("TestPassword123!").passwordHash.value
+
+    val parts = phc.split("$")
+    assertEquals(parts[1], "argon2id")
+    assertEquals(parts[2], "v=19")
+    assertEquals(parts[3], "m=65536,t=3,p=4")
+  }
 
   @Test
-  fun `hash and verify match`() {
+  fun `custom hasher produces PHC with matching properties`() {
+    val hasher =
+      Argon2CredentialsHasher(hashLength = 32, memoryKb = 128, iterations = 5, parallelism = 2)
+    val phc = hasher.hash("TestPassword123!").passwordHash.value
+
+    val parts = phc.split("$")
+    assertEquals(parts[1], "argon2id")
+    assertEquals(parts[2], "v=19")
+    assertEquals(parts[3], "m=128,t=5,p=2")
+  }
+
+  @Test
+  fun `hash and verify round-trip with default hasher`() {
+    val hasher = Argon2CredentialsHasher()
     val password = "TestPassword123!"
 
     val hashed = hasher.hash(password)
 
-    val result = hasher.verify(password, hashed.passwordHash)
+    assertTrue(hasher.verify(password, hashed.passwordHash))
+    assertFalse(hasher.verify("wrongPassword", hashed.passwordHash))
+  }
+
+  @Test
+  fun `hash and verify round-trip with custom hasher`() {
+    val hasher =
+      Argon2CredentialsHasher(hashLength = 32, memoryKb = 128, iterations = 5, parallelism = 2)
+    val password = "TestPassword123!"
+
+    val hashed = hasher.hash(password)
 
-    assertTrue(result)
+    assertTrue(hasher.verify(password, hashed.passwordHash))
+    assertFalse(hasher.verify("wrongPassword", hashed.passwordHash))
   }
 
   @Test
   fun `verify with manually crafted argon2id PHC works`() {
+    val hasher = Argon2CredentialsHasher()
     val phc = $$"$argon2id$v=19$m=65536,t=3,p=4$cz7sQK/RvBYgFpiBqQxM3w$6fo3usNp7CdtjYZxbfT0OA"
-
     val passwordHash = PasswordHash(phc)
 
     assertTrue(hasher.verify("TestPassword123!", passwordHash))
@@ -51,8 +85,8 @@ class Argon2CredentialsHasherTests {
 
   @Test
   fun `verify with manually crafted argon2i PHC works`() {
+    val hasher = Argon2CredentialsHasher()
     val phc = $$"$argon2i$v=19$m=16,t=2,p=1$VklGNXdOeU9KaDZrNkoybQ$Jx2+0wy31xNwJCHDNB19YQ"
-
     val passwordHash = PasswordHash(phc)
 
     assertTrue(hasher.verify("TestPassword123!", passwordHash))
@@ -61,8 +95,8 @@ class Argon2CredentialsHasherTests {
 
   @Test
   fun `verify with manually crafted argon2d PHC works`() {
+    val hasher = Argon2CredentialsHasher()
     val phc = $$"$argon2d$v=19$m=16,t=2,p=1$VklGNXdOeU9KaDZrNkoybQ$xWb4I3lKxryS2fVn11QgSQ"
-
     val passwordHash = PasswordHash(phc)
 
     assertTrue(hasher.verify("TestPassword123!", passwordHash))
diff --git a/navauth-common/src/test/kotlin/unit/mojang/CompositeProfileServiceTest.kt b/navauth-common/src/test/kotlin/unit/mojang/CompositeProfileServiceTest.kt
new file mode 100644
index 00000000..e98daf92
--- /dev/null
+++ b/navauth-common/src/test/kotlin/unit/mojang/CompositeProfileServiceTest.kt
@@ -0,0 +1,156 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package unit.mojang
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.runs
+import java.util.UUID
+import pl.spcode.navauth.common.config.MojangAPIConfig
+import pl.spcode.navauth.common.domain.mojang.MojangProfile
+import pl.spcode.navauth.common.domain.mojang.MojangProfileApi
+import pl.spcode.navauth.common.domain.user.MojangId
+import pl.spcode.navauth.common.domain.user.Username
+import pl.spcode.navauth.common.infra.mojang.CompositeProfileService
+import pl.spcode.navauth.common.infra.mojang.MineToolsProfileService
+import pl.spcode.navauth.common.infra.mojang.MojangProfileServiceImpl
+import pl.spcode.navauth.common.infra.mojang.ProfileCache
+
+class CompositeProfileServiceTest :
+  FunSpec({
+    lateinit var config: MojangAPIConfig
+    lateinit var mineTools: MineToolsProfileService
+    lateinit var mojang: MojangProfileServiceImpl
+    lateinit var cache: ProfileCache
+    lateinit var service: CompositeProfileService
+
+    val username = Username("test")
+    val minetoolsProfile = MojangProfile(MojangId(UUID.randomUUID()), Username("MinetoolsPlayer"))
+    val mojangProfile = MojangProfile(MojangId(UUID.randomUUID()), Username("MojangPlayer"))
+
+    beforeTest {
+      config = MojangAPIConfig()
+      mineTools = mockk()
+      mojang = mockk()
+      cache = mockk()
+      every { cache.put(any(), any()) } just runs
+      service = CompositeProfileService(config, mojang, mineTools, cache)
+    }
+
+    test("returns cached profile without calling APIs") {
+      every { cache.get(username) } returns minetoolsProfile
+
+      val result = service.fetchProfileInfo(username)
+
+      result shouldBe minetoolsProfile
+    }
+
+    test("queries minetools first (default order) and returns its result") {
+      every { cache.get(username) } returns null
+      every { mineTools.fetchProfileInfo(username) } returns minetoolsProfile
+
+      val result = service.fetchProfileInfo(username)
+
+      result shouldBe minetoolsProfile
+    }
+
+    test("falls back to mojang when minetools returns null") {
+      every { cache.get(username) } returns null
+      every { mineTools.fetchProfileInfo(username) } returns null
+      every { mojang.fetchProfileInfo(username) } returns mojangProfile
+
+      val result = service.fetchProfileInfo(username)
+
+      result shouldBe mojangProfile
+    }
+
+    test("falls back to mojang when minetools throws") {
+      every { cache.get(username) } returns null
+      every { mineTools.fetchProfileInfo(username) } throws RuntimeException("minetools error")
+      every { mojang.fetchProfileInfo(username) } returns mojangProfile
+
+      val result = service.fetchProfileInfo(username)
+
+      result shouldBe mojangProfile
+    }
+
+    test("returns null when all APIs return null") {
+      every { cache.get(username) } returns null
+      every { mineTools.fetchProfileInfo(username) } returns null
+      every { mojang.fetchProfileInfo(username) } returns null
+
+      val result = service.fetchProfileInfo(username)
+
+      result.shouldBeNull()
+    }
+
+    test("throws when all APIs throw") {
+      every { cache.get(username) } returns null
+      every { mineTools.fetchProfileInfo(username) } throws RuntimeException("minetools error")
+      every { mojang.fetchProfileInfo(username) } throws RuntimeException("mojang error")
+
+      shouldThrow<RuntimeException> { service.fetchProfileInfo(username) }
+    }
+
+    test("returns minetools result and caches it") {
+      every { cache.get(username) } returns null
+      every { mineTools.fetchProfileInfo(username) } returns minetoolsProfile
+      every { cache.put(username, minetoolsProfile) } returns Unit
+
+      val result = service.fetchProfileInfo(username)
+
+      result shouldBe minetoolsProfile
+    }
+
+    test("falls back when minetools throws, returns mojang result and caches it") {
+      every { cache.get(username) } returns null
+      every { mineTools.fetchProfileInfo(username) } throws RuntimeException("minetools error")
+      every { mojang.fetchProfileInfo(username) } returns mojangProfile
+      every { cache.put(username, mojangProfile) } returns Unit
+
+      val result = service.fetchProfileInfo(username)
+
+      result shouldBe mojangProfile
+    }
+
+    test("uses configured order: MOJANG first then MINETOOLS") {
+      config.apiOrder = listOf(MojangProfileApi.MOJANG, MojangProfileApi.MINETOOLS)
+      every { cache.get(username) } returns null
+      every { mojang.fetchProfileInfo(username) } returns mojangProfile
+
+      val result = service.fetchProfileInfo(username)
+
+      result shouldBe mojangProfile
+    }
+
+    test("returns first result from configured order with single API") {
+      config.apiOrder = listOf(MojangProfileApi.MOJANG)
+      every { cache.get(username) } returns null
+      every { mojang.fetchProfileInfo(username) } returns mojangProfile
+
+      val result = service.fetchProfileInfo(username)
+
+      result shouldBe mojangProfile
+    }
+  })
diff --git a/navauth-common/src/test/kotlin/unit/mojang/MineToolsProfileServiceTest.kt b/navauth-common/src/test/kotlin/unit/mojang/MineToolsProfileServiceTest.kt
new file mode 100644
index 00000000..354bf170
--- /dev/null
+++ b/navauth-common/src/test/kotlin/unit/mojang/MineToolsProfileServiceTest.kt
@@ -0,0 +1,97 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package unit.mojang
+
+import com.google.gson.Gson
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import io.mockk.mockk
+import java.net.http.HttpClient
+import java.net.http.HttpRequest
+import java.net.http.HttpResponse
+import java.net.http.HttpResponse.BodyHandler
+import java.util.UUID
+import pl.spcode.navauth.common.config.MojangAPIConfig
+import pl.spcode.navauth.common.domain.user.MojangId
+import pl.spcode.navauth.common.domain.user.Username
+import pl.spcode.navauth.common.infra.mojang.MineToolsProfileService
+
+class MineToolsProfileServiceTest :
+  FunSpec({
+    lateinit var httpClient: HttpClient
+    lateinit var response: HttpResponse<String>
+    lateinit var service: MineToolsProfileService
+
+    beforeTest {
+      httpClient = mockk()
+      response = mockk()
+      service = MineToolsProfileService(httpClient, Gson(), MojangAPIConfig())
+    }
+
+    test("returns profile on successful response with status OK") {
+      every { response.body() } returns
+        """{"id":"853c80ef3c3749fdaa49938b674adae6","name":"Notch","status":"OK"}"""
+      every { httpClient.send(any<HttpRequest>(), any<BodyHandler<String>>()) } returns response
+
+      val profile = service.fetchProfileInfo(Username("notch"))
+
+      profile.shouldNotBeNull()
+      profile!!.uuid shouldBe MojangId(UUID.fromString("853c80ef-3c37-49fd-aa49-938b674adae6"))
+      profile.name shouldBe Username("Notch")
+    }
+
+    test("returns null when status is ERR") {
+      every { response.body() } returns """{"status":"ERR"}"""
+      every { httpClient.send(any<HttpRequest>(), any<BodyHandler<String>>()) } returns response
+
+      val profile = service.fetchProfileInfo(Username("nonexistent"))
+
+      profile.shouldBeNull()
+    }
+
+    test("returns null when status is OK but id is null") {
+      every { response.body() } returns """{"id":null,"name":"test","status":"OK"}"""
+      every { httpClient.send(any<HttpRequest>(), any<BodyHandler<String>>()) } returns response
+
+      val profile = service.fetchProfileInfo(Username("test"))
+
+      profile.shouldBeNull()
+    }
+
+    test("returns null when status is OK but name is null") {
+      every { response.body() } returns
+        """{"id":"853c80ef3c3749fdaa49938b674adae6","name":null,"status":"OK"}"""
+      every { httpClient.send(any<HttpRequest>(), any<BodyHandler<String>>()) } returns response
+
+      val profile = service.fetchProfileInfo(Username("test"))
+
+      profile.shouldBeNull()
+    }
+
+    test("throws on network error") {
+      every { httpClient.send(any<HttpRequest>(), any<BodyHandler<String>>()) } throws
+        RuntimeException("timeout")
+
+      shouldThrow<RuntimeException> { service.fetchProfileInfo(Username("notch")) }
+    }
+  })
diff --git a/navauth-common/src/test/kotlin/unit/mojang/MojangProfileServiceImplTest.kt b/navauth-common/src/test/kotlin/unit/mojang/MojangProfileServiceImplTest.kt
new file mode 100644
index 00000000..34f44cd6
--- /dev/null
+++ b/navauth-common/src/test/kotlin/unit/mojang/MojangProfileServiceImplTest.kt
@@ -0,0 +1,79 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package unit.mojang
+
+import com.google.gson.Gson
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.nulls.shouldNotBeNull
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import io.mockk.mockk
+import java.net.http.HttpClient
+import java.net.http.HttpRequest
+import java.net.http.HttpResponse
+import java.net.http.HttpResponse.BodyHandler
+import java.util.UUID
+import pl.spcode.navauth.common.config.MojangAPIConfig
+import pl.spcode.navauth.common.domain.user.MojangId
+import pl.spcode.navauth.common.domain.user.Username
+import pl.spcode.navauth.common.infra.mojang.MojangProfileServiceImpl
+
+class MojangProfileServiceImplTest :
+  FunSpec({
+    lateinit var httpClient: HttpClient
+    lateinit var response: HttpResponse<String>
+    lateinit var service: MojangProfileServiceImpl
+
+    beforeTest {
+      httpClient = mockk()
+      response = mockk()
+      service = MojangProfileServiceImpl(httpClient, Gson(), MojangAPIConfig())
+    }
+
+    test("returns profile on successful response") {
+      every { response.statusCode() } returns 200
+      every { response.body() } returns
+        """{"id":"853c80ef3c3749fdaa49938b674adae6","name":"Notch"}"""
+      every { httpClient.send(any<HttpRequest>(), any<BodyHandler<String>>()) } returns response
+
+      val profile = service.fetchProfileInfo(Username("notch"))
+
+      profile.shouldNotBeNull()
+      profile!!.uuid shouldBe MojangId(UUID.fromString("853c80ef-3c37-49fd-aa49-938b674adae6"))
+      profile.name shouldBe Username("Notch")
+    }
+
+    test("returns null on 404") {
+      every { response.statusCode() } returns 404
+      every { httpClient.send(any<HttpRequest>(), any<BodyHandler<String>>()) } returns response
+
+      val profile = service.fetchProfileInfo(Username("nonexistent"))
+
+      profile.shouldBeNull()
+    }
+
+    test("throws on network error") {
+      every { httpClient.send(any<HttpRequest>(), any<BodyHandler<String>>()) } throws
+        RuntimeException("connection refused")
+
+      shouldThrow<RuntimeException> { service.fetchProfileInfo(Username("notch")) }
+    }
+  })
diff --git a/navauth-common/src/test/kotlin/unit/mojang/ProfileCacheTest.kt b/navauth-common/src/test/kotlin/unit/mojang/ProfileCacheTest.kt
new file mode 100644
index 00000000..74f96d22
--- /dev/null
+++ b/navauth-common/src/test/kotlin/unit/mojang/ProfileCacheTest.kt
@@ -0,0 +1,75 @@
+/*
+ * NavAuth
+ * Copyright © 2026 Oliwier Fijas (Navio1430)
+ *
+ * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
+ * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
+ *
+ * NavAuth is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
+ * and navigate to version 3 of the GNU Affero General Public License.
+ *
+ */
+
+package unit.mojang
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.nulls.shouldBeNull
+import io.kotest.matchers.shouldBe
+import java.util.UUID
+import pl.spcode.navauth.common.config.MojangAPIConfig
+import pl.spcode.navauth.common.domain.mojang.MojangProfile
+import pl.spcode.navauth.common.domain.user.MojangId
+import pl.spcode.navauth.common.domain.user.Username
+import pl.spcode.navauth.common.infra.mojang.ProfileCache
+
+class ProfileCacheTest :
+  FunSpec({
+    lateinit var cache: ProfileCache
+    val username = Username("test")
+    val profile = MojangProfile(MojangId(UUID.randomUUID()), username)
+
+    beforeTest { cache = ProfileCache(MojangAPIConfig()) }
+
+    test("get returns null for uncached username") { cache.get(username).shouldBeNull() }
+
+    test("get returns profile after put") {
+      cache.put(username, profile)
+      cache.get(username) shouldBe profile
+    }
+
+    test("put overwrites existing entry") {
+      val newProfile = MojangProfile(MojangId(UUID.randomUUID()), username)
+      cache.put(username, profile)
+      cache.put(username, newProfile)
+      cache.get(username) shouldBe newProfile
+    }
+
+    test("invalidate removes entry") {
+      cache.put(username, profile)
+      cache.invalidate(username)
+      cache.get(username).shouldBeNull()
+    }
+
+    test("invalidate does not throw for missing key") { cache.invalidate(Username("nonexistent")) }
+
+    test("get returns null for different usernames") {
+      val other = Username("other")
+      cache.put(username, profile)
+      cache.get(other).shouldBeNull()
+    }
+
+    test("get returns cached entry when TTL has not expired") {
+      val config = MojangAPIConfig()
+      config.profileCacheTTL = java.time.Duration.ofHours(1)
+      val longTtlCache = ProfileCache(config)
+
+      longTtlCache.put(username, profile)
+      longTtlCache.get(username) shouldBe profile
+    }
+  })
diff --git a/navauth-common/src/test/kotlin/unit/queue/EncryptionQueueServiceTests.kt b/navauth-common/src/test/kotlin/unit/queue/EncryptionQueueServiceTests.kt
new file mode 100644
index 00000000..dd797495
--- /dev/null
+++ b/navauth-common/src/test/kotlin/unit/queue/EncryptionQueueServiceTests.kt
@@ -0,0 +1,227 @@
+package unit.queue
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import io.mockk.mockk
+import io.mockk.verify
+import java.util.UUID
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
+import pl.spcode.navauth.common.config.EncryptionQueueConfig
+import pl.spcode.navauth.common.infra.crypto.queue.EncryptionQueueServiceImpl
+
+class EncryptionQueueServiceTests :
+  FunSpec({
+    val config =
+      EncryptionQueueConfig().apply {
+        encryptionQueueMinThreads = 2
+        encryptionQueueMaxThreads = 4
+      }
+
+    fun createService(): EncryptionQueueServiceImpl = EncryptionQueueServiceImpl(config)
+
+    test("submitTask executes the operation") {
+      val service = createService()
+      val playerId = UUID.randomUUID()
+      var executed = false
+      val latch = CountDownLatch(1)
+
+      service.submitTask(
+        playerId = playerId,
+        operation = {
+          executed = true
+          latch.countDown()
+        },
+        onCancelled = mockk(relaxed = true),
+      )
+
+      latch.await(5, TimeUnit.SECONDS) shouldBe true
+      executed shouldBe true
+    }
+
+    test("submitTask throws EncryptionTaskAlreadyQueuedException for duplicate playerId") {
+      val service = createService()
+      val playerId = UUID.randomUUID()
+      val blocker = CountDownLatch(1)
+
+      service.submitTask(
+        playerId = playerId,
+        operation = { blocker.await() },
+        onCancelled = mockk(relaxed = true),
+      )
+
+      shouldThrow<EncryptionTaskAlreadyQueuedException> {
+        service.submitTask(playerId = playerId, operation = {}, onCancelled = mockk(relaxed = true))
+      }
+
+      blocker.countDown()
+    }
+
+    test("submitTask allows different playerIds") {
+      val service = createService()
+      val latch1 = CountDownLatch(1)
+      val latch2 = CountDownLatch(1)
+
+      service.submitTask(
+        playerId = UUID.randomUUID(),
+        operation = { latch1.countDown() },
+        onCancelled = mockk(relaxed = true),
+      )
+      service.submitTask(
+        playerId = UUID.randomUUID(),
+        operation = { latch2.countDown() },
+        onCancelled = mockk(relaxed = true),
+      )
+
+      latch1.await(5, TimeUnit.SECONDS) shouldBe true
+      latch2.await(5, TimeUnit.SECONDS) shouldBe true
+    }
+
+    test("dequeueTask returns false when no task exists") {
+      val service = createService()
+      service.dequeueTask(UUID.randomUUID()) shouldBe false
+    }
+
+    test("dequeueTask removes queued task and invokes onCancelled") {
+      val config =
+        EncryptionQueueConfig().apply {
+          encryptionQueueMinThreads = 1
+          encryptionQueueMaxThreads = 1
+        }
+      val service = EncryptionQueueServiceImpl(config)
+      val blockerStarted = CountDownLatch(1)
+      val blockerRelease = CountDownLatch(1)
+      val blockerId = UUID.randomUUID()
+
+      service.submitTask(
+        playerId = blockerId,
+        operation = {
+          blockerStarted.countDown()
+          blockerRelease.await()
+        },
+        onCancelled = mockk(relaxed = true),
+      )
+
+      blockerStarted.await(5, TimeUnit.SECONDS) shouldBe true
+
+      val targetId = UUID.randomUUID()
+      val opLatch = CountDownLatch(1)
+      val onCancelled = mockk<() -> Unit>(relaxed = true)
+
+      service.submitTask(
+        playerId = targetId,
+        operation = { opLatch.countDown() },
+        onCancelled = onCancelled,
+      )
+
+      service.dequeueTask(targetId) shouldBe true
+      verify { onCancelled.invoke() }
+
+      opLatch.await(1, TimeUnit.SECONDS) shouldBe false
+      service.isTaskQueued(targetId) shouldBe false
+
+      blockerRelease.countDown()
+    }
+
+    test("dequeueTask returns true and sets cancelled for executing task") {
+      val service = createService()
+      val opStarted = CountDownLatch(1)
+      val opRelease = CountDownLatch(1)
+      val playerId = UUID.randomUUID()
+
+      service.submitTask(
+        playerId = playerId,
+        operation = {
+          opStarted.countDown()
+          opRelease.await()
+        },
+        onCancelled = mockk(relaxed = true),
+      )
+
+      opStarted.await(5, TimeUnit.SECONDS) shouldBe true
+
+      service.dequeueTask(playerId) shouldBe true
+      service.isTaskQueued(playerId) shouldBe false
+
+      opRelease.countDown()
+    }
+
+    test("onCancelled is not called when task executes normally") {
+      val service = createService()
+      val playerId = UUID.randomUUID()
+      val latch = CountDownLatch(1)
+      val onCancelled = mockk<() -> Unit>(relaxed = true)
+
+      service.submitTask(
+        playerId = playerId,
+        operation = { latch.countDown() },
+        onCancelled = onCancelled,
+      )
+
+      latch.await(5, TimeUnit.SECONDS) shouldBe true
+      verify(inverse = true) { onCancelled.invoke() }
+    }
+
+    test("isTaskQueued reflects current state") {
+      val service = createService()
+      val playerId = UUID.randomUUID()
+      val blocker = CountDownLatch(1)
+      val done = CountDownLatch(1)
+
+      service.isTaskQueued(playerId) shouldBe false
+
+      service.submitTask(
+        playerId = playerId,
+        operation = {
+          blocker.await()
+          done.countDown()
+        },
+        onCancelled = mockk(relaxed = true),
+      )
+
+      service.isTaskQueued(playerId) shouldBe true
+
+      blocker.countDown()
+      done.await(5, TimeUnit.SECONDS) shouldBe true
+
+      Thread.sleep(100)
+      service.isTaskQueued(playerId) shouldBe false
+    }
+
+    test("EncryptionTaskAlreadyQueuedException is thrown and caught correctly") {
+      val service = createService()
+      val playerId = UUID.randomUUID()
+      val blocker = CountDownLatch(1)
+
+      service.submitTask(
+        playerId = playerId,
+        operation = { blocker.await() },
+        onCancelled = mockk(relaxed = true),
+      )
+
+      shouldThrow<EncryptionTaskAlreadyQueuedException> {
+        service.submitTask(playerId = playerId, operation = {}, onCancelled = mockk(relaxed = true))
+      }
+
+      blocker.countDown()
+    }
+
+    test("dequeueTask after task already completed returns false") {
+      val service = createService()
+      val playerId = UUID.randomUUID()
+      val latch = CountDownLatch(1)
+
+      service.submitTask(
+        playerId = playerId,
+        operation = { latch.countDown() },
+        onCancelled = mockk(relaxed = true),
+      )
+
+      latch.await(5, TimeUnit.SECONDS) shouldBe true
+
+      Thread.sleep(200)
+      service.dequeueTask(playerId) shouldBe false
+    }
+  })
diff --git a/navauth-common/src/test/kotlin/unit/shared/VersionUtilsTests.kt b/navauth-common/src/test/kotlin/unit/shared/VersionUtilsTests.kt
new file mode 100644
index 00000000..639249b2
--- /dev/null
+++ b/navauth-common/src/test/kotlin/unit/shared/VersionUtilsTests.kt
@@ -0,0 +1,63 @@
+package unit.shared
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import pl.spcode.navauth.common.shared.utils.VersionUtils
+import utils.generateRandomString
+
+class VersionUtilsTests {
+
+  @Test
+  fun `parseVersion strips prefix and suffix`() {
+    val suffix = generateRandomString(5).dropWhile { it.digitToIntOrNull() != null }
+    val prefix = generateRandomString(5).dropLastWhile { it.digitToIntOrNull() != null }
+    assertEquals("0.2.0", VersionUtils.parseVersion("${prefix}0.2.0$suffix"))
+  }
+
+  @Test
+  fun `parseVersion returns plain version as-is`() {
+    assertEquals("0.2.0", VersionUtils.parseVersion("0.2.0"))
+  }
+
+  @Test
+  fun `isVersionOlderThan returns true when version is older`() {
+    assertTrue(VersionUtils.isVersionOlderThan("0.1.9", "0.2.0"))
+  }
+
+  @Test
+  fun `isVersionOlderThan returns true when major is older`() {
+    assertTrue(VersionUtils.isVersionOlderThan("0.2.0", "1.0.0"))
+  }
+
+  @Test
+  fun `isVersionOlderThan returns false when version equals minimum`() {
+    assertFalse(VersionUtils.isVersionOlderThan("0.2.0", "0.2.0"))
+  }
+
+  @Test
+  fun `isVersionOlderThan returns false when version is newer`() {
+    assertFalse(VersionUtils.isVersionOlderThan("0.2.1", "0.2.0"))
+  }
+
+  @Test
+  fun `isVersionOlderThan returns false when version is newer on minor`() {
+    assertFalse(VersionUtils.isVersionOlderThan("0.3.0", "0.2.0"))
+  }
+
+  @Test
+  fun `isVersionOlderThan handles SNAPSHOT versions correctly`() {
+    assertFalse(VersionUtils.isVersionOlderThan("0.2.0-SNAPSHOT", "0.2.0"))
+  }
+
+  @Test
+  fun `isVersionOlderThan handles newer SNAPSHOT correctly`() {
+    assertFalse(VersionUtils.isVersionOlderThan("0.2.1-SNAPSHOT", "0.2.0"))
+  }
+
+  @Test
+  fun `isVersionOlderThan handles older SNAPSHOT correctly`() {
+    assertTrue(VersionUtils.isVersionOlderThan("0.1.9-SNAPSHOT", "0.2.0"))
+  }
+}
diff --git a/navauth-common/src/test/kotlin/utils/StringUtils.kt b/navauth-common/src/test/kotlin/utils/StringUtils.kt
index 21e54404..82e85e9d 100644
--- a/navauth-common/src/test/kotlin/utils/StringUtils.kt
+++ b/navauth-common/src/test/kotlin/utils/StringUtils.kt
@@ -18,8 +18,9 @@
 
 package utils
 
-fun generateRandomString(length: Int): String {
-  val allowedChars = ('A'..'Z') + ('a'..'z') + ('0'..'9')
+fun generateRandomString(length: Int, withNumbers: Boolean = true): String {
+  val allowedChars =
+    if (withNumbers) ('A'..'Z') + ('a'..'z') + ('0'..'9') else ('A'..'Z') + ('a'..'z')
   return (1..length).map { allowedChars.random() }.joinToString("")
 }
 
diff --git a/navauth-velocity/build.gradle.kts b/navauth-velocity/build.gradle.kts
index 77100333..b691b1c2 100644
--- a/navauth-velocity/build.gradle.kts
+++ b/navauth-velocity/build.gradle.kts
@@ -1,55 +1,17 @@
-
 plugins {
   alias(libs.plugins.blossom)
-  alias(libs.plugins.shadow)
+  id("buildsrc.navauth-shadow")
+  kotlin("kapt")
 }
 
 val projectName = "navauth"
 
-var prefix = "pl.spcode.${projectName.lowercase()}.lib";
-fun com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar.relocatePrefixed(pkg: String) {
-  relocate(pkg, "${prefix}.$pkg")
-}
-
 tasks.shadowJar {
   destinationDirectory.set(file("../target"))
 
   archiveBaseName.set("${projectName}-velocity")
   archiveClassifier = null
 
-  relocate("com.google", "$prefix.com.google") {
-    exclude("com/google/inject/**")
-    exclude("com/google/gson/**")
-  }
-
-  exclude("com/google/inject/**")
-  exclude("com/google/gson/**")
-
-  exclude("org/slf4j/**")
-
-  relocatePrefixed("kotlin")
-  relocatePrefixed("org.bstats")
-  relocatePrefixed("at.favre")
-  relocatePrefixed("com.eternalcode")
-  relocatePrefixed("com.j256")
-  relocatePrefixed("com.mysql")
-  relocatePrefixed("com.zaxxer")
-  relocatePrefixed("dev.rollczi")
-  relocatePrefixed("eu.okaeri")
-  relocatePrefixed("google.protobuf")
-  relocatePrefixed("jakarta.inject")
-  relocatePrefixed("javax.annotation")
-  relocatePrefixed("org.aopalliance")
-  relocatePrefixed("org.bouncycastle")
-  relocatePrefixed("org.checkerframework")
-  relocatePrefixed("org.h2")
-  relocatePrefixed("org.intellij")
-  relocatePrefixed("org.jetbrains")
-  relocatePrefixed("org.postgresql")
-  // todo make sure we relocate this or something
-//  relocatePrefixed("org.sqlite")
-  relocatePrefixed("org.yaml")
-
   doLast {
     val pluginsDir = file("./run/velocity/plugins")
     if (pluginsDir.exists() && pluginsDir.isDirectory) {
@@ -68,9 +30,14 @@ tasks.shadowJar {
   }
 }
 
-blossom {
-  replaceTokenIn("pl/spcode/$projectName/velocity/Bootstrap.java")
-  replaceToken("@version@", rootProject.version.toString())
+sourceSets {
+  main {
+    blossom {
+      kotlinSources {
+        property("version", rootProject.version.toString())
+      }
+    }
+  }
 }
 
 repositories {
@@ -79,28 +46,22 @@ repositories {
 }
 
 dependencies {
-
   implementation(project(":navauth-common"))
 
   implementation(libs.litecommands.velocity)
 
   compileOnly(libs.velocitypowered.velocity.api)
-  annotationProcessor(libs.velocitypowered.velocity.api)
+  kapt(libs.velocitypowered.velocity.api)
 
   // bstats
   implementation("org.bstats:bstats-velocity:3.1.0")
 
-  // Tribufu-Rcon used for containers
+  // Tribufu-Rcon used in itzg containers
   compileOnly("com.tribufu:Tribufu-VelocityRcon:1.2.0")
 }
 
-tasks.compileJava {
-  options.compilerArgs.add("-parameters")
-}
-
 tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
   compilerOptions {
     freeCompilerArgs.add("-java-parameters")
   }
 }
-
diff --git a/navauth-velocity/src/main/java/pl/spcode/navauth/velocity/Bootstrap.java b/navauth-velocity/src/main/java/pl/spcode/navauth/velocity/Bootstrap.java
deleted file mode 100644
index 83275e8e..00000000
--- a/navauth-velocity/src/main/java/pl/spcode/navauth/velocity/Bootstrap.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * NavAuth
- * Copyright © 2025 Oliwier Fijas (Navio1430)
- *
- * NavAuth is free software; You can redistribute it and/or modify it under the terms of:
- * the GNU Affero General Public License version 3 as published by the Free Software Foundation.
- *
- * NavAuth is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with NavAuth. If not, see <https://www.gnu.org/licenses/>
- * and navigate to version 3 of the GNU Affero General Public License.
- *
- */
-
-package pl.spcode.navauth.velocity;
-
-import com.google.inject.Inject;
-import com.google.inject.Injector;
-import com.velocitypowered.api.event.Subscribe;
-import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
-import com.velocitypowered.api.plugin.Plugin;
-import org.slf4j.Logger;
-
-@Plugin(
-    id = "navauth",
-    name = "NavAuth",
-    version = "@version@",
-    url = "https://spcode.pl/navauth",
-    description =
-        "Minecraft login plugin built for speed, security, and seamless player authentication.",
-    authors = {"Navio1430"})
-public class Bootstrap {
-
-  private static NavAuthVelocity instance;
-
-  @Inject
-  private Bootstrap(Logger logger, Injector injector) {
-    logger.info("Bootstrapping velocity plugin...");
-    instance = injector.getInstance(NavAuthVelocity.class);
-    instance.init();
-  }
-
-  @Subscribe
-  private void onProxyInitializeEvent(ProxyInitializeEvent event) {
-    instance.onProxyInitializeEvent(this);
-  }
-}
diff --git a/navauth-velocity/src/main/kotlin-templates/pl/spcode/navauth/velocity/BuildParameters.kt.peb b/navauth-velocity/src/main/kotlin-templates/pl/spcode/navauth/velocity/BuildParameters.kt.peb
new file mode 100644
index 00000000..0936e910
--- /dev/null
+++ b/navauth-velocity/src/main/kotlin-templates/pl/spcode/navauth/velocity/BuildParameters.kt.peb
@@ -0,0 +1,7 @@
+package pl.spcode.navauth.velocity
+
+class BuildParameters {
+  companion object {
+    const val VERSION = "{{ version }}"
+  }
+}
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/NavAuthApiImpl.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/NavAuthApiImpl.kt
index f5a9de16..287c178e 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/NavAuthApiImpl.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/NavAuthApiImpl.kt
@@ -19,12 +19,30 @@
 package pl.spcode.navauth.velocity
 
 import com.google.inject.Inject
+import com.velocitypowered.api.proxy.ProxyServer
+import java.util.UUID
 import pl.spcode.navauth.api.NavAuthAPI
 import pl.spcode.navauth.api.event.NavAuthEventBus
+import pl.spcode.navauth.common.application.auth.session.AuthSessionService
+import pl.spcode.navauth.velocity.infra.auth.VelocityUniqueSessionId
+import pl.spcode.navauth.velocity.infra.player.VelocityPlayerAdapter
 
-class NavAuthApiImpl @Inject constructor(val eventBusInstance: NavAuthEventBus) : NavAuthAPI() {
+class NavAuthApiImpl
+@Inject
+constructor(
+  val eventBusInstance: NavAuthEventBus,
+  val authSessionService: AuthSessionService<VelocityPlayerAdapter>,
+  val proxyServer: ProxyServer,
+) : NavAuthAPI() {
 
   override fun provideEventBus(): NavAuthEventBus {
     return eventBusInstance
   }
+
+  override fun isAuthenticated(playerUuid: UUID): Boolean {
+    val player = proxyServer.getPlayer(playerUuid).orElse(null) ?: return false
+    val sessionId = VelocityUniqueSessionId(player)
+    val session = authSessionService.findSession(sessionId)
+    return session?.isAuthenticated == true
+  }
 }
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/NavAuthVelocity.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/NavAuthVelocity.kt
index f6817eb2..ed447432 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/NavAuthVelocity.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/NavAuthVelocity.kt
@@ -24,7 +24,9 @@ import com.google.inject.Key
 import com.google.inject.Singleton
 import com.velocitypowered.api.command.CommandSource
 import com.velocitypowered.api.event.Subscribe
+import com.velocitypowered.api.event.proxy.ProxyInitializeEvent
 import com.velocitypowered.api.event.proxy.ProxyShutdownEvent
+import com.velocitypowered.api.plugin.Plugin
 import com.velocitypowered.api.plugin.annotation.DataDirectory
 import com.velocitypowered.api.proxy.ProxyServer
 import dev.rollczi.litecommands.LiteCommands
@@ -59,6 +61,15 @@ import pl.spcode.navauth.velocity.module.VelocityMultificationsModule
 import pl.spcode.navauth.velocity.module.VelocityServicesModule
 import pl.spcode.navauth.velocity.multification.VelocityViewerProvider
 
+@Plugin(
+  id = "navauth",
+  name = "NavAuth",
+  version = BuildParameters.VERSION,
+  url = "https://spcode.pl/navauth",
+  description =
+    "Minecraft login plugin built for speed, security, and seamless player authentication.",
+  authors = ["Navio1430"],
+)
 @Singleton
 class NavAuthVelocity
 @Inject
@@ -71,13 +82,12 @@ constructor(
 
   private val logger: Logger = LoggerFactory.getLogger(NavAuthVelocity::class.java)
 
-  // chicken or egg problem, unfortunately
-  var pluginInstance: Bootstrap? = null
   lateinit var injector: Injector
 
   lateinit var liteCommands: LiteCommands<CommandSource>
 
-  fun init() {
+  @Subscribe
+  fun onProxyInitializeEvent(event: ProxyInitializeEvent) {
     try {
       logger.info("Initializing NavAuth plugin...")
 
@@ -106,6 +116,7 @@ constructor(
           VelocityMultificationsModule(velocityViewerProvider),
           VelocityCommandsModule(),
           SchedulerModule(this, proxyServer.scheduler),
+          GsonModule(),
           HttpClientModule(),
           DataPersistenceModule(),
           ServicesModule(),
@@ -120,19 +131,10 @@ constructor(
 
       val apiImpl = injector.getInstance(NavAuthApiImpl::class.java)
       NavAuthAPI.setAPIInstance(apiImpl)
-    } catch (ex: Exception) {
-      logger.error("Could not initialize NavAuth plugin, shutting down the server...", ex)
-      proxyServer.shutdown(Component.text("NavAuth initialization failure"))
-    }
-  }
-
-  fun onProxyInitializeEvent(pluginInstance: Bootstrap) {
-    try {
-      this.pluginInstance = pluginInstance
 
       // initialize bstats
       val pluginId = 28777
-      metricsFactory.make(pluginInstance, pluginId)
+      metricsFactory.make(this, pluginId)
 
       registerListeners(injector)
       registerCommands(injector)
@@ -170,11 +172,8 @@ constructor(
   }
 
   fun registerListeners(injector: Injector) {
-    // register self as listener because of the shutdown event
-    proxyServer.eventManager.register(pluginInstance, this)
-
     val listeners = VelocityListenersRegistry.getWithInjection(injector)
-    listeners.forEach { proxyServer.eventManager.register(pluginInstance, it) }
+    listeners.forEach { proxyServer.eventManager.register(this, it) }
   }
 
   @Suppress("UNNECESSARY_SAFE_CALL")
@@ -186,8 +185,7 @@ constructor(
     logger.info("Goodbye!")
   }
 
-  override fun provideInstance(): Bootstrap {
-    require(pluginInstance != null) { "plugin was not initialized yet" }
-    return pluginInstance!!
+  override fun provideInstance(): NavAuthVelocity {
+    return this
   }
 }
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/VelocityPluginProvider.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/VelocityPluginProvider.kt
index 980db744..9080b522 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/VelocityPluginProvider.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/VelocityPluginProvider.kt
@@ -19,5 +19,5 @@
 package pl.spcode.navauth.velocity
 
 interface VelocityPluginProvider {
-  fun provideInstance(): Bootstrap
+  fun provideInstance(): NavAuthVelocity
 }
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/ForceCrackedAdminCommand.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/ForceCrackedAdminCommand.kt
index fc43b522..51cea2f3 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/ForceCrackedAdminCommand.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/ForceCrackedAdminCommand.kt
@@ -29,6 +29,7 @@ import dev.rollczi.litecommands.annotations.permission.Permission
 import java.util.Optional
 import pl.spcode.navauth.common.annotation.Description
 import pl.spcode.navauth.common.application.credentials.UserCredentialsService
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.command.user.UserArgumentResolver
 import pl.spcode.navauth.common.command.user.UsernameOrUuidRaw
@@ -72,21 +73,27 @@ constructor(
 
     val newPassword = newPasswordOpt.orElseGet { generateRandomString(8) }
 
-    val hashedPassword = userCredentialsService.hashPassword(newPassword)
-    userService.migrateToNonPremium(user, hashedPassword)
+    try {
+      userCredentialsService.enqueueHashPassword(newPassword, user.uuid.value).thenAccept {
+        hashedPassword ->
+        userService.migrateToNonPremium(user, hashedPassword)
 
-    val passwordText =
-      if (CommandSourceUtils.isConsoleOrRcon(sender)) {
-        "$newPassword"
-      } else {
-        val placeholders = mapOf(Pair("PASSWORD", newPassword))
-        multification.config.adminCopyPasswordText.applyPlaceholders(placeholders)
-      }
+        val passwordText =
+          if (CommandSourceUtils.isConsoleOrRcon(sender)) {
+            "$newPassword"
+          } else {
+            val placeholders = mapOf(Pair("PASSWORD", newPassword))
+            multification.config.adminCopyPasswordText.applyPlaceholders(placeholders)
+          }
 
-    multification
-      .create(sender) { it.multification.adminCmdAccountMigratedToNonPremiumSuccess }
-      .placeholder("%USERNAME%", user.username.value)
-      .placeholder("%PASSWORD_TEXT%", passwordText)
-      .send()
+        multification
+          .create(sender) { it.multification.adminCmdAccountMigratedToNonPremiumSuccess }
+          .placeholder("%USERNAME%", user.username.value)
+          .placeholder("%PASSWORD_TEXT%", passwordText)
+          .send()
+      }
+    } catch (_: EncryptionTaskAlreadyQueuedException) {
+      multification.create(sender) { it.multification.processAlreadyInProgressError }.send()
+    }
   }
 }
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/ForcePremiumAdminCommand.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/ForcePremiumAdminCommand.kt
index 9edb9973..f0865f25 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/ForcePremiumAdminCommand.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/ForcePremiumAdminCommand.kt
@@ -27,7 +27,7 @@ import dev.rollczi.litecommands.annotations.context.Context
 import dev.rollczi.litecommands.annotations.execute.Execute
 import dev.rollczi.litecommands.annotations.permission.Permission
 import pl.spcode.navauth.common.annotation.Description
-import pl.spcode.navauth.common.application.mojang.MojangProfileService
+import pl.spcode.navauth.common.application.mojang.ProfileService
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.command.user.UserArgumentResolver
 import pl.spcode.navauth.common.command.user.UsernameOrUuidRaw
@@ -40,7 +40,7 @@ class ForcePremiumAdminCommand
 @Inject
 constructor(
   val userService: UserService,
-  val profileService: MojangProfileService,
+  val profileService: ProfileService,
   val userArgumentResolver: UserArgumentResolver,
   val multification: VelocityMultification,
 ) {
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/MigrateUserDataAdminCommand.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/MigrateUserDataAdminCommand.kt
index ef0ab454..6e9f1de8 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/MigrateUserDataAdminCommand.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/admin/MigrateUserDataAdminCommand.kt
@@ -28,7 +28,7 @@ import dev.rollczi.litecommands.annotations.context.Context
 import dev.rollczi.litecommands.annotations.execute.Execute
 import dev.rollczi.litecommands.annotations.permission.Permission
 import pl.spcode.navauth.common.annotation.Description
-import pl.spcode.navauth.common.application.mojang.MojangProfileService
+import pl.spcode.navauth.common.application.mojang.ProfileService
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.application.user.UsernameAlreadyTakenException
 import pl.spcode.navauth.common.application.validator.UsernameValidator
@@ -45,7 +45,7 @@ class MigrateUserDataAdminCommand
 constructor(
   val proxyServer: ProxyServer,
   val userService: UserService,
-  val profileService: MojangProfileService,
+  val profileService: ProfileService,
   val userArgumentResolver: UserArgumentResolver,
   val usernameValidator: UsernameValidator,
   val multification: VelocityMultification,
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/ChangePasswordCommand.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/ChangePasswordCommand.kt
index a9fde534..9c3804bd 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/ChangePasswordCommand.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/ChangePasswordCommand.kt
@@ -28,6 +28,7 @@ import dev.rollczi.litecommands.annotations.execute.Execute
 import dev.rollczi.litecommands.annotations.permission.Permission
 import pl.spcode.navauth.common.annotation.Description
 import pl.spcode.navauth.common.application.credentials.UserCredentialsService
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.velocity.command.Permissions
 import pl.spcode.navauth.velocity.multification.VelocityMultification
@@ -58,13 +59,24 @@ constructor(
       return
     }
 
-    val isCorrectPassword = userCredentialsService.verifyPassword(credentials, currentPassword)
-    if (!isCorrectPassword) {
-      multification.send(sender) { it.multification.wrongCredentialsError }
-      return
-    }
+    try {
+      userCredentialsService
+        .enqueueVerifyPassword(credentials, currentPassword, sender.uniqueId)
+        .whenComplete { isCorrect, throwable ->
+          if (throwable != null) {
+            multification.send(sender) { it.multification.unexpectedErrorOccurred }
+            return@whenComplete
+          }
+          if (!isCorrect) {
+            multification.send(sender) { it.multification.wrongCredentialsError }
+            return@whenComplete
+          }
 
-    userCredentialsService.updatePassword(user, newPassword)
-    multification.send(sender) { it.multification.newPasswordSetSuccess }
+          userCredentialsService.updatePassword(user, newPassword)
+          multification.send(sender) { it.multification.newPasswordSetSuccess }
+        }
+    } catch (_: EncryptionTaskAlreadyQueuedException) {
+      multification.send(sender) { it.multification.processAlreadyInProgressError }
+    }
   }
 }
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/LoginCommand.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/LoginCommand.kt
index 7fa402c6..9b164024 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/LoginCommand.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/LoginCommand.kt
@@ -31,7 +31,9 @@ import kotlin.jvm.optionals.getOrNull
 import pl.spcode.navauth.api.domain.auth.AuthSessionType
 import pl.spcode.navauth.common.annotation.Description
 import pl.spcode.navauth.common.application.auth.session.AuthSessionService
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
 import pl.spcode.navauth.common.command.exception.MissingPermissionException
+import pl.spcode.navauth.common.infra.auth.LoginAuthSession
 import pl.spcode.navauth.velocity.command.Permissions
 import pl.spcode.navauth.velocity.infra.auth.VelocityLoginAuthSession
 import pl.spcode.navauth.velocity.infra.auth.VelocityUniqueSessionId
@@ -121,10 +123,27 @@ constructor(
     password: String?,
     code: String?,
   ) {
-    if (session.auth(password, code)) {
-      return
+    try {
+      session.enqueueAuthTask(password, code).whenComplete { result, throwable ->
+        if (throwable != null) {
+          multification.send(sender) { it.multification.unexpectedErrorOccurred }
+          return@whenComplete
+        }
+        when (result) {
+          LoginAuthSession.AuthTaskResult.WrongCredentials -> {
+            multification.send(sender) { it.multification.wrongCredentialsError }
+          }
+          LoginAuthSession.AuthTaskResult.FailedTooManyAttempts -> {
+            // handled by VelocityLoginAuthSession.onTooManyLoginAttempts
+          }
+          LoginAuthSession.AuthTaskResult.Success -> {
+            // handled by VelocityLoginAuthSession.onAuthenticated
+          }
+        }
+      }
+      multification.send(sender) { it.multification.loggingInInfo }
+    } catch (_: EncryptionTaskAlreadyQueuedException) {
+      multification.send(sender) { it.multification.alreadyTryingToLoginError }
     }
-
-    multification.send(sender) { it.multification.wrongCredentialsError }
   }
 }
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/PremiumAccountCommand.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/PremiumAccountCommand.kt
index 46edf00b..581ee9ef 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/PremiumAccountCommand.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/PremiumAccountCommand.kt
@@ -26,7 +26,7 @@ import dev.rollczi.litecommands.annotations.command.Command
 import dev.rollczi.litecommands.annotations.context.Context
 import dev.rollczi.litecommands.annotations.execute.Execute
 import pl.spcode.navauth.common.annotation.Description
-import pl.spcode.navauth.common.application.mojang.MojangProfileService
+import pl.spcode.navauth.common.application.mojang.ProfileService
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.command.exception.MissingPermissionException
 import pl.spcode.navauth.common.domain.user.Username
@@ -39,7 +39,7 @@ class PremiumAccountCommand
 @Inject
 constructor(
   val userService: UserService,
-  val mojangProfileService: MojangProfileService,
+  val mojangProfileService: ProfileService,
   val multification: VelocityMultification,
 ) {
 
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/RegisterCommand.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/RegisterCommand.kt
index 0760f16b..3dedf14b 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/RegisterCommand.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/RegisterCommand.kt
@@ -29,13 +29,14 @@ import dev.rollczi.litecommands.annotations.execute.Execute
 import pl.spcode.navauth.api.domain.auth.AuthSessionType
 import pl.spcode.navauth.common.annotation.Description
 import pl.spcode.navauth.common.application.auth.session.AuthSessionService
+import pl.spcode.navauth.common.application.credentials.UserCredentialsService
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.application.validator.PasswordValidator
 import pl.spcode.navauth.common.command.exception.MissingPermissionException
 import pl.spcode.navauth.common.domain.user.User
 import pl.spcode.navauth.common.domain.user.UserUuid
 import pl.spcode.navauth.common.domain.user.Username
-import pl.spcode.navauth.common.infra.crypto.hasher.BCryptCredentialsHasher
 import pl.spcode.navauth.velocity.command.Permissions
 import pl.spcode.navauth.velocity.infra.auth.VelocityUniqueSessionId
 import pl.spcode.navauth.velocity.infra.player.VelocityPlayerAdapter
@@ -48,6 +49,7 @@ class RegisterCommand
 constructor(
   val authSessionService: AuthSessionService<VelocityPlayerAdapter>,
   val userService: UserService,
+  val userCredentialsService: UserCredentialsService,
   val passwordValidator: PasswordValidator,
   val multification: VelocityMultification,
 ) {
@@ -86,11 +88,19 @@ constructor(
       return
     }
 
-    userService.createAndStoreUserWithNewCredentials(
-      User.nonPremium(UserUuid(sender.uniqueId), Username(sender.username)),
-      BCryptCredentialsHasher().hash(password),
-    )
-    // register session will send success message
-    session.authenticate()
+    try {
+      userCredentialsService.enqueueHashPassword(password, sender.uniqueId).thenAccept {
+        hashedPassword ->
+        userService.createAndStoreUserWithNewCredentials(
+          User.nonPremium(UserUuid(sender.uniqueId), Username(sender.username)),
+          hashedPassword,
+        )
+        // register session will send success message
+        session.authenticate()
+      }
+      multification.send(sender) { it.multification.registeringInfo }
+    } catch (_: EncryptionTaskAlreadyQueuedException) {
+      multification.send(sender) { it.multification.processAlreadyInProgressError }
+    }
   }
 }
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/TwoFactorSetupCommand.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/TwoFactorSetupCommand.kt
index 8aa7f6fc..e923b7e6 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/TwoFactorSetupCommand.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/command/user/TwoFactorSetupCommand.kt
@@ -27,9 +27,11 @@ import dev.rollczi.litecommands.annotations.command.RootCommand
 import dev.rollczi.litecommands.annotations.context.Context
 import dev.rollczi.litecommands.annotations.execute.Execute
 import java.util.Optional
+import java.util.concurrent.CompletableFuture
 import net.kyori.adventure.text.minimessage.MiniMessage
 import pl.spcode.navauth.common.annotation.Description
 import pl.spcode.navauth.common.application.credentials.UserCredentialsService
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionTaskAlreadyQueuedException
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.command.exception.MissingPermissionException
 import pl.spcode.navauth.common.config.MessagesConfig
@@ -83,28 +85,40 @@ constructor(
         return
       }
 
-      val isCorrectPassword =
-        userCredentialsService.verifyPassword(credentials, currentPassword.get())
-      if (!isCorrectPassword) {
-        multification.send(sender) { it.multification.wrongCredentialsError }
-        return
+      try {
+        userCredentialsService
+          .enqueueVerifyPassword(credentials, currentPassword.get(), sender.uniqueId)
+          .whenComplete { isCorrect, throwable ->
+            CompletableFuture.supplyAsync {
+              if (throwable != null) {
+                multification.send(sender) { it.multification.unexpectedErrorOccurred }
+                return@supplyAsync
+              }
+              if (!isCorrect) {
+                multification.send(sender) { it.multification.wrongCredentialsError }
+                return@supplyAsync
+              }
+
+              val secret = TOTP2FA().generateSecret()
+              val session =
+                totpSetupSessionFactory.createSession(VelocityPlayerAdapter(sender), secret)
+              totpSetupSessionService.registerSession(UserUuid(sender.uniqueId), session)
+
+              val remainingSeconds = TotpSetupSessionService.SESSION_LIFETIME_SECONDS
+              multification
+                .create()
+                .player(sender.uniqueId)
+                .notice(messages.multification.twoFactorSetupInstruction)
+                .placeholder("%SECRET%", secret.value)
+                .placeholder("%REMAINING_SECONDS%", remainingSeconds.toString())
+                .send()
+            }
+          }
+      } catch (_: EncryptionTaskAlreadyQueuedException) {
+        multification.send(sender) { it.multification.processAlreadyInProgressError }
       }
+      return
     }
-
-    val secret = TOTP2FA().generateSecret()
-    val session = totpSetupSessionFactory.createSession(VelocityPlayerAdapter(sender), secret)
-    totpSetupSessionService.registerSession(UserUuid(sender.uniqueId), session)
-
-    val remainingSeconds = TotpSetupSessionService.SESSION_LIFETIME_SECONDS
-    multification
-      .create()
-      .player(sender.uniqueId)
-      .notice(messages.multification.twoFactorSetupInstruction)
-      .placeholder("%SECRET%", secret.value)
-      .placeholder("%REMAINING_SECONDS%", remainingSeconds.toString())
-      .send()
-
-    return
   }
 
   @Async
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/infra/auth/VelocityLoginAuthSession.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/infra/auth/VelocityLoginAuthSession.kt
index 5a0893f7..f557f641 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/infra/auth/VelocityLoginAuthSession.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/infra/auth/VelocityLoginAuthSession.kt
@@ -38,10 +38,10 @@ class VelocityLoginAuthSession(
   userCredentials: UserCredentials,
   userCredentialsService: UserCredentialsService,
   scheduler: NavAuthScheduler,
-  val velocityEventDispatcher: VelocityEventDispatcher,
-  val multification: VelocityMultification,
+  private val velocityEventDispatcher: VelocityEventDispatcher,
+  private val multification: VelocityMultification,
   generalConfig: GeneralConfig,
-  val messagesConfig: MessagesConfig,
+  private val messagesConfig: MessagesConfig,
   eventBus: NavAuthEventBus,
 ) :
   LoginAuthSession<VelocityPlayerAdapter>(
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/listener/velocity/ConnectionListeners.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/listener/velocity/ConnectionListeners.kt
index a5714e48..f7b15caa 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/listener/velocity/ConnectionListeners.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/listener/velocity/ConnectionListeners.kt
@@ -29,6 +29,7 @@ import net.kyori.adventure.text.Component
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import pl.spcode.navauth.common.application.auth.session.AuthSessionService
+import pl.spcode.navauth.common.application.credentials.queue.EncryptionQueueService
 import pl.spcode.navauth.common.application.user.UserActivitySessionService
 import pl.spcode.navauth.common.component.TextColors
 import pl.spcode.navauth.common.config.GeneralConfig
@@ -43,6 +44,7 @@ class ConnectionListeners
 @Inject
 constructor(
   val authSessionService: AuthSessionService<VelocityPlayerAdapter>,
+  val encryptionQueueService: EncryptionQueueService,
   val serverSelectionService: VelocityServerSelectionService,
   val userActivitySessionService: UserActivitySessionService,
   val generalConfig: GeneralConfig,
@@ -53,6 +55,7 @@ constructor(
   @Subscribe
   fun onDisconnect(event: DisconnectEvent) {
     authSessionService.closeSession(VelocityUniqueSessionId(event.player))
+    encryptionQueueService.dequeueTask(event.player.uniqueId)
     userActivitySessionService.storePlayerSessionOnLeave(VelocityPlayerAdapter(event.player))
   }
 
diff --git a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/listener/velocity/LoginListeners.kt b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/listener/velocity/LoginListeners.kt
index c881c490..366ff91a 100644
--- a/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/listener/velocity/LoginListeners.kt
+++ b/navauth-velocity/src/main/kotlin/pl/spcode/navauth/velocity/listener/velocity/LoginListeners.kt
@@ -30,13 +30,13 @@ import net.kyori.adventure.text.Component
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 import pl.spcode.navauth.common.application.auth.handshake.AuthHandshakeSessionService
+import pl.spcode.navauth.common.application.auth.username.PostUsernameResolutionState
 import pl.spcode.navauth.common.application.auth.username.UsernameResFailureReason
 import pl.spcode.navauth.common.application.auth.username.UsernameResResult
 import pl.spcode.navauth.common.application.auth.username.UsernameResolutionService
 import pl.spcode.navauth.common.application.user.UserService
 import pl.spcode.navauth.common.application.validator.UsernameValidator
 import pl.spcode.navauth.common.component.TextColors
-import pl.spcode.navauth.common.component.TextComponent
 import pl.spcode.navauth.common.config.GeneralConfig
 import pl.spcode.navauth.common.config.MessagesConfig
 import pl.spcode.navauth.common.domain.auth.handshake.AuthHandshakeSession
@@ -131,9 +131,20 @@ constructor(
       return
     }
 
+    val sessionUser =
+      if (
+        res is UsernameResResult.Success &&
+          res.postResolutionState != PostUsernameResolutionState.NO_CHANGE
+      ) {
+        // re-fetch if any change occurred
+        userService.findUserByUsernameIgnoreCase(connUsername)
+      } else {
+        existingUser
+      }
+
     authHandshakeSessionService.createSession(
       VelocityUniqueSessionId(connUsername, event.connection.remoteAddress),
-      existingUser,
+      sessionUser,
       connUsername,
       res,
     )
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 18703120..7387b9c7 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -4,4 +4,6 @@ include("navauth-common")
 include("navauth-velocity")
 include("navauth-docs-gen")
 include("navauth-api")
-include("navauth-api-examples")
\ No newline at end of file
+include("navauth-api-examples")
+include("integration")
+include("integration:ajqueue")
\ No newline at end of file