@streamr/dht 100.0.0-testnet-one.0 → 100.0.0-testnet-one.1

package/src/connection/ConnectionManager.ts

@@ -95,7 +95,7 @@ const INTERNAL_SERVICE_ID = 'system/connection-manager'
 // - if we create stricter types for incoming messages (message.sourceDescriptor or
 //   disconnectNotice.peerDescriptor)
 // - if ManagedConnection#peerDescriptor is never undefined
-export const getNodeIdOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescriptor | undefined): string => { 
+export const getNodeIdOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescriptor | undefined): string => {
     if (peerDescriptor !== undefined) {
         return getNodeIdFromPeerDescriptor(peerDescriptor)
     } else {
@@ -158,7 +158,12 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.connections.size <= maxConnections) {
             return
         }
-        const disconnectionCandidates = new SortedContactList<Contact>(peerIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 100000)
+        const disconnectionCandidates = new SortedContactList<Contact>({
+            referenceId: peerIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 
+            maxSize: 100000,  // TODO use config option or named constant?
+            allowToContainReferenceId: false,
+            emitEvents: false
+        })
         this.connections.forEach((connection) => {
             if (!this.locks.isLocked(connection.peerIdKey) && Date.now() - connection.getLastUsed() > lastUsedLimit) {
                 logger.trace('disconnecting in timeout interval: ' + getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()))
@@ -182,7 +187,6 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         logger.trace(`Starting ConnectionManager...`)
         await this.connectorFacade.start(
             (connection: ManagedConnection) => this.onNewConnection(connection),
-            (peerDescriptor: PeerDescriptor) => this.canConnect(peerDescriptor),
             this
         )
         // Garbage collection of connections
@@ -275,14 +279,14 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         return connection.send(binary, doNotConnect)
     }
 
-    private isConnectionToSelf(peerDescriptor: PeerDescriptor): boolean { 
+    private isConnectionToSelf(peerDescriptor: PeerDescriptor): boolean {
         return areEqualPeerDescriptors(peerDescriptor, this.getLocalPeerDescriptor()) || this.isOwnWebsocketServer(peerDescriptor)
     }
 
     private isOwnWebsocketServer(peerDescriptor: PeerDescriptor): boolean {
         const localPeerDescriptor = this.getLocalPeerDescriptor()
         if ((peerDescriptor.websocket !== undefined) && (localPeerDescriptor.websocket !== undefined)) {
-            return ((peerDescriptor.websocket.port === localPeerDescriptor.websocket.port) 
+            return ((peerDescriptor.websocket.port === localPeerDescriptor.websocket.port)
                 && (peerDescriptor.websocket.host === localPeerDescriptor.websocket.host))
         } else {
             return false
@@ -313,11 +317,6 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         return this.locks.isRemoteLocked(peerIdKey)
     }
 
-    private canConnect(peerDescriptor: PeerDescriptor): boolean {
-        // Perhaps the connection's state should be checked here
-        return !this.hasConnection(peerDescriptor) // TODO: Add port range check
-    }
-
     public handleMessage(message: Message): void {
         logger.trace('Received message of type ' + message.messageType)
         if (message.messageType !== MessageType.RPC) {
@@ -325,7 +324,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 ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             return
         }
@@ -333,7 +332,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" ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             this.emit('message', message)
         }
@@ -376,16 +375,16 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (storedConnection && storedConnection.connectionId.equals(connection.connectionId)) {
             this.locks.clearAllLocks(peerIdKey)
             this.connections.delete(peerIdKey)
-            logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
+            logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor())
                 + ' deleted connection in onDisconnected() gracefulLeave: ' + gracefulLeave)
             this.emit('disconnected', connection.getPeerDescriptor()!, gracefulLeave)
             this.onConnectionCountChange()
         } else {
-            logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) 
+            logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor())
                 + ' onDisconnected() did nothing, no such connection in connectionManager')
             if (storedConnection) {
                 logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor())
-                + ' connectionIds do not match ' + storedConnection.connectionId.toString() + ' ' + connection.connectionId.toString())
+                    + ' connectionIds do not match ' + storedConnection.connectionId.toString() + ' ' + connection.connectionId.toString())
             }
         }
 
@@ -426,11 +425,11 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
                 const oldConnection = this.connections.get(newPeerID.toKey())!
                 logger.trace('replaced: ' + getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!))
                 const buffer = oldConnection.stealOutputBuffer()
-                
+
                 for (const data of buffer) {
                     newConnection.sendNoWait(data)
                 }
-                
+
                 oldConnection.reportBufferSentByOtherConnection()
                 oldConnection.replacedByOtherConnection = true
             } else {

package/src/connection/ConnectorFacade.ts

@@ -16,7 +16,6 @@ export interface ConnectorFacade {
     getLocalPeerDescriptor: () => PeerDescriptor | undefined
     start: (
         onNewConnection: (connection: ManagedConnection) => boolean,
-        canConnect: (peerDescriptor: PeerDescriptor) => boolean,
         autoCertifierTransport: ITransport
     ) => Promise<void>
     stop: () => Promise<void>
@@ -59,14 +58,12 @@ export class DefaultConnectorFacade implements ConnectorFacade {
 
     async start(
         onNewConnection: (connection: ManagedConnection) => boolean,
-        canConnect: (peerDescriptor: PeerDescriptor) => boolean,
         autoCertifierTransport: ITransport
     ): Promise<void> {
         logger.trace(`Creating WebsocketConnectorRpcLocal`)
         const webSocketConnectorConfig = {
             transport: this.config.transport,
             // TODO should we use canConnect also for WebrtcConnector? (NET-1142)
-            canConnect: (peerDescriptor: PeerDescriptor) => canConnect(peerDescriptor),
             onNewConnection,
             portRange: this.config.websocketPortRange,
             host: this.config.websocketHost,

package/src/connection/connectivityChecker.ts

@@ -44,13 +44,14 @@ export const sendConnectivityRequest = async (
         tls: entryPoint.websocket!.tls,
     }
     const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityRequest')
+    logger.debug(`Attempting connectivity check with entrypoint ${url}`)
     try {
         outgoingConnection = await connectAsync({
             url,
             selfSigned: request.selfSigned
         })
     } catch (e) {
-        throw new Err.ConnectionFailed(`Failed to connect to the entrypoint ${url}`, e)
+        throw new Err.ConnectionFailed(`Failed to connect to entrypoint for connectivity check: ${url}`, e)
     }
     // send connectivity request
     const msg: Message = {
@@ -74,7 +75,7 @@ export const sendConnectivityRequest = async (
                 try {
                     const message: Message = Message.fromBinary(bytes)
                     if (message.body.oneofKind === 'connectivityResponse') {
-                        logger.trace('ConnectivityResponse received: ' + JSON.stringify(Message.toJson(message)))
+                        logger.debug('ConnectivityResponse received: ' + JSON.stringify(Message.toJson(message)))
                         const connectivityResponseMessage = message.body.connectivityResponse
                         outgoingConnection!.off('data', listener)
                         clearTimeout(timeoutId)

package/src/connection/websocket/ClientWebsocket.ts

@@ -8,6 +8,9 @@ const logger = new Logger(module)
 // https://kapeli.com/cheat_sheets/WebSocket_Status_Codes.docset/Contents/Resources/Documents/index
 // Browsers send this automatically when closing a tab
 export const GOING_AWAY = 1001
+// The GOING_AWAY is a reserved code and we shouldn't send that from the application. Therefore
+// we have a custom counterpart
+export const CUSTOM_GOING_AWAY = 3001
 
 const BINARY_TYPE = 'arraybuffer'
 
@@ -69,7 +72,7 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.destroyed = true
         this.stopListening()
         this.socket = undefined
-        const gracefulLeave = code === GOING_AWAY
+        const gracefulLeave = (code === GOING_AWAY) || (code === CUSTOM_GOING_AWAY)
         this.emit('disconnected', gracefulLeave, code, reason)
         this.removeAllListeners()
     }
@@ -92,7 +95,7 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.removeAllListeners()
         if (!this.destroyed) {
             logger.trace(`Closing socket for connection ${this.connectionId.toString()}`)
-            this.socket?.close(gracefulLeave === true ? GOING_AWAY : undefined)
+            this.socket?.close(gracefulLeave ? CUSTOM_GOING_AWAY : undefined)
         } else {
             logger.debug('Tried to close() a stopped connection')
         }

package/src/connection/websocket/ServerWebsocket.ts

@@ -1,9 +1,9 @@
 import EventEmitter from 'eventemitter3'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
-import { connection as WsConnection } from 'websocket'
+import { Message, connection as WsConnection } from 'websocket'
 import { Logger } from '@streamr/utils'
 import { Url } from 'url'
-import { GOING_AWAY } from './ClientWebsocket'
+import { CUSTOM_GOING_AWAY, GOING_AWAY } from './ClientWebsocket'
 
 const logger = new Logger(module)
 
@@ -29,37 +29,52 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
     constructor(socket: WsConnection, resourceURL: Url) {
         super()
 
+        this.onMessage = this.onMessage.bind(this)
+        this.onClose = this.onClose.bind(this)
+        this.onError = this.onError.bind(this)
+
         this.resourceURL = resourceURL
         this.connectionId = new ConnectionID()
 
-        socket.on('message', (message) => {
-            logger.trace('ServerWebsocket::onMessage')
-            if (message.type === MessageType.UTF8) {
-                logger.debug('Received string Message: ' + message.utf8Data)
-            } else if (message.type === MessageType.BINARY) {
-                logger.trace('Received Binary Message of ' + message.binaryData.length + ' bytes')
-                this.emit('data',
-                    new Uint8Array(message.binaryData.buffer, message.binaryData.byteOffset,
-                        message.binaryData.byteLength / Uint8Array.BYTES_PER_ELEMENT))
-            }
-        })
-        socket.on('close', (reasonCode, description) => {
-            logger.trace('Peer ' + socket.remoteAddress + ' disconnected.')            
-            this.doDisconnect(reasonCode, description)
-        })
-
-        socket.on('error', (error) => {
-            this.emit('error', error.name)
-        })
+        socket.on('message', this.onMessage)
+        socket.on('close', this.onClose)
+        socket.on('error', this.onError)
 
         this.socket = socket
     }
 
+    private onMessage(message: Message): void {
+        logger.trace('ServerWebsocket::onMessage')
+        if (message.type === MessageType.UTF8) {
+            logger.debug('Received string Message: ' + message.utf8Data)
+        } else if (message.type === MessageType.BINARY) {
+            logger.trace('Received Binary Message of ' + message.binaryData.length + ' bytes')
+            this.emit('data',
+                new Uint8Array(message.binaryData.buffer, message.binaryData.byteOffset,
+                    message.binaryData.byteLength / Uint8Array.BYTES_PER_ELEMENT))
+        }
+    }
+
+    private onClose(reasonCode: number, description: string): void {
+        logger.trace('Peer ' + this.socket?.remoteAddress + ' disconnected.')
+        this.doDisconnect(reasonCode, description)
+    }
+
+    private onError(error: Error): void {
+        this.emit('error', error.name)
+    }
+
+    private stopListening(): void {
+        this.socket?.off('message', this.onMessage)
+        this.socket?.off('close', this.onClose)
+        this.socket?.off('error', this.onError)
+    }
+
     private doDisconnect(reasonCode: number, description: string): void {
         this.stopped = true
-        this.socket?.removeAllListeners()
+        this.stopListening()
         this.socket = undefined
-        const gracefulLeave = reasonCode === GOING_AWAY
+        const gracefulLeave = (reasonCode === GOING_AWAY) || (reasonCode === CUSTOM_GOING_AWAY)
         this.emit('disconnected', gracefulLeave, reasonCode, description)
     }
 
@@ -83,7 +98,7 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.emit('disconnected', gracefulLeave, undefined, 'close() called')
         this.removeAllListeners()
         if (!this.stopped) {
-            this.socket?.close(gracefulLeave === true ? GOING_AWAY : undefined)
+            this.socket?.close(gracefulLeave ? GOING_AWAY : undefined)
         } else {
             logger.debug('Tried to close a stopped connection')
         }
@@ -93,7 +108,7 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
         if (!this.stopped) {
             this.removeAllListeners()
             if (this.socket) {
-                this.socket.removeAllListeners()
+                this.stopListening()
                 this.socket.close()
                 this.socket = undefined
             }

package/src/connection/websocket/WebsocketConnector.ts

@@ -44,7 +44,6 @@ const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 
 export interface WebsocketConnectorConfig {
     transport: ITransport
-    canConnect: (peerDescriptor: PeerDescriptor) => boolean
     onNewConnection: (connection: ManagedConnection) => boolean
     portRange?: PortRange
     maxMessageSize?: number
@@ -100,8 +99,18 @@ export class WebsocketConnector {
 
     private registerLocalRpcMethods(config: WebsocketConnectorConfig) {
         const rpcLocal = new WebsocketConnectorRpcLocal({
-            canConnect: (peerDescriptor: PeerDescriptor) => config.canConnect(peerDescriptor),
             connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
+            hasConnection: (targetPeerDescriptor: PeerDescriptor): boolean => {
+                const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
+                if (this.connectingConnections.has(peerKey)
+                    || this.connectingConnections.has(peerKey)
+                    || this.ongoingConnectRequests.has(peerKey)
+                ) {
+                    return true
+                } else {
+                    return false
+                }
+            },
             onNewConnection: (connection: ManagedConnection) => config.onNewConnection(connection),
             abortSignal: this.abortController.signal
         })
@@ -109,7 +118,7 @@ export class WebsocketConnector {
             WebsocketConnectionRequest,
             WebsocketConnectionResponse,
             'requestConnection',
-            async (req: WebsocketConnectionRequest, context: ServerCallContext) => {
+            async (req: WebsocketConnectionRequest, context: ServerCallContext): Promise<WebsocketConnectionResponse> => {
                 if (!this.abortController.signal.aborted) {
                     return rpcLocal.requestConnection(req, context)
                 } else {
@@ -191,7 +200,7 @@ export class WebsocketConnector {
                         // Do real connectivity checking
                         const connectivityRequest = {
                             port: this.selectedPort!,
-                            host: this.host, 
+                            host: this.host,
                             tls: this.serverEnableTls,
                             selfSigned
                         }
@@ -267,8 +276,14 @@ export class WebsocketConnector {
                 targetPeerDescriptor,
                 toProtoRpcClient(new WebsocketConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
-            // TODO should we have some handling for this floating promise?
-            remoteConnector.requestConnection(localPeerDescriptor.websocket!.host, localPeerDescriptor.websocket!.port)
+            remoteConnector.requestConnection().then((_response: WebsocketConnectionResponse) => {
+                logger.trace('Sent WebsocketConnectionRequest request to peer', { targetPeerDescriptor })
+                return
+            }, (err) => {
+                logger.debug('Failed to send WebsocketConnectionRequest request to peer of failed to get the response ', {
+                    error: err, targetPeerDescriptor
+                })
+            })
         })
         const managedConnection = new ManagedConnection(
             this.localPeerDescriptor!,
@@ -293,12 +308,8 @@ export class WebsocketConnector {
         if (this.ongoingConnectRequests.has(peerId.toKey())) {
             const ongoingConnectRequest = this.ongoingConnectRequests.get(peerId.toKey())!
             ongoingConnectRequest.attachImplementation(serverWebsocket)
-            if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
-                ongoingConnectRequest.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
-            } else {
-                ongoingConnectRequest.acceptHandshake()
-                this.ongoingConnectRequests.delete(peerId.toKey())
-            }
+            ongoingConnectRequest.acceptHandshake()
+            this.ongoingConnectRequests.delete(peerId.toKey())
         } else {
             const managedConnection = new ManagedConnection(
                 this.localPeerDescriptor!,

package/src/connection/websocket/WebsocketConnectorRpcLocal.ts

@@ -9,8 +9,8 @@ import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { ManagedConnection } from '../ManagedConnection'
 
 interface WebsocketConnectorRpcLocalConfig {
-    canConnect: (peerDescriptor: PeerDescriptor) => boolean
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection
+    hasConnection: (targetPeerDescriptor: PeerDescriptor) => boolean
     onNewConnection: (connection: ManagedConnection) => boolean
     abortSignal: AbortSignal
 }
@@ -25,17 +25,15 @@ export class WebsocketConnectorRpcLocal implements IWebsocketConnectorRpc {
 
     public async requestConnection(_request: WebsocketConnectionRequest, context: ServerCallContext): Promise<WebsocketConnectionResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (this.config.canConnect(senderPeerDescriptor)) {
-            setImmediate(() => {
-                if (this.config.abortSignal.aborted) {
-                    return
-                }
+        setImmediate(() => {
+            if (this.config.abortSignal.aborted) {
+                return
+            }
+            if (!this.config.hasConnection(senderPeerDescriptor)) {
                 const connection = this.config.connect(senderPeerDescriptor)
                 this.config.onNewConnection(connection)
-            })
-            return { accepted: true }
-        } else {
-            return { accepted: false }
-        }
+            }
+        })
+        return { accepted: true }
     }
 }

package/src/connection/websocket/WebsocketConnectorRpcRemote.ts

@@ -1,10 +1,10 @@
 import {
     PeerDescriptor,
-    WebsocketConnectionRequest
+    WebsocketConnectionRequest,
+    WebsocketConnectionResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { IWebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger } from '@streamr/utils'
-import * as Err from '../../helpers/errors'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { RpcRemote } from '../../dht/contact/RpcRemote'
@@ -21,19 +21,10 @@ export class WebsocketConnectorRpcRemote extends RpcRemote<IWebsocketConnectorRp
         super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
     }
 
-    async requestConnection(ip: string, port: number): Promise<boolean> {
+    async requestConnection(): Promise<WebsocketConnectionResponse> {
         logger.trace(`Requesting WebSocket connection from ${getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
-        const request: WebsocketConnectionRequest = {
-            ip,
-            port
-        }
+        const request: WebsocketConnectionRequest = {}
         const options = this.formDhtRpcOptions()
-        try {
-            const res = await this.getClient().requestConnection(request, options)
-            return res.accepted
-        } catch (err) {
-            logger.debug(new Err.WebsocketConnectionRequestRejected('WebsocketConnectionRequest rejected', err).stack!)
-            return false
-        }
+        return this.getClient().requestConnection(request, options)
     }
 }

package/src/connection/websocket/WebsocketServer.ts

@@ -101,11 +101,17 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
                     return
                 }
                 
-                const connection = request.accept(undefined, request.origin)
-                
-                logger.trace('IConnection accepted.')
+                let connection
+                try {
+                    connection = request.accept(undefined, request.origin)
+                    logger.trace('Connection accepted.', { remoteAddress: request.remoteAddress })
+                } catch (err) {
+                    logger.debug('Accepting websocket connection failed', { remoteAddress: request.remoteAddress, err })
+                }
 
-                this.emit('connected', new ServerWebsocket(connection, request.resourceURL))
+                if (connection) {
+                    this.emit('connected', new ServerWebsocket(connection, request.resourceURL))
+                }
             })
             this.httpServer.once('error', (err: Error) => {
                 reject(new WebsocketServerStartError('Starting Websocket server failed', err))
@@ -137,9 +143,18 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
         this.removeAllListeners()
         return new Promise((resolve, _reject) => {
             this.wsServer?.shutDown()
-            this.httpServer?.close(() => {
+            this.httpServer?.once('close', () => {
+                // removeAllListeners is maybe not needed?
+                this.httpServer?.removeAllListeners()
                 resolve()
             })
+            this.httpServer?.close()
+            // the close method "Stops the server from accepting new connections and closes all 
+            // connections connected to this server which are not sending a request or waiting for a 
+            // response." (https://nodejs.org/api/http.html#serverclosecallback)
+            // i.e. we need to call closeAllConnections() to close the rest of the connections
+            // (in practice this closes the active websocket connections)
+            this.httpServer?.closeAllConnections()
         })
     }
 

package/src/dht/DhtNode.ts

@@ -51,7 +51,7 @@ import { MarkRequired } from 'ts-essentials'
 import { DhtNodeRpcLocal } from './DhtNodeRpcLocal'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { ExternalApiRpcLocal } from './ExternalApiRpcLocal'
-import { PeerManager } from './PeerManager'
+import { PeerManager, getDistance } from './PeerManager'
 
 export interface DhtNodeEvents {
     newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
@@ -148,7 +148,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     public connectionManager?: ConnectionManager
     private started = false
-    private stopped = false
+    private abortController = new AbortController()
     private entryPointDisconnectTimeout?: NodeJS.Timeout
 
     constructor(conf: DhtNodeOptions) {
@@ -173,7 +173,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async start(): Promise<void> {
-        if (this.started || this.stopped) {
+        if (this.started || this.abortController.signal.aborted) {
             return
         }
         logger.trace(`Starting new Streamr Network DHT Node with serviceId ${this.config.serviceId}`)
@@ -283,7 +283,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             localDataStore: this.localDataStore,
             dhtNodeEmitter: this,
             getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => {
-                return this.peerManager!.bucket!.closest(id, n)
+                return this.peerManager!.getClosestNeighborsTo(id, n)
             },
             rpcRequestTimeout: this.config.rpcRequestTimeout
         })
@@ -297,7 +297,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     private initPeerManager() {
         this.peerManager = new PeerManager({
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
-            maxNeighborListSize: this.config.maxNeighborListSize,
+            maxContactListSize: this.config.maxNeighborListSize,
             ownPeerId: this.getNodeId(),
             connectionManager: this.connectionManager!,
             peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
@@ -343,13 +343,16 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     private bindRpcLocalMethods(): void {
-        if (!this.started || this.stopped) {
+        if (!this.started || this.abortController.signal.aborted) {
             return
         }
         const dhtNodeRpcLocal = new DhtNodeRpcLocal({
-            bucket: this.peerManager!.bucket!,
             serviceId: this.config.serviceId,
             peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
+            getClosestPeersTo: (kademliaId: Uint8Array, limit: number) => {
+                return this.peerManager!.getClosestNeighborsTo(kademliaId, limit)
+                    .map((dhtPeer: DhtNodeRpcRemote) => dhtPeer.getPeerDescriptor())
+            },
             addNewContact: (contact: PeerDescriptor) => this.peerManager!.handleNewPeers([contact]),
             removeContact: (contact: PeerDescriptor) => this.removeContact(contact)
         })
@@ -382,8 +385,8 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     private isPeerCloserToIdThanSelf(peer1: PeerDescriptor, compareToId: PeerID): boolean {
-        const distance1 = this.peerManager!.bucket!.distance(peer1.nodeId, compareToId.value)
-        const distance2 = this.peerManager!.bucket!.distance(this.localPeerDescriptor!.nodeId, compareToId.value)
+        const distance1 = getDistance(peer1.nodeId, compareToId.value)
+        const distance2 = getDistance(this.localPeerDescriptor!.nodeId, compareToId.value)
         return distance1 < distance2
     }
 
@@ -408,16 +411,16 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return this.localPeerDescriptor
     }
 
-    public getClosestContacts(maxCount?: number): PeerDescriptor[] {
-        return this.peerManager!.neighborList!.getClosestContacts(maxCount).map((c) => c.getPeerDescriptor())
+    public getClosestContacts(limit?: number): PeerDescriptor[] {
+        return this.peerManager!.getClosestContactsTo(this.localPeerDescriptor!.nodeId, limit).map((peer) => peer.getPeerDescriptor())
     }
-
+    
     public getNodeId(): PeerID {
         return peerIdFromPeerDescriptor(this.localPeerDescriptor!)
     }
 
-    public getBucketSize(): number {
-        return this.peerManager!.bucket!.count()
+    public getNumberOfNeighbors(): number {
+        return this.peerManager!.getNumberOfNeighbors()
     }
 
     private connectToEntryPoint(entryPoint: PeerDescriptor): void {
@@ -435,7 +438,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async send(msg: Message): Promise<void> {
-        if (!this.started || this.stopped) {
+        if (!this.started || this.abortController.signal.aborted) {
             return
         }
         const reachableThrough = this.peerDiscovery!.isJoinOngoing() ? this.config.entryPoints ?? [] : []
@@ -481,7 +484,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async deleteDataFromDht(key: Uint8Array, waitForCompletion: boolean): Promise<void> {
-        if (!this.stopped) {
+        if (!this.abortController.signal.aborted) {
             await this.finder!.startFind(key, FindAction.DELETE_DATA, undefined, waitForCompletion)
         }
     }
@@ -508,8 +511,9 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return Array.from(this.peerManager!.connections.values()).map((peer) => peer.getPeerDescriptor())
     }
 
-    public getKBucketPeers(): PeerDescriptor[] {
-        return this.peerManager!.bucket!.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
+    // TODO rename to getNeighbors
+    public getAllNeighborPeerDescriptors(): PeerDescriptor[] {
+        return this.peerManager!.getNeighbors()
     }
 
     public getNumberOfConnections(): number {
@@ -529,7 +533,13 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async waitForNetworkConnectivity(): Promise<void> {
-        await waitForCondition(() => this.peerManager!.connections.size > 0, this.config.networkConnectivityTimeout)
+        await waitForCondition(() => {
+            if (!this.peerManager) {
+                return false
+            } else {
+                return (this.peerManager.getNumberOfConnections() > 0)
+            }
+        }, this.config.networkConnectivityTimeout, 100, this.abortController.signal)
     }
 
     public hasJoined(): boolean {
@@ -537,11 +547,11 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async stop(): Promise<void> {
-        if (this.stopped || !this.started) {
+        if (this.abortController.signal.aborted || !this.started) {
             return
         }
         logger.trace('stop()')
-        this.stopped = true
+        this.abortController.abort()
         await this.storeRpcLocal!.destroy()
         if (this.entryPointDisconnectTimeout) {
             clearTimeout(this.entryPointDisconnectTimeout)