refactor: packet

src/core/packet/msg/builder.ts

@@ -0,0 +1,52 @@
+import {PushMsgBody} from "@/core/packet/proto/message/message";
+import {NapProtoEncodeStructType} from "@/core/packet/proto/NapProto";
+import * as crypto from "crypto";
+import {PacketForwardNode} from "@/core/packet/msg/entity/forward";
+
+export class PacketMsgBuilder {
+    buildFakeMsg(selfUid: string, element: PacketForwardNode[]): NapProtoEncodeStructType<typeof PushMsgBody>[] {
+        return element.map((node): NapProtoEncodeStructType<typeof PushMsgBody> => {
+            const avatar = `https://q.qlogo.cn/headimg_dl?dst_uin=${node.senderId}&spec=640&img_type=jpg`
+            return {
+                responseHead: {
+                    fromUid: "",
+                    fromUin: node.senderId,
+                    toUid: node.groupId ? undefined : selfUid,
+                    forward: node.groupId ? undefined : {
+                        friendName: node.senderName,
+                    },
+                    grp: node.groupId ? {
+                        groupUin: node.groupId,
+                        memberName: node.senderName,
+                        unknown5: 2
+                    } : undefined,
+                },
+                contentHead: {
+                    type: node.groupId ? 82 : 9,
+                    subType: node.groupId ? undefined : 4,
+                    divSeq: node.groupId ? undefined : 4,
+                    msgId: crypto.randomBytes(4).readUInt32LE(0),
+                    sequence: crypto.randomBytes(4).readUInt32LE(0),
+                    timeStamp: Math.floor(Date.now() / 1000),
+                    field7: BigInt(1),
+                    field8: 0,
+                    field9: 0,
+                    forward: {
+                        field1: 0,
+                        field2: 0,
+                        field3: node.groupId ? 0 : 2,
+                        unknownBase64: avatar,
+                        avatar: avatar
+                    }
+                },
+                body: {
+                    richText: {
+                        elems: node.msg.map(
+                            (msg) => msg.buildElement() ?? []
+                        )
+                    }
+                }
+            }
+        });
+    }
+}

src/core/packet/msg/element.ts

@@ -0,0 +1,117 @@
+import {NapProtoEncodeStructType, NapProtoMsg} from "@/core/packet/proto/NapProto";
+import {Elem, MentionExtra} from "@/core/packet/proto/message/element";
+import {
+    AtType,
+    SendArkElement,
+    SendFaceElement,
+    SendFileElement,
+    SendMessageElement,
+    SendPicElement,
+    SendPttElement,
+    SendReplyElement,
+    SendTextElement,
+    SendVideoElement
+} from "@/core";
+
+// raw <-> packet
+// TODO: check ob11 -> raw impl!
+// TODO: parse to raw element
+export abstract class IPacketMsgElement<T extends SendMessageElement> {
+    protected constructor(rawElement: T) {
+    }
+
+    buildContent(): Uint8Array | undefined {
+        return undefined;
+    }
+
+    buildElement(): NapProtoEncodeStructType<typeof Elem> | undefined {
+        return undefined;
+    }
+}
+
+export class PacketMsgTextElement extends IPacketMsgElement<SendTextElement> {
+    text: string;
+
+    constructor(element: SendTextElement) {
+        super(element);
+        console.log(JSON.stringify(element));
+        this.text = element.textElement.content;
+    }
+
+    buildElement(): NapProtoEncodeStructType<typeof Elem> {
+        return {
+            text: {
+                str: this.text
+            }
+        };
+    }
+}
+
+export class PacketMsgAtElement extends PacketMsgTextElement {
+    targetUid: string;
+    atAll: boolean;
+
+    constructor(element: SendTextElement) {
+        super(element);
+        this.targetUid = element.textElement.atNtUid;
+        this.atAll = element.textElement.atType === AtType.atAll
+    }
+
+    buildElement(): NapProtoEncodeStructType<typeof Elem> {
+        const res = new NapProtoMsg(MentionExtra).encode({
+                type: this.atAll ? 1 : 2,
+                uin: 0,
+                field5: 0,
+                uid: this.targetUid,
+            }
+        )
+        return {
+            text: {
+                str: this.text,
+                pbReserve: res
+            }
+        }
+    }
+}
+
+export class PacketMsgPttElement extends IPacketMsgElement<SendPttElement> {
+    constructor(element: SendPttElement) {
+        super(element);
+    }
+}
+
+export class PacketMsgPicElement extends IPacketMsgElement<SendPicElement> {
+    constructor(element: SendPicElement) {
+        super(element);
+    }
+}
+
+export class PacketMsgReplyElement extends IPacketMsgElement<SendReplyElement> {
+    constructor(element: SendReplyElement) {
+        super(element);
+    }
+}
+
+export class PacketMsgFaceElement extends IPacketMsgElement<SendFaceElement> {
+    constructor(element: SendFaceElement) {
+        super(element);
+    }
+}
+
+export class PacketMsgFileElement extends IPacketMsgElement<SendFileElement> {
+    constructor(element: SendFileElement) {
+        super(element);
+    }
+}
+
+export class PacketMsgVideoElement extends IPacketMsgElement<SendVideoElement> {
+    constructor(element: SendVideoElement) {
+        super(element);
+    }
+}
+
+export class PacketMsgLightAppElement extends IPacketMsgElement<SendArkElement> {
+    constructor(element: SendArkElement) {
+        super(element);
+    }
+}

src/core/packet/msg/entity/forward.ts

@@ -0,0 +1,10 @@
+import {IPacketMsgElement} from "@/core/packet/msg/element";
+import {SendMessageElement} from "@/core";
+
+export interface PacketForwardNode {
+    groupId?: number
+    senderId: number
+    senderName: string
+    time: number
+    msg: IPacketMsgElement<SendMessageElement>[]
+}

src/core/packet/packetClient.ts

@@ -0,0 +1,127 @@
+import { LogWrapper } from "@/common/log";
+import { LRUCache } from "@/common/lru-cache";
+import WebSocket from "ws";
+import { createHash } from "crypto";
+
+export class PacketClient {
+    private websocket: WebSocket | undefined;
+    public isConnected: boolean = false;
+    private reconnectAttempts: number = 0;
+    private maxReconnectAttempts: number = 5;
+    //trace_id-type callback
+    private cb = new LRUCache<string, any>(500);
+    constructor(private url: string, public logger: LogWrapper) { }
+
+    connect(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.logger.log.bind(this.logger)(`Attempting to connect to ${this.url}`);
+            this.websocket = new WebSocket(this.url);
+            this.websocket.on('error', (err) => this.logger.logError.bind(this.logger)('[Core] [Packet Server] Error:', err.message));
+            
+            this.websocket.onopen = () => {
+                this.isConnected = true;
+                this.reconnectAttempts = 0;
+                this.logger.log.bind(this.logger)(`Connected to ${this.url}`);
+                resolve();
+            };
+
+            this.websocket.onerror = (error) => {
+                this.logger.logError.bind(this.logger)(`WebSocket error: ${error}`);
+                reject(error);
+            };
+
+            this.websocket.onmessage = (event) => {
+                // const message = JSON.parse(event.data.toString());
+                // console.log("Received message:", message);
+                this.handleMessage(event.data).then().catch();
+            };
+
+            this.websocket.onclose = () => {
+                this.isConnected = false;
+                this.logger.logWarn.bind(this.logger)(`Disconnected from ${this.url}`);
+                this.attemptReconnect();
+            };
+        });
+    }
+
+    private attemptReconnect(): void {
+        try {
+            if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                this.reconnectAttempts++;
+                this.logger.logError.bind(this.logger)(`Reconnecting attempt ${this.reconnectAttempts}`);
+                setTimeout(() => {
+                    this.connect().catch((error) => {
+                        this.logger.logError.bind(this.logger)(`Reconnect attempt failed: ${error.message}`);
+                    });
+                }, 5000 * this.reconnectAttempts);
+            } else {
+                this.logger.logError.bind(this.logger)(`Max reconnect attempts reached. Could not reconnect to ${this.url}`);
+            }
+        } catch (error: any) {
+            this.logger.logError.bind(this.logger)(`Error attempting to reconnect: ${error.message}`);
+        }
+    }
+    async registerCallback(trace_id: string, type: string, callback: any): Promise<void> {
+        this.cb.put(createHash('md5').update(trace_id).digest('hex') + type, callback);
+    }
+
+    async init(pid: number, recv: string, send: string): Promise<void> {
+        if (!this.isConnected || !this.websocket) {
+            throw new Error("WebSocket is not connected");
+        }
+
+        const initMessage = {
+            action: 'init',
+            pid: pid,
+            recv: recv,
+            send: send
+        };
+        this.websocket.send(JSON.stringify(initMessage));
+    }
+
+    async sendCommand(cmd: string, data: string, trace_id: string, rsp: boolean = false, timeout: number = 5000, sendcb: any = () => { }): Promise<any> {
+        return new Promise<any>((resolve, reject) => {
+            if (!this.isConnected || !this.websocket) {
+                throw new Error("WebSocket is not connected");
+            }
+            const commandMessage = {
+                action: 'send',
+                cmd: cmd,
+                data: data,
+                trace_id: trace_id
+            };
+            this.websocket.send(JSON.stringify(commandMessage));
+            if (rsp) {
+                this.registerCallback(trace_id, 'recv', (json: any) => {
+                    clearTimeout(timeoutHandle);
+                    resolve(json);
+                });
+            }
+            this.registerCallback(trace_id, 'send', (json: any) => {
+                sendcb(json);
+                if (!rsp) {
+                    clearTimeout(timeoutHandle);
+                    resolve(json);
+                }
+            });
+            const timeoutHandle = setTimeout(() => {
+                reject(new Error(`sendCommand timed out after ${timeout} ms`));
+            }, timeout);
+        });
+    }
+    private async handleMessage(message: any): Promise<void> {
+        try {
+
+            let json = JSON.parse(message.toString());
+            let trace_id_md5 = json.trace_id_md5;
+            let action = json?.type ?? 'init';
+            let event = this.cb.get(trace_id_md5 + action);
+            if (event) {
+                await event(json.data);
+            }
+            //console.log("Received message:", json);
+        } catch (error) {
+            this.logger.logError.bind(this.logger)(`Error parsing message: ${error}`);
+        }
+    }
+}

src/core/packet/packetPacker.ts

@@ -0,0 +1,123 @@
+import * as zlib from "node:zlib";
+import { NapProtoMsg } from "@/core/packet/proto/NapProto";
+import { OidbSvcTrpcTcpBase } from "@/core/packet/proto/oidb/OidbBase";
+import { OidbSvcTrpcTcp0X9067_202 } from "@/core/packet/proto/oidb/Oidb.0x9067_202";
+import { OidbSvcTrpcTcp0X8FC_2, OidbSvcTrpcTcp0X8FC_2_Body } from "@/core/packet/proto/oidb/Oidb.0x8FC_2";
+import { OidbSvcTrpcTcp0XFE1_2 } from "@/core/packet/proto/oidb/Oidb.fe1_2";
+import { OidbSvcTrpcTcp0XED3_1 } from "@/core/packet/proto/oidb/Oidb.ed3_1";
+import {LongMsgResult, SendLongMsgReq} from "@/core/packet/proto/message/action";
+import {PacketMsgBuilder} from "@/core/packet/msg/builder";
+import {PacketForwardNode} from "@/core/packet/msg/entity/forward";
+
+export type PacketHexStr = string & { readonly hexNya: unique symbol };
+
+export class PacketPacker {
+    private packetBuilder: PacketMsgBuilder
+
+    constructor() {
+        this.packetBuilder = new PacketMsgBuilder();
+    }
+
+    private toHexStr(byteArray: Uint8Array): PacketHexStr {
+        return Buffer.from(byteArray).toString('hex') as PacketHexStr;
+    }
+
+    packOidbPacket(cmd: number, subCmd: number, body: Uint8Array, isUid: boolean = true, isLafter: boolean = false): Uint8Array {
+        return new NapProtoMsg(OidbSvcTrpcTcpBase).encode({
+            command: cmd,
+            subCommand: subCmd,
+            body: body,
+            isReserved: isUid ? 1 : 0
+        });
+    }
+
+    packPokePacket(group: number, peer: number): PacketHexStr {
+        const oidb_0xed3 = new NapProtoMsg(OidbSvcTrpcTcp0XED3_1).encode({
+            uin: peer,
+            groupUin: group,
+            friendUin: group,
+            ext: 0
+        });
+        return this.toHexStr(this.packOidbPacket(0xed3, 1, oidb_0xed3));
+    }
+
+    packRkeyPacket(): PacketHexStr {
+        const oidb_0x9067_202 = new NapProtoMsg(OidbSvcTrpcTcp0X9067_202).encode({
+            reqHead: {
+                common: {
+                    requestId: 1,
+                    command: 202
+                },
+                scene: {
+                    requestType: 2,
+                    businessType: 1,
+                    sceneType: 0
+                },
+                client: {
+                    agentType: 2
+                }
+            },
+            downloadRKeyReq: {
+                key: [10, 20, 2]
+            },
+        });
+        return this.toHexStr(this.packOidbPacket(0x9067, 202, oidb_0x9067_202));
+    }
+
+    packSetSpecialTittlePacket(groupCode: string, uid: string, tittle: string): PacketHexStr {
+        const oidb_0x8FC_2_body = new NapProtoMsg(OidbSvcTrpcTcp0X8FC_2_Body).encode({
+            targetUid: uid,
+            specialTitle: tittle,
+            expiredTime: -1,
+            uinName: tittle
+        });
+        const oidb_0x8FC_2 = new NapProtoMsg(OidbSvcTrpcTcp0X8FC_2).encode({
+            groupUin: +groupCode,
+            body: oidb_0x8FC_2_body
+        });
+        return this.toHexStr(this.packOidbPacket(0x8FC, 2, oidb_0x8FC_2, false, false));
+    }
+
+    packStatusPacket(uin: number): PacketHexStr {
+        let oidb_0xfe1_2 = new NapProtoMsg(OidbSvcTrpcTcp0XFE1_2).encode({
+            uin: uin,
+            key: [{ key: 27372 }]
+        });
+        return this.toHexStr(this.packOidbPacket(0xfe1, 2, oidb_0xfe1_2));
+    }
+
+    packUploadForwardMsg(selfUid: string, msg: PacketForwardNode[], groupUin: number = 0) : PacketHexStr {
+        // console.log("packUploadForwardMsg START!!!", selfUid, msg, groupUin);
+        const msgBody = this.packetBuilder.buildFakeMsg(selfUid, msg);
+        const longMsgResultData = new NapProtoMsg(LongMsgResult).encode(
+            {
+                action: {
+                    actionCommand: "MultiMsg",
+                    actionData: {
+                        msgBody: msgBody
+                    }
+                }
+            }
+        )
+        // console.log("packUploadForwardMsg LONGMSGRESULT!!!", this.toHexStr(longMsgResultData));
+        const payload = zlib.gzipSync(Buffer.from(longMsgResultData));
+        // console.log("packUploadForwardMsg PAYLOAD!!!", payload);
+        const req = new NapProtoMsg(SendLongMsgReq).encode(
+            {
+                info: {
+                    type: groupUin === 0 ? 1 : 3,
+                    uid: {
+                        uid: groupUin === 0 ? selfUid : groupUin.toString(),
+                    },
+                    groupUin: groupUin,
+                    payload: payload
+                },
+                settings: {
+                    field1: 4, field2: 1, field3: 7, field4: 0
+                }
+            }
+        )
+        // console.log("packUploadForwardMsg REQ!!!", req);
+        return this.toHexStr(req);
+    }
+}

src/core/packet/proto/NapProto.ts

@@ -0,0 +1,139 @@
+import { MessageType, PartialMessage, RepeatType, ScalarType } from '@protobuf-ts/runtime';
+import { PartialFieldInfo } from "@protobuf-ts/runtime/build/types/reflection-info";
+
+type LowerCamelCase<S extends string> = CamelCaseHelper<S, false, true>;
+
+type CamelCaseHelper<
+    S extends string,
+    CapNext extends boolean,
+    IsFirstChar extends boolean
+> = S extends `${infer F}${infer R}`
+    ? F extends '_'
+    ? CamelCaseHelper<R, true, false>
+    : F extends `${number}`
+    ? `${F}${CamelCaseHelper<R, true, false>}`
+    : CapNext extends true
+    ? `${Uppercase<F>}${CamelCaseHelper<R, false, false>}`
+    : IsFirstChar extends true
+    ? `${Lowercase<F>}${CamelCaseHelper<R, false, false>}`
+    : `${F}${CamelCaseHelper<R, false, false>}`
+    : '';
+
+type ScalarTypeToTsType<T extends ScalarType> =
+    T extends ScalarType.DOUBLE | ScalarType.FLOAT | ScalarType.INT32 | ScalarType.FIXED32 | ScalarType.UINT32 | ScalarType.SFIXED32 | ScalarType.SINT32 ? number :
+    T extends ScalarType.INT64 | ScalarType.UINT64 | ScalarType.FIXED64 | ScalarType.SFIXED64 | ScalarType.SINT64 ? bigint :
+    T extends ScalarType.BOOL ? boolean :
+    T extends ScalarType.STRING ? string :
+    T extends ScalarType.BYTES ? Uint8Array :
+    never;
+
+interface BaseProtoFieldType<T, O extends boolean, R extends O extends true ? false : boolean> {
+    kind: 'scalar' | 'message';
+    no: number;
+    type: T;
+    optional: O;
+    repeat: R;
+}
+
+interface ScalarProtoFieldType<T extends ScalarType, O extends boolean, R extends O extends true ? false : boolean> extends BaseProtoFieldType<T, O, R> {
+    kind: 'scalar';
+}
+
+interface MessageProtoFieldType<T extends () => ProtoMessageType, O extends boolean, R extends O extends true ? false : boolean> extends BaseProtoFieldType<T, O, R> {
+    kind: 'message';
+}
+
+type ProtoFieldType =
+    | ScalarProtoFieldType<ScalarType, boolean, boolean>
+    | MessageProtoFieldType<() => ProtoMessageType, boolean, boolean>;
+
+type ProtoMessageType = {
+    [key: string]: ProtoFieldType;
+};
+
+export function ProtoField<T extends ScalarType, O extends boolean = false, R extends O extends true ? false : boolean = false>(no: number, type: T, optional?: O, repeat?: R): ScalarProtoFieldType<T, O, R>;
+export function ProtoField<T extends () => ProtoMessageType, O extends boolean = false, R extends O extends true ? false : boolean = false>(no: number, type: T, optional?: O, repeat?: R): MessageProtoFieldType<T, O, R>;
+export function ProtoField(no: number, type: ScalarType | (() => ProtoMessageType), optional?: boolean, repeat?: boolean): ProtoFieldType {
+    if (typeof type === 'function') {
+        return { kind: 'message', no: no, type: type, optional: optional ?? false, repeat: repeat ?? false };
+    } else {
+        return { kind: 'scalar', no: no, type: type, optional: optional ?? false, repeat: repeat ?? false };
+    }
+}
+
+type ProtoFieldReturnType<T extends unknown, E extends boolean> = NonNullable<T> extends ScalarProtoFieldType<infer S, infer O, infer R>
+    ? ScalarTypeToTsType<S>
+    : T extends NonNullable<MessageProtoFieldType<infer S, infer O, infer R>>
+    ? NonNullable<NapProtoStructType<ReturnType<S>, E>>
+    : never;
+
+type RequiredFieldsBaseType<T extends unknown, E extends boolean> = {
+    [K in keyof T as T[K] extends { optional: true } ? never : LowerCamelCase<K & string>]:
+    T[K] extends { repeat: true }
+    ? ProtoFieldReturnType<T[K], E>[]
+    : ProtoFieldReturnType<T[K], E>
+}
+
+type OptionalFieldsBaseType<T extends unknown, E extends boolean> = {
+    [K in keyof T as T[K] extends { optional: true } ? LowerCamelCase<K & string> : never]?:
+    T[K] extends { repeat: true }
+    ? ProtoFieldReturnType<T[K], E>[]
+    : ProtoFieldReturnType<T[K], E>
+}
+
+type RequiredFieldsType<T extends unknown, E extends boolean> = E extends true ? Partial<RequiredFieldsBaseType<T, E>> : RequiredFieldsBaseType<T, E>;
+
+type OptionalFieldsType<T extends unknown, E extends boolean> = E extends true ? Partial<OptionalFieldsBaseType<T, E>> : OptionalFieldsBaseType<T, E>;
+
+type NapProtoStructType<T extends unknown, E extends boolean> = RequiredFieldsType<T, E> & OptionalFieldsType<T, E>;
+
+export type NapProtoEncodeStructType<T extends unknown> = NapProtoStructType<T, true>;
+
+export type NapProtoDecodeStructType<T extends unknown> = NapProtoStructType<T, false>;
+
+const NapProtoMsgCache = new Map<ProtoMessageType, MessageType<NapProtoStructType<ProtoMessageType, boolean>>>();
+
+export class NapProtoMsg<T extends ProtoMessageType> {
+    private readonly _msg: T;
+    private readonly _field: PartialFieldInfo[];
+    private readonly _proto_msg: MessageType<NapProtoStructType<T, boolean>>;
+
+    constructor(fields: T) {
+        this._msg = fields;
+        this._field = Object.keys(fields).map(key => {
+            const field = fields[key];
+            if (field.kind === 'scalar') {
+                const repeatType = field.repeat
+                    ? [ScalarType.STRING, ScalarType.BYTES].includes(field.type)
+                        ? RepeatType.UNPACKED
+                        : RepeatType.PACKED
+                    : RepeatType.NO;
+                return {
+                    no: field.no,
+                    name: key,
+                    kind: 'scalar',
+                    T: field.type,
+                    opt: field.optional,
+                    repeat: repeatType,
+                };
+            } else if (field.kind === 'message') {
+                return {
+                    no: field.no,
+                    name: key,
+                    kind: 'message',
+                    repeat: field.repeat ? RepeatType.PACKED : RepeatType.NO,
+                    T: () => new NapProtoMsg(field.type())._proto_msg,
+                };
+            }
+        }) as PartialFieldInfo[];
+        this._proto_msg = new MessageType<NapProtoStructType<T, boolean>>('nya', this._field);
+    }
+
+    encode(data: NapProtoEncodeStructType<T>): Uint8Array {
+        return this._proto_msg.toBinary(this._proto_msg.create(data as PartialMessage<NapProtoEncodeStructType<T>>));
+    }
+
+    decode(data: Uint8Array): NapProtoDecodeStructType<T> {
+        return this._proto_msg.fromBinary(data) as NapProtoDecodeStructType<T>;
+    }
+}

src/core/packet/proto/message/action.ts

@@ -0,0 +1,117 @@
+import {ScalarType} from "@protobuf-ts/runtime";
+import {ProtoField} from "../NapProto";
+import {PushMsgBody} from "@/core/packet/proto/message/message";
+
+export const LongMsgResult = {
+    action: ProtoField(2, () => LongMsgAction)
+};
+
+export const LongMsgAction = {
+    actionCommand: ProtoField(1, ScalarType.STRING),
+    actionData: ProtoField(2, () => LongMsgContent)
+};
+
+export const LongMsgContent = {
+    msgBody: ProtoField(1, () => PushMsgBody, false, true)
+};
+
+export const RecvLongMsgReq = {
+    info: ProtoField(1, () => RecvLongMsgInfo, true),
+    settings: ProtoField(15, () => LongMsgSettings, true)
+};
+
+export const RecvLongMsgInfo = {
+    uid: ProtoField(1, () => LongMsgUid, true),
+    resId: ProtoField(2, ScalarType.STRING, true),
+    acquire: ProtoField(3, ScalarType.BOOL)
+};
+
+export const LongMsgUid = {
+    uid: ProtoField(2, ScalarType.STRING, true)
+};
+
+export const LongMsgSettings = {
+    field1: ProtoField(1, ScalarType.UINT32),
+    field2: ProtoField(2, ScalarType.UINT32),
+    field3: ProtoField(3, ScalarType.UINT32),
+    field4: ProtoField(4, ScalarType.UINT32)
+};
+
+export const RecvLongMsgResp = {
+    result: ProtoField(1, () => RecvLongMsgResult),
+    settings: ProtoField(15, () => LongMsgSettings)
+};
+
+export const RecvLongMsgResult = {
+    resId: ProtoField(3, ScalarType.STRING),
+    payload: ProtoField(4, ScalarType.BYTES)
+};
+
+export const SendLongMsgReq = {
+    info: ProtoField(2, () => SendLongMsgInfo),
+    settings: ProtoField(15, () => LongMsgSettings)
+};
+
+export const SendLongMsgInfo = {
+    type: ProtoField(1, ScalarType.UINT32),
+    uid: ProtoField(2, () => LongMsgUid, true),
+    groupUin: ProtoField(3, ScalarType.UINT32, true),
+    payload: ProtoField(4, ScalarType.BYTES, true)
+};
+
+export const SendLongMsgResp = {
+    result: ProtoField(2, () => SendLongMsgResult),
+    settings: ProtoField(15, () => LongMsgSettings)
+};
+
+export const SendLongMsgResult = {
+    resId: ProtoField(3, ScalarType.STRING)
+};
+
+export const SsoGetGroupMsg = {
+    info: ProtoField(1, () => SsoGetGroupMsgInfo),
+    direction: ProtoField(2, ScalarType.BOOL)
+};
+
+export const SsoGetGroupMsgInfo = {
+    groupUin: ProtoField(1, ScalarType.UINT32),
+    startSequence: ProtoField(2, ScalarType.UINT32),
+    endSequence: ProtoField(3, ScalarType.UINT32)
+};
+
+export const SsoGetGroupMsgResponse = {
+    body: ProtoField(3, () => SsoGetGroupMsgResponseBody)
+};
+
+export const SsoGetGroupMsgResponseBody = {
+    groupUin: ProtoField(3, ScalarType.UINT32),
+    startSequence: ProtoField(4, ScalarType.UINT32),
+    endSequence: ProtoField(5, ScalarType.UINT32),
+    messages: ProtoField(6, () => PushMsgBody, false, true)
+};
+
+export const SsoGetRoamMsg = {
+    friendUid: ProtoField(1, ScalarType.STRING, true),
+    time: ProtoField(2, ScalarType.UINT32),
+    random: ProtoField(3, ScalarType.UINT32),
+    count: ProtoField(4, ScalarType.UINT32),
+    direction: ProtoField(5, ScalarType.BOOL)
+};
+
+export const SsoGetRoamMsgResponse = {
+    friendUid: ProtoField(3, ScalarType.STRING),
+    timestamp: ProtoField(5, ScalarType.UINT32),
+    random: ProtoField(6, ScalarType.UINT32),
+    messages: ProtoField(7, () => PushMsgBody, false, true)
+};
+
+export const SsoGetC2cMsg = {
+    friendUid: ProtoField(2, ScalarType.STRING, true),
+    startSequence: ProtoField(3, ScalarType.UINT32),
+    endSequence: ProtoField(4, ScalarType.UINT32)
+};
+
+export const SsoGetC2cMsgResponse = {
+    friendUid: ProtoField(4, ScalarType.STRING),
+    messages: ProtoField(7, () => PushMsgBody, false, true)
+};

src/core/packet/proto/message/c2c.ts

@@ -0,0 +1,11 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+export const C2C = {
+    uin: ProtoField(1, ScalarType.UINT32, true),
+    uid: ProtoField(2, ScalarType.STRING, true),
+    field3: ProtoField(3, ScalarType.UINT32, true),
+    sig: ProtoField(4, ScalarType.UINT32, true),
+    receiverUin: ProtoField(5, ScalarType.UINT32, true),
+    receiverUid: ProtoField(6, ScalarType.STRING, true),
+};

src/core/packet/proto/message/component.ts

@@ -0,0 +1,147 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+import { Elem } from "@/core/packet/proto/message/element";
+
+export const Attr = {
+    codePage: ProtoField(1, ScalarType.INT32),
+    time: ProtoField(2, ScalarType.INT32),
+    random: ProtoField(3, ScalarType.INT32),
+    color: ProtoField(4, ScalarType.INT32),
+    size: ProtoField(5, ScalarType.INT32),
+    effect: ProtoField(6, ScalarType.INT32),
+    charSet: ProtoField(7, ScalarType.INT32),
+    pitchAndFamily: ProtoField(8, ScalarType.INT32),
+    fontName: ProtoField(9, ScalarType.STRING),
+    reserveData: ProtoField(10, ScalarType.BYTES),
+};
+
+export const NotOnlineFile = {
+    fileType: ProtoField(1, ScalarType.INT32, true),
+    sig: ProtoField(2, ScalarType.BYTES, true),
+    fileUuid: ProtoField(3, ScalarType.STRING, true),
+    fileMd5: ProtoField(4, ScalarType.BYTES, true),
+    fileName: ProtoField(5, ScalarType.STRING, true),
+    fileSize: ProtoField(6, ScalarType.INT64, true),
+    note: ProtoField(7, ScalarType.BYTES, true),
+    reserved: ProtoField(8, ScalarType.INT32, true),
+    subcmd: ProtoField(9, ScalarType.INT32, true),
+    microCloud: ProtoField(10, ScalarType.INT32, true),
+    bytesFileUrls: ProtoField(11, ScalarType.BYTES, false, true),
+    downloadFlag: ProtoField(12, ScalarType.INT32, true),
+    dangerEvel: ProtoField(50, ScalarType.INT32, true),
+    lifeTime: ProtoField(51, ScalarType.INT32, true),
+    uploadTime: ProtoField(52, ScalarType.INT32, true),
+    absFileType: ProtoField(53, ScalarType.INT32, true),
+    clientType: ProtoField(54, ScalarType.INT32, true),
+    expireTime: ProtoField(55, ScalarType.INT32, true),
+    pbReserve: ProtoField(56, ScalarType.BYTES, true),
+    fileHash: ProtoField(57, ScalarType.STRING, true),
+};
+
+export const Ptt = {
+    fileType: ProtoField(1, ScalarType.INT32),
+    srcUin: ProtoField(2, ScalarType.UINT64),
+    fileUuid: ProtoField(3, ScalarType.STRING),
+    fileMd5: ProtoField(4, ScalarType.BYTES),
+    fileName: ProtoField(5, ScalarType.STRING),
+    fileSize: ProtoField(6, ScalarType.INT32),
+    reserve: ProtoField(7, ScalarType.BYTES),
+    fileId: ProtoField(8, ScalarType.INT32),
+    serverIp: ProtoField(9, ScalarType.INT32),
+    serverPort: ProtoField(10, ScalarType.INT32),
+    boolValid: ProtoField(11, ScalarType.BOOL),
+    signature: ProtoField(12, ScalarType.BYTES),
+    shortcut: ProtoField(13, ScalarType.BYTES),
+    fileKey: ProtoField(14, ScalarType.BYTES),
+    magicPttIndex: ProtoField(15, ScalarType.INT32),
+    voiceSwitch: ProtoField(16, ScalarType.INT32),
+    pttUrl: ProtoField(17, ScalarType.BYTES),
+    groupFileKey: ProtoField(18, ScalarType.STRING),
+    time: ProtoField(19, ScalarType.INT32),
+    downPara: ProtoField(20, ScalarType.BYTES),
+    format: ProtoField(29, ScalarType.INT32),
+    pbReserve: ProtoField(30, ScalarType.BYTES),
+    bytesPttUrls: ProtoField(31, ScalarType.BYTES, false, true),
+    downloadFlag: ProtoField(32, ScalarType.INT32),
+};
+
+export const RichText = {
+    attr: ProtoField(1, () => Attr, true),
+    elems: ProtoField(2, () => Elem, false, true),
+    notOnlineFile: ProtoField(3, () => NotOnlineFile, true),
+    ptt: ProtoField(4, () => Ptt, true),
+};
+
+export const ButtonExtra = {
+    data: ProtoField(1, () => KeyboardData),
+};
+
+export const KeyboardData = {
+    rows: ProtoField(1, () => Row, false, true),
+};
+
+export const Row = {
+    buttons: ProtoField(1, () => Button, false, true),
+};
+
+export const Button = {
+    id: ProtoField(1, ScalarType.STRING),
+    renderData: ProtoField(2, () => RenderData),
+    action: ProtoField(3, () => Action),
+};
+
+export const RenderData = {
+    label: ProtoField(1, ScalarType.STRING),
+    visitedLabel: ProtoField(2, ScalarType.STRING),
+    style: ProtoField(3, ScalarType.INT32),
+};
+
+export const Action = {
+    type: ProtoField(1, ScalarType.INT32),
+    permission: ProtoField(2, () => Permission),
+    unsupportTips: ProtoField(4, ScalarType.STRING),
+    data: ProtoField(5, ScalarType.STRING),
+    reply: ProtoField(7, ScalarType.BOOL),
+    enter: ProtoField(8, ScalarType.BOOL),
+};
+
+export const Permission = {
+    type: ProtoField(1, ScalarType.INT32),
+    specifyRoleIds: ProtoField(2, ScalarType.STRING, false, true),
+    specifyUserIds: ProtoField(3, ScalarType.STRING, false, true),
+};
+
+export const FileExtra = {
+    file: ProtoField(1, () => NotOnlineFile),
+};
+
+export const GroupFileExtra = {
+    field1: ProtoField(1, ScalarType.UINT32),
+    fileName: ProtoField(2, ScalarType.STRING),
+    display: ProtoField(3, ScalarType.STRING),
+    inner: ProtoField(7, () => GroupFileExtraInner),
+};
+
+export const GroupFileExtraInner = {
+    info: ProtoField(2, () => GroupFileExtraInfo),
+};
+
+export const GroupFileExtraInfo = {
+    busId: ProtoField(1, ScalarType.UINT32),
+    fileId: ProtoField(2, ScalarType.STRING),
+    fileSize: ProtoField(3, ScalarType.UINT64),
+    fileName: ProtoField(4, ScalarType.STRING),
+    field5: ProtoField(5, ScalarType.UINT32),
+    field7: ProtoField(7, ScalarType.STRING),
+    fileMd5: ProtoField(8, ScalarType.STRING),
+};
+
+export const ImageExtraUrl = {
+    origUrl: ProtoField(30, ScalarType.STRING),
+};
+
+export const PokeExtra = {
+    type: ProtoField(1, ScalarType.UINT32),
+    field7: ProtoField(7, ScalarType.UINT32),
+    field8: ProtoField(8, ScalarType.UINT32),
+};

src/core/packet/proto/message/element.ts

@@ -0,0 +1,346 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+export const Elem = {
+    text: ProtoField(1, () => Text, true),
+    face: ProtoField(2, () => Face, true),
+    onlineImage: ProtoField(3, () => OnlineImage, true),
+    notOnlineImage: ProtoField(4, () => NotOnlineImage, true),
+    transElem: ProtoField(5, () => TransElem, true),
+    marketFace: ProtoField(6, () => MarketFace, true),
+    customFace: ProtoField(8, () => CustomFace, true),
+    elemFlags2: ProtoField(9, () => ElemFlags2, true),
+    richMsg: ProtoField(12, () => RichMsg, true),
+    groupFile: ProtoField(13, () => GroupFile, true),
+    extraInfo: ProtoField(16, () => ExtraInfo, true),
+    videoFile: ProtoField(19, () => VideoFile, true),
+    anonymousGroupMessage: ProtoField(21, () => AnonymousGroupMessage, true),
+    customElem: ProtoField(31, () => CustomElem, true),
+    generalFlags: ProtoField(37, () => GeneralFlags, true),
+    srcMsg: ProtoField(45, () => SrcMsg, true),
+    lightAppElem: ProtoField(51, () => LightAppElem, true),
+    commonElem: ProtoField(53, () => CommonElem, true),
+}
+
+export const Text = {
+    str: ProtoField(1, ScalarType.STRING, true),
+    lint: ProtoField(2, ScalarType.STRING, true),
+    attr6Buf: ProtoField(3, ScalarType.BYTES, true),
+    attr7Buf: ProtoField(4, ScalarType.BYTES, true),
+    buf: ProtoField(11, ScalarType.BYTES, true),
+    pbReserve: ProtoField(12, ScalarType.BYTES, true),
+}
+
+export const Face = {
+    index: ProtoField(1, ScalarType.INT32, true),
+    old: ProtoField(2, ScalarType.BYTES, true),
+    buf: ProtoField(11, ScalarType.BYTES, true),
+};
+
+export const OnlineImage = {
+    guid: ProtoField(1, ScalarType.BYTES),
+    filePath: ProtoField(2, ScalarType.BYTES),
+    oldVerSendFile: ProtoField(3, ScalarType.BYTES),
+}
+
+export const NotOnlineImage = {
+    filePath: ProtoField(1, ScalarType.STRING),
+    fileLen: ProtoField(2, ScalarType.UINT32),
+    downloadPath: ProtoField(3, ScalarType.STRING),
+    oldVerSendFile: ProtoField(4, ScalarType.BYTES),
+    imgType: ProtoField(5, ScalarType.INT32),
+    previewsImage: ProtoField(6, ScalarType.BYTES),
+    picMd5: ProtoField(7, ScalarType.BYTES),
+    picHeight: ProtoField(8, ScalarType.UINT32),
+    picWidth: ProtoField(9, ScalarType.UINT32),
+    resId: ProtoField(10, ScalarType.STRING),
+    flag: ProtoField(11, ScalarType.BYTES),
+    thumbUrl: ProtoField(12, ScalarType.STRING),
+    original: ProtoField(13, ScalarType.INT32),
+    bigUrl: ProtoField(14, ScalarType.STRING),
+    origUrl: ProtoField(15, ScalarType.STRING),
+    bizType: ProtoField(16, ScalarType.INT32),
+    result: ProtoField(17, ScalarType.INT32),
+    index: ProtoField(18, ScalarType.INT32),
+    opFaceBuf: ProtoField(19, ScalarType.BYTES),
+    oldPicMd5: ProtoField(20, ScalarType.BOOL),
+    thumbWidth: ProtoField(21, ScalarType.INT32),
+    thumbHeight: ProtoField(22, ScalarType.INT32),
+    fileId: ProtoField(23, ScalarType.INT32),
+    showLen: ProtoField(24, ScalarType.UINT32),
+    downloadLen: ProtoField(25, ScalarType.UINT32),
+    x400Url: ProtoField(26, ScalarType.STRING),
+    x400Width: ProtoField(27, ScalarType.INT32),
+    x400Height: ProtoField(28, ScalarType.INT32),
+    pbRes: ProtoField(29, () => NotOnlineImage_PbReserve),
+}
+
+export const NotOnlineImage_PbReserve = {
+    subType: ProtoField(1, ScalarType.INT32),
+    field3: ProtoField(3, ScalarType.INT32),
+    field4: ProtoField(4, ScalarType.INT32),
+    summary: ProtoField(8, ScalarType.STRING),
+    field10: ProtoField(10, ScalarType.INT32),
+    field20: ProtoField(20, () => NotOnlineImage_PbReserve2),
+    url: ProtoField(30, ScalarType.STRING),
+    md5Str: ProtoField(31, ScalarType.STRING),
+}
+
+export const NotOnlineImage_PbReserve2 = {
+    field1: ProtoField(1, ScalarType.INT32),
+    field2: ProtoField(2, ScalarType.STRING),
+    field3: ProtoField(3, ScalarType.INT32),
+    field4: ProtoField(4, ScalarType.INT32),
+    field5: ProtoField(5, ScalarType.INT32),
+    field7: ProtoField(7, ScalarType.STRING),
+}
+
+export const TransElem = {
+    elemType: ProtoField(1, ScalarType.INT32),
+    elemValue: ProtoField(2, ScalarType.BYTES),
+}
+
+export const MarketFace = {
+    faceName: ProtoField(1, ScalarType.BYTES),
+    itemType: ProtoField(2, ScalarType.INT32),
+    faceInfo: ProtoField(3, ScalarType.INT32),
+    faceId: ProtoField(4, ScalarType.BYTES),
+    tabId: ProtoField(5, ScalarType.INT32),
+    subType: ProtoField(6, ScalarType.INT32),
+    key: ProtoField(7, ScalarType.BYTES),
+    param: ProtoField(8, ScalarType.BYTES),
+    mediaType: ProtoField(9, ScalarType.INT32),
+    imageWidth: ProtoField(10, ScalarType.INT32),
+    imageHeight: ProtoField(11, ScalarType.INT32),
+    mobileparam: ProtoField(12, ScalarType.BYTES),
+    pbReserve: ProtoField(13, ScalarType.BYTES),
+}
+
+export const CustomFace = {
+    guid: ProtoField(1, ScalarType.BYTES),
+    filePath: ProtoField(2, ScalarType.STRING),
+    shortcut: ProtoField(3, ScalarType.STRING),
+    buffer: ProtoField(4, ScalarType.BYTES),
+    flag: ProtoField(5, ScalarType.BYTES),
+    oldData: ProtoField(6, ScalarType.BYTES, true),
+    fileId: ProtoField(7, ScalarType.UINT32),
+    serverIp: ProtoField(8, ScalarType.INT32, true),
+    serverPort: ProtoField(9, ScalarType.INT32, true),
+    fileType: ProtoField(10, ScalarType.INT32),
+    signature: ProtoField(11, ScalarType.BYTES),
+    useful: ProtoField(12, ScalarType.INT32),
+    md5: ProtoField(13, ScalarType.BYTES),
+    thumbUrl: ProtoField(14, ScalarType.STRING),
+    bigUrl: ProtoField(15, ScalarType.STRING),
+    origUrl: ProtoField(16, ScalarType.STRING),
+    bizType: ProtoField(17, ScalarType.INT32),
+    repeatIndex: ProtoField(18, ScalarType.INT32),
+    repeatImage: ProtoField(19, ScalarType.INT32),
+    imageType: ProtoField(20, ScalarType.INT32),
+    index: ProtoField(21, ScalarType.INT32),
+    width: ProtoField(22, ScalarType.INT32),
+    height: ProtoField(23, ScalarType.INT32),
+    source: ProtoField(24, ScalarType.INT32),
+    size: ProtoField(25, ScalarType.UINT32),
+    origin: ProtoField(26, ScalarType.INT32),
+    thumbWidth: ProtoField(27, ScalarType.INT32, true),
+    thumbHeight: ProtoField(28, ScalarType.INT32, true),
+    showLen: ProtoField(29, ScalarType.INT32),
+    downloadLen: ProtoField(30, ScalarType.INT32),
+    x400Url: ProtoField(31, ScalarType.STRING, true),
+    x400Width: ProtoField(32, ScalarType.INT32),
+    x400Height: ProtoField(33, ScalarType.INT32),
+    pbRes: ProtoField(34, () => CustomFace_PbReserve, true),
+}
+
+export const CustomFace_PbReserve = {
+    subType: ProtoField(1, ScalarType.INT32),
+    summary: ProtoField(9, ScalarType.STRING),
+}
+
+export const ElemFlags2 = {
+    colorTextId: ProtoField(1, ScalarType.UINT32),
+    msgId: ProtoField(2, ScalarType.UINT64),
+    whisperSessionId: ProtoField(3, ScalarType.UINT32),
+    pttChangeBit: ProtoField(4, ScalarType.UINT32),
+    vipStatus: ProtoField(5, ScalarType.UINT32),
+    compatibleId: ProtoField(6, ScalarType.UINT32),
+    insts: ProtoField(7, () => Instance, false, true),
+    msgRptCnt: ProtoField(8, ScalarType.UINT32),
+    srcInst: ProtoField(9, () => Instance),
+    longtitude: ProtoField(10, ScalarType.UINT32),
+    latitude: ProtoField(11, ScalarType.UINT32),
+    customFont: ProtoField(12, ScalarType.UINT32),
+    pcSupportDef: ProtoField(13, () => PcSupportDef),
+    crmFlags: ProtoField(14, ScalarType.UINT32, true),
+}
+
+export const PcSupportDef = {
+    pcPtlBegin: ProtoField(1, ScalarType.UINT32),
+    pcPtlEnd: ProtoField(2, ScalarType.UINT32),
+    macPtlBegin: ProtoField(3, ScalarType.UINT32),
+    macPtlEnd: ProtoField(4, ScalarType.UINT32),
+    ptlsSupport: ProtoField(5, ScalarType.INT32, false, true),
+    ptlsNotSupport: ProtoField(6, ScalarType.UINT32, false, true),
+}
+
+export const Instance = {
+    appId: ProtoField(1, ScalarType.UINT32),
+    instId: ProtoField(2, ScalarType.UINT32),
+}
+
+export const RichMsg = {
+    template1: ProtoField(1, ScalarType.BYTES, true),
+    serviceId: ProtoField(2, ScalarType.INT32, true),
+    msgResId: ProtoField(3, ScalarType.BYTES, true),
+    rand: ProtoField(4, ScalarType.INT32, true),
+    seq: ProtoField(5, ScalarType.UINT32, true),
+}
+
+export const GroupFile = {
+    filename: ProtoField(1, ScalarType.BYTES),
+    fileSize: ProtoField(2, ScalarType.UINT64),
+    fileId: ProtoField(3, ScalarType.BYTES),
+    batchId: ProtoField(4, ScalarType.BYTES),
+    fileKey: ProtoField(5, ScalarType.BYTES),
+    mark: ProtoField(6, ScalarType.BYTES),
+    sequence: ProtoField(7, ScalarType.UINT64),
+    batchItemId: ProtoField(8, ScalarType.BYTES),
+    feedMsgTime: ProtoField(9, ScalarType.INT32),
+    pbReserve: ProtoField(10, ScalarType.BYTES),
+}
+
+export const ExtraInfo = {
+    nick: ProtoField(1, ScalarType.BYTES),
+    groupCard: ProtoField(2, ScalarType.BYTES),
+    level: ProtoField(3, ScalarType.INT32),
+    flags: ProtoField(4, ScalarType.INT32),
+    groupMask: ProtoField(5, ScalarType.INT32),
+    msgTailId: ProtoField(6, ScalarType.INT32),
+    senderTitle: ProtoField(7, ScalarType.BYTES),
+    apnsTips: ProtoField(8, ScalarType.BYTES),
+    uin: ProtoField(9, ScalarType.UINT64),
+    msgStateFlag: ProtoField(10, ScalarType.INT32),
+    apnsSoundType: ProtoField(11, ScalarType.INT32),
+    newGroupFlag: ProtoField(12, ScalarType.INT32),
+}
+
+export const VideoFile = {
+    fileUuid: ProtoField(1, ScalarType.STRING),
+    fileMd5: ProtoField(2, ScalarType.BYTES),
+    fileName: ProtoField(3, ScalarType.STRING),
+    fileFormat: ProtoField(4, ScalarType.INT32),
+    fileTime: ProtoField(5, ScalarType.INT32),
+    fileSize: ProtoField(6, ScalarType.INT32),
+    thumbWidth: ProtoField(7, ScalarType.INT32),
+    thumbHeight: ProtoField(8, ScalarType.INT32),
+    thumbFileMd5: ProtoField(9, ScalarType.BYTES),
+    source: ProtoField(10, ScalarType.BYTES),
+    thumbFileSize: ProtoField(11, ScalarType.INT32),
+    busiType: ProtoField(12, ScalarType.INT32),
+    fromChatType: ProtoField(13, ScalarType.INT32),
+    toChatType: ProtoField(14, ScalarType.INT32),
+    boolSupportProgressive: ProtoField(15, ScalarType.BOOL),
+    fileWidth: ProtoField(16, ScalarType.INT32),
+    fileHeight: ProtoField(17, ScalarType.INT32),
+    subBusiType: ProtoField(18, ScalarType.INT32),
+    videoAttr: ProtoField(19, ScalarType.INT32),
+    bytesThumbFileUrls: ProtoField(20, ScalarType.BYTES, false, true),
+    bytesVideoFileUrls: ProtoField(21, ScalarType.BYTES, false, true),
+    thumbDownloadFlag: ProtoField(22, ScalarType.INT32),
+    videoDownloadFlag: ProtoField(23, ScalarType.INT32),
+    pbReserve: ProtoField(24, ScalarType.BYTES),
+}
+
+export const AnonymousGroupMessage = {
+    flags: ProtoField(1, ScalarType.INT32),
+    anonId: ProtoField(2, ScalarType.BYTES),
+    anonNick: ProtoField(3, ScalarType.BYTES),
+    headPortrait: ProtoField(4, ScalarType.INT32),
+    expireTime: ProtoField(5, ScalarType.INT32),
+    bubbleId: ProtoField(6, ScalarType.INT32),
+    rankColor: ProtoField(7, ScalarType.BYTES),
+}
+
+export const CustomElem = {
+    desc: ProtoField(1, ScalarType.BYTES),
+    data: ProtoField(2, ScalarType.BYTES),
+    enumType: ProtoField(3, ScalarType.INT32),
+    ext: ProtoField(4, ScalarType.BYTES),
+    sound: ProtoField(5, ScalarType.BYTES),
+}
+
+export const GeneralFlags = {
+    bubbleDiyTextId: ProtoField(1, ScalarType.INT32),
+    groupFlagNew: ProtoField(2, ScalarType.INT32),
+    uin: ProtoField(3, ScalarType.UINT64),
+    rpId: ProtoField(4, ScalarType.BYTES),
+    prpFold: ProtoField(5, ScalarType.INT32),
+    longTextFlag: ProtoField(6, ScalarType.INT32),
+    longTextResId: ProtoField(7, ScalarType.STRING, true),
+    groupType: ProtoField(8, ScalarType.INT32),
+    toUinFlag: ProtoField(9, ScalarType.INT32),
+    glamourLevel: ProtoField(10, ScalarType.INT32),
+    memberLevel: ProtoField(11, ScalarType.INT32),
+    groupRankSeq: ProtoField(12, ScalarType.UINT64),
+    olympicTorch: ProtoField(13, ScalarType.INT32),
+    babyqGuideMsgCookie: ProtoField(14, ScalarType.BYTES),
+    uin32ExpertFlag: ProtoField(15, ScalarType.INT32),
+    bubbleSubId: ProtoField(16, ScalarType.INT32),
+    pendantId: ProtoField(17, ScalarType.UINT64),
+    rpIndex: ProtoField(18, ScalarType.BYTES),
+    pbReserve: ProtoField(19, ScalarType.BYTES),
+};
+
+export const SrcMsg = {
+    origSeqs: ProtoField(1, ScalarType.UINT32, false, true),
+    senderUin: ProtoField(2, ScalarType.UINT64),
+    time: ProtoField(3, ScalarType.INT32, true),
+    flag: ProtoField(4, ScalarType.INT32, true),
+    elems: ProtoField(5, () => Elem, false, true),
+    type: ProtoField(6, ScalarType.INT32, true),
+    richMsg: ProtoField(7, ScalarType.BYTES, true),
+    pbReserve: ProtoField(8, ScalarType.BYTES, true),
+    sourceMsg: ProtoField(9, ScalarType.BYTES, true),
+    toUin: ProtoField(10, ScalarType.UINT64, true),
+    troopName: ProtoField(11, ScalarType.BYTES, true),
+}
+
+export const LightAppElem = {
+    data: ProtoField(1, ScalarType.BYTES),
+    msgResid: ProtoField(2, ScalarType.BYTES, true),
+}
+
+export const CommonElem = {
+    serviceType: ProtoField(1, ScalarType.INT32),
+    pbElem: ProtoField(2, ScalarType.BYTES),
+    businessType: ProtoField(3, ScalarType.UINT32),
+}
+
+export const FaceExtra = {
+    faceId: ProtoField(1, ScalarType.INT32, true),
+}
+
+export const MentionExtra = {
+    type: ProtoField(3, ScalarType.INT32, true),
+    uin: ProtoField(4, ScalarType.UINT32, true),
+    field5: ProtoField(5, ScalarType.INT32, true),
+    uid: ProtoField(9, ScalarType.STRING, true),
+}
+
+export const QFaceExtra = {
+    field1: ProtoField(1, ScalarType.STRING, true),
+    field2: ProtoField(2, ScalarType.STRING, true),
+    faceId: ProtoField(3, ScalarType.INT32, true),
+    field4: ProtoField(4, ScalarType.INT32, true),
+    field5: ProtoField(5, ScalarType.INT32, true),
+    field6: ProtoField(6, ScalarType.STRING, true),
+    preview: ProtoField(7, ScalarType.STRING, true),
+    field9: ProtoField(9, ScalarType.INT32, true),
+}
+
+export const QSmallFaceExtra = {
+    faceId: ProtoField(1, ScalarType.UINT32),
+    preview: ProtoField(2, ScalarType.STRING),
+    preview2: ProtoField(3, ScalarType.STRING),
+}

src/core/packet/proto/message/group.ts

@@ -0,0 +1,19 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+export const GroupRecallMsg = {
+    type: ProtoField(1, ScalarType.UINT32),
+    groupUin: ProtoField(2, ScalarType.UINT32),
+    field3: ProtoField(3, () => GroupRecallMsgField3),
+    field4: ProtoField(4, () => GroupRecallMsgField4),
+};
+
+export const GroupRecallMsgField3 = {
+    sequence: ProtoField(1, ScalarType.UINT32),
+    random: ProtoField(2, ScalarType.UINT32),
+    field3: ProtoField(3, ScalarType.UINT32),
+};
+
+export const GroupRecallMsgField4 = {
+    field1: ProtoField(1, ScalarType.UINT32),
+};

src/core/packet/proto/message/message.ts

@@ -0,0 +1,75 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+import {ForwardHead, Grp, GrpTmp, ResponseForward, ResponseGrp, Trans0X211, WPATmp} from "@/core/packet/proto/message/routing";
+import {RichText} from "@/core/packet/proto/message/component";
+import {C2C} from "@/core/packet/proto/message/c2c";
+
+export const ContentHead = {
+    type: ProtoField(1, ScalarType.UINT32),
+    subType: ProtoField(2, ScalarType.UINT32, true),
+    divSeq: ProtoField(3, ScalarType.UINT32, true),
+    msgId: ProtoField(4, ScalarType.UINT32, true),
+    sequence: ProtoField(5, ScalarType.UINT32, true),
+    timeStamp: ProtoField(6, ScalarType.UINT32, true),
+    field7: ProtoField(7, ScalarType.UINT64, true),
+    field8: ProtoField(8, ScalarType.UINT32, true),
+    field9: ProtoField(9, ScalarType.UINT32, true),
+    newId: ProtoField(12, ScalarType.UINT64, true),
+    forward: ProtoField(15, () => ForwardHead, true),
+};
+
+export const MessageBody = {
+    richText: ProtoField(1, () => RichText, true),
+    msgContent: ProtoField(2, ScalarType.BYTES, true),
+    msgEncryptContent: ProtoField(3, ScalarType.BYTES, true),
+};
+
+export const Message = {
+    routingHead: ProtoField(1, () => RoutingHead, true),
+    contentHead: ProtoField(2, () => ContentHead, true),
+    body: ProtoField(3, () => MessageBody, true),
+    clientSequence: ProtoField(4, ScalarType.UINT32, true),
+    random: ProtoField(5, ScalarType.UINT32, true),
+    syncCookie: ProtoField(6, ScalarType.BYTES, true),
+    via: ProtoField(8, ScalarType.UINT32, true),
+    dataStatist: ProtoField(9, ScalarType.UINT32, true),
+    ctrl: ProtoField(12, () => MessageControl, true),
+    multiSendSeq: ProtoField(14, ScalarType.UINT32),
+};
+
+export const MessageControl = {
+    msgFlag: ProtoField(1, ScalarType.INT32),
+};
+
+export const PushMsg = {
+    message: ProtoField(1, () => PushMsgBody),
+    status: ProtoField(3, ScalarType.INT32, true),
+    pingFlag: ProtoField(5, ScalarType.INT32, true),
+    generalFlag: ProtoField(9, ScalarType.INT32, true),
+};
+
+export const PushMsgBody = {
+    responseHead: ProtoField(1, () => ResponseHead),
+    contentHead: ProtoField(2, () => ContentHead),
+    body: ProtoField(3, () => MessageBody, true),
+};
+
+export const ResponseHead = {
+    fromUin: ProtoField(1, ScalarType.UINT32),
+    fromUid: ProtoField(2, ScalarType.STRING, true),
+    type: ProtoField(3, ScalarType.UINT32),
+    sigMap: ProtoField(4, ScalarType.UINT32),
+    toUin: ProtoField(5, ScalarType.UINT32),
+    toUid: ProtoField(6, ScalarType.STRING, true),
+    forward: ProtoField(7, () => ResponseForward, true),
+    grp: ProtoField(8, () => ResponseGrp, true),
+};
+
+export const RoutingHead = {
+    c2c: ProtoField(1, () => C2C, true),
+    grp: ProtoField(2, () => Grp, true),
+    grpTmp: ProtoField(3, () => GrpTmp, true),
+    wpaTmp: ProtoField(6, () => WPATmp, true),
+    trans0X211: ProtoField(15, () => Trans0X211, true),
+};
+

src/core/packet/proto/message/notify.ts

@@ -0,0 +1,22 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+export const FriendRecall = {
+    info: ProtoField(1, () => FriendRecallInfo),
+    instId: ProtoField(2, ScalarType.UINT32),
+    appId: ProtoField(3, ScalarType.UINT32),
+    longMessageFlag: ProtoField(4, ScalarType.UINT32),
+    reserved: ProtoField(5, ScalarType.BYTES),
+};
+
+export const FriendRecallInfo = {
+    fromUid: ProtoField(1, ScalarType.STRING),
+    toUid: ProtoField(2, ScalarType.STRING),
+    sequence: ProtoField(3, ScalarType.UINT32),
+    newId: ProtoField(4, ScalarType.UINT64),
+    time: ProtoField(5, ScalarType.UINT32),
+    random: ProtoField(6, ScalarType.UINT32),
+    pkgNum: ProtoField(7, ScalarType.UINT32),
+    pkgIndex: ProtoField(8, ScalarType.UINT32),
+    divSeq: ProtoField(9, ScalarType.UINT32),
+};

src/core/packet/proto/message/routing.ts

@@ -0,0 +1,41 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+export const ForwardHead = {
+    field1: ProtoField(1, ScalarType.UINT32, true),
+    field2: ProtoField(2, ScalarType.UINT32, true),
+    field3: ProtoField(3, ScalarType.UINT32, true),
+    unknownBase64: ProtoField(5, ScalarType.STRING, true),
+    avatar: ProtoField(6, ScalarType.STRING, true),
+};
+
+export const Grp = {
+    groupCode: ProtoField(1, ScalarType.UINT32, true),
+};
+
+export const GrpTmp = {
+    groupUin: ProtoField(1, ScalarType.UINT32, true),
+    toUin: ProtoField(2, ScalarType.UINT32, true),
+};
+
+export const ResponseForward = {
+    friendName: ProtoField(6, ScalarType.STRING, true),
+};
+
+export const ResponseGrp = {
+    groupUin: ProtoField(1, ScalarType.UINT32),
+    memberName: ProtoField(4, ScalarType.STRING),
+    unknown5: ProtoField(5, ScalarType.UINT32),
+    groupName: ProtoField(7, ScalarType.STRING),
+};
+
+export const Trans0X211 = {
+    toUin: ProtoField(1, ScalarType.UINT64, true),
+    ccCmd: ProtoField(2, ScalarType.UINT32, true),
+    uid: ProtoField(8, ScalarType.STRING, true),
+};
+
+export const WPATmp = {
+    toUin: ProtoField(1, ScalarType.UINT64),
+    sig: ProtoField(2, ScalarType.BYTES),
+};

src/core/packet/proto/oidb/Oidb.0x8FC_2.ts

@@ -0,0 +1,16 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+
+//设置群头衔 OidbSvcTrpcTcp.0x8fc_2
+export const OidbSvcTrpcTcp0X8FC_2_Body = {
+    targetUid: ProtoField(1, ScalarType.STRING),
+    specialTitle: ProtoField(5, ScalarType.STRING),
+    expiredTime: ProtoField(6, ScalarType.SINT32),
+    uinName: ProtoField(7, ScalarType.STRING),
+    targetName: ProtoField(8, ScalarType.STRING),
+}
+export const OidbSvcTrpcTcp0X8FC_2 = {
+    groupUin: ProtoField(1, ScalarType.UINT32),
+    body: ProtoField(3, ScalarType.BYTES),
+}

src/core/packet/proto/oidb/Oidb.0x9067_202.ts

@@ -0,0 +1,26 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+import { MultiMediaReqHead } from "./common/Ntv2.RichMedia";
+
+//Req
+export const OidbSvcTrpcTcp0X9067_202 = {
+    ReqHead: ProtoField(1, () => MultiMediaReqHead),
+    DownloadRKeyReq: ProtoField(4, () => OidbSvcTrpcTcp0X9067_202Key),
+}
+export const OidbSvcTrpcTcp0X9067_202Key = {
+    key: ProtoField(1, ScalarType.INT32, false, true),
+}
+
+//Rsp
+export const OidbSvcTrpcTcp0X9067_202_RkeyList = {
+    rkey: ProtoField(1, ScalarType.STRING),
+    time: ProtoField(4, ScalarType.UINT32),
+    type: ProtoField(5, ScalarType.UINT32),
+
+}
+export const OidbSvcTrpcTcp0X9067_202_Data = {
+    rkeyList: ProtoField(1, () => OidbSvcTrpcTcp0X9067_202_RkeyList, false, true),
+}
+export const OidbSvcTrpcTcp0X9067_202_Rsp_Body = {
+    data: ProtoField(4, () => OidbSvcTrpcTcp0X9067_202_Data),
+}

src/core/packet/proto/oidb/Oidb.ed3_1.ts

@@ -0,0 +1,10 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+// Send Poke
+export const OidbSvcTrpcTcp0XED3_1 = {
+    uin: ProtoField(1, ScalarType.UINT32),
+    groupUin: ProtoField(2, ScalarType.UINT32),
+    friendUin: ProtoField(5, ScalarType.UINT32),
+    ext: ProtoField(6, ScalarType.UINT32, true)
+}

src/core/packet/proto/oidb/Oidb.fe1_2.ts

@@ -0,0 +1,23 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+export const OidbSvcTrpcTcp0XFE1_2 = {
+    uin: ProtoField(1, ScalarType.UINT32),
+    key: ProtoField(3, () => OidbSvcTrpcTcp0XFE1_2Key, false, true),
+}
+
+export const OidbSvcTrpcTcp0XFE1_2Key = {
+    key: ProtoField(1, ScalarType.UINT32)
+}
+export const OidbSvcTrpcTcp0XFE1_2RSP_Status = {
+    key: ProtoField(1, ScalarType.UINT32),
+    value: ProtoField(2, ScalarType.UINT64)
+}
+
+export const OidbSvcTrpcTcp0XFE1_2RSP_Data = {
+    status: ProtoField(2, () => OidbSvcTrpcTcp0XFE1_2RSP_Status)
+}
+
+export const OidbSvcTrpcTcp0XFE1_2RSP = {
+    data: ProtoField(1, () => OidbSvcTrpcTcp0XFE1_2RSP_Data)
+}

src/core/packet/proto/oidb/OidbBase.ts

@@ -0,0 +1,13 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+export const OidbSvcTrpcTcpBase = {
+    command: ProtoField(1, ScalarType.UINT32),
+    subCommand: ProtoField(2, ScalarType.UINT32),
+    body: ProtoField(4, ScalarType.BYTES),
+    errorMsg: ProtoField(5, ScalarType.STRING, true),
+    isReserved: ProtoField(12, ScalarType.UINT32)
+}
+export const OidbSvcTrpcTcpBaseRsp = {
+    body: ProtoField(4, ScalarType.BYTES)
+}

src/core/packet/proto/oidb/common/Ntv2.RichMedia.ts

@@ -0,0 +1,83 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../../NapProto";
+
+export const NTV2RichMediaReq = {
+    ReqHead: ProtoField(1, ScalarType.BYTES),
+    DownloadRKeyReq: ProtoField(4, ScalarType.BYTES),
+}
+export const MultiMediaReqHead = {
+    Common: ProtoField(1, () => CommonHead),
+    Scene: ProtoField(2, () => SceneInfo),
+    Client: ProtoField(3, () => ClientMeta),
+}
+export const CommonHead = {
+    RequestId: ProtoField(1, ScalarType.UINT32),
+    Command: ProtoField(2, ScalarType.UINT32),
+}
+export const SceneInfo = {
+    RequestType: ProtoField(101, ScalarType.UINT32),
+    BusinessType: ProtoField(102, ScalarType.UINT32),
+    SceneType: ProtoField(200, ScalarType.UINT32),
+}
+export const ClientMeta = {
+    AgentType: ProtoField(1, ScalarType.UINT32),
+}
+export const C2CUserInfo = {
+    AccountType: ProtoField(1, ScalarType.UINT32),
+    TargetUid: ProtoField(2, ScalarType.STRING),
+}
+export const GroupInfo = {
+    GroupUin: ProtoField(1, ScalarType.UINT32),
+}
+export const DownloadReq = {
+    Node: ProtoField(1, ScalarType.BYTES),
+    Download: ProtoField(2, ScalarType.BYTES),
+}
+export const FileInfo = {
+    FileSize: ProtoField(1, ScalarType.UINT32),
+    FileHash: ProtoField(2, ScalarType.STRING),
+    FileSha1: ProtoField(3, ScalarType.STRING),
+    FileName: ProtoField(4, ScalarType.STRING),
+    Type: ProtoField(5, ScalarType.BYTES),
+    Width: ProtoField(6, ScalarType.UINT32),
+    Height: ProtoField(7, ScalarType.UINT32),
+    Time: ProtoField(8, ScalarType.UINT32),
+    Original: ProtoField(9, ScalarType.UINT32),
+}
+export const IndexNode = {
+    Info: ProtoField(1, ScalarType.BYTES),
+    FileUuid: ProtoField(2, ScalarType.STRING),
+    StoreId: ProtoField(3, ScalarType.UINT32),
+    UploadTime: ProtoField(4, ScalarType.UINT32),
+    Ttl: ProtoField(5, ScalarType.UINT32),
+    subType: ProtoField(6, ScalarType.UINT32),
+}
+export const FileType = {
+    Type: ProtoField(1, ScalarType.UINT32),
+    PicFormat: ProtoField(2, ScalarType.UINT32),
+    VideoFormat: ProtoField(3, ScalarType.UINT32),
+    VoiceFormat: ProtoField(4, ScalarType.UINT32),
+}
+export const DownloadExt = {
+    Pic: ProtoField(1, ScalarType.BYTES),
+    Video: ProtoField(2, ScalarType.BYTES),
+    Ptt: ProtoField(3, ScalarType.BYTES),
+}
+export const VideoDownloadExt = {
+    BusiType: ProtoField(1, ScalarType.UINT32),
+    SceneType: ProtoField(2, ScalarType.UINT32),
+    SubBusiType: ProtoField(3, ScalarType.UINT32),
+}
+export const PicDownloadExt = {}
+export const PttDownloadExt = {}
+export const PicUrlExtInfo = {
+    OriginalParameter: ProtoField(1, ScalarType.STRING),
+    BigParameter: ProtoField(2, ScalarType.STRING),
+    ThumbParameter: ProtoField(3, ScalarType.STRING),
+}
+export const VideoExtInfo = {
+    VideoCodecFormat: ProtoField(1, ScalarType.UINT32),
+}
+export const MsgInfo = {
+
+}

src/core/packet/proto/old/Message.ts

@@ -0,0 +1,48 @@
+import { MessageType, BinaryReader, ScalarType } from '@protobuf-ts/runtime';
+
+export const BodyInner = new MessageType("BodyInner", [
+    { no: 1, name: "msgType", kind: "scalar", T: ScalarType.UINT32 /* uint32 */, opt: true },
+    { no: 2, name: "subType", kind: "scalar", T: ScalarType.UINT32 /* uint32 */, opt: true }
+]);
+
+export const NoifyData = new MessageType("NoifyData", [
+    { no: 1, name: "skip", kind: "scalar", T: ScalarType.BYTES /* bytes */, opt: true },
+    { no: 2, name: "innerData", kind: "scalar", T: ScalarType.BYTES /* bytes */, opt: true }
+]);
+
+export const MsgHead = new MessageType("MsgHead", [
+    { no: 2, name: "bodyInner", kind: "message", T: () => BodyInner, opt: true },
+    { no: 3, name: "noifyData", kind: "message", T: () => NoifyData, opt: true }
+]);
+
+export const Message = new MessageType("Message", [
+    { no: 1, name: "msgHead", kind: "message", T: () => MsgHead }
+]);
+
+export const SubDetail = new MessageType("SubDetail", [
+    { no: 1, name: "msgSeq", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 2, name: "msgTime", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 6, name: "senderUid", kind: "scalar", T: ScalarType.STRING /* string */ }
+]);
+
+export const RecallDetails = new MessageType("RecallDetails", [
+    { no: 1, name: "operatorUid", kind: "scalar", T: ScalarType.STRING /* string */ },
+    { no: 3, name: "subDetail", kind: "message", T: () => SubDetail }
+]);
+
+export const RecallGroup = new MessageType("RecallGroup", [
+    { no: 1, name: "type", kind: "scalar", T: ScalarType.INT32 /* int32 */ },
+    { no: 4, name: "peerUid", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 11, name: "recallDetails", kind: "message", T: () => RecallDetails },
+    { no: 37, name: "grayTipsSeq", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ }
+]);
+
+export function decodeMessage(buffer: Uint8Array): any {
+    const reader = new BinaryReader(buffer);
+    return Message.internalBinaryRead(reader, reader.len, { readUnknownField: true, readerFactory: () => new BinaryReader(buffer) });
+}
+
+export function decodeRecallGroup(buffer: Uint8Array): any {
+    const reader = new BinaryReader(buffer);
+    return RecallGroup.internalBinaryRead(reader, reader.len, { readUnknownField: true, readerFactory: () => new BinaryReader(buffer) });
+}

src/core/packet/proto/old/ProfileLike.ts

@@ -0,0 +1,58 @@
+import { MessageType, BinaryReader, ScalarType, RepeatType } from '@protobuf-ts/runtime';
+
+export const LikeDetail = new MessageType("likeDetail", [
+    { no: 1, name: "txt", kind: "scalar", T: ScalarType.STRING /* string */ },
+    { no: 3, name: "uin", kind: "scalar", T: ScalarType.INT64 /* int64 */ },
+    { no: 5, name: "nickname", kind: "scalar", T: ScalarType.STRING /* string */ }
+]);
+
+export const LikeMsg = new MessageType("likeMsg", [
+    { no: 1, name: "times", kind: "scalar", T: ScalarType.INT32 /* int32 */ },
+    { no: 2, name: "time", kind: "scalar", T: ScalarType.INT32 /* int32 */ },
+    { no: 3, name: "detail", kind: "message", T: () => LikeDetail }
+]);
+
+export const ProfileLikeSubTip = new MessageType("profileLikeSubTip", [
+    { no: 14, name: "msg", kind: "message", T: () => LikeMsg }
+]);
+export const ProfileLikeTip = new MessageType("profileLikeTip", [
+    { no: 1, name: "msgType", kind: "scalar", T: ScalarType.INT32 /* int32 */ },
+    { no: 2, name: "subType", kind: "scalar", T: ScalarType.INT32 /* int32 */ },
+    { no: 203, name: "content", kind: "message", T: () => ProfileLikeSubTip }
+]);
+export const SysMessageHeader = new MessageType("SysMessageHeader", [
+    { no: 1, name: "PeerNumber", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 2, name: "PeerString", kind: "scalar", T: ScalarType.STRING /* string */ },
+    { no: 5, name: "Uin", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 6, name: "Uid", kind: "scalar", T: ScalarType.STRING /* string */, opt: true }
+]);
+
+export const SysMessageMsgSpec = new MessageType("SysMessageMsgSpec", [
+    { no: 1, name: "msgType", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 2, name: "subType", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 3, name: "subSubType", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 5, name: "msgSeq", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 6, name: "time", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ },
+    { no: 12, name: "msgId", kind: "scalar", T: ScalarType.UINT64 /* uint64 */ },
+    { no: 13, name: "other", kind: "scalar", T: ScalarType.UINT32 /* uint32 */ }
+]);
+
+export const SysMessageBodyWrapper = new MessageType("SysMessageBodyWrapper", [
+    { no: 2, name: "wrappedBody", kind: "scalar", T: ScalarType.BYTES /* bytes */ }
+]);
+
+export const SysMessage = new MessageType("SysMessage", [
+    { no: 1, name: "header", kind: "message", T: () => SysMessageHeader, repeat: RepeatType.UNPACKED },
+    { no: 2, name: "msgSpec", kind: "message", T: () => SysMessageMsgSpec, repeat: RepeatType.UNPACKED },
+    { no: 3, name: "bodyWrapper", kind: "message", T: () => SysMessageBodyWrapper }
+]);
+
+export function decodeProfileLikeTip(buffer: Uint8Array): any {
+    const reader = new BinaryReader(buffer);
+    return ProfileLikeTip.internalBinaryRead(reader, reader.len, { readUnknownField: true, readerFactory: () => new BinaryReader(buffer) });
+}
+
+export function decodeSysMessage(buffer: Uint8Array): any {
+    const reader = new BinaryReader(buffer);
+    return SysMessage.internalBinaryRead(reader, reader.len, { readUnknownField: true, readerFactory: () => new BinaryReader(buffer) });
+}