baltica 0.1.22 → 0.1.23

package/README.md

@@ -91,6 +91,7 @@ const client = new Client({
     userId: "proxy-username",    // Optional
     password: "proxy-password",  // Optional
   },
+  skinFile: `./skins/skin.png`, // If you want to load a skin from a png file
 });
 
 await client.connect();

package/dist/client/client.js

@@ -57,6 +57,8 @@ class Client extends shared_1.Emitter {
         this.packetCompressor = new shared_1.PacketCompressor(this);
         this.handleGamePackets();
         this.raknet.on("encapsulated", this.handleEncapsulated.bind(this));
+        // Wait for authentication to complete before sending network settings request
+        await this.waitForSessionReady();
         const request = new protocol_1.RequestNetworkSettingsPacket();
         request.protocol = types_1.ProtocolList[types_1.CurrentVersionConst];
         this.send(request);

package/dist/client/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./worker";
 export * from "./types";
 export * from "./client";
+export * from "./skin-loader";

package/dist/client/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./worker"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./client"), exports);
+__exportStar(require("./skin-loader"), exports);

package/dist/client/skin-loader.d.ts

@@ -0,0 +1,38 @@
+import type { SkinData } from "./types/payload";
+/**
+ * Load a Minecraft Bedrock skin from a PNG file
+ * @param pngPath - Path to the PNG skin file (64x64 or 64x32)
+ * @returns SkinData object ready to use in client options
+ *
+ * @example
+ * ```typescript
+ * import { Client, loadSkinFromPNG } from 'baltica';
+ *
+ * const client = new Client({
+ *     address: "play.example.com",
+ *     port: 19132,
+ *     skinData: loadSkinFromPNG('./my-skin.png')
+ * });
+ * ```
+ */
+export declare function loadSkinFromPNG(pngPath: string): SkinData;
+/**
+ * Load a Minecraft Bedrock skin from raw RGBA buffer
+ * @param buffer - Raw RGBA pixel data buffer
+ * @param width - Skin width (typically 64)
+ * @param height - Skin height (typically 64 or 32)
+ * @returns SkinData object ready to use in client options
+ *
+ * @example
+ * ```typescript
+ * import { Client, loadSkinFromBuffer } from 'baltica';
+ *
+ * const rgbaBuffer = Buffer.from([...]); // Your RGBA data
+ * const client = new Client({
+ *     address: "play.example.com",
+ *     port: 19132,
+ *     skinData: loadSkinFromBuffer(rgbaBuffer, 64, 64)
+ * });
+ * ```
+ */
+export declare function loadSkinFromBuffer(buffer: Buffer, width: number, height: number): SkinData;

package/dist/client/skin-loader.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSkinFromPNG = loadSkinFromPNG;
+exports.loadSkinFromBuffer = loadSkinFromBuffer;
+const fs = __importStar(require("node:fs"));
+const pngjs_1 = require("pngjs");
+/**
+ * Load a Minecraft Bedrock skin from a PNG file
+ * @param pngPath - Path to the PNG skin file (64x64 or 64x32)
+ * @returns SkinData object ready to use in client options
+ *
+ * @example
+ * ```typescript
+ * import { Client, loadSkinFromPNG } from 'baltica';
+ *
+ * const client = new Client({
+ *     address: "play.example.com",
+ *     port: 19132,
+ *     skinData: loadSkinFromPNG('./my-skin.png')
+ * });
+ * ```
+ */
+function loadSkinFromPNG(pngPath) {
+    // Read and parse PNG file
+    const pngData = fs.readFileSync(pngPath);
+    const png = pngjs_1.PNG.sync.read(pngData);
+    // Validate dimensions
+    if (png.width !== 64 || (png.height !== 64 && png.height !== 32)) {
+        throw new Error(`Invalid skin dimensions: ${png.width}x${png.height}. Expected 64x64 or 64x32`);
+    }
+    // Convert RGBA pixel data to base64
+    const base64Skin = png.data.toString("base64");
+    // Create skin resource patch for standard humanoid model
+    const resourcePatch = {
+        geometry: {
+            default: "geometry.humanoid.custom",
+        },
+    };
+    return {
+        AnimatedImageData: [],
+        ArmSize: "wide",
+        CapeData: "",
+        CapeId: "",
+        CapeImageHeight: 0,
+        CapeImageWidth: 0,
+        CapeOnClassicSkin: false,
+        PersonaPieces: [],
+        PersonaSkin: false,
+        PieceTintColors: [],
+        PremiumSkin: false,
+        SkinAnimationData: "",
+        SkinColor: "#0",
+        SkinData: base64Skin,
+        SkinGeometryData: "",
+        SkinGeometryDataEngineVersion: "",
+        SkinId: `custom_skin_${Date.now()}`,
+        SkinImageHeight: png.height,
+        SkinImageWidth: png.width,
+        SkinResourcePatch: Buffer.from(JSON.stringify(resourcePatch)).toString("base64"),
+        TrustedSkin: true,
+    };
+}
+/**
+ * Load a Minecraft Bedrock skin from raw RGBA buffer
+ * @param buffer - Raw RGBA pixel data buffer
+ * @param width - Skin width (typically 64)
+ * @param height - Skin height (typically 64 or 32)
+ * @returns SkinData object ready to use in client options
+ *
+ * @example
+ * ```typescript
+ * import { Client, loadSkinFromBuffer } from 'baltica';
+ *
+ * const rgbaBuffer = Buffer.from([...]); // Your RGBA data
+ * const client = new Client({
+ *     address: "play.example.com",
+ *     port: 19132,
+ *     skinData: loadSkinFromBuffer(rgbaBuffer, 64, 64)
+ * });
+ * ```
+ */
+function loadSkinFromBuffer(buffer, width, height) {
+    // Validate dimensions
+    if (width !== 64 || (height !== 64 && height !== 32)) {
+        throw new Error(`Invalid skin dimensions: ${width}x${height}. Expected 64x64 or 64x32`);
+    }
+    // Validate buffer size (RGBA = 4 bytes per pixel)
+    const expectedSize = width * height * 4;
+    if (buffer.length !== expectedSize) {
+        throw new Error(`Invalid buffer size: ${buffer.length} bytes. Expected ${expectedSize} bytes for ${width}x${height} RGBA`);
+    }
+    // Convert to base64
+    const base64Skin = buffer.toString("base64");
+    // Create skin resource patch
+    const resourcePatch = {
+        geometry: {
+            default: "geometry.humanoid.custom",
+        },
+    };
+    return {
+        AnimatedImageData: [],
+        ArmSize: "wide",
+        CapeData: "",
+        CapeId: "",
+        CapeImageHeight: 0,
+        CapeImageWidth: 0,
+        CapeOnClassicSkin: false,
+        PersonaPieces: [],
+        PersonaSkin: false,
+        PieceTintColors: [],
+        PremiumSkin: false,
+        SkinAnimationData: "",
+        SkinColor: "#0",
+        SkinData: base64Skin,
+        SkinGeometryData: "",
+        SkinGeometryDataEngineVersion: "",
+        SkinId: `custom_skin_${Date.now()}`,
+        SkinImageHeight: height,
+        SkinImageWidth: width,
+        SkinResourcePatch: Buffer.from(JSON.stringify(resourcePatch)).toString("base64"),
+        TrustedSkin: true,
+    };
+}

package/dist/client/types/client-data.js

@@ -42,6 +42,7 @@ const uuid_1345_1 = require("uuid-1345");
 const __1 = require("../");
 const types_1 = require("../../shared/types");
 const login_data_1 = require("./login-data");
+const skin_loader_1 = require("../skin-loader");
 const PUBLIC_KEY = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAECRXueJeTDqNRRgJi/vlRufByu/2G0i2Ebt6YMar5QX/R0DIIyrJMcUpruK4QveTfJSTp3Shlq4Gk34cD/4GUWwkv0DVuzeuB+tXija7HBxii03NHDbPAD0AKnLr2wdAp";
 const algorithm = "ES384";
 class ClientData {
@@ -52,6 +53,10 @@ class ClientData {
         this.client = client;
         this.payload = (0, __1.createDefaultPayload)(client);
         this.loginData = (0, login_data_1.prepareLoginData)();
+        // Load skin from file if skinFile is provided
+        if (client.options.skinFile && !client.options.skinData) {
+            client.options.skinData = (0, skin_loader_1.loadSkinFromPNG)(client.options.skinFile);
+        }
     }
     createLoginPacket() {
         const loginPacket = new protocol_1.LoginPacket();
@@ -68,7 +73,7 @@ class ClientData {
         return loginPacket;
     }
     async createClientChain(mojangKey, offline) {
-        const { clientX509, ecdhKeyPair } = this.loginData;
+        const { clientX509, ecdhKeyPair, sessionTokenData } = this.loginData;
         let payload;
         let header;
         if (offline) {
@@ -96,6 +101,19 @@ class ClientData {
                 identityPublicKey: mojangKey || PUBLIC_KEY,
                 certificateAuthority: true,
             };
+            // Add session token data for PocketMine 1.21.100+ compatibility
+            if (sessionTokenData) {
+                payload.ipt = sessionTokenData.ipt;
+                payload.tid = sessionTokenData.tid;
+                payload.mid = sessionTokenData.mid;
+                payload.xid = sessionTokenData.xid;
+                payload.cpk = sessionTokenData.cpk;
+                payload.xname = this.client.profile.name;
+            }
+            // Add pfcd if available (PlayFab ID)
+            if (this.payload.pfcd) {
+                payload.pfcd = this.payload.pfcd;
+            }
             header = {
                 alg: algorithm,
                 x5u: clientX509,

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

@@ -33,6 +33,8 @@ export type ClientOptions = {
     tokensFolder: string;
     /** Skin Data for custom skins (By default we parse it from json)*/
     skinData: SkinData | undefined;
+    /** Path to PNG skin file (alternative to skinData) */
+    skinFile: string | undefined;
     /** LoginPacket data Customization */
     loginOptions: LoginPacketOptions;
     /** The View Distance of the client.  */

package/dist/client/types/client-options.js

@@ -18,6 +18,8 @@ exports.defaultClientOptions = {
     tokensFolder: "tokens",
     /** Default Value: undefined */
     skinData: undefined,
+    /** Default Value: undefined */
+    skinFile: undefined,
     loginOptions: {
         /** Default Value: Unknown */
         currentInputMode: protocol_1.InputMode.Unknown,

package/dist/client/types/login-data.d.ts

@@ -6,6 +6,13 @@ type LoginData = {
     clientX509: string;
     clientIdentityChain: string;
     clientUserChain: string;
+    sessionTokenData?: {
+        ipt: string;
+        tid: string;
+        mid: string;
+        xid: string;
+        cpk: string;
+    };
 };
 export declare const prepareLoginData: () => LoginData;
 export type { LoginData };

package/dist/client/types/payload.d.ts

@@ -29,6 +29,7 @@ export type Payload = {
     PlatformOnlineId: string;
     PlatformType: number;
     PlayFabId: string;
+    pfcd?: string;
     PremiumSkin: boolean;
     SelfSignedId: string;
     ServerAddress: string;

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

@@ -11,6 +11,9 @@ export interface BedrockTokens {
     xuid: string;
     gamertag: string;
     userHash: string;
+    xstsToken: string;
+    playfabXstsToken: string;
+    playfabUserHash: string;
 }
 export interface ProxyOptions {
     host: string;

package/dist/shared/auth/authentication.js

@@ -48,6 +48,7 @@ const raknet_1 = require("@sanctumterra/raknet");
 const fetch_socks_1 = require("fetch-socks");
 const undici_1 = require("undici");
 const MINECRAFT_BEDROCK_RELYING_PARTY = "https://multiplayer.minecraft.net/";
+const PLAYFAB_RELYING_PARTY = "https://b980a380.minecraft.playfabapi.com/";
 const XBOX_AUTH_CLIENT_ID = "00000000441cc96b";
 function hashString(str) {
     let hash = 0;
@@ -154,12 +155,23 @@ async function authenticateWithCredentials(options) {
             saveCache(cacheFile, userToken, userHash, userTokenResp.NotAfter);
         }
     }
+    // Get XSTS token for Minecraft Bedrock
     const xstsResp = await exchangeTokenForXSTSToken(userToken, MINECRAFT_BEDROCK_RELYING_PARTY, proxiedFetch);
     const xuid = xstsResp.DisplayClaims.xui[0].xid || "";
+    // Get XSTS token for Playfab (needed for session token)
+    const playfabXstsResp = await exchangeTokenForXSTSToken(userToken, PLAYFAB_RELYING_PARTY, proxiedFetch);
     const chains = await getMinecraftBedrockChains(xstsResp.Token, userHash, clientPublicKey, proxiedFetch);
     const gamertag = extractGamertagFromChains(chains);
     raknet_1.Logger.info(`Authenticated as: ${gamertag} (${xuid})`);
-    return { chains, xuid, gamertag, userHash };
+    return {
+        chains,
+        xuid,
+        gamertag,
+        userHash,
+        xstsToken: xstsResp.Token,
+        playfabXstsToken: playfabXstsResp.Token,
+        playfabUserHash: playfabXstsResp.DisplayClaims.xui[0].uhs,
+    };
 }
 /**
  * Get Microsoft access token using email/password via OAuth flow

package/dist/shared/auth.js

@@ -114,6 +114,35 @@ async function authenticateWithEmailPassword(client) {
             uuid: generateUUID(tokens.gamertag),
             xuid: Number(tokens.xuid) || 0,
         };
+        // Get Playfab session ticket
+        const playfabData = await getPlayfabSessionTicket(tokens.playfabUserHash, tokens.playfabXstsToken);
+        // Get the multiplayer session token
+        // First get the MC services token (mcToken)
+        const mcToken = await getMinecraftServicesTokenFromPlayfab(playfabData.sessionTicket);
+        // Then use mcToken to get the multiplayer session token
+        const sessionToken = await getMultiplayerSessionTokenFromMcToken(mcToken, client.data.loginData.clientX509);
+        client.data.loginToken = sessionToken;
+        // Extract pfcd from session token and store it
+        try {
+            const tokenParts = sessionToken.split(".");
+            if (tokenParts.length >= 2) {
+                const payload = JSON.parse(Buffer.from(tokenParts[1], "base64").toString());
+                if (payload.pfcd) {
+                    client.data.payload.pfcd = payload.pfcd;
+                }
+                // Store session token data for client chain
+                client.data.loginData.sessionTokenData = {
+                    ipt: payload.ipt,
+                    tid: payload.prop ? JSON.parse(payload.prop).tid : undefined,
+                    mid: payload.prop ? JSON.parse(payload.prop).mid : undefined,
+                    xid: payload.xid,
+                    cpk: payload.cpk,
+                };
+            }
+        }
+        catch (e) {
+            raknet_1.Logger.warn(`Failed to extract pfcd from session token: ${e instanceof Error ? e.message : String(e)}`);
+        }
         const endTime = Date.now();
         raknet_1.Logger.info(`Authentication with Xbox (email/password) took ${(endTime - startTime) / 1000}s.`);
         setupClientProfile(client, profile, tokens.chains);
@@ -155,6 +184,144 @@ async function getMultiplayerSessionToken(authflow, client) {
         throw error;
     }
 }
+async function getPlayfabSessionTicket(playfabUserHash, playfabXstsToken) {
+    try {
+        const response = await fetch("https://20ca2.playfabapi.com/Client/LoginWithXbox", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                CreateAccount: true,
+                EncryptedRequest: null,
+                InfoRequestParameters: {
+                    GetCharacterInventories: false,
+                    GetCharacterList: false,
+                    GetPlayerProfile: true,
+                    GetPlayerStatistics: false,
+                    GetTitleData: false,
+                    GetUserAccountInfo: true,
+                    GetUserData: false,
+                    GetUserInventory: false,
+                    GetUserReadOnlyData: false,
+                    GetUserVirtualCurrency: false,
+                    PlayerStatisticNames: null,
+                    ProfileConstraints: null,
+                    TitleDataKeys: null,
+                    UserDataKeys: null,
+                    UserReadOnlyDataKeys: null,
+                },
+                PlayerSecret: null,
+                TitleId: "20CA2",
+                XboxToken: `XBL3.0 x=${playfabUserHash};${playfabXstsToken}`,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Playfab login failed: ${response.status} ${response.statusText} - ${text}`);
+        }
+        const json = (await response.json());
+        return {
+            sessionTicket: json.data.SessionTicket,
+            playFabId: json.data.PlayFabId,
+        };
+    }
+    catch (error) {
+        raknet_1.Logger.error(`Error while getting Playfab session ticket: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+async function getMinecraftServicesTokenFromPlayfab(sessionTicket) {
+    try {
+        const response = await fetch("https://authorization.franchise.minecraft-services.net/api/v1.0/session/start", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                device: {
+                    applicationType: "MinecraftPE",
+                    gameVersion: "1.21.130",
+                    id: "c1681ad3-415e-30cd-abd3-3b8f51e771d1",
+                    memory: String(8 * (1024 * 1024 * 1024)),
+                    platform: "Windows10",
+                    playFabTitleId: "20CA2",
+                    storePlatform: "uwp.store",
+                    type: "Windows10",
+                },
+                user: {
+                    token: sessionTicket,
+                    tokenType: "PlayFab",
+                },
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`MC services token failed: ${response.status} ${response.statusText} - ${text}`);
+        }
+        const json = (await response.json());
+        return json.result.authorizationHeader;
+    }
+    catch (error) {
+        raknet_1.Logger.error(`Error while getting MC services token: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+async function getMultiplayerSessionTokenFromMcToken(mcToken, publicKey) {
+    try {
+        const response = await fetch("https://authorization.franchise.minecraft-services.net/api/v1.0/multiplayer/session/start", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: mcToken,
+                "Accept-Encoding": "identity",
+            },
+            body: JSON.stringify({
+                publicKey: publicKey,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Multiplayer session start failed: ${response.status} ${response.statusText} - ${text}`);
+        }
+        const json = (await response.json());
+        return json.result.signedToken;
+    }
+    catch (error) {
+        raknet_1.Logger.error(`Error while getting Multiplayer Session Token: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
+async function getMultiplayerSessionTokenFromXsts(sessionTicket, publicKey) {
+    try {
+        const response = await fetch("https://authorization.franchise.minecraft-services.net/api/v1.0/session/start", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                device: {
+                    applicationType: "MinecraftPE",
+                    gameVersion: "1.21.130",
+                    id: "c1681ad3-415e-30cd-abd3-3b8f51e771d1",
+                    memory: String(8 * (1024 * 1024 * 1024)),
+                    platform: "Windows10",
+                    playFabTitleId: "20CA2",
+                    storePlatform: "uwp.store",
+                    type: "Windows10",
+                },
+                user: {
+                    token: sessionTicket,
+                    tokenType: "PlayFab",
+                },
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Multiplayer session start failed: ${response.status} ${response.statusText} - ${text}`);
+        }
+        const json = (await response.json());
+        return json.result.authorizationHeader;
+    }
+    catch (error) {
+        raknet_1.Logger.error(`Error while getting Multiplayer Session Token: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}
 function extractProfile(jwt) {
     if (!jwt) {
         raknet_1.Logger.error("JWT is undefined or empty");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "baltica",
   "description": "Library for Minecraft Bedrock Edition community developers.",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "minecraft": "1.21.130",
   "main": "dist/index.js",
   "license": "MIT",
@@ -33,7 +33,9 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@types/node": "^22.19.7",
+    "@types/pngjs": "^6.0.5",
     "@types/uuid-1345": "^0.99.25",
+    "pngjs": "^7.0.0",
     "typescript": "^5.9.3"
   }
 }