apK

.github/workflows/build.yml

@@ -0,0 +1,17 @@
+name: Build APK
+on: workflow_dispatch
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: '17'
+      - run: chmod +x gradlew
+      - run: ./gradlew assembleRelease
+      - uses: actions/upload-artifact@v4
+        with:
+          name: apk
+          path: app/build/outputs/apk/**/*.apk

PLACEMENT_FIX_NOTES.md

@@ -0,0 +1,12 @@
+# Placement fix
+
+This revision aligns PistonCrystal/Surround placement with the decompiled latest WClient:
+- cache a real outgoing ITEM_USE placement transaction as a template;
+- clone that transaction for module placements so newer protocol fields are preserved;
+- use the protocol BlockDefinition from the held ItemData directly;
+- sanitize ItemData net-id before sending;
+- rebuild server-authoritative inventory actions;
+- keep local block state updated immediately.
+
+The decompiled latest WClient Scaffold (`com.retrivedmods.wclient.game.module.misc.a1`)
+was used as the behavioral reference.

app/proguard-rules.pro

@@ -3,6 +3,17 @@
 -keep class io.netty.** { *; }
 -keep class org.cloudburstmc.netty.** { *; }
 -keep class org.cloudburstmc.protocol.bedrock.codec.** { *; }
+# com.retrivedmods.wclient.util.PacketFieldUtil sets several packet fields (TextPacket.message,
+# MovePlayerPacket.onGround, PlayerHotbarPacket.selectHotbarSlot, etc.) via raw reflection using
+# string field names, because those fields no longer have public setters in the current Bedrock
+# protocol library. Nothing else in the app references those fields by name, so without a keep
+# rule R8 is free to rename or strip them in a release build - which is exactly what caused
+# NoSuchFieldException crashes (e.g. "Field 'message' not found in ...") the moment a module that
+# hits one of these reflective sets actually ran. Keeping the whole packet/data packages (not just
+# the specific classes/fields used today) means future PacketFieldUtil usages don't silently
+# reintroduce the same crash.
+-keep class org.cloudburstmc.protocol.bedrock.packet.** { *; }
+-keep class org.cloudburstmc.protocol.bedrock.data.** { *; }
 -keep @io.netty.channel.ChannelHandler$Sharable class *
 -keepclassmembers class * {
     @com.google.gson.annotations.SerializedName <fields>;

app/src/main/java/com/retrivedmods/wclient/activity/MainActivity.kt

@@ -76,22 +76,8 @@ class MainActivity : ComponentActivity() {
                 if (showLoading) {
                     LoadingScreen(
                         onDone = {
-                            lifecycleScope.launch {
-                                wclientId = VerificationManager.getWClientId(this@MainActivity)
-
-                                if (VerificationManager.isWhitelisted(this@MainActivity, wclientId)) {
-                                    showLoading = false
-                                    return@launch
-                                }
-
-                                if (VerificationManager.isVerified(this@MainActivity, wclientId)) {
-                                    showLoading = false
-                                    return@launch
-                                }
-
-                                showLoading = false
-                                showVerificationDialog = true
-                            }
+                            // WClient ID verification (ad-gate) disabled - go straight in.
+                            showLoading = false
                         }
                     )
                 } else if (showVerificationDialog) {

app/src/main/java/com/retrivedmods/wclient/game/AccountManager.kt

@@ -6,37 +6,46 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
 import com.google.gson.JsonParser
 import com.retrivedmods.wclient.application.AppContext
-import com.retrivedmods.wclient.game.RealmsAuthFlow
 import com.retrivedmods.wclient.service.RealmsManager
 import com.retrivedmods.wrelay.util.AuthUtils
-import com.retrivedmods.wrelay.util.refresh
 import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import net.raphimc.minecraftauth.MinecraftAuth
-import net.raphimc.minecraftauth.step.bedrock.session.StepFullBedrockSession.FullBedrockSession
+import net.raphimc.minecraftauth.bedrock.BedrockAuthManager
 import java.io.File
 import java.util.concurrent.TimeUnit
 
 object AccountManager {
 
+    // Bedrock game version reported to Mojang/Xbox services when negotiating a Minecraft
+    // session (net.raphimc.minecraftauth.bedrock.model.MinecraftSession). Keep this in sync with
+    // com.retrivedmods.wclient.util.MinecraftUtils.RECOMMENDED_VERSION.
+    const val GAME_VERSION = "1.26.40"
+
+    // BedrockAuthManager (5.x) is a live, self-refreshing manager object rather than the old
+    // immutable FullBedrockSession, so we pair it with a plain cached display name for UI use
+    // (looking up the name via the manager would be a network call if the token had expired).
+    data class WAccount(
+        val authManager: BedrockAuthManager,
+        val displayName: String
+    )
+
     private val coroutineScope =
         CoroutineScope(Dispatchers.IO + CoroutineName("AccountManagerCoroutine"))
 
-    private val _accounts: MutableList<FullBedrockSession> = mutableStateListOf()
+    private val _accounts: MutableList<WAccount> = mutableStateListOf()
 
-    val accounts: List<FullBedrockSession>
+    val accounts: List<WAccount>
         get() = _accounts
 
-    var selectedAccount: FullBedrockSession? by mutableStateOf(null)
+    var selectedAccount: WAccount? by mutableStateOf(null)
         private set
 
     private val TOKEN_REFRESH_INTERVAL_MS = TimeUnit.MINUTES.toMillis(30)
 
-    private val TOKEN_REFRESH_THRESHOLD_MS = TimeUnit.HOURS.toMillis(2)
-
     init {
         val fetchedAccounts = fetchAccounts()
 
@@ -48,114 +57,92 @@ object AccountManager {
         startTokenRefreshScheduler()
     }
 
-    fun addAccount(fullBedrockSession: FullBedrockSession) {
-        val existingAccount = _accounts.find { it.mcChain.displayName == fullBedrockSession.mcChain.displayName }
+    fun addAccount(authManager: BedrockAuthManager) {
+        val displayName = authManager.minecraftCertificateChain.getUpToDate().identityDisplayName
+        val account = WAccount(authManager, displayName)
+
+        val existingAccount = _accounts.find { it.displayName == displayName }
         if (existingAccount != null) {
             _accounts.remove(existingAccount)
         }
 
-        _accounts.add(fullBedrockSession)
-
-        coroutineScope.launch {
-            val file = File(AppContext.instance.cacheDir, "accounts")
-            file.mkdirs()
+        _accounts.add(account)
 
-            try {
-                val json = if (fullBedrockSession.realmsXsts != null) {
-                    RealmsAuthFlow.BEDROCK_DEVICE_CODE_LOGIN_WITH_REALMS.toJson(fullBedrockSession)
-                } else {
-                    println("No Realms token available, saving with regular auth flow")
-                    MinecraftAuth.BEDROCK_DEVICE_CODE_LOGIN.toJson(fullBedrockSession)
-                }
-                file.resolve("${fullBedrockSession.mcChain.displayName}.json")
-                    .writeText(AuthUtils.gson.toJson(json))
-                println("Successfully saved account: ${fullBedrockSession.mcChain.displayName} - Realms support: ${fullBedrockSession.realmsXsts != null}")
-            } catch (e: Exception) {
-                println("Failed to save account with Realms support, trying fallback: ${e.message}")
-                try {
-                    val json = MinecraftAuth.BEDROCK_DEVICE_CODE_LOGIN.toJson(fullBedrockSession)
-                    file.resolve("${fullBedrockSession.mcChain.displayName}.json")
-                        .writeText(AuthUtils.gson.toJson(json))
-                    println("Successfully saved account with fallback method: ${fullBedrockSession.mcChain.displayName}")
-                } catch (fallbackException: Exception) {
-                    println("Failed to save account even with fallback: ${fallbackException.message}")
-                    fallbackException.printStackTrace()
-                }
-            }
+        if (existingAccount == selectedAccount) {
+            selectAccount(account)
         }
+
+        saveAccountToDisk(account)
     }
 
-    fun removeAccount(fullBedrockSession: FullBedrockSession) {
-        _accounts.remove(fullBedrockSession)
+    fun removeAccount(account: WAccount) {
+        _accounts.remove(account)
 
         coroutineScope.launch {
             val file = File(AppContext.instance.cacheDir, "accounts")
             file.mkdirs()
 
-            file.resolve("${fullBedrockSession.mcChain.displayName}.json")
-                .delete()
+            file.resolve("${account.displayName}.json").delete()
         }
     }
 
-    fun selectAccount(fullBedrockSession: FullBedrockSession?) {
-        selectedAccount = fullBedrockSession
+    fun selectAccount(account: WAccount?) {
+        selectedAccount = account
 
-        RealmsManager.updateSession(fullBedrockSession)
+        RealmsManager.updateSession(account)
 
         coroutineScope.launch {
             val file = File(AppContext.instance.cacheDir, "accounts")
             file.mkdirs()
 
             runCatching {
-                val selectedAccount = file.resolve("selectedAccount")
-                if (fullBedrockSession != null) {
-                    selectedAccount.writeText(fullBedrockSession.mcChain.displayName)
+                val selectedAccountFile = file.resolve("selectedAccount")
+                if (account != null) {
+                    selectedAccountFile.writeText(account.displayName)
                 } else {
-                    selectedAccount.delete()
+                    selectedAccountFile.delete()
                 }
             }
         }
     }
 
-    private fun fetchAccounts(): List<FullBedrockSession> {
+    private fun fetchAccounts(): List<WAccount> {
         val file = File(AppContext.instance.cacheDir, "accounts")
         file.mkdirs()
 
-        val accounts = ArrayList<FullBedrockSession>()
+        val accounts = ArrayList<WAccount>()
         val listFiles = file.listFiles() ?: emptyArray()
         for (child in listFiles) {
             runCatching {
                 if (child.isFile && child.extension == "json") {
-                    val account = try {
-                        RealmsAuthFlow.BEDROCK_DEVICE_CODE_LOGIN_WITH_REALMS
-                            .fromJson(JsonParser.parseString(child.readText()).asJsonObject)
-                    } catch (e: Exception) {
-                        println("Failed to load account with Realms support from ${child.name}, trying legacy format: ${e.message}")
-                        MinecraftAuth.BEDROCK_DEVICE_CODE_LOGIN
-                            .fromJson(JsonParser.parseString(child.readText()).asJsonObject)
-                    }
-                    accounts.add(account)
-                    println("Loaded account ${account.mcChain.displayName} - Realms support: ${account.realmsXsts != null}")
+                    val httpClient = MinecraftAuth.createHttpClient()
+                    val json = JsonParser.parseString(child.readText()).asJsonObject
+                    val authManager = BedrockAuthManager.fromJson(httpClient, GAME_VERSION, json)
+                    val displayName =
+                        authManager.minecraftCertificateChain.getUpToDate().identityDisplayName
+                    accounts.add(WAccount(authManager, displayName))
+                    println("Loaded account $displayName")
                 }
             }.onFailure {
                 println("Failed to load account from ${child.name}: ${it.message}")
+                it.printStackTrace()
             }
         }
 
         return accounts
     }
 
-    private fun fetchSelectedAccount(): FullBedrockSession? {
+    private fun fetchSelectedAccount(): WAccount? {
         val file = File(AppContext.instance.cacheDir, "accounts")
         file.mkdirs()
 
-        val selectedAccount = file.resolve("selectedAccount")
-        if (!selectedAccount.exists() || selectedAccount.isDirectory) {
+        val selectedAccountFile = file.resolve("selectedAccount")
+        if (!selectedAccountFile.exists() || selectedAccountFile.isDirectory) {
             return null
         }
 
-        val displayName = selectedAccount.readText()
-        return accounts.find { it.mcChain.displayName == displayName }
+        val displayName = selectedAccountFile.readText()
+        return accounts.find { it.displayName == displayName }
     }
 
     private fun startTokenRefreshScheduler() {
@@ -178,95 +165,34 @@ object AccountManager {
             return
         }
 
-        val accountsToRefresh = _accounts.filter { account ->
-            shouldRefreshToken(account)
-        }
-
-        if (accountsToRefresh.isNotEmpty()) {
-            println("Found ${accountsToRefresh.size} accounts that need token refresh")
-        }
-
-        accountsToRefresh.forEach { account ->
+        _accounts.forEach { account ->
             try {
-                println("Refreshing token for account: ${account.mcChain.displayName}")
-                val httpClient = MinecraftAuth.createHttpClient()
-                httpClient.connectTimeout = 10000
-                httpClient.readTimeout = 10000
-
-                val refreshedAccount = try {
-                    if (account.realmsXsts != null) {
-                        RealmsAuthFlow.BEDROCK_DEVICE_CODE_LOGIN_WITH_REALMS.refresh(httpClient, account)
-                    } else {
-                        account.refresh()
-                    }
-                } catch (e: Exception) {
-                    println("Failed to refresh with Realms support, trying regular refresh: ${e.message}")
-                    account.refresh()
-                }
-
-                val index = _accounts.indexOf(account)
-                if (index >= 0) {
-                    _accounts[index] = refreshedAccount
-
-                    if (selectedAccount == account) {
-                        selectedAccount = refreshedAccount
-                        RealmsManager.updateSession(refreshedAccount)
-                    }
-
-                    saveAccountToDisk(refreshedAccount)
-                }
-
-                println("Successfully refreshed token for: ${refreshedAccount.mcChain.displayName}")
+                // getUpToDate() only performs a network refresh when the cached value is
+                // missing/expired, so this is a no-op for accounts that are already fresh -
+                // no more manually tracking expiry thresholds or swapping session objects.
+                account.authManager.minecraftCertificateChain.getUpToDate()
+                account.authManager.playFabToken.getUpToDate()
+                saveAccountToDisk(account)
             } catch (e: Exception) {
-                println("Failed to refresh token for ${account.mcChain.displayName}: ${e.message}")
+                println("Failed to refresh token for ${account.displayName}: ${e.message}")
                 e.printStackTrace()
             }
         }
     }
 
-    private fun shouldRefreshToken(account: FullBedrockSession): Boolean {
-        val currentTime = System.currentTimeMillis()
-
-        val msaToken = account.mcChain.xblXsts.initialXblSession.msaToken
-        if (msaToken.expireTimeMs - currentTime < TOKEN_REFRESH_THRESHOLD_MS) {
-            return true
-        }
-
-        val xblExpireTime = account.mcChain.xblXsts.expireTimeMs
-        if (xblExpireTime - currentTime < TOKEN_REFRESH_THRESHOLD_MS) {
-            return true
-        }
-
-        val playFabExpireTime = account.playFabToken.expireTimeMs
-        if (playFabExpireTime - currentTime < TOKEN_REFRESH_THRESHOLD_MS) {
-            return true
-        }
-
-        return false
-    }
-
-    private fun saveAccountToDisk(account: FullBedrockSession) {
-        val file = File(AppContext.instance.cacheDir, "accounts")
-        file.mkdirs()
+    private fun saveAccountToDisk(account: WAccount) {
+        coroutineScope.launch {
+            val file = File(AppContext.instance.cacheDir, "accounts")
+            file.mkdirs()
 
-        try {
-            val json = if (account.realmsXsts != null) {
-                RealmsAuthFlow.BEDROCK_DEVICE_CODE_LOGIN_WITH_REALMS.toJson(account)
-            } else {
-                MinecraftAuth.BEDROCK_DEVICE_CODE_LOGIN.toJson(account)
-            }
-            file.resolve("${account.mcChain.displayName}.json")
-                .writeText(AuthUtils.gson.toJson(json))
-        } catch (e: Exception) {
-            println("Failed to save account with Realms support, trying fallback: ${e.message}")
             try {
-                val json = MinecraftAuth.BEDROCK_DEVICE_CODE_LOGIN.toJson(account)
-                file.resolve("${account.mcChain.displayName}.json")
+                val json = BedrockAuthManager.toJson(account.authManager)
+                file.resolve("${account.displayName}.json")
                     .writeText(AuthUtils.gson.toJson(json))
-            } catch (fallbackException: Exception) {
-                println("Failed to save account even with fallback: ${fallbackException.message}")
-                fallbackException.printStackTrace()
+            } catch (e: Exception) {
+                println("Failed to save account ${account.displayName}: ${e.message}")
+                e.printStackTrace()
             }
         }
     }
-}
+}