@streamr/dht 100.0.0-testnet-three.5 → 100.0.0

package/src/connection/connectivityRequestHandler.ts

@@ -1,21 +1,22 @@
 import { ipv4ToNumber, Logger } from '@streamr/utils'
 import { v4 } from 'uuid'
 import {
-    ConnectivityRequest, ConnectivityResponse,
-    Message, MessageType
+    ConnectivityRequest,
+    ConnectivityResponse,
+    Message
 } from '../proto/packages/dht/protos/DhtRpc'
 import { NatType } from './ConnectionManager'
 import { CONNECTIVITY_CHECKER_SERVICE_ID, connectAsync } from './connectivityChecker'
 import { IConnection } from './IConnection'
-import { ServerWebsocket } from './websocket/ServerWebsocket'
+import { WebsocketServerConnection } from './websocket/WebsocketServerConnection'
 import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
-import { version as localVersion } from '../../package.json'
+import { LOCAL_PROTOCOL_VERSION } from '../helpers/version'
 
 export const DISABLE_CONNECTIVITY_PROBE = 0
 
 const logger = new Logger(module)
 
-export const attachConnectivityRequestHandler = (connectionToListenTo: ServerWebsocket): void => {
+export const attachConnectivityRequestHandler = (connectionToListenTo: WebsocketServerConnection): void => {
     connectionToListenTo.on('data', async (data: Uint8Array) => {
         logger.trace('server received data')
         try {
@@ -35,9 +36,9 @@ export const attachConnectivityRequestHandler = (connectionToListenTo: ServerWeb
     })
 }
 
-const handleIncomingConnectivityRequest = async (connection: ServerWebsocket, connectivityRequest: ConnectivityRequest): Promise<void> => {
-    const host = connectivityRequest.host ?? connection.getRemoteAddress()
-    const ipAddress = connection.getRemoteIp()
+const handleIncomingConnectivityRequest = async (connection: WebsocketServerConnection, connectivityRequest: ConnectivityRequest): Promise<void> => {
+    const host = connectivityRequest.host ?? connection.remoteIpAddress
+    const ipAddress = connection.remoteIpAddress
     let connectivityResponse: ConnectivityResponse
     if (connectivityRequest.port !== DISABLE_CONNECTIVITY_PROBE) {
         connectivityResponse = await connectivityProbe(connectivityRequest, ipAddress, host)
@@ -47,12 +48,11 @@ const handleIncomingConnectivityRequest = async (connection: ServerWebsocket, co
             host,
             natType: NatType.UNKNOWN,
             ipAddress: ipv4ToNumber(ipAddress),
-            version: localVersion
+            version: LOCAL_PROTOCOL_VERSION
         }
     }
     const msg: Message = {
         serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
-        messageType: MessageType.CONNECTIVITY_RESPONSE,
         messageId: v4(),
         body: {
             oneofKind: 'connectivityResponse',
@@ -84,7 +84,7 @@ const connectivityProbe = async (connectivityRequest: ConnectivityRequest, ipAdd
             natType: NatType.OPEN_INTERNET,
             websocket: { host, port: connectivityRequest.port, tls: connectivityRequest.tls },
             ipAddress: ipv4ToNumber(ipAddress),
-            version: localVersion
+            version: LOCAL_PROTOCOL_VERSION
         }
     } catch (err) {
         logger.debug('error', { err })
@@ -92,7 +92,7 @@ const connectivityProbe = async (connectivityRequest: ConnectivityRequest, ipAdd
             host,
             natType: NatType.UNKNOWN,
             ipAddress: ipv4ToNumber(ipAddress),
-            version: localVersion
+            version: LOCAL_PROTOCOL_VERSION
         }
     }
     if (outgoingConnection) {

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -26,7 +26,7 @@ export interface Params {
     bufferThresholdLow?: number
     connectingTimeout?: number
     maxMessageSize?: number
-    iceServers?: IceServer[]
+    iceServers?: IceServer[]  // TODO make this parameter required (empty array is a good fallback which can be set by the caller if needed)
     portRange?: PortRange
 }
 

package/src/connection/webrtc/WebrtcConnector.ts

@@ -75,6 +75,7 @@ export class WebrtcConnector {
         onNewConnection: (connection: ManagedConnection) => boolean
     ) {
         const localRpc = new WebrtcConnectorRpcLocal({
+            createConnection: (targetPeerDescriptor: PeerDescriptor) => this.createConnection(targetPeerDescriptor),
             connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
             onNewConnection,
             ongoingConnectAttempts: this.ongoingConnectAttempts,
@@ -133,14 +134,7 @@ export class WebrtcConnector {
             return existingConnection
         }
 
-        const connection = new NodeWebrtcConnection({
-            remotePeerDescriptor: targetPeerDescriptor,
-            iceServers: this.config.iceServers,
-            bufferThresholdLow: this.config.bufferThresholdLow,
-            bufferThresholdHigh: this.config.bufferThresholdHigh,
-            connectingTimeout: this.config.connectionTimeout,
-            portRange: this.config.portRange
-        })
+        const connection = this.createConnection(targetPeerDescriptor)
 
         const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor!)
         const targetNodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
@@ -199,6 +193,18 @@ export class WebrtcConnector {
         return managedConnection
     }
 
+    private createConnection(targetPeerDescriptor: PeerDescriptor): NodeWebrtcConnection {
+        return new NodeWebrtcConnection({
+            remotePeerDescriptor: targetPeerDescriptor,
+            iceServers: this.config.iceServers,
+            bufferThresholdLow: this.config.bufferThresholdLow,
+            bufferThresholdHigh: this.config.bufferThresholdHigh,
+            connectingTimeout: this.config.connectionTimeout,
+            portRange: this.config.portRange
+            // TODO should we pass maxMessageSize?
+        })
+    }
+
     setLocalPeerDescriptor(peerDescriptor: PeerDescriptor): void {
         this.localPeerDescriptor = peerDescriptor
     }

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -18,13 +18,13 @@ import { ManagedWebrtcConnection } from '../ManagedWebrtcConnection'
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { version as localVersion } from '../../../package.json'
-import { isCompatibleVersion } from '../../helpers/versionCompatibility'
+import { isMaybeSupportedVersion } from '../../helpers/version'
 import { ConnectionID } from '../IConnection'
 
 const logger = new Logger(module)
 
 interface WebrtcConnectorRpcLocalConfig {
+    createConnection: (targetPeerDescriptor: PeerDescriptor) => NodeWebrtcConnection 
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection 
     onNewConnection: (connection: ManagedConnection) => boolean
     // TODO pass accessor methods instead of passing a mutable entity
@@ -60,7 +60,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
         let connection = managedConnection?.getWebrtcConnection()
 
         if (!managedConnection) {
-            connection = new NodeWebrtcConnection({ remotePeerDescriptor: remotePeer })
+            connection = this.config.createConnection(remotePeer)
             managedConnection = new ManagedWebrtcConnection(this.config.getLocalPeerDescriptor(), undefined, connection)
             managedConnection.setRemotePeerDescriptor(remotePeer)
             this.config.ongoingConnectAttempts.set(nodeId, managedConnection)
@@ -84,11 +84,11 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
         connection!.setConnectionId(request.connectionId as ConnectionID)
         connection!.setRemoteDescription(request.description, 'offer')
 
-        managedConnection.on('handshakeRequest', (_sourceDescriptor: PeerDescriptor, sourceVersion: string) => {
+        managedConnection.on('handshakeRequest', (_sourceDescriptor: PeerDescriptor, remoteVersion: string) => {
             if (this.config.ongoingConnectAttempts.has(nodeId)) {
                 this.config.ongoingConnectAttempts.delete(nodeId)
             }
-            if (!isCompatibleVersion(sourceVersion, localVersion)) {
+            if (!isMaybeSupportedVersion(remoteVersion)) {
                 managedConnection!.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
             } else {
                 managedConnection!.acceptHandshake()

package/src/connection/websocket/WebsocketConnector.ts

@@ -17,10 +17,10 @@ import { ManagedConnection } from '../ManagedConnection'
 import { WebsocketServer } from './WebsocketServer'
 import { sendConnectivityRequest } from '../connectivityChecker'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
-import { ServerWebsocket } from './ServerWebsocket'
+import { WebsocketServerConnection } from './WebsocketServerConnection'
 import { Handshaker } from '../Handshaker'
-import { ParsedUrlQuery } from 'querystring'
-import { range, sample } from 'lodash'
+import queryString from 'querystring'
+import { shuffle } from 'lodash'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { expectedConnectionType } from '../../helpers/Connectivity'
 import { WebsocketServerStartError } from '../../helpers/errors'
@@ -29,8 +29,7 @@ import { DISABLE_CONNECTIVITY_PROBE, attachConnectivityRequestHandler } from '..
 import * as Err from '../../helpers/errors'
 import { Empty } from '../../proto/google/protobuf/empty'
 import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { version as localVersion } from '../../../package.json'
-import { isCompatibleVersion } from '../../helpers/versionCompatibility'
+import { LOCAL_PROTOCOL_VERSION, isMaybeSupportedVersion } from '../../helpers/version'
 
 const logger = new Logger(module)
 
@@ -143,10 +142,10 @@ export class WebsocketConnector {
     public async start(): Promise<void> {
         if (!this.abortController.signal.aborted && this.websocketServer) {
             this.websocketServer.on('connected', (connection: IConnection) => {
-                const serverSocket = connection as unknown as ServerWebsocket
-                const query = serverSocket.resourceURL.query as unknown as (ParsedUrlQuery | null)
-                const action = query?.action as (Action | undefined)
-                logger.trace('WebSocket client connected', { action, remoteAddress: serverSocket.getRemoteAddress() })
+                const serverSocket = connection as unknown as WebsocketServerConnection
+                const query = queryString.parse(serverSocket.resourceURL.query as string ?? '')
+                const action = query.action as (Action | undefined)
+                logger.trace('WebSocket client connected', { action, remoteAddress: serverSocket.remoteIpAddress })
                 if (action === 'connectivityRequest') {
                     attachConnectivityRequestHandler(serverSocket)
                 } else if (action === 'connectivityProbe') {
@@ -175,7 +174,7 @@ export class WebsocketConnector {
                 host: '127.0.0.1',
                 natType: NatType.UNKNOWN,
                 ipAddress: ipv4ToNumber('127.0.0.1'),
-                version: localVersion
+                version: LOCAL_PROTOCOL_VERSION
             }
         }
         if (!this.config.entrypoints || this.config.entrypoints.length === 0) {
@@ -190,11 +189,12 @@ export class WebsocketConnector {
                 },
                 // TODO: Resolve the given host name or or use as is if IP was given. 
                 ipAddress: ipv4ToNumber('127.0.0.1'),
-                version: localVersion
+                version: LOCAL_PROTOCOL_VERSION
             }
         }
-        for (const reattempt of range(ENTRY_POINT_CONNECTION_ATTEMPTS)) {
-            const entryPoint = sample(this.config.entrypoints)!
+        const shuffledEntrypoints = shuffle(this.config.entrypoints)
+        while (shuffledEntrypoints.length > 0 && !this.abortController.signal.aborted) {
+            const entryPoint = shuffledEntrypoints[0]
             try {
                 // Do real connectivity checking
                 const connectivityRequest = {
@@ -204,17 +204,16 @@ export class WebsocketConnector {
                     selfSigned
                 }
                 if (!this.abortController.signal.aborted) {
-                    return await sendConnectivityRequest(connectivityRequest, entryPoint, localVersion)
+                    return await sendConnectivityRequest(connectivityRequest, entryPoint)
                 } else {
                     throw new Err.ConnectionFailed('ConnectivityChecker is destroyed')
                 }
             } catch (err) {
-                if (reattempt < ENTRY_POINT_CONNECTION_ATTEMPTS) {
-                    const error = `Failed to connect to entrypoint with id ${getNodeIdFromPeerDescriptor(entryPoint)} `
-                        + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
-                    logger.error(error, { error: err })
-                    await wait(2000)
-                }
+                const error = `Failed to connect to entrypoint with id ${getNodeIdFromPeerDescriptor(entryPoint)} `
+                    + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
+                logger.error(error, { error: err })
+                shuffledEntrypoints.shift()
+                await wait(2000, this.abortController.signal)
             }
         }
         throw new WebsocketServerStartError(`Failed to connect to the entrypoints after ${ENTRY_POINT_CONNECTION_ATTEMPTS} attempts`)
@@ -299,17 +298,17 @@ export class WebsocketConnector {
 
     private onServerSocketHandshakeRequest(
         sourcePeerDescriptor: PeerDescriptor,
-        serverWebsocket: IConnection,
-        sourceVersion: string,
+        websocketServerConnection: IConnection,
+        remoteVersion: string,
         targetPeerDescriptor?: PeerDescriptor
     ) {
         const nodeId = getNodeIdFromPeerDescriptor(sourcePeerDescriptor)
         if (this.ongoingConnectRequests.has(nodeId)) {
             const ongoingConnectRequest = this.ongoingConnectRequests.get(nodeId)!
-            if (!isCompatibleVersion(sourceVersion, localVersion)) {
+            if (!isMaybeSupportedVersion(remoteVersion)) {
                 ongoingConnectRequest.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
             } else {
-                ongoingConnectRequest.attachImplementation(serverWebsocket)
+                ongoingConnectRequest.attachImplementation(websocketServerConnection)
                 ongoingConnectRequest.acceptHandshake()
             }
             this.ongoingConnectRequests.delete(nodeId)
@@ -318,11 +317,11 @@ export class WebsocketConnector {
                 this.localPeerDescriptor!,
                 ConnectionType.WEBSOCKET_SERVER,
                 undefined,
-                serverWebsocket,
+                websocketServerConnection,
                 targetPeerDescriptor
             )
             managedConnection.setRemotePeerDescriptor(sourcePeerDescriptor)
-            if (!isCompatibleVersion(sourceVersion, localVersion)) {
+            if (!isMaybeSupportedVersion(remoteVersion)) {
                 managedConnection.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
             } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
                 managedConnection.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)

package/src/connection/websocket/WebsocketServer.ts

@@ -1,8 +1,8 @@
 import { createServer as createHttpServer, Server as HttpServer, IncomingMessage, ServerResponse } from 'http'
 import { createServer as createHttpsServer, Server as HttpsServer } from 'https'
 import EventEmitter from 'eventemitter3'
-import { server as WsServer } from 'websocket'
-import { ServerWebsocket } from './ServerWebsocket'
+import WebSocket from 'ws'
+import { WebsocketServerConnection } from './WebsocketServerConnection'
 import { ConnectionSourceEvents } from '../IConnectionSource'
 import { Logger, asAbortable } from '@streamr/utils'
 import { createSelfSignedCertificate } from '@streamr/autocertifier-client' 
@@ -11,16 +11,10 @@ import { PortRange, TlsCertificate } from '../ConnectionManager'
 import { range } from 'lodash'
 import fs from 'fs'
 import { v4 as uuid } from 'uuid'
+import { parse } from 'url'
 
 const logger = new Logger(module)
 
-// NodeJsWsServer is declared as a global in test-browser Electron tests
-// in preload.js using "window.NodeJsWsServer = require('websocket').server".
-// This is done in order to use the real nodejs websocket server in tests
-// instead of a dummy polyfill.
-
-declare class NodeJsWsServer extends WsServer { }
-
 interface WebsocketServerConfig {
     portRange: PortRange
     enableTls: boolean
@@ -31,7 +25,7 @@ interface WebsocketServerConfig {
 export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
 
     private httpServer?: HttpServer | HttpsServer
-    private wsServer?: WsServer
+    private wsServer?: WebSocket.Server
     private readonly abortController = new AbortController()
     private readonly config: WebsocketServerConfig
 
@@ -88,28 +82,26 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
                 return true
             }
 
-            this.wsServer = this.createWsServer(this.httpServer)
+            this.wsServer = this.createWsServer()
             
-            this.wsServer.on('request', (request) => {
+            this.wsServer.on('connection', (ws: WebSocket, request: IncomingMessage) => {
+                logger.trace(`New connection from ${request.socket.remoteAddress}`)
                 if (!originIsAllowed()) {
                     // Make sure we only accept requests from an allowed origin
-                    request.reject()
-                    logger.trace('IConnection from origin ' + request.origin + ' rejected.')
+                    ws.close()
+                    logger.trace('IConnection from origin ' + request.headers.origin + ' rejected.')
                     return
                 }
-                
-                let connection
-                try {
-                    connection = request.accept(undefined, request.origin)
-                    logger.trace('Connection accepted.', { remoteAddress: request.remoteAddress })
-                } catch (err) {
-                    logger.debug('Accepting websocket connection failed', { remoteAddress: request.remoteAddress, err })
-                }
+                this.emit('connected', new WebsocketServerConnection(ws, parse(request.url!), request.socket.remoteAddress!))
+            })
 
-                if (connection) {
-                    this.emit('connected', new ServerWebsocket(connection, request.resourceURL))
-                }
+            this.httpServer.on('upgrade', (request, socket, head) => {
+                logger.trace('Received upgrade request for ' + request.url)
+                this.wsServer!.handleUpgrade(request, socket, head, (ws: WebSocket) => {
+                    this.wsServer!.emit('connection', ws, request)
+                })
             })
+
             this.httpServer.once('error', (err: Error) => {
                 reject(new WebsocketServerStartError('Starting Websocket server failed', err))
             })
@@ -139,7 +131,10 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
         this.abortController.abort()
         this.removeAllListeners()
         return new Promise((resolve, _reject) => {
-            this.wsServer?.shutDown()
+            this.wsServer!.close()
+            for (const ws of this.wsServer!.clients) {
+                ws.terminate()
+            }
             this.httpServer?.once('close', () => {
                 // removeAllListeners is maybe not needed?
                 this.httpServer?.removeAllListeners()
@@ -155,21 +150,11 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
         })
     }
 
-    private createWsServer(httpServer: HttpServer | HttpsServer): WsServer {
-        const maxReceivedMessageSize = this.config.maxMessageSize ?? 1048576
-        // Use the real nodejs WebSocket server in Electron tests
-        if (typeof NodeJsWsServer !== 'undefined') {
-            return new NodeJsWsServer({
-                httpServer,
-                autoAcceptConnections: false,
-                maxReceivedMessageSize
-            })
-        } else {
-            return this.wsServer = new WsServer({
-                httpServer,
-                autoAcceptConnections: false,
-                maxReceivedMessageSize
-            })
-        }
+    private createWsServer(): WebSocket.Server {
+        const maxPayload = this.config.maxMessageSize ?? 1048576
+        return this.wsServer = new WebSocket.Server({
+            noServer: true,
+            maxPayload
+        })
     }
 }

package/src/connection/websocket/{ServerWebsocket.ts → WebsocketServerConnection.ts}

@@ -1,6 +1,6 @@
 import EventEmitter from 'eventemitter3'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
-import { Message, connection as WsConnection } from 'websocket'
+import WebSocket from 'ws'
 import { Logger } from '@streamr/utils'
 import { Url } from 'url'
 import { CUSTOM_GOING_AWAY, GOING_AWAY } from './ClientWebsocket'
@@ -8,26 +8,16 @@ import { createRandomConnectionId } from '../Connection'
 
 const logger = new Logger(module)
 
-// NodeJsBuffer is global defined in preload.js of Karma
-// It is used to make Karma/Electron tests to use the NodeJS
-// implementation of Buffer instead of the browser polyfill
-
-declare let NodeJsBuffer: BufferConstructor
-
-enum MessageType {
-    UTF8 = 'utf8',
-    BINARY = 'binary'
-}
-
-export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements IConnection {
+export class WebsocketServerConnection extends EventEmitter<ConnectionEvents> implements IConnection {
 
     public readonly connectionId: ConnectionID
     public readonly connectionType = ConnectionType.WEBSOCKET_SERVER
     public readonly resourceURL: Url
-    private socket?: WsConnection
+    public readonly remoteIpAddress: string
+    private socket?: WebSocket
     private stopped = false
 
-    constructor(socket: WsConnection, resourceURL: Url) {
+    constructor(socket: WebSocket, resourceURL: Url, remoteAddress: string) {
         super()
 
         this.onMessage = this.onMessage.bind(this)
@@ -36,6 +26,7 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
 
         this.resourceURL = resourceURL
         this.connectionId = createRandomConnectionId()
+        this.remoteIpAddress = remoteAddress
 
         socket.on('message', this.onMessage)
         socket.on('close', this.onClose)
@@ -44,20 +35,17 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.socket = socket
     }
 
-    private onMessage(message: Message): void {
-        logger.trace('ServerWebsocket::onMessage')
-        if (message.type === MessageType.UTF8) {
-            logger.debug('Received string Message: ' + message.utf8Data)
-        } else if (message.type === MessageType.BINARY) {
-            logger.trace('Received Binary Message of ' + message.binaryData.length + ' bytes')
-            this.emit('data',
-                new Uint8Array(message.binaryData.buffer, message.binaryData.byteOffset,
-                    message.binaryData.byteLength / Uint8Array.BYTES_PER_ELEMENT))
+    private onMessage(message: WebSocket.RawData, isBinary: boolean): void {
+        if (!isBinary) {
+            logger.trace('Received string Message')
+        } else {
+            logger.trace('Websocket server received Message')
+            this.emit('data', new Uint8Array(message as Buffer))
         }
     }
 
     private onClose(reasonCode: number, description: string): void {
-        logger.trace('Peer ' + this.socket?.remoteAddress + ' disconnected.')
+        logger.trace('Peer ' + this.remoteIpAddress + ' disconnected.')
         this.doDisconnect(reasonCode, description)
     }
 
@@ -80,16 +68,9 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
     }
 
     public send(data: Uint8Array): void {
-        // If in an Karma / Electron test, use the NodeJS implementation
-        // of Buffer instead of the browser polyfill
-
         // TODO: no need to check this.socket as it is always defined when stopped is false?
         if (!this.stopped && this.socket) {
-            if (typeof NodeJsBuffer !== 'undefined') {
-                this.socket.sendBytes(NodeJsBuffer.from(data))
-            } else {
-                this.socket.sendBytes(Buffer.from(data))
-            }
+            this.socket.send(data, { binary: true })
         } else {
             logger.debug('Tried to call send() on a stopped socket')
         }
@@ -120,26 +101,4 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
             logger.debug('Tried to destroy() a stopped connection')
         }
     }
-
-    public getRemoteAddress(): string {
-        // TODO: no need to check this.socket as it is always defined when stopped is false?
-        if (!this.stopped && this.socket) {
-            return this.socket.remoteAddress
-        } else {
-            // TODO throw
-            logger.error('Tried to get the remoteAddress of a stopped connection')
-            return ''
-        }
-    }
-
-    public getRemoteIp(): string {
-        // TODO: no need to check this.socket as it is always defined when stopped is false?
-        if (!this.stopped && this.socket) {
-            return this.socket.socket.remoteAddress!
-        } else {
-            // TODO throw
-            logger.error('Tried to get the remoteAddress of a stopped connection')
-            return ''
-        }
-    }
 }