@streamr/dht 101.1.2 → 102.0.0-beta.1

package/src/connection/ConnectionManager.ts

@@ -10,9 +10,10 @@ import {
     LockResponse,
     Message,
     PeerDescriptor,
-    UnlockRequest
-} from '../proto/packages/dht/protos/DhtRpc'
-import { ConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
+    UnlockRequest,
+    SetPrivateRequest
+} from '../../generated/packages/dht/protos/DhtRpc'
+import { ConnectionLockRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
 import { DEFAULT_SEND_OPTIONS, ITransport, SendOptions, TransportEvents } from '../transport/ITransport'
 import { RoutingRpcCommunicator } from '../transport/RoutingRpcCommunicator'
 import { ConnectionLockStates, LockID } from './ConnectionLockStates'
@@ -21,7 +22,7 @@ import { ManagedConnection, Events as ManagedConnectionEvents } from './ManagedC
 import { ConnectionLockRpcRemote } from './ConnectionLockRpcRemote'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { ConnectionLockRpcLocal } from './ConnectionLockRpcLocal'
-import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, toNodeId } from '../identifiers'
 import { getOfferer } from '../helpers/offering'
 import { ConnectionsView } from './ConnectionsView'
 import { OutputBuffer } from './OutputBuffer'
@@ -31,6 +32,7 @@ import { PendingConnection } from './PendingConnection'
 export interface ConnectionManagerOptions {
     maxConnections?: number
     metricsContext: MetricsContext
+    allowIncomingPrivateConnections: boolean
     createConnectorFacade: () => ConnectorFacade
 }
 
@@ -108,7 +110,7 @@ const INTERNAL_SERVICE_ID = 'system/connection-manager'
 // - if ManagedConnection#peerDescriptor is never undefined
 export const getNodeIdOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescriptor | undefined): string => {
     if (peerDescriptor !== undefined) {
-        return getNodeIdFromPeerDescriptor(peerDescriptor)
+        return toNodeId(peerDescriptor)
     } else {
         return 'unknown'
     }
@@ -127,6 +129,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     private rpcCommunicator?: RoutingRpcCommunicator
     private disconnectorIntervalRef?: NodeJS.Timeout
     private state = ConnectionManagerState.IDLE
+    private privateClientMode = false
 
     constructor(options: ConnectionManagerOptions) {
         super()
@@ -154,7 +157,18 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             removeRemoteLocked: (id: DhtAddress, lockId: LockID) => this.locks.removeRemoteLocked(id, lockId),
             closeConnection: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string) => 
                 this.closeConnection(peerDescriptor, gracefulLeave, reason),
-            getLocalPeerDescriptor: () => this.getLocalPeerDescriptor()
+            getLocalPeerDescriptor: () => this.getLocalPeerDescriptor(),
+            setPrivate: (id: DhtAddress, isPrivate: boolean) => {
+                if (!this.options.allowIncomingPrivateConnections) {
+                    logger.debug(`node ${id} attemted to set a connection as private, but it is not allowed`)
+                    return
+                }
+                if (isPrivate) {
+                    this.locks.addPrivate(id)
+                } else {
+                    this.locks.removePrivate(id)
+                }
+            }
         })
         this.rpcCommunicator.registerRpcMethod(LockRequest, LockResponse, 'lockRequest',
             (req: LockRequest, context: ServerCallContext) => lockRpcLocal.lockRequest(req, context))
@@ -162,6 +176,8 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             (req: UnlockRequest, context: ServerCallContext) => lockRpcLocal.unlockRequest(req, context))
         this.rpcCommunicator.registerRpcNotification(DisconnectNotice, 'gracefulDisconnect',
             (req: DisconnectNotice, context: ServerCallContext) => lockRpcLocal.gracefulDisconnect(req, context))
+        this.rpcCommunicator.registerRpcNotification(SetPrivateRequest, 'setPrivate',
+            (req: SetPrivateRequest, context: ServerCallContext) => lockRpcLocal.setPrivate(req, context))
     }
 
     /*
@@ -173,14 +189,15 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             return
         }
         const disconnectionCandidates = new SortedContactList<ManagedConnection>({
-            referenceId: getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 
+            referenceId: toNodeId(this.getLocalPeerDescriptor()), 
             maxSize: 100000,  // TODO use options option or named constant?
             allowToContainReferenceId: false
         })
         this.endpoints.forEach((endpoint) => {
             if (endpoint.connected) {
                 const connection = endpoint.connection
-                if (!this.locks.isLocked(connection.getNodeId()) && Date.now() - connection.getLastUsedTimestamp() > maxIdleTime) {
+                const nodeId = connection.getNodeId()
+                if (!this.locks.isLocked(nodeId) && !this.locks.isPrivate(nodeId) && Date.now() - connection.getLastUsedTimestamp() > maxIdleTime) {
                     logger.trace('disconnecting in timeout interval: ' + getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()))
                     disconnectionCandidates.addContact(connection)
                 }
@@ -189,7 +206,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         const disconnectables = disconnectionCandidates.getFurthestContacts(this.endpoints.size - maxConnections)
         for (const disconnectable of disconnectables) {
             const peerDescriptor = disconnectable.getPeerDescriptor()!
-            logger.trace('garbageCollecting ' + getNodeIdFromPeerDescriptor(peerDescriptor))
+            logger.trace('garbageCollecting ' + toNodeId(peerDescriptor))
             this.gracefullyDisconnectAsync(peerDescriptor, DisconnectMode.NORMAL).catch((_e) => { })
         }
     }
@@ -273,7 +290,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.isConnectionToSelf(peerDescriptor)) {
             throw new Err.CannotConnectToSelf('Cannot send to self')
         }
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         logger.trace(`Sending message to: ${nodeId}`)
         message = {
             ...message,
@@ -283,7 +300,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (!connection && opts.connect) {
             connection = this.connectorFacade.createConnection(peerDescriptor)
             this.onNewConnection(connection)
-        } else if (!connection) {
+        } else if (!connection || (connection && !this.endpoints.get(nodeId)!.connected && !opts.connect)) {
             throw new Err.SendFailed('No connection to target, connect flag is false')
         }
         const binary = Message.toBinary(message)
@@ -291,7 +308,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         this.metrics.sendMessagesPerSecond.record(1)
 
         if (this.endpoints.get(nodeId)!.connected) {
-            return (connection as ManagedConnection).send(binary)
+            (connection as ManagedConnection).send(binary)
         } else {
             return (this.endpoints.get(nodeId)! as ConnectingEndpoint).buffer.push(binary)
         }
@@ -317,7 +334,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
 
     public hasConnection(nodeId: DhtAddress): boolean {
         // TODO if we remove filtering in getConnections, this can just be this.connection.has(nodeId)
-        return this.getConnections().some((c) => getNodeIdFromPeerDescriptor(c) == nodeId)
+        return this.getConnections().some((c) => toNodeId(c) == nodeId)
     }
 
     public getConnectionCount(): number {
@@ -341,7 +358,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             return
         }
         if (this.duplicateMessageDetector.isMostLikelyDuplicate(message.messageId)) {
-            logger.trace('handleMessage filtered duplicate ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
+            logger.trace('handleMessage filtered duplicate ' + toNodeId(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             return
         }
@@ -349,7 +366,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (message.serviceId === INTERNAL_SERVICE_ID) {
             this.rpcCommunicator?.handleMessageFromPeer(message)
         } else {
-            logger.trace('emit "message" ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
+            logger.trace('emit "message" ' + toNodeId(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             this.emit('message', message)
         }
@@ -365,6 +382,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         try {
             message = Message.fromBinary(data)
         } catch (e) {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
             logger.debug(`Parsing incoming data into Message failed: ${e}`)
             return
         }
@@ -372,6 +390,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         try {
             this.handleMessage(message)
         } catch (e) {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
             logger.debug(`Handling incoming data failed: ${e}`)
         }
     }
@@ -381,7 +400,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         managedConnection.on('managedData', this.onData)
         managedConnection.once('disconnected', (gracefulLeave: boolean) => this.onDisconnected(peerDescriptor, gracefulLeave))
 
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         const endpoint = this.endpoints.get(nodeId)! as ConnectingEndpoint
         const outputBuffer = endpoint.buffer
         const pendingConnection = endpoint.connection
@@ -396,12 +415,15 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             connected: true,
             connection: managedConnection
         })
+        if (this.privateClientMode) {
+            this.setPrivateForConnection(peerDescriptor, this.privateClientMode).catch(() => {})
+        }
         this.emit('connected', peerDescriptor)
         this.onConnectionCountChange()
     }
 
     private onDisconnected(peerDescriptor: PeerDescriptor, gracefulLeave: boolean) {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         logger.trace(nodeId + ' onDisconnected() gracefulLeave: ' + gracefulLeave)
         const endpoint = this.endpoints.get(nodeId)
         if (endpoint) {
@@ -430,10 +452,10 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     private acceptNewConnection(newConnection: PendingConnection): boolean {
-        const nodeId = getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor())
+        const nodeId = toNodeId(newConnection.getPeerDescriptor())
         logger.trace(nodeId + ' acceptNewConnection()')
         if (this.endpoints.has(nodeId)) {
-            if (getOfferer(getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()), nodeId) === 'remote') {
+            if (getOfferer(toNodeId(this.getLocalPeerDescriptor()), nodeId) === 'remote') {
                 let buffer: OutputBuffer | undefined
                 const endpoint = this.endpoints.get(nodeId)!
                 // This is a rare occurance but it does happen from time to time.
@@ -467,7 +489,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     private async closeConnection(peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string): Promise<void> {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         logger.trace(nodeId + ' ' + 'closeConnection() ' + reason)
         this.locks.clearAllLocks(nodeId)
         if (this.endpoints.has(nodeId)) {
@@ -483,7 +505,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        const nodeId = toNodeId(targetDescriptor)
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
             targetDescriptor,
@@ -500,7 +522,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        const nodeId = toNodeId(targetDescriptor)
         this.locks.removeLocalLocked(nodeId, lockId)
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
@@ -514,21 +536,55 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     public weakLockConnection(nodeId: DhtAddress, lockId: LockID): void {
-        if (this.state === ConnectionManagerState.STOPPED || (nodeId === getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()))) {
+        if (this.state === ConnectionManagerState.STOPPED || (nodeId === toNodeId(this.getLocalPeerDescriptor()))) {
             return
         }
         this.locks.addWeakLocked(nodeId, lockId)
     }
 
     public weakUnlockConnection(nodeId: DhtAddress, lockId: LockID): void {
-        if (this.state === ConnectionManagerState.STOPPED || (nodeId === getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()))) {
+        if (this.state === ConnectionManagerState.STOPPED || (nodeId === toNodeId(this.getLocalPeerDescriptor()))) {
             return
         }
         this.locks.removeWeakLocked(nodeId, lockId)
     }
 
+    public async enablePrivateClientMode(): Promise<void> {
+        this.privateClientMode = true
+        await Promise.all(Array.from(this.endpoints.values()).map((endpoint) => {
+            if (endpoint.connected) {
+                const peerDescription = endpoint.connection.getPeerDescriptor()
+                return this.setPrivateForConnection(peerDescription!, true)
+            }
+        }))
+    }
+
+    public async disablePrivateClientMode(): Promise<void> {
+        this.privateClientMode = false
+        await Promise.all(Array.from(this.endpoints.values()).map((endpoint) => {
+            if (endpoint.connected) {
+                const peerDescription = endpoint.connection.getPeerDescriptor()
+                return this.setPrivateForConnection(peerDescription!, false)
+            }
+        }))
+    }
+
+    public isPrivateClientMode(): boolean {
+        return this.privateClientMode
+    }
+
+    private async setPrivateForConnection(targetDescriptor: PeerDescriptor, isPrivate: boolean): Promise<void> {
+        const rpcRemote = new ConnectionLockRpcRemote(
+            this.getLocalPeerDescriptor(),
+            targetDescriptor,
+            this.rpcCommunicator!,
+            ConnectionLockRpcClient
+        )
+        await rpcRemote.setPrivate(isPrivate)
+    }
+
     private async gracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
-        const endpoint = this.endpoints.get(getNodeIdFromPeerDescriptor(targetDescriptor))
+        const endpoint = this.endpoints.get(toNodeId(targetDescriptor))
 
         if (!endpoint) {
             logger.debug('gracefullyDisconnectedAsync() tried on a non-existing connection')
@@ -565,7 +621,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     private async doGracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
-        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        const nodeId = toNodeId(targetDescriptor)
         logger.trace(nodeId + ' gracefullyDisconnectAsync()')
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
@@ -585,11 +641,21 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             .map((endpoint) => endpoint)
             // TODO is this filtering needed? (if it is, should we do the same filtering e.g.
             // in getConnection() or in other methods which access this.endpoints directly?)
-            .filter((endpoint) => endpoint.connected)
+            .filter((endpoint) => endpoint.connected && !this.locks.isPrivate(toNodeId(endpoint.connection.getPeerDescriptor()!)))
             .map((endpoint) => endpoint.connection.getPeerDescriptor()!)
     }
 
     private onConnectionCountChange() {
         this.metrics.connectionAverageCount.record(this.endpoints.size)
     }
+
+    public getDiagnosticInfo(): Record<string, unknown> {
+        const managedConnections: ManagedConnection[] = Array.from(this.endpoints.values())
+            .filter((endpoint) => endpoint.connected)
+            .map((endpoint) => endpoint.connection)
+        return {
+            connections: managedConnections.map((connection) => connection.getDiagnosticInfo()),
+            connectionCount: this.endpoints.size
+        }
+    }
 }

package/src/connection/ConnectionsView.ts

@@ -1,5 +1,5 @@
 import { DhtAddress } from '../identifiers'
-import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 
 export interface ConnectionsView {
     getConnections: () => PeerDescriptor[]

package/src/connection/ConnectorFacade.ts

@@ -2,7 +2,7 @@ import { Logger } from '@streamr/utils'
 import {
     ConnectivityResponse,
     PeerDescriptor
-} from '../proto/packages/dht/protos/DhtRpc'
+} from '../../generated/packages/dht/protos/DhtRpc'
 import { ITransport } from '../transport/ITransport'
 import { PortRange, TlsCertificate } from './ConnectionManager'
 import { Simulator } from './simulator/Simulator'

package/src/connection/Handshaker.ts

@@ -1,16 +1,17 @@
 import { Logger } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { v4 } from 'uuid'
-import { Message, HandshakeRequest, HandshakeResponse, PeerDescriptor, HandshakeError } from '../proto/packages/dht/protos/DhtRpc'
+import { Message, HandshakeRequest, HandshakeResponse, PeerDescriptor, HandshakeError } from '../../generated/packages/dht/protos/DhtRpc'
 import { IConnection } from './IConnection'
-import { LOCAL_PROTOCOL_VERSION, isMaybeSupportedVersion } from '../helpers/version'
-import { getNodeIdFromPeerDescriptor } from '../identifiers'
+import { LOCAL_PROTOCOL_VERSION, isMaybeSupportedProtocolVersion } from '../helpers/version'
+import { toNodeId } from '../identifiers'
 import { PendingConnection } from './PendingConnection'
+import { version as applicationVersion } from '../../package.json'
 
 const logger = new Logger(module)
 
 interface HandshakerEvents {
-    handshakeRequest: (source: PeerDescriptor, version: string, target?: PeerDescriptor) => void
+    handshakeRequest: (source: PeerDescriptor, protocolVersion: string, target?: PeerDescriptor) => void
     handshakeCompleted: (remote: PeerDescriptor) => void
     handshakeFailed: (error?: HandshakeError) => void
 }
@@ -35,7 +36,7 @@ export const createOutgoingHandshaker = (
         pendingConnection.off('disconnected', managedConnectionDisconnectedListener)
     }
     const handshakeFailedListener = (error?: HandshakeError) => {
-        if (error === HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR || error === HandshakeError.UNSUPPORTED_VERSION) {
+        if (error === HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR || error === HandshakeError.UNSUPPORTED_PROTOCOL_VERSION) {
             pendingConnection.close(false)
             stopHandshaker()
         } else {
@@ -43,12 +44,12 @@ export const createOutgoingHandshaker = (
         }
     }
     const handshakeCompletedListener = (peerDescriptor: PeerDescriptor) => {
-        logger.trace('handshake completed for outgoing connection, ' + getNodeIdFromPeerDescriptor(peerDescriptor))
+        logger.trace('handshake completed for outgoing connection, ' + toNodeId(peerDescriptor))
         pendingConnection.onHandshakeCompleted(connection)
         stopHandshaker()
     }
     const connectedListener = () => handshaker.sendHandshakeRequest(targetPeerDescriptor)
-    const disconnectedListener = (graceful: boolean) => { 
+    const disconnectedListener = (graceful: boolean) => {
         pendingConnection.close(graceful)
         stopHandshaker()
     }
@@ -112,7 +113,8 @@ export const createHandshakeRequest = (localPeerDescriptor: PeerDescriptor, remo
     const outgoingHandshake: HandshakeRequest = {
         sourcePeerDescriptor: localPeerDescriptor,
         targetPeerDescriptor: remotePeerDescriptor,
-        version: LOCAL_PROTOCOL_VERSION
+        protocolVersion: LOCAL_PROTOCOL_VERSION,
+        applicationVersion
     }
     return {
         serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
@@ -122,13 +124,14 @@ export const createHandshakeRequest = (localPeerDescriptor: PeerDescriptor, remo
             handshakeRequest: outgoingHandshake
         }
     }
-} 
+}
 
 export const createHandshakeResponse = (localPeerDescriptor: PeerDescriptor, error?: HandshakeError): Message => {
     const outgoingHandshakeResponse: HandshakeResponse = {
         sourcePeerDescriptor: localPeerDescriptor,
         error,
-        version: LOCAL_PROTOCOL_VERSION
+        protocolVersion: LOCAL_PROTOCOL_VERSION,
+        applicationVersion
     }
     return {
         serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
@@ -165,15 +168,16 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
                 const handshake = message.body.handshakeRequest
                 this.emit(
                     'handshakeRequest',
-                    handshake.sourcePeerDescriptor!, 
-                    handshake.version,
+                    handshake.sourcePeerDescriptor!,
+                    handshake.protocolVersion,
                     handshake.targetPeerDescriptor
                 )
             }
             if (message.body.oneofKind === 'handshakeResponse') {
                 logger.trace('handshake response received')
                 const handshake = message.body.handshakeResponse
-                const error = !isMaybeSupportedVersion(handshake.version) ? HandshakeError.UNSUPPORTED_VERSION : handshake.error
+                const error = !isMaybeSupportedProtocolVersion(handshake.protocolVersion) 
+                    ? HandshakeError.UNSUPPORTED_PROTOCOL_VERSION : handshake.error
                 if (error !== undefined) {
                     this.emit('handshakeFailed', error)
                 } else {
@@ -183,7 +187,7 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
         } catch (err) {
             logger.debug('error while parsing handshake message', err)
         }
-        
+
     }
 
     public sendHandshakeRequest(remotePeerDescriptor?: PeerDescriptor): void {

package/src/connection/ManagedConnection.ts

@@ -1,10 +1,10 @@
 import { ConnectionID, IConnection } from './IConnection'
 import * as Err from '../helpers/errors'
-import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
-import { DhtAddress, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { DhtAddress, toNodeId } from '../identifiers'
 import { createRandomConnectionId } from './Connection'
 
 export interface ManagedConnectionEvents {
@@ -26,6 +26,11 @@ export class ManagedConnection extends EventEmitter<ManagedConnectionEvents> {
     private lastUsedTimestamp: number = Date.now()
     private replacedAsDuplicate = false
     private stopped = false
+    private openedAt = Date.now()
+    private bytesSent = 0
+    private bytesReceived = 0
+    private messagesSent = 0
+    private messagesReceived = 0
 
     constructor(peerDescriptor: PeerDescriptor, connection: IConnection) {
         super()
@@ -34,6 +39,8 @@ export class ManagedConnection extends EventEmitter<ManagedConnectionEvents> {
 
         connection.on('data', (bytes: Uint8Array) => {
             this.lastUsedTimestamp = Date.now()
+            this.messagesReceived += 1
+            this.bytesReceived += bytes.length
             this.emit('managedData', bytes, this.getPeerDescriptor()!)
         })
         connection.on('disconnected', (gracefulLeave) => this.onDisconnected(gracefulLeave))
@@ -62,6 +69,8 @@ export class ManagedConnection extends EventEmitter<ManagedConnectionEvents> {
             throw new Err.SendFailed('ManagedConnection is stopped')
         }
         this.lastUsedTimestamp = Date.now()
+        this.messagesSent += 1
+        this.bytesSent += data.length
         this.connection.send(data)
     }
 
@@ -74,7 +83,7 @@ export class ManagedConnection extends EventEmitter<ManagedConnectionEvents> {
     }
 
     getNodeId(): DhtAddress {
-        return getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+        return toNodeId(this.remotePeerDescriptor)
     }
 
     getLastUsedTimestamp(): number {
@@ -85,4 +94,20 @@ export class ManagedConnection extends EventEmitter<ManagedConnectionEvents> {
         return this.remotePeerDescriptor
     }
 
+    getDiagnosticInfo(): Record<string, unknown> {
+        return {
+            remotePeerDescriptor: this.remotePeerDescriptor,
+            lastUsedTimestamp: this.lastUsedTimestamp,
+            replacedAsDuplicate: this.replacedAsDuplicate,
+            stopped: this.stopped,
+            openedAt: this.openedAt,
+            bytesSent: this.bytesSent,
+            bytesReceived: this.bytesReceived,
+            messagesSent: this.messagesSent,
+            messagesReceived: this.messagesReceived
+            // Add connection type?
+        }
+
+    }
+
 }

package/src/connection/PendingConnection.ts

@@ -1,5 +1,5 @@
 import EventEmitter from 'eventemitter3'
-import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { Logger, setAbortableTimeout } from '@streamr/utils'
 import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
 import { IConnection } from './IConnection'

package/src/connection/connectivityChecker.ts

@@ -4,11 +4,11 @@ import * as Err from '../helpers/errors'
 import {
     ConnectivityRequest, ConnectivityResponse,
     Message, PeerDescriptor
-} from '../proto/packages/dht/protos/DhtRpc'
+} from '../../generated/packages/dht/protos/DhtRpc'
 import { ConnectionEvents, IConnection } from './IConnection'
 import { WebsocketClientConnection } from './websocket/NodeWebsocketClientConnection'
 import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketClientConnector'
-import { isMaybeSupportedVersion } from '../helpers/version'
+import { isMaybeSupportedProtocolVersion } from '../helpers/version'
 
 const logger = new Logger(module)
 
@@ -79,13 +79,14 @@ export const sendConnectivityRequest = async (
                     if (message.body.oneofKind === 'connectivityResponse') {
                         logger.debug('ConnectivityResponse received: ' + JSON.stringify(Message.toJson(message)))
                         const connectivityResponseMessage = message.body.connectivityResponse
-                        const remoteVersion = connectivityResponseMessage.version
+                        const remoteProtocolVersion = connectivityResponseMessage.protocolVersion
                         outgoingConnection!.off('data', listener)
                         clearTimeout(timeoutId)
-                        if (isMaybeSupportedVersion(remoteVersion)) {
+                        if (isMaybeSupportedProtocolVersion(remoteProtocolVersion)) {
                             resolve(connectivityResponseMessage)
                         } else {
-                            reject(`Unsupported version: ${remoteVersion}`)
+                            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                            reject(`Unsupported version: ${remoteProtocolVersion}`)
                         }
                     }
                 } catch (err) {

package/src/connection/connectivityRequestHandler.ts

@@ -4,7 +4,7 @@ import {
     ConnectivityRequest,
     ConnectivityResponse,
     Message
-} from '../proto/packages/dht/protos/DhtRpc'
+} from '../../generated/packages/dht/protos/DhtRpc'
 import { NatType } from './ConnectionManager'
 import { CONNECTIVITY_CHECKER_SERVICE_ID, connectAsync } from './connectivityChecker'
 import { IConnection } from './IConnection'
@@ -54,7 +54,7 @@ const handleIncomingConnectivityRequest = async (
             host,
             natType: NatType.UNKNOWN,
             ipAddress: ipv4ToNumber(ipAddress),
-            version: LOCAL_PROTOCOL_VERSION
+            protocolVersion: LOCAL_PROTOCOL_VERSION
         }
     }
     if (geoIpLocator !== undefined) {
@@ -97,7 +97,7 @@ const connectivityProbe = async (connectivityRequest: ConnectivityRequest, ipAdd
             natType: NatType.OPEN_INTERNET,
             websocket: { host, port: connectivityRequest.port, tls: connectivityRequest.tls },
             ipAddress: ipv4ToNumber(ipAddress),
-            version: LOCAL_PROTOCOL_VERSION
+            protocolVersion: LOCAL_PROTOCOL_VERSION
         }
     } catch (err) {
         logger.debug('error', { err })
@@ -105,7 +105,7 @@ const connectivityProbe = async (connectivityRequest: ConnectivityRequest, ipAdd
             host,
             natType: NatType.UNKNOWN,
             ipAddress: ipv4ToNumber(ipAddress),
-            version: LOCAL_PROTOCOL_VERSION
+            protocolVersion: LOCAL_PROTOCOL_VERSION
         }
     }
     if (outgoingConnection) {

package/src/connection/simulator/Simulator.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/parameter-properties */
-import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
 import { SimulatorConnector } from './SimulatorConnector'
 import { SimulatorConnection } from './SimulatorConnection'
 import { ConnectionID } from '../IConnection'
@@ -7,7 +7,7 @@ import { Logger } from '@streamr/utils'
 import { getRegionDelayMatrix } from './pings'
 import Heap from 'heap'
 import { debugVars } from '../../helpers/debugHelpers'
-import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { DhtAddress, toNodeId } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -90,7 +90,7 @@ class CloseOperation extends SimulatorOperation {
 export class Simulator {
     private stopped = false
     private connectors: Map<DhtAddress, SimulatorConnector> = new Map()
-    private latencyTable?: Array<Array<number>>
+    private latencyTable?: number[][]
     private associations: Map<ConnectionID, Association> = new Map()
 
     private latencyType: LatencyType
@@ -183,15 +183,16 @@ export class Simulator {
     }
 
     public addConnector(connector: SimulatorConnector): void {
-        this.connectors.set(getNodeIdFromPeerDescriptor(connector.getPeerDescriptor()), connector)
+        this.connectors.set(toNodeId(connector.getPeerDescriptor()), connector)
     }
 
     private executeConnectOperation(operation: ConnectOperation): void {
-        const target = this.connectors.get(getNodeIdFromPeerDescriptor(operation.targetDescriptor))
+        const target = this.connectors.get(toNodeId(operation.targetDescriptor))
 
         if (!target) {
             logger.error('Target connector not found when executing connect operation')
-            return operation.association.connectedCallback!('Target connector not found')
+            operation.association.connectedCallback!('Target connector not found')
+            return
         }
 
         target.handleIncomingConnection(operation.sourceConnection)
@@ -293,7 +294,7 @@ export class Simulator {
             logger.error('connect() called on a stopped simulator ' + (new Error().stack))
             return
         }
-        debugVars['simulatorHeapSize'] = this.operationQueue.size()
+        debugVars.simulatorHeapSize = this.operationQueue.size()
 
         const association = new Association(sourceConnection, undefined, connectedCallback)
         this.associations.set(sourceConnection.connectionId, association)