@baltica/raknet 0.0.1

package/dist/shared/proto/packets/online/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./acknowledgement";
+export * from "./ack";
+export * from "./nack";
+export * from "./connected-ping";
+export * from "./connected-pong";
+export * from "./connection-request";
+export * from "./connection-request-accepted";
+export * from "./new-incoming-connection";
+export * from "./disconnect";
+export * from "./frame-set";

package/dist/shared/proto/packets/online/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./acknowledgement"), exports);
+__exportStar(require("./ack"), exports);
+__exportStar(require("./nack"), exports);
+__exportStar(require("./connected-ping"), exports);
+__exportStar(require("./connected-pong"), exports);
+__exportStar(require("./connection-request"), exports);
+__exportStar(require("./connection-request-accepted"), exports);
+__exportStar(require("./new-incoming-connection"), exports);
+__exportStar(require("./disconnect"), exports);
+__exportStar(require("./frame-set"), exports);

package/dist/shared/proto/packets/online/nack.d.ts

@@ -0,0 +1,5 @@
+import { Packet } from "../../enums/packet";
+import { Acknowledgement } from "./acknowledgement";
+export declare class Nack extends Acknowledgement {
+    static ID: Packet;
+}

package/dist/shared/proto/packets/online/nack.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nack = void 0;
+const packet_1 = require("../../enums/packet");
+const acknowledgement_1 = require("./acknowledgement");
+class Nack extends acknowledgement_1.Acknowledgement {
+    static ID = packet_1.Packet.Nack;
+}
+exports.Nack = Nack;

package/dist/shared/proto/packets/online/new-incoming-connection.d.ts

@@ -0,0 +1,12 @@
+import { Packet } from "../../enums/packet";
+import { DataPacket } from "../data-packet";
+import { Address } from "../../types/address";
+export declare class NewIncomingConnection extends DataPacket {
+    static ID: Packet;
+    address: Address;
+    internalAddress: Address;
+    incomingTimestamp: bigint;
+    serverTimestamp: bigint;
+    serialize(): Buffer;
+    deserialize(): this;
+}

package/dist/shared/proto/packets/online/new-incoming-connection.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewIncomingConnection = void 0;
+const packet_1 = require("../../enums/packet");
+const data_packet_1 = require("../data-packet");
+const address_1 = require("../../types/address");
+class NewIncomingConnection extends data_packet_1.DataPacket {
+    static ID = packet_1.Packet.NewIncomingConnection;
+    address;
+    internalAddress;
+    incomingTimestamp;
+    serverTimestamp;
+    serialize() {
+        this.writeUint8(NewIncomingConnection.ID);
+        address_1.Address.write(this, this.address);
+        for (let i = 0; i < 10; i++) {
+            address_1.Address.write(this, this.internalAddress);
+        }
+        this.writeInt64(this.incomingTimestamp);
+        this.writeInt64(this.serverTimestamp);
+        return this.getBuffer();
+    }
+    deserialize() {
+        this.address = address_1.Address.read(this);
+        for (let i = 0; i < 10; i++) {
+            this.internalAddress = address_1.Address.read(this);
+        }
+        this.incomingTimestamp = this.readInt64();
+        this.serverTimestamp = this.readInt64();
+        return this;
+    }
+}
+exports.NewIncomingConnection = NewIncomingConnection;

package/dist/shared/proto/types/address.d.ts

@@ -0,0 +1,11 @@
+import type { RemoteInfo } from "node:dgram";
+import type { BinaryStream } from "@serenityjs/binarystream";
+export declare class Address {
+    address: string;
+    port: number;
+    version: number;
+    constructor(address: string, port: number, version: number);
+    static fromIdentifier(identifier: RemoteInfo): Address;
+    static write(stream: BinaryStream, address: Address): void;
+    static read(stream: BinaryStream): Address;
+}

package/dist/shared/proto/types/address.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Address = void 0;
+class Address {
+    address;
+    port;
+    version;
+    constructor(address, port, version) {
+        this.address = address;
+        this.port = port;
+        this.version = version;
+    }
+    static fromIdentifier(identifier) {
+        return new Address(identifier.address, identifier.port, identifier.family === "IPv4" ? 4 : 6);
+    }
+    static write(stream, address) {
+        stream.writeUint8(address.version);
+        if (address.version === 4) {
+            const addressBits = address.address.split(".", 4);
+            for (const bit of addressBits) {
+                stream.writeUint8(Number.parseInt(bit, 10) ^ 0xff);
+            }
+            stream.writeUint16(address.port);
+        }
+        else {
+            stream.writeUint16(23);
+            stream.writeUint16(address.port);
+            stream.writeUint32(0);
+            const addressParts = address.address.split(":");
+            for (const part of addressParts) {
+                const num = Number.parseInt(part, 16);
+                stream.writeUint16(num ^ 0xffff);
+            }
+            stream.writeUint32(0);
+        }
+    }
+    static read(stream) {
+        const version = stream.readUint8();
+        if (version === 4) {
+            const bytes = stream.read(4);
+            const address = bytes.map((byte) => byte ^ 0xff).join(".");
+            const port = stream.readUint16();
+            return new Address(address, port, version);
+        }
+        if (version === 6) {
+            stream.offset += 2;
+            const port = stream.readUint16();
+            stream.offset += 4;
+            const addressParts = [];
+            for (let i = 0; i < 8; i++) {
+                const part = stream.readUint16() ^ 0xffff;
+                addressParts.push(part.toString(16).padStart(4, "0"));
+            }
+            const address = addressParts.join(":");
+            stream.offset += 4;
+            return new Address(address, port, version);
+        }
+        return new Address("0.0.0.0", 0, 0);
+    }
+}
+exports.Address = Address;

package/dist/shared/proto/types/data-type.d.ts

@@ -0,0 +1,5 @@
+import { BinaryStream } from "@serenityjs/binarystream";
+export declare abstract class DataType {
+    abstract write(stream: BinaryStream): void;
+    static read(_stream: BinaryStream): DataType;
+}

package/dist/shared/proto/types/data-type.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = void 0;
+class DataType {
+    static read(_stream) {
+        throw new Error(`${this.name}.read is not implemented!`);
+    }
+}
+exports.DataType = DataType;

package/dist/shared/proto/types/frame.d.ts

@@ -0,0 +1,22 @@
+import type { BinaryStream } from "@serenityjs/binarystream";
+import { Reliability } from "../enums/reliability";
+export declare const SplitFlag = 16;
+export declare class Frame {
+    reliability: Reliability;
+    reliableFrameIndex: number;
+    sequenceFrameIndex: number;
+    orderedFrameIndex: number;
+    orderChannel: number;
+    splitFrameIndex: number;
+    splitSize: number;
+    splitId: number;
+    payload: Buffer;
+    static write(stream: BinaryStream, frames: Array<Frame>): void;
+    static read(stream: BinaryStream): Array<Frame>;
+    isSplit(): boolean;
+    isReliable(): boolean;
+    isSequenced(): boolean;
+    isOrdered(): boolean;
+    isOrderExclusive(): boolean;
+    getByteLength(): number;
+}

package/dist/shared/proto/types/frame.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Frame = exports.SplitFlag = void 0;
+const binarystream_1 = require("@serenityjs/binarystream");
+const reliability_1 = require("../enums/reliability");
+exports.SplitFlag = 0x10;
+class Frame {
+    reliability;
+    reliableFrameIndex;
+    sequenceFrameIndex;
+    orderedFrameIndex;
+    orderChannel;
+    splitFrameIndex;
+    splitSize;
+    splitId;
+    payload;
+    static write(stream, frames) {
+        for (const frame of frames) {
+            const isReliable = frame.isReliable();
+            const isSequenced = frame.isSequenced();
+            const isOrdered = frame.isOrdered();
+            const isSplit = frame.isSplit();
+            const header = (frame.reliability << 5) | (isSplit ? exports.SplitFlag : 0);
+            stream.writeUint8(header);
+            stream.writeUint16(frame.payload.byteLength << 3);
+            if (isReliable)
+                stream.writeUint24(frame.reliableFrameIndex, binarystream_1.Endianness.Little);
+            if (isSequenced)
+                stream.writeUint24(frame.sequenceFrameIndex, binarystream_1.Endianness.Little);
+            if (isOrdered) {
+                stream.writeUint24(frame.orderedFrameIndex, binarystream_1.Endianness.Little);
+                stream.writeUint8(frame.orderChannel);
+            }
+            if (isSplit) {
+                stream.writeUint32(frame.splitSize);
+                stream.writeUint16(frame.splitId);
+                stream.writeUint32(frame.splitFrameIndex);
+            }
+            stream.write(frame.payload);
+        }
+    }
+    static read(stream) {
+        const frames = [];
+        while (!stream.feof()) {
+            const frame = new Frame();
+            const header = stream.readUint8();
+            const reliability = (header & 0xe0) >> 5;
+            const split = (header & exports.SplitFlag) !== 0;
+            const length = Math.ceil(stream.readUint16() / 8);
+            frame.reliability = reliability;
+            const isReliable = frame.isReliable();
+            const isSequenced = frame.isSequenced();
+            const isOrdered = frame.isOrdered();
+            if (isReliable)
+                frame.reliableFrameIndex = stream.readUint24(binarystream_1.Endianness.Little);
+            if (isSequenced)
+                frame.sequenceFrameIndex = stream.readUint24(binarystream_1.Endianness.Little);
+            if (isOrdered) {
+                frame.orderedFrameIndex = stream.readUint24(binarystream_1.Endianness.Little);
+                frame.orderChannel = stream.readUint8();
+            }
+            if (split) {
+                frame.splitSize = stream.readUint32();
+                frame.splitId = stream.readUint16();
+                frame.splitFrameIndex = stream.readUint32();
+            }
+            frame.payload = stream.read(length);
+            frames.push(frame);
+        }
+        return frames;
+    }
+    isSplit() {
+        return this.splitSize > 0;
+    }
+    isReliable() {
+        return [
+            reliability_1.Reliability.Reliable,
+            reliability_1.Reliability.ReliableOrdered,
+            reliability_1.Reliability.ReliableSequenced,
+            reliability_1.Reliability.ReliableWithAckReceipt,
+            reliability_1.Reliability.ReliableOrderedWithAckReceipt,
+        ].includes(this.reliability);
+    }
+    isSequenced() {
+        return [
+            reliability_1.Reliability.ReliableSequenced,
+            reliability_1.Reliability.UnreliableSequenced,
+        ].includes(this.reliability);
+    }
+    isOrdered() {
+        return [
+            reliability_1.Reliability.UnreliableSequenced,
+            reliability_1.Reliability.ReliableOrdered,
+            reliability_1.Reliability.ReliableSequenced,
+            reliability_1.Reliability.ReliableOrderedWithAckReceipt,
+        ].includes(this.reliability);
+    }
+    isOrderExclusive() {
+        return [
+            reliability_1.Reliability.ReliableOrdered,
+            reliability_1.Reliability.ReliableOrderedWithAckReceipt,
+        ].includes(this.reliability);
+    }
+    getByteLength() {
+        return (3 +
+            this.payload.byteLength +
+            (this.isReliable() ? 3 : 0) +
+            (this.isSequenced() ? 3 : 0) +
+            (this.isOrdered() ? 4 : 0) +
+            (this.isSplit() ? 10 : 0));
+    }
+}
+exports.Frame = Frame;

package/dist/shared/proto/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./data-type";
+export * from "./magic";
+export * from "./mtu";
+export * from "./address";
+export * from "./frame";

package/dist/shared/proto/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./data-type"), exports);
+__exportStar(require("./magic"), exports);
+__exportStar(require("./mtu"), exports);
+__exportStar(require("./address"), exports);
+__exportStar(require("./frame"), exports);

package/dist/shared/proto/types/magic.d.ts

@@ -0,0 +1,7 @@
+import { DataType } from "./data-type";
+import { BinaryStream } from "@serenityjs/binarystream";
+export declare class Magic extends DataType {
+    buffer: Buffer;
+    write(stream: BinaryStream): void;
+    static read(stream: BinaryStream): Magic;
+}

package/dist/shared/proto/types/magic.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Magic = void 0;
+const data_type_1 = require("./data-type");
+const MAGIC = Buffer.from("00ffff00fefefefefdfdfdfd12345678", "hex");
+class Magic extends data_type_1.DataType {
+    buffer = MAGIC;
+    write(stream) {
+        stream.write(MAGIC);
+    }
+    static read(stream) {
+        const magic = new Magic();
+        magic.buffer = stream.read(16);
+        return magic;
+    }
+}
+exports.Magic = Magic;

package/dist/shared/proto/types/mtu.d.ts

@@ -0,0 +1,5 @@
+import type { BinaryStream } from "@serenityjs/binarystream";
+export declare class MTU {
+    static write(stream: BinaryStream, mtu: number): void;
+    static read(stream: BinaryStream): number;
+}

package/dist/shared/proto/types/mtu.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MTU = void 0;
+class MTU {
+    static write(stream, mtu) {
+        stream.write(Buffer.alloc(mtu - stream.getBuffer().length));
+    }
+    static read(stream) {
+        return stream.buffer.byteLength;
+    }
+}
+exports.MTU = MTU;

package/dist/shared/socks5.d.ts

@@ -0,0 +1,16 @@
+import { Socket as TcpSocket } from "node:net";
+import { Socket as UdpSocket } from "node:dgram";
+export type Socks5Options = {
+    host: string;
+    port: number;
+    username?: string;
+    password?: string;
+};
+export type Socks5Relay = {
+    socket: UdpSocket;
+    tcp: TcpSocket;
+    send: (data: Buffer, targetAddress: string, targetPort: number) => void;
+    close: () => void;
+    onMessage: (handler: (data: Buffer, senderAddress: string, senderPort: number) => void) => void;
+};
+export declare function createSocks5Relay(proxy: Socks5Options, family?: "udp4" | "udp6"): Promise<Socks5Relay>;

package/dist/shared/socks5.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSocks5Relay = createSocks5Relay;
+const node_net_1 = require("node:net");
+const node_dgram_1 = require("node:dgram");
+async function createSocks5Relay(proxy, family = "udp4") {
+    const tcp = await tcpConnect(proxy.host, proxy.port);
+    await authenticate(tcp, proxy.username, proxy.password);
+    const relay = await udpAssociate(tcp);
+    const udp = (0, node_dgram_1.createSocket)(family);
+    await new Promise((resolve) => {
+        udp.bind(0, () => resolve());
+    });
+    let messageHandler = null;
+    udp.on("message", (msg) => {
+        if (msg.length < 10)
+            return;
+        if (msg[0] !== 0 || msg[1] !== 0 || msg[2] !== 0)
+            return;
+        const atyp = msg[3];
+        let offset;
+        let addr;
+        if (atyp === 0x01) {
+            addr = `${msg[4]}.${msg[5]}.${msg[6]}.${msg[7]}`;
+            offset = 8;
+        }
+        else if (atyp === 0x03) {
+            const len = msg[4];
+            addr = msg.subarray(5, 5 + len).toString("ascii");
+            offset = 5 + len;
+        }
+        else if (atyp === 0x04) {
+            const parts = [];
+            for (let i = 0; i < 8; i++)
+                parts.push(msg.readUInt16BE(4 + i * 2).toString(16));
+            addr = parts.join(":");
+            offset = 20;
+        }
+        else
+            return;
+        const port = msg.readUInt16BE(offset);
+        const payload = msg.subarray(offset + 2);
+        if (messageHandler)
+            messageHandler(payload, addr, port);
+    });
+    tcp.on("close", () => udp.close());
+    return {
+        socket: udp,
+        tcp,
+        send(data, targetAddress, targetPort) {
+            const header = buildUdpHeader(targetAddress, targetPort);
+            const packet = Buffer.concat([header, data]);
+            udp.send(packet, relay.port, relay.address);
+        },
+        close() {
+            udp.close();
+            tcp.destroy();
+        },
+        onMessage(handler) {
+            messageHandler = handler;
+        },
+    };
+}
+function tcpConnect(host, port) {
+    return new Promise((resolve, reject) => {
+        const socket = (0, node_net_1.connect)(port, host, () => resolve(socket));
+        socket.once("error", reject);
+    });
+}
+function authenticate(tcp, username, password) {
+    return new Promise((resolve, reject) => {
+        const methods = username && password ? Buffer.from([0x05, 0x02, 0x00, 0x02]) : Buffer.from([0x05, 0x01, 0x00]);
+        tcp.write(methods);
+        tcp.once("data", (raw) => {
+            const response = Buffer.from(raw);
+            if (response[0] !== 0x05)
+                return reject(new Error("Invalid SOCKS5 response"));
+            const method = response[1];
+            if (method === 0x00)
+                return resolve();
+            if (method === 0x02 && username && password) {
+                const uBuf = Buffer.from(username, "utf8");
+                const pBuf = Buffer.from(password, "utf8");
+                const auth = Buffer.alloc(3 + uBuf.length + pBuf.length);
+                auth[0] = 0x01;
+                auth[1] = uBuf.length;
+                uBuf.copy(auth, 2);
+                auth[2 + uBuf.length] = pBuf.length;
+                pBuf.copy(auth, 3 + uBuf.length);
+                tcp.write(auth);
+                tcp.once("data", (authRaw) => {
+                    const authResp = Buffer.from(authRaw);
+                    if (authResp[1] === 0x00)
+                        resolve();
+                    else
+                        reject(new Error("SOCKS5 authentication failed"));
+                });
+            }
+            else {
+                reject(new Error(`SOCKS5 unsupported auth method: ${method}`));
+            }
+        });
+    });
+}
+function udpAssociate(tcp) {
+    return new Promise((resolve, reject) => {
+        const request = Buffer.from([
+            0x05, 0x03, 0x00,
+            0x01, 0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00,
+        ]);
+        tcp.write(request);
+        tcp.once("data", (raw) => {
+            const response = Buffer.from(raw);
+            if (response[0] !== 0x05 || response[1] !== 0x00) {
+                return reject(new Error(`SOCKS5 UDP ASSOCIATE failed: ${response[1]}`));
+            }
+            const atyp = response[3];
+            let address;
+            let portOffset;
+            if (atyp === 0x01) {
+                address = `${response[4]}.${response[5]}.${response[6]}.${response[7]}`;
+                portOffset = 8;
+            }
+            else if (atyp === 0x03) {
+                const len = response[4];
+                address = response.subarray(5, 5 + len).toString("ascii");
+                portOffset = 5 + len;
+            }
+            else if (atyp === 0x04) {
+                const parts = [];
+                for (let i = 0; i < 8; i++)
+                    parts.push(response.readUInt16BE(4 + i * 2).toString(16));
+                address = parts.join(":");
+                portOffset = 20;
+            }
+            else {
+                return reject(new Error(`SOCKS5 unsupported address type: ${atyp}`));
+            }
+            const port = response.readUInt16BE(portOffset);
+            if (address === "0.0.0.0" || address === "::") {
+                address = tcp.remoteAddress;
+            }
+            resolve({ address, port });
+        });
+    });
+}
+function buildUdpHeader(address, port) {
+    const isIPv4 = address.includes(".");
+    if (isIPv4) {
+        const header = Buffer.alloc(10);
+        header[3] = 0x01;
+        const parts = address.split(".");
+        for (let i = 0; i < 4; i++)
+            header[4 + i] = parseInt(parts[i], 10);
+        header.writeUInt16BE(port, 8);
+        return header;
+    }
+    const header = Buffer.alloc(22);
+    header[3] = 0x04;
+    const parts = address.split(":");
+    for (let i = 0; i < 8; i++)
+        header.writeUInt16BE(parseInt(parts[i], 16), 4 + i * 2);
+    header.writeUInt16BE(port, 20);
+    return header;
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@baltica/raknet",
+  "version": "0.0.1",
+  "description": "RakNet implementation for Baltica",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "clean": "rimraf dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@baltica/utils": "*",
+    "@serenityjs/binarystream": "^3.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.9",
+    "@types/node": "^25.3.0"
+  }
+}