@hytopia.com/server-protocol 1.3.51 → 1.3.52-dev.webrtc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hytopia.com/server-protocol",
-  "version": "1.3.51",
+  "version": "1.3.52-dev.webrtc",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -12,7 +12,8 @@
   },
   "dependencies": {
     "@hytopia.com/server-protocol": "^1.1.3",
-    "ajv": "^8.17.1"
+    "ajv": "^8.17.1",
+    "mediasoup": "^3.15.7"
   },
   "repository": {
     "type": "git",

package/packets/PacketCore.ts

@@ -41,6 +41,9 @@ export enum PacketId {
   LIGHTS = 44,
   PLAYERS = 45,
 
+  // Standard Bi-Directional Packet Types: 116 - 127 range
+  CONNECTION = 116,
+
   // Debug Inbound Packet Types: 128 - 191 range
   DEBUG_CONFIG = 128,
 

package/packets/PacketDefinitions.ts

@@ -1,12 +1,13 @@
+import * as bidirectionalPackets from './bidirectional';
 import * as inboundPackets from './inbound';
 import * as outboundPackets from './outbound';
 import type { PacketId, AnyPacket, AnyPacketDefinition, IPacket } from './PacketCore';
 
-export { inboundPackets, outboundPackets };
+export { bidirectionalPackets, inboundPackets, outboundPackets };
 
 export const registeredPackets = new Map<PacketId, AnyPacketDefinition>();
 
-const allPackets = { ...inboundPackets, ...outboundPackets };
+const allPackets = { ...bidirectionalPackets, ...inboundPackets, ...outboundPackets };
 
 for (const packet of Object.values(allPackets)) {
   if ('id' in packet && 'schema' in packet) {

package/packets/bidirectional/Connection.ts

@@ -0,0 +1,11 @@
+import { definePacket, PacketId } from '../PacketCore';
+import type { IPacket } from '../PacketCore';
+import { connectionSchema } from '../../schemas/Connection';
+import type { ConnectionSchema } from '../../schemas/Connection';
+
+export type ConnectionPacket = IPacket<typeof PacketId.CONNECTION, ConnectionSchema>;
+
+export const connectionPacketDefinition = definePacket(
+  PacketId.CONNECTION,
+  connectionSchema
+);

package/packets/bidirectional/index.ts

@@ -0,0 +1 @@
+export * from './Connection';

package/schemas/Connection.ts

@@ -0,0 +1,184 @@
+import * as mediasoup from 'mediasoup';
+import { JSONSchemaType } from 'ajv';
+
+/**
+ * Types
+ */
+
+type WrtcConnectAck = {
+  i: string; // transport id
+}
+
+type WrtcDataChannel = {
+  i: string;                               // data channel id
+  di: string;                              // data producer id
+  l: string;                               // label
+  s: mediasoup.types.SctpStreamParameters; // sctp stream parameters
+}
+
+type WrtcProduceDataAck = {
+  i: string; // producer id
+}
+
+type WrtcTransport = {
+  i: string;                          // transport id
+  ip: mediasoup.types.IceParameters;  // ice parameters
+  ic: mediasoup.types.IceCandidate[]; // ice candidates
+  d: mediasoup.types.DtlsParameters;  // dtls parameters
+  s: mediasoup.types.SctpParameters;  // sctp parameters
+}
+
+type WrtcTransportConnect = {
+  i: string;                         // transport id
+  d: mediasoup.types.DtlsParameters; // dtls parameters
+}
+
+export type ConnectionSchema = {
+  c?: WrtcTransportConnect[], // wrtc transport connect | client -> server  | 3rd wrtc packet
+  ca?: WrtcConnectAck[],      // wrtc connect ack       | server -> client  | 4th wrtc packet
+  d?: WrtcDataChannel[],      // wrtc data channels     | server <-> client | 2nd wrtc packet s->c, 5th wrtc packet c->s
+  p?: 'wss' | 'wrtc';         // protocol switch signal | client -> server  | 1st wrtc packet (send 'wrtc')
+  pa?: WrtcProduceDataAck[],  // wrtc produce data ack  | server -> client  | 6th wrtc packet
+  t?: WrtcTransport[],        // wrtc transports        | server -> client  | 2nd wrtc packet
+};
+
+/**
+ * Schemas
+ */
+
+const wrtcConnectAckSchema: JSONSchemaType<WrtcConnectAck> = {
+  type: 'object',
+  properties: {
+    i: { type: 'string' },
+  },
+  required: [ 'i' ],
+  additionalProperties: false,
+};
+
+const wrtcDtlsParametersSchema: JSONSchemaType<mediasoup.types.DtlsParameters> = {
+  type: 'object',
+  properties: {
+    role: { type: 'string', enum: [ 'auto', 'client', 'server' ], nullable: true },
+    fingerprints: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          algorithm: { type: 'string', enum: [ 'sha-1', 'sha-224', 'sha-256', 'sha-384', 'sha-512' ] },
+          value: { type: 'string' },
+        },
+        required: [ 'algorithm', 'value' ],
+      }
+    },
+  },
+  required: [ 'fingerprints' ],
+  additionalProperties: false,
+};
+
+const wrtcIceCandidateSchema: JSONSchemaType<mediasoup.types.IceCandidate> = {
+  type: 'object',
+  properties: {
+    foundation: { type: 'string' },
+    priority: { type: 'number' },
+    ip: { type: 'string' },
+    address: { type: 'string' },
+    protocol: { type: 'string', enum: [ 'udp', 'tcp' ] },
+    port: { type: 'number' },
+    type: { type: 'string', enum: [ 'host' ] },
+    tcpType: { type: 'string', enum: [ 'passive' ], nullable: true },
+  },
+  required: [ 'foundation', 'priority', 'ip', 'address', 'protocol', 'port', 'type' ],
+  additionalProperties: false,
+};
+
+const wrtcIceParametersSchema: JSONSchemaType<mediasoup.types.IceParameters> = {
+  type: 'object',
+  properties: {
+    usernameFragment: { type: 'string' },
+    password: { type: 'string' },
+    iceLite: { type: 'boolean', nullable: true },
+  },
+  required: [ 'usernameFragment', 'password' ],
+  additionalProperties: false,
+};
+
+const wrtcProduceDataAckSchema: JSONSchemaType<WrtcProduceDataAck> = {
+  type: 'object',
+  properties: {
+    i: { type: 'string' },
+  },
+  required: [ 'i' ],
+  additionalProperties: false,
+};
+
+const wrtcSctpParametersSchema: JSONSchemaType<mediasoup.types.SctpParameters> = {
+  type: 'object',
+  properties: {
+    port: { type: 'number' },
+    OS: { type: 'number' },
+    MIS: { type: 'number' },
+    maxMessageSize: { type: 'number' },
+  },
+  required: [ 'port', 'OS', 'MIS', 'maxMessageSize' ],
+  additionalProperties: false,
+};
+
+const wrtcSctpStreamParametersSchema: JSONSchemaType<mediasoup.types.SctpStreamParameters> = {
+  type: 'object',
+  properties: {
+    streamId: { type: 'number' },
+    ordered: { type: 'boolean', nullable: true },
+    maxPacketLifeTime: { type: 'number', nullable: true },
+    maxRetransmits: { type: 'number', nullable: true },
+  },
+  required: [ 'streamId' ],
+  additionalProperties: false,
+};
+
+const wrtcTransportSchema: JSONSchemaType<WrtcTransport> = {
+  type: 'object',
+  properties: {
+    i: { type: 'string' },
+    ip: wrtcIceParametersSchema,
+    ic: { type: 'array', items: wrtcIceCandidateSchema },
+    d: wrtcDtlsParametersSchema,
+    s: wrtcSctpParametersSchema,
+  },
+  required: [ 'i', 'ip', 'ic', 'd', 's' ],
+  additionalProperties: false,
+};
+
+const wrtcTransportConnectSchema: JSONSchemaType<WrtcTransportConnect> = {
+  type: 'object',
+  properties: {
+    i: { type: 'string' },
+    d: wrtcDtlsParametersSchema,
+  },
+  required: [ 'i', 'd' ],
+  additionalProperties: false,
+};
+
+const wrtcDataChannelSchema: JSONSchemaType<WrtcDataChannel> = {
+  type: 'object',
+  properties: {
+    i: { type: 'string' },
+    di: { type: 'string' },
+    l: { type: 'string' },
+    s: wrtcSctpStreamParametersSchema,
+  },
+  required: [ 'i', 'di', 'l', 's' ],
+  additionalProperties: false,
+};
+
+export const connectionSchema: JSONSchemaType<ConnectionSchema> = {
+  type: 'object',
+  properties: {
+    c: { type: 'array', items: { ...wrtcTransportConnectSchema }, nullable: true },
+    ca: { type: 'array', items: { ...wrtcConnectAckSchema }, nullable: true },
+    d: { type: 'array', items: { ...wrtcDataChannelSchema }, nullable: true },
+    p: { type: 'string', enum: [ 'wss', 'wrtc' ], nullable: true },
+    pa: { type: 'array', items: { ...wrtcProduceDataAckSchema }, nullable: true },
+    t: { type: 'array', items: { ...wrtcTransportSchema }, nullable: true },
+  },
+  additionalProperties: false,
+};