@sanctumterra/raknet 1.1.8 → 1.1.11

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

@@ -1,12 +1,12 @@
 import type { Ack, Frame, FrameSet } from "@serenityjs/raknet";
-import type { OpenConnectionFirstReply, OpenConnectionSecondReply, UnconnectedPong } from "../packets";
+import type { OpenConnectionReplyOne, OpenConnectionReplyTwo, UnconnectedPong } from "../packets";
 interface ClientEvents {
     tick: [];
     close: [];
     error: [error: Error];
     "unconnected-pong": [UnconnectedPong];
-    "open-connection-first-reply": [OpenConnectionFirstReply];
-    "open-connection-second-reply": [OpenConnectionSecondReply];
+    "open-connection-reply-one": [OpenConnectionReplyOne];
+    "open-connection-reply-two": [OpenConnectionReplyTwo];
     frameset: [FrameSet];
     encapsulated: [Frame];
     connect: [];

package/dist/client/client.js

@@ -18,19 +18,18 @@ class Client extends emitter_1.default {
         this.status = raknet_1.Status.Disconnected;
         this.options = { ...options_1.defaultOptions, ...options };
         this.socket = options.socket ?? (0, node_dgram_1.createSocket)("udp4");
-        this.receiver = new receiver_1.Receiver(this, this.socket);
+        this.receiver = new receiver_1.Receiver(this);
         this.sender = new sender_1.Sender(this);
     }
     async connect() {
         this.ticker = setInterval(() => {
             this.tick++;
             this.emit("tick");
-        }, 50);
+        }, 50).unref();
         this.tick++;
         this.status = raknet_1.Status.Connecting;
         const advertisement = await this.ping();
         await sender_1.Sender.connect(this);
-        this.emit("connect");
         return advertisement;
     }
     ping() {
@@ -42,6 +41,7 @@ class Client extends emitter_1.default {
     close() {
         this.emit("close");
         this.socket.close();
+        // @ts-ignore
         clearInterval(this.ticker);
     }
     disconnect() {

package/dist/client/options.js

@@ -6,9 +6,9 @@ const defaultOptions = {
     host: "0.0.0.0",
     port: 19132,
     guid: BigInt(Math.floor(Math.random() * 9007199254740991)),
-    mtu: 1024,
+    mtu: 1492,
     debug: false,
-    timeout: 5000,
+    timeout: 10000,
     socket: undefined,
 };
 exports.defaultOptions = defaultOptions;

package/dist/client/receiver.d.ts

@@ -1,11 +1,8 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { Frame } from "@serenityjs/raknet";
-import type { Socket } from "node:dgram";
 import type { Client } from "./client";
+import { NewIncomingConnection } from "../packets";
 declare class Receiver {
-    private readonly client;
-    private readonly socket;
     private lastInputSequence;
     private receivedFrameSequences;
     private lostFrameSequences;
@@ -13,26 +10,23 @@ declare class Receiver {
     private inputOrderIndex;
     protected inputOrderingQueue: Map<number, Map<number, Frame>>;
     protected readonly fragmentsQueue: Map<number, Map<number, Frame>>;
-    constructor(client: Client, socket: Socket);
+    private client;
+    constructor(client: Client);
+    incomingMessage(buffer: Buffer): void;
+    otherPackets(buffer: Buffer): void;
+    sendUnconnectedPing(): void;
     private tick;
-    handle(packet: Buffer): void;
-    private handleFrameSet;
+    send(buffer: Buffer): void;
+    handleFrameSet(buffer: Buffer): void;
     private handleFrame;
-    private handleOrdered;
-    private processOrderedFrames;
-    private handleSequenced;
+    private processFrame;
     private handleFragment;
     private reassembleAndProcessFragment;
-    private processFrame;
+    private handleSequenced;
+    private handleOrdered;
+    private processOrderedFrames;
     private handleConnectedPing;
-    private handleAckSequences;
-    private handleNackSequences;
-    private handleUnconnectedPong;
-    private handleOpenConnectionReply1;
-    private handleOpenConnectionReply2;
-    private handleValidPacket;
-    private handleSequenceGap;
-    private createReassembledFrame;
+    handleConnectionRequestAcceptedTwo(frame: Frame): NewIncomingConnection;
     private handleConnectionRequestAccepted;
 }
 export { Receiver };

package/dist/client/receiver.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Receiver = void 0;
-const binarystream_1 = require("@serenityjs/binarystream");
 const raknet_1 = require("@serenityjs/raknet");
+const binarystream_1 = require("@serenityjs/binarystream");
 const packets_1 = require("../packets");
 const sender_1 = require("./sender");
+const magic = Buffer.from("00ffff00fefefefefdfdfdfd12345678", "hex");
 class Receiver {
-    constructor(client, socket) {
+    constructor(client) {
         this.lastInputSequence = -1;
         this.receivedFrameSequences = new Set();
         this.lostFrameSequences = new Set();
@@ -15,55 +16,98 @@ class Receiver {
         this.inputOrderingQueue = new Map();
         this.fragmentsQueue = new Map();
         this.client = client;
-        this.client.on("tick", () => this.tick());
-        this.socket = socket;
-        this.socket.on("message", (packet) => this.handle(packet));
         for (let index = 0; index < 64; index++) {
             this.inputOrderingQueue.set(index, new Map());
         }
+        this.client.on("tick", () => {
+            this.tick();
+        });
+        this.client.socket.on("message", (...data) => {
+            this.incomingMessage(data[0]);
+        });
     }
-    tick() {
-        this.handleAckSequences();
-        this.handleNackSequences();
-    }
-    handle(packet) {
-        const packetType = packet[0];
-        if (this.client.options.debug)
-            console.log(`Received packet: ${packetType}`);
-        switch (packetType) {
-            case raknet_1.Packet.UnconnectedPong:
-                this.handleUnconnectedPong(packet);
+    incomingMessage(buffer) {
+        const packetId = buffer.readUint8();
+        const ignore = [132, 192, 128];
+        if (this.client.options.debug && !ignore.includes(packetId)) {
+            console.log(`Received Socket Message: ${packetId}`);
+        }
+        switch (packetId) {
+            case raknet_1.Bitflags.Valid:
+                this.handleFrameSet(buffer);
                 break;
-            case raknet_1.Packet.OpenConnectionReply1:
-                this.handleOpenConnectionReply1(packet);
+            case raknet_1.Packet.OpenConnectionReply1: {
+                const reply = new packets_1.OpenConnectionReplyOne(buffer);
+                const deserialized = reply.deserialize();
+                if (reply.security) {
+                    console.error("Server requires security, which is not supported.");
+                    process.exit(1);
+                }
+                this.client.emit("open-connection-reply-one", deserialized);
+                sender_1.Sender.secondRequest(this.client, deserialized);
                 break;
-            case raknet_1.Packet.OpenConnectionReply2:
-                this.handleOpenConnectionReply2(packet);
+            }
+            case raknet_1.Packet.OpenConnectionReply2: {
+                const reply = new packets_1.OpenConnectionReplyTwo(buffer);
+                const deserialized = reply.deserialize();
+                this.client.emit("open-connection-reply-two", deserialized);
+                this.client.sender.connectionRequest();
                 break;
-            case raknet_1.Bitflags.Valid: {
-                if (this.client.options.debug)
-                    console.log(`Received valid packet: ${packetType}`);
-                this.handleValidPacket(packet);
-                return;
             }
-            case raknet_1.Packet.Ack: {
-                this.client.emit("ack", new raknet_1.Ack(packet).deserialize());
+            case raknet_1.Packet.UnconnectedPong: {
                 break;
             }
-            default: {
-                const packetId = packet.readUint8() & 0xf0;
-                if ((packetId & 0xf0) === raknet_1.Bitflags.Valid) {
-                    if (this.client.options.debug)
-                        console.log(`Received valid packet: ${packetType}`);
-                    this.handleFrameSet(packet);
-                    return;
-                }
-                if (this.client.options.debug)
-                    console.debug(`Received unknown packet: ${packetType}`);
+            default:
+                this.otherPackets(buffer);
+        }
+    }
+    otherPackets(buffer) {
+        const packetId = buffer.readUint8() & 0xf0;
+        switch (packetId) {
+            case raknet_1.Bitflags.Valid:
+                this.handleFrameSet(buffer);
+                break;
+            case raknet_1.Packet.Ack:
+                //this.ack(buffer);
+                break;
+            case raknet_1.Packet.Nack:
+                //console.debug(new Nack(buffer).deserialize());
+                break;
+            case raknet_1.Packet.ConnectionRequestAccepted: {
                 break;
             }
+            default:
+                if (this.client.options.debug)
+                    console.debug(`Received unknown packet ${packetId}`);
+                break;
         }
     }
+    sendUnconnectedPing() {
+        const packet = new raknet_1.UnconnectedPing();
+        packet.timestamp = BigInt(Date.now());
+        packet.magic = magic;
+        packet.client = BigInt(this.client.options.guid);
+        this.client.send(packet.serialize());
+    }
+    tick() {
+        if (this.receivedFrameSequences.size > 0) {
+            const ack = new raknet_1.Ack();
+            ack.sequences = [...this.receivedFrameSequences];
+            for (const sequence of this.receivedFrameSequences)
+                this.receivedFrameSequences.delete(sequence);
+            this.send(ack.serialize());
+        }
+        if (this.lostFrameSequences.size > 0) {
+            const nack = new raknet_1.Nack();
+            nack.sequences = [...this.lostFrameSequences];
+            for (const sequence of this.lostFrameSequences)
+                this.lostFrameSequences.delete(sequence);
+            this.send(nack.serialize());
+        }
+    }
+    send(buffer) {
+        this.client.send(buffer);
+    }
     handleFrameSet(buffer) {
         const frameSet = new raknet_1.FrameSet(buffer).deserialize();
         if (this.receivedFrameSequences.has(frameSet.sequence)) {
@@ -72,22 +116,27 @@ class Receiver {
             return;
         }
         this.lostFrameSequences.delete(frameSet.sequence);
-        if (frameSet.sequence <= this.lastInputSequence) {
+        if (frameSet.sequence < this.lastInputSequence ||
+            frameSet.sequence === this.lastInputSequence) {
             if (this.client.options.debug)
                 console.debug(`Received out of order frameset ${frameSet.sequence}!`);
             return;
         }
         this.receivedFrameSequences.add(frameSet.sequence);
-        this.handleSequenceGap(frameSet.sequence);
+        const diff = frameSet.sequence - this.lastInputSequence;
+        if (diff !== 1) {
+            for (let index = this.lastInputSequence + 1; index < frameSet.sequence; index++) {
+                if (!this.receivedFrameSequences.has(index)) {
+                    this.lostFrameSequences.add(index);
+                }
+            }
+        }
         this.lastInputSequence = frameSet.sequence;
         for (const frame of frameSet.frames) {
             this.handleFrame(frame);
         }
     }
     handleFrame(frame) {
-        if (this.client.options.debug) {
-            console.debug(`Handling frame: reliability=${frame.reliability}, orderIndex=${frame.orderIndex}, sequenceIndex=${frame.sequenceIndex}`);
-        }
         if (frame.isSplit()) {
             this.handleFragment(frame);
         }
@@ -101,47 +150,31 @@ class Receiver {
             this.processFrame(frame);
         }
     }
-    handleOrdered(frame) {
-        const expectedOrderIndex = this.inputOrderIndex[frame.orderChannel];
-        const orderingQueue = this.inputOrderingQueue.get(frame.orderChannel) ||
-            new Map();
-        if (frame.orderIndex === expectedOrderIndex) {
-            this.processOrderedFrames(frame, orderingQueue);
-        }
-        else if (frame.orderIndex > expectedOrderIndex) {
-            orderingQueue.set(frame.orderIndex, frame);
-        }
-    }
-    processOrderedFrames(frame, orderingQueue) {
-        this.processFrame(frame);
-        this.inputOrderIndex[frame.orderChannel]++;
-        let nextOrderIndex = this.inputOrderIndex[frame.orderChannel];
-        while (orderingQueue.has(nextOrderIndex)) {
-            const nextFrame = orderingQueue.get(nextOrderIndex);
-            if (nextFrame) {
-                this.processFrame(nextFrame);
-                orderingQueue.delete(nextOrderIndex);
-                this.inputOrderIndex[frame.orderChannel]++;
-                nextOrderIndex++;
-            }
-        }
-    }
-    handleSequenced(frame) {
-        const currentHighestSequence = this.inputHighestSequenceIndex[frame.orderChannel];
-        if (frame.sequenceIndex > currentHighestSequence) {
-            this.inputHighestSequenceIndex[frame.orderChannel] = frame.sequenceIndex;
-            this.processFrame(frame);
-        }
-        else {
-            if (this.client.options.debug)
-                console.debug(`Discarding old sequenced frame: ${frame.sequenceIndex}`);
+    processFrame(frame) {
+        const header = frame.payload[0];
+        switch (header) {
+            case raknet_1.Packet.ConnectionRequestAccepted:
+                this.handleConnectionRequestAccepted(frame);
+                break;
+            case raknet_1.Packet.ConnectedPing:
+                this.handleConnectedPing(frame.payload);
+                break;
+            default:
+                this.client.emit("encapsulated", frame);
+                break;
         }
     }
     handleFragment(frame) {
-        const fragment = this.fragmentsQueue.get(frame.splitId) || new Map();
-        this.fragmentsQueue.set(frame.splitId, fragment);
+        if (!this.fragmentsQueue.has(frame.splitId)) {
+            this.fragmentsQueue.set(frame.splitId, new Map());
+        }
+        const fragment = this.fragmentsQueue.get(frame.splitId);
+        if (!fragment)
+            return;
         fragment.set(frame.splitIndex, frame);
         if (fragment.size === frame.splitSize) {
+            if (this.client.options.debug)
+                console.debug(`Reassembling complete frame from fragments: splitId=${frame.splitId}`);
             this.reassembleAndProcessFragment(frame, fragment);
         }
     }
@@ -157,119 +190,114 @@ class Receiver {
                 return;
             }
         }
-        const reassembledFrame = this.createReassembledFrame(frame, stream.getBuffer());
+        const reassembledFrame = new raknet_1.Frame();
+        reassembledFrame.reliability = frame.reliability;
+        reassembledFrame.reliableIndex = frame.reliableIndex;
+        reassembledFrame.sequenceIndex = frame.sequenceIndex;
+        reassembledFrame.orderIndex = frame.orderIndex;
+        reassembledFrame.orderChannel = frame.orderChannel;
+        reassembledFrame.payload = stream.getBuffer();
         this.fragmentsQueue.delete(frame.splitId);
         this.handleFrame(reassembledFrame);
     }
-    processFrame(frame) {
-        const header = frame.payload[0];
+    handleSequenced(frame) {
+        const currentHighestSequence = this.inputHighestSequenceIndex[frame.orderChannel];
         if (this.client.options.debug)
-            console.log(`Processing frame: ${header}`);
-        switch (header) {
-            case raknet_1.Packet.ConnectionRequestAccepted: {
-                this.handleConnectionRequestAccepted(frame);
-                break;
-            }
-            case raknet_1.Packet.Disconnect: {
-                this.client.close();
-                break;
-            }
-            case raknet_1.Packet.ConnectedPing: {
-                this.handleConnectedPing(frame);
-                break;
-            }
-            case 254: {
-                if (this.client.options.debug)
-                    console.log(`Received encapsulated packet: ${header}`);
-                this.client.emit("encapsulated", frame);
-                break;
-            }
-            default: {
+            console.debug(`Handling sequenced frame: sequenceIndex=${frame.sequenceIndex}, currentHighest=${currentHighestSequence}`);
+        if (frame.sequenceIndex > currentHighestSequence) {
+            this.inputHighestSequenceIndex[frame.orderChannel] = frame.sequenceIndex;
+            this.processFrame(frame);
+        }
+        else {
+            if (this.client.options.debug)
+                console.debug(`Discarding old sequenced frame: ${frame.sequenceIndex}`);
+        }
+    }
+    handleOrdered(frame) {
+        if (this.client.options.debug)
+            console.debug(`Handling ordered frame: orderIndex=${frame.orderIndex}, channel=${frame.orderChannel}`);
+        const expectedOrderIndex = this.inputOrderIndex[frame.orderChannel];
+        const outOfOrderQueue = this.inputOrderingQueue.get(frame.orderChannel);
+        if (frame.orderIndex === expectedOrderIndex) {
+            this.processOrderedFrames(frame, outOfOrderQueue);
+        }
+        else if (frame.orderIndex > expectedOrderIndex) {
+            if (this.client.options.debug)
+                console.debug(`Queuing out-of-order frame: ${frame.orderIndex}`);
+            outOfOrderQueue.set(frame.orderIndex, frame);
+        }
+        else {
+            if (this.client.options.debug)
+                console.debug(`Discarding old frame: ${frame.orderIndex}`);
+        }
+    }
+    processOrderedFrames(frame, outOfOrderQueue) {
+        this.processFrame(frame);
+        this.inputOrderIndex[frame.orderChannel]++;
+        let nextOrderIndex = this.inputOrderIndex[frame.orderChannel];
+        while (outOfOrderQueue.has(nextOrderIndex)) {
+            const nextFrame = outOfOrderQueue.get(nextOrderIndex);
+            if (nextFrame) {
                 if (this.client.options.debug)
-                    console.debug(`Received unknown packet in processFrame: ${header}`);
-                break;
+                    console.debug(`Processing queued frame: ${nextOrderIndex}`);
+                this.processFrame(nextFrame);
+                outOfOrderQueue.delete(nextOrderIndex);
+                this.inputOrderIndex[frame.orderChannel]++;
+                nextOrderIndex++;
             }
         }
     }
-    handleConnectedPing(iframe) {
-        const packet = new packets_1.ConnectedPing(iframe.payload);
+    handleConnectedPing(buffer) {
+        const packet = new packets_1.ConnectedPing(buffer);
         const deserializedPacket = packet.deserialize();
-        const pong = new raknet_1.ConnectedPong();
-        pong.pingTimestamp = deserializedPacket.timestamp;
-        pong.timestamp = BigInt(Date.now());
+        const pong = new packets_1.ConnectedPong();
+        pong.pingTime = deserializedPacket.timestamp;
+        pong.pongTime = BigInt(Date.now());
         const frame = new raknet_1.Frame();
         frame.reliability = raknet_1.Reliability.Unreliable;
         frame.orderChannel = 0;
         frame.payload = pong.serialize();
         this.client.sender.sendFrame(frame, raknet_1.Priority.Immediate);
     }
-    handleAckSequences() {
-        if (this.receivedFrameSequences.size > 0) {
-            const ack = new raknet_1.Ack();
-            ack.sequences = [...this.receivedFrameSequences];
-            this.receivedFrameSequences.clear();
-            this.client.send(ack.serialize());
-        }
+    handleConnectionRequestAcceptedTwo(frame) {
+        const des = new packets_1.ConnectionRequestAccepted(frame.payload).deserialize();
+        const packet = new packets_1.NewIncomingConnection();
+        packet.internalAddresses = new Array(10).fill(new raknet_1.Address("0.0.0.0", 0, 4));
+        packet.serverAddress = des.address;
+        packet.incomingTimestamp = BigInt(Date.now());
+        packet.serverTimestamp = des.timestamp;
+        return packet;
     }
-    handleNackSequences() {
-        if (this.lostFrameSequences.size > 0) {
-            const nack = new raknet_1.Nack();
-            nack.sequences = [...this.lostFrameSequences];
-            this.lostFrameSequences.clear();
-            this.client.send(nack.serialize());
-        }
-    }
-    handleUnconnectedPong(packet) {
-        const pong = new packets_1.UnconnectedPong(packet);
-        this.client.emit("unconnected-pong", pong.deserialize());
-    }
-    handleOpenConnectionReply1(packet) {
-        const reply = new packets_1.OpenConnectionFirstReply(packet);
-        const deserialized = reply.deserialize();
-        this.client.emit("open-connection-first-reply", deserialized);
-        sender_1.Sender.secondRequest(this.client, deserialized);
-    }
-    handleOpenConnectionReply2(packet) {
-        const reply = new packets_1.OpenConnectionSecondReply(packet);
-        const deserialized = reply.deserialize();
-        this.client.emit("open-connection-second-reply", deserialized);
-        this.client.sender.connectionRequest();
-    }
-    handleValidPacket(packet) {
+    handleConnectionRequestAccepted(frame) {
+        let des;
+        let packet;
         try {
-            const frameSet = new raknet_1.FrameSet(packet);
-            const deserialized = frameSet.deserialize();
-            this.client.emit("frameset", deserialized);
-            this.handleFrameSet(packet);
+            const IncomingPacket = new packets_1.ConnectionRequestAccepted(frame.payload);
+            des = IncomingPacket.deserialize();
+            packet = new packets_1.NewIncomingConnection();
+            packet.internalAddresses = new Array(10).fill(new raknet_1.Address("0.0.0.0", 0, 4));
+            packet.serverAddress = new raknet_1.Address(des.address.address, des.address.port, 4);
+            packet.incomingTimestamp = BigInt(Date.now());
+            packet.serverTimestamp = des.timestamp;
         }
         catch (error) {
-            console.error(error);
+            packet = this.handleConnectionRequestAcceptedTwo(frame);
         }
-    }
-    handleSequenceGap(currentSequence) {
-        const diff = currentSequence - this.lastInputSequence;
-        if (diff !== 1) {
-            for (let index = this.lastInputSequence + 1; index < currentSequence; index++) {
-                if (!this.receivedFrameSequences.has(index)) {
-                    this.lostFrameSequences.add(index);
-                }
-            }
+        if (!packet) {
+            console.error("Failed to deserialize IncomingPacket!");
+            return;
         }
-    }
-    createReassembledFrame(originalFrame, payload) {
-        const reassembledFrame = new raknet_1.Frame();
-        reassembledFrame.reliability = originalFrame.reliability;
-        reassembledFrame.reliableIndex = originalFrame.reliableIndex;
-        reassembledFrame.sequenceIndex = originalFrame.sequenceIndex;
-        reassembledFrame.orderIndex = originalFrame.orderIndex;
-        reassembledFrame.orderChannel = originalFrame.orderChannel;
-        reassembledFrame.payload = payload;
-        return reassembledFrame;
-    }
-    handleConnectionRequestAccepted(frame) {
-        const packet = new packets_1.ConnectionRequestAccepted(frame.payload);
-        const deserialized = packet.deserialize();
-        this.client.sender.newIncommingConnection(frame.payload, deserialized);
+        const sendFrame = new raknet_1.Frame();
+        sendFrame.reliability = raknet_1.Reliability.ReliableOrdered;
+        sendFrame.orderChannel = 0;
+        sendFrame.payload = packet.serialize();
+        if (!sendFrame.payload) {
+            console.error("Failed to serialize the packet!");
+            return;
+        }
+        this.client.status = raknet_1.Status.Connected;
+        this.client.sender.sendFrame(sendFrame, raknet_1.Priority.Immediate);
+        void this.client.emit("connect");
     }
 }
 exports.Receiver = Receiver;

package/dist/client/sender.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Frame, FrameSet, Priority } from "@serenityjs/raknet";
 import type { Client } from "./client";
-import { type OpenConnectionFirstReply, type ConnectionRequestAccepted } from "../packets";
+import { OpenConnectionReplyOne } from "../packets";
 import { type Advertisement } from "./types/Advertisement";
 declare class Sender {
     private readonly client;
@@ -22,9 +22,9 @@ declare class Sender {
     private createSplitFrame;
     private queueFrame;
     sendQueue(amount: number): void;
-    newIncommingConnection(payload: Buffer, deserialized?: ConnectionRequestAccepted | null): void;
+    newIncommingConnection(payload: Buffer): void;
     connectionRequest(): void;
-    static secondRequest(client: Client, reply1: OpenConnectionFirstReply): void;
+    static secondRequest(client: Client, reply1: OpenConnectionReplyOne): void;
     static ping(client: Client): Promise<Advertisement>;
     static connect(client: Client): Promise<void>;
 }

package/dist/client/sender.js

@@ -12,17 +12,19 @@ class Sender {
         this.outputReliableIndex = 0;
         this.outputFrames = new Set();
         this.outputBackup = new Map();
-        this.outputOrderIndex = Array(32).fill(0);
-        this.outputSequenceIndex = Array(32).fill(0);
         this.outputFrameQueue = new raknet_1.FrameSet();
-        this.mtu = client.options.mtu;
         this.outputFrameQueue.frames = [];
+        this.outputOrderIndex = Array.from({ length: 32 }).fill(0);
+        this.outputSequenceIndex = Array.from({ length: 32 }).fill(0);
+        this.mtu = client.options.mtu;
         this.client.on("tick", () => this.tick());
     }
     tick() {
         if (this.client.status === raknet_1.Status.Disconnecting ||
-            this.client.status === raknet_1.Status.Disconnected)
+            this.client.status === raknet_1.Status.Disconnected) {
+            console.log("Can not send queue, client is disconnecting or disconnected");
             return;
+        }
         this.sendQueue(this.outputFrames.size);
     }
     sendFrame(frame, priority) {
@@ -98,40 +100,50 @@ class Sender {
             this.outputFrames.delete(frame);
         this.client.send(frameset.serialize());
     }
-    newIncommingConnection(payload, deserialized = null) {
-        const packet = new packets_1.NewIncomingConnection();
-        if (deserialized === null) {
+    newIncommingConnection(payload) {
+        let des = null;
+        let packet;
+        console.log("RATATA");
+        try {
+            const IncomingPacket = new packets_1.ConnectionRequestAccepted(payload);
+            des = IncomingPacket.deserialize();
+            packet = new packets_1.NewIncomingConnection();
             packet.internalAddresses = new Array(10).fill(new raknet_1.Address("0.0.0.0", 0, 4));
-            packet.serverAddress = new raknet_1.Address("0.0.0.0", 0, 0);
+            packet.serverAddress = new raknet_1.Address(des.address.address, des.address.port, 4);
             packet.incomingTimestamp = BigInt(Date.now());
-            packet.serverTimestamp = 0n;
+            packet.serverTimestamp = des.timestamp;
         }
-        else {
-            packet.internalAddresses = new Array(10).fill(new raknet_1.Address("0.0.0.0", 0, 4));
-            packet.serverAddress = new raknet_1.Address(deserialized.address.address, deserialized.address.port, 4);
+        catch (error) {
+            const _des = new packets_1.ConnectionRequestAccepted(payload).deserialize();
+            packet = new packets_1.NewIncomingConnection();
+            packet.internalAddresses = new Array(20).fill(new raknet_1.Address("0.0.0.0", 0, 4));
+            packet.serverAddress = new raknet_1.Address("0.0.0.0", 0, 4);
             packet.incomingTimestamp = BigInt(Date.now());
-            packet.serverTimestamp = deserialized.timestamp;
+            packet.serverTimestamp = BigInt(0);
         }
+        if (!packet) {
+            console.error("Failed to deserialize IncomingPacket!");
+            return;
+        }
+        console.log(packet);
+        this.client.status = raknet_1.Status.Connected;
         this.client.sender.frameAndSend(packet.serialize(), raknet_1.Priority.Immediate);
+        void this.client.emit("connect");
     }
     connectionRequest() {
         const packet = new packets_1.ConnectionRequest();
         packet.client = BigInt(this.client.options.guid);
         packet.timestamp = BigInt(Date.now());
         packet.security = false;
-        const frame = new raknet_1.Frame();
-        frame.reliability = raknet_1.Reliability.Reliable;
-        frame.orderChannel = 0;
-        frame.payload = packet.serialize();
-        this.sendFrame(frame, raknet_1.Priority.Immediate);
+        this.frameAndSend(packet.serialize(), raknet_1.Priority.Immediate);
     }
     static secondRequest(client, reply1) {
-        const packet = new packets_1.OpenConnectionSecondRequest();
-        packet.magic = new raknet_1.Magic();
-        packet.address = new raknet_1.Address(client.socket.address().address, client.socket.address().port, 4);
-        packet.mtu = client.options.mtu;
-        packet.client = reply1.guid;
-        client.send(packet.serialize());
+        const pak = new packets_1.OpenConnectionRequestTwo();
+        pak.magic = reply1.magic;
+        pak.address = new raknet_1.Address("0.0.0.0", client.options.port, 4);
+        pak.mtu = reply1.mtu;
+        pak.client = client.options.guid;
+        client.send(pak.serialize());
     }
     static async ping(client) {
         return new Promise((resolve, reject) => {
@@ -156,26 +168,76 @@ class Sender {
         });
     }
     static async connect(client) {
-        return new Promise((resolve, reject) => {
-            const packet = new packets_1.OpenConnectionFirstRequest();
-            packet.magic = new raknet_1.Magic();
-            packet.mtu = client.options.mtu;
-            packet.protocol = client.options.protocol;
-            client.send(packet.serialize());
-            const timer = setTimeout(() => {
-                reject(new Error(`Connection request has timed out after ${client.options.timeout}ms.`));
-                client.socket.off("message", listener);
-                clearTimeout(timer);
-            }, client.options.timeout);
-            const listener = (packet) => {
-                if (packet[0] === raknet_1.Packet.Ack) {
+        const maxRetries = 5;
+        let retryCount = 0;
+        const attemptConnection = () => {
+            return new Promise((resolve, reject) => {
+                let send = true;
+                let MTU = client.options.mtu - 28;
+                const packet = new packets_1.OpenConnectionRequestOne();
+                packet.magic = Buffer.from([
+                    0, 255, 255, 0, 254, 254, 254, 254, 253, 253, 253, 253, 18, 52, 86,
+                    120,
+                ]);
+                packet.mtu = MTU;
+                packet.protocol = client.options.protocol;
+                const interval = setInterval(() => {
+                    if (MTU <= 1172)
+                        MTU = 548;
+                    if (MTU > 1400)
+                        MTU = 1172;
+                    packet.mtu = MTU;
+                    client.options.mtu = MTU;
+                    if (send) {
+                        client.send(packet.serialize());
+                    }
+                }, 1500);
+                const timer = setTimeout(() => {
+                    client.socket.off("message", listener);
+                    clearTimeout(timer);
+                    clearInterval(interval);
+                    reject(new Error("Connection attempt timed out"));
+                }, client.options.timeout);
+                const packet8Timer = setTimeout(() => {
                     client.socket.off("message", listener);
                     clearTimeout(timer);
-                    resolve();
+                    clearInterval(interval);
+                    reject(new Error("Packet 8 not received"));
+                }, client.options.timeout / 3);
+                const listener = (buffer) => {
+                    if (buffer[0] === raknet_1.Packet.OpenConnectionReply1) {
+                        send = false;
+                        const reply1 = new packets_1.OpenConnectionReplyOne(buffer);
+                        const deserializedReply1 = reply1.deserialize();
+                        Sender.secondRequest(client, deserializedReply1);
+                    }
+                    else if (buffer[0] === raknet_1.Packet.Ack) {
+                        client.socket.off("message", listener);
+                        clearTimeout(timer);
+                        clearTimeout(packet8Timer);
+                        clearInterval(interval);
+                        resolve();
+                    }
+                };
+                client.socket.on("message", listener);
+                client.send(packet.serialize());
+            });
+        };
+        while (retryCount < maxRetries) {
+            try {
+                await attemptConnection();
+                return;
+            }
+            catch (error) {
+                if (client.options.debug)
+                    console.log(`Connection attempt ${retryCount + 1} failed: ${error.message}`);
+                retryCount++;
+                if (retryCount >= maxRetries) {
+                    throw new Error(`Failed to connect after ${maxRetries} attempts`);
                 }
-            };
-            client.socket.on("message", listener);
-        });
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+            }
+        }
     }
 }
 exports.Sender = Sender;

package/dist/packets/OpenConnectionReplyOne.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { BasePacket } from "@serenityjs/raknet";
+declare class OpenConnectionReplyOne extends BasePacket {
+    magic: Buffer;
+    guid: bigint;
+    security: boolean;
+    mtu: number;
+}
+export { OpenConnectionReplyOne };

package/dist/packets/{open-connection-first-reply.js → OpenConnectionReplyOne.js}

@@ -9,28 +9,28 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenConnectionFirstReply = void 0;
+exports.OpenConnectionReplyOne = void 0;
 const binarystream_1 = require("@serenityjs/binarystream");
 const raknet_1 = require("@serenityjs/raknet");
-let OpenConnectionFirstReply = class OpenConnectionFirstReply extends raknet_1.BasePacket {
+let OpenConnectionReplyOne = class OpenConnectionReplyOne extends raknet_1.BasePacket {
 };
-exports.OpenConnectionFirstReply = OpenConnectionFirstReply;
+exports.OpenConnectionReplyOne = OpenConnectionReplyOne;
 __decorate([
     (0, raknet_1.Serialize)(raknet_1.Magic),
-    __metadata("design:type", raknet_1.Magic)
-], OpenConnectionFirstReply.prototype, "magic", void 0);
+    __metadata("design:type", Buffer)
+], OpenConnectionReplyOne.prototype, "magic", void 0);
 __decorate([
-    (0, raknet_1.Serialize)(binarystream_1.Long),
+    (0, raknet_1.Serialize)(binarystream_1.Uint64, 0 /* Endianness.Big */),
     __metadata("design:type", BigInt)
-], OpenConnectionFirstReply.prototype, "guid", void 0);
+], OpenConnectionReplyOne.prototype, "guid", void 0);
 __decorate([
     (0, raknet_1.Serialize)(binarystream_1.Bool),
     __metadata("design:type", Boolean)
-], OpenConnectionFirstReply.prototype, "security", void 0);
+], OpenConnectionReplyOne.prototype, "security", void 0);
 __decorate([
-    (0, raknet_1.Serialize)(binarystream_1.Short),
+    (0, raknet_1.Serialize)(binarystream_1.Uint16, 0 /* Endianness.Big */),
     __metadata("design:type", Number)
-], OpenConnectionFirstReply.prototype, "mtu", void 0);
-exports.OpenConnectionFirstReply = OpenConnectionFirstReply = __decorate([
+], OpenConnectionReplyOne.prototype, "mtu", void 0);
+exports.OpenConnectionReplyOne = OpenConnectionReplyOne = __decorate([
     (0, raknet_1.Proto)(raknet_1.Packet.OpenConnectionReply1)
-], OpenConnectionFirstReply);
+], OpenConnectionReplyOne);

package/dist/packets/{open-connection-second-reply.d.ts → OpenConnectionReplyTwo.d.ts}

@@ -1,9 +1,9 @@
 import { Address, BasePacket, Magic } from "@serenityjs/raknet";
-declare class OpenConnectionSecondReply extends BasePacket {
+declare class OpenConnectionReplyTwo extends BasePacket {
     magic: Magic;
     guid: bigint;
     address: Address;
     mtu: number;
     encryption: boolean;
 }
-export { OpenConnectionSecondReply };
+export { OpenConnectionReplyTwo };

package/dist/packets/{open-connection-second-reply.js → OpenConnectionReplyTwo.js}

@@ -9,32 +9,32 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenConnectionSecondReply = void 0;
+exports.OpenConnectionReplyTwo = void 0;
 const binarystream_1 = require("@serenityjs/binarystream");
 const raknet_1 = require("@serenityjs/raknet");
-let OpenConnectionSecondReply = class OpenConnectionSecondReply extends raknet_1.BasePacket {
+let OpenConnectionReplyTwo = class OpenConnectionReplyTwo extends raknet_1.BasePacket {
 };
-exports.OpenConnectionSecondReply = OpenConnectionSecondReply;
+exports.OpenConnectionReplyTwo = OpenConnectionReplyTwo;
 __decorate([
     (0, raknet_1.Serialize)(raknet_1.Magic),
     __metadata("design:type", raknet_1.Magic)
-], OpenConnectionSecondReply.prototype, "magic", void 0);
+], OpenConnectionReplyTwo.prototype, "magic", void 0);
 __decorate([
     (0, raknet_1.Serialize)(binarystream_1.Long),
     __metadata("design:type", BigInt)
-], OpenConnectionSecondReply.prototype, "guid", void 0);
+], OpenConnectionReplyTwo.prototype, "guid", void 0);
 __decorate([
     (0, raknet_1.Serialize)(raknet_1.Address),
     __metadata("design:type", raknet_1.Address)
-], OpenConnectionSecondReply.prototype, "address", void 0);
+], OpenConnectionReplyTwo.prototype, "address", void 0);
 __decorate([
     (0, raknet_1.Serialize)(binarystream_1.Short),
     __metadata("design:type", Number)
-], OpenConnectionSecondReply.prototype, "mtu", void 0);
+], OpenConnectionReplyTwo.prototype, "mtu", void 0);
 __decorate([
     (0, raknet_1.Serialize)(binarystream_1.Bool),
     __metadata("design:type", Boolean)
-], OpenConnectionSecondReply.prototype, "encryption", void 0);
-exports.OpenConnectionSecondReply = OpenConnectionSecondReply = __decorate([
+], OpenConnectionReplyTwo.prototype, "encryption", void 0);
+exports.OpenConnectionReplyTwo = OpenConnectionReplyTwo = __decorate([
     (0, raknet_1.Proto)(raknet_1.Packet.OpenConnectionReply2)
-], OpenConnectionSecondReply);
+], OpenConnectionReplyTwo);

package/dist/packets/OpenConnectionRequestOne.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { BasePacket } from "@serenityjs/raknet";
+declare class OpenConnectionRequestOne extends BasePacket {
+    magic: Buffer;
+    protocol: number;
+    mtu: number;
+}
+export { OpenConnectionRequestOne };

package/dist/packets/{open-connection-first-request.js → OpenConnectionRequestOne.js}

@@ -9,24 +9,24 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenConnectionFirstRequest = void 0;
+exports.OpenConnectionRequestOne = void 0;
 const binarystream_1 = require("@serenityjs/binarystream");
 const raknet_1 = require("@serenityjs/raknet");
-let OpenConnectionFirstRequest = class OpenConnectionFirstRequest extends raknet_1.BasePacket {
+let OpenConnectionRequestOne = class OpenConnectionRequestOne extends raknet_1.BasePacket {
 };
-exports.OpenConnectionFirstRequest = OpenConnectionFirstRequest;
+exports.OpenConnectionRequestOne = OpenConnectionRequestOne;
 __decorate([
     (0, raknet_1.Serialize)(raknet_1.Magic),
-    __metadata("design:type", raknet_1.Magic)
-], OpenConnectionFirstRequest.prototype, "magic", void 0);
+    __metadata("design:type", Buffer)
+], OpenConnectionRequestOne.prototype, "magic", void 0);
 __decorate([
     (0, raknet_1.Serialize)(binarystream_1.Uint8),
     __metadata("design:type", Number)
-], OpenConnectionFirstRequest.prototype, "protocol", void 0);
+], OpenConnectionRequestOne.prototype, "protocol", void 0);
 __decorate([
     (0, raknet_1.Serialize)(raknet_1.MTU),
     __metadata("design:type", Number)
-], OpenConnectionFirstRequest.prototype, "mtu", void 0);
-exports.OpenConnectionFirstRequest = OpenConnectionFirstRequest = __decorate([
+], OpenConnectionRequestOne.prototype, "mtu", void 0);
+exports.OpenConnectionRequestOne = OpenConnectionRequestOne = __decorate([
     (0, raknet_1.Proto)(raknet_1.Packet.OpenConnectionRequest1)
-], OpenConnectionFirstRequest);
+], OpenConnectionRequestOne);

package/dist/packets/{open-connection-second-request.d.ts → OpenConnectionRequestTwo.d.ts}

@@ -1,8 +1,8 @@
 import { Address, BasePacket, Magic } from "@serenityjs/raknet";
-declare class OpenConnectionSecondRequest extends BasePacket {
+declare class OpenConnectionRequestTwo extends BasePacket {
     magic: Magic;
     address: Address;
     mtu: number;
     client: bigint;
 }
-export { OpenConnectionSecondRequest };
+export { OpenConnectionRequestTwo };

package/dist/packets/{open-connection-second-request.js → OpenConnectionRequestTwo.js}

@@ -9,28 +9,28 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenConnectionSecondRequest = void 0;
+exports.OpenConnectionRequestTwo = void 0;
 const binarystream_1 = require("@serenityjs/binarystream");
 const raknet_1 = require("@serenityjs/raknet");
-let OpenConnectionSecondRequest = class OpenConnectionSecondRequest extends raknet_1.BasePacket {
+let OpenConnectionRequestTwo = class OpenConnectionRequestTwo extends raknet_1.BasePacket {
 };
-exports.OpenConnectionSecondRequest = OpenConnectionSecondRequest;
+exports.OpenConnectionRequestTwo = OpenConnectionRequestTwo;
 __decorate([
     (0, raknet_1.Serialize)(raknet_1.Magic),
     __metadata("design:type", raknet_1.Magic)
-], OpenConnectionSecondRequest.prototype, "magic", void 0);
+], OpenConnectionRequestTwo.prototype, "magic", void 0);
 __decorate([
     (0, raknet_1.Serialize)(raknet_1.Address),
     __metadata("design:type", raknet_1.Address)
-], OpenConnectionSecondRequest.prototype, "address", void 0);
+], OpenConnectionRequestTwo.prototype, "address", void 0);
 __decorate([
-    (0, raknet_1.Serialize)(binarystream_1.Short),
+    (0, raknet_1.Serialize)(binarystream_1.Uint16, 0 /* Endianness.Big */),
     __metadata("design:type", Number)
-], OpenConnectionSecondRequest.prototype, "mtu", void 0);
+], OpenConnectionRequestTwo.prototype, "mtu", void 0);
 __decorate([
-    (0, raknet_1.Serialize)(binarystream_1.Long),
+    (0, raknet_1.Serialize)(binarystream_1.Long, 0 /* Endianness.Big */),
     __metadata("design:type", BigInt)
-], OpenConnectionSecondRequest.prototype, "client", void 0);
-exports.OpenConnectionSecondRequest = OpenConnectionSecondRequest = __decorate([
+], OpenConnectionRequestTwo.prototype, "client", void 0);
+exports.OpenConnectionRequestTwo = OpenConnectionRequestTwo = __decorate([
     (0, raknet_1.Proto)(raknet_1.Packet.OpenConnectionRequest2)
-], OpenConnectionSecondRequest);
+], OpenConnectionRequestTwo);

package/dist/packets/index.d.ts

@@ -3,10 +3,10 @@ export * from "./connected-pong";
 export * from "./connection-request-accepted";
 export * from "./connection-request";
 export * from "./new-incoming-connection";
-export * from "./open-connection-first-reply";
-export * from "./open-connection-first-request";
-export * from "./open-connection-second-reply";
-export * from "./open-connection-second-request";
+export * from "./OpenConnectionReplyOne";
+export * from "./OpenConnectionRequestOne";
+export * from "./OpenConnectionReplyTwo";
+export * from "./OpenConnectionRequestTwo";
 export * from "./unconnected-ping";
 export * from "./unconnected-pong";
 export * from "./disconnect";

package/dist/packets/index.js

@@ -19,10 +19,10 @@ __exportStar(require("./connected-pong"), exports);
 __exportStar(require("./connection-request-accepted"), exports);
 __exportStar(require("./connection-request"), exports);
 __exportStar(require("./new-incoming-connection"), exports);
-__exportStar(require("./open-connection-first-reply"), exports);
-__exportStar(require("./open-connection-first-request"), exports);
-__exportStar(require("./open-connection-second-reply"), exports);
-__exportStar(require("./open-connection-second-request"), exports);
+__exportStar(require("./OpenConnectionReplyOne"), exports);
+__exportStar(require("./OpenConnectionRequestOne"), exports);
+__exportStar(require("./OpenConnectionReplyTwo"), exports);
+__exportStar(require("./OpenConnectionRequestTwo"), exports);
 __exportStar(require("./unconnected-ping"), exports);
 __exportStar(require("./unconnected-pong"), exports);
 __exportStar(require("./disconnect"), exports);

package/dist/tools/test.js

@@ -4,7 +4,7 @@ const client_1 = require("../client/client");
 const client = new client_1.Client({
     debug: true,
     host: "127.0.0.1",
-    port: 19132,
+    port: 19133,
 });
 client.connect().then((advertisement) => {
     console.log(advertisement);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanctumterra/raknet",
-  "version": "1.1.8",
+  "version": "1.1.11",
   "module": "index.ts",
   "main": "./dist/index.js",
   "type": "commonjs",

package/dist/packets/open-connection-first-reply.d.ts

@@ -1,8 +0,0 @@
-import { BasePacket, Magic } from "@serenityjs/raknet";
-declare class OpenConnectionFirstReply extends BasePacket {
-    magic: Magic;
-    guid: bigint;
-    security: boolean;
-    mtu: number;
-}
-export { OpenConnectionFirstReply };

package/dist/packets/open-connection-first-request.d.ts

@@ -1,7 +0,0 @@
-import { BasePacket, Magic } from "@serenityjs/raknet";
-declare class OpenConnectionFirstRequest extends BasePacket {
-    magic: Magic;
-    protocol: number;
-    mtu: number;
-}
-export { OpenConnectionFirstRequest };