@streamr/dht 100.2.4-beta.0 → 100.2.5-beta.0

package/karma.config.js

@@ -4,8 +4,8 @@ const { createKarmaConfig, createWebpackConfig } = require('@streamr/browser-tes
 
 const TEST_PATHS = [
     'test/unit/**/!(connectivityRequestHandler*).ts',
-    './test/integration/**/!(DhtWith*|ReplicateData*).ts/',
-    './test/end-to-end/**/!(RecoveryFromFailedAutoCertification*|memory-leak*).ts'
+    './test/integration/**/!(DhtWith*|ReplicateData*|GeoIpConnectivityChecking*).ts/',
+    './test/end-to-end/**/!(RecoveryFromFailedAutoCertification*|memory-leak*|GeoIpLayer0*).ts'
 ]
 
 const NodeWebrtcConnection = path.resolve(__dirname, 'src/connection/webrtc/NodeWebrtcConnection.ts')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamr/dht",
-  "version": "100.2.4-beta.0",
+  "version": "100.2.5-beta.0",
   "description": "Streamr Network DHT",
   "repository": {
     "type": "git",
@@ -29,17 +29,18 @@
     "@js-sdsl/ordered-map": "^4.4.2",
     "@protobuf-ts/runtime": "^2.8.2",
     "@protobuf-ts/runtime-rpc": "^2.8.2",
-    "@streamr/autocertifier-client": "100.2.4-beta.0",
-    "@streamr/cdn-location": "100.2.4-beta.0",
-    "@streamr/proto-rpc": "100.2.4-beta.0",
-    "@streamr/utils": "100.2.4-beta.0",
+    "@streamr/autocertifier-client": "100.2.5-beta.0",
+    "@streamr/cdn-location": "100.2.5-beta.0",
+    "@streamr/geoip-location": "100.2.5-beta.0",
+    "@streamr/proto-rpc": "100.2.5-beta.0",
+    "@streamr/utils": "100.2.5-beta.0",
     "eventemitter3": "^5.0.0",
     "heap": "^0.2.6",
     "ipaddr.js": "^2.0.1",
     "k-bucket": "^5.1.0",
     "lodash": "^4.17.21",
     "lru-cache": "10.2.0",
-    "node-datachannel": "^0.4.3",
+    "node-datachannel": "^0.8.0",
     "querystring": "0.2.1",
     "uuid": "^9.0.1",
     "websocket": "^1.0.34",
@@ -47,15 +48,13 @@
   },
   "devDependencies": {
     "@streamr/browser-test-runner": "^0.0.1",
-    "@streamr/test-utils": "100.2.4-beta.0",
-    "@types/express": "^4.17.21",
+    "@streamr/test-utils": "100.2.5-beta.0",
     "@types/heap": "^0.2.34",
     "@types/k-bucket": "^5.0.1",
     "@types/lodash": "^4.14.202",
     "@types/uuid": "^9.0.8",
     "@types/websocket": "^1.0.10",
     "@types/ws": "^8.5.10",
-    "express": "^4.19.2",
     "jest-leak-detector": "^27.3.1",
     "patch-package": "^8.0.0",
     "ts-essentials": "^9.4.1",

package/protos/DhtRpc.proto

@@ -206,7 +206,7 @@ message ConnectivityRequest {
   uint32 port = 1;
   bool tls = 2;
   optional string host = 3;
-  bool selfSigned = 4;
+  bool allowSelfSignedCertificate = 4;
 }
 
 message ConnectivityResponse {
@@ -215,6 +215,8 @@ message ConnectivityResponse {
   ConnectivityMethod websocket = 3;
   uint32 ipAddress = 4;
   string version = 5;
+  optional double latitude = 6;
+  optional double longitude = 7;
 }
 
 message HandshakeRequest {

package/src/connection/ConnectionManager.ts

@@ -24,6 +24,7 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { ConnectionLockRpcLocal } from './ConnectionLockRpcLocal'
 import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { getOfferer } from '../helpers/offering'
+import { ConnectionsView } from './ConnectionsView'
 
 export interface ConnectionManagerConfig {
     maxConnections?: number
@@ -93,7 +94,7 @@ export const getNodeIdOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescrip
     }
 }
 
-export class ConnectionManager extends EventEmitter<TransportEvents> implements ITransport, ConnectionLocker {
+export class ConnectionManager extends EventEmitter<TransportEvents> implements ITransport, ConnectionsView, ConnectionLocker {
 
     private config: ConnectionManagerConfig
     private readonly metricsContext: MetricsContext
@@ -158,15 +159,8 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             maxSize: 100000,  // TODO use config option or named constant?
             allowToContainReferenceId: false
         })
-        this.connections.forEach((connection, key) => {
-            // TODO: Investigate why multiple invalid WS client connections to the same
-            // server with a different nodeId can remain in the this.connections map.
-            // Seems to only happen if the ConnectionManager acting as client is not running a WS server itself.
-            if (connection.getPeerDescriptor() !== undefined && !this.hasConnection(getNodeIdFromPeerDescriptor(connection.getPeerDescriptor()!))) {
-                logger.trace(`Attempting to disconnect a hanging connection to ${getNodeIdFromPeerDescriptor(connection.getPeerDescriptor()!)}`)
-                connection.close(false).catch(() => {})
-                this.connections.delete(key)
-            } else if (!this.locks.isLocked(connection.getNodeId()) && Date.now() - connection.getLastUsedTimestamp() > maxIdleTime) {
+        this.connections.forEach((connection) => {
+            if (!this.locks.isLocked(connection.getNodeId()) && Date.now() - connection.getLastUsedTimestamp() > maxIdleTime) {
                 logger.trace('disconnecting in timeout interval: ' + getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()))
                 disconnectionCandidates.addContact(connection)
             }

package/src/connection/ConnectionsView.ts

@@ -0,0 +1,8 @@
+import { DhtAddress } from '../identifiers'
+import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+
+export interface ConnectionsView {
+    getConnections: () => PeerDescriptor[]
+    getConnectionCount: () => number
+    hasConnection: (nodeId: DhtAddress) => boolean
+}

package/src/connection/ConnectorFacade.ts

@@ -44,7 +44,8 @@ export interface DefaultConnectorFacadeConfig {
     websocketServerEnableTls?: boolean
     autoCertifierUrl?: string
     autoCertifierConfigFile?: string
-    createLocalPeerDescriptor: (connectivityResponse: ConnectivityResponse) => PeerDescriptor
+    geoIpDatabaseFolder?: string
+    createLocalPeerDescriptor: (connectivityResponse: ConnectivityResponse) => Promise<PeerDescriptor>
 }
 
 export class DefaultConnectorFacade implements ConnectorFacade {
@@ -76,7 +77,8 @@ export class DefaultConnectorFacade implements ConnectorFacade {
             autoCertifierUrl: this.config.autoCertifierUrl!,
             autoCertifierConfigFile: this.config.autoCertifierConfigFile!,
             autoCertifierTransport,
-            maxMessageSize: this.config.maxMessageSize
+            maxMessageSize: this.config.maxMessageSize,
+            geoIpDatabaseFolder: this.config.geoIpDatabaseFolder
         }
         this.websocketConnector = new WebsocketConnector(webSocketConnectorConfig)
         logger.trace(`Creating WebRtcConnectorRpcLocal`)
@@ -98,13 +100,13 @@ export class DefaultConnectorFacade implements ConnectorFacade {
         // LocalPeerDescriptor could be stored in one place and passed from there to the connectors
         const temporarilySelfSigned = (!this.config.tlsCertificate && this.config.websocketServerEnableTls === true)
         const connectivityResponse = await this.websocketConnector.checkConnectivity(temporarilySelfSigned)
-        const localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+        const localPeerDescriptor = await this.config.createLocalPeerDescriptor(connectivityResponse)
         this.setLocalPeerDescriptor(localPeerDescriptor)
         if (localPeerDescriptor.websocket && !this.config.tlsCertificate && this.config.websocketServerEnableTls) {
             try {
                 await this.websocketConnector.autoCertify()
                 const connectivityResponse = await this.websocketConnector.checkConnectivity(false)
-                const autocertifiedLocalPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+                const autocertifiedLocalPeerDescriptor = await this.config.createLocalPeerDescriptor(connectivityResponse)
                 if (autocertifiedLocalPeerDescriptor.websocket !== undefined) {
                     this.setLocalPeerDescriptor(autocertifiedLocalPeerDescriptor)
                 } else {
@@ -135,7 +137,7 @@ export class DefaultConnectorFacade implements ConnectorFacade {
         this.websocketConnector = new WebsocketConnector(webSocketConnectorConfig)
         await this.websocketConnector.start()
         const connectivityResponse = await this.websocketConnector.checkConnectivity(false)
-        const localPeerDescriptor = this.config.createLocalPeerDescriptor(connectivityResponse)
+        const localPeerDescriptor = await this.config.createLocalPeerDescriptor(connectivityResponse)
         this.setLocalPeerDescriptor(localPeerDescriptor)
     }
 

package/src/connection/connectivityChecker.ts

@@ -13,14 +13,14 @@ import { isMaybeSupportedVersion } from '../helpers/version'
 const logger = new Logger(module)
 
 // TODO use config option or named constant?
-export const connectAsync = async ({ url, selfSigned, timeoutMs = 1000 }:
-    { url: string, selfSigned: boolean, timeoutMs?: number }
+export const connectAsync = async ({ url, allowSelfSignedCertificate, timeoutMs = 1000 }:
+    { url: string, allowSelfSignedCertificate: boolean, timeoutMs?: number }
 ): Promise<IConnection> => {
     const socket = new WebsocketClientConnection()
     let result: RunAndRaceEventsReturnType<ConnectionEvents>
     try {
         result = await runAndRaceEvents3<ConnectionEvents>([
-            () => { socket.connect(url, selfSigned) }],
+            () => { socket.connect(url, allowSelfSignedCertificate) }],
         socket, ['connected', 'error'],
         timeoutMs)
     } catch (e) {
@@ -50,7 +50,7 @@ export const sendConnectivityRequest = async (
     try {
         outgoingConnection = await connectAsync({
             url,
-            selfSigned: request.selfSigned
+            allowSelfSignedCertificate: request.allowSelfSignedCertificate
         })
     } catch (e) {
         throw new Err.ConnectionFailed(`Failed to connect to entrypoint for connectivity check: ${url}`, e)

package/src/connection/connectivityRequestHandler.ts

@@ -11,12 +11,13 @@ import { IConnection } from './IConnection'
 import { WebsocketServerConnection } from './websocket/WebsocketServerConnection'
 import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
 import { LOCAL_PROTOCOL_VERSION } from '../helpers/version'
+import { GeoIpLocator } from '@streamr/geoip-location'
 
 export const DISABLE_CONNECTIVITY_PROBE = 0
 
 const logger = new Logger(module)
 
-export const attachConnectivityRequestHandler = (connectionToListenTo: WebsocketServerConnection): void => {
+export const attachConnectivityRequestHandler = (connectionToListenTo: WebsocketServerConnection, geoIpLocator?: GeoIpLocator): void => {
     connectionToListenTo.on('data', async (data: Uint8Array) => {
         logger.trace('server received data')
         try {
@@ -24,7 +25,8 @@ export const attachConnectivityRequestHandler = (connectionToListenTo: Websocket
             if (message.body.oneofKind === 'connectivityRequest') {
                 logger.trace('ConnectivityRequest received: ' + JSON.stringify(Message.toJson(message)))
                 try {
-                    await handleIncomingConnectivityRequest(connectionToListenTo, message.body.connectivityRequest)
+                    await handleIncomingConnectivityRequest(connectionToListenTo,
+                        message.body.connectivityRequest, geoIpLocator)
                     logger.trace('handleIncomingConnectivityRequest ok')
                 } catch (err1) {
                     logger.error('handleIncomingConnectivityRequest', { err: err1 })
@@ -36,9 +38,13 @@ export const attachConnectivityRequestHandler = (connectionToListenTo: Websocket
     })
 }
 
-const handleIncomingConnectivityRequest = async (connection: WebsocketServerConnection, connectivityRequest: ConnectivityRequest): Promise<void> => {
-    const host = connectivityRequest.host ?? connection.remoteIpAddress
-    const ipAddress = connection.remoteIpAddress
+const handleIncomingConnectivityRequest = async (
+    connection: WebsocketServerConnection,
+    connectivityRequest: ConnectivityRequest,
+    geoIpLocator?: GeoIpLocator
+): Promise<void> => {
+    const host = connectivityRequest.host ?? connection.getRemoteIpAddress()
+    const ipAddress = connection.getRemoteIpAddress()
     let connectivityResponse: ConnectivityResponse
     if (connectivityRequest.port !== DISABLE_CONNECTIVITY_PROBE) {
         connectivityResponse = await connectivityProbe(connectivityRequest, ipAddress, host)
@@ -51,6 +57,13 @@ const handleIncomingConnectivityRequest = async (connection: WebsocketServerConn
             version: LOCAL_PROTOCOL_VERSION
         }
     }
+    if (geoIpLocator !== undefined) {
+        const location = geoIpLocator.lookup(ipAddress)
+        if (location !== undefined) {
+            connectivityResponse.latitude = location.latitude
+            connectivityResponse.longitude = location.longitude
+        }
+    }
     const msg: Message = {
         serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
         messageId: v4(),
@@ -76,7 +89,7 @@ const connectivityProbe = async (connectivityRequest: ConnectivityRequest, ipAdd
         logger.trace(`Attempting Connectivity Check to ${url}`)
         outgoingConnection = await connectAsync({
             url,
-            selfSigned: connectivityRequest.selfSigned
+            allowSelfSignedCertificate: connectivityRequest.allowSelfSignedCertificate
         })
         logger.trace('Connectivity test produced positive result, communicating reply to the requester ' + host + ':' + connectivityRequest.port)
         connectivityResponseMessage = {

package/src/connection/{ManagedWebrtcConnection.ts → webrtc/ManagedWebrtcConnection.ts}

@@ -1,7 +1,7 @@
-import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
-import { ConnectionType } from './IConnection'
-import { ManagedConnection } from './ManagedConnection'
-import { NodeWebrtcConnection } from './webrtc/NodeWebrtcConnection'
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { ConnectionType } from '../IConnection'
+import { ManagedConnection } from '../ManagedConnection'
+import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 
 export class ManagedWebrtcConnection extends ManagedConnection {
 

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -2,7 +2,7 @@ import { IWebrtcConnection, WebrtcConnectionEvents } from './IWebrtcConnection'
 import { ConnectionType, IConnection, ConnectionID, ConnectionEvents } from '../IConnection'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import EventEmitter from 'eventemitter3'
-import nodeDatachannel, { DataChannel, DescriptionType, PeerConnection } from 'node-datachannel'
+import { DataChannel, DescriptionType, PeerConnection, cleanup, initLogger } from 'node-datachannel'
 import { Logger } from '@streamr/utils'
 import { IllegalRtcPeerConnectionState } from '../../helpers/errors'
 import { iceServerAsString } from './iceServerAsString'
@@ -16,7 +16,7 @@ const logger = new Logger(module)
 export const WEBRTC_CLEANUP = new class {
     // eslint-disable-next-line class-methods-use-this
     cleanUp(): void {
-        nodeDatachannel.cleanup()
+        cleanup()
     }
 }
 
@@ -42,7 +42,7 @@ enum RtcPeerConnectionStateEnum {
     new = 'new'
 }
 
-nodeDatachannel.initLogger('Fatal')
+initLogger('Fatal')
 
 type RtcPeerConnectionState = keyof typeof RtcPeerConnectionStateEnum
 

package/src/connection/webrtc/WebrtcConnector.ts

@@ -9,7 +9,7 @@ import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicat
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
 import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { ManagedWebrtcConnection } from '../ManagedWebrtcConnection'
+import { ManagedWebrtcConnection } from './ManagedWebrtcConnection'
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
 import { ManagedConnection } from '../ManagedConnection'

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -14,7 +14,7 @@ import { IWebrtcConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.serv
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
 import { ManagedConnection } from '../ManagedConnection'
-import { ManagedWebrtcConnection } from '../ManagedWebrtcConnection'
+import { ManagedWebrtcConnection } from './ManagedWebrtcConnection'
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
@@ -89,9 +89,9 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
                 this.config.ongoingConnectAttempts.delete(nodeId)
             }
             if (!isMaybeSupportedVersion(remoteVersion)) {
-                managedConnection!.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
+                managedConnection.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
             } else {
-                managedConnection!.acceptHandshake()
+                managedConnection.acceptHandshake()
             }
         })
         return {}

package/src/connection/websocket/AbstractWebsocketClientConnection.ts

@@ -34,7 +34,7 @@ export abstract class AbstractWebsocketClientConnection extends EventEmitter<Con
     }
 
     // TODO explicit default value for "selfSigned" or make it required
-    public abstract connect(address: string, selfSigned?: boolean): void
+    public abstract connect(address: string, allowSelfSignedCertificate: boolean): void
     
     protected abstract stopListening(): void
 

package/src/connection/websocket/WebsocketConnector.ts

@@ -30,6 +30,7 @@ import * as Err from '../../helpers/errors'
 import { Empty } from '../../proto/google/protobuf/empty'
 import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { LOCAL_PROTOCOL_VERSION, isMaybeSupportedVersion } from '../../helpers/version'
+import { GeoIpLocator } from '@streamr/geoip-location'
 
 const logger = new Logger(module)
 
@@ -39,7 +40,6 @@ export const connectivityMethodToWebsocketUrl = (ws: ConnectivityMethod, action?
     return (ws.tls ? 'wss://' : 'ws://') + ws.host + ':' + ws.port + ((action !== undefined) ? '?action=' + action : '')
 }
 
-const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 export interface WebsocketConnectorConfig {
     transport: ITransport
     onNewConnection: (connection: ManagedConnection) => boolean
@@ -53,6 +53,7 @@ export interface WebsocketConnectorConfig {
     autoCertifierUrl: string
     autoCertifierConfigFile: string
     serverEnableTls: boolean
+    geoIpDatabaseFolder?: string
 }
 
 export class WebsocketConnector {
@@ -60,6 +61,7 @@ export class WebsocketConnector {
     private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocket-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly websocketServer?: WebsocketServer
+    private geoIpLocator?: GeoIpLocator
     private readonly ongoingConnectRequests: Map<DhtAddress, ManagedConnection> = new Map()
     private host?: string
     private autoCertifierClient?: AutoCertifierClientFacade
@@ -87,17 +89,10 @@ export class WebsocketConnector {
     private registerLocalRpcMethods(config: WebsocketConnectorConfig) {
         const rpcLocal = new WebsocketConnectorRpcLocal({
             connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
-            hasConnection: (nodeId: DhtAddress): boolean => {
-                if (this.connectingConnections.has(nodeId)
-                    || this.connectingConnections.has(nodeId)
-                    || this.ongoingConnectRequests.has(nodeId)
-                    || config.hasConnection(nodeId)
-                ) {
-                    return true
-                } else {
-                    return false
-                }
-            },
+            hasConnection: (nodeId: DhtAddress): boolean => (this.connectingConnections.has(nodeId)
+                || this.ongoingConnectRequests.has(nodeId)
+                || config.hasConnection(nodeId))
+            ,
             onNewConnection: (connection: ManagedConnection) => config.onNewConnection(connection),
             abortSignal: this.abortController.signal
         })
@@ -145,9 +140,9 @@ export class WebsocketConnector {
                 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 })
+                logger.trace('WebSocket client connected', { action, remoteAddress: serverSocket.getRemoteIpAddress() })
                 if (action === 'connectivityRequest') {
-                    attachConnectivityRequestHandler(serverSocket)
+                    attachConnectivityRequestHandler(serverSocket, this.geoIpLocator)
                 } else if (action === 'connectivityProbe') {
                     // no-op
                 } else {
@@ -163,12 +158,23 @@ export class WebsocketConnector {
                     }
                 }
             })
+            
+            if (this.config.geoIpDatabaseFolder) {
+                const geoIpLocator = new GeoIpLocator(this.config.geoIpDatabaseFolder)
+                try {
+                    await geoIpLocator.start()
+                    this.geoIpLocator = geoIpLocator
+                } catch (err) {
+                    logger.error('Failed to start GeoIpLocator', { err })
+                }
+            }
+
             const port = await this.websocketServer.start()
             this.selectedPort = port
         }
     }
 
-    public async checkConnectivity(selfSigned: boolean): Promise<ConnectivityResponse> {
+    public async checkConnectivity(allowSelfSignedCertificate: boolean): Promise<ConnectivityResponse> {
         // TODO: this could throw?
         if (this.abortController.signal.aborted) {
             return {
@@ -183,9 +189,9 @@ export class WebsocketConnector {
             return {
                 host: this.host!,
                 natType: NatType.OPEN_INTERNET,
-                websocket: { 
-                    host: this.host!, 
-                    port: this.selectedPort!, 
+                websocket: {
+                    host: this.host!,
+                    port: this.selectedPort!,
                     tls: this.config.tlsCertificate !== undefined
                 },
                 // TODO: Resolve the given host name or or use as is if IP was given. 
@@ -202,7 +208,7 @@ export class WebsocketConnector {
                     port: this.selectedPort ?? DISABLE_CONNECTIVITY_PROBE,
                     host: this.host,
                     tls: this.websocketServer ? this.config.serverEnableTls : false,
-                    selfSigned
+                    allowSelfSignedCertificate
                 }
                 if (!this.abortController.signal.aborted) {
                     return await sendConnectivityRequest(connectivityRequest, entryPoint)
@@ -217,7 +223,10 @@ export class WebsocketConnector {
                 await wait(2000, this.abortController.signal)
             }
         }
-        throw new WebsocketServerStartError(`Failed to connect to the entrypoints after ${ENTRY_POINT_CONNECTION_ATTEMPTS} attempts`)
+        throw new WebsocketServerStartError(
+            `Failed to connect to the entrypoints after ${this.config.entrypoints.length} attempts\n`
+            + `Attempted hosts: ${this.config.entrypoints.map((entry) => `${entry.websocket!.host}:${entry.websocket!.port}`).join(', ')}`
+        )
     }
 
     public isPossibleToFormConnection(targetPeerDescriptor: PeerDescriptor): boolean {
@@ -260,7 +269,7 @@ export class WebsocketConnector {
             socket.on('disconnected', delFunc)
             managedConnection.on('handshakeCompleted', delFunc)
 
-            socket.connect(url)
+            socket.connect(url, false)
 
             return managedConnection
         }
@@ -307,6 +316,8 @@ export class WebsocketConnector {
             const ongoingConnectRequest = this.ongoingConnectRequests.get(nodeId)!
             if (!isMaybeSupportedVersion(remoteVersion)) {
                 ongoingConnectRequest.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
+            } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
+                ongoingConnectRequest.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
             } else {
                 ongoingConnectRequest.attachImplementation(websocketServerConnection)
                 ongoingConnectRequest.acceptHandshake()
@@ -347,5 +358,6 @@ export class WebsocketConnector {
         const attempts = Array.from(this.connectingConnections.values())
         await Promise.allSettled(attempts.map((conn) => conn.close(false)))
         await this.websocketServer?.stop()
+        await this.geoIpLocator?.stop()
     }
 }

package/src/connection/websocket/WebsocketServerConnection.ts

@@ -13,7 +13,7 @@ export class WebsocketServerConnection extends EventEmitter<ConnectionEvents> im
     public readonly connectionId: ConnectionID
     public readonly connectionType = ConnectionType.WEBSOCKET_SERVER
     public readonly resourceURL: Url
-    public readonly remoteIpAddress: string
+    private readonly remoteIpAddress: string
     private socket?: WebSocket
     private stopped = false
 
@@ -34,6 +34,11 @@ export class WebsocketServerConnection extends EventEmitter<ConnectionEvents> im
 
         this.socket = socket
     }
+    
+    // use a getter to make it possible to mock the value in tests
+    public getRemoteIpAddress(): string {
+        return this.remoteIpAddress
+    }
 
     private onMessage(message: WebSocket.RawData, isBinary: boolean): void {
         if (!isBinary) {