baltica 0.1.17 → 0.1.18

package/dist/client/client.js

@@ -176,8 +176,8 @@ class Client extends shared_1.Emitter {
                 serverBoundLoadingScreen.type =
                     protocol_1.ServerboundLoadingScreenType.EndLoadingScreen;
                 serverBoundLoadingScreen.hasScreenId = false;
-                this.send(init);
                 this.send(serverBoundLoadingScreen);
+                this.send(init);
                 this.emit("SetLocalPlayerAsInitializedPacket", init);
             }
         });

package/dist/client/types/client-options.d.ts

@@ -43,6 +43,10 @@ export type ClientOptions = {
     compressionMethod: CompressionMethod;
     /** Whether to emit unknown packets as buffer */
     emitUnknownPackets: boolean;
+    /** Email for direct email/password authentication (requires 2FA disabled) */
+    email?: string;
+    /** Password for direct email/password authentication (requires 2FA disabled) */
+    password?: string;
 };
 /** Default Client Options */
 export declare const defaultClientOptions: ClientOptions;

package/dist/shared/auth/authentication.d.ts

@@ -0,0 +1,20 @@
+import { authenticate as xboxAuthenticate, live, xnet } from "@xboxreplay/xboxlive-auth";
+import type { AuthenticateResponse, Email } from "@xboxreplay/xboxlive-auth";
+export interface BedrockTokens {
+    chains: string[];
+    xuid: string;
+    gamertag: string;
+    userHash: string;
+}
+export interface AuthOptions {
+    email: string;
+    password: string;
+    clientPublicKey: string;
+}
+/**
+ * Authenticates with Xbox Live using email/password and obtains Minecraft Bedrock tokens
+ * NOTE: Only works if 2FA is DISABLED on the Microsoft account
+ */
+export declare function authenticateWithCredentials(options: AuthOptions): Promise<BedrockTokens>;
+export { xboxAuthenticate as authenticate, live, xnet };
+export type { AuthenticateResponse, Email };

package/dist/shared/auth/authentication.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xnet = exports.live = exports.authenticate = void 0;
+exports.authenticateWithCredentials = authenticateWithCredentials;
+const xboxlive_auth_1 = require("@xboxreplay/xboxlive-auth");
+Object.defineProperty(exports, "authenticate", { enumerable: true, get: function () { return xboxlive_auth_1.authenticate; } });
+Object.defineProperty(exports, "live", { enumerable: true, get: function () { return xboxlive_auth_1.live; } });
+Object.defineProperty(exports, "xnet", { enumerable: true, get: function () { return xboxlive_auth_1.xnet; } });
+const raknet_1 = require("@sanctumterra/raknet");
+const MINECRAFT_BEDROCK_RELYING_PARTY = "https://multiplayer.minecraft.net/";
+/**
+ * Authenticates with Xbox Live using email/password and obtains Minecraft Bedrock tokens
+ * NOTE: Only works if 2FA is DISABLED on the Microsoft account
+ */
+async function authenticateWithCredentials(options) {
+    const { email, password, clientPublicKey } = options;
+    raknet_1.Logger.info("Authenticating with Xbox Live...");
+    try {
+        const liveToken = await xboxlive_auth_1.live.authenticateWithCredentials({
+            email: email,
+            password,
+        });
+        // Exchange for Xbox user token
+        const userTokenResp = await xboxlive_auth_1.xnet.exchangeRpsTicketForUserToken(liveToken.access_token, "t");
+        const userHash = userTokenResp.DisplayClaims.xui[0].uhs;
+        // Get XSTS token for Minecraft Bedrock
+        const xstsResp = await xboxlive_auth_1.xnet.exchangeTokenForXSTSToken(userTokenResp.Token, {
+            XSTSRelyingParty: MINECRAFT_BEDROCK_RELYING_PARTY,
+            sandboxId: "RETAIL",
+        });
+        const xuid = xstsResp.DisplayClaims.xui[0].xid || "";
+        // Get Minecraft Bedrock chains using the client's public key
+        const chains = await getMinecraftBedrockChains(xstsResp.Token, userHash, clientPublicKey);
+        const gamertag = extractGamertagFromChains(chains);
+        raknet_1.Logger.info(`Authenticated as: ${gamertag} (${xuid})`);
+        return { chains, xuid, gamertag, userHash };
+    }
+    catch (error) {
+        const err = error;
+        if (err.attributes?.code === "INVALID_CREDENTIALS_OR_2FA_ENABLED") {
+            throw new Error("Authentication failed: Invalid credentials or 2FA is enabled.\n" +
+                "Direct email/password login only works with 2FA DISABLED.");
+        }
+        throw error;
+    }
+}
+async function getMinecraftBedrockChains(xstsToken, userHash, clientPublicKey) {
+    const response = await fetch("https://multiplayer.minecraft.net/authentication", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `XBL3.0 x=${userHash};${xstsToken}`,
+            "Client-Version": "1.21.130",
+        },
+        body: JSON.stringify({ identityPublicKey: clientPublicKey }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Minecraft Bedrock auth failed: ${response.status} - ${text}`);
+    }
+    const data = (await response.json());
+    return data.chain || [];
+}
+function extractGamertagFromChains(chains) {
+    for (const chain of chains) {
+        try {
+            const [, payload] = chain.split(".");
+            if (payload) {
+                const decoded = JSON.parse(Buffer.from(payload, "base64").toString());
+                if (decoded.extraData?.displayName) {
+                    return decoded.extraData.displayName;
+                }
+            }
+        }
+        catch {
+            /* continue */
+        }
+    }
+    return "";
+}

package/dist/shared/auth.js

@@ -44,6 +44,7 @@ const node_crypto_1 = require("node:crypto");
 const prismarine_auth_1 = require("prismarine-auth");
 const uuid_1345_1 = require("uuid-1345");
 const types_1 = require("./types");
+const authentication_1 = require("./auth/authentication");
 exports.UUID_NAMESPACE = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
 const PUBLIC_KEY = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAECRXueJeTDqNRRgJi/vlRufByu/2G0i2Ebt6YMar5QX/R0DIIyrJMcUpruK4QveTfJSTp3Shlq4Gk34cD/4GUWwkv0DVuzeuB+tXija7HBxii03NHDbPAD0AKnLr2wdAp";
 async function createOfflineSession(client) {
@@ -69,6 +70,11 @@ async function createOfflineSession(client) {
 }
 async function authenticate(client) {
     const startTime = Date.now();
+    // Check if email/password auth is requested
+    if (client.options.email && client.options.password) {
+        return authenticateWithEmailPassword(client);
+    }
+    // Default: use prismarine-auth (device code flow)
     try {
         const authflow = createAuthflow(client);
         const chains = await getMinecraftBedrockToken(authflow, client);
@@ -87,6 +93,36 @@ async function authenticate(client) {
         throw error;
     }
 }
+/**
+ * Authenticate using email/password directly (requires 2FA disabled)
+ */
+async function authenticateWithEmailPassword(client) {
+    const startTime = Date.now();
+    try {
+        if (!client.options.email || !client.options.password) {
+            throw new Error("Email and password are required for email/password authentication");
+        }
+        const tokens = await (0, authentication_1.authenticateWithCredentials)({
+            email: client.options.email,
+            password: client.options.password,
+            clientPublicKey: client.data.loginData.clientX509,
+        });
+        const profile = {
+            name: tokens.gamertag,
+            uuid: generateUUID(tokens.gamertag),
+            xuid: Number(tokens.xuid) || 0,
+        };
+        const endTime = Date.now();
+        raknet_1.Logger.info(`Authentication with Xbox (email/password) took ${(endTime - startTime) / 1000}s.`);
+        setupClientProfile(client, profile, tokens.chains);
+        await setupClientChains(client);
+        client.emit("session");
+    }
+    catch (error) {
+        raknet_1.Logger.error(`Email/password authentication failed: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
 async function getMultiplayerSessionToken(authflow, client) {
     try {
         // @ts-expect-error Method exists at runtime

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "baltica",
   "description": "Library for Minecraft Bedrock Edition community developers.",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "minecraft": "1.21.130",
   "main": "dist/index.js",
   "license": "MIT",
@@ -21,9 +21,10 @@
     }
   ],
   "dependencies": {
-    "@sanctumterra/raknet": "^1.4.0",
+    "@sanctumterra/raknet": "^1.4.7",
     "@serenityjs/binarystream": "^3.0.10",
     "@serenityjs/protocol": "^0.8.14",
+    "@xboxreplay/xboxlive-auth": "^5.1.0",
     "jose": "^5.10.0",
     "prismarine-auth": "^2.7.0",
     "uuid-1345": "^1.0.2"