@vaitosoi/minejs 0.3.1 → 0.4.0

package/src/client/auth.ts

@@ -1,21 +1,37 @@
 import http from "node:http";
-import cryto from "node:crypto";
-import net from "node:net";
+import crypto from "node:crypto";
 import { exec } from "node:child_process";
-import { AuthDenied, AuthError, AuthTokenExpired, CantGetMsAccessToken, ProfileError, ProfileNotFound, XboxError } from "../base/error";
+import { AuthDenied, OAuthError, AuthTokenExpired, CantGetMsAccessToken, ProfileError, ProfileNotFound, XboxError, AuthClientError, MinecraftError } from "../base/error";
+import { minecraftSha1 } from "../base/math";
+import { getJson } from "../base/http";
 
-export interface AuthOption {
+interface Loopback {
     /**
-     * `"loopback"` - open a browser to login
-     * `"device_code"` - provide a device code to login
+     * This method will provide you a url to click on and do the authentication.
+     * 
+     * This will require an opening port in order to receive the response from Microsoft. If you cant, considering using `device_code` method.
+     */
+    method: "loopback",
+
+    /**
+     * The opening port for listening the response
      */
-    method: "loopback" | "device_code",
+    port: number
 
     /**
      * Automatedly open browser or print a URL to click on.
      */
     openBrowser: boolean,
+}
 
+interface DeviceCode {
+    /**
+     * This method will provide you a device code, then you have to type this code in the given URL.
+     */
+    method: "device_code",
+}
+
+export type AuthOption = (Loopback | DeviceCode) & {
     /**
      * The Client ID
      * 
@@ -101,17 +117,6 @@ function open(url: string, log: (message: string) => any) {
     }
 }
 
-// Got this from https://github.com/sindresorhus/get-port/blob/main/index.js#L47
-const getFreePort = () => new Promise<number>((resolve) => {
-    const server = net.createServer();
-    server.listen(0, () => {
-        const port = (server.address() as net.AddressInfo).port;
-        server.close(() =>
-            resolve(port)
-        );
-    });
-});
-
 const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
 
 /**
@@ -121,34 +126,100 @@ export class AuthClient {
     private readonly codeVerifier: string;
     private readonly codeChallenge: string;
     // private refreshToken?: string;
+    private accessToken: string = "";
+    private uuid: string = "";
 
     constructor(private option: AuthOption) {
-        const codeVerifier = cryto.randomBytes(32).toString("hex");
-        const hashed = cryto.hash("sha256", codeVerifier, "base64url");
+        const codeVerifier = crypto.randomBytes(32).toString("hex");
+        const hashed = crypto.createHash("sha256").update(codeVerifier).digest("base64url");
         this.option.log ||= console.log;
 
         this.codeVerifier = codeVerifier;
         this.codeChallenge = hashed;
     }
 
-    public async auth() {
+    /**
+     * Send a auth notify to Minecraft server, after receive Encryption Request
+     * 
+     * @see https://minecraft.wiki/w/Java_Edition_protocol/Encryption#Authentication
+     */
+    public async sendAuth(
+        // Sever things
+        serverId: string,
+        sharedSecret: Buffer,
+        publicKey: Buffer,
+    ) {
+        const hash = minecraftSha1(serverId, sharedSecret, publicKey);
+        const response = await fetch(
+            "https://sessionserver.mojang.com/session/minecraft/join",
+            {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    accessToken: this.accessToken,
+                    selectedProfile: this.uuid,
+                    serverId: hash,
+                })
+            }
+        );
+        console.log({
+            accessToken: this.accessToken,
+            selectedProfile: this.uuid,
+            serverId: hash,
+        });
+        if (response.status === 204) return;
+        const json = await getJson(response, "send auth request") as Record<string, string>;
+        throw new AuthClientError(json["error"]! + ("errorMessage" in json ? `: ${json["errorMessage"]}` : ""));
+    }
+
+    /**
+     * Get player key pair for signing stuff
+     * 
+     * @see https://minecraft.wiki/w/Mojang_API#Get_keypair_for_signature
+     */
+    public async getKeyPair() {
+        const response = await fetch(
+            "https://api.minecraftservices.com/player/certificates",
+            {
+                headers: {
+                    Authorization: `Bearer ${this.accessToken}`
+                }
+            }
+        );
+        if (response.status !== 200) throw new AuthClientError("can't get the auth key", await response.text());
+        const json = await getJson(response, "get key pair") as any;
+        console.log(json);
+        return {
+            publicKey: String(json["keyPair"]["publicKey"]),
+            signature: String(json["publicKeySignatureV2"]),
+            expiresAt: Number(json["expiresAt"]),
+        };
+    }
+
+
+    /**
+     * Get player UUID
+     */
+    public async getUUID() {
         if (this.option.method === "loopback") return this.loopback();
         else return this.deviceCode();
     }
 
     private async loopback() {
-        const freePort = await getFreePort();
-        const expectState = cryto.randomBytes(8).toString("hex");
+        const option = this.option as Loopback;
+        const expectState = crypto.randomBytes(8).toString("hex");
         const authUrl = new URL("https://login.microsoftonline.com/consumers/oauth2/v2.0/authorize");
         authUrl.searchParams.append("client_id", this.option.client_id);
         authUrl.searchParams.append("response_type", "code");
-        authUrl.searchParams.append("redirect_uri", `http://127.0.0.1:${freePort}`);
+        authUrl.searchParams.append("redirect_uri", `http://localhost:${option.port}`);
         authUrl.searchParams.append("scope", "XboxLive.signin offline_access");
         authUrl.searchParams.append("code_challenge", this.codeChallenge);
         authUrl.searchParams.append("code_challenge_method", "S256");
         authUrl.searchParams.append("state", expectState);
 
-        if (this.option.openBrowser === true)
+        if (option.openBrowser === true)
             open(authUrl.toString(), this.option.log!);
         else
             this.option.log!(`please open this url in your browser: ${authUrl.toString()}`);
@@ -156,32 +227,35 @@ export class AuthClient {
         const msAuthToken = await new Promise<string | null>((resolve) => {
             const server = http.createServer((req, res) => {
                 const end = (html: string, result: any = null) => {
-                    res.end(html);
-                    server.close();
-                    return resolve(result);
+                    if (res.writable)
+                        res.end(html);
+                    if (server.listening) {
+                        server.close();
+                        return resolve(result);
+                    }
                 };
 
-                const url = new URL(req.url || "", `http://127.0.0.1:${freePort}`);
+                const url = new URL(req.url || "", `http://localhost:${option.port}`);
                 const error = url.searchParams.get("error");
                 if (error) {
                     const description = url.searchParams.get("error_description")!;
-                    end(ErrorHTML.replace("{error}", error).replace("{error_description}", description));
+                    return end(ErrorHTML.replace("{error}", error).replace("{error_description}", description));
                 }
 
                 const code = url.searchParams.get("code");
                 if (!code)
-                    end(InvalidHTML.replace("{reason}", "Missing <code>code</code> parameter"));
+                    return end(InvalidHTML.replace("{reason}", "Missing <code>code</code> parameter"));
 
                 const state = url.searchParams.get("state");
                 if (!state)
-                    end(InvalidHTML.replace("{reason}", "Missing <code>state</code> parameter"));
+                    return end(InvalidHTML.replace("{reason}", "Missing <code>state</code> parameter"));
                 if (state !== expectState)
-                    end(InvalidHTML.replace("{reason}", "Mismatch state"));
+                    return end(InvalidHTML.replace("{reason}", "Mismatch state"));
 
                 return end(SuccessHTML, code);
             });
 
-            server.listen(freePort);
+            server.listen(option.port);
         });
 
         if (!msAuthToken)
@@ -190,9 +264,9 @@ export class AuthClient {
         const msTokenUrl = new URL("https://login.microsoftonline.com/consumers/oauth2/v2.0/token");
         const msTokenBody = new URLSearchParams();
         msTokenBody.append("client_id", this.option.client_id);
-        msTokenBody.append("code", msAuthToken);
         msTokenBody.append("scope", "XboxLive.signin offline_access");
-        msTokenBody.append("redirect_uri", `http://127.0.0.1:${freePort}`);
+        msTokenBody.append("code", msAuthToken);
+        msTokenBody.append("redirect_uri", `http://localhost:${option.port}`);
         msTokenBody.append("grant_type", "authorization_code");
         msTokenBody.append("code_verifier", this.codeVerifier);
         const msTokenRequest = await fetch(msTokenUrl, {
@@ -202,9 +276,9 @@ export class AuthClient {
             method: "POST",
             body: msTokenBody.toString()
         });
-        const msTokenResponse = await msTokenRequest.json() as Record<string, any>;
+        const msTokenResponse = await getJson(msTokenRequest, "microsoft token request") as Record<string, any>;
         if ("error" in msTokenResponse)
-            throw new AuthError(msTokenResponse["error"]);
+            throw new OAuthError(msTokenResponse["error"]);
         const msToken = msTokenResponse["access_token"];
 
         return this.getMcToken(msToken);
@@ -231,7 +305,7 @@ export class AuthClient {
         this.option.log!(message);
 
         let msToken;
-        const msTokenUrl = new URL("https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token");
+        const msTokenUrl = new URL("https://login.microsoftonline.com/consumers/oauth2/v2.0/token");
         const msTokenBody = new URLSearchParams();
         msTokenBody.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
         msTokenBody.set("client_id", this.option.client_id);
@@ -240,9 +314,10 @@ export class AuthClient {
             await sleep(interval * 1000);
             const msTokenRequest = await fetch(msTokenUrl, {
                 headers: {
-                    "Content-Type": "application/x-www-form-urlencoded"
+                    "Content-Type": "application/x-www-form-urlencoded",
                 },
-                method: "POST"
+                method: "POST",
+                body: msTokenBody.toString()
             });
             const msTokenResponse = await msTokenRequest.json() as Record<string, any>;
             if ("error" in msTokenResponse)
@@ -251,7 +326,7 @@ export class AuthClient {
                     case "slow_down": interval += 5; continue;
                     case "auth_denied": throw new AuthDenied();
                     case "expired_token": throw new AuthTokenExpired();
-                    default: throw new AuthError(msTokenResponse["error"]);
+                    default: throw new OAuthError(msTokenResponse["error"]);
                 }
             else {
                 msToken = msTokenResponse["access_token"];
@@ -263,10 +338,9 @@ export class AuthClient {
             throw new CantGetMsAccessToken();
 
         return this.getMcToken(msToken);
-    } 
+    }
 
     private async getMcToken(msToken: string): Promise<{
-        token: string,
         uuid: string,
         name: string
     }> {
@@ -287,14 +361,14 @@ export class AuthClient {
             }),
             method: "POST"
         });
-        const xboxReponse = await xboxRequest.json() as Record<string, any>;
+        const xboxReponse = await getJson(xboxRequest, "xbox request") as Record<string, any>;
         const xboxToken = xboxReponse["Token"];
         const userHash = xboxReponse["DisplayClaims"]["xui"][0]["uhs"];
 
         const xboxSecurityRequest = await fetch("https://xsts.auth.xboxlive.com/xsts/authorize", {
             headers: {
                 "Content-Type": "application/json",
-                Accept: "application/json"
+                "Accept": "application/json",
             },
             body: JSON.stringify({
                 "Properties": {
@@ -306,7 +380,7 @@ export class AuthClient {
             }),
             method: "POST"
         });
-        const xboxSecurityReponse = await xboxSecurityRequest.json() as Record<string, any>;
+        const xboxSecurityReponse = await getJson(xboxSecurityRequest, "xbox security request") as Record<string, any>;
         if ("XErr" in xboxSecurityReponse)
             throw new XboxError(xboxSecurityReponse["XErr"]);
         const xboxSecurityToken = xboxSecurityReponse["Token"];
@@ -314,14 +388,17 @@ export class AuthClient {
         const minecraftRequest = await fetch("https://api.minecraftservices.com/authentication/login_with_xbox", {
             headers: {
                 "Content-Type": "application/json",
-                Accept: "application/json"
+                "Accept": "application/json",
+                'User-Agent': 'MinecraftLauncher/2.2.10675'
             },
             body: JSON.stringify({
-                "identityToken": `XBL3.0 x=${userHash};${xboxSecurityToken}"`
+                "identityToken": `XBL3.0 x=${userHash};${xboxSecurityToken}`,
             }),
             method: "POST"
         });
-        const minecraftResponse = await minecraftRequest.json() as Record<string, any>;
+        const minecraftResponse = await getJson(minecraftRequest, "minecraft request") as Record<string, any>;
+        if ("errorMessage" in minecraftResponse)
+            throw new MinecraftError(minecraftResponse["errorMessage"]);
         const minecraftToken = minecraftResponse["access_token"];
 
         const mcProfileRequest = await fetch("https://api.minecraftservices.com/minecraft/profile", {
@@ -330,15 +407,16 @@ export class AuthClient {
             },
             method: "GET"
         });
-        const mcProfileResponse = await mcProfileRequest.json() as Record<string, any>;
+        const mcProfileResponse = await getJson(mcProfileRequest, "minecraft profile request") as Record<string, any>;
         if ("error" in mcProfileResponse) {
             if (mcProfileResponse["error"] === "NOT_FOUND")
                 throw new ProfileNotFound();
             else throw new ProfileError(mcProfileResponse["error"], mcProfileResponse["errorMessage"]);
         }
 
+        this.accessToken = minecraftToken;
+        this.uuid = mcProfileResponse["id"];
         return {
-            token: minecraftToken,
             uuid: mcProfileResponse["id"],
             name: mcProfileResponse["name"]
         };

package/src/client/client.ts

@@ -1,43 +1,89 @@
-import { EventEmitter } from "node:stream";
+import { EventEmitter } from "node:events";
 import { BlockManager, BlockState } from "../world/block";
 import { EntitiesManager } from "../world/entity";
-import { MoveDirection, Player } from "../physics/player";
+import { Input, Player } from "../physics/player";
 import { TickLoop } from "../world/tick";
 import { Message, TCPClient, TCPClientOption } from "./tcp";
 import { TypedEmmiter as TypedEmitter } from "../base/event";
 import { BlockRegistry, EntityRegistry, PacketRegistry, ProtocolVersionMapping } from "../version/registry";
 import { BaseVec3, Vec3 } from "../physics/direction";
 import { TextComponent } from "../base/typing";
-import { EmittedEvent as EmittedEvent, Entity, SharedState } from "../world/state";
+import { ClientStatus, ConnectionState, EmittedEvent as EmittedEvent, Entity, SharedState } from "../world/state";
 import { Dispatcher } from "../packet/dispatcher";
 import { VersionCodec } from "../version/codec";
 import { AuthClient } from "./auth";
 import { computeUUID } from "../base/math";
+import { HaveSignatureButNotIndex } from "../base/error";
 
-export type ClientOption = Omit<TCPClientOption, "protocolVersion"> & { version: string }
+export type ClientOption = Omit<TCPClientOption, "protocolVersion"> & {
+    version: string,
+
+    /**
+     * Whenever should the client verify the message against the signature, if any
+     * 
+     * When set this option to true, you HAVE TO set `shouldVerifyMessageOrder` to true
+     */
+    shouldVerifyMessageSignature?: boolean
+
+    /**
+     * Should verify the message orders to keep the sync with server.
+     */
+    shouldVerifyMessageOrder?: boolean
+}
 
 export interface ClientEvents {
+    // TCP Events
+    /** When the TCP socket connect is initted sucessfully */
     connect: [],
+    /** When the TCP socket connection is destroyed */
     destroy: [],
 
+    /**
+     * When the client is ready.
+     * 
+     * Specifically, when the packet `Login (play)` is received
+     */
     ready: [],
+    /**
+     * When the client got disconnected from sevrer
+     */
     disconnect: [reason: string],
+    /**
+     * When the disconection come with the raw Text Component
+     */
     disconnectRaw: [textComponent: TextComponent],
 
+    /**
+     * When server send `Player Position Synchronization` packet
+     * 
+     * Note: this event is not fired when the client is moved by holding the input
+     */
     playerPosition: [position: BaseVec3],
 
+    /** When the chunk is loaded */
     loadChunk: [chunkX: number, sectionY: number, chunkZ: number],
+    /** When the chunk got deleted by the server */
     unloadChunk: [chunkX: number, chunkZ: number],
 
+    /** When an entity is spawned or appeared in the client view distance */
     spawnEntity: [entity: Entity],
+    /** When an entity is updated, including position, rotation, etc... */
     updateEntity: [entityId: number],
+    /** When an entity go out of client view distance or despawned */
     removeEntity: [entityId: number],
 
     // Chat
+    /** When a chat message got broadcasted */
     message: [message: Message],
+    /** When a message is failed to be verified against the signature sent with it */
+    failedMessage: [message: Message],
+    /** The system message */
     systemMessage: [message: string],
+    /** The raw system message */
     systemMessageRaw: [textComponent: TextComponent],
+    /** The action bar */
     actionBar: [message: string],
+    /** The raw action bar */
     actionBarRaw: [textComponent: TextComponent],
 }
 
@@ -52,16 +98,18 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
     private blocks: BlockManager;
     private entities: EntitiesManager;
     private player: Player;
-    private uuid: Buffer = Buffer.alloc(0);
 
     private tcp: TCPClient;
     private state: SharedState<IsReady>;
 
     constructor(private options: ClientOption) {
+        if (options.shouldVerifyMessageSignature === true && options.shouldVerifyMessageOrder !== true)
+            throw new HaveSignatureButNotIndex();
+
         super();
 
         // For managing shared data
-        this.state = new SharedState(options, () => this.uuid);
+        this.state = new SharedState(options);
         // For handling packet
         const dispatcher = new Dispatcher(this.state, this.emit.bind(this));
         // For reading packet
@@ -82,7 +130,7 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
             dispatcher.sendLoginStart();
         };
         dispatcher.sendPacket = this.tcp.sendPacket.bind(this.tcp);
-        dispatcher.tcpDisconnect = this.tcp.disconnect.bind(this.tcp);
+        dispatcher.disconnect = this.disconnect.bind(this);
         versionCodec.consumePacket = dispatcher.handlePacket.bind(dispatcher);
 
         // For querying data
@@ -95,6 +143,10 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
             this.entities,
             this.blocks,
         );
+        this.player.sendPlayerPos = dispatcher.sendPlayerPos;
+        this.player.sendPlayerPosRot = dispatcher.sendPlayerPosRot;
+        this.player.sendPlayerRot = dispatcher.sendPlayerRot;
+        this.player.sendPlayerStatus = dispatcher.sendPlayerStatus;
 
         // For tick-tock tick-tock
         this.tickLoop = new TickLoop(() => {
@@ -105,6 +157,10 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
                 .forEach((packet) => this.tcp.sendPacket(packet.id, packet.data));
             this.player.tick();
         });
+
+        // Forward TCP events
+        this.tcp.on("connect", () => this.emit("connect"));
+        this.tcp.on("destroy", () => this.emit("destroy"));
     }
 
     private emitEvent(event: EmittedEvent) {
@@ -126,14 +182,14 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
      */
     public async connect() {
         await this.loadRegistries();
-
-        if (!this.uuid.length) {
+        if (!this.state.playerUUID) {
             if (this.options.auth) {
-                const authClient = new AuthClient(this.options.auth);
-                const { uuid } = await authClient.auth();
-                this.uuid = Buffer.from(uuid);
+                this.state.authClient = new AuthClient(this.options.auth);
+                const { uuid } = await this.state.authClient.getUUID();
+                this.state.playerUUID = uuid.replaceAll("-", "");
+                await this.state.startSignatureLoop();
             } else
-                this.uuid = computeUUID(this.options.playerName);
+                this.state.playerUUID = computeUUID(this.options.playerName);
         }
 
         this.tcp.connect();
@@ -143,30 +199,40 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
             this.player.setInitialVal();
             this.tickLoop.start();
         });
-        this.once("disconnect", () => {
-            this.tickLoop.stop();
-            this.player.pruneInitialVal();
+        this.tcp.once("destroy", () => {
+            if (this.state.state === ConnectionState.Disconnected) return;
+            this.disconnect("socket close");
         });
     }
     /**
      * Destroy the connection
      */
-    public disconnect() {
+    public disconnect(reason: string = "Disconnect", raw?: TextComponent) {
+        this.state.state = ConnectionState.Disconnected;
+        this.state.status = ClientStatus.Disconnected;
+        this.tickLoop.stop();
+        this.player.pruneInitialVal();
+        this.state.pruneStates();
+        this.emit("disconnect", reason);
+        if (raw)
+            this.emit("disconnectRaw", raw);
         this.tcp.disconnect();
+        if (this.options.auth)
+            this.state.stopSignatureLoop();
     }
 
     // Inputs
     /**
      * Press and hold a key
      */
-    public hold(direction: MoveDirection) {
-        this.player.input(direction);
+    public hold(inout: Input) {
+        this.player.input(inout);
     }
     /**
      * Release a key
      */
-    public release(direction: MoveDirection) {
-        this.player.releaseInput(direction);
+    public release(input: Input) {
+        this.player.releaseInput(input);
     }
     /**
      * Release all key
@@ -185,4 +251,13 @@ export class Client<IsReady extends boolean = boolean> extends (EventEmitter as
         const vec3 = Vec3.loadArgs(a, b, c);
         return this.blocks.at(vec3);
     }
+
+    /**
+     * Rotate your face
+     * @param yaw In degree
+     * @param pitch In degree
+     */
+    public lookAt(yaw: number, pitch: number) {
+        this.player.setAngle(yaw, pitch);
+    }
 }

package/src/client/tcp.ts

@@ -6,10 +6,10 @@ import { TypedEmmiter } from "../base/event";
 import { BinaryDecoder } from "../packet/decoder";
 import { BinaryEncoder } from "../packet/encoder";
 import { AuthOption } from "./auth";
-import { ClientStatus, ConnectionState, SharedState } from "../world/state";
+import { ClientStatus, SharedState } from "../world/state";
 import { EncodeResult } from "../version/codec";
 import { TextComponent } from "../base/typing";
-import { MissingAuthOption, SockerIsNotWritable } from "../base/error";
+import { NotImplemented, SockerIsNotWritable, UnexpectedValue } from "../base/error";
 
 // Minecraft related typing
 
@@ -31,11 +31,6 @@ export interface TCPClientOption {
     protocolVersion: number,
     /** Player name */
     playerName: string,
-    /**
-     * Set to true only if you are playing in offline server or crack server
-     */
-    isOffline?: boolean,
-
     /**
      * Send empty `Known Packet` to let server send all Registry data, which may consume a lot of bandwith
      */
@@ -99,19 +94,16 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
     ) {
         super();
         this.socket = new Socket(socketOption);
-
-        if (!option.isOffline && !option.auth)
-            throw new MissingAuthOption();
     }
 
-    public sendInitPacket: () => void = () => { throw new Error("method not implemented"); };
-    public forwardPacket: (packetId: number, decoder: BinaryDecoder) => void = (...args) => { throw new Error("method not implemented"); };
-    public parsePacket: (packetId: string | number, data: object) => EncodeResult = (...args) => { throw new Error("method not implemented"); };
+    public sendInitPacket: () => void = () => { throw new NotImplemented(); };
+    public forwardPacket: (packetId: number, decoder: BinaryDecoder) => void = () => { throw new NotImplemented(); };
+    public parsePacket: (packetId: string | number, data: object) => EncodeResult = () => { throw new NotImplemented(); };
 
     /**
      * Connect to server
      */
-    public async connect() {
+    public connect() {
         this.state.status = ClientStatus.Connecting;
         const connection = this.socket.connect({
             host: this.option.host,
@@ -124,26 +116,17 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
         });
         connection.on("data", (data) => {
             let buf = Buffer.from(data);
-            if (this.state.decipher) {
+            if (this.state.decipher)
                 buf = this.state.decipher.update(buf);
-            }
             this.emit("raw", Buffer.from(buf));
             this.bufferPool = Buffer.concat([this.bufferPool, buf]);
             this.handlePacket();
         });
         connection.once("end", () => {
             this.emit("destroy");
-            if (this.state.status === ClientStatus.Disconnected) return;
-            this.state.status = ClientStatus.Disconnected;
-            this.state.state = ConnectionState.Disconnected;
-            // this.emit("disconnect", "socket close");
         });
         connection.once("close", () => {
             this.emit("destroy");
-            if (this.state.status === ClientStatus.Disconnected) return;
-            this.state.status = ClientStatus.Disconnected;
-            this.state.state = ConnectionState.Disconnected;
-            // this.emit("disconnect", "socket close");
         });
     }
 
@@ -157,9 +140,7 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
     */
 
     private handlePacket() {
-        while (true) {
-            if (this.bufferPool.length === 0) break;
-
+        while (this.bufferPool.length > 0) {
             let decoder = new BinaryDecoder(this.bufferPool);
             let packetLength: number;
             try {
@@ -184,6 +165,8 @@ export class TCPClient extends (EventEmitter as new () => TypedEmmiter<TCPClient
                 } else {
                     const dataBuffer = this.bufferPool.subarray(decoder.offset, expectedPacketEnd);
                     const decompressed = inflateSync(dataBuffer);
+                    if (decompressed.length !== dataLength)
+                        throw new UnexpectedValue("decompressed packet data", decompressed.length.toString(), dataLength.toString());
                     decoder = new BinaryDecoder(decompressed);
                     packetID = decoder.readVarInt();
                 }