@streamr/dht 101.1.2 → 102.0.0-beta.1

package/src/connection/simulator/SimulatorConnection.ts

@@ -1,10 +1,10 @@
 import { ConnectionType, IConnection } from '../IConnection'
 import { Simulator } from './Simulator'
-import { Message, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { Message, PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
 import { Connection } from '../Connection'
 import { Logger } from '@streamr/utils'
 import { protoToString } from '../../helpers/protoToString'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { toNodeId } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -45,15 +45,15 @@ export class SimulatorConnection extends Connection implements IConnection {
             this.simulator.send(this, data)
 
         } else {
-            const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
-            const targetNodeId = getNodeIdFromPeerDescriptor(this.targetPeerDescriptor)
+            const localNodeId = toNodeId(this.localPeerDescriptor)
+            const targetNodeId = toNodeId(this.targetPeerDescriptor)
             logger.error(localNodeId + ', ' + targetNodeId + 'tried to send() on a stopped connection')
         }
     }
 
     public async close(gracefulLeave: boolean): Promise<void> {
-        const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
-        const targetNodeId = getNodeIdFromPeerDescriptor(this.targetPeerDescriptor)
+        const localNodeId = toNodeId(this.localPeerDescriptor)
+        const targetNodeId = toNodeId(this.targetPeerDescriptor)
 
         logger.trace(localNodeId + ', ' + targetNodeId + ' close()')
         if (!this.stopped) {
@@ -104,7 +104,7 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public handleIncomingDisconnection(): void {
         if (!this.stopped) {
-            const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
+            const localNodeId = toNodeId(this.localPeerDescriptor)
             logger.trace(localNodeId + ' handleIncomingDisconnection()')
             this.stopped = true
             this.doDisconnect(false)
@@ -114,7 +114,7 @@ export class SimulatorConnection extends Connection implements IConnection {
     }
 
     public destroy(): void {
-        const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
+        const localNodeId = toNodeId(this.localPeerDescriptor)
         if (!this.stopped) {
             logger.trace(localNodeId + ' destroy()')
             this.removeAllListeners()
@@ -125,8 +125,8 @@ export class SimulatorConnection extends Connection implements IConnection {
     }
 
     private doDisconnect(gracefulLeave: boolean) {
-        const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
-        const targetNodeId = getNodeIdFromPeerDescriptor(this.targetPeerDescriptor)
+        const localNodeId = toNodeId(this.localPeerDescriptor)
+        const targetNodeId = toNodeId(this.targetPeerDescriptor)
         logger.trace(localNodeId + ' doDisconnect()')
         this.stopped = true
 

package/src/connection/simulator/SimulatorConnector.ts

@@ -3,11 +3,11 @@ import { ConnectionType } from '../IConnection'
 import {
     HandshakeError,
     PeerDescriptor,
-} from '../../proto/packages/dht/protos/DhtRpc'
+} from '../../../generated/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
 import { Simulator } from './Simulator'
 import { SimulatorConnection } from './SimulatorConnection'
-import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { DhtAddress, toNodeId } from '../../identifiers'
 import { acceptHandshake, createIncomingHandshaker, createOutgoingHandshaker, rejectHandshake } from '../Handshaker'
 import { PendingConnection } from '../PendingConnection'
 
@@ -32,8 +32,8 @@ export class SimulatorConnector {
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): PendingConnection {
-        logger.trace('connect() ' + getNodeIdFromPeerDescriptor(targetPeerDescriptor))
-        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        logger.trace('connect() ' + toNodeId(targetPeerDescriptor))
+        const nodeId = toNodeId(targetPeerDescriptor)
         const existingConnection = this.connectingConnections.get(nodeId)
         if (existingConnection) {
             return existingConnection
@@ -65,7 +65,7 @@ export class SimulatorConnector {
     public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
         // connection is incoming, so remotePeerDescriptor is localPeerDescriptor
         const remotePeerDescriptor = sourceConnection.localPeerDescriptor
-        const remoteNodeId = getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor)
+        const remoteNodeId = toNodeId(sourceConnection.localPeerDescriptor)
         logger.trace(remoteNodeId + ' incoming connection, stopped: ' + this.stopped)
         if (this.stopped) {
             return

package/src/connection/simulator/SimulatorTransport.ts

@@ -1,5 +1,5 @@
 import { MetricsContext } from '@streamr/utils'
-import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
 import { ConnectionManager } from '../ConnectionManager'
 import { Simulator } from './Simulator'
 import { SimulatorConnectorFacade } from '../ConnectorFacade'
@@ -8,7 +8,8 @@ export class SimulatorTransport extends ConnectionManager {
     constructor(localPeerDescriptor: PeerDescriptor, simulator: Simulator) {
         super({
             createConnectorFacade: () => new SimulatorConnectorFacade(localPeerDescriptor, simulator),
-            metricsContext: new MetricsContext()
+            metricsContext: new MetricsContext(),
+            allowIncomingPrivateConnections: false
         })
     }
 }

package/src/connection/simulator/pings.ts

@@ -25,7 +25,7 @@ export const regionPingMatrix = [
     [205.555, 178.082, 186.533, 195.774, 216.701, 117.089, 128.001, 175.761, 176.018, 125.551, 303.904, 285.782, 323.15, 309.618, 255.904, 0.262]
 ]
 
-export function getRegionDelayMatrix(): Array<Array<number>> {
+export function getRegionDelayMatrix(): number[][] {
     const ret = []
     for (let i = 0; i < regionPingMatrix.length; i++) {
         const row = []

package/src/connection/webrtc/BrowserWebrtcConnection.ts

@@ -2,7 +2,7 @@ import EventEmitter from 'eventemitter3'
 import { WebrtcConnectionEvents, IWebrtcConnection, RtcDescription } from './IWebrtcConnection'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
 import { Logger } from '@streamr/utils'
-import { IceServer } from './WebrtcConnector'
+import { EARLY_TIMEOUT, IceServer } from './WebrtcConnector'
 import { createRandomConnectionId } from '../Connection'
 
 enum DisconnectedRtcPeerConnectionStateEnum {
@@ -32,11 +32,15 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
     private makingOffer = false
     private isOffering = false
     private closed = false
+    private earlyTimeout: NodeJS.Timeout
 
     constructor(params: Params) {
         super()
         this.connectionId = createRandomConnectionId()
         this.iceServers = params.iceServers ?? []
+        this.earlyTimeout = setTimeout(() => {
+            this.doClose(false, 'timed out due to remote descriptor not being set')
+        }, EARLY_TIMEOUT)
     }
 
     public start(isOffering: boolean): void {
@@ -55,6 +59,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         }
 
         this.peerConnection.onicegatheringstatechange = () => {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
             logger.trace(`conn.onGatheringStateChange: ${this.peerConnection?.iceGatheringState}`)
         }
 
@@ -95,6 +100,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         }
         try {
             await this.peerConnection?.setRemoteDescription({ sdp: description, type: type.toLowerCase() as RTCSdpType })
+            clearTimeout(this.earlyTimeout)
         } catch (err) {
             logger.warn('Failed to set remote description', { err })
         }
@@ -132,6 +138,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         if (!this.closed) {
             this.closed = true
             this.lastState = 'closed'
+            clearTimeout(this.earlyTimeout)
 
             this.stopListening()
             this.emit('disconnected', gracefulLeave, undefined, reason)
@@ -175,6 +182,8 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
 
     private setupDataChannel(dataChannel: RTCDataChannel): void {
         this.dataChannel = dataChannel
+        this.dataChannel.binaryType = 'arraybuffer'
+
         dataChannel.onopen = () => {
             logger.trace('dc.onOpen')
             this.onDataChannelOpen()

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -1,16 +1,14 @@
 import { IWebrtcConnection, WebrtcConnectionEvents } from './IWebrtcConnection'
 import { ConnectionType, IConnection, ConnectionID, ConnectionEvents } from '../IConnection'
-import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
 import EventEmitter from 'eventemitter3'
-// TODO: why does eslint import rule plugin not work?
-// eslint-disable-next-line import/no-unresolved
 import { DataChannel, DescriptionType, PeerConnection, initLogger } from 'node-datachannel'
 import { Logger } from '@streamr/utils'
 import { IllegalRtcPeerConnectionState } from '../../helpers/errors'
 import { iceServerAsString } from './iceServerAsString'
-import { IceServer } from './WebrtcConnector'
+import { IceServer, EARLY_TIMEOUT } from './WebrtcConnector'
 import { PortRange } from '../ConnectionManager'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { toNodeId } from '../../identifiers'
 import { createRandomConnectionId } from '../Connection'
 
 const logger = new Logger(module)
@@ -58,6 +56,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     private readonly maxMessageSize?: number
     private closed = false
     private offering?: boolean
+    private readonly earlyTimeout: NodeJS.Timeout
 
     constructor(params: Params) {
         super()
@@ -69,10 +68,13 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
         this.remotePeerDescriptor = params.remotePeerDescriptor
         this.maxMessageSize = params.maxMessageSize ?? 1048576
         this.portRange = params.portRange
+        this.earlyTimeout = setTimeout(() => {
+            this.doClose(false, 'timed out due to remote descriptor not being set')
+        }, EARLY_TIMEOUT)
     }
 
     public start(isOffering: boolean): void {
-        const nodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+        const nodeId = toNodeId(this.remotePeerDescriptor)
         this.offering = isOffering
         logger.trace(`Starting new connection for peer ${nodeId}`, { isOffering })
         this.connection = new PeerConnection(nodeId, {
@@ -101,7 +103,8 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
 
     public async setRemoteDescription(description: string, type: string): Promise<void> {
         if (this.connection) {
-            const remoteNodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+            clearTimeout(this.earlyTimeout)
+            const remoteNodeId = toNodeId(this.remotePeerDescriptor)
             try {
                 logger.trace(`Setting remote descriptor for peer: ${remoteNodeId}`)
                 this.connection.setRemoteDescription(description, type as DescriptionType)
@@ -117,7 +120,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     public addRemoteCandidate(candidate: string, mid: string): void {
         if (this.connection) {
             if (this.remoteDescriptionSet) {
-                const remoteNodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+                const remoteNodeId = toNodeId(this.remotePeerDescriptor)
                 try {
                     logger.trace(`Setting remote candidate for peer: ${remoteNodeId}`)
                     this.connection.addRemoteCandidate(candidate, mid)
@@ -138,7 +141,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
             try {
                 this.dataChannel!.sendMessageBinary(data as Buffer)
             } catch (err) {
-                const remoteNodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+                const remoteNodeId = toNodeId(this.remotePeerDescriptor)
                 logger.debug('Failed to send binary message to ' + remoteNodeId + err)
             }
         }
@@ -150,7 +153,8 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
 
     private doClose(gracefulLeave: boolean, reason?: string): void {
         if (!this.closed) {
-            const remoteNodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+            clearTimeout(this.earlyTimeout)
+            const remoteNodeId = toNodeId(this.remotePeerDescriptor)
             logger.trace(`Closing Node WebRTC Connection to ${remoteNodeId}` + `${(reason !== undefined) ? `, reason: ${reason}` : ''}`)
 
             this.closed = true
@@ -210,7 +214,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     }
 
     private onDataChannelOpen(): void {
-        logger.trace(`DataChannel opened for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
+        logger.trace(`DataChannel opened for peer ${toNodeId(this.remotePeerDescriptor)}`)
         this.emit('connected')
     }
 

package/src/connection/webrtc/WebrtcConnector.ts

@@ -4,21 +4,21 @@ import {
     PeerDescriptor,
     RtcAnswer,
     RtcOffer, WebrtcConnectionRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
+} from '../../../generated/packages/dht/protos/DhtRpc'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
-import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { WebrtcConnectorRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
 import { PortRange } from '../ConnectionManager'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { WebrtcConnectorRpcLocal } from './WebrtcConnectorRpcLocal'
-import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, toNodeId } from '../../identifiers'
 import { getOfferer } from '../../helpers/offering'
 import { acceptHandshake, createIncomingHandshaker, createOutgoingHandshaker, rejectHandshake } from '../Handshaker'
-import { isMaybeSupportedVersion } from '../../helpers/version'
+import { isMaybeSupportedProtocolVersion } from '../../helpers/version'
 import { PendingConnection } from '../PendingConnection'
 
 const logger = new Logger(module)
@@ -32,6 +32,8 @@ export const replaceInternalIpWithExternalIp = (candidate: string, ip: string):
     return parsed.join(' ')
 }
 
+export const EARLY_TIMEOUT = 5000
+
 export interface WebrtcConnectorOptions {
     onNewConnection: (connection: PendingConnection) => boolean
     transport: ITransport
@@ -127,9 +129,9 @@ export class WebrtcConnector {
             throw new Err.CannotConnectToSelf('Cannot open WebRTC Connection to self')
         }
 
-        logger.trace(`Opening WebRTC connection to ${getNodeIdFromPeerDescriptor(targetPeerDescriptor)}`)
+        logger.trace(`Opening WebRTC connection to ${toNodeId(targetPeerDescriptor)}`)
 
-        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const nodeId = toNodeId(targetPeerDescriptor)
         const existingConnection = this.ongoingConnectAttempts.get(nodeId)
         if (existingConnection) {
             return existingConnection.managedConnection
@@ -137,8 +139,8 @@ export class WebrtcConnector {
 
         const connection = this.createConnection(targetPeerDescriptor)
 
-        const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor!)
-        const targetNodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const localNodeId = toNodeId(this.localPeerDescriptor!)
+        const targetNodeId = toNodeId(targetPeerDescriptor)
         const offering = (getOfferer(localNodeId, targetNodeId) === 'local')
         let pendingConnection: PendingConnection
         const remoteConnector = new WebrtcConnectorRpcRemote(
@@ -167,8 +169,8 @@ export class WebrtcConnector {
                 remoteConnector.sendRtcAnswer(description, connection.connectionId)
             })
             handshaker.on('handshakeRequest', (_sourceDescriptor: PeerDescriptor, remoteVersion: string) => {
-                if (!isMaybeSupportedVersion(remoteVersion)) {
-                    rejectHandshake(pendingConnection!, connection, handshaker, HandshakeError.UNSUPPORTED_VERSION)
+                if (!isMaybeSupportedProtocolVersion(remoteVersion)) {
+                    rejectHandshake(pendingConnection!, connection, handshaker, HandshakeError.UNSUPPORTED_PROTOCOL_VERSION)
                 } else {
                     acceptHandshake(handshaker, pendingConnection, connection)
                 }
@@ -224,7 +226,7 @@ export class WebrtcConnector {
         const attempts = Array.from(this.ongoingConnectAttempts.values())
         await Promise.allSettled(attempts.map(async (conn) => {
             conn.connection.destroy()
-            await conn.managedConnection.close(false)
+            conn.managedConnection.close(false)
         }))
 
         this.rpcCommunicator.destroy()

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -1,18 +1,18 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { Logger } from '@streamr/utils'
 import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
-import { Empty } from '../../proto/google/protobuf/empty'
+import { Empty } from '../../../generated/google/protobuf/empty'
 import {
     IceCandidate,
     PeerDescriptor,
     RtcAnswer,
     RtcOffer
-} from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebrtcConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+} from '../../../generated/packages/dht/protos/DhtRpc'
+import { IWebrtcConnectorRpc } from '../../../generated/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
-import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { DhtAddress, toNodeId } from '../../identifiers'
 import { ConnectionID } from '../IConnection'
 import { ConnectingConnection } from './WebrtcConnector'
 import { PendingConnection } from '../PendingConnection'
@@ -39,7 +39,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async requestConnection(context: ServerCallContext): Promise<Empty> {
         const targetPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (this.options.ongoingConnectAttempts.has(getNodeIdFromPeerDescriptor(targetPeerDescriptor))) {
+        if (this.options.ongoingConnectAttempts.has(toNodeId(targetPeerDescriptor))) {
             return {}
         }
         const pendingConnection = this.options.connect(targetPeerDescriptor, false)
@@ -49,7 +49,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async rtcOffer(request: RtcOffer, context: ServerCallContext): Promise<Empty> {
         const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
+        const nodeId = toNodeId(remotePeerDescriptor)
         let connection: NodeWebrtcConnection
         let pendingConnection: PendingConnection
 
@@ -69,7 +69,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async rtcAnswer(request: RtcAnswer, context: ServerCallContext): Promise<Empty> {
         const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
+        const nodeId = toNodeId(remotePeerDescriptor)
         const connection = this.options.ongoingConnectAttempts.get(nodeId)?.connection
         if (!connection) {
             return {}
@@ -83,7 +83,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async iceCandidate(request: IceCandidate, context: ServerCallContext): Promise<Empty> {
         const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
+        const nodeId = toNodeId(remotePeerDescriptor)
         const connection = this.options.ongoingConnectAttempts.get(nodeId)?.connection
         if (!connection) {
             return {}

package/src/connection/webrtc/WebrtcConnectorRpcRemote.ts

@@ -5,8 +5,8 @@ import {
     RtcAnswer,
     RtcOffer,
     WebrtcConnectionRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
-import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+} from '../../../generated/packages/dht/protos/DhtRpc'
+import { WebrtcConnectorRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
 
 const logger = new Logger(module)
 

package/src/connection/websocket/WebsocketClientConnector.ts

@@ -6,13 +6,13 @@ import {
     ConnectivityMethod,
     PeerDescriptor,
     WebsocketConnectionRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
+} from '../../../generated/packages/dht/protos/DhtRpc'
 import { WebsocketServer } from './WebsocketServer'
 import { createOutgoingHandshaker } from '../Handshaker'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { expectedConnectionType } from '../../helpers/Connectivity'
-import { Empty } from '../../proto/google/protobuf/empty'
-import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { Empty } from '../../../generated/google/protobuf/empty'
+import { DhtAddress, toNodeId } from '../../identifiers'
 import { GeoIpLocator } from '@streamr/geoip-location'
 import { PendingConnection } from '../PendingConnection'
 
@@ -73,7 +73,7 @@ export class WebsocketClientConnector {
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): PendingConnection {
-        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const nodeId = toNodeId(targetPeerDescriptor)
         const existingConnection = this.connectingConnections.get(nodeId)
         if (existingConnection) {
             return existingConnection
@@ -114,6 +114,6 @@ export class WebsocketClientConnector {
         await Promise.allSettled(requests.map((conn) => conn.close(true)))
 
         await this.websocketServer?.stop()
-        await this.geoIpLocator?.stop()
+        this.geoIpLocator?.stop()
     }
 }

package/src/connection/websocket/WebsocketClientConnectorRpcLocal.ts

@@ -2,11 +2,11 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import {
     PeerDescriptor,
     WebsocketConnectionRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebsocketClientConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+} from '../../../generated/packages/dht/protos/DhtRpc'
+import { IWebsocketClientConnectorRpc } from '../../../generated/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
-import { Empty } from '../../proto/google/protobuf/empty'
-import { getNodeIdFromPeerDescriptor, DhtAddress } from '../../identifiers'
+import { Empty } from '../../../generated/google/protobuf/empty'
+import { toNodeId, DhtAddress } from '../../identifiers'
 import { PendingConnection } from '../PendingConnection'
 
 interface WebsocketClientConnectorRpcLocalOptions {
@@ -29,7 +29,7 @@ export class WebsocketClientConnectorRpcLocal implements IWebsocketClientConnect
             return {}
         }
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (!this.options.hasConnection(getNodeIdFromPeerDescriptor(senderPeerDescriptor))) {
+        if (!this.options.hasConnection(toNodeId(senderPeerDescriptor))) {
             const connection = this.options.connect(senderPeerDescriptor)
             this.options.onNewConnection(connection)
         }

package/src/connection/websocket/WebsocketClientConnectorRpcRemote.ts

@@ -1,17 +1,17 @@
 import {
     WebsocketConnectionRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
+} from '../../../generated/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
 import { RpcRemote } from '../../dht/contact/RpcRemote'
-import { WebsocketClientConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { WebsocketClientConnectorRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
+import { toNodeId } from '../../identifiers'
 
 const logger = new Logger(module)
 
 export class WebsocketClientConnectorRpcRemote extends RpcRemote<WebsocketClientConnectorRpcClient> {
 
     async requestConnection(): Promise<void> {
-        logger.trace(`Requesting WebSocket connection from ${getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
+        logger.trace(`Requesting WebSocket connection from ${toNodeId(this.getLocalPeerDescriptor())}`)
         const request: WebsocketConnectionRequest = {}
         const options = this.formDhtRpcOptions()
         return this.getClient().requestConnection(request, options)

package/src/connection/websocket/WebsocketServerConnector.ts

@@ -2,9 +2,9 @@ import { GeoIpLocator } from '@streamr/geoip-location'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
 import { Action, connectivityMethodToWebsocketUrl } from './WebsocketClientConnector'
 import { WebsocketServer } from './WebsocketServer'
-import { areEqualPeerDescriptors, DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { areEqualPeerDescriptors, DhtAddress, toNodeId } from '../../identifiers'
 import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
-import { ConnectivityResponse, HandshakeError, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { ConnectivityResponse, HandshakeError, PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
 import { ITransport } from '../../transport/ITransport'
 import { ipv4ToNumber, Logger, wait } from '@streamr/utils'
@@ -12,12 +12,12 @@ import { attachConnectivityRequestHandler, DISABLE_CONNECTIVITY_PROBE } from '..
 import { WebsocketServerConnection } from './WebsocketServerConnection'
 import { ConnectionType, IConnection } from '../IConnection'
 import queryString from 'querystring'
-import { isMaybeSupportedVersion, LOCAL_PROTOCOL_VERSION } from '../../helpers/version'
+import { isMaybeSupportedProtocolVersion, LOCAL_PROTOCOL_VERSION } from '../../helpers/version'
 import { shuffle } from 'lodash'
 import { sendConnectivityRequest } from '../connectivityChecker'
 import { acceptHandshake, Handshaker, rejectHandshake } from '../Handshaker'
 import { WebsocketClientConnectorRpcRemote } from './WebsocketClientConnectorRpcRemote'
-import { WebsocketClientConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { WebsocketClientConnectorRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
 import { WebsocketServerStartError } from '../../helpers/errors'
 import * as Err from '../../helpers/errors'
 import { expectedConnectionType } from '../../helpers/Connectivity'
@@ -114,23 +114,27 @@ export class WebsocketServerConnector {
     private attachHandshaker(connection: IConnection) {
         // TODO: use createIncomingHandshaker here?
         const handshaker = new Handshaker(this.localPeerDescriptor!, connection)
-        handshaker.once('handshakeRequest', (localPeerDescriptor: PeerDescriptor, sourceVersion: string, remotePeerDescriptor?: PeerDescriptor) => {
-            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, handshaker, sourceVersion, remotePeerDescriptor)
+        handshaker.once('handshakeRequest', (
+            localPeerDescriptor: PeerDescriptor,
+            remoteProtocolVersion: string,
+            remotePeerDescriptor?: PeerDescriptor
+        ) => {
+            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, handshaker, remoteProtocolVersion, remotePeerDescriptor)
         })
     }
 
     private onServerSocketHandshakeRequest(
-        sourcePeerDescriptor: PeerDescriptor,
+        remotePeerDescriptor: PeerDescriptor,
         websocketServerConnection: IConnection,
         handshaker: Handshaker,
-        remoteVersion: string,
+        remoteProtocolVersion: string,
         targetPeerDescriptor?: PeerDescriptor
     ) {
-        const nodeId = getNodeIdFromPeerDescriptor(sourcePeerDescriptor)
+        const nodeId = toNodeId(remotePeerDescriptor)
         if (this.ongoingConnectRequests.has(nodeId)) {
             const { pendingConnection, delFunc } = this.ongoingConnectRequests.get(nodeId)!
-            if (!isMaybeSupportedVersion(remoteVersion)) {
-                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_VERSION)
+            if (!isMaybeSupportedProtocolVersion(remoteProtocolVersion)) {
+                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_PROTOCOL_VERSION)
                 delFunc()
             } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
                 rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
@@ -139,10 +143,10 @@ export class WebsocketServerConnector {
                 acceptHandshake(handshaker, pendingConnection, websocketServerConnection)
             }
         } else {
-            const pendingConnection = new PendingConnection(sourcePeerDescriptor)
+            const pendingConnection = new PendingConnection(remotePeerDescriptor)
             
-            if (!isMaybeSupportedVersion(remoteVersion)) {
-                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_VERSION)  
+            if (!isMaybeSupportedProtocolVersion(remoteProtocolVersion)) {
+                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_PROTOCOL_VERSION)  
             } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
                 rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)  
             } else if (this.options.onNewConnection(pendingConnection)) {
@@ -160,7 +164,7 @@ export class WebsocketServerConnector {
                 host: '127.0.0.1',
                 natType: NatType.UNKNOWN,
                 ipAddress: ipv4ToNumber('127.0.0.1'),
-                version: LOCAL_PROTOCOL_VERSION
+                protocolVersion: LOCAL_PROTOCOL_VERSION
             }
         }
         if (!this.options.entrypoints || this.options.entrypoints.length === 0) {
@@ -175,7 +179,7 @@ export class WebsocketServerConnector {
                 },
                 // TODO: Resolve the given host name or or use as is if IP was given. 
                 ipAddress: ipv4ToNumber('127.0.0.1'),
-                version: LOCAL_PROTOCOL_VERSION
+                protocolVersion: LOCAL_PROTOCOL_VERSION
             }
         }
         const shuffledEntrypoints = shuffle(this.options.entrypoints)
@@ -195,7 +199,7 @@ export class WebsocketServerConnector {
                     throw new Err.ConnectionFailed('ConnectivityChecker is destroyed')
                 }
             } catch (err) {
-                const error = `Failed to connect to entrypoint with id ${getNodeIdFromPeerDescriptor(entryPoint)} `
+                const error = `Failed to connect to entrypoint with id ${toNodeId(entryPoint)} `
                     + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
                 logger.error(error, { err })
                 shuffledEntrypoints.shift()
@@ -227,7 +231,7 @@ export class WebsocketServerConnector {
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): PendingConnection {
-        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const nodeId = toNodeId(targetPeerDescriptor)
         if (this.ongoingConnectRequests.has(nodeId)) {
             return this.ongoingConnectRequests.get(nodeId)!.pendingConnection
         }
@@ -251,7 +255,7 @@ export class WebsocketServerConnector {
             })
         })
         const pendingConnection = new PendingConnection(targetPeerDescriptor)
-        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const nodeId = toNodeId(targetPeerDescriptor)
         // TODO: can this leak?
         const delFunc = () => {
             pendingConnection.off('connected', delFunc)
@@ -280,7 +284,7 @@ export class WebsocketServerConnector {
         await Promise.allSettled(requests.map((ongoingConnectRequest) => ongoingConnectRequest.pendingConnection.close(true)))
 
         await this.websocketServer?.stop()
-        await this.geoIpLocator?.stop()
+        this.geoIpLocator?.stop()
     }
 
 }