@streamr/dht 101.1.1 → 102.0.0-beta.0

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,10 +1,10 @@
 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 { toNodeId } from '../identifiers'
 import { PendingConnection } from './PendingConnection'
 
 const logger = new Logger(module)
@@ -43,7 +43,7 @@ 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()
     }

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,7 +4,7 @@ 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'
@@ -85,6 +85,7 @@ export const sendConnectivityRequest = async (
                         if (isMaybeSupportedVersion(remoteVersion)) {
                             resolve(connectivityResponseMessage)
                         } else {
+                            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                             reject(`Unsupported version: ${remoteVersion}`)
                         }
                     }

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'

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)
 
@@ -183,11 +183,11 @@ 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')

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/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,6 +1,6 @@
 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
@@ -8,9 +8,9 @@ import { DataChannel, DescriptionType, PeerConnection, initLogger } from 'node-d
 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 +58,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 +70,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 +105,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 +122,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 +143,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 +155,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 +216,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,18 +4,18 @@ 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'
@@ -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(
@@ -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)
         }