@sanctumterra/raknet 1.1.7 → 1.1.10

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/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,86 @@ 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];
+    incomingMessage(buffer) {
+        const packetId = buffer.readUint8();
+        const ignore = [132, 192, 128];
         if (this.client.options.debug)
-            console.log(`Received packet: ${packetType}`);
-        switch (packetType) {
-            case raknet_1.Packet.UnconnectedPong:
-                this.handleUnconnectedPong(packet);
-                break;
-            case raknet_1.Packet.OpenConnectionReply1:
-                this.handleOpenConnectionReply1(packet);
+            if (!ignore.includes(packetId))
+                console.debug("Received Packet ID ", packetId);
+        switch (packetId) {
+            case raknet_1.Bitflags.Valid:
+                this.handleFrameSet(buffer);
                 break;
-            case raknet_1.Packet.OpenConnectionReply2:
-                this.handleOpenConnectionReply2(packet);
+            case raknet_1.Packet.OpenConnectionReply1: {
+                const reply = new packets_1.OpenConnectionFirstReply(buffer);
+                const deserialized = reply.deserialize();
+                this.client.emit("open-connection-first-reply", deserialized);
+                sender_1.Sender.secondRequest(this.client, deserialized);
                 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.OpenConnectionReply2: {
+                const reply = new packets_1.OpenConnectionSecondReply(buffer);
+                const deserialized = reply.deserialize();
+                this.client.emit("open-connection-second-reply", deserialized);
+                this.client.sender.connectionRequest();
                 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;
-                }
+            default:
+                this.otherPackets(buffer);
                 if (this.client.options.debug)
-                    console.debug(`Received unknown packet: ${packetType}`);
+                    console.debug("Received unknown packet ", packetId);
+        }
+    }
+    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;
+            default:
+                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 +104,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 +138,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,115 +178,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];
-        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: {
-                this.client.emit("encapsulated", frame);
-                break;
-            }
-            default: {
+    handleSequenced(frame) {
+        const currentHighestSequence = this.inputHighestSequenceIndex[frame.orderChannel];
+        if (this.client.options.debug)
+            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());
-        }
-    }
-    handleNackSequences() {
-        if (this.lostFrameSequences.size > 0) {
-            const nack = new raknet_1.Nack();
-            nack.sequences = [...this.lostFrameSequences];
-            this.lostFrameSequences.clear();
-            this.client.send(nack.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;
     }
-    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 { type OpenConnectionFirstReply } from "../packets";
 import { type Advertisement } from "./types/Advertisement";
 declare class Sender {
     private readonly client;
@@ -22,7 +22,7 @@ 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 ping(client: Client): Promise<Advertisement>;

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,48 @@ 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;
+        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;
+        }
+        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.OpenConnectionSecondRequest();
+        pak.mtu = client.options.mtu;
+        pak.client = client.options.guid;
+        pak.magic = reply1.magic;
+        pak.address = new raknet_1.Address(client.socket.address().address, client.socket.address().port, 4);
+        client.send(pak.serialize());
     }
     static async ping(client) {
         return new Promise((resolve, reject) => {
@@ -161,7 +171,6 @@ class Sender {
             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);
@@ -175,6 +184,7 @@ class Sender {
                 }
             };
             client.socket.on("message", listener);
+            client.send(packet.serialize());
         });
     }
 }

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: 19133,
+    port: 19132,
 });
 client.connect().then((advertisement) => {
     console.log(advertisement);

package/package.json

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