@baltica/raknet 0.0.1

package/dist/client/client.d.ts

@@ -0,0 +1,20 @@
+import { Emitter } from "@baltica/utils";
+import { Priority } from "../shared";
+import { ClientEvents, ClientOptions } from "./types";
+export declare class Client extends Emitter<ClientEvents> {
+    private socket;
+    private network;
+    private tickInterval?;
+    private relay?;
+    options: ClientOptions;
+    constructor(options?: Partial<ClientOptions>);
+    private bindPromise;
+    private ensureBound;
+    private init;
+    private initProxy;
+    private initDirect;
+    ping(address?: string, port?: number): Promise<string>;
+    connect(): Promise<void>;
+    sendReliable(data: Buffer, priority?: Priority): void;
+    close(): void;
+}

package/dist/client/client.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const node_dgram_1 = require("node:dgram");
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:dns/promises");
+const utils_1 = require("@baltica/utils");
+const shared_1 = require("../shared");
+const types_1 = require("./types");
+class Client extends utils_1.Emitter {
+    socket;
+    network;
+    tickInterval;
+    relay;
+    options;
+    constructor(options = {}) {
+        super();
+        this.options = { ...types_1.defaultClientOptions, guid: (0, node_crypto_1.randomBytes)(8).readBigUInt64BE(), ...options };
+        this.network = new shared_1.NetworkSession(this.options.mtu, true);
+        this.network.guid = this.options.guid;
+        this.network.maxRetransmit = this.options.maxRetransmit;
+        this.network.on("connect", () => this.emit("connect"));
+        this.network.on("disconnect", () => this.emit("disconnect"));
+        this.network.on("encapsulated", (buf) => this.emit("encapsulated", buf));
+        this.network.on("error", (err) => this.emit("error", err));
+    }
+    bindPromise = null;
+    ensureBound() {
+        if (this.bindPromise)
+            return this.bindPromise;
+        this.bindPromise = this.init();
+        return this.bindPromise;
+    }
+    async init() {
+        const family = this.options.family === "udp4" ? 4 : 6;
+        const resolved = await (0, promises_1.lookup)(this.options.address, family);
+        this.network.address = new shared_1.Address(resolved.address, this.options.port, family);
+        if (this.options.proxy)
+            return this.initProxy();
+        return this.initDirect();
+    }
+    async initProxy() {
+        this.relay = await (0, shared_1.createSocks5Relay)(this.options.proxy, this.options.family);
+        this.socket = this.relay.socket;
+        const targetAddress = this.network.address.address;
+        const targetPort = this.network.address.port;
+        this.network.send = (data) => this.relay.send(data, targetAddress, targetPort);
+        this.relay.onMessage((data) => this.network.receive(data));
+        this.tickInterval = setInterval(() => this.network.tick(), 50);
+    }
+    initDirect() {
+        this.socket = (0, node_dgram_1.createSocket)(this.options.family);
+        this.network.send = (data) => this.socket.send(data, this.options.port, this.options.address);
+        return new Promise((resolve) => {
+            try {
+                this.socket.address();
+                this.socket.on("message", (buf) => this.network.receive(buf));
+                this.tickInterval = setInterval(() => this.network.tick(), 50);
+                resolve();
+            }
+            catch {
+                this.socket.bind();
+                this.socket.on("listening", () => {
+                    this.socket.on("message", (buf) => this.network.receive(buf));
+                    this.tickInterval = setInterval(() => this.network.tick(), 50);
+                    resolve();
+                });
+            }
+        });
+    }
+    async ping(address, port) {
+        await this.ensureBound();
+        const targetAddress = address ?? this.network.address.address;
+        const targetPort = port ?? this.network.address.port;
+        return new Promise((resolve) => {
+            this.network.once("pong", resolve);
+            const ping = new shared_1.UnconnectedPing();
+            ping.guid = this.options.guid;
+            ping.timestamp = BigInt(Date.now());
+            const data = ping.serialize();
+            if (this.relay)
+                this.relay.send(data, targetAddress, targetPort);
+            else
+                this.socket.send(data, targetPort, targetAddress);
+        });
+    }
+    async connect() {
+        await this.ensureBound();
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                this.network.off("connect", onConnect);
+                this.network.off("error", onError);
+                clearTimeout(timer);
+            };
+            const onConnect = () => { cleanup(); resolve(); };
+            const onError = (err) => { cleanup(); reject(err); };
+            const timer = setTimeout(() => {
+                cleanup();
+                this.network.status = shared_1.Status.Disconnected;
+                reject(new Error("Connection timed out"));
+            }, this.options.timeout);
+            this.network.once("connect", onConnect);
+            this.network.once("error", onError);
+            const req = new shared_1.OpenConnectionRequestOne();
+            req.protocol = 11;
+            req.mtu = this.options.mtu;
+            this.network.sendOfflineWithRetry(req.serialize());
+        });
+    }
+    sendReliable(data, priority = shared_1.Priority.Medium) {
+        this.network.frameAndSend(data, priority);
+    }
+    close() {
+        if (this.tickInterval)
+            clearInterval(this.tickInterval);
+        if (this.relay)
+            this.relay.close();
+        else
+            this.socket.close();
+    }
+}
+exports.Client = Client;

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./client";

package/dist/client/index.js

@@ -0,0 +1,18 @@
+"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("./types"), exports);
+__exportStar(require("./client"), exports);

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

@@ -0,0 +1,6 @@
+export type ClientEvents = {
+    connect: [];
+    disconnect: [];
+    encapsulated: [buffer: Buffer];
+    error: [error: Error];
+};

package/dist/client/types/client-events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client/types/client-options.d.ts

@@ -0,0 +1,12 @@
+import type { Socks5Options } from "../../shared";
+export type ClientOptions = {
+    mtu: number;
+    timeout: number;
+    maxRetransmit: number;
+    address: string;
+    port: number;
+    family: "udp4" | "udp6";
+    guid: bigint;
+    proxy?: Socks5Options;
+};
+export declare const defaultClientOptions: Omit<ClientOptions, "guid">;

package/dist/client/types/client-options.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultClientOptions = void 0;
+exports.defaultClientOptions = {
+    address: "127.0.0.1",
+    family: "udp4", // IPV4/udp4 is used by default in most of the things
+    maxRetransmit: 3,
+    mtu: 1028, // The most stable from what i can see
+    port: 19132,
+    timeout: 5000,
+};

package/dist/client/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client-events";
+export * from "./client-options";

package/dist/client/types/index.js

@@ -0,0 +1,18 @@
+"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("./client-events"), exports);
+__exportStar(require("./client-options"), exports);

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./shared";
+export * from "./client";
+export * from "./server";

package/dist/index.js

@@ -0,0 +1,19 @@
+"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("./shared"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./server"), exports);

package/dist/server/connection.d.ts

@@ -0,0 +1,16 @@
+import { Emitter } from "@baltica/utils";
+import { NetworkSession, Address, Priority } from "../shared";
+export type ConnectionEvents = {
+    connect: [];
+    disconnect: [];
+    encapsulated: [payload: Buffer];
+};
+export declare class Connection extends Emitter<ConnectionEvents> {
+    readonly network: NetworkSession;
+    readonly address: Address;
+    readonly guid: bigint;
+    constructor(network: NetworkSession);
+    send(data: Buffer, priority?: Priority): void;
+    disconnect(): void;
+    get identifier(): string;
+}

package/dist/server/connection.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = void 0;
+const utils_1 = require("@baltica/utils");
+const shared_1 = require("../shared");
+class Connection extends utils_1.Emitter {
+    network;
+    address;
+    guid;
+    constructor(network) {
+        super();
+        this.network = network;
+        this.address = network.address;
+        this.guid = network.remoteGuid;
+        network.on("connect", () => this.emit("connect"));
+        network.on("disconnect", () => this.emit("disconnect"));
+        network.on("encapsulated", (payload) => this.emit("encapsulated", payload));
+    }
+    send(data, priority = shared_1.Priority.Medium) {
+        this.network.frameAndSend(data, priority);
+    }
+    disconnect() {
+        this.network.status = 3;
+        this.network.emit("disconnect");
+    }
+    get identifier() {
+        return `${this.address.address}:${this.address.port}`;
+    }
+}
+exports.Connection = Connection;

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./connection";
+export * from "./server";

package/dist/server/index.js

@@ -0,0 +1,19 @@
+"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("./types"), exports);
+__exportStar(require("./connection"), exports);
+__exportStar(require("./server"), exports);

package/dist/server/server.d.ts

@@ -0,0 +1,19 @@
+import { RemoteInfo } from "node:dgram";
+import { Emitter } from "@baltica/utils";
+import { ServerEvents, ServerOptions } from "./types";
+import { Connection } from "./connection";
+export declare class Server extends Emitter<ServerEvents> {
+    private socket;
+    private tickInterval?;
+    private connections;
+    options: ServerOptions;
+    constructor(options?: Partial<ServerOptions>);
+    private static key;
+    start(): Promise<void>;
+    stop(): void;
+    getConnection(rinfo: RemoteInfo): Connection | undefined;
+    getConnections(): Map<string, Connection>;
+    private tick;
+    private sendTo;
+    private handleMessage;
+}

package/dist/server/server.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const node_dgram_1 = require("node:dgram");
+const node_crypto_1 = require("node:crypto");
+const utils_1 = require("@baltica/utils");
+const shared_1 = require("../shared");
+const types_1 = require("./types");
+const connection_1 = require("./connection");
+const RAKNET_PROTOCOL = 11;
+class Server extends utils_1.Emitter {
+    socket;
+    tickInterval;
+    connections = new Map();
+    options;
+    constructor(options = {}) {
+        super();
+        this.options = { ...types_1.defaultServerOptions, guid: (0, node_crypto_1.randomBytes)(8).readBigUInt64BE(), ...options };
+        this.socket = (0, node_dgram_1.createSocket)(this.options.family);
+    }
+    static key(rinfo) {
+        return `${rinfo.address}:${rinfo.port}`;
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.socket.bind(this.options.port, this.options.address);
+            this.socket.on("listening", () => {
+                this.socket.on("message", (buffer, rinfo) => this.handleMessage(buffer, rinfo));
+                this.tickInterval = setInterval(() => this.tick(), 50);
+                resolve();
+            });
+        });
+    }
+    stop() {
+        if (this.tickInterval)
+            clearInterval(this.tickInterval);
+        for (const conn of this.connections.values())
+            conn.disconnect();
+        this.connections.clear();
+        this.socket.close();
+    }
+    getConnection(rinfo) {
+        return this.connections.get(Server.key(rinfo));
+    }
+    getConnections() {
+        return this.connections;
+    }
+    tick() {
+        for (const conn of this.connections.values())
+            conn.network.tick();
+    }
+    sendTo(data, rinfo) {
+        this.socket.send(data, rinfo.port, rinfo.address);
+    }
+    handleMessage(buffer, rinfo) {
+        const key = Server.key(rinfo);
+        const conn = this.connections.get(key);
+        if (conn) {
+            conn.network.receive(buffer);
+            return;
+        }
+        const id = buffer[0];
+        const payload = buffer.subarray(1);
+        switch (id) {
+            case shared_1.Packet.UnconnectedPing:
+            case shared_1.Packet.UnconnectedPingOpenConnections: {
+                const ping = new shared_1.UnconnectedPing(payload).deserialize();
+                const pong = new shared_1.UnconnectedPong();
+                pong.timestamp = ping.timestamp;
+                pong.guid = this.options.guid;
+                pong.message = this.options.message;
+                this.sendTo(pong.serialize(), rinfo);
+                break;
+            }
+            case shared_1.Packet.OpenConnectionRequest1: {
+                const req = new shared_1.OpenConnectionRequestOne(payload).deserialize();
+                if (req.protocol !== RAKNET_PROTOCOL)
+                    break;
+                const reply = new shared_1.OpenConnectionReplyOne();
+                reply.guid = this.options.guid;
+                reply.security = false;
+                reply.cookie = null;
+                reply.hasCookie = false;
+                reply.serverPublicKey = null;
+                reply.mtu = Math.min(this.options.mtu, req.mtu);
+                this.sendTo(reply.serialize(), rinfo);
+                break;
+            }
+            case shared_1.Packet.OpenConnectionRequest2: {
+                if (this.connections.size >= this.options.maxConnections)
+                    break;
+                const req = new shared_1.OpenConnectionRequestTwo(payload).deserialize();
+                const mtu = Math.min(this.options.mtu, req.mtu);
+                const session = new shared_1.NetworkSession(mtu, false);
+                session.guid = this.options.guid;
+                session.remoteGuid = req.guid;
+                session.address = shared_1.Address.fromIdentifier(rinfo);
+                session.serverMessage = this.options.message;
+                session.send = (data) => this.sendTo(data, rinfo);
+                const reply = new shared_1.OpenConnectionReplyTwo();
+                reply.guid = this.options.guid;
+                reply.address = shared_1.Address.fromIdentifier(rinfo);
+                reply.mtu = mtu;
+                reply.encryptionEnabled = false;
+                session.send(reply.serialize());
+                const connection = new connection_1.Connection(session);
+                connection.on("connect", () => this.emit("connect", connection));
+                connection.on("disconnect", () => {
+                    this.connections.delete(key);
+                    this.emit("disconnect", connection);
+                });
+                connection.on("encapsulated", (payload) => this.emit("encapsulated", payload, connection));
+                this.connections.set(key, connection);
+                break;
+            }
+        }
+    }
+}
+exports.Server = Server;

package/dist/server/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./server-events";
+export * from "./server-options";

package/dist/server/types/index.js

@@ -0,0 +1,18 @@
+"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("./server-events"), exports);
+__exportStar(require("./server-options"), exports);

package/dist/server/types/server-events.d.ts

@@ -0,0 +1,6 @@
+import type { Connection } from "../connection";
+export type ServerEvents = {
+    connect: [connection: Connection];
+    disconnect: [connection: Connection];
+    encapsulated: [payload: Buffer, connection: Connection];
+};

package/dist/server/types/server-events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/types/server-options.d.ts

@@ -0,0 +1,10 @@
+export type ServerOptions = {
+    address: string;
+    port: number;
+    family: "udp4" | "udp6";
+    mtu: number;
+    maxConnections: number;
+    message: string;
+    guid: bigint;
+};
+export declare const defaultServerOptions: Omit<ServerOptions, "guid">;

package/dist/server/types/server-options.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultServerOptions = void 0;
+exports.defaultServerOptions = {
+    address: "0.0.0.0",
+    port: 19132,
+    family: "udp4",
+    mtu: 1028,
+    maxConnections: 20,
+    message: "MCPE;Baltica;0;0.0.0;0;0;0;Baltica;Survival;1;19132;19133;0;",
+};

package/dist/shared/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./network-session";
+export * from "./socks5";
+export * from "./proto";

package/dist/shared/index.js

@@ -0,0 +1,19 @@
+"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("./network-session"), exports);
+__exportStar(require("./socks5"), exports);
+__exportStar(require("./proto"), exports);

package/dist/shared/network-session.d.ts

@@ -0,0 +1,63 @@
+import { Frame, Priority, Status, Address } from "./proto";
+import { Emitter } from "@baltica/utils";
+export type NetworkEvents = {
+    encapsulated: [payload: Buffer];
+    pong: [message: string];
+    connect: [];
+    disconnect: [];
+    error: [error: Error];
+};
+export declare class NetworkSession extends Emitter<NetworkEvents> {
+    mtu: number;
+    client: boolean;
+    guid: bigint;
+    remoteGuid: bigint;
+    status: Status;
+    address: Address;
+    send: (data: Buffer) => void;
+    serverMessage?: string;
+    maxRetransmit: number;
+    retransmitInterval: number;
+    outputReliableIndex: number;
+    outputSplitIndex: number;
+    private outputSequence;
+    outputSequenceIndex: number[];
+    outputOrderIndex: number[];
+    outputFrames: Set<Frame>;
+    outputBackup: Map<number, Frame[]>;
+    receivedFrameSequences: Set<number>;
+    lostFrameSequences: Set<number>;
+    pendingAcks: Set<number>;
+    lastInputSequence: number;
+    fragmentsQueue: Map<number, {
+        frames: Map<number, Frame>;
+        timestamp: number;
+    }>;
+    inputHighestSequenceIndex: number[];
+    inputOrderIndex: number[];
+    private inputOrderingQueue;
+    private receivedReliableFrameIndices;
+    private highestReliableIndex;
+    private offlineRetry;
+    private outputBackupTimestamps;
+    constructor(mtu: number, client: boolean);
+    sendOfflineWithRetry(data: Buffer): void;
+    private clearOfflineRetry;
+    receive(buffer: Buffer): void;
+    private handleClientOffline;
+    private handleServerOffline;
+    private handleOnlinePacket;
+    tick(): void;
+    private onAck;
+    private onNack;
+    frameAndSend(data: Buffer, priority?: Priority): void;
+    sendFrame(frame: Frame, priority?: Priority): void;
+    private sendSplit;
+    private queueFrame;
+    private flush;
+    private onFrameSet;
+    private handleFrame;
+    private handleSplit;
+    private handleSequenced;
+    private handleOrdered;
+}