nethernet 0.0.1 → 0.1.0

package/.github/workflows/ci.yml

@@ -13,7 +13,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [18.x]
+        node-version: [24.x]
 
     steps:
     - uses: actions/checkout@v2

package/.github/workflows/publish.yml

@@ -3,6 +3,9 @@ on:
   push:
     branches:
       - master # Change this to your default branch
+permissions:
+  id-token: write
+  contents: write
 jobs:
   npm-publish:
     name: npm-publish
@@ -13,13 +16,12 @@ jobs:
     - name: Set up Node.js
       uses: actions/setup-node@master
       with:
-        node-version: 18.0.0
+        node-version: 24
+        registry-url: 'https://registry.npmjs.org'
     - id: publish
-      uses: JS-DevTools/npm-publish@v1
-      with:
-        token: ${{ secrets.NPM_AUTH_TOKEN }}
+      uses: JS-DevTools/npm-publish@v4
     - name: Create Release
-      if: steps.publish.outputs.type != 'none'
+      if: ${{ steps.publish.outputs.type }}
       id: create_release
       uses: actions/create-release@v1
       env:

package/HISTORY.md

@@ -1,5 +1,14 @@
 ## History
 
+### 0.1.0
+* [Update CI to Node 24 (#10)](https://github.com/PrismarineJS/node-nethernet/commit/bbd59e2895a48454682df7eee460ff080f4e7df7) (thanks @rom1504)
+* [Fix publish workflow for trusted publishing (#9)](https://github.com/PrismarineJS/node-nethernet/commit/63351452f0a4bffdf6c011f155dced9140369ceb) (thanks @rom1504)
+* [Fix publish condition for npm-publish v4 (#8)](https://github.com/PrismarineJS/node-nethernet/commit/f945da96e87f93068b1605f8c242054d08e05515) (thanks @rom1504)
+* [Switch to trusted publishing via OIDC (#7)](https://github.com/PrismarineJS/node-nethernet/commit/78777cdb6fab03c31d288ec7dba48bcf318ee8e2) (thanks @rom1504)
+* [Initial implementation (#1)](https://github.com/PrismarineJS/node-nethernet/commit/622ad0e2dc144f5f5de5a33d4f77bc9bef388a40) (thanks @LucienHH)
+* [init](https://github.com/PrismarineJS/node-nethernet/commit/d33f363e5e5e5a9a326cc9acb5e4d4cb0e22d27d) (thanks @extremeheat)
+* [Initial commit](https://github.com/PrismarineJS/node-nethernet/commit/a2d42ca53c6751134e6e96625518b396d4b2b6c2) (thanks @extremeheat)
+
 ### 1.0.0
 
 * initial implementation

package/README.md

@@ -6,20 +6,35 @@
 
 [![Official Discord](https://img.shields.io/static/v1.svg?label=OFFICIAL&message=DISCORD&color=blue&logo=discord&style=for-the-badge)](https://discord.gg/GsEFRM8)
 
-WIP
 
-A template repository to make it easy to create new prismarine repo
+A Node.JS implementation of the NetherNet protocol.
 
-## Usage
+## Install
 
-```js
-const template = require('nethernet')
-
-template.helloWorld()
+```sh
+npm install nethernet
 ```
 
-## API
+## Example
+
+```ts
+const { Client, Server } = require('node-nethernet')
+
+const server = new Server()
+// Client sends request to the broadcast address and server responds with a message
+server.setAdvertisement(Buffer.from([0]))
+const client = new Client(server.networkId)
+
+client.on('encapsulated', (buffer) => {
+  console.assert(buffer.toString() === '\xA0 Hello world')
+})
 
-### helloWorld()
+server.on('openConnection', (client) => {
+  client.send(Buffer.from('\xA0 Hello world'))
+})
 
-Prints hello world
+server.listen()
+
+client.connect()
+
+```

package/example.js

@@ -1,3 +1,18 @@
-const template = require('node-nethernet')
+const { Client, Server } = require('nethernet')
 
-template.helloWorld()
+const server = new Server()
+// Client sends request to broadcast address and server responds with a message
+server.setAdvertisement(Buffer.from([0]))
+const client = new Client(server.networkId)
+
+client.on('encapsulated', (buffer) => {
+  console.assert(buffer.toString() === '\xA0 Hello world')
+})
+
+server.on('openConnection', (client) => {
+  client.send(Buffer.from('\xA0 Hello world'))
+})
+
+server.listen()
+
+client.connect()

package/index.d.ts

@@ -0,0 +1,132 @@
+import EventEmitter from 'node:events'
+import { RemoteInfo, Socket } from 'node:dgram'
+import { PeerConnection, DataChannel, IceServer } from 'node-datachannel'
+
+declare module 'nethernet' {
+
+  export interface ResponsePacket {
+    binary: number[]
+    buffer: Buffer
+    writeIndex: number
+    readIndex: number
+    id: number
+    packetLength: number
+    senderId: bigint
+    data: Buffer
+  }
+
+  export class Connection {
+    nethernet: Client | Server;
+    address: bigint;
+    rtcConnection: PeerConnection;
+    reliable: DataChannel | null;
+    unreliable: DataChannel | null;
+    promisedSegments: number;
+    buf: Buffer | null;
+    sendQueue: Buffer[];      
+
+    constructor(nethernet: Client | Server, address: bigint, rtcConnection: PeerConnection);
+    setChannels(reliable?: DataChannel | null, unreliable?: DataChannel | null): void;
+    handleMessage(data: Buffer | string | ArrayBuffer): void;
+    send(data: Buffer | string): number;
+    sendNow(data: Buffer): number;
+    flushQueue(): void;
+    close(): void;
+  }
+
+  export interface ServerOptions {
+    networkId?: bigint;
+  }
+
+  export interface ServerEvents {
+    openConnection: (connection: Connection) => void;
+    closeConnection: (connectionId: bigint, reason: string) => void;
+    encapsulated: (data: Buffer, connectionId: bigint) => void;
+    close: (reason?: string) => void;
+  }
+
+  export class Server extends EventEmitter {
+    options: ServerOptions;
+    networkId: bigint;
+    connections: Map<bigint, Connection>;
+    advertisement?: Buffer;
+    socket: Socket;
+    serializer: any;
+    deserializer: any;
+
+    constructor(options?: ServerOptions);
+    handleCandidate(signal: SignalStructure): Promise<void>;
+    handleOffer(signal: SignalStructure, respond: (signal: SignalStructure) => void, credentials?: (string | IceServer)[]): Promise<void>;
+    processPacket(buffer: Buffer, rinfo: RemoteInfo): void;
+    setAdvertisement(buffer: Buffer): void;
+    handleRequest(rinfo: RemoteInfo): void;
+    handleMessage(packet: any, rinfo: RemoteInfo): void;
+    listen(): Promise<void>;
+    close(reason?: string): void;
+
+    on<K extends keyof ServerEvents>(event: K, listener: ServerEvents[K]): this;
+    emit<K extends keyof ServerEvents>(event: K, ...args: Parameters<ServerEvents[K]>): boolean;
+  }
+
+  export interface ClientEvents {
+    connected: (connection: Connection) => void;
+    disconnect: (connectionId: bigint, reason: string) => void;
+    encapsulated: (data: Buffer, connectionId: bigint) => void;
+    pong: (packet: any) => void;
+  }  
+
+  export class Client extends EventEmitter {
+    serverNetworkId: bigint;
+    broadcastAddress: string;
+    networkId: bigint;
+    connectionId: bigint;
+    socket: Socket;
+    serializer: any;
+    deserializer: any;
+    responses: Map<bigint, any>;
+    addresses: Map<bigint, RemoteInfo>;
+    credentials: (string | IceServer)[];
+    signalHandler: (signal: SignalStructure) => void;
+    connection?: Connection;
+    rtcConnection?: PeerConnection;
+    pingInterval?: NodeJS.Timeout;
+    running: boolean;
+  
+    constructor(networkId: bigint, broadcastAddress?: string);
+    handleCandidate(signal: SignalStructure): Promise<void>;
+    handleAnswer(signal: SignalStructure): Promise<void>;
+    createOffer(): Promise<void>;
+    processPacket(buffer: Buffer, rinfo: RemoteInfo): void;
+    handleResponse(packet: any, rinfo: RemoteInfo): void;
+    handleMessage(packet: any): void;
+    handleSignal(signal: SignalStructure): void;
+    sendDiscoveryRequest(): void;
+    sendDiscoveryMessage(signal: SignalStructure): void;
+    connect(): Promise<void>;
+    send(buffer: Buffer): void;
+    ping(): void;
+    close(reason?: string): void;
+
+    on<K extends keyof ClientEvents>(event: K, listener: ClientEvents[K]): this;
+    emit<K extends keyof ClientEvents>(event: K, ...args: Parameters<ClientEvents[K]>): boolean;
+  }
+
+  export enum SignalType {
+    ConnectRequest = 'CONNECTREQUEST',
+    ConnectResponse = 'CONNECTRESPONSE',
+    CandidateAdd = 'CANDIDATEADD',
+    ConnectError = 'CONNECTERROR'
+  }
+
+  export class SignalStructure {
+    type: SignalType;
+    connectionId: bigint;
+    data: string;
+    networkId?: bigint;
+
+    constructor(type: SignalType, connectionId: bigint, data: string, networkId?: bigint);
+    toString(): string;
+    static fromString(message: string): SignalStructure;
+  }
+
+}

package/index.js

@@ -1,9 +1,17 @@
-if (typeof process !== 'undefined' && parseInt(process.versions.node.split('.')[0]) < 18) {
-  console.error('Your node version is currently', process.versions.node)
-  console.error('Please update it to a version >= 18.x.x from https://nodejs.org/')
-  process.exit(1)
+const { Client } = require('./src/client')
+const { Server } = require('./src/server')
+const { SignalStructure } = require('./src/signalling')
+
+const SignalType = {
+  ConnectRequest: 'CONNECTREQUEST',
+  ConnectResponse: 'CONNECTRESPONSE',
+  CandidateAdd: 'CANDIDATEADD',
+  ConnectError: 'CONNECTERROR'
 }
 
-module.exports.helloWorld = function () {
-  console.log('Hello world !')
+module.exports = {
+  Client,
+  Server,
+  SignalType,
+  SignalStructure
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nethernet",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "(WIP) Minecraft Bedrock nethernet protocol",
   "main": "index.js",
   "scripts": {
@@ -24,8 +24,13 @@
   },
   "homepage": "https://github.com/PrismarineJS/node-nethernet#readme",
   "devDependencies": {
-    "node-nethernet": "file:.",
-    "standard": "^17.0.0",
-    "mocha": "^10.0.0"
+    "debug": "^4.4.0",
+    "mocha": "^10.0.0",
+    "nethernet": "file:.",
+    "standard": "^17.0.0"
+  },
+  "dependencies": {
+    "node-datachannel": "^0.26.0",
+    "protodef": "^1.19.0"
   }
 }

package/src/client.js

@@ -0,0 +1,206 @@
+const dgram = require('node:dgram')
+const { EventEmitter } = require('node:events')
+
+const { Connection } = require('./connection')
+const { SignalType, SignalStructure } = require('./signalling')
+
+const { getRandomUint64, createPacketData, prepareSecurePacket, processSecurePacket } = require('./util')
+const { PeerConnection } = require('node-datachannel')
+const { PACKET_TYPE, createSerializer, createDeserializer } = require('./serializer')
+
+const debug = require('debug')('nethernet')
+
+const PORT = 7551
+const BROADCAST_ADDRESS = '255.255.255.255'
+const SOCKET_CLOSE_TIMEOUT_MS = 100
+
+class Client extends EventEmitter {
+  constructor (networkId, broadcastAddress = BROADCAST_ADDRESS) {
+    super()
+
+    this.serverNetworkId = networkId
+
+    this.broadcastAddress = broadcastAddress
+
+    this.networkId = getRandomUint64()
+
+    this.connectionId = getRandomUint64()
+
+    this.socket = dgram.createSocket('udp4')
+
+    this.socket.on('message', (buffer, rinfo) => {
+      this.processPacket(buffer, rinfo)
+    })
+
+    this.socket.bind(() => {
+      this.socket.setBroadcast(true)
+    })
+
+    this.serializer = createSerializer()
+    this.deserializer = createDeserializer()
+
+    this.responses = new Map()
+    this.addresses = new Map()
+
+    this.credentials = []
+
+    this.signalHandler = this.sendDiscoveryMessage
+
+    this.sendDiscoveryRequest()
+
+    this.pingInterval = setInterval(() => {
+      this.sendDiscoveryRequest()
+    }, 2000)
+  }
+
+  async handleCandidate (signal) {
+    this.rtcConnection.addRemoteCandidate(signal.data, '0')
+  }
+
+  async handleAnswer (signal) {
+    this.rtcConnection.setRemoteDescription(signal.data, 'answer')
+  }
+
+  async createOffer () {
+    this.rtcConnection = new PeerConnection('client', { iceServers: this.credentials })
+
+    this.connection = new Connection(this, this.connectionId, this.rtcConnection)
+
+    this.rtcConnection.onLocalCandidate(candidate => {
+      this.signalHandler(
+        new SignalStructure(SignalType.CandidateAdd, this.connectionId, candidate, this.serverNetworkId)
+      )
+    })
+
+    this.rtcConnection.onLocalDescription(desc => {
+      const pattern = /o=rtc \d+ 0 IN IP4 127\.0\.0\.1/
+
+      const newOLine = `o=- ${this.networkId} 2 IN IP4 127.0.0.1`
+
+      desc = desc.replace(pattern, newOLine)
+
+      debug('client ICE local description changed', desc)
+      this.signalHandler(
+        new SignalStructure(SignalType.ConnectRequest, this.connectionId, desc, this.serverNetworkId)
+      )
+    })
+
+    this.rtcConnection.onStateChange(state => {
+      debug('Client state changed', state)
+      if (state === 'connected') this.emit('connected', this.connection)
+      if (state === 'closed' || state === 'disconnected' || state === 'failed') this.emit('disconnect', this.connectionId, 'disconnected')
+    })
+
+    setTimeout(() => {
+      this.connection.setChannels(
+        this.rtcConnection.createDataChannel('ReliableDataChannel'),
+        this.rtcConnection.createDataChannel('UnreliableDataChannel')
+      )
+    }, 500)
+  }
+
+  processPacket (buffer, rinfo) {
+    const parsedPacket = processSecurePacket(buffer, this.deserializer)
+    debug('Received packet', parsedPacket)
+
+    switch (parsedPacket.name) {
+      case 'discovery_request':
+        break
+      case 'discovery_response':
+        this.handleResponse(parsedPacket, rinfo)
+        break
+      case 'discovery_message':
+        this.handleMessage(parsedPacket)
+        break
+      default:
+        throw new Error('Unknown packet type')
+    }
+  }
+
+  handleResponse (packet, rinfo) {
+    const senderId = BigInt(packet.params.sender_id)
+    this.addresses.set(senderId, rinfo)
+    this.responses.set(senderId, packet.params)
+    this.emit('pong', packet.params)
+  }
+
+  handleMessage (packet) {
+    const data = packet.params.data
+
+    if (data === 'Ping') {
+      return
+    }
+
+    const signal = SignalStructure.fromString(data)
+
+    signal.networkId = packet.params.sender_id
+
+    this.handleSignal(signal)
+  }
+
+  handleSignal (signal) {
+    switch (signal.type) {
+      case SignalType.ConnectResponse:
+        this.handleAnswer(signal)
+        break
+      case SignalType.CandidateAdd:
+        this.handleCandidate(signal)
+        break
+    }
+  }
+
+  sendDiscoveryRequest () {
+    const packetData = createPacketData('discovery_request', PACKET_TYPE.DISCOVERY_REQUEST, this.networkId)
+
+    const packetToSend = prepareSecurePacket(this.serializer, packetData)
+
+    this.socket.send(packetToSend, PORT, this.broadcastAddress)
+  }
+
+  sendDiscoveryMessage (signal) {
+    const rinfo = this.addresses.get(BigInt(signal.networkId))
+
+    if (!rinfo) {
+      return
+    }
+
+    const packetData = createPacketData('discovery_message', PACKET_TYPE.DISCOVERY_MESSAGE, this.networkId,
+      {
+        recipient_id: BigInt(signal.networkId),
+        data: signal.toString()
+      }
+    )
+
+    const packetToSend = prepareSecurePacket(this.serializer, packetData)
+    this.socket.send(packetToSend, rinfo.port, rinfo.address)
+  }
+
+  async connect () {
+    this.running = true
+
+    await this.createOffer()
+  }
+
+  send (buffer) {
+    this.connection.send(buffer)
+  }
+
+  ping () {
+    this.running = true
+
+    this.sendDiscoveryRequest()
+  }
+
+  close (reason) {
+    debug('Closing client', reason)
+    if (!this.running) return
+    clearInterval(this.pingInterval)
+    this.connection?.close()
+    setTimeout(() => this.socket.close(), SOCKET_CLOSE_TIMEOUT_MS)
+    this.connection = null
+    this.running = false
+    this.removeAllListeners()
+  }
+}
+
+module.exports = { Client }

package/src/compilerTypes.js

@@ -0,0 +1,32 @@
+/* eslint-disable */
+const [Read, Write, SizeOf] = [{}, {}, {}]
+
+/**
+ * Encapsulated data with length prefix
+ */
+Read.encapsulated = ['parametrizable', (compiler, { lengthType, type }) => {
+  return compiler.wrapCode(`
+  const payloadSize = ${compiler.callType(lengthType, 'offset')}
+  const { value, size } = ctx.${type}(buffer, offset + payloadSize.size)
+  return { value, size: size + payloadSize.size }
+`.trim())
+}]
+Write.encapsulated = ['parametrizable', (compiler, { lengthType, type }) => {
+  return compiler.wrapCode(`
+  const buf = Buffer.allocUnsafe(buffer.length - offset)
+  const payloadSize = (ctx.${type})(value, buf, 0)
+  let size = (ctx.${lengthType})(payloadSize, buffer, offset)
+  size += buf.copy(buffer, size, 0, payloadSize)
+
+  return size
+`.trim())
+}]
+SizeOf.encapsulated = ['parametrizable', (compiler, { lengthType, type }) => {
+  return compiler.wrapCode(`
+    const payloadSize = (ctx.${type})(value)
+    return (ctx.${lengthType})(payloadSize) + payloadSize
+`.trim())
+}]
+
+
+module.exports = { Read, Write, SizeOf }

package/src/connection.js

@@ -0,0 +1,121 @@
+const debug = require('debug')('nethernet')
+
+const MAX_MESSAGE_SIZE = 10_000
+
+class Connection {
+  constructor (nethernet, address, rtcConnection) {
+    this.nethernet = nethernet
+    this.address = address
+    this.rtcConnection = rtcConnection
+    this.reliable = null
+    this.unreliable = null
+    this.promisedSegments = 0
+    this.buf = Buffer.alloc(0)
+    this.sendQueue = []
+  }
+
+  setChannels (reliable, unreliable) {
+    if (reliable) {
+      this.reliable = reliable
+      this.reliable.onMessage((msg) => {
+        this.handleMessage(msg)
+      })
+      this.reliable.onOpen(() => {
+        this.flushQueue()
+      })
+    }
+    if (unreliable) {
+      this.unreliable = unreliable
+    }
+  }
+
+  handleMessage (data) {
+    if (typeof data === 'string' || data instanceof ArrayBuffer) {
+      data = Buffer.from(data)
+    }
+
+    if (data.length < 2) {
+      throw new Error('Unexpected EOF')
+    }
+
+    const segments = data[0]
+    debug(`handleMessage segments: ${segments}`)
+    data = data.subarray(1)
+
+    if (this.promisedSegments > 0 && this.promisedSegments - 1 !== segments) {
+      throw new Error(`Invalid promised segments: expected ${this.promisedSegments - 1}, got ${segments}`)
+    }
+
+    this.promisedSegments = segments
+    this.buf = this.buf ? Buffer.concat([this.buf, data]) : data
+
+    if (this.promisedSegments > 0) {
+      return
+    }
+
+    this.nethernet.emit('encapsulated', this.buf, this.address)
+    this.buf = null
+  }
+
+  send (data) {
+    if (typeof data === 'string') {
+      data = Buffer.from(data)
+    }
+
+    if (!this.reliable || this.reliable.readyState === 'connecting') {
+      debug('Reliable channel not open, queuing message')
+      this.sendQueue.push(data)
+      return 0
+    }
+
+    if (this.reliable.readyState === 'closed' || this.reliable.readyState === 'closing') {
+      debug('Reliable channel is not open', this.reliable?.readyState)
+      throw new Error('Reliable channel is not open')
+    }
+
+    return this.sendNow(data)
+  }
+
+  sendNow (data) {
+    let n = 0
+    let segments = Math.ceil(data.length / MAX_MESSAGE_SIZE)
+
+    for (let i = 0; i < data.length; i += MAX_MESSAGE_SIZE) {
+      segments--
+      const end = Math.min(i + MAX_MESSAGE_SIZE, data.length)
+      const frag = data.subarray(i, end)
+      const message = Buffer.concat([Buffer.from([segments]), frag])
+      debug('Sending fragment', segments)
+      this.reliable.sendMessageBinary(message)
+      n += frag.length
+    }
+
+    if (segments !== 0) {
+      throw new Error('Segments count did not reach 0 after sending all fragments')
+    }
+
+    return n
+  }
+
+  flushQueue () {
+    debug('Flushing send queue')
+    while (this.sendQueue.length > 0) {
+      const data = this.sendQueue.shift()
+      this.sendNow(data)
+    }
+  }
+
+  close () {
+    if (this.reliable) {
+      this.reliable.close()
+    }
+    if (this.unreliable) {
+      this.unreliable.close()
+    }
+    if (this.rtcConnection) {
+      this.rtcConnection.close()
+    }
+  }
+}
+
+module.exports = { Connection }

package/src/crypto.js

@@ -0,0 +1,30 @@
+const crypto = require('node:crypto')
+
+const appIdBuffer = Buffer.alloc(8)
+appIdBuffer.writeBigUInt64LE(BigInt(0xdeadbeef))
+
+const AES_KEY = crypto.createHash('sha256')
+  .update(appIdBuffer)
+  .digest()
+
+function encrypt (data) {
+  const cipher = crypto.createCipheriv('aes-256-ecb', AES_KEY, null)
+  return Buffer.concat([cipher.update(data), cipher.final()])
+}
+
+function decrypt (data) {
+  const decipher = crypto.createDecipheriv('aes-256-ecb', AES_KEY, null)
+  return Buffer.concat([decipher.update(data), decipher.final()])
+}
+
+function calculateChecksum (data) {
+  const hmac = crypto.createHmac('sha256', AES_KEY)
+  hmac.update(data)
+  return hmac.digest()
+}
+
+module.exports = {
+  encrypt,
+  decrypt,
+  calculateChecksum
+}

package/src/protocol.json

@@ -0,0 +1,129 @@
+{
+  "types": {
+    "string": [
+      "pstring",
+      {
+        "countType": "varint"
+      }
+    ],
+    "encapsulated": "native",
+    "nethernet_packet": [
+      "encapsulated",
+      {
+        "lengthType": "lu16",
+        "type": "nethernet_packet_inner"
+      }
+    ],
+    "nethernet_packet_inner": [
+      "container",
+      [
+        {
+          "name": "name",
+          "type": [
+            "mapper",
+            {
+              "type": "lu16",
+              "mappings": {
+                "0": "discovery_request",
+                "1": "discovery_response",
+                "2": "discovery_message"
+              }
+            }
+          ]
+        },
+        {
+          "name": "params",
+          "type": [
+            "switch",
+            {
+              "compareTo": "name",
+              "fields": {
+                "discovery_request": "DiscoveryRequest",
+                "discovery_response": "DiscoveryResponse",
+                "discovery_message": "DiscoveryMessage"
+              }
+            }
+          ]
+        }
+      ]
+    ],
+    "DiscoveryRequest": [
+      "container",
+      [
+        {
+          "name": "sender_id",
+          "type": "lu64"
+        },
+        {
+          "name": "reserved",
+          "type": [
+            "buffer",
+            {
+              "count": 8
+            }
+          ]
+        }
+      ]
+    ],
+    "DiscoveryResponse": [
+      "container",
+      [
+        {
+          "name": "sender_id",
+          "type": "lu64"
+        },
+        {
+          "name": "reserved",
+          "type": [
+            "buffer",
+            {
+              "count": 8
+            }
+          ]
+        },
+        {
+          "name": "data",
+          "type": [
+            "pstring",
+            {
+              "countType": "lu32",
+              "encoding": "utf-8"
+            }
+          ]
+        }
+      ]
+    ],
+    "DiscoveryMessage": [
+      "container",
+      [
+        {
+          "name": "sender_id",
+          "type": "lu64"
+        },
+        {
+          "name": "reserved",
+          "type": [
+            "buffer",
+            {
+              "count": 8
+            }
+          ]
+        },
+        {
+          "name": "recipient_id",
+          "type": "lu64"
+        },
+        {
+          "name": "data",
+          "type": [
+            "pstring",
+            {
+              "countType": "lu32",
+              "encoding": "utf-8"
+            }
+          ]
+        }
+      ]
+    ]
+  }
+}

package/src/serializer.js

@@ -0,0 +1,35 @@
+const { ProtoDefCompiler } = require('protodef').Compiler
+const { FullPacketParser, Serializer } = require('protodef')
+const protocol = require('./protocol.json')
+
+const PACKET_TYPE = {
+  DISCOVERY_REQUEST: 0,
+  DISCOVERY_RESPONSE: 1,
+  DISCOVERY_MESSAGE: 2
+}
+
+function createProtocol () {
+  const compiler = new ProtoDefCompiler()
+  compiler.addTypesToCompile(protocol.types)
+  compiler.addTypes(require('./compilerTypes'))
+
+  const compiledProto = compiler.compileProtoDefSync()
+  return compiledProto
+}
+
+function createSerializer () {
+  const proto = createProtocol()
+  return new Serializer(proto, 'nethernet_packet')
+}
+
+function createDeserializer () {
+  const proto = createProtocol()
+  return new FullPacketParser(proto, 'nethernet_packet')
+}
+
+module.exports = {
+  PACKET_TYPE,
+  createDeserializer,
+  createSerializer,
+  createProtocol
+}

package/src/server.js

@@ -0,0 +1,176 @@
+const dgram = require('node:dgram')
+const { EventEmitter } = require('node:events')
+const { PeerConnection } = require('node-datachannel')
+
+const { Connection } = require('./connection')
+const { SignalStructure, SignalType } = require('./signalling')
+
+const { PACKET_TYPE, createSerializer, createDeserializer } = require('./serializer')
+
+const { getRandomUint64, createPacketData, prepareSecurePacket, processSecurePacket } = require('./util')
+
+const debug = require('debug')('nethernet')
+
+class Server extends EventEmitter {
+  constructor (options = {}) {
+    super()
+
+    this.options = options
+
+    this.networkId = options.networkId ?? getRandomUint64()
+
+    this.connections = new Map()
+
+    this.serializer = createSerializer()
+    this.deserializer = createDeserializer()
+  }
+
+  async handleCandidate (signal) {
+    const conn = this.connections.get(signal.connectionId)
+
+    if (conn) {
+      conn.rtcConnection.addRemoteCandidate(signal.data, '0')
+    } else {
+      debug('Connection not found', signal.connectionId)
+    }
+  }
+
+  async handleOffer (signal, respond, credentials = []) {
+    const rtcConnection = new PeerConnection('server', { iceServers: credentials })
+
+    const connection = new Connection(this, signal.connectionId, rtcConnection)
+
+    this.connections.set(signal.connectionId, connection)
+
+    debug('Received offer', signal.connectionId)
+
+    rtcConnection.onLocalDescription(description => {
+      debug('Local description', description)
+      respond(
+        new SignalStructure(SignalType.ConnectResponse, signal.connectionId, description, signal.networkId)
+      )
+    })
+
+    rtcConnection.onLocalCandidate(candidate => {
+      respond(
+        new SignalStructure(SignalType.CandidateAdd, signal.connectionId, candidate, signal.networkId)
+      )
+    })
+
+    rtcConnection.onDataChannel(channel => {
+      debug('Received data channel', channel.getLabel())
+      if (channel.getLabel() === 'ReliableDataChannel') connection.setChannels(channel)
+      if (channel.getLabel() === 'UnreliableDataChannel') connection.setChannels(null, channel)
+    })
+
+    rtcConnection.onStateChange(state => {
+      debug('Server RTC state changed', state)
+      if (state === 'connected') this.emit('openConnection', connection)
+      if (state === 'closed' || state === 'disconnected' || state === 'failed') this.emit('closeConnection', signal.connectionId, 'disconnected')
+    })
+
+    rtcConnection.setRemoteDescription(signal.data, 'offer')
+  }
+
+  processPacket (buffer, rinfo) {
+    const parsedPacket = processSecurePacket(buffer, this.deserializer)
+    debug('Received packet', parsedPacket)
+
+    switch (parsedPacket.name) {
+      case 'discovery_request':
+        this.handleRequest(rinfo)
+        break
+      case 'discovery_response':
+        break
+      case 'discovery_message':
+        this.handleMessage(parsedPacket, rinfo)
+        break
+      default:
+        throw new Error('Unknown packet type')
+    }
+  }
+
+  setAdvertisement (buffer) {
+    this.advertisement = buffer
+  }
+
+  handleRequest (rinfo) {
+    const data = this.advertisement
+
+    if (!data) {
+      throw new Error('Advertisement data not set yet')
+    }
+
+    const packetData = createPacketData('discovery_response', PACKET_TYPE.DISCOVERY_RESPONSE, this.networkId,
+      {
+        data: data.toString('hex')
+      }
+    )
+
+    const packetToSend = prepareSecurePacket(this.serializer, packetData)
+    this.socket.send(packetToSend, rinfo.port, rinfo.address)
+  }
+
+  handleMessage (packet, rinfo) {
+    const data = packet.params.data
+    if (data === 'Ping') {
+      return
+    }
+
+    const respond = (signal) => {
+      const packetData = createPacketData('discovery_message', PACKET_TYPE.DISCOVERY_MESSAGE, this.networkId,
+        {
+          recipient_id: BigInt(signal.networkId),
+          data: signal.toString()
+        }
+      )
+
+      const packetToSend = prepareSecurePacket(this.serializer, packetData)
+      this.socket.send(packetToSend, rinfo.port, rinfo.address)
+    }
+
+    const signal = SignalStructure.fromString(data)
+
+    signal.networkId = packet.params.sender_id
+
+    switch (signal.type) {
+      case SignalType.ConnectRequest:
+        this.handleOffer(signal, respond)
+        break
+      case SignalType.CandidateAdd:
+        this.handleCandidate(signal)
+        break
+    }
+  }
+
+  async listen () {
+    this.socket = dgram.createSocket('udp4')
+
+    this.socket.on('message', (buffer, rinfo) => {
+      this.processPacket(buffer, rinfo)
+    })
+
+    await new Promise((resolve, reject) => {
+      const failFn = e => reject(e)
+      this.socket.once('error', failFn)
+      this.socket.bind(7551, () => {
+        this.socket.removeListener('error', failFn)
+        resolve(true)
+      })
+    })
+  }
+
+  close (reason) {
+    debug('Closing server', reason)
+    for (const conn of this.connections.values()) {
+      conn.close()
+    }
+
+    this.socket.close(() => {
+      this.emit('close', reason)
+      this.removeAllListeners()
+    })
+  }
+}
+
+module.exports = { Server }

package/src/signalling.js

@@ -0,0 +1,27 @@
+const SignalType = {
+  ConnectRequest: 'CONNECTREQUEST',
+  ConnectResponse: 'CONNECTRESPONSE',
+  CandidateAdd: 'CANDIDATEADD',
+  ConnectError: 'CONNECTERROR'
+}
+
+class SignalStructure {
+  constructor (type, connectionId, data, networkId) {
+    this.type = type
+    this.connectionId = connectionId
+    this.data = data
+    this.networkId = networkId
+  }
+
+  toString () {
+    return `${this.type} ${this.connectionId} ${this.data}`
+  }
+
+  static fromString (message) {
+    const [type, connectionId, ...data] = message.split(' ')
+
+    return new this(type, BigInt(connectionId), data.join(' '))
+  }
+}
+
+module.exports = { SignalStructure, SignalType }

package/src/util.js

@@ -0,0 +1,52 @@
+const { encrypt, calculateChecksum, decrypt } = require('./crypto')
+
+const getRandomUint64 = () => {
+  const high = Math.floor(Math.random() * 0xFFFFFFFF)
+  const low = Math.floor(Math.random() * 0xFFFFFFFF)
+
+  return (BigInt(high) << 32n) | BigInt(low)
+}
+
+const createPacketData = (packetName, packetId, senderId, additionalParams = {}) => {
+  return {
+    name: packetName,
+    params: {
+      sender_id: senderId,
+      reserved: Buffer.alloc(8),
+      ...additionalParams
+    }
+  }
+}
+
+const prepareSecurePacket = (serializer, packetData) => {
+  const buf = serializer.createPacketBuffer(packetData)
+
+  const checksum = calculateChecksum(buf)
+  const encryptedData = encrypt(buf)
+
+  return Buffer.concat([checksum, encryptedData])
+}
+
+const processSecurePacket = (buffer, deserializer) => {
+  if (buffer.length < 32) {
+    throw new Error('Packet is too short')
+  }
+
+  const decryptedData = decrypt(buffer.slice(32))
+
+  const checksum = calculateChecksum(decryptedData)
+  if (Buffer.compare(buffer.slice(0, 32), checksum) !== 0) {
+    throw new Error('Checksum mismatch')
+  }
+
+  const packet = deserializer.parsePacketBuffer(decryptedData)
+
+  return { name: packet.data.name, params: packet.data.params }
+}
+
+module.exports = {
+  getRandomUint64,
+  createPacketData,
+  prepareSecurePacket,
+  processSecurePacket
+}

package/test/basic.test.js

@@ -1,7 +1,106 @@
 /* eslint-env mocha */
+process.env.DEBUG = '*'
+const { Server, Client } = require('nethernet')
 
-describe('basic', () => {
-  it('test', () => {
+async function pingTest () {
+  return new Promise((resolve, reject) => {
+    const message = 'FMCPE;JSRakNet - JS powered RakNet;408;1.16.20;0;5;0;JSRakNet;Creative;'
+    const server = new Server()
+    server.setAdvertisement(Buffer.from(message))
+    const client = new Client(server.networkId, '127.0.0.1')
+    client.once('pong', (packet) => {
+      console.log('PONG data', packet)
+      const msg = Buffer.from(packet.data, 'hex').toString()
+      if (!msg || msg !== message) throw Error(`PONG mismatch ${msg} != ${message}`)
+      console.log('OK')
+      client.close()
+      server.close()
+      setTimeout(() => {
+        resolve() // allow for server + client to close
+      }, 500)
+    })
 
+    server.listen()
+    client.ping()
   })
+}
+
+async function connectTest () {
+  return new Promise((resolve, reject) => {
+    const message = 'FMCPE;JSRakNet - JS powered RakNet;408;1.16.20;0;5;0;JSRakNet;Creative;'
+    const server = new Server()
+    server.setAdvertisement(Buffer.from(message))
+    const client = new Client(server.networkId, '127.0.0.1')
+
+    server.listen()
+    let lastC = 0
+    client.on('connected', () => {
+      console.log('connected!')
+      client.on('encapsulated', (encap) => {
+        console.assert(encap[0] === 0xf0)
+        const ix = encap[1]
+        if (lastC++ !== ix) {
+          throw Error(`Packet mismatch: ${lastC - 1} != ${ix}`)
+        }
+        client.send(encap)
+      })
+    })
+    let lastS = 0
+    server.on('encapsulated', (encap) => {
+      console.assert(encap[0] === 0xf0)
+      const ix = encap[1]
+      if (lastS++ !== ix) {
+        throw Error(`Packet mismatch: ${lastS - 1} != ${ix}`)
+      }
+      if (lastS === 50) {
+        client.close()
+        server.close()
+        resolve(true)
+      }
+    })
+    server.on('openConnection', (client) => {
+      console.debug('Client opened connection')
+      for (let i = 0; i < 50; i++) {
+        const buf = Buffer.alloc(1000)
+        for (let j = 0; j < 64; j += 4) buf[j] = j + i
+        buf[0] = 0xf0
+        buf[1] = i
+        client.send(buf)
+      }
+    })
+    client.connect()
+  })
+}
+
+async function kickTest () {
+  return new Promise((resolve, reject) => {
+    const server = new Server()
+    server.setAdvertisement(Buffer.from([0]))
+    const client = new Client(server.networkId, '127.0.0.1')
+    server.on('openConnection', (con) => {
+      console.log('new connection')
+      con.close()
+    })
+    server.listen()
+    client.on('disconnect', packet => {
+      console.log('Client got disconnect', packet)
+      try {
+        client.send(Buffer.from('\xf0 yello'))
+      } catch (e) {
+        console.log('** Expected error 😀 **', e)
+        server.close()
+        client.close()
+        resolve()
+      }
+    })
+
+    client.connect()
+  })
+}
+
+describe('server tests', function () {
+  this.timeout(30000)
+  it('ping test', pingTest)
+  it('connection test', connectTest)
+  it('kick test', kickTest)
 })