baltica 0.0.9 → 0.0.11

package/README.md

@@ -4,6 +4,10 @@
   <img src="https://raw.githubusercontent.com/SanctumTerra/Baltica/master/.extra/logo.png" alt="Baltica Logo" width="200"/>
 </p>
 
+---
+**Supported Versions**   `1.21.80` `1.21.70` `1.21.60` `1.21.50`
+---
+
 Baltica is a high-performance Minecraft Bedrock Edition networking toolkit built with TypeScript. It serves three main purposes:
 1. A powerful bridge/proxy that can modify, intercept, and manipulate network traffic between Minecraft Bedrock clients and servers
 2. A robust client library for creating Minecraft Bedrock bots and automated players
@@ -285,11 +289,6 @@ Baltica supports both Node.js and Bun runtimes, with Bun offering significant pe
 - Better packet processing performance
 - Improved concurrent connections handling
 
-To run with Bun:
-```bash
-bun run start
-```
-
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.

package/dist/bridge/bridge-options.d.ts

@@ -1,21 +1,21 @@
 import type * as Protocol from "@serenityjs/protocol";
 import type { PacketNames } from "../client";
-import type { ClientCacheStatusPacket } from "../network/packets/client-cache-status";
 import { type ServerOptions } from "../server/server-options";
 export type BridgePlayerEvents = {
     [K in PacketNames as `clientbound-${K}`]: [
         packet: InstanceType<(typeof Protocol)[K]>,
-        cancelled: boolean
+        eventStatus: {
+            cancelled: boolean;
+            modified: boolean;
+        }
     ];
 } & {
     [K in PacketNames as `serverbound-${K}`]: [
         packet: InstanceType<(typeof Protocol)[K]>,
-        cancelled: boolean
-    ];
-} & {
-    "serverbound-ClientCacheStatusPacket": [
-        packet: ClientCacheStatusPacket,
-        cancelled: boolean
+        eventStatus: {
+            cancelled: boolean;
+            modified: boolean;
+        }
     ];
 };
 export type BridgeOptions = ServerOptions & {

package/dist/bridge/bridge-options.js

@@ -8,5 +8,6 @@ exports.defaultBridgeOptions = {
         host: "127.0.0.1",
         port: 19132,
     },
+    levelName: "SanctumTerra Server",
     offline: false,
 };

package/dist/bridge/bridge-player.d.ts

@@ -1,4 +1,4 @@
-import type { LevelChunkPacket } from "../network/packets/level-chunk-packet";
+import { type LevelChunkPacket } from "@serenityjs/protocol";
 import type { Client } from "../client";
 import { Emitter } from "../libs";
 import type { Player } from "../server";

package/dist/bridge/bridge-player.js

@@ -10,16 +10,11 @@ class BridgePlayer extends libs_1.Emitter {
         this.player = player;
         this.postStartGame = false;
         this.levelChunkQueue = [];
-        this.once("clientbound-StartGamePacket", (packet) => {
+        this.once("clientbound-StartGamePacket", (packet, eventStatus) => {
             this.postStartGame = true;
             for (const chunk of this.levelChunkQueue) {
                 const eventName = "clientbound-LevelChunkPacket";
-                this.emit(eventName, chunk, false);
-                if ("binary" in packet) {
-                    packet.binary = [];
-                }
-                const newBuffer = chunk.serialize();
-                this.player.send(newBuffer);
+                this.emit(eventName, chunk, { cancelled: false, modified: false });
             }
         });
     }

package/dist/bridge/bridge.js

@@ -41,7 +41,6 @@ const raknet_1 = require("@sanctumterra/raknet");
 const protocol_1 = require("@serenityjs/protocol");
 const Protocol = __importStar(require("@serenityjs/protocol"));
 const client_1 = require("../client");
-const level_chunk_packet_1 = require("../network/packets/level-chunk-packet");
 const server_1 = require("../server");
 const bridge_options_1 = require("./bridge-options");
 const bridge_player_1 = require("./bridge-player");
@@ -60,9 +59,9 @@ class Bridge extends server_1.Server {
     initializePacketCache() {
         const CLIENT_CACHE_STATUS_ID = 129;
         this.packetClassCache.set(CLIENT_CACHE_STATUS_ID, protocol_1.ClientCacheStatusPacket);
-        const levelChunkId = level_chunk_packet_1.LevelChunkPacket.id;
+        const levelChunkId = Protocol.LevelChunkPacket.id;
         if (levelChunkId !== undefined) {
-            this.packetClassCache.set(levelChunkId, level_chunk_packet_1.LevelChunkPacket);
+            this.packetClassCache.set(levelChunkId, Protocol.LevelChunkPacket);
         }
     }
     getPacketClass(id, PacketClass) {
@@ -77,52 +76,110 @@ class Bridge extends server_1.Server {
         const id = (0, protocol_1.getPacketId)(buffer);
         const PacketClass = protocol_1.Packets[id];
         const packetName = PacketClass?.name ?? "ClientCacheStatusPacket";
+        console.log(packetName);
         const eventName = `${isClientbound ? "clientbound" : "serverbound"}-${packetName}`;
         if (!PacketClass && id !== 129) {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`Passing through unknown packet ID: ${id}`);
+            }
             sender.send(buffer);
             return;
         }
         if (packetName === "LevelChunkPacket" && !player.postStartGame) {
-            player.levelChunkQueue.push(new level_chunk_packet_1.LevelChunkPacket(buffer).deserialize());
+            try {
+                player.levelChunkQueue.push(new Protocol.LevelChunkPacket(buffer).deserialize());
+            }
+            catch (e) {
+                raknet_1.Logger.error("Failed to deserialize LevelChunkPacket for queueing", e);
+                sender.send(buffer);
+            }
+            return;
+        }
+        if (packetName === "ItemStackRequestPacket") {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`Passing through ItemStackRequestPacket (ID: ${id}) without processing.`);
+            }
+            sender.send(buffer);
+            return;
+        }
+        const hasListeners = player.hasListeners(eventName);
+        const isClientCachePacket = packetName === "ClientCacheStatusPacket";
+        const needsProcessing = hasListeners || isClientCachePacket;
+        if (!needsProcessing) {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (No listeners/special handling, sending original)`);
+            }
+            sender.send(buffer);
             return;
         }
-        if (!player.hasListeners(eventName) &&
-            packetName !== "ClientCacheStatusPacket") {
+        const cacheKey = `${id}-${buffer.toString("hex")}`;
+        const cachedSerializedBuffer = this.packetSerializationCache.get(cacheKey);
+        if (cachedSerializedBuffer) {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Sending cached serialized)`);
+            }
+            sender.send(cachedSerializedBuffer);
+            return;
+        }
+        const CachedPacketClass = this.getPacketClass(id, PacketClass);
+        if (!CachedPacketClass) {
+            raknet_1.Logger.warn(`Could not get packet class for ${packetName} (ID: ${id}) despite needing processing. Sending original.`);
             sender.send(buffer);
             return;
         }
+        let packet;
         try {
-            const CachedPacketClass = this.getPacketClass(id, PacketClass);
-            if (!CachedPacketClass) {
-                sender.send(buffer);
+            packet = new CachedPacketClass(buffer).deserialize();
+        }
+        catch (e) {
+            raknet_1.Logger.error(`Failed to deserialize ${packetName} (ID: ${id}). Sending original buffer.`, e);
+            sender.send(buffer);
+            return;
+        }
+        if (packet instanceof protocol_1.ClientCacheStatusPacket) {
+            packet.enabled = false;
+            raknet_1.Logger.warn(`Modified and dropping ClientCacheStatusPacket (ID: ${id})`);
+            return;
+        }
+        const eventStatus = { cancelled: false, modified: false };
+        if (hasListeners) {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Emitting event)`);
+            }
+            player.emit(eventName, packet, eventStatus);
+            if (eventStatus.cancelled) {
+                if (this.debugLog) {
+                    raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Cancelled by listener)`);
+                }
                 return;
             }
+        }
+        let bridgeMadeModifications = false;
+        if ("binary" in packet && packet.binary !== undefined) {
+            if (!Array.isArray(packet.binary) || packet.binary.length > 0) {
+                packet.binary = [];
+                bridgeMadeModifications = true;
+            }
+        }
+        const requiresSerialization = eventStatus.modified || bridgeMadeModifications;
+        if (requiresSerialization) {
             if (this.debugLog) {
-                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName}`);
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Re-serializing after modification)`);
             }
-            const cacheKey = `${id}-${buffer.toString("hex")}`;
-            let newBuffer = this.packetSerializationCache.get(cacheKey);
-            if (!newBuffer) {
-                const packet = new CachedPacketClass(buffer).deserialize();
-                if (packet instanceof protocol_1.ClientCacheStatusPacket) {
-                    packet.enabled = false;
-                    raknet_1.Logger.warn("Ignoring ClientCacheStatusPacket");
-                    return;
-                }
-                const cancelled = false;
-                player.emit(eventName, packet, cancelled);
-                if (cancelled)
-                    return;
-                if ("binary" in packet) {
-                    packet.binary = [];
-                }
-                newBuffer = packet.serialize();
-                this.packetSerializationCache.set(cacheKey, newBuffer);
+            try {
+                const newSerializedBuffer = packet.serialize();
+                this.packetSerializationCache.set(cacheKey, newSerializedBuffer);
+                sender.send(newSerializedBuffer);
+            }
+            catch (e) {
+                raknet_1.Logger.error(`Failed to serialize modified ${packetName} (ID: ${id}). Sending original buffer.`, e);
+                sender.send(buffer);
             }
-            sender.send(newBuffer);
         }
-        catch (e) {
-            raknet_1.Logger.error(`Failed to process ${packetName}`, e);
+        else {
+            if (this.debugLog) {
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName} (ID: ${id}) (Processed, not modified, sending original)`);
+            }
             sender.send(buffer);
         }
     }
@@ -142,8 +199,8 @@ class Bridge extends server_1.Server {
                 const frame = new raknet_1.Frame();
                 frame.orderChannel = 0;
                 frame.payload = rakDisconnect.serialize();
-                player.client.raknet.sendFrame(frame, raknet_1.Priority.Immediate);
-                player.client.send(disconnect);
+                player.client?.raknet?.sendFrame(frame, raknet_1.Priority.Immediate);
+                player.client?.send(disconnect);
             }
         });
     }
@@ -163,14 +220,50 @@ class Bridge extends server_1.Server {
         });
     }
     onLogin(player) {
+        console.log("Creating Client");
+        const payload = player.player.data.payload;
+        console.log(this.options);
         const client = new client_1.Client({
             host: this.options.destination.host,
             port: this.options.destination.port,
             version: this.options.version,
             tokensFolder: "tokens",
-            viewDistance: 2,
+            viewDistance: payload.MaxViewDistance,
             worker: true,
             offline: this.options.offline,
+            deviceOS: payload.DeviceOS,
+            skinData: {
+                AnimatedImageData: payload.AnimatedImageData,
+                ArmSize: payload.ArmSize,
+                SkinData: payload.SkinData,
+                TrustedSkin: payload.TrustedSkin,
+                CapeData: payload.CapeData,
+                CapeId: payload.CapeId,
+                CapeImageHeight: payload.CapeImageHeight,
+                CapeImageWidth: payload.CapeImageWidth,
+                CapeOnClassicSkin: payload.CapeOnClassicSkin,
+                PersonaPieces: payload.PersonaPieces,
+                PieceTintColors: payload.PieceTintColors,
+                PersonaSkin: payload.PersonaSkin,
+                PremiumSkin: payload.PremiumSkin,
+                SkinAnimationData: payload.SkinAnimationData,
+                SkinColor: payload.SkinColor,
+                SkinGeometryData: payload.SkinGeometryData,
+                SkinGeometryDataEngineVersion: payload.SkinGeometryDataEngineVersion,
+                SkinId: payload.SkinId,
+                SkinImageHeight: payload.SkinImageHeight,
+                SkinImageWidth: payload.SkinImageWidth,
+                SkinResourcePatch: payload.SkinResourcePatch,
+            },
+            loginOptions: {
+                CurrentInputMode: payload.CurrentInputMode,
+                DefaultInputMode: payload.DefaultInputMode,
+                DeviceModel: payload.DeviceModel,
+            },
+            platformType: payload.PlatformType,
+            memoryTier: payload.MemoryTier,
+            uiProfile: payload.UIProfile,
+            graphicsMode: payload.GraphicsMode,
         });
         console.log(this.options);
         player.client = client;
@@ -183,10 +276,10 @@ class Bridge extends server_1.Server {
             packet.enabled = false;
             client.send(packet.serialize());
         });
-        player.once("serverbound-ResourcePackClientResponsePacket", () => {
-            const packet = new protocol_1.ClientCacheStatusPacket();
-            packet.enabled = false;
-            player.player.send(packet.serialize());
+        player.once("serverbound-ResourcePackClientResponsePacket", (packet, eventStatus) => {
+            const responsePacket = new protocol_1.ClientCacheStatusPacket();
+            responsePacket.enabled = false;
+            player.player.send(responsePacket.serialize());
         });
         client.once("PlayStatusPacket", (packet) => {
             if (packet.status !== protocol_1.PlayStatus.LoginSuccess) {

package/dist/client/client-data.js

@@ -41,6 +41,7 @@ const jose = __importStar(require("jose"));
 const node_crypto_1 = require("node:crypto");
 const login_data_1 = require("./types/login-data");
 const raknet_1 = require("@sanctumterra/raknet");
+const client_options_1 = require("./client-options");
 const PUBLIC_KEY = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAECRXueJeTDqNRRgJi/vlRufByu/2G0i2Ebt6YMar5QX/R0DIIyrJMcUpruK4QveTfJSTp3Shlq4Gk34cD/4GUWwkv0DVuzeuB+tXija7HBxii03NHDbPAD0AKnLr2wdAp";
 const algorithm = "ES384";
 const curve = "secp384r1";
@@ -56,7 +57,18 @@ class ClientData {
         const loginPacket = new protocol_1.LoginPacket();
         const chain = [this.loginData.clientIdentityChain, ...this.accessToken];
         const userChain = this.loginData.clientUserChain;
-        const encodedChain = JSON.stringify({ chain });
+        let encodedChain = "";
+        if ((0, client_options_1.versionHigherThan)(this.client.options.version, "1.21.80")) {
+            const certificate = JSON.stringify({ chain });
+            encodedChain = JSON.stringify({
+                AuthenticationType: 2,
+                Certificate: certificate,
+                Token: "",
+            });
+        }
+        else {
+            encodedChain = JSON.stringify({ chain });
+        }
         loginPacket.protocol = this.client.protocol;
         loginPacket.tokens = new protocol_1.LoginTokens(userChain, encodedChain);
         return loginPacket;
@@ -105,7 +117,10 @@ class ClientData {
     }
     async createClientUserChain(privateKey) {
         const { clientX509 } = this.loginData;
-        const customPayload = this.client.options.skinData || {};
+        // Partial Payload
+        const customPayload = {
+            ...this.client.options.skinData,
+        };
         const payload = {
             ...this.payload,
             ...customPayload,

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

@@ -1,14 +1,13 @@
 import { CompressionMethod, InputMode } from "@serenityjs/protocol";
 import type * as Protocol from "@serenityjs/protocol";
-import type { ClientCacheStatusPacket } from "../network/packets/client-cache-status";
 import type { Advertisement } from "@sanctumterra/raknet";
-import { AddPaintingPacket, UpdateSubchunkBlocksPacket, MotionPredictHintsPacket, SetLastHurtByPacket, SetDefaultGamemodePacket, UpdatePlayerGameTypePacket, UpdateBlockSyncPacket } from "../network/packets";
-import { LevelChunkPacket } from "../network/packets/level-chunk-packet";
+import type { SkinData } from "./types/payload";
 export declare enum ProtocolList {
     "1.21.50" = 766,
     "1.21.60" = 776,
     "1.21.70" = 786,
-    "1.21.80" = 800
+    "1.21.80" = 800,
+    "1.21.90" = 818
 }
 export declare enum DeviceOS {
     Undefined = 0,
@@ -28,6 +27,20 @@ export declare enum DeviceOS {
     WindowsPhone = 14,
     Linux = 15
 }
+/**
+ * Checks if client version is higher than the specified version
+ * @param clientVersion The client version to check
+ * @param targetVersion The version to compare against
+ * @returns True if client version is higher than targetVersion
+ */
+export declare function versionHigherThan(clientVersion: keyof typeof ProtocolList, targetVersion: keyof typeof ProtocolList): boolean;
+/**
+ * Checks if client version is lower than the specified version
+ * @param clientVersion The client version to check
+ * @param targetVersion The version to compare against
+ * @returns True if client version is lower than targetVersion
+ */
+export declare function versionLowerThan(clientVersion: keyof typeof ProtocolList, targetVersion: keyof typeof ProtocolList): boolean;
 type LoginPacketOptions = {
     DeviceModel: string;
     CurrentInputMode: InputMode;
@@ -44,11 +57,15 @@ type ClientOptions = {
     username: string;
     tokensFolder: string;
     viewDistance: number;
-    skinData: object | undefined;
+    skinData: SkinData | undefined;
     offline: boolean;
     worker: boolean;
     loginOptions: LoginPacketOptions;
     betaAuth: boolean;
+    platformType: number;
+    memoryTier: number;
+    uiProfile: number;
+    graphicsMode: number;
 };
 declare const defaultClientOptions: ClientOptions;
 type PacketNames = {
@@ -58,35 +75,8 @@ type ClientEvents = {
     [K in PacketNames]: [packet: InstanceType<(typeof Protocol)[K]>];
 } & {
     session: [];
-    ClientCacheStatusPacket: [
-        packet: InstanceType<typeof ClientCacheStatusPacket>
-    ];
-    UpdateSubchunkBlocksPacket: [
-        packet: InstanceType<typeof UpdateSubchunkBlocksPacket>
-    ];
-    MotionPredictHintsPacket: [
-        packet: InstanceType<typeof MotionPredictHintsPacket>
-    ];
-    SetLastHurtByPacket: [packet: InstanceType<typeof SetLastHurtByPacket>];
-    SetDefaultGamemodePacket: [
-        packet: InstanceType<typeof SetDefaultGamemodePacket>
-    ];
-    UpdatePlayerGameTypePacket: [
-        packet: InstanceType<typeof UpdatePlayerGameTypePacket>
-    ];
-    UpdateBlockSyncPacket: [packet: InstanceType<typeof UpdateBlockSyncPacket>];
 } & {
     packet: [packet: InstanceType<(typeof Protocol)[PacketNames]>];
     connect: [packet: Advertisement];
 };
 export { type ClientOptions, defaultClientOptions, type ClientEvents, type PacketNames, };
-export declare const ExtraPackets: {
-    58: typeof LevelChunkPacket;
-    22: typeof AddPaintingPacket;
-    172: typeof UpdateSubchunkBlocksPacket;
-    157: typeof MotionPredictHintsPacket;
-    96: typeof SetLastHurtByPacket;
-    105: typeof SetDefaultGamemodePacket;
-    151: typeof UpdatePlayerGameTypePacket;
-    110: typeof UpdateBlockSyncPacket;
-};

package/dist/client/client-options.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExtraPackets = exports.defaultClientOptions = exports.DeviceOS = exports.ProtocolList = void 0;
+exports.defaultClientOptions = exports.DeviceOS = exports.ProtocolList = void 0;
+exports.versionHigherThan = versionHigherThan;
+exports.versionLowerThan = versionLowerThan;
 const protocol_1 = require("@serenityjs/protocol");
-const packets_1 = require("../network/packets");
-const level_chunk_packet_1 = require("../network/packets/level-chunk-packet");
 var ProtocolList;
 (function (ProtocolList) {
     ProtocolList[ProtocolList["1.21.50"] = 766] = "1.21.50";
     ProtocolList[ProtocolList["1.21.60"] = 776] = "1.21.60";
     ProtocolList[ProtocolList["1.21.70"] = 786] = "1.21.70";
     ProtocolList[ProtocolList["1.21.80"] = 800] = "1.21.80";
+    ProtocolList[ProtocolList["1.21.90"] = 818] = "1.21.90";
 })(ProtocolList || (exports.ProtocolList = ProtocolList = {}));
 var DeviceOS;
 (function (DeviceOS) {
@@ -30,6 +31,24 @@ var DeviceOS;
     DeviceOS[DeviceOS["WindowsPhone"] = 14] = "WindowsPhone";
     DeviceOS[DeviceOS["Linux"] = 15] = "Linux";
 })(DeviceOS || (exports.DeviceOS = DeviceOS = {}));
+/**
+ * Checks if client version is higher than the specified version
+ * @param clientVersion The client version to check
+ * @param targetVersion The version to compare against
+ * @returns True if client version is higher than targetVersion
+ */
+function versionHigherThan(clientVersion, targetVersion) {
+    return ProtocolList[clientVersion] > ProtocolList[targetVersion];
+}
+/**
+ * Checks if client version is lower than the specified version
+ * @param clientVersion The client version to check
+ * @param targetVersion The version to compare against
+ * @returns True if client version is lower than targetVersion
+ */
+function versionLowerThan(clientVersion, targetVersion) {
+    return ProtocolList[clientVersion] < ProtocolList[targetVersion];
+}
 const defaultClientOptions = {
     host: "127.0.0.1",
     port: 19132,
@@ -37,7 +56,7 @@ const defaultClientOptions = {
     compressionMethod: protocol_1.CompressionMethod.Zlib,
     compressionLevel: 7,
     deviceOS: DeviceOS.NintendoSwitch,
-    version: "1.21.80",
+    version: "1.21.90",
     username: "SanctumTerra",
     tokensFolder: "tokens",
     viewDistance: 10,
@@ -45,20 +64,14 @@ const defaultClientOptions = {
     offline: false,
     worker: false,
     loginOptions: {
-        DeviceModel: "SwimmingPool",
+        DeviceModel: "Bean Bag Chair",
         CurrentInputMode: protocol_1.InputMode.GamePad,
         DefaultInputMode: protocol_1.InputMode.GamePad,
     },
     betaAuth: false,
+    platformType: 2,
+    memoryTier: 2,
+    uiProfile: 0,
+    graphicsMode: 0,
 };
 exports.defaultClientOptions = defaultClientOptions;
-exports.ExtraPackets = {
-    [58]: level_chunk_packet_1.LevelChunkPacket,
-    [22]: packets_1.AddPaintingPacket,
-    [172]: packets_1.UpdateSubchunkBlocksPacket,
-    [157]: packets_1.MotionPredictHintsPacket,
-    [96]: packets_1.SetLastHurtByPacket,
-    [105]: packets_1.SetDefaultGamemodePacket,
-    [151]: packets_1.UpdatePlayerGameTypePacket,
-    [110]: packets_1.UpdateBlockSyncPacket,
-};

package/dist/client/client.d.ts

@@ -25,19 +25,30 @@ declare class Client extends Emitter<ClientEvents> {
     runtimeEntityId: bigint;
     cancelPastLogin: boolean;
     constructor(options: Partial<ClientOptions>);
+    private initializeSession;
     connect(): Promise<[Advertisement, StartGamePacket]>;
+    private waitForSessionReady;
+    private waitForConnection;
     private handleStartGamePacket;
+    private requestChunkRadius;
     private handleEncapsulated;
     private sendPacket;
     send(packet: DataPacket | Buffer): void;
     queue(packet: DataPacket | Buffer): void;
     /** Already decompressed packets */
     processPacket(buffer: Buffer): void;
-    listen(): void;
+    private setupEventListeners;
+    private setupConnectionListeners;
+    private handleRaknetConnect;
+    private setupPacketListeners;
+    private handleNetworkSettingsPacket;
+    private handleServerHandshake;
     private handlePlayStatusPacket;
+    private completePlayerSpawn;
     private handleResourcePacksInfoPacket;
     startEncryption(iv: Buffer): void;
     disconnect(): void;
+    private cleanup;
     sendMessage(text: string): void;
 }
 export { Client };