@streamr/dht 100.0.0-testnet-three.6 → 100.1.0

package/src/connection/ManagedConnection.ts

@@ -35,7 +35,7 @@ export class ManagedConnection extends EventEmitter<Events> {
     public connectionType: ConnectionType
     private handshaker?: Handshaker
     private handshakeCompleted = false
-    private lastUsed: number = Date.now()
+    private lastUsedTimestamp: number = Date.now()
     private stopped = false
     private bufferSentbyOtherConnection = false
     private closing = false
@@ -160,8 +160,8 @@ export class ManagedConnection extends EventEmitter<Events> {
         return getNodeIdFromPeerDescriptor(this.remotePeerDescriptor!)
     }
 
-    public getLastUsed(): number {
-        return this.lastUsed
+    public getLastUsedTimestamp(): number {
+        return this.lastUsedTimestamp
     }
 
     public setRemotePeerDescriptor(peerDescriptor: PeerDescriptor): void {
@@ -173,7 +173,7 @@ export class ManagedConnection extends EventEmitter<Events> {
     }
 
     private onHandshakeCompleted(peerDescriptor: PeerDescriptor) {
-        this.lastUsed = Date.now()
+        this.lastUsedTimestamp = Date.now()
 
         this.setRemotePeerDescriptor(peerDescriptor)
         this.handshakeCompleted = true
@@ -193,7 +193,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         this.implementation = impl
 
         impl.on('data', (bytes: Uint8Array) => {
-            this.lastUsed = Date.now()
+            this.lastUsedTimestamp = Date.now()
             if (this.listenerCount('managedData') === 0) {
                 this.inputBuffer.push(bytes)
             } else {
@@ -205,7 +205,7 @@ export class ManagedConnection extends EventEmitter<Events> {
             this.emit('error', name)
         })
         impl.on('connected', () => {
-            this.lastUsed = Date.now()
+            this.lastUsedTimestamp = Date.now()
             logger.trace('connected emitted')
             this.emit('connected')
         })
@@ -231,7 +231,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         if (this.closing) {
             throw new Err.SendFailed('ManagedConnection is closing')
         }
-        this.lastUsed = Date.now()
+        this.lastUsedTimestamp = Date.now()
 
         if (!connect && !this.implementation) {
             throw new Err.ConnectionNotOpen('Connection not open when calling send() with connect flag as false')
@@ -263,7 +263,7 @@ export class ManagedConnection extends EventEmitter<Events> {
     }
 
     public sendNoWait(data: Uint8Array): void {
-        this.lastUsed = Date.now()
+        this.lastUsedTimestamp = Date.now()
         if (this.implementation) {
             this.implementation.send(data)
         } else {

package/src/connection/connectivityChecker.ts

@@ -3,12 +3,12 @@ import { v4 } from 'uuid'
 import * as Err from '../helpers/errors'
 import {
     ConnectivityRequest, ConnectivityResponse,
-    Message, MessageType, PeerDescriptor
+    Message, PeerDescriptor
 } from '../proto/packages/dht/protos/DhtRpc'
 import { ConnectionEvents, IConnection } from './IConnection'
-import { ClientWebsocket } from './websocket/ClientWebsocket'
+import { WebsocketClientConnection } from './websocket/NodeWebsocketClientConnection'
 import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
-import { isCompatibleVersion } from '../helpers/versionCompatibility'
+import { isMaybeSupportedVersion } from '../helpers/version'
 
 const logger = new Logger(module)
 
@@ -16,7 +16,7 @@ const logger = new Logger(module)
 export const connectAsync = async ({ url, selfSigned, timeoutMs = 1000 }:
     { url: string, selfSigned: boolean, timeoutMs?: number }
 ): Promise<IConnection> => {
-    const socket = new ClientWebsocket()
+    const socket = new WebsocketClientConnection()
     let result: RunAndRaceEventsReturnType<ConnectionEvents>
     try {
         result = await runAndRaceEvents3<ConnectionEvents>([
@@ -37,8 +37,7 @@ const CONNECTIVITY_CHECKER_TIMEOUT = 5000
 
 export const sendConnectivityRequest = async (
     request: ConnectivityRequest,
-    entryPoint: PeerDescriptor,
-    localVersion: string
+    entryPoint: PeerDescriptor
 ): Promise<ConnectivityResponse> => {
     let outgoingConnection: IConnection
     const wsServerInfo = {
@@ -59,7 +58,7 @@ export const sendConnectivityRequest = async (
     // send connectivity request
     const msg: Message = {
         serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
-        messageType: MessageType.CONNECTIVITY_REQUEST, messageId: v4(),
+        messageId: v4(),
         body: {
             oneofKind: 'connectivityRequest',
             connectivityRequest: request
@@ -83,16 +82,16 @@ export const sendConnectivityRequest = async (
                         const remoteVersion = connectivityResponseMessage.version
                         outgoingConnection!.off('data', listener)
                         clearTimeout(timeoutId)
-                        if (isCompatibleVersion(localVersion, remoteVersion)) {
+                        if (isMaybeSupportedVersion(remoteVersion)) {
                             resolve(connectivityResponseMessage)
                         } else {
-                            reject(`Invalid version: ${remoteVersion}`)
+                            reject(`Unsupported version: ${remoteVersion}`)
                         }
                     } else {
                         return
                     }
                 } catch (err) {
-                    logger.trace(`Could not parse message: ${err}`)
+                    logger.trace('Could not parse message', { err })
                 }
             }
             outgoingConnection!.on('data', listener)

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 {
@@ -25,19 +26,19 @@ export const attachConnectivityRequestHandler = (connectionToListenTo: ServerWeb
                 try {
                     await handleIncomingConnectivityRequest(connectionToListenTo, message.body.connectivityRequest)
                     logger.trace('handleIncomingConnectivityRequest ok')
-                } catch (e) {
-                    logger.error('handleIncomingConnectivityRequest', { error: e })
+                } catch (err1) {
+                    logger.error('handleIncomingConnectivityRequest', { err: err1 })
                 }
             }
-        } catch (err) {
-            logger.trace(`Could not parse message: ${err}`)
+        } catch (err2) {
+            logger.trace('Could not parse message', { err: err2 })
         }
     })
 }
 
-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/BrowserWebrtcConnection.ts

@@ -5,6 +5,12 @@ import { Logger } from '@streamr/utils'
 import { IceServer } from './WebrtcConnector'
 import { createRandomConnectionId } from '../Connection'
 
+enum DisconnectedRtcPeerConnectionStateEnum {
+    DISCONNECTED = 'disconnected',
+    FAILED = 'failed',
+    CLOSED = 'closed',
+}
+
 const logger = new Logger(module)
 
 export const WEBRTC_CLEANUP = new class {
@@ -58,6 +64,8 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
             logger.trace(`conn.onGatheringStateChange: ${this.peerConnection?.iceGatheringState}`)
         }
 
+        this.peerConnection.onconnectionstatechange = () => this.onStateChange()
+
         if (isOffering) {
             this.peerConnection.onnegotiationneeded = async () => {
                 try {
@@ -211,6 +219,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         }
 
         if (this.peerConnection !== undefined) {
+            this.peerConnection.onconnectionstatechange = null
             this.peerConnection.onicecandidate = null
             this.peerConnection.onicegatheringstatechange = null
             this.peerConnection.onnegotiationneeded = null
@@ -223,6 +232,15 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         this.emit('connected')
     }
 
+    private onStateChange(): void {
+        if (this.peerConnection!.connectionState === DisconnectedRtcPeerConnectionStateEnum.CLOSED
+            || this.peerConnection!.connectionState === DisconnectedRtcPeerConnectionStateEnum.DISCONNECTED
+            || this.peerConnection!.connectionState === DisconnectedRtcPeerConnectionStateEnum.FAILED
+        ) {
+            this.doClose(false)
+        }
+    }
+
     public setConnectionId(connectionId: ConnectionID): void {
         this.connectionId = connectionId
     }

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/{ClientWebsocket.ts → AbstractWebsocketClientConnection.ts}

@@ -1,10 +1,14 @@
-import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
-import { ICloseEvent, IMessageEvent, w3cwebsocket as Websocket } from 'websocket'
-import { ConnectionEvents, ConnectionID, ConnectionType, IConnection } from '../IConnection'
 import { createRandomConnectionId } from '../Connection'
+import { ConnectionEvents, ConnectionID, ConnectionType, IConnection } from '../IConnection'
+import { Logger } from '@streamr/utils'
 
-const logger = new Logger(module)
+export interface Socket {
+    binaryType: string
+    readyState: number
+    close(code?: number, reason?: string): void
+    send(data: string | Buffer | ArrayBuffer | ArrayBufferView): void
+}
 
 // https://kapeli.com/cheat_sheets/WebSocket_Status_Codes.docset/Contents/Resources/Documents/index
 // Browsers send this automatically when closing a tab
@@ -12,78 +16,33 @@ export const GOING_AWAY = 1001
 // The GOING_AWAY is a reserved code and we shouldn't send that from the application. Therefore
 // we have a custom counterpart
 export const CUSTOM_GOING_AWAY = 3001
+// https://github.com/websockets/ws/blob/master/doc/ws.md#ready-state-constants
+const OPEN = 1
 
-const BINARY_TYPE = 'arraybuffer'
+const logger = new Logger(module)
 
-export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements IConnection {
+export abstract class AbstractWebsocketClientConnection extends EventEmitter<ConnectionEvents> implements IConnection {
 
     public readonly connectionId: ConnectionID
-    private socket?: Websocket
+    protected abstract socket?: Socket
     public connectionType = ConnectionType.WEBSOCKET_CLIENT
-
-    private destroyed = false
-
+    protected destroyed = false
+    
     constructor() {
         super()
         this.connectionId = createRandomConnectionId()
     }
 
     // TODO explicit default value for "selfSigned" or make it required
-    public connect(address: string, selfSigned?: boolean): void {
-        if (!this.destroyed) {
-            this.socket = new Websocket(address, undefined, undefined, undefined, { rejectUnauthorized: !selfSigned })
-            this.socket.binaryType = BINARY_TYPE
-            this.socket.onerror = (error: Error) => {
-                if (!this.destroyed) {
-                    logger.trace('WebSocket Client error: ' + error?.message, { error })
-                    this.emit('error', error.name)
-                }
-            }
-
-            this.socket.onopen = () => {
-                if (!this.destroyed) {
-                    logger.trace('WebSocket Client Connected')
-                    if (this.socket && this.socket.readyState === this.socket.OPEN) {
-                        this.emit('connected')
-                    }
-                }
-            }
-
-            this.socket.onclose = (event: ICloseEvent) => {
-                if (!this.destroyed) {
-                    logger.trace('Websocket Closed')
-                    this.doDisconnect(event.code, event.reason)
-                }
-            }
-
-            this.socket.onmessage = (message: IMessageEvent) => {
-                if (!this.destroyed) {
-                    if (typeof message.data === 'string') {
-                        logger.debug('Received string: \'' + message.data + '\'')
-                    } else {
-                        this.emit('data', new Uint8Array(message.data))
-                    }
-                }
-            }
-        } else {
-            logger.debug('Tried to connect() a stopped connection')
-        }
-    }
-
-    private doDisconnect(code?: number, reason?: string) {
-        this.destroyed = true
-        this.stopListening()
-        this.socket = undefined
-        const gracefulLeave = (code === GOING_AWAY) || (code === CUSTOM_GOING_AWAY)
-        this.emit('disconnected', gracefulLeave, code, reason)
-        this.removeAllListeners()
-    }
+    public abstract connect(address: string, selfSigned?: boolean): void
+    
+    protected abstract stopListening(): void
 
     public send(data: Uint8Array): void {
         if (!this.destroyed) {
-            if (this.socket && this.socket.readyState === this.socket.OPEN) {
+            if (this.socket && this.socket.readyState === OPEN) {
                 logger.trace(`Sending data with size ${data.byteLength}`)
-                this.socket?.send(data.buffer)
+                this.socket?.send(data)
             } else {
                 logger.debug('Tried to send data on a non-open connection')
             }
@@ -103,15 +62,6 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
         }
     }
 
-    private stopListening(): void {
-        if (this.socket) {
-            this.socket.onopen = undefined as unknown as (() => void)
-            this.socket.onclose = undefined as unknown as (() => void)
-            this.socket.onerror = undefined as unknown as (() => void)
-            this.socket.onmessage = undefined as unknown as (() => void)
-        }
-    }
-
     public destroy(): void {
         logger.trace('destroy() a connection')
         if (!this.destroyed) {
@@ -126,4 +76,41 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
             logger.debug('Tried to destroy() a stopped connection')
         }
     }
+
+    protected onOpen(): void {
+        if (!this.destroyed) {
+            logger.trace('WebSocket Client Connected')
+            if (this.socket && this.socket.readyState === OPEN) {
+                this.emit('connected')
+            }
+        }
+    }
+
+    protected onMessage(message: Uint8Array): void {
+        this.emit('data', message)
+    }
+
+    protected onClose(code: number, reason: string): void {
+        if (!this.destroyed) {
+            logger.trace('Websocket Closed')
+            this.doDisconnect(code, reason)
+        }
+    }
+
+    protected onError(error: Error): void {
+        if (!this.destroyed) {
+            logger.trace('WebSocket Client error: ' + error?.message, { error })
+            this.emit('error', error.name)
+        }
+    }
+
+    protected doDisconnect(code?: number, reason?: string): void {
+        this.destroyed = true
+        this.stopListening()
+        this.socket = undefined
+        const gracefulLeave = (code === GOING_AWAY) || (code === CUSTOM_GOING_AWAY)
+        this.emit('disconnected', gracefulLeave, code, reason)
+        this.removeAllListeners()
+    }
+
 }

package/src/connection/websocket/BrowserWebsocketClientConnection.ts

@@ -0,0 +1,44 @@
+import { Logger } from '@streamr/utils'
+import { ICloseEvent, IMessageEvent, w3cwebsocket as Websocket } from 'websocket'
+import { AbstractWebsocketClientConnection } from './AbstractWebsocketClientConnection'
+
+const logger = new Logger(module)
+
+const BINARY_TYPE = 'arraybuffer'
+
+export class WebsocketClientConnection extends AbstractWebsocketClientConnection {
+
+    protected socket?: Websocket 
+
+    // TODO explicit default value for "selfSigned" or make it required
+    public connect(address: string, selfSigned?: boolean): void {
+        if (!this.destroyed) {
+            this.socket = new Websocket(address, undefined, undefined, undefined, { rejectUnauthorized: !selfSigned })
+            this.socket.binaryType = BINARY_TYPE
+            this.socket.onerror = (error: Error) => this.onError(error)
+            this.socket.onopen = () => this.onOpen()
+            this.socket.onclose = (event: ICloseEvent) => this.onClose(event.code, event.reason)
+            this.socket.onmessage = (message: IMessageEvent) => {
+                if (!this.destroyed) {
+                    if (typeof message.data === 'string') {
+                        logger.debug('Received string data, only binary data is supported')
+                    } else {
+                        this.onMessage(new Uint8Array(message.data))
+                    }
+                }
+            }
+        } else {
+            logger.debug('Tried to connect() a stopped connection')
+        }
+    }
+
+    protected stopListening(): void {
+        if (this.socket) {
+            this.socket.onopen = undefined as unknown as (() => void)
+            this.socket.onclose = undefined as unknown as (() => void)
+            this.socket.onerror = undefined as unknown as (() => void)
+            this.socket.onmessage = undefined as unknown as (() => void)
+        }
+    }
+
+}

package/src/connection/websocket/NodeWebsocketClientConnection.ts

@@ -0,0 +1,39 @@
+import { Logger, binaryToUtf8 } from '@streamr/utils'
+import { WebSocket } from 'ws'
+import { AbstractWebsocketClientConnection } from './AbstractWebsocketClientConnection'
+
+const logger = new Logger(module)
+
+const BINARY_TYPE = 'nodebuffer'
+
+export class WebsocketClientConnection extends AbstractWebsocketClientConnection {
+
+    protected socket?: WebSocket
+
+    // TODO explicit default value for "selfSigned" or make it required
+    public connect(address: string, selfSigned?: boolean): void {
+        if (!this.destroyed) {
+            this.socket = new WebSocket(address, { rejectUnauthorized: !selfSigned })
+            this.socket.binaryType = BINARY_TYPE
+            this.socket.on('error', (error: Error) => this.onError(error))
+            this.socket.on('open', () => this.onOpen())
+            this.socket.on('close', (code: number, reason: Buffer) => this.onClose(code, binaryToUtf8(reason)))
+            this.socket.on('message', (message: Buffer, isBinary: boolean) => {
+                if (!this.destroyed) {
+                    if (isBinary === false) {
+                        logger.debug('Received string data, only binary data is supported')
+                    } else {
+                        this.onMessage(new Uint8Array(message))
+                    }
+                }
+            })
+        } else {
+            logger.debug('Tried to connect() a stopped connection')
+        }
+    }
+
+    protected stopListening(): void {
+        this.socket?.removeAllListeners()
+    }
+
+}