baltica 0.0.1

package/dist/client/client.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_crypto_2 = require("node:crypto");
+const raknet_1 = require("@sanctumterra/raknet");
+const protocol_1 = require("@serenityjs/protocol");
+const emitter_1 = require("../libs/emitter");
+const network_1 = require("../network");
+const client_cache_status_1 = require("../network/client-cache-status");
+const level_chunk_packet_1 = require("../network/level-chunk-packet");
+const packet_encryptor_1 = require("../network/packet-encryptor");
+const client_data_1 = require("./client-data");
+const client_options_1 = require("./client-options");
+const worker_1 = require("./worker");
+class Client extends emitter_1.Emitter {
+    constructor(options) {
+        super();
+        this.options = { ...client_options_1.defaultClientOptions, ...options };
+        this.status = raknet_1.Status.Disconnected;
+        this.protocol = client_options_1.ProtocolList[this.options.version];
+        this.raknet = this.options.worker
+            ? new worker_1.WorkerClient({
+                address: this.options.host,
+                port: this.options.port,
+            })
+            : new raknet_1.Client({
+                address: this.options.host,
+                port: this.options.port,
+            });
+        this.sessionReady = false;
+        this._encryptionEnabled = false;
+        this._compressionEnabled = false;
+        this.cancelPastLogin = false;
+        this.data = new client_data_1.ClientData(this);
+        this.once("session", this.handleSession.bind(this));
+        this.options.offline ? (0, network_1.createOfflineSession)(this) : (0, network_1.authenticate)(this);
+    }
+    async connect() {
+        this.packetCompressor = new network_1.PacketCompressor(this);
+        this.listen();
+        const advertisement = await this.raknet.connect();
+        this.raknet.on("encapsulated", this.handleEncapsulated.bind(this));
+        return new Promise((resolve, reject) => {
+            this.once("StartGamePacket", this.handleStartGamePacket.bind(this));
+            this.once("SetLocalPlayerAsInitializedPacket", this.handleSetLocalPlayerAsInitializedPacket.bind(this));
+            this.once("AvailableCommandsPacket", () => { });
+            const interval = setInterval(() => {
+                if (this.status === raknet_1.Status.Connected &&
+                    this.startGamePacket &&
+                    this.sessionReady) {
+                    clearInterval(interval);
+                    resolve([advertisement, this.startGamePacket]);
+                }
+            }, 50);
+        });
+    }
+    handleStartGamePacket(packet) {
+        this.startGamePacket = packet;
+        this.runtimeEntityId = packet.runtimeEntityId;
+        if (this.cancelPastLogin)
+            return;
+        const radius = new protocol_1.RequestChunkRadiusPacket();
+        radius.radius = this.options.viewDistance;
+        radius.maxRadius = this.options.viewDistance;
+        this.queue(radius);
+    }
+    handleSetLocalPlayerAsInitializedPacket(packet) {
+        this.status = raknet_1.Status.Connected;
+    }
+    handleEncapsulated(buffer) {
+        try {
+            const packets = this.packetCompressor.decompress(buffer);
+            for (const packet of packets) {
+                this.processPacket(packet);
+            }
+        }
+        catch (error) {
+            raknet_1.Logger.error("Failed to handle encapsulated packet", error);
+        }
+    }
+    sendPacket(packet, priority = raknet_1.Priority.Normal) {
+        try {
+            const serialized = packet instanceof protocol_1.DataPacket ? packet.serialize() : packet;
+            const compressed = this.packetCompressor.compress(serialized, this.options.compressionMethod);
+            const frame = new raknet_1.Frame();
+            frame.orderChannel = 0;
+            frame.payload = compressed;
+            this.raknet.sendFrame(frame, priority);
+        }
+        catch (error) {
+            raknet_1.Logger.error(`Failed to send packet ${packet.constructor.name}`, error);
+        }
+    }
+    send(packet) {
+        this.sendPacket(packet, raknet_1.Priority.Immediate);
+    }
+    queue(packet) {
+        raknet_1.Logger.debug(`Queueing packet ${packet.constructor.name}`);
+        this.sendPacket(packet, raknet_1.Priority.Normal);
+    }
+    /** Already decompressed packets */
+    processPacket(buffer) {
+        const id = (0, protocol_1.getPacketId)(buffer);
+        if (!protocol_1.Packets[id])
+            return raknet_1.Logger.warn(`Unknown Game packet ${id}`);
+        let PacketClass = protocol_1.Packets[id];
+        try {
+            if (id === protocol_1.Packet.LevelChunk) {
+                PacketClass = level_chunk_packet_1.LevelChunkPacket;
+            }
+            if (this.hasListeners(PacketClass.name)) {
+                const packet = new PacketClass(buffer).deserialize();
+                this.emit(PacketClass.name, packet);
+            }
+            if (this.hasListeners("packet")) {
+                const packet = new PacketClass(buffer).deserialize();
+                this.emit("packet", packet);
+            }
+        }
+        catch (error) {
+            raknet_1.Logger.error(`Failed to process packet ${PacketClass.name}`, error);
+        }
+    }
+    handleSession() {
+        this.sessionReady = true;
+    }
+    listen() {
+        this.raknet.once("connect", () => {
+            const timer = setInterval(() => {
+                if (this.sessionReady) {
+                    const request = new protocol_1.RequestNetworkSettingsPacket();
+                    request.protocol = this.protocol;
+                    this.send(request);
+                    clearInterval(timer);
+                }
+            }, 50);
+        });
+        this.once("NetworkSettingsPacket", (packet) => {
+            this._compressionEnabled = true;
+            this.options.compressionMethod = this.packetCompressor.getMethod(packet.compressionMethod);
+            this.options.compressionThreshold = packet.compressionThreshold;
+            const loginPacket = this.data.createLoginPacket();
+            this.send(loginPacket);
+        });
+        this.once("ServerToClientHandshakePacket", (packet) => {
+            const [header, payload] = packet.token
+                .split(".")
+                .map((k) => Buffer.from(k, "base64"));
+            const { x5u } = JSON.parse(header.toString());
+            const { salt } = JSON.parse(payload.toString());
+            const pubKeyDer = (0, node_crypto_2.createPublicKey)({
+                key: Buffer.from(x5u, "base64"),
+                type: "spki",
+                format: "der",
+            });
+            this.data.sharedSecret = this.data.createSharedSecret(this.data.loginData.ecdhKeyPair.privateKey, pubKeyDer);
+            const secretHash = (0, node_crypto_1.createHash)("sha256")
+                .update(new Uint8Array(Buffer.from(salt, "base64")))
+                .update(new Uint8Array(this.data.sharedSecret))
+                .digest();
+            this.secretKeyBytes = secretHash;
+            this.iv = secretHash.slice(0, 16);
+            this.startEncryption(this.iv);
+            const handshake = new protocol_1.ClientToServerHandshakePacket();
+            this.send(handshake);
+        });
+        this.once("ResourcePacksInfoPacket", this.handleResourcePacksInfoPacket.bind(this));
+        // this.once("ResourcePackStackPacket", this.handleResourcePacksInfoPacket.bind(this));
+        this.on("PlayStatusPacket", this.handlePlayStatusPacket.bind(this));
+    }
+    handlePlayStatusPacket(packet) {
+        if (packet.status === protocol_1.PlayStatus.LoginSuccess) {
+        }
+        if (packet.status === protocol_1.PlayStatus.PlayerSpawn) {
+            if (this.cancelPastLogin)
+                return;
+            const init = new protocol_1.SetLocalPlayerAsInitializedPacket();
+            init.runtimeEntityId = this.runtimeEntityId;
+            const ServerBoundLoadingScreen = new protocol_1.ServerboundLoadingScreenPacketPacket();
+            ServerBoundLoadingScreen.type =
+                protocol_1.ServerboundLoadingScreenType.EndLoadingScreen;
+            ServerBoundLoadingScreen.hasScreenId = false;
+            this.send(init);
+            this.emit("SetLocalPlayerAsInitializedPacket", init);
+        }
+    }
+    handleResourcePacksInfoPacket(packet) {
+        if (this.cancelPastLogin)
+            return;
+        const response = new protocol_1.ResourcePackClientResponsePacket();
+        response.packs = [];
+        response.response = protocol_1.ResourcePackResponse.Completed;
+        this.send(response);
+        if (packet instanceof protocol_1.ResourcePacksInfoPacket) {
+            this.send(client_cache_status_1.ClientCacheStatusPacket.create(false));
+        }
+    }
+    startEncryption(iv) {
+        this.packetEncryptor = new packet_encryptor_1.PacketEncryptor(this, iv);
+        this._encryptionEnabled = true;
+    }
+    sendMessage(text) {
+        const textPacket = new protocol_1.TextPacket();
+        textPacket.filtered = "";
+        textPacket.message = text.replace(/^\s+/, "");
+        textPacket.needsTranslation = false;
+        textPacket.parameters = [];
+        textPacket.platformChatId = "";
+        textPacket.source = this.profile.name;
+        textPacket.type = protocol_1.TextPacketType.Chat;
+        textPacket.xuid = "";
+        this.sendPacket(textPacket, raknet_1.Priority.Normal);
+    }
+}
+exports.Client = Client;

package/dist/client/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./client";
+export * from "./client-options";
+export * from "./client-data";
+export * from "./types";
+export * from "./worker";

package/dist/client/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("./client"), exports);
+__exportStar(require("./client-options"), exports);
+__exportStar(require("./client-data"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./worker"), exports);

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

@@ -0,0 +1,3 @@
+export * from "./payload";
+export * from "./skin";
+export * from "./login-data";

package/dist/client/types/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("./payload"), exports);
+__exportStar(require("./skin"), exports);
+__exportStar(require("./login-data"), exports);

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

@@ -0,0 +1,11 @@
+import { type KeyPairKeyObjectResult } from "node:crypto";
+type LoginData = {
+    ecdhKeyPair: KeyPairKeyObjectResult;
+    publicKeyDER: string | Buffer;
+    privateKeyPEM: string | Buffer;
+    clientX509: string;
+    clientIdentityChain: string;
+    clientUserChain: string;
+};
+export declare const prepareLoginData: () => LoginData;
+export type { LoginData };

package/dist/client/types/login-data.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareLoginData = void 0;
+const node_crypto_1 = require("node:crypto");
+const curve = "secp384r1";
+const pem = { format: "pem", type: "sec1" };
+const der = { format: "der", type: "spki" };
+const prepareLoginData = () => {
+    const ecdhKeyPair = (0, node_crypto_1.generateKeyPairSync)("ec", { namedCurve: curve });
+    const loginData = {
+        ecdhKeyPair: ecdhKeyPair,
+        publicKeyDER: Buffer.alloc(0),
+        privateKeyPEM: "",
+        clientX509: "",
+        clientIdentityChain: "",
+        clientUserChain: "",
+    };
+    loginData.ecdhKeyPair = (0, node_crypto_1.generateKeyPairSync)("ec", { namedCurve: curve });
+    loginData.publicKeyDER = loginData.ecdhKeyPair.publicKey.export(der);
+    loginData.privateKeyPEM = loginData.ecdhKeyPair.privateKey
+        .export(pem)
+        .toString("base64");
+    loginData.clientX509 = loginData.publicKeyDER.toString("base64");
+    return loginData;
+};
+exports.prepareLoginData = prepareLoginData;

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

@@ -0,0 +1,50 @@
+import type { Player } from "src/server/player";
+import type { Client } from "../client";
+import type { AnimatedImageData, PersonaPieces, PieceTintColors } from "./skin";
+export type Payload = {
+    AnimatedImageData: AnimatedImageData[];
+    ArmSize: string;
+    CapeData: string;
+    CapeId: string;
+    CapeImageHeight: number;
+    CapeImageWidth: number;
+    CapeOnClassicSkin: boolean;
+    ClientRandomId: number;
+    CompatibleWithClientSideChunkGen: boolean;
+    CurrentInputMode: number;
+    DefaultInputMode: number;
+    DeviceId: string;
+    DeviceModel: string;
+    DeviceOS: number;
+    GameVersion: string;
+    GuiScale: number;
+    IsEditorMode: boolean;
+    LanguageCode: string;
+    MaxViewDistance: number;
+    MemoryTier: number;
+    OverrideSkin: boolean;
+    PersonaPieces: PersonaPieces[];
+    PersonaSkin: boolean;
+    PieceTintColors: PieceTintColors[];
+    PlatformOfflineId: string;
+    PlatformOnlineId: string;
+    PlatformType: number;
+    PlayFabId: string;
+    PremiumSkin: boolean;
+    SelfSignedId: string;
+    ServerAddress: string;
+    SkinAnimationData: string;
+    SkinColor: string;
+    SkinGeometryDataEngineVersion: string;
+    SkinData: string;
+    SkinGeometryData: string;
+    SkinId: string;
+    SkinImageHeight: number;
+    SkinImageWidth: number;
+    SkinResourcePatch: string;
+    ThirdPartyName: string;
+    ThirdPartyNameOnly: boolean;
+    TrustedSkin: boolean;
+    UIProfile: number;
+};
+export declare const createDefaultPayload: (client: Client | Player) => Payload;

package/dist/client/types/payload.js

@@ -0,0 +1,91 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultPayload = void 0;
+const client_data_1 = require("../client-data");
+const client_options_1 = require("../client-options");
+const skin = __importStar(require("./skin/Skin.json"));
+const createDefaultPayload = (client) => {
+    return {
+        AnimatedImageData: skin.skinData.AnimatedImageData,
+        ArmSize: skin.skinData.ArmSize,
+        CapeData: skin.skinData.CapeData,
+        CapeId: skin.skinData.CapeId,
+        CapeImageHeight: skin.skinData.CapeImageHeight,
+        CapeImageWidth: skin.skinData.CapeImageWidth,
+        CapeOnClassicSkin: skin.skinData.CapeOnClassicSkin,
+        ClientRandomId: client_data_1.ClientData.generateId(),
+        CompatibleWithClientSideChunkGen: false,
+        CurrentInputMode: client.options.loginOptions.CurrentInputMode,
+        DefaultInputMode: client.options.loginOptions.DefaultInputMode,
+        DeviceId: client_data_1.ClientData.nextUUID(),
+        DeviceModel: client.options.loginOptions.DeviceModel,
+        DeviceOS: client.options.deviceOS ?? client_options_1.DeviceOS.NintendoSwitch,
+        GameVersion: client.options?.version,
+        GuiScale: 0,
+        IsEditorMode: false,
+        LanguageCode: "en_US",
+        MaxViewDistance: client.options?.viewDistance,
+        MemoryTier: 2,
+        OverrideSkin: false,
+        PersonaPieces: skin.skinData.PersonaPieces,
+        PersonaSkin: skin.skinData.PersonaSkin,
+        PieceTintColors: skin.skinData.PieceTintColors,
+        PlatformOfflineId: client_data_1.ClientData.nextUUID().replace(/-/g, ""),
+        PlatformOnlineId: client_data_1.ClientData.OnlineId(),
+        PlatformType: 2,
+        PlayFabId: client_data_1.ClientData.nextUUID().replace(/-/g, "").slice(0, 16),
+        PremiumSkin: skin.skinData.PremiumSkin,
+        SelfSignedId: client_data_1.ClientData.nextUUID(),
+        ServerAddress: `${client.options.host}:${client.options.port}`,
+        SkinAnimationData: skin.skinData.SkinAnimationData,
+        SkinColor: skin.skinData.SkinColor,
+        SkinGeometryDataEngineVersion: skin.skinData.SkinGeometryDataEngineVersion,
+        SkinData: skin.skinData.SkinData,
+        SkinGeometryData: skin.skinData.SkinGeometryData,
+        SkinId: skin.skinData.SkinId,
+        SkinImageHeight: skin.skinData.SkinImageHeight,
+        SkinImageWidth: skin.skinData.SkinImageWidth,
+        SkinResourcePatch: skin.skinData.SkinResourcePatch,
+        ThirdPartyName: client.profile?.name || "Player",
+        ThirdPartyNameOnly: false,
+        TrustedSkin: skin.skinData.TrustedSkin,
+        UIProfile: 0,
+    };
+};
+exports.createDefaultPayload = createDefaultPayload;
+const getRandomId = () => {
+    return Math.floor(Math.random() * Date.now() * Math.random() * 1000000) ^ Date.now();
+};