baltica 0.0.1

package/dist/bridge/bridge-options.d.ts

@@ -0,0 +1,22 @@
+import type * as Protocol from "@serenityjs/protocol";
+import type { PacketNames } from "../client";
+import type { ClientCacheStatusPacket } from "../network/client-cache-status";
+import { type ServerOptions } from "../server/server-options";
+export type BridgePlayerEvents = {
+    [K in PacketNames as `clientbound-${K}`]: [
+        packet: InstanceType<(typeof Protocol)[K]>
+    ];
+} & {
+    [K in PacketNames as `serverbound-${K}`]: [
+        packet: InstanceType<(typeof Protocol)[K]>
+    ];
+} & {
+    "serverbound-ClientCacheStatusPacket": [packet: ClientCacheStatusPacket];
+};
+export type BridgeOptions = ServerOptions & {
+    destination: {
+        host: string;
+        port: number;
+    };
+};
+export declare const defaultBridgeOptions: BridgeOptions;

package/dist/bridge/bridge-options.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultBridgeOptions = void 0;
+const server_options_1 = require("../server/server-options");
+exports.defaultBridgeOptions = {
+    ...server_options_1.defaultServerOptions,
+    destination: {
+        host: "127.0.0.1",
+        port: 19132,
+    },
+};

package/dist/bridge/bridge-player.d.ts

@@ -0,0 +1,14 @@
+import type { Client } from "../client";
+import { Emitter } from "../libs";
+import type { Player } from "../server";
+import type { Bridge } from "./bridge";
+import type { BridgePlayerEvents } from "./bridge-options";
+export declare class BridgePlayer extends Emitter<BridgePlayerEvents> {
+    player: Player;
+    bridge: Bridge;
+    client: Client;
+    cacheStatus: boolean;
+    constructor(bridge: Bridge, player: Player);
+    prepare(): void;
+    getClient(): Client;
+}

package/dist/bridge/bridge-player.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BridgePlayer = void 0;
+const protocol_1 = require("@serenityjs/protocol");
+const libs_1 = require("../libs");
+class BridgePlayer extends libs_1.Emitter {
+    constructor(bridge, player) {
+        super();
+        this.bridge = bridge;
+        this.player = player;
+    }
+    prepare() {
+        this.player.connection.on("disconnect", () => {
+            const disconnect = new protocol_1.DisconnectPacket();
+            disconnect.hideDisconnectScreen = false;
+            disconnect.message = new protocol_1.DisconnectMessage("");
+            disconnect.reason =
+                protocol_1.DisconnectReason.UnspecifiedClientInstanceDisconnection;
+            this.client.send(disconnect);
+        });
+    }
+    getClient() {
+        return this.client;
+    }
+}
+exports.BridgePlayer = BridgePlayer;

package/dist/bridge/bridge.d.ts

@@ -0,0 +1,25 @@
+import type { ForceArray } from "../libs";
+import { type Player, Server, type ServerEvents } from "../server";
+import { type BridgeOptions } from "./bridge-options";
+import { BridgePlayer } from "./bridge-player";
+type BridgeSpecificEvents = {
+    connect: [BridgePlayer];
+};
+type BridgeEvents = ServerEvents & BridgeSpecificEvents;
+export declare class Bridge extends Server {
+    options: BridgeOptions;
+    private clients;
+    private packetClassCache;
+    private readonly debugLog;
+    constructor(options?: Partial<BridgeOptions>);
+    private initializePacketCache;
+    private getPacketClass;
+    private processPacketCommon;
+    prepare(): void;
+    onConnect(player: Player): void;
+    onLogin(player: BridgePlayer): void;
+    emit: <K extends keyof BridgeEvents>(name: K, ...args: ForceArray<BridgeEvents[K]>) => void;
+    on: <K extends keyof BridgeEvents>(name: K, callback: (...args: ForceArray<BridgeEvents[K]>) => void) => void;
+    once: <K extends keyof BridgeEvents>(name: K, callback: (...args: ForceArray<BridgeEvents[K]>) => void) => void;
+}
+export {};

package/dist/bridge/bridge.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bridge = void 0;
+const raknet_1 = require("@sanctumterra/raknet");
+const protocol_1 = require("@serenityjs/protocol");
+const client_1 = require("../client");
+const client_cache_status_1 = require("../network/client-cache-status");
+const level_chunk_packet_1 = require("../network/level-chunk-packet");
+const server_1 = require("../server");
+const bridge_options_1 = require("./bridge-options");
+const bridge_player_1 = require("./bridge-player");
+class Bridge extends server_1.Server {
+    constructor(options = {}) {
+        super(options);
+        this.clients = new Map();
+        this.packetClassCache = new Map();
+        this.debugLog = false;
+        this.options = { ...bridge_options_1.defaultBridgeOptions, ...options };
+        this.prepare();
+        this.initializePacketCache();
+    }
+    initializePacketCache() {
+        const CLIENT_CACHE_STATUS_ID = 129;
+        this.packetClassCache.set(CLIENT_CACHE_STATUS_ID, client_cache_status_1.ClientCacheStatusPacket);
+        if ("id" in level_chunk_packet_1.LevelChunkPacket) {
+            const levelChunkId = level_chunk_packet_1.LevelChunkPacket.id;
+            this.packetClassCache.set(levelChunkId, level_chunk_packet_1.LevelChunkPacket);
+        }
+    }
+    getPacketClass(id, PacketClass) {
+        const CLIENT_CACHE_STATUS_ID = 129;
+        let CachedPacketClass = this.packetClassCache.get(id);
+        if (!CachedPacketClass) {
+            if (id === CLIENT_CACHE_STATUS_ID) {
+                CachedPacketClass =
+                    client_cache_status_1.ClientCacheStatusPacket;
+            }
+            else if (PacketClass && typeof PacketClass === "function") {
+                CachedPacketClass = PacketClass;
+            }
+            if (CachedPacketClass) {
+                this.packetClassCache.set(id, CachedPacketClass);
+            }
+        }
+        return CachedPacketClass;
+    }
+    processPacketCommon(buffer, player, isClientbound, sender) {
+        const CLIENT_CACHE_STATUS_ID = 129;
+        const id = (0, protocol_1.getPacketId)(buffer);
+        const PacketClass = protocol_1.Packets[id];
+        // @ts-ignore
+        if (!PacketClass && id !== CLIENT_CACHE_STATUS_ID) {
+            sender.send(buffer);
+            return;
+        }
+        const packetName = PacketClass?.name ?? "ClientCacheStatusPacket";
+        const eventName = `${isClientbound ? "clientbound" : "serverbound"}-${packetName}`;
+        if (!player.hasListeners(eventName) &&
+            packetName !== "ClientCacheStatusPacket") {
+            sender.send(buffer);
+            return;
+        }
+        try {
+            const CachedPacketClass = this.getPacketClass(id, PacketClass);
+            if (!CachedPacketClass) {
+                sender.send(buffer);
+                return;
+            }
+            if (this.debugLog) {
+                raknet_1.Logger.info(`${isClientbound ? "Client -> BridgePlayer" : "BridgePlayer -> Client"} : ${packetName}`);
+            }
+            const packet = new CachedPacketClass(buffer).deserialize();
+            if (packet instanceof client_cache_status_1.ClientCacheStatusPacket) {
+                packet.supported = false;
+                raknet_1.Logger.warn("Ignoring ClientCacheStatusPacket");
+                return;
+            }
+            player.emit(eventName, packet);
+            if ("binary" in packet) {
+                packet.binary = [];
+            }
+            const newBuffer = packet.serialize();
+            sender.send(buffer.equals(newBuffer) ? buffer : newBuffer);
+        }
+        catch (e) {
+            console.error(`Failed to process ${packetName}`, e);
+            sender.send(buffer);
+        }
+    }
+    prepare() {
+        this.on("playerConnect", this.onConnect.bind(this));
+        this.raknet.options.maxPacketsPerSecond = 20000;
+    }
+    onConnect(player) {
+        if (!(player.connection instanceof raknet_1.Connection))
+            return;
+        const bridgePlayer = new bridge_player_1.BridgePlayer(this, player);
+        this.clients.set(`${player.connection.getAddress().address}:${player.connection.getAddress().port}`, bridgePlayer);
+        this.emit("connect", bridgePlayer);
+        bridgePlayer.player.once("ClientCacheStatusPacket", (packet) => {
+            bridgePlayer.cacheStatus = packet.supported;
+        });
+        bridgePlayer.player.on("ClientToServerHandshakePacket", (packet) => {
+            console.log("ClientToServerHandshakePacket");
+            this.onLogin(bridgePlayer);
+            return;
+        });
+    }
+    onLogin(player) {
+        const client = new client_1.Client({
+            host: this.options.destination.host,
+            port: this.options.destination.port,
+            version: "1.21.50",
+            offline: false,
+            tokensFolder: "tokens",
+            viewDistance: 2,
+            worker: true,
+        });
+        player.client = client;
+        client.cancelPastLogin = true;
+        client.removeAllListeners("ResourcePackStackPacket");
+        client.removeAllListeners("ResourcePacksInfoPacket");
+        client.removeAllListeners("PlayStatusPacket");
+        client.once("ResourcePacksInfoPacket", (packet) => {
+            client.send(client_cache_status_1.ClientCacheStatusPacket.create(false));
+        });
+        player.once("serverbound-ResourcePackClientResponsePacket", (packet) => {
+            player.player.send(client_cache_status_1.ClientCacheStatusPacket.create(false));
+        });
+        client.once("PlayStatusPacket", (packet) => {
+            if (packet.status !== protocol_1.PlayStatus.LoginSuccess)
+                throw new Error("Login failed");
+            client.processPacket = (buffer) => {
+                this.processPacketCommon(buffer, player, true, player.player);
+            };
+            player.player.processPacket = (buffer) => {
+                this.processPacketCommon(buffer, player, false, client);
+            };
+        });
+        client.connect();
+    }
+}
+exports.Bridge = Bridge;

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

@@ -0,0 +1,28 @@
+import { KeyObject } from "node:crypto";
+import { LoginPacket } from "@serenityjs/protocol";
+import type { Player } from "src/server/player";
+import type { Client } from "./client";
+import { type LoginData } from "./types/login-data";
+import { type Payload } from "./types/payload";
+declare class ClientData {
+    client: Client | Player;
+    /** This Contains a lot of Data for the Login Packet */
+    payload: Payload;
+    /** This Contains the Access Tokens from Auth */
+    accessToken: string[];
+    /** This Contains the Login Data */
+    loginData: LoginData;
+    /** This Contains the Shared Secret */
+    sharedSecret: Buffer;
+    constructor(client: Client | Player);
+    createLoginPacket(): LoginPacket;
+    createClientChain(mojangKey: string | null, offline: boolean): Promise<string>;
+    private createClientChainInternal;
+    createClientUserChain(privateKey: KeyObject): Promise<string>;
+    createSharedSecret(privateKey: KeyObject, publicKey: KeyObject): Buffer;
+    private validateKeys;
+    static nextUUID(): string;
+    static generateId(): number;
+    static OnlineId(): string;
+}
+export { ClientData };

package/dist/client/client-data.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientData = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const raknet_1 = require("@sanctumterra/raknet");
+const protocol_1 = require("@serenityjs/protocol");
+const jsonwebtoken_1 = require("jsonwebtoken");
+const uuid_1345_1 = require("uuid-1345");
+const login_data_1 = require("./types/login-data");
+const payload_1 = require("./types/payload");
+const PUBLIC_KEY = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAECRXueJeTDqNRRgJi/vlRufByu/2G0i2Ebt6YMar5QX/R0DIIyrJMcUpruK4QveTfJSTp3Shlq4Gk34cD/4GUWwkv0DVuzeuB+tXija7HBxii03NHDbPAD0AKnLr2wdAp";
+const algorithm = "ES384";
+const curve = "secp384r1";
+const pem = { format: "pem", type: "sec1" };
+const der = { format: "der", type: "spki" };
+const signAsync = (0, node_util_1.promisify)(jsonwebtoken_1.sign);
+class ClientData {
+    constructor(client) {
+        this.client = client;
+        this.payload = (0, payload_1.createDefaultPayload)(client);
+        this.loginData = (0, login_data_1.prepareLoginData)();
+    }
+    createLoginPacket() {
+        const loginPacket = new protocol_1.LoginPacket();
+        const chain = [this.loginData.clientIdentityChain, ...this.accessToken];
+        const userChain = this.loginData.clientUserChain;
+        const encodedChain = JSON.stringify({ chain });
+        loginPacket.protocol = this.client.protocol;
+        loginPacket.tokens = new protocol_1.LoginTokens(userChain, encodedChain);
+        return loginPacket;
+    }
+    async createClientChain(mojangKey, offline) {
+        return this.createClientChainInternal(mojangKey, offline);
+    }
+    async createClientChainInternal(mojangKey, offline) {
+        const { clientX509, ecdhKeyPair } = this.loginData;
+        let payload;
+        let signOptions;
+        if (offline) {
+            payload = {
+                extraData: {
+                    displayName: this.client.profile.name,
+                    identity: this.client.profile.uuid,
+                    titleId: "89692877",
+                    XUID: "0",
+                },
+                certificateAuthority: true,
+                identityPublicKey: clientX509,
+            };
+            signOptions = {
+                algorithm: algorithm,
+                notBefore: 0,
+                issuer: "self",
+                expiresIn: 60 * 60,
+                header: { alg: algorithm, x5u: clientX509, typ: undefined },
+            };
+        }
+        else {
+            payload = {
+                identityPublicKey: mojangKey || PUBLIC_KEY,
+                certificateAuthority: true,
+            };
+            signOptions = {
+                algorithm: algorithm,
+                header: { alg: algorithm, x5u: clientX509, typ: undefined },
+            };
+        }
+        return signAsync(payload, ecdhKeyPair.privateKey.export({ format: "pem", type: "pkcs8" }), signOptions);
+    }
+    async createClientUserChain(privateKey) {
+        const { clientX509 } = this.loginData;
+        const customPayload = this.client.options.skinData || {};
+        const payload = {
+            ...this.payload,
+            ...customPayload,
+            ServerAddress: `${this.client.options.host}:${this.client.options.port}`,
+            ClientRandomId: Date.now(),
+            DeviceId: ClientData.nextUUID(),
+            PlayFabId: ClientData.nextUUID().replace(/-/g, "").slice(0, 16),
+            SelfSignedId: ClientData.nextUUID(),
+        };
+        return signAsync(payload, privateKey.export({ format: "pem", type: "pkcs8" }), {
+            algorithm,
+            header: { alg: algorithm, x5u: clientX509, typ: undefined },
+            noTimestamp: true,
+        });
+    }
+    createSharedSecret(privateKey, publicKey) {
+        this.validateKeys(privateKey, publicKey);
+        const curve = privateKey.asymmetricKeyDetails?.namedCurve;
+        if (!curve) {
+            throw new Error("Invalid private key format. Named curve is missing.");
+        }
+        try {
+            const ecdh = (0, node_crypto_1.createECDH)(curve);
+            const privateKeyJwk = privateKey.export({ format: "jwk" });
+            const publicKeyJwk = publicKey.export({ format: "jwk" });
+            if (!privateKeyJwk.d || !publicKeyJwk.x || !publicKeyJwk.y) {
+                throw new Error("Invalid key format. Missing 'd', 'x', or 'y' parameters.");
+            }
+            ecdh.setPrivateKey(new Uint8Array(Buffer.from(privateKeyJwk.d, "base64")));
+            const publicKeyBuffer = Buffer.concat([
+                new Uint8Array([0x04]),
+                new Uint8Array(Buffer.from(publicKeyJwk.x, "base64")),
+                new Uint8Array(Buffer.from(publicKeyJwk.y, "base64")),
+            ]);
+            const computedSecret = ecdh.computeSecret(new Uint8Array(publicKeyBuffer));
+            return Buffer.from(new Uint8Array(computedSecret));
+        }
+        catch (error) {
+            raknet_1.Logger.error("Error computing shared secret:", error);
+            throw new Error("Failed to create shared secret.");
+        }
+    }
+    validateKeys(privateKey, publicKey) {
+        if (!(privateKey instanceof node_crypto_1.KeyObject) ||
+            !(publicKey instanceof node_crypto_1.KeyObject)) {
+            throw new Error("Both privateKey and publicKey must be crypto.KeyObject instances");
+        }
+        if (privateKey.type !== "private" || publicKey.type !== "public") {
+            throw new Error("Invalid key types. Expected private and public keys.");
+        }
+    }
+    static nextUUID() {
+        return (0, uuid_1345_1.v3)({
+            namespace: "6ba7b811-9dad-11d1-80b4-00c04fd430c8",
+            name: Date.now().toString(),
+        });
+    }
+    static generateId() {
+        const randomNum = Math.floor(Math.random() * 9000000000000000000) + 1000000000000000000;
+        return -randomNum;
+    }
+    static OnlineId() {
+        const randomNum = Math.floor(Math.random() * 9000000000000000000) + 1000000000000000000;
+        return `${randomNum}`;
+    }
+}
+exports.ClientData = ClientData;

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

@@ -0,0 +1,58 @@
+import { CompressionMethod, InputMode } from "@serenityjs/protocol";
+import type * as Protocol from "@serenityjs/protocol";
+import type { ClientCacheStatusPacket } from "../network/client-cache-status";
+export declare enum ProtocolList {
+    "1.21.50" = 766
+}
+export declare enum DeviceOS {
+    Undefined = 0,
+    Android = 1,
+    IOS = 2,
+    OSX = 3,
+    FireOS = 4,
+    GearVR = 5,
+    Hololens = 6,
+    Win10 = 7,
+    Win32 = 8,
+    Dedicated = 9,
+    TVOS = 10,
+    Orbis = 11,
+    NintendoSwitch = 12,
+    Xbox = 13,
+    WindowsPhone = 14,
+    Linux = 15
+}
+type LoginPacketOptions = {
+    DeviceModel: string;
+    CurrentInputMode: InputMode;
+    DefaultInputMode: InputMode;
+};
+type ClientOptions = {
+    host: string;
+    port: number;
+    compressionThreshold: number;
+    compressionMethod: CompressionMethod;
+    compressionLevel: number;
+    deviceOS: DeviceOS;
+    version: keyof typeof ProtocolList;
+    username: string;
+    tokensFolder: string;
+    viewDistance: number;
+    skinData: object | undefined;
+    offline: boolean;
+    worker: boolean;
+    loginOptions: LoginPacketOptions;
+};
+declare const defaultClientOptions: ClientOptions;
+type PacketNames = {
+    [K in keyof typeof Protocol]: K extends `${string}Packet` ? K extends "Packet" | "DataPacket" ? never : K : never;
+}[keyof typeof Protocol];
+type ClientEvents = {
+    [K in PacketNames]: [packet: InstanceType<(typeof Protocol)[K]>];
+} & {
+    session: [];
+    ClientCacheStatus: [packet: ClientCacheStatusPacket];
+} & {
+    packet: [packet: InstanceType<(typeof Protocol)[PacketNames]>];
+};
+export { type ClientOptions, defaultClientOptions, type ClientEvents, type PacketNames, };

package/dist/client/client-options.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultClientOptions = exports.DeviceOS = exports.ProtocolList = void 0;
+const protocol_1 = require("@serenityjs/protocol");
+var ProtocolList;
+(function (ProtocolList) {
+    ProtocolList[ProtocolList["1.21.50"] = 766] = "1.21.50";
+})(ProtocolList || (exports.ProtocolList = ProtocolList = {}));
+var DeviceOS;
+(function (DeviceOS) {
+    DeviceOS[DeviceOS["Undefined"] = 0] = "Undefined";
+    DeviceOS[DeviceOS["Android"] = 1] = "Android";
+    DeviceOS[DeviceOS["IOS"] = 2] = "IOS";
+    DeviceOS[DeviceOS["OSX"] = 3] = "OSX";
+    DeviceOS[DeviceOS["FireOS"] = 4] = "FireOS";
+    DeviceOS[DeviceOS["GearVR"] = 5] = "GearVR";
+    DeviceOS[DeviceOS["Hololens"] = 6] = "Hololens";
+    DeviceOS[DeviceOS["Win10"] = 7] = "Win10";
+    DeviceOS[DeviceOS["Win32"] = 8] = "Win32";
+    DeviceOS[DeviceOS["Dedicated"] = 9] = "Dedicated";
+    DeviceOS[DeviceOS["TVOS"] = 10] = "TVOS";
+    DeviceOS[DeviceOS["Orbis"] = 11] = "Orbis";
+    DeviceOS[DeviceOS["NintendoSwitch"] = 12] = "NintendoSwitch";
+    DeviceOS[DeviceOS["Xbox"] = 13] = "Xbox";
+    DeviceOS[DeviceOS["WindowsPhone"] = 14] = "WindowsPhone";
+    DeviceOS[DeviceOS["Linux"] = 15] = "Linux";
+})(DeviceOS || (exports.DeviceOS = DeviceOS = {}));
+const defaultClientOptions = {
+    host: "127.0.0.1",
+    port: 19132,
+    compressionThreshold: 1,
+    compressionMethod: protocol_1.CompressionMethod.Zlib,
+    compressionLevel: 7,
+    deviceOS: DeviceOS.NintendoSwitch,
+    version: "1.21.50",
+    username: "SanctumTerra",
+    tokensFolder: "tokens",
+    viewDistance: 10,
+    skinData: undefined,
+    offline: false,
+    worker: false,
+    loginOptions: {
+        DeviceModel: "SwimmingPool",
+        CurrentInputMode: protocol_1.InputMode.GamePad,
+        DefaultInputMode: protocol_1.InputMode.GamePad,
+    },
+};
+exports.defaultClientOptions = defaultClientOptions;

package/dist/client/client.d.ts

@@ -0,0 +1,44 @@
+import { Client as RaknetClient } from "@sanctumterra/raknet";
+import { DataPacket } from "@serenityjs/protocol";
+import { Emitter } from "../libs/emitter";
+import { type Profile } from "../network";
+import { PacketEncryptor } from "../network/packet-encryptor";
+import { ClientData } from "./client-data";
+import { type ClientEvents, type ClientOptions, ProtocolList } from "./client-options";
+import { WorkerClient } from "./worker";
+declare class Client extends Emitter<ClientEvents> {
+    raknet: RaknetClient | WorkerClient;
+    options: ClientOptions;
+    private startGamePacket?;
+    private status;
+    _encryptionEnabled: boolean;
+    _compressionEnabled: boolean;
+    private packetCompressor;
+    protocol: ProtocolList;
+    profile: Profile;
+    data: ClientData;
+    username: string;
+    sessionReady: boolean;
+    secretKeyBytes: Buffer;
+    iv: Buffer;
+    packetEncryptor: PacketEncryptor;
+    runtimeEntityId: bigint;
+    cancelPastLogin: boolean;
+    constructor(options: Partial<ClientOptions>);
+    connect(): Promise<unknown>;
+    private handleStartGamePacket;
+    private handleSetLocalPlayerAsInitializedPacket;
+    private handleEncapsulated;
+    private sendPacket;
+    send(packet: DataPacket | Buffer): void;
+    queue(packet: DataPacket | Buffer): void;
+    /** Already decompressed packets */
+    processPacket(buffer: Buffer): void;
+    private handleSession;
+    listen(): void;
+    private handlePlayStatusPacket;
+    private handleResourcePacksInfoPacket;
+    startEncryption(iv: Buffer): void;
+    sendMessage(text: string): void;
+}
+export { Client };