@serenityjs/raknet 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,829 @@
+import { BinaryStream, Endianness, Bool, Byte, Float32, Float64, Int8, Int16, Int24, Int32, Int64, Long, Short, String16, String32, Uint8, Uint16, Uint24, Uint32, Uint64, ULong, UShort, Uuid, VarInt, VarLong, VarString, ZigZag, ZigZong } from '@serenityjs/binarystream';
+import { Socket } from 'node:dgram';
+import { Emitter } from '@serenityjs/emitter';
+import { Logger } from '@serenityjs/logger';
+
+/**
+ * Represents a data type.
+ */
+declare abstract class DataType {
+    /**
+     * Creates a new data type.
+     */
+    constructor(..._arguments_: Array<unknown>);
+    /**
+     * Reads the data type from a binary stream.
+     * @param _stream The binary stream to read from.
+     * @param _endian The endianness to use.
+     * @param _parameter An optional parameter.
+     * @returns The data type.
+     */
+    static read(_stream: BinaryStream, _endian?: Endianness, _parameter?: unknown): unknown;
+    /**
+     * Writes the data type to a binary stream.
+     * @param _stream The binary stream to write to.
+     * @param _value The data type to write.
+     * @param _endian The endianness to use.
+     * @param _parameter An optional parameter.
+     */
+    static write(_stream: BinaryStream, _value: unknown, _endian?: Endianness, _parameter?: unknown): void;
+}
+
+/**
+ * Represents a magic data type.
+ * Magic is used when establishing a connection in RakNet.
+ */
+declare class Magic extends DataType {
+    /**
+     * Reads the magic data type from a binary stream.
+     * @param stream The binary stream to read from.
+     * @returns The magic data type.
+     */
+    static read(stream: BinaryStream): Buffer;
+    /**
+     * Writes the magic data type to a binary stream.
+     * @param stream The binary stream to write to.
+     */
+    static write(stream: BinaryStream): void;
+}
+
+/**
+ * Represents a maximum transmission unit data type.
+ * MTU is used when establishing a connection in RakNet.
+ */
+declare class MTU extends DataType {
+    /**
+     * Reads the mtu data type from a binary stream.
+     * @param stream The binary stream to read from.
+     * @returns The mtu data type.
+     */
+    static read(stream: BinaryStream): number;
+    /**
+     * Writes the mtu data type to a binary stream.
+     * @param stream The binary stream to write to.
+     * @param value The value to write.
+     */
+    static write(stream: BinaryStream, value: number): void;
+}
+
+type ValidTypes = typeof Bool | typeof Byte | typeof DataType | typeof Float32 | typeof Float64 | typeof Int8 | typeof Int16 | typeof Int24 | typeof Int32 | typeof Int64 | typeof Long | typeof Short | typeof String16 | typeof String32 | typeof Uint8 | typeof Uint16 | typeof Uint24 | typeof Uint32 | typeof Uint64 | typeof ULong | typeof UShort | typeof Uuid | typeof VarInt | typeof VarLong | typeof VarString | typeof ZigZag | typeof ZigZong;
+
+interface PacketMetadata {
+    endian: Endianness;
+    name: string;
+    parameter: string;
+    type: ValidTypes;
+}
+
+interface NetworkIdentifier {
+    address: string;
+    port: number;
+    version: number;
+}
+
+declare enum Packet {
+    ConnectedPing = 0,// 0
+    UnconnectedPing = 1,// 1
+    ConnectedPong = 3,// 3
+    OpenConnectionRequest1 = 5,// 5
+    OpenConnectionReply1 = 6,// 6
+    OpenConnectionRequest2 = 7,// 7
+    OpenConnectionReply2 = 8,// 8
+    ConnectionRequest = 9,// 9
+    ConnectionRequestAccepted = 16,// 16
+    NewIncomingConnection = 19,// 19
+    Disconnect = 21,// 21
+    IncompatibleProtocolVersion = 25,// 25
+    UnconnectedPong = 28,// 28
+    FrameSet = 128,// 128
+    Nack = 160,// 160
+    Ack = 192
+}
+
+declare enum Bitflags {
+    Valid = 128,
+    Ack = 64,
+    Nak = 32,
+    Split = 16
+}
+
+declare enum Priority {
+    Normal = 0,
+    Immediate = 1
+}
+
+declare enum Status {
+    Connecting = 0,
+    Connected = 1,
+    Disconnecting = 2,
+    Disconnected = 3
+}
+
+declare enum Reliability {
+    Unreliable = 0,
+    UnreliableSequenced = 1,
+    Reliable = 2,
+    ReliableOrdered = 3,
+    ReliableSequenced = 4,
+    UnreliableWithAckReceipt = 5,
+    ReliableWithAckReceipt = 6,
+    ReliableOrderedWithAckReceipt = 7
+}
+
+/**
+ * Represents a connection in the server
+ */
+declare class Connection {
+    /**
+     * The server instance
+     */
+    protected readonly server: RaknetServer;
+    /**
+     * The status of the connection
+     */
+    status: Status;
+    /**
+     * The network identifier of the connection
+     */
+    readonly identifier: NetworkIdentifier;
+    /**
+     * The GUID of the connection
+     */
+    readonly guid: bigint;
+    /**
+     * The maximum transmission unit of the connection
+     */
+    readonly mtu: number;
+    protected readonly receivedFrameSequences: Set<number>;
+    protected readonly lostFrameSequences: Set<number>;
+    protected readonly inputHighestSequenceIndex: Array<number>;
+    protected readonly fragmentsQueue: Map<number, Map<number, Frame>>;
+    protected readonly inputOrderIndex: Array<number>;
+    protected inputOrderingQueue: Map<number, Map<number, Frame>>;
+    protected lastInputSequence: number;
+    protected readonly outputBackupQueue: Map<number, Frame[]>;
+    protected readonly outputOrderIndex: Array<number>;
+    protected readonly outputSequenceIndex: Array<number>;
+    protected outputFrameQueue: FrameSet;
+    protected outputSequence: number;
+    protected outputReliableIndex: number;
+    protected outputFragmentIndex: number;
+    /**
+     * Creates a new connection
+     * @param server The server instance
+     * @param identifier The network identifier
+     * @param guid The GUID
+     * @param mtu The maximum transmission unit
+     */
+    constructor(server: RaknetServer, identifier: NetworkIdentifier, guid: bigint, mtu: number);
+    /**
+     * Ticks the connection
+     */
+    tick(): void;
+    /**
+     * Sends a buffer to the connection
+     */
+    send(buffer: Buffer): void;
+    /**
+     * Disconnects the connection
+     */
+    disconnect(): void;
+    /**
+     * Handles incoming packets
+     * @param buffer The packet buffer
+     */
+    incoming(buffer: Buffer): void;
+    /**
+     * Handles incoming batch packets
+     * @param buffer The packet buffer
+     */
+    incomingBatch(buffer: Buffer): void;
+    /**
+     * Handles incoming acks
+     * @param buffer The packet buffer
+     */
+    private handleIncomingAck;
+    /**
+     * Handles incoming nacks
+     * @param buffer The packet buffer
+     */
+    private handleIncomingNack;
+    /**
+     * Handles incoming framesets
+     * @param buffer The packet buffer
+     */
+    private handleIncomingFrameSet;
+    /**
+     * Handles incoming frames
+     * @param frame The frame
+     */
+    private handleFrame;
+    /**
+     * Handles fragmented frames
+     * @param frame The frame
+     */
+    private handleFragment;
+    /**
+     * Sends a frame to the connection.
+     *
+     * @param frame - The frame to send
+     * @param priority - The priority of the frame
+     */
+    sendFrame(frame: Frame, priority: Priority): void;
+    /**
+     * Adds a frame to the output queue
+     * @param frame The frame
+     * @param priority The priority
+     */
+    private addFrameToQueue;
+    /**
+     * Sends the output frame queue
+     */
+    sendFrameQueue(): void;
+    /**
+     * Sends a frame set to the connection
+     * @param frameset The frame set
+     */
+    private sendFrameSet;
+    /**
+     * Handles an incoming connection request
+     * @param buffer The packet buffer
+     */
+    private handleIncomingConnectionRequest;
+    /**
+     * Handles an incoming connected ping
+     * @param buffer The packet buffer
+     */
+    private handleIncomingConnectedPing;
+}
+
+/**
+ * The raknet server
+ */
+declare class RaknetServer extends Emitter<RaknetEvents> {
+    /**
+     * The server tick interval
+     */
+    protected interval: NodeJS.Timeout | null;
+    /**
+     * The raknet server logger
+     */
+    readonly logger: Logger;
+    /**
+     * The server socket
+     */
+    readonly socket: Socket;
+    /**
+     * The server address
+     */
+    readonly address: string;
+    /**
+     * The server port
+     */
+    readonly port: number;
+    /**
+     * The server guid
+     */
+    readonly guid: bigint;
+    /**
+     * The server connections
+     */
+    readonly connections: Map<string, Connection>;
+    /**
+     * The server protocol
+     */
+    protocol: number | null;
+    /**
+     * The server version
+     */
+    version: string | null;
+    /**
+     * The server message
+     */
+    message: string | null;
+    /**
+     * The server max connections
+     */
+    maxConnections: number | null;
+    /**
+     * Creates a new raknet server
+     * @param address the server address
+     * @param port the server port
+     */
+    constructor(address: string, port?: number);
+    /**
+     * Starts the server
+     */
+    start(): void;
+    /**
+     * Stops the server
+     */
+    stop(): void;
+    /**
+     * Sends a buffer to the specified network identifier
+     * @param buffer the buffer to send
+     * @param identifier the network identifier to send the buffer to
+     */
+    send(buffer: Buffer, identifier: NetworkIdentifier): void;
+    /**
+     * Handles incoming packets
+     * @param buffer the packet buffer
+     * @param rinfo the remote info
+     */
+    private incoming;
+}
+
+/**
+ * Handles all ofline raknet server operations
+ */
+declare class Offline {
+    /**
+     * The server instance
+     */
+    static server: RaknetServer;
+    /**
+     * Handles all incoming offline packets
+     * @param buffer The packet buffer
+     * @param identifier The network identifier
+     */
+    static incoming(buffer: Buffer, identifier: NetworkIdentifier): void;
+    /**
+     * Handles an unconnected ping
+     * @param buffer The packet buffer
+     * @param identifier The network identifier
+     */
+    private static handleUnconnectedPing;
+    /**
+     * Handles an open connection request 1
+     * @param buffer The packet buffer
+     * @param identifier The network identifier
+     */
+    private static handleOpenConnectionRequest1;
+    /**
+     * Handles an open connection request 2
+     * @param buffer The packet buffer
+     * @param identifier The network identifier
+     */
+    private static handleOpenConnectionRequest2;
+}
+
+interface RaknetEvents {
+    error: [Error];
+    connect: [Connection];
+    disconnect: [Connection];
+    encapsulated: [Connection, Buffer];
+}
+
+/**
+ * Represents an address data type.
+ * Address is used when establishing a connection in RakNet.
+ */
+declare class Address extends DataType {
+    /**
+     * The address of the data type.
+     */
+    address: string;
+    /**
+     * The port of the data type.
+     */
+    port: number;
+    /**
+     * The version of the data type.
+     */
+    version: number;
+    /**
+     * Initializes a new instance of the Address data type.
+     * @param address The address of the data type.
+     * @param port The port of the data type.
+     * @param version The version of the data type.
+     */
+    constructor(address: string, port: number, version: number);
+    /**
+     * Converts the Address data type to a NetworkIdentifier.
+     *
+     * @param identifier The NetworkIdentifier.
+     * @returns The NetworkIdentifier.
+     */
+    static fromIdentifier(identifier: NetworkIdentifier): Address;
+    /**
+     * Reads the Address data type from a binary stream.
+     * @param stream The binary stream to read from.
+     * @returns The Address data type.
+     */
+    static read(stream: BinaryStream): Address;
+    /**
+     * Writes the Address data type to a binary stream.
+     * @param stream The binary stream to write to.
+     * @param value The value to write.
+     */
+    static write(stream: BinaryStream, value: Address): void;
+}
+
+/**
+ * Represents a frame data type.
+ * Frame is used when sending data in RakNet.
+ */
+declare class Frame extends DataType {
+    /**
+     * The reliability of the frame.
+     */
+    reliability: Reliability;
+    /**
+     * The reliable index of the frame.
+     */
+    reliableIndex: number;
+    /**
+     * The sequence index of the frame.
+     */
+    sequenceIndex: number;
+    /**
+     * The order index of the frame.
+     */
+    orderIndex: number;
+    /**
+     * The order channel of the frame.
+     */
+    orderChannel: number;
+    /**
+     * The fragment size of the frame.
+     */
+    fragmentSize: number;
+    /**
+     * The fragment id of the frame.
+     */
+    fragmentId: number;
+    /**
+     * The fragment index of the frame.
+     */
+    fragmentIndex: number;
+    /**
+     * The payload of the frame.
+     */
+    payload: Buffer;
+    /**
+     * Checks if the frame is fragmented.
+     * @returns True if the frame is fragmented; otherwise, false.
+     */
+    isFragmented(): boolean;
+    /**
+     * Checks if the frame is reliable.
+     * @returns True if the frame is reliable; otherwise, false.
+     */
+    isReliable(): boolean;
+    /**
+     * Checks if the frame is sequenced.
+     * @returns True if the frame is sequenced; otherwise, false.
+     */
+    isSequenced(): boolean;
+    /**
+     * Checks if the frame is ordered.
+     * @returns True if the frame is ordered; otherwise, false.
+     */
+    isOrdered(): boolean;
+    /**
+     * Checks if the frame is order exclusive.
+     * @returns True if the frame is order exclusive; otherwise, false.
+     */
+    isOrderExclusive(): boolean;
+    /**
+     * Gets the byte length of the frame.
+     * @returns The byte length of the frame.
+     */
+    getByteLength(): number;
+    /**
+     * Reads the Frame data type from a binary stream.
+     * @param stream The binary stream to read from.
+     * @returns The Frame data type.
+     */
+    static read(stream: BinaryStream): Array<Frame>;
+    /**
+     * Writes the Frame data type to a binary stream.
+     * @param stream The binary stream to write to.
+     */
+    static write(stream: BinaryStream, value: Array<Frame>): void;
+}
+
+/**
+ * Represents an address data type.
+ * Address is used when establishing a connection in RakNet.
+ */
+declare class SystemAddress extends DataType {
+    /**
+     * Converts the Address data type to a NetworkIdentifier.
+     *
+     * @param identifier The NetworkIdentifier.
+     * @returns The NetworkIdentifier.
+     */
+    static fromIdentifier(identifier: NetworkIdentifier): Address;
+    /**
+     * Reads the Address data type from a binary stream.
+     * @param stream The binary stream to read from.
+     * @returns The Address data type.
+     */
+    static read(stream: BinaryStream): Array<Address>;
+    /**
+     * Writes the Address data type to a binary stream.
+     * @param stream The binary stream to write to.
+     * @param value The value to write.
+     */
+    static write(stream: BinaryStream): void;
+}
+
+/**
+ * Represents a packet.
+ */
+declare abstract class BasePacket extends BinaryStream {
+    /**
+     * The packet id.
+     */
+    static id: number;
+    /**
+     * The packet id data type.
+     */
+    static id_type: ValidTypes;
+    /**
+     * Flushes the binary stream.
+     */
+    flush(): void;
+    /**
+     * Gets the packet id.
+     * @returns The packet id.
+     */
+    getId(): number;
+    /**
+     * Gets the packet id data type.
+     * @returns The packet id data type.
+     */
+    getIdType(): ValidTypes;
+    /**
+     * Serializes the packet.
+     * @returns The serialized packet.
+     */
+    serialize(): Buffer;
+    /**
+     * Deserializes the packet.
+     */
+    deserialize(): this;
+}
+
+/**
+ * Represents an unconnected ping packet.
+ */
+declare class UnconnectedPing extends BasePacket {
+    /**
+     * The timestamp of the ping.
+     */
+    timestamp: bigint;
+    /**
+     * The magic bytes of the ping.
+     */
+    magic: Buffer;
+    /**
+     * The client guid of the ping.
+     */
+    client: bigint;
+}
+
+/**
+ * Represents an unconnected pong packet.
+ */
+declare class UnconnectedPong extends BasePacket {
+    /**
+     * The timestamp of the pong.
+     */
+    timestamp: bigint;
+    /**
+     * The server guid of the pong.
+     */
+    guid: bigint;
+    /**
+     * The magic bytes of the pong.
+     */
+    magic: Buffer;
+    /**
+     * The server message of the pong.
+     */
+    message: string;
+}
+
+/**
+ * Represents an open connection request 1 packet.
+ */
+declare class OpenConnectionRequest1 extends BasePacket {
+    /**
+     * The magic bytes of the request.
+     */
+    magic: Buffer;
+    /**
+     * The protocol version of the request.
+     */
+    protocol: number;
+    /**
+     * The maximum transfer unit of the request.
+     */
+    mtu: number;
+}
+
+/**
+ * Represents an open connection reply 1 packet.
+ */
+declare class OpenConnectionReply1 extends BasePacket {
+    /**
+     * The magic bytes of the reply.
+     */
+    magic: Buffer;
+    /**
+     * The server guid of the reply.
+     */
+    guid: bigint;
+    /**
+     * If raknet is using security.
+     */
+    security: boolean;
+    /**
+     * The maximum transfer unit of the reply.
+     */
+    mtu: number;
+}
+
+/**
+ * Represents an open connection request 2 packet.
+ */
+declare class OpenConnectionRequest2 extends BasePacket {
+    /**
+     * The magic bytes of the request.
+     */
+    magic: Buffer;
+    /**
+     * The protocol version of the request.
+     */
+    address: Address;
+    /**
+     * The mtu of the request.
+     */
+    mtu: number;
+    /**
+     * The client guid of the request.
+     */
+    client: bigint;
+}
+
+/**
+ * Represents an open connection reply 2 packet.
+ */
+declare class OpenConnectionReply2 extends BasePacket {
+    /**
+     * The magic bytes of the reply.
+     */
+    magic: Buffer;
+    /**
+     * The server guid of the reply.
+     */
+    guid: bigint;
+    /**
+     * Client adrress.
+     */
+    address: Address;
+    /**
+     * The maximum transfer unit of the reply.
+     */
+    mtu: number;
+    /**
+     * If raknet is using encryption.
+     */
+    encryption: boolean;
+}
+
+/**
+ * Represents an connected pong packet.
+ */
+declare class ConnectedPong extends BasePacket {
+    /**
+     * The timestamp of the ping.
+     */
+    pingTimestamp: bigint;
+    /**
+     * The timestamp of the pong.
+     */
+    timestamp: bigint;
+}
+
+/**
+ * Represents an connected ping packet.
+ */
+declare class ConnectedPing extends BasePacket {
+    /**
+     * The timestamp of the ping.
+     */
+    timestamp: bigint;
+}
+
+/**
+ * Represents an connection request packet.
+ */
+declare class ConnectionRequest extends BasePacket {
+    /**
+     * The client guid of the request.
+     */
+    client: bigint;
+    /**
+     * The timestamp of the request.
+     */
+    timestamp: bigint;
+}
+
+/**
+ * Represents a frame set packet.
+ * This packet hold multiple frames.
+ */
+declare class FrameSet extends BasePacket {
+    /**
+     * The sequence of the frame set.
+     */
+    sequence: number;
+    /**
+     * The frames of the frame set.
+     */
+    frames: Array<Frame>;
+}
+
+declare class Ack extends BasePacket {
+    sequences: Array<number>;
+    serialize(): Buffer;
+    deserialize(): this;
+}
+
+declare class Nack extends BasePacket {
+    sequences: Array<number>;
+    serialize(): Buffer;
+    deserialize(): this;
+}
+
+/**
+ * Represents a disconnect packet.
+ */
+declare class Disconnect extends BasePacket {
+}
+
+/**
+ * Represents an connection request accepted packet.
+ */
+declare class ConnectionRequestAccepted extends BasePacket {
+    /**
+     * The client address of the request.
+     */
+    address: Address;
+    /**
+     * The system index of the request.
+     */
+    systemIndex: number;
+    /**
+     * The system address of the request.
+     */
+    systemAddress: Array<Address>;
+    /**
+     * The request timestamp of the request.
+     */
+    requestTimestamp: bigint;
+    /**
+     * The timestamp of the request.
+     */
+    timestamp: bigint;
+}
+
+/**
+ * Proto decorator for packet classes.
+ *
+ * @param id Packet id.
+ * @returns The packet decorator.
+ */
+declare function Proto(id: number): (target: typeof BasePacket) => void;
+
+declare function Serialize(type: ValidTypes, endian?: Endianness, parameter?: string): (target: BasePacket, name: string) => void;
+
+/**
+ * Raknet protocol version.
+ */
+declare const Protocol = 11;
+/**
+ * The tick rate of the Raknet protocol.
+ */
+declare const RaknetTPS = 100;
+/**
+ * The length of a Raknet tick in seconds.
+ */
+declare const RaknetTickLength: number;
+/**
+ * The size of a UDP header.
+ */
+declare const udpHeaderSize = 28;
+/**
+ * The minimum size of a Raknet packet.
+ */
+declare const MinMtuSize = 400;
+/**
+ * The maximum size of a Raknet packet.
+ */
+declare const MaxMtuSize = 1492;
+
+export { Ack, Address, BasePacket, Bitflags, ConnectedPing, ConnectedPong, Connection, ConnectionRequest, ConnectionRequestAccepted, DataType, Disconnect, Frame, FrameSet, MTU, Magic, MaxMtuSize, MinMtuSize, Nack, type NetworkIdentifier, Offline, OpenConnectionReply1, OpenConnectionReply2, OpenConnectionRequest1, OpenConnectionRequest2, Packet, type PacketMetadata, Priority, Proto, Protocol, type RaknetEvents, RaknetServer, RaknetTPS, RaknetTickLength, Reliability, Serialize, Status, SystemAddress, UnconnectedPing, UnconnectedPong, type ValidTypes, udpHeaderSize };