baltica 2.0.9 → 2.0.10

package/dist/client/client.d.ts

@@ -13,6 +13,7 @@ export declare class Client extends Emitter<ClientEvents> {
     loginData: LoginData;
     stopPastLogin: boolean;
     startGameData: StartGamePacket;
+    private isDisconnected;
     constructor(options: Partial<ClientOptions>);
     connect(): Promise<void>;
     private registerHandshakeHandlers;

package/dist/client/client.js

@@ -20,6 +20,7 @@ class Client extends utils_1.Emitter {
     loginData;
     stopPastLogin = false;
     startGameData;
+    isDisconnected = false;
     constructor(options) {
         super();
         this.options = { ...types_1.defaultClientOptions, ...options };
@@ -145,6 +146,9 @@ class Client extends utils_1.Emitter {
         this.removeAllListeners();
     }
     disconnect(reason = "client disconnect") {
+        if (this.isDisconnected)
+            return;
+        this.isDisconnected = true;
         this.emit("disconnect", reason);
         setTimeout(() => {
             if (this.raknet && typeof this.raknet.disconnect === "function") {
@@ -225,6 +229,8 @@ class Client extends utils_1.Emitter {
         this.sendUncompressed(request.serialize(), raknet_1.Priority.High);
     }
     send(packet, priority = raknet_1.Priority.Medium, compressionMethod) {
+        if (this.isDisconnected)
+            return;
         try {
             const compressed = this.packetCompressor.compress(packet, compressionMethod);
             this.raknet.sendReliable(compressed, priority);

package/dist/server/player.d.ts

@@ -11,6 +11,7 @@ export declare class Player extends Emitter<PlayerEvents> {
     connection: Connection;
     username: string;
     xuid: string;
+    private isDisconnected;
     private privateKey;
     private publicKeyDER;
     private clientX509;

package/dist/server/player.js

@@ -51,6 +51,7 @@ class Player extends utils_1.Emitter {
     connection;
     username = "";
     xuid = "";
+    isDisconnected = false;
     privateKey;
     publicKeyDER;
     clientX509;
@@ -184,6 +185,8 @@ class Player extends utils_1.Emitter {
         }
     }
     send(packet, priority = raknet_1.Priority.High, compressionMethod) {
+        if (this.isDisconnected)
+            return;
         try {
             const compressed = this.packetCompressor.compress(packet, compressionMethod);
             this.connection.send(compressed, priority);
@@ -203,6 +206,9 @@ class Player extends utils_1.Emitter {
         this.connection.send(buf, priority);
     }
     disconnect(reason = "disconnected") {
+        if (this.isDisconnected)
+            return;
+        this.isDisconnected = true;
         utils_1.Logger.info(`Disconnecting ${this.username || "player"}: ${reason}`);
         this.connection.disconnect();
         this.emit("disconnect");

package/dist/shared/serializer/packet-encryptor.js

@@ -67,26 +67,45 @@ class PacketEncryptor {
         return Buffer.from(new Uint8Array(hash.subarray(0, 8)));
     }
     encryptPacket(payload) {
-        if (!this.cipher)
-            throw new Error("Cipher not initialized");
-        const checksum = this.computeCheckSum(payload, this.sendCounter);
-        const toEncrypt = Buffer.concat([payload, checksum]);
-        const encrypted = this.cipher.update(toEncrypt);
-        this.sendCounter++;
-        return Buffer.concat([Buffer.from([0xfe]), encrypted]);
+        if (!this.cipher) {
+            // Cipher destroyed - return unencrypted
+            return Buffer.concat([Buffer.from([0xfe]), payload]);
+        }
+        try {
+            const checksum = this.computeCheckSum(payload, this.sendCounter);
+            const toEncrypt = Buffer.concat([payload, checksum]);
+            const encrypted = this.cipher.update(toEncrypt);
+            this.sendCounter++;
+            return Buffer.concat([Buffer.from([0xfe]), encrypted]);
+        }
+        catch {
+            // Cipher in invalid state - return unencrypted
+            return Buffer.concat([Buffer.from([0xfe]), payload]);
+        }
     }
     decryptPacket(encryptedPayload) {
-        if (!this.decipher)
-            throw new Error("Decipher not initialized");
-        const decrypted = this.decipher.update(encryptedPayload);
-        const packet = decrypted.subarray(0, decrypted.length - 8);
-        const receivedChecksum = decrypted.subarray(decrypted.length - 8);
-        const computedChecksum = this.computeCheckSum(packet, this.receiveCounter);
-        this.receiveCounter++;
-        if (!receivedChecksum.equals(computedChecksum)) {
-            throw new Error("Checksum mismatch");
+        if (!this.decipher) {
+            // Decipher destroyed - return as-is
+            return encryptedPayload;
+        }
+        try {
+            const decrypted = this.decipher.update(encryptedPayload);
+            const packet = decrypted.subarray(0, decrypted.length - 8);
+            const receivedChecksum = decrypted.subarray(decrypted.length - 8);
+            const computedChecksum = this.computeCheckSum(packet, this.receiveCounter);
+            this.receiveCounter++;
+            if (!receivedChecksum.equals(computedChecksum)) {
+                throw new Error("Checksum mismatch");
+            }
+            return packet;
+        }
+        catch (err) {
+            // Re-throw checksum errors, ignore cipher state errors
+            if (err instanceof Error && err.message === "Checksum mismatch") {
+                throw err;
+            }
+            return encryptedPayload;
         }
-        return packet;
     }
 }
 exports.PacketEncryptor = PacketEncryptor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baltica",
-  "version": "2.0.9",
+  "version": "2.0.10",
   "description": "Core baltica package",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",