bedrock-portal-nethernet 2.1.0 → 2.2.0

package/dist/nethernet/server.d.ts

@@ -1,17 +1,29 @@
 import { Connection } from './connection';
 import { Signal } from '../signaling/signal';
 import { SignalStructure } from '../signaling/struct';
+type PendingCandidate = {
+    signal: SignalStructure;
+    attempts: number;
+};
 export declare class Server {
     networkId: bigint;
     connectionId: bigint;
     signaling: Signal;
     connections: Map<bigint, Connection>;
+    pendingCandidates: Map<bigint, PendingCandidate[]>;
+    remoteDescriptionReady: Set<bigint>;
+    pendingCandidateTimers: Map<bigint, NodeJS.Timeout>;
     onOpenConnection: (conn: Connection) => void;
     onCloseConnection: (id: bigint, reason: string) => void;
     onEncapsulated: (packet: Buffer, id: bigint) => void;
     constructor(signaling: Signal, networkId?: bigint, connectionId?: bigint);
     handleCandidate(signal: SignalStructure): Promise<void>;
+    queueCandidate(signal: SignalStructure, reason?: string): void;
+    schedulePendingCandidateFlush(connectionId: bigint): void;
+    flushPendingCandidates(connectionId: bigint): void;
+    requeueCandidate(candidate: PendingCandidate, remaining: PendingCandidate[], reason: string): void;
     handleOffer(signal: SignalStructure): Promise<void>;
     listen(): Promise<void>;
     close(): void;
 }
+export {};

package/dist/nethernet/server.js

@@ -5,6 +5,8 @@ const node_datachannel_1 = require("node-datachannel");
 const connection_1 = require("./connection");
 const struct_1 = require("../signaling/struct");
 const debugFn = require('debug')('bedrock-portal-nethernet');
+const MAX_PENDING_CANDIDATE_ATTEMPTS = 50;
+const PENDING_CANDIDATE_RETRY_MS = 100;
 const getRandomUint64 = () => {
     const high = Math.floor(Math.random() * 0xFFFFFFFF);
     const low = Math.floor(Math.random() * 0xFFFFFFFF);
@@ -15,6 +17,9 @@ class Server {
     connectionId;
     signaling;
     connections;
+    pendingCandidates;
+    remoteDescriptionReady;
+    pendingCandidateTimers;
     onOpenConnection;
     onCloseConnection;
     onEncapsulated;
@@ -23,18 +28,78 @@ class Server {
         this.networkId = networkId;
         this.connectionId = connectionId;
         this.connections = new Map();
+        this.pendingCandidates = new Map();
+        this.remoteDescriptionReady = new Set();
+        this.pendingCandidateTimers = new Map();
         this.onOpenConnection = () => { };
         this.onCloseConnection = () => { };
         this.onEncapsulated = () => { };
     }
     async handleCandidate(signal) {
         const conn = this.connections.get(signal.connectionId);
-        if (conn) {
+        if (!conn || !this.remoteDescriptionReady.has(signal.connectionId)) {
+            this.queueCandidate(signal);
+            return;
+        }
+        try {
             conn.rtcConnection.addRemoteCandidate(signal.data, '0');
         }
+        catch (error) {
+            this.queueCandidate(signal, formatCandidateError(error));
+        }
+    }
+    queueCandidate(signal, reason = 'connection is not ready') {
+        const candidates = this.pendingCandidates.get(signal.connectionId) || [];
+        candidates.push({ signal, attempts: 0 });
+        this.pendingCandidates.set(signal.connectionId, candidates);
+        debugFn('Queued ICE candidate', signal.connectionId, reason);
+        this.schedulePendingCandidateFlush(signal.connectionId);
+    }
+    schedulePendingCandidateFlush(connectionId) {
+        if (this.pendingCandidateTimers.has(connectionId))
+            return;
+        const timer = setTimeout(() => {
+            this.pendingCandidateTimers.delete(connectionId);
+            this.flushPendingCandidates(connectionId);
+        }, PENDING_CANDIDATE_RETRY_MS);
+        timer.unref?.();
+        this.pendingCandidateTimers.set(connectionId, timer);
+    }
+    flushPendingCandidates(connectionId) {
+        const candidates = this.pendingCandidates.get(connectionId);
+        if (!candidates?.length)
+            return;
+        const conn = this.connections.get(connectionId);
+        const remaining = [];
+        for (const candidate of candidates) {
+            if (!conn || !this.remoteDescriptionReady.has(connectionId)) {
+                this.requeueCandidate(candidate, remaining, 'connection is not ready');
+                continue;
+            }
+            try {
+                conn.rtcConnection.addRemoteCandidate(candidate.signal.data, '0');
+            }
+            catch (error) {
+                this.requeueCandidate(candidate, remaining, formatCandidateError(error));
+            }
+        }
+        if (remaining.length) {
+            this.pendingCandidates.set(connectionId, remaining);
+            this.schedulePendingCandidateFlush(connectionId);
+        }
         else {
-            debugFn('Received candidate for unknown connection', signal);
+            this.pendingCandidates.delete(connectionId);
+        }
+    }
+    requeueCandidate(candidate, remaining, reason) {
+        if (candidate.attempts >= MAX_PENDING_CANDIDATE_ATTEMPTS) {
+            debugFn('Dropping ICE candidate after retries', candidate.signal.connectionId, reason);
+            return;
         }
+        remaining.push({
+            signal: candidate.signal,
+            attempts: candidate.attempts + 1,
+        });
     }
     async handleOffer(signal) {
         if (!this.signaling.credentials) {
@@ -55,10 +120,15 @@ class Server {
         rtcConnection.onIceStateChange(state => {
             if (state === 'connected')
                 this.onOpenConnection(connection);
-            if (state === 'disconnected')
+            if (state === 'disconnected') {
+                this.remoteDescriptionReady.delete(signal.connectionId);
+                this.pendingCandidates.delete(signal.connectionId);
                 this.onCloseConnection(signal.connectionId, 'disconnected');
+            }
         });
         rtcConnection.setRemoteDescription(signal.data, 'offer');
+        this.remoteDescriptionReady.add(signal.connectionId);
+        this.flushPendingCandidates(signal.connectionId);
         const answer = rtcConnection.localDescription();
         if (!answer) {
             throw new Error('No answer');
@@ -70,10 +140,14 @@ class Server {
         this.signaling.on('signal', (signal) => {
             switch (signal.type) {
                 case struct_1.SignalType.ConnectRequest:
-                    this.handleOffer(signal);
+                    this.handleOffer(signal).catch(error => {
+                        debugFn('Failed to handle connect offer', signal, error);
+                    });
                     break;
                 case struct_1.SignalType.CandidateAdd:
-                    this.handleCandidate(signal);
+                    this.handleCandidate(signal).catch(error => {
+                        debugFn('Failed to handle ICE candidate', signal, error);
+                    });
                     break;
                 default:
                     debugFn('Received signal for unknown type', signal);
@@ -81,9 +155,18 @@ class Server {
         });
     }
     close() {
+        for (const timer of this.pendingCandidateTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.pendingCandidateTimers.clear();
+        this.pendingCandidates.clear();
+        this.remoteDescriptionReady.clear();
         for (const conn of this.connections.values()) {
             conn.close();
         }
     }
 }
 exports.Server = Server;
+function formatCandidateError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/options.d.ts

@@ -1,6 +1,7 @@
 import { CompressionAlgorithm } from './transforms/framer';
 export type Options = {
     version: string;
+    signalingMode: 'rpc' | 'legacy';
     autoInitPlayer: boolean;
     offline: boolean;
     connectTimeout: number;
@@ -9,14 +10,5 @@ export type Options = {
     compressionThreshold: number;
     protocolVersion: number;
 };
-export declare const CURRENT_VERSION = "1.26.10";
-export declare const defaultOptions: {
-    version: string;
-    autoInitPlayer: boolean;
-    offline: boolean;
-    connectTimeout: number;
-    compressionAlgorithm: CompressionAlgorithm;
-    compressionLevel: number;
-    compressionThreshold: number;
-    protocolVersion: number;
-};
+export declare const CURRENT_VERSION = "1.26.20";
+export declare const defaultOptions: Options;

package/dist/options.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultOptions = exports.CURRENT_VERSION = void 0;
 const framer_1 = require("./transforms/framer");
 // Currently supported verson. Note, clients with newer versions can still connect as long as data is in minecraft-data
-exports.CURRENT_VERSION = '1.26.10';
+exports.CURRENT_VERSION = '1.26.20';
 exports.defaultOptions = {
     // https://minecraft.wiki/w/Protocol_version#Bedrock_Edition_2
     version: exports.CURRENT_VERSION,
+    signalingMode: 'rpc',
     // client: If we should send SetPlayerInitialized to the server after getting play_status spawn.
     // if this is disabled, no 'spawn' event will be emitted, you should manually set
     // client.status to ClientStatus.Initialized after sending the init packet.
@@ -22,5 +23,5 @@ exports.defaultOptions = {
     // server: If true, only compress if a payload is larger than compressionThreshold
     compressionThreshold: 512,
     // server and client: The protocol version to use
-    protocolVersion: 944,
+    protocolVersion: 975,
 };

package/dist/server.js

@@ -91,7 +91,7 @@ class Server extends tiny_typed_emitter_1.TypedEmitter {
         process.nextTick(() => client.onDecryptedPacket(buffer));
     };
     async listen(auth, networkId) {
-        this.signaling = new signal_1.Signal(auth, networkId, this.options.version);
+        this.signaling = new signal_1.Signal(auth, networkId, this.options.version, this.options.signalingMode);
         this.nethernet = new server_1.Server(this.signaling, networkId);
         await this.nethernet.listen();
         this.nethernet.onOpenConnection = this.onOpenConnection;

package/dist/serverPlayer.js

@@ -8,7 +8,6 @@ const tiny_typed_emitter_1 = require("tiny-typed-emitter");
 const loginVerify_1 = __importDefault(require("./handshake/loginVerify"));
 const keyExchange_1 = require("./handshake/keyExchange");
 const util_1 = require("./datatypes/util");
-const options_1 = require("./options");
 const framer_1 = require("./transforms/framer");
 const debug = require('debug')('bedrock-portal-nethernet');
 exports.ClientStatus = {
@@ -103,7 +102,7 @@ class Player extends tiny_typed_emitter_1.TypedEmitter {
         //     return false
         //   }
         // }
-        if (clientVersion < Number(options_1.CURRENT_VERSION)) {
+        if (clientVersion < this.server.options.protocolVersion) {
             this.sendDisconnectStatus('failed_client'); // client too old
             return false;
         }

package/dist/signaling/signal.d.ts

@@ -1,27 +1,45 @@
 import type { Authflow } from 'prismarine-auth';
 import { EventEmitter } from 'events';
 import { Data, ErrorEvent, WebSocket } from 'ws';
-import { SignalStructure } from './struct';
+import { NetworkId, SignalStructure } from './struct';
+type TurnServer = {
+    hostname: string;
+    port: number;
+    username?: string;
+    password?: string;
+};
+type JsonObject = Record<string, unknown>;
 export declare class Signal extends EventEmitter {
     ws: WebSocket | null;
-    networkId: bigint;
-    credentials: {
-        hostname: string;
-        port: number;
-        username: string;
-        password: string;
-    }[] | null;
+    networkId: NetworkId;
+    credentials: TurnServer[] | null;
     private authflow;
     private version;
     private pingInterval;
     private retryCount;
-    constructor(authflow: Authflow, networkId: bigint, version: string);
+    private pendingRequests;
+    private mode;
+    constructor(authflow: Authflow, networkId: NetworkId, version: string, signalingMode?: 'rpc' | 'legacy');
     connect(): Promise<void>;
     destroy(resume?: boolean): Promise<void>;
     init(): Promise<void>;
     onOpen(): void;
     onError(err: ErrorEvent): void;
     onClose(code: number, reason: string): void;
+    handleCloseCleanup(code: number, reason: string): void;
+    clearPing(): void;
+    rejectPending(error: Error): void;
+    startLegacyPing(): void;
+    onRpcOpen(): void;
     onMessage(res: Data): void;
+    onLegacyMessage(message: JsonObject): void;
+    onRpcMessage(message: JsonObject): void;
+    handleRpcResponse(message: JsonObject): void;
+    handleRpcRequest(message: JsonObject): void;
+    processIncomingRpcMessage(message: JsonObject): void;
+    sendRpcDeliveryAck(target: string, messageId: string): Promise<unknown>;
+    sendJsonRpcRequest(method: string, params: unknown): Promise<unknown>;
+    sendJsonRpcResult(id: string | number, result: unknown): void;
     write(signal: SignalStructure): void;
 }
+export {};

package/dist/signaling/signal.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Signal = void 0;
+const crypto_1 = require("crypto");
 const debug_1 = __importDefault(require("debug"));
 const json_bigint_1 = require("json-bigint");
 const events_1 = require("events");
@@ -14,6 +15,18 @@ const MessageType = {
     Signal: 1,
     Credentials: 2,
 };
+const Rpc = {
+    TurnAuth: 'Signaling_TurnAuth_v1_0',
+    SendMessage: 'Signaling_SendClientMessage_v1_0',
+    ReceiveMessage: 'Signaling_ReceiveMessage_v1_0',
+    Ping: 'System_Ping_v1_0',
+    Pong: 'System_Pong_v1_0',
+    WebRtc: 'Signaling_WebRtc_v1_0',
+    Delivery: 'Signaling_DeliveryNotification_V1_0',
+};
+const RPC_SIGNAL_URL = 'wss://signal.franchise.minecraft-services.net/ws/v1.0/messaging/connect';
+const LEGACY_SIGNAL_URL = 'wss://signal.franchise.minecraft-services.net/ws/v1.0/signaling';
+const SIGNALING_USER_AGENT = 'libHttpClient/1.0.0.0';
 const debug = (0, debug_1.default)('bedrock-portal-nethernet');
 class Signal extends events_1.EventEmitter {
     ws;
@@ -23,7 +36,9 @@ class Signal extends events_1.EventEmitter {
     version;
     pingInterval;
     retryCount;
-    constructor(authflow, networkId, version) {
+    pendingRequests;
+    mode;
+    constructor(authflow, networkId, version, signalingMode = 'rpc') {
         super();
         this.authflow = authflow;
         this.networkId = networkId;
@@ -32,6 +47,8 @@ class Signal extends events_1.EventEmitter {
         this.credentials = null;
         this.pingInterval = null;
         this.retryCount = 0;
+        this.pendingRequests = new Map();
+        this.mode = signalingMode;
     }
     async connect() {
         if (this.ws?.readyState === ws_1.WebSocket.OPEN)
@@ -41,22 +58,17 @@ class Signal extends events_1.EventEmitter {
     }
     async destroy(resume = false) {
         debug('Disconnecting from Signal');
-        if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-            this.pingInterval = null;
-        }
+        this.clearPing();
+        this.rejectPending(new Error('Signal disconnected'));
         if (this.ws) {
             this.ws.onmessage = null;
             this.ws.onclose = null;
-            const shouldClose = this.ws.readyState === ws_1.WebSocket.OPEN;
+            const shouldClose = this.ws.readyState === ws_1.WebSocket.OPEN || this.ws.readyState === ws_1.WebSocket.CONNECTING;
             if (shouldClose) {
-                let outerResolve;
-                const promise = new Promise((resolve) => {
-                    outerResolve = resolve;
+                await new Promise((resolve) => {
+                    this.ws.onclose = resolve;
+                    this.ws.close(1000, 'Normal Closure');
                 });
-                this.ws.onclose = outerResolve;
-                this.ws.close(1000, 'Normal Closure');
-                await promise;
             }
             this.ws.onerror = null;
         }
@@ -67,20 +79,27 @@ class Signal extends events_1.EventEmitter {
     async init() {
         const xbl = await this.authflow.getMinecraftBedrockServicesToken({ version: this.version });
         debug('Fetched XBL Token', xbl);
-        const address = `wss://signal.franchise.minecraft-services.net/ws/v1.0/signaling/${this.networkId}`;
+        this.mode = this.mode === 'legacy' ? 'legacy' : 'rpc';
+        const address = this.mode === 'legacy' ? `${LEGACY_SIGNAL_URL}/${this.networkId}` : RPC_SIGNAL_URL;
         debug('Connecting to Signal', address);
-        const ws = new ws_1.WebSocket(address, {
-            headers: { Authorization: xbl.mcToken },
-        });
-        this.pingInterval = setInterval(() => {
-            if (this.ws && this.ws.readyState === ws_1.WebSocket.OPEN) {
-                this.ws.send(JSON.stringify({ Type: MessageType.RequestPing }));
-            }
-        }, 5000);
+        const headers = this.mode === 'legacy'
+            ? { Authorization: xbl.mcToken }
+            : {
+                'Authorization': xbl.mcToken,
+                'User-Agent': SIGNALING_USER_AGENT,
+                'session-id': (0, crypto_1.randomUUID)(),
+                'request-id': (0, crypto_1.randomUUID)(),
+            };
+        const ws = new ws_1.WebSocket(address, { headers });
         ws.onopen = () => {
             this.onOpen();
+            if (this.mode === 'legacy')
+                this.startLegacyPing();
+            else
+                this.onRpcOpen();
         };
         ws.onclose = (event) => {
+            this.handleCloseCleanup(event.code, event.reason);
             this.onClose(event.code, event.reason);
         };
         ws.onerror = (event) => {
@@ -111,14 +130,79 @@ class Signal extends events_1.EventEmitter {
             }
         }
     }
+    handleCloseCleanup(code, reason) {
+        this.clearPing();
+        this.rejectPending(new Error(`Signal closed with code ${code}: ${reason || 'none'}`));
+    }
+    clearPing() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+    rejectPending(error) {
+        for (const pending of this.pendingRequests.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+    startLegacyPing() {
+        this.clearPing();
+        this.pingInterval = setInterval(() => {
+            if (this.ws && this.ws.readyState === ws_1.WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ Type: MessageType.RequestPing }));
+            }
+        }, 5000);
+        this.pingInterval.unref?.();
+    }
+    onRpcOpen() {
+        this.clearPing();
+        this.pingInterval = setInterval(() => {
+            if (this.ws && this.ws.readyState === ws_1.WebSocket.OPEN) {
+                this.sendJsonRpcRequest(Rpc.Ping, {}).catch(error => {
+                    debug('RPC ping failed', error);
+                });
+            }
+        }, 50000);
+        this.pingInterval.unref?.();
+        this.sendJsonRpcRequest(Rpc.TurnAuth, {})
+            .then((response) => {
+            this.credentials = parseTurnServers(response);
+            this.emit('credentials', this.credentials);
+        })
+            .catch((error) => {
+            debug('Failed to fetch JSON-RPC TURN credentials', error);
+            if (this.listenerCount('error') > 0)
+                this.emit('error', error);
+        });
+    }
     onMessage(res) {
+        if (Buffer.isBuffer(res))
+            res = res.toString('utf8');
         if (!(typeof res === 'string'))
             return debug('Recieved non-string message', res);
-        const message = JSON.parse(res);
+        let message;
+        try {
+            message = JSON.parse(res);
+        }
+        catch (error) {
+            debug('Failed to parse signaling message', res, error);
+            return;
+        }
         debug('Recieved message', message);
+        if (isRecord(message) && 'Type' in message) {
+            return this.onLegacyMessage(message);
+        }
+        if (isRecord(message)) {
+            return this.onRpcMessage(message);
+        }
+    }
+    onLegacyMessage(message) {
         switch (message.Type) {
             case MessageType.Credentials: {
-                if (message.From != 'Server') {
+                const from = getFirstString(message, ['From']);
+                if (from != 'Server') {
                     debug('received credentials from non-Server', 'message', message);
                     return;
                 }
@@ -127,7 +211,11 @@ class Signal extends events_1.EventEmitter {
                 break;
             }
             case MessageType.Signal: {
-                const signal = struct_1.SignalStructure.fromString(message.Message, BigInt(message.From));
+                const from = getFirstString(message, ['From']);
+                const payload = getFirstString(message, ['Message']);
+                if (!from || !payload)
+                    return;
+                const signal = struct_1.SignalStructure.fromString(payload, parseNetworkId(from));
                 this.emit('signal', signal);
                 break;
             }
@@ -136,31 +224,210 @@ class Signal extends events_1.EventEmitter {
             }
         }
     }
+    onRpcMessage(message) {
+        if (Object.prototype.hasOwnProperty.call(message, 'result') || (message.error && Object.prototype.hasOwnProperty.call(message, 'id'))) {
+            this.handleRpcResponse(message);
+        }
+        else if (message.method) {
+            this.handleRpcRequest(message);
+        }
+    }
+    handleRpcResponse(message) {
+        if (message.id === undefined || message.id === null)
+            return;
+        const id = String(message.id);
+        const pending = this.pendingRequests.get(id);
+        if (!pending)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(id);
+        if (message.error) {
+            const rpcError = isRecord(message.error) ? message.error : null;
+            const errorMessage = typeof rpcError?.message === 'string' ? rpcError.message : JSON.stringify(message.error);
+            pending.reject(new Error(errorMessage));
+            return;
+        }
+        pending.resolve(message.result || {});
+    }
+    handleRpcRequest(message) {
+        const id = message.id;
+        const hasResponseId = typeof id === 'string' || typeof id === 'number';
+        switch (typeof message.method === 'string' ? message.method : undefined) {
+            case Rpc.ReceiveMessage: {
+                if (hasResponseId)
+                    this.sendJsonRpcResult(id, null);
+                const params = Array.isArray(message.params) ? message.params : [];
+                for (const item of params) {
+                    this.processIncomingRpcMessage(item);
+                }
+                break;
+            }
+            case Rpc.Ping:
+            case Rpc.Pong: {
+                if (hasResponseId)
+                    this.sendJsonRpcResult(id, null);
+                break;
+            }
+            default:
+                debug('Unhandled RPC signaling method', message.method, message);
+        }
+    }
+    processIncomingRpcMessage(message) {
+        const from = getFirstString(message, ['From', 'from']);
+        const rawInner = getFirstString(message, ['Message', 'message']);
+        const messageId = getFirstString(message, ['Id', 'id']) || (0, crypto_1.randomUUID)();
+        if (!from || !rawInner) {
+            debug('Ignoring malformed RPC signal message', message);
+            return;
+        }
+        this.sendRpcDeliveryAck(from, messageId).catch(error => {
+            debug('Failed to send RPC delivery acknowledgement', error);
+        });
+        let inner;
+        try {
+            inner = JSON.parse(rawInner);
+        }
+        catch (error) {
+            debug('Failed to parse inner RPC signaling message', rawInner, error);
+            return;
+        }
+        if (!isRecord(inner) || inner.method !== Rpc.WebRtc) {
+            debug('Ignoring non-WebRTC RPC inner message', isRecord(inner) ? inner.method : undefined);
+            return;
+        }
+        const params = isRecord(inner.params) ? inner.params : null;
+        const payload = params?.message;
+        if (typeof payload !== 'string') {
+            debug('Ignoring RPC WebRTC message without string payload', inner);
+            return;
+        }
+        const signal = struct_1.SignalStructure.fromString(payload, parseNetworkId(from));
+        signal.rpcFrom = from;
+        this.emit('signal', signal);
+    }
+    sendRpcDeliveryAck(target, messageId) {
+        const innerMessage = {
+            params: { messageId },
+            jsonrpc: '2.0',
+            method: Rpc.Delivery,
+        };
+        return this.sendJsonRpcRequest(Rpc.SendMessage, {
+            toPlayerId: String(target),
+            messageId: (0, crypto_1.randomUUID)(),
+            message: JSON.stringify(innerMessage),
+        });
+    }
+    sendJsonRpcRequest(method, params) {
+        if (!this.ws || this.ws.readyState !== ws_1.WebSocket.OPEN) {
+            return Promise.reject(new Error('WebSocket not connected'));
+        }
+        const id = (0, crypto_1.randomUUID)();
+        const request = {
+            params,
+            jsonrpc: '2.0',
+            method,
+            id,
+        };
+        const promise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Timed out waiting for RPC response to ${method}`));
+            }, 30000);
+            timer.unref?.();
+            this.pendingRequests.set(id, { resolve, reject, timer });
+        });
+        this.ws.send(JSON.stringify(request));
+        return promise;
+    }
+    sendJsonRpcResult(id, result) {
+        if (!this.ws || this.ws.readyState !== ws_1.WebSocket.OPEN)
+            return;
+        this.ws.send(JSON.stringify({
+            id,
+            result,
+            jsonrpc: '2.0',
+        }));
+    }
     write(signal) {
         if (!this.ws)
             throw new Error('WebSocket not connected');
+        if (this.mode === 'rpc') {
+            const target = signal.rpcFrom || stringifyNetworkId(signal.networkId);
+            const innerMessage = {
+                params: {
+                    netherNetId: stringifyNetworkId(this.networkId),
+                    message: signal.toString(),
+                },
+                jsonrpc: '2.0',
+                method: Rpc.WebRtc,
+            };
+            this.sendJsonRpcRequest(Rpc.SendMessage, {
+                toPlayerId: String(target),
+                messageId: (0, crypto_1.randomUUID)(),
+                message: JSON.stringify(innerMessage),
+            }).catch(error => {
+                debug('Failed to send JSON-RPC signal', target, error);
+            });
+            return;
+        }
         const message = (0, json_bigint_1.stringify)({ Type: MessageType.Signal, To: signal.networkId, Message: signal.toString() });
         debug('Sending Signal', message);
         this.ws.send(message);
     }
 }
 exports.Signal = Signal;
+function parseNetworkId(value) {
+    if (typeof value === 'bigint')
+        return value;
+    const stringValue = String(value);
+    if (/^[0-9]+$/.test(stringValue)) {
+        try {
+            return BigInt(stringValue);
+        }
+        catch (_error) {
+            return stringValue;
+        }
+    }
+    return stringValue;
+}
+function stringifyNetworkId(value) {
+    return typeof value === 'bigint' ? value.toString() : String(value);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object';
+}
+function getFirstString(source, keys) {
+    if (!isRecord(source))
+        return undefined;
+    for (const key of keys) {
+        const value = source[key];
+        if (value !== undefined && value !== null)
+            return String(value);
+    }
+    return undefined;
+}
 function parseTurnServers(dataString) {
     const servers = [];
-    const data = JSON.parse(dataString);
-    if (!data.TurnAuthServers)
+    const data = typeof dataString === 'string' ? JSON.parse(dataString) : dataString;
+    if (!isRecord(data))
         return servers;
-    for (const server of data.TurnAuthServers) {
-        if (!server.Urls)
+    const turnServers = data.TurnAuthServers || data.turnAuthServers;
+    if (!Array.isArray(turnServers))
+        return servers;
+    for (const server of turnServers) {
+        if (!isRecord(server))
+            continue;
+        const urls = server.Urls || server.urls;
+        if (!Array.isArray(urls))
             continue;
-        for (const url of server.Urls) {
-            const match = url.match(/(stun|turn):([^:]+):(\d+)/);
+        for (const url of urls) {
+            const match = String(url).match(/^(stun|turn):(?:\[([^\]]+)\]|([^:/?]+)):(\d+)/);
             if (match) {
                 servers.push({
-                    hostname: match[2],
-                    port: parseInt(match[3], 10),
-                    username: server.Username || undefined,
-                    password: server.Password || undefined,
+                    hostname: match[2] || match[3],
+                    port: parseInt(match[4], 10),
+                    username: getFirstString(server, ['Username', 'username']),
+                    password: getFirstString(server, ['Password', 'password', 'Credential', 'credential']),
                 });
             }
         }

package/dist/signaling/struct.d.ts

@@ -1,3 +1,4 @@
+export type NetworkId = bigint | string;
 export declare const SignalType: {
     ConnectRequest: string;
     ConnectResponse: string;
@@ -8,8 +9,9 @@ export declare class SignalStructure {
     type: string;
     connectionId: bigint;
     data: string;
-    networkId: bigint;
-    constructor(type: string, connectionId: bigint, data: string, networkId: bigint);
+    networkId: NetworkId;
+    rpcFrom?: string;
+    constructor(type: string, connectionId: bigint, data: string, networkId: NetworkId);
     toString(): string;
-    static fromString(message: string, networkId: bigint): SignalStructure;
+    static fromString(message: string, networkId: NetworkId): SignalStructure;
 }

package/dist/signaling/struct.js

@@ -12,6 +12,7 @@ class SignalStructure {
     connectionId;
     data;
     networkId;
+    rpcFrom;
     constructor(type, connectionId, data, networkId) {
         this.type = type;
         this.connectionId = connectionId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bedrock-portal-nethernet",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "A simple server implementation for the Bedrock Edition Nethernet protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",