@vaitosoi/minejs 0.3.1 → 0.4.0

package/src/version/codec.ts

@@ -1,9 +1,8 @@
-import z, { file } from "zod";
-import { MissingField, MissingPacketField, UnexpectedValue } from "../base/error";
+import z from "zod";
+import { MissingField, MissingPacketField, NotImplemented, UnexpectedValue } from "../base/error";
 import { BinaryDecoder } from "../packet/decoder";
 import { ConnectionState, SharedState } from "../world/state";
 import { FieldNode, PacketObject, PacketRegistry, VersionDefinitions } from "./registry";
-import { Dispatcher } from "../packet/dispatcher";
 import { BinaryEncoder } from "../packet/encoder";
 
 const TCPStateMapping: Record<ConnectionState, keyof z.infer<typeof VersionDefinitions> | null> = {
@@ -22,7 +21,7 @@ export interface EncodeResult {
 export class VersionCodec {
     constructor(private readonly state: SharedState) { }
 
-    public consumePacket: (packetId: string, data: object) => void = (...args) => { throw new Error("method not implemented"); };
+    public consumePacket: (packetId: string, data: object) => void = () => { throw new NotImplemented(); };
 
     public handlePacket(packetId: number, decoder: BinaryDecoder) {
         const mappedState = TCPStateMapping[this.state.state];
@@ -31,13 +30,25 @@ export class VersionCodec {
         if (!packet) return; // console.log("no packet");
 
         const { name, structure, skipForNow } = packet;
+
         if (skipForNow) return;
-        // console.log(`> packet ${name}`);
+
         const resolvedObject: Record<string, any> = {};
-        for (const [name, field] of Object.entries(structure)) {
-            // console.log({ name, resolvedObject });
-            resolvedObject[name] = this.readField(packetId, resolvedObject, name, field, decoder);
-        }
+        if (Object.keys(structure).length > 0)
+            for (const [name, field] of Object.entries(structure))
+                try {
+                    resolvedObject[name] = this.readField(packetId, resolvedObject, name, field, decoder);
+                } catch (err) {
+                    if (err instanceof NotImplemented) return;
+                    throw err;
+                }
+        if (this.state.clientOptions.debug?.packetLogger)
+            console.dir({
+                dir: "to client",
+                state: mappedState,
+                name,
+                data: resolvedObject,
+            });
 
         this.consumePacket(`${TCPStateMapping[this.state.state]}:${name}`, resolvedObject);
     }
@@ -48,6 +59,14 @@ export class VersionCodec {
         const packet = PacketRegistry.getPacket(mappedState, "serverbound", packetId);
         if (!packet) throw new UnexpectedValue("valid serverbound packet id", packetId.toString());
 
+        if (this.state.clientOptions.debug?.packetLogger)
+            console.dir({
+                dir: "to server",
+                state: mappedState,
+                id: packetId,
+                data,
+            });
+
         const { name: packetName, structure } = packet;
         let encoder = new BinaryEncoder();
         for (const [name, field] of Object.entries(structure)) {
@@ -98,7 +117,7 @@ export class VersionCodec {
                 let length;
                 if (!isNaN(Number(field.length)))
                     length = Number(field.length);
-                else 
+                else
                     length = readObject[field.length];
                 if (length === undefined) throw new MissingPacketField(packetId, fieldName, field.length.toString());
                 return decoder.readArray(length, (decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
@@ -114,6 +133,7 @@ export class VersionCodec {
             }
             case "angle": return decoder.readAngle();
             case "id_or_x": return decoder.readIdOrX((decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
+            case "id_set": return decoder.readIdSet();
             case "chat_type_decoration": return decoder.readChatTypeDecoration();
             case "chat_type": return decoder.readChatType();
             case "enum": return this.readField(packetId, readObject, fieldName, field.subType, decoder);
@@ -144,6 +164,7 @@ export class VersionCodec {
             case "bitset": return decoder.readPrefixedArray((decoder) => decoder.readLong());
             case "teleport_flags": return decoder.readTeleportFlag();
             case "null": return null;
+            case "not_implemented": throw new NotImplemented();
             case "switch": {
                 if (!(field.dependsOn in readObject)) throw new MissingPacketField(packetId, fieldName, field.dependsOn);
                 const dependencyValue = readObject[field.dependsOn];
@@ -185,7 +206,7 @@ export class VersionCodec {
             //     return encoder.writeArray(length, (decoder) => this.readField(packetId, readObject, fieldName, field.subType, decoder));
             // }
             case "prefixed_array": {
-                const length = metadata["length"];
+                const length = metadata["length"] || field.length;
                 if (!length) throw new MissingField("length", "prefixed array metadata object");
                 if (!Array.isArray(value))
                     throw new UnexpectedValue("an array for prefixed array", typeof value);

package/src/version/registry.ts

@@ -125,9 +125,9 @@ export const SupportTypes = z.enum([
     "fixed_point",
     "angle",
     "id_or_x",
+    "id_set",
     "chat_type_decoration",
     "chat_type",
-    "chunk_data",
     "enum",
     "json_text",
     "not_implemented",
@@ -301,11 +301,6 @@ export class PacketRegistry {
                 this.nameToId[stateKey]![typeKey] = {};
                 // eslint-disable-next-line prefer-const
                 for (let [key, value] of Object.entries(type) as [string | number, any]) {
-                    if (typeof key === "string" && !isNaN(parseInt(key))) {
-                        type[parseInt(key)] = value;
-                        delete type[key];
-                        key = parseInt(key);
-                    } // transform all string key into numberic key
                     this.nameToId[stateKey]![typeKey]![value.name] = key;
                 }
             }
@@ -328,6 +323,6 @@ export class PacketRegistry {
         if (isNaN(numbericId))
             throw new UnexpectedValue("valid packet id", id.toString(), "name or number or hex");
         else
-            return this.definition[state][type][numbericId.toString()];
+            return this.definition[state][type]["0x" + numbericId.toString(16).toUpperCase()];
     }
 }

package/src/world/state.ts

@@ -1,10 +1,11 @@
 import { Cipheriv, Decipheriv } from "node:crypto";
 import { If } from "../base/typing";
 import { Angle, BaseVec3 } from "../physics/direction";
-import { ClientNotReady } from "../base/error";
+import { AuthRelatedNotFound, ClientNotReady } from "../base/error";
 import { ClientEvents, ClientOption } from "../client/client";
-import { TypedEmmiter } from "../base/event";
-import { TCPClient } from "../client/tcp";
+import { AuthClient } from "../client/auth";
+import { MessageLink } from "../message/link";
+import { SignatureCache } from "../message/sigCache";
 
 export interface Server {
     knownPacks?: ServerKnownPack
@@ -146,18 +147,36 @@ export class SharedState<IsReady extends boolean = boolean> {
     public status: ClientStatus = ClientStatus.Disconnected;
     public compressionThreshold: number = 0;
 
+    // Auth stuffs
+    public authClient: AuthClient | undefined = undefined;
+    public playerUUID: string | undefined = undefined;
+    public publicKey: Buffer | undefined = undefined;
+    public signature: Buffer | undefined = undefined;
+    public signatureExpireTime: number | undefined = undefined;
+    // eslint-disable-next-line no-undef
+    private signatureTimeoutInstance: NodeJS.Timeout | undefined = undefined;
+
     public sharedSecret: Buffer | undefined = undefined;
     public cipher: Cipheriv | undefined = undefined;
     public decipher: Decipheriv | undefined = undefined;
+    public useEncryption: boolean = false;
+    public sessionID: Buffer | undefined = undefined;
 
     public server: Server | undefined = undefined;
     public registry: Record<string, ServerRegistryEntry[]> | undefined = undefined;
     public world: If<IsReady, ServerWorld> = null as any;
     public player: If<IsReady, ClientPlayer> = null as any;
 
+    /**
+     * For maintaining message order.
+     * 
+     * A UUID map to a MessageLink.
+     */
+    public messageLinks: Record<string, MessageLink> | undefined = undefined;
+    public messageSignatureCache: SignatureCache | undefined = undefined;
+
     constructor(
         public clientOptions: ClientOption,
-        public getUuid: () => Buffer,
     ) { }
 
     public isReady(): this is SharedState<true> {
@@ -173,15 +192,64 @@ export class SharedState<IsReady extends boolean = boolean> {
         this.mutationQueue = [];
         this.eventQueue = [];
         this.sendQueue = [];
+
         this.state = ConnectionState.Disconnected;
+        this.status = ClientStatus.Disconnected;
         this.compressionThreshold = 0;
+
+        this.authClient = undefined;
+        this.playerUUID = undefined;
+        this.publicKey = undefined;
+        this.signature = undefined;
+
         this.sharedSecret = undefined;
         this.cipher = undefined;
         this.decipher = undefined;
+        this.useEncryption = false;
+        this.sessionID = undefined;
+        this.signatureTimeoutInstance = undefined;
+
         this.server = undefined;
         this.registry = undefined;
         this.world = undefined as any;
         this.player = undefined as any;
+
+        if (this.clientOptions.shouldVerifyMessageSignature)
+            this.messageSignatureCache = SignatureCache.default();
+        else
+            this.messageSignatureCache = undefined;
+        if (this.clientOptions.shouldVerifyMessageOrder)
+            this.messageLinks = {};
+        else
+            this.messageLinks = undefined;
+    }
+
+    public getSignature() {
+        if (this.publicKey && this.signature)
+            return {
+                publicKey: this.publicKey,
+                signature: this.signature
+            };
+        throw new AuthRelatedNotFound("public key and signature");
+    }
+
+    private async fetchSignature() {
+        if (!this.authClient)
+            throw new AuthRelatedNotFound("instance of class AuthClient");
+        const { publicKey, signature, expiresAt } = await this.authClient.getKeyPair();
+        this.publicKey = Buffer.from(publicKey);
+        this.signature = Buffer.from(signature);
+        return expiresAt;
+    }
+    public async startSignatureLoop() {
+        const expiresAt = await this.fetchSignature();
+        this.signatureTimeoutInstance = setTimeout(
+            async () => await this.startSignatureLoop(), 
+            expiresAt - Date.now() - 10_000
+        );
+    }
+    public stopSignatureLoop() {
+        clearTimeout(this.signatureTimeoutInstance);
     }
 
     public enqueueMutation(mutation: MutateState) { this.mutationQueue.push(mutation); }

package/test/client/index.ts

@@ -1,22 +1,25 @@
-import { MoveDirection, Client } from "../../src/";
+import { Input, Client } from "../../src/index";
 
 const client = new Client({
     playerName: "bot",
     host: "localhost",
     port: 25565,
     version: "26.2",
-    // debug: {
-    //     packetLogger: true
-    // },
-    isOffline: true,
+    debug: {
+        packetLogger: true
+    },
     loadRegistry: false,
-    // auth: {
-    //     client_id: "d86254d8-edf7-4640-90eb-643c99af188e",
-    //     method: "loopback",
-    //     openBrowser: true
-    // }
+    auth: {
+        client_id: "d86254d8-edf7-4640-90eb-643c99af188e",
+        method: "loopback",
+        openBrowser: true,
+        port: 12345
+    },
+    shouldVerifyMessageOrder: true,
+    shouldVerifyMessageSignature: true
 });
 client.connect();
+client.hold(Input.Jump);
 client.on("disconnect", (...args) => console.dir({ name: "disconnect", args }, { depth: null }));
 client.on("disconnectRaw", (...args) => console.dir({ name: "disconnectRaw", args }, { depth: null }));
 // client.on("loadChunk", (...args) => console.dir({ name: "loadChunk", args }, { depth: null }));
@@ -34,18 +37,22 @@ client.on("message", (message) => {
     if (!message.content.startsWith("_")) return;
     const args = message.content.slice(1).split(" ");
     switch (args[0]) {
-        case "w": client.hold(MoveDirection.Forward); break;
-        case "sw": client.release(MoveDirection.Forward); break;
+        case "w": client.hold(Input.Forward); break;
+        case "sw": client.release(Input.Forward); break;
         case "ws":
-            client.hold(MoveDirection.Forward);
+            client.hold(Input.Forward);
             setTimeout(() => client.disconnect(), 2000);
             break;
-        case "s": client.hold(MoveDirection.Backward); break;
-        case "ss": client.release(MoveDirection.Backward); break;
-        case "a": client.hold(MoveDirection.Left); break;
-        case "sa": client.release(MoveDirection.Left); break;
-        case "d": client.hold(MoveDirection.Right); break;
-        case "sd": client.release(MoveDirection.Right); break;
+        case "s": client.hold(Input.Backward); break;
+        case "ss": client.release(Input.Backward); break;
+        case "a": client.hold(Input.Left); break;
+        case "sa": client.release(Input.Left); break;
+        case "d": client.hold(Input.Right); break;
+        case "sd": client.release(Input.Right); break;
+        case "j": client.hold(Input.Jump); break;
+        case "sj": client.release(Input.Jump); break;
+        case "run": client.hold(Input.Sprint); break;
+        case "srun": client.release(Input.Sprint); break;
         case "stop": client.stopMoving(); break;
 
         case "at": {
@@ -56,7 +63,7 @@ client.on("message", (message) => {
         }
 
         case "disconnect":
-        case "exit": 
+        case "exit":
             client.disconnect();
             break;
     }