@streamr/dht 100.2.2 → 100.2.4-beta.0

package/protos/DhtRpc.proto

@@ -9,7 +9,9 @@ import "google/protobuf/timestamp.proto";
 import "packages/proto-rpc/protos/ProtoRpc.proto";
 
 service DhtNodeRpc {
+  // TODO rename to getClosestNeighbors (breaking change)
   rpc getClosestPeers (ClosestPeersRequest) returns (ClosestPeersResponse);
+  // TODO rename to getClosestRingContacts (breaking change)
   rpc getClosestRingPeers (ClosestRingPeersRequest) returns (ClosestRingPeersResponse);
   rpc ping (PingRequest) returns (PingResponse);
   rpc leaveNotice (LeaveNotice) returns (google.protobuf.Empty);
@@ -92,21 +94,25 @@ message DataEntry {
   bool deleted = 8;
 }
 
+// TODO rename to ClosestNeighborsRequest
 message ClosestPeersRequest {
   bytes nodeId = 1;
   string requestId = 2;
 }
 
+// TODO rename to ClosestNeighborsResponse
 message ClosestPeersResponse {
   repeated PeerDescriptor peers = 1;
   string requestId = 2;
 }
 
+// TODO rename to ClosestRingContactsRequest
 message ClosestRingPeersRequest {
   bytes ringId = 1;
   string requestId = 2;
 }
 
+// TODO rename to ClosestRingContactsResponse
 message ClosestRingPeersResponse {
   repeated PeerDescriptor leftPeers = 1;
   repeated PeerDescriptor rightPeers = 2;
@@ -125,7 +131,7 @@ enum RecursiveOperation {
 }
 
 message RecursiveOperationResponse {
-  repeated PeerDescriptor closestConnectedPeers = 1;
+  repeated PeerDescriptor closestConnectedNodes = 1;
   repeated DataEntry dataEntries = 2;
   bool noCloserNodesFound = 3;
   repeated PeerDescriptor routingPath = 4;

package/src/connection/ConnectionLockStates.ts

@@ -36,12 +36,10 @@ export class ConnectionLockStates {
     public isRemoteLocked(id: DhtAddress, lockId?: LockID): boolean {
         if (lockId === undefined) {
             return this.remoteLocks.has(id)
+        } else if (this.remoteLocks.has(id) && this.remoteLocks.get(id)!.has(lockId)) {
+            return true
         } else {
-            if (this.remoteLocks.has(id) && this.remoteLocks.get(id)!.has(lockId)) {
-                return true
-            } else {
-                return false
-            }
+            return false
         }
     }
 

package/src/connection/ConnectionManager.ts

@@ -304,7 +304,13 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     public hasConnection(nodeId: DhtAddress): boolean {
-        return this.connections.has(nodeId)
+        // TODO if we remove filtering in getConnections, this can just be this.connection.has(nodeId)
+        return this.getConnections().some((c) => getNodeIdFromPeerDescriptor(c) == nodeId)
+    }
+
+    public getConnectionCount(): number {
+        // TODO if we remove filtering in getConnections, this can just be this.connection.length
+        return this.getConnections().length
     }
 
     public hasLocalLockedConnection(nodeId: DhtAddress): boolean {
@@ -545,6 +551,8 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
 
     public getConnections(): PeerDescriptor[] {
         return Array.from(this.connections.values())
+            // 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.connections directly?)
             .filter((managedConnection: ManagedConnection) => managedConnection.isHandshakeCompleted())
             .map((managedConnection: ManagedConnection) => managedConnection.getPeerDescriptor()!)
     }

package/src/connection/ManagedConnection.ts

@@ -96,21 +96,18 @@ export class ManagedConnection extends EventEmitter<Events> {
             })
             outgoingConnection.once('disconnected', this.onDisconnected)
 
-        } else {
-            if (incomingConnection) {
-                this.handshaker = new Handshaker(this.localPeerDescriptor, incomingConnection)
-                this.handshaker.on('handshakeRequest', (
-                    sourcePeerDescriptor: PeerDescriptor,
-                    version: string,
-                    targetPeerDescriptor?: PeerDescriptor
-                ) => {
-                    this.setRemotePeerDescriptor(sourcePeerDescriptor)
-                    this.emit('handshakeRequest', sourcePeerDescriptor, version, targetPeerDescriptor)
-                })
-
-                incomingConnection.on('disconnected', this.onDisconnected)
+        } else if (incomingConnection) {
+            this.handshaker = new Handshaker(this.localPeerDescriptor, incomingConnection)
+            this.handshaker.on('handshakeRequest', (
+                sourcePeerDescriptor: PeerDescriptor,
+                version: string,
+                targetPeerDescriptor?: PeerDescriptor
+            ) => {
+                this.setRemotePeerDescriptor(sourcePeerDescriptor)
+                this.emit('handshakeRequest', sourcePeerDescriptor, version, targetPeerDescriptor)
+            })
 
-            }
+            incomingConnection.on('disconnected', this.onDisconnected)
         }
     }
 

package/src/connection/websocket/WebsocketConnector.ts

@@ -154,6 +154,7 @@ export class WebsocketConnector {
                     // The localPeerDescriptor can be undefined here as the WS server is used for connectivity checks
                     // before the localPeerDescriptor is set during start.
                     // Handshaked connections should be rejected before the localPeerDescriptor is set.
+                    // eslint-disable-next-line no-lonely-if
                     if (this.localPeerDescriptor !== undefined) {
                         this.attachHandshaker(connection)
                     } else {

package/src/dht/DhtNode.ts

@@ -53,12 +53,12 @@ import { getLocalRegion } from '@streamr/cdn-location'
 import { RingContacts } from './contact/RingContactList'
 
 export interface DhtNodeEvents {
-    contactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    randomContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
-    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    closestContactAdded: (peerDescriptor: PeerDescriptor) => void
+    closestContactRemoved: (peerDescriptor: PeerDescriptor) => void
+    randomContactAdded: (peerDescriptor: PeerDescriptor) => void
+    randomContactRemoved: (peerDescriptor: PeerDescriptor) => void
+    ringContactAdded: (peerDescriptor: PeerDescriptor) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor) => void
 }
 
 export interface DhtNodeOptions {
@@ -241,7 +241,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
         this.rpcCommunicator = new RoutingRpcCommunicator(
             this.config.serviceId,
-            this.transport.send,
+            (msg, opts) => this.transport!.send(msg, opts),
             { rpcRequestTimeout: this.config.rpcRequestTimeout }
         )
 
@@ -252,7 +252,6 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         this.peerDiscovery = new PeerDiscovery({
             localPeerDescriptor: this.localPeerDescriptor!,
             joinNoProgressLimit: this.config.joinNoProgressLimit,
-            peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
             joinTimeout: this.config.dhtJoinTimeout,
             serviceId: this.config.serviceId,
             parallelism: this.config.joinParallelism,
@@ -261,19 +260,19 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         })
         this.router = new Router({
             rpcCommunicator: this.rpcCommunicator,
-            connections: this.peerManager!.connections,
             localPeerDescriptor: this.localPeerDescriptor!,
             handleMessage: (message: Message) => this.handleMessageFromRouter(message),
+            getConnections: () => this.getConnections()
         })
         this.recursiveOperationManager = new RecursiveOperationManager({
             rpcCommunicator: this.rpcCommunicator,
             router: this.router,
             sessionTransport: this,
-            connections: this.peerManager!.connections,
             localPeerDescriptor: this.localPeerDescriptor!,
             serviceId: this.config.serviceId,
+            localDataStore: this.localDataStore,
             addContact: (contact: PeerDescriptor) => this.peerManager!.addContact(contact),
-            localDataStore: this.localDataStore
+            createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => this.createDhtNodeRpcRemote(peerDescriptor),
         })
         this.storeManager = new StoreManager({
             rpcCommunicator: this.rpcCommunicator,
@@ -296,7 +295,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 )
             }
         })
-        this.on('contactAdded', (peerDescriptor: PeerDescriptor) => {
+        this.on('closestContactAdded', (peerDescriptor: PeerDescriptor) => {
             this.storeManager!.onContactAdded(peerDescriptor)
         })
         this.bindRpcLocalMethods()
@@ -309,28 +308,27 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             localNodeId: this.getNodeId(),
             localPeerDescriptor: this.localPeerDescriptor!,
             connectionLocker: this.connectionLocker,
-            peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
-            isLayer0: (this.connectionLocker !== undefined),
+            lockId: this.config.serviceId,
             createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => this.createDhtNodeRpcRemote(peerDescriptor),
-            lockId: this.config.serviceId
+            hasConnection: (nodeId: DhtAddress) => this.transport!.hasConnection(nodeId)
         })
-        this.peerManager.on('contactRemoved', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) => {
-            this.emit('contactRemoved', peerDescriptor, activeContacts)
+        this.peerManager.on('closestContactRemoved', (peerDescriptor: PeerDescriptor) => {
+            this.emit('closestContactRemoved', peerDescriptor)
         })
-        this.peerManager.on('contactAdded', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) =>
-            this.emit('contactAdded', peerDescriptor, activeContacts)
+        this.peerManager.on('closestContactAdded', (peerDescriptor: PeerDescriptor) =>
+            this.emit('closestContactAdded', peerDescriptor)
         )
-        this.peerManager.on('randomContactRemoved', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) =>
-            this.emit('randomContactRemoved', peerDescriptor, activeContacts)
+        this.peerManager.on('randomContactRemoved', (peerDescriptor: PeerDescriptor) =>
+            this.emit('randomContactRemoved', peerDescriptor)
         )
-        this.peerManager.on('randomContactAdded', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) =>
-            this.emit('randomContactAdded', peerDescriptor, activeContacts)
+        this.peerManager.on('randomContactAdded', (peerDescriptor: PeerDescriptor) =>
+            this.emit('randomContactAdded', peerDescriptor)
         )
-        this.peerManager.on('ringContactRemoved', (peerDescriptor: PeerDescriptor, activeContacts: RingContacts) => {
-            this.emit('ringContactRemoved', peerDescriptor, activeContacts)
+        this.peerManager.on('ringContactRemoved', (peerDescriptor: PeerDescriptor) => {
+            this.emit('ringContactRemoved', peerDescriptor)
         })
-        this.peerManager.on('ringContactAdded', (peerDescriptor: PeerDescriptor, activeContacts: RingContacts) => {
-            this.emit('ringContactAdded', peerDescriptor, activeContacts)
+        this.peerManager.on('ringContactAdded', (peerDescriptor: PeerDescriptor) => {
+            this.emit('ringContactAdded', peerDescriptor)
         })
         this.peerManager.on('kBucketEmpty', () => {
             if (!this.peerDiscovery!.isJoinOngoing()
@@ -348,18 +346,22 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             }
         })
         this.transport!.on('connected', (peerDescriptor: PeerDescriptor) => {
-            this.peerManager!.onContactConnected(peerDescriptor)
             this.router!.onNodeConnected(peerDescriptor)
             this.emit('connected', peerDescriptor)
         })
         this.transport!.on('disconnected', (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => {
-            this.peerManager!.onContactDisconnected(getNodeIdFromPeerDescriptor(peerDescriptor), gracefulLeave)
+            const isLayer0 = (this.connectionLocker !== undefined)
+            if (isLayer0) {
+                const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+                if (gracefulLeave) {
+                    this.peerManager!.removeContact(nodeId)
+                } else {
+                    this.peerManager!.removeNeighbor(nodeId)
+                }
+            }
             this.router!.onNodeDisconnected(peerDescriptor)
             this.emit('disconnected', peerDescriptor, gracefulLeave)
         })
-        this.transport!.getConnections().forEach((peer) => {
-            this.peerManager!.onContactConnected(peer)
-        })
     }
 
     private bindRpcLocalMethods(): void {
@@ -368,11 +370,11 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         }
         const dhtNodeRpcLocal = new DhtNodeRpcLocal({
             peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
-            getClosestPeersTo: (nodeId: DhtAddress, limit: number) => {
+            getClosestNeighborsTo: (nodeId: DhtAddress, limit: number) => {
                 return this.peerManager!.getClosestNeighborsTo(nodeId, limit)
                     .map((dhtPeer: DhtNodeRpcRemote) => dhtPeer.getPeerDescriptor())
             },
-            getClosestRingPeersTo: (ringIdRaw: RingIdRaw, limit: number) => {
+            getClosestRingContactsTo: (ringIdRaw: RingIdRaw, limit: number) => {
                 return this.getClosestRingContactsTo(ringIdRaw, limit)
             },
             addContact: (contact: PeerDescriptor) => this.peerManager!.addContact(contact),
@@ -432,9 +434,22 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public getClosestContacts(limit?: number): PeerDescriptor[] {
-        return this.peerManager!.getClosestContactsTo(
-            this.getNodeId(),
-            limit).map((peer) => peer.getPeerDescriptor())
+        return this.peerManager!.getClosestContacts()
+            .getClosestContacts(limit)
+            .map((peer) => peer.getPeerDescriptor())
+    }
+
+    // TODO remove defaultContactQueryLimit parameter from RandomContactList#getContacts and use explicit value here?
+    getRandomContacts(): PeerDescriptor[] {
+        return this.peerManager!.getRandomContacts().getContacts().map((c) => c.getPeerDescriptor())
+    }
+
+    getRingContacts(): RingContacts {
+        const contacts = this.peerManager!.getRingContacts().getClosestContacts()
+        return {
+            left: contacts.left.map((c) => c.getPeerDescriptor()),
+            right: contacts.right.map((c) => c.getPeerDescriptor())
+        }
     }
 
     public getClosestRingContactsTo(ringIdRaw: RingIdRaw, limit?: number): RingContacts {
@@ -470,7 +485,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     private getConnectedEntryPoints(): PeerDescriptor[] {
         return this.config.entryPoints !== undefined ? this.config.entryPoints.filter((entryPoint) =>
-            this.peerManager!.connections.has(getNodeIdFromPeerDescriptor(entryPoint))
+            this.transport!.hasConnection(getNodeIdFromPeerDescriptor(entryPoint))
         ) : []
     }
 
@@ -544,16 +559,20 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return this.localPeerDescriptor!
     }
 
-    public getConnections(): PeerDescriptor[] {
-        return Array.from(this.peerManager!.connections.values()).map((peer) => peer.getPeerDescriptor())
-    }
-
     public getNeighbors(): PeerDescriptor[] {
         return this.started ? this.peerManager!.getNeighbors() : []
     }
 
+    public getConnections(): PeerDescriptor[] {
+        return this.transport!.getConnections()
+    }
+
     public getConnectionCount(): number {
-        return this.peerManager!.getConnectionCount()
+        return this.transport!.getConnectionCount()
+    }
+
+    public hasConnection(nodeId: DhtAddress): boolean {
+        return this.transport!.hasConnection(nodeId)
     }
 
     public getLocalLockedConnectionCount(): number {
@@ -573,7 +592,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             if (!this.peerManager) {
                 return false
             } else {
-                return (this.peerManager.getConnectionCount() > 0)
+                return (this.getConnectionCount() > 0)
             }
         }, this.config.networkConnectivityTimeout, 100, this.abortController.signal)
     }

package/src/dht/DhtNodeRpcLocal.ts

@@ -18,8 +18,8 @@ import { RingContacts } from './contact/RingContactList'
 
 interface DhtNodeRpcLocalConfig {
     peerDiscoveryQueryBatchSize: number
-    getClosestPeersTo: (nodeId: DhtAddress, limit: number) => PeerDescriptor[]
-    getClosestRingPeersTo: (id: RingIdRaw, limit: number) => RingContacts
+    getClosestNeighborsTo: (nodeId: DhtAddress, limit: number) => PeerDescriptor[]
+    getClosestRingContactsTo: (id: RingIdRaw, limit: number) => RingContacts
     addContact: (contact: PeerDescriptor) => void
     removeContact: (nodeId: DhtAddress) => void
 }
@@ -37,18 +37,19 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
     async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
         this.config.addContact((context as DhtCallContext).incomingSourceDescriptor!)
         const response = {
-            peers: this.config.getClosestPeersTo(getDhtAddressFromRaw(request.nodeId), this.config.peerDiscoveryQueryBatchSize),
+            peers: this.config.getClosestNeighborsTo(getDhtAddressFromRaw(request.nodeId), this.config.peerDiscoveryQueryBatchSize),
             requestId: request.requestId
         }
         return response
     }
 
+    // TODO rename to getClosestRingContacts
     async getClosestRingPeers(request: ClosestRingPeersRequest, context: ServerCallContext): Promise<ClosestRingPeersResponse> {
         this.config.addContact((context as DhtCallContext).incomingSourceDescriptor!)
-        const closestPeers = this.config.getClosestRingPeersTo(request.ringId as RingIdRaw, this.config.peerDiscoveryQueryBatchSize)
+        const closestContacts = this.config.getClosestRingContactsTo(request.ringId as RingIdRaw, this.config.peerDiscoveryQueryBatchSize)
         const response = {
-            leftPeers: closestPeers.left,
-            rightPeers: closestPeers.right,
+            leftPeers: closestContacts.left,
+            rightPeers: closestContacts.right,
             requestId: request.requestId
         }
         return response

package/src/dht/DhtNodeRpcRemote.ts

@@ -58,6 +58,7 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
         }
     }
 
+    // TODO rename to getClosestRingContacts (breaking change)
     async getClosestRingPeers(ringIdRaw: RingIdRaw): Promise<RingContacts> {
         logger.trace(`Requesting getClosestRingPeers on ${this.serviceId} from ${this.getNodeId()}`)
         const request: ClosestRingPeersRequest = {

package/src/dht/PeerManager.ts

@@ -7,11 +7,11 @@ import {
 } from '../proto/packages/dht/protos/DhtRpc'
 import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
 import { RandomContactList } from './contact/RandomContactList'
-import { SortedContactList } from './contact/SortedContactList'
+import { ReadonlySortedContactList, SortedContactList } from './contact/SortedContactList'
 import { ConnectionLocker } from '../connection/ConnectionManager'
 import EventEmitter from 'eventemitter3'
 import { DhtAddress, DhtAddressRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../identifiers'
-import { RingContactList, RingContacts } from './contact/RingContactList'
+import { RingContactList } from './contact/RingContactList'
 import { RingIdRaw, getRingIdRawFromPeerDescriptor } from './contact/ringIdentifiers'
 import { LockID } from '../connection/ConnectionLockStates'
 
@@ -20,22 +20,21 @@ const logger = new Logger(module)
 interface PeerManagerConfig {
     numberOfNodesPerKBucket: number
     maxContactListSize: number
-    peerDiscoveryQueryBatchSize: number
     localNodeId: DhtAddress
     localPeerDescriptor: PeerDescriptor
     connectionLocker?: ConnectionLocker
-    isLayer0: boolean
     lockId: LockID
     createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
+    hasConnection: (nodeId: DhtAddress) => boolean
 }
 
 export interface PeerManagerEvents {
-    contactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    randomContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
-    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    closestContactAdded: (peerDescriptor: PeerDescriptor) => void
+    closestContactRemoved: (peerDescriptor: PeerDescriptor) => void
+    randomContactAdded: (peerDescriptor: PeerDescriptor) => void
+    randomContactRemoved: (peerDescriptor: PeerDescriptor) => void
+    ringContactAdded: (peerDescriptor: PeerDescriptor) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor) => void
     kBucketEmpty: () => void
 }
 
@@ -52,8 +51,6 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     // * 'contacts' are all non-unresponsive nodes that we know about
 
     private neighbors: KBucket<DhtNodeRpcRemote>
-    // Nodes that are connected to this node on Layer0
-    public readonly connections: Map<DhtAddress, DhtNodeRpcRemote> = new Map()
     private closestContacts: SortedContactList<DhtNodeRpcRemote>
     private activeContacts: Set<DhtAddress>
     private ringContacts: RingContactList<DhtNodeRpcRemote>
@@ -70,11 +67,11 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             numberOfNodesToPing: this.config.numberOfNodesPerKBucket
         })
         this.ringContacts = new RingContactList<DhtNodeRpcRemote>(getRingIdRawFromPeerDescriptor(this.config.localPeerDescriptor))
-        this.ringContacts.on('ringContactAdded', (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => {
-            this.emit('ringContactAdded', peerDescriptor, closestPeers)
+        this.ringContacts.on('contactAdded', (contact: DhtNodeRpcRemote) => {
+            this.emit('ringContactAdded', contact.getPeerDescriptor())
         })
-        this.ringContacts.on('ringContactRemoved', (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => {
-            this.emit('ringContactRemoved', peerDescriptor, closestPeers)
+        this.ringContacts.on('contactRemoved', (contact: DhtNodeRpcRemote) => {
+            this.emit('ringContactRemoved', contact.getPeerDescriptor())
         })
         this.neighbors.on('ping', (oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote) => this.onKBucketPing(oldContacts, newContact))
         this.neighbors.on('removed', (contact: DhtNodeRpcRemote) => this.onKBucketRemoved(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
@@ -87,23 +84,23 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             maxSize: this.config.maxContactListSize,
             allowToContainReferenceId: false
         })
-        this.closestContacts.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) => {
+        this.closestContacts.on('contactRemoved', (contact: DhtNodeRpcRemote) => {
             if (this.stopped) {
                 return
             }
-            this.emit('contactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
-            this.randomContacts.addContact(this.config.createDhtNodeRpcRemote(removedContact.getPeerDescriptor()))
+            this.emit('closestContactRemoved', contact.getPeerDescriptor())
+            this.randomContacts.addContact(this.config.createDhtNodeRpcRemote(contact.getPeerDescriptor()))
         })
-        this.closestContacts.on('contactAdded', (contactAdded: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
-            this.emit('contactAdded', contactAdded.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        this.closestContacts.on('contactAdded', (contact: DhtNodeRpcRemote) =>
+            this.emit('closestContactAdded', contact.getPeerDescriptor())
         )
         this.activeContacts = new Set()
         this.randomContacts = new RandomContactList(this.config.localNodeId, this.config.maxContactListSize)
-        this.randomContacts.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
-            this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        this.randomContacts.on('contactRemoved', (removedContact: DhtNodeRpcRemote) =>
+            this.emit('randomContactRemoved', removedContact.getPeerDescriptor())
         )
-        this.randomContacts.on('contactAdded', (contactAdded: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
-            this.emit('randomContactAdded', contactAdded.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        this.randomContacts.on('contactAdded', (contactAdded: DhtNodeRpcRemote) =>
+            this.emit('randomContactAdded', contactAdded.getPeerDescriptor())
         )
     }
 
@@ -143,7 +140,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
             // Important to lock here, before the ping result is known
             this.config.connectionLocker?.weakLockConnection(nodeId, this.config.lockId)
-            if (this.connections.has(contact.getNodeId())) {
+            if (this.config.hasConnection(contact.getNodeId())) {
                 logger.trace(`Added new contact ${nodeId}`)
             } else {    // open connection by pinging
                 logger.trace('starting ping ' + nodeId)
@@ -184,35 +181,6 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return undefined
     }
 
-    onContactConnected(peerDescriptor: PeerDescriptor): void {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-        if (nodeId === this.config.localNodeId) {
-            logger.error('handleConnected() to self')
-        }
-        const rpcRemote = this.config.createDhtNodeRpcRemote(peerDescriptor)
-        if (!this.connections.has(nodeId)) {
-            this.connections.set(nodeId, rpcRemote)
-            logger.trace('connectionschange add ' + this.connections.size)
-        } else {
-            logger.trace('new connection not set to connections, there is already a connection with the peer ID')
-        }
-        logger.trace('connected: ' + nodeId + ' ' + this.connections.size)
-    }
-
-    onContactDisconnected(nodeId: DhtAddress, gracefulLeave: boolean): void {
-        logger.trace('disconnected: ' + nodeId)
-        this.connections.delete(nodeId)
-        if (this.config.isLayer0) {
-            this.neighbors.remove(getRawFromDhtAddress(nodeId))
-            if (gracefulLeave === true) {
-                logger.trace(nodeId + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
-                this.removeContact(nodeId)
-            } else {
-                logger.trace(nodeId + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
-            }
-        }
-    }
-
     removeContact(nodeId: DhtAddress): void {
         if (this.stopped) {
             return
@@ -225,6 +193,10 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         this.randomContacts.removeContact(nodeId)
     }
 
+    removeNeighbor(nodeId: DhtAddress): void {
+        this.neighbors.remove(getRawFromDhtAddress(nodeId))
+    }
+
     stop(): void {
         this.stopped = true
         this.neighbors.toArray().forEach((rpcRemote: DhtNodeRpcRemote) => {
@@ -238,7 +210,6 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         })
         this.closestContacts.stop()
         this.randomContacts.stop()
-        this.connections.clear()
     }
 
     getClosestNeighborsTo(referenceId: DhtAddress, limit?: number, excludedNodeIds?: Set<DhtAddress>): DhtNodeRpcRemote[] {
@@ -252,18 +223,8 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return closest.getClosestContacts()
     }
 
-    // TODO reduce copy-paste?
-    getClosestContactsTo(referenceId: DhtAddress, limit?: number, excludedNodeIds?: Set<DhtAddress>): DhtNodeRpcRemote[] {
-        const closest = new SortedContactList<DhtNodeRpcRemote>({
-            referenceId,
-            allowToContainReferenceId: true,
-            excludedNodeIds,
-            maxSize: limit
-        })
-        for (const contact of this.closestContacts.getAllContactsInUndefinedOrder()) {
-            closest.addContact(contact)
-        }
-        return closest.getClosestContacts()
+    getClosestContacts(): ReadonlySortedContactList<DhtNodeRpcRemote> {
+        return this.closestContacts
     }
 
     getClosestRingContactsTo(
@@ -278,15 +239,20 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         this.ringContacts.getAllContacts().map((contact) => closest.addContact(contact))
         return closest.getClosestContacts(limit ?? 8)
     }
+    
+    getRandomContacts(): RandomContactList<DhtNodeRpcRemote> {
+        return this.randomContacts
+    }
+    
+    getRingContacts(): RingContactList<DhtNodeRpcRemote> {
+        return this.ringContacts
+    }
 
+    // TODO rename getNearbyContactsCount
     getContactCount(excludedNodeIds?: Set<DhtAddress>): number {
         return this.closestContacts.getSize(excludedNodeIds)
     }
 
-    getConnectionCount(): number {
-        return this.connections.size
-    }
-
     getNeighborCount(): number {
         return this.neighbors.count()
     }

package/src/dht/contact/ContactList.ts

@@ -2,8 +2,8 @@ import EventEmitter from 'eventemitter3'
 import { DhtAddress } from '../../identifiers'
 
 export interface Events<C> {
-    contactRemoved: (removedContact: C, closestContacts: C[]) => void
-    contactAdded: (contactAdded: C, closestContacts: C[]) => void
+    contactRemoved: (removedContact: C) => void
+    contactAdded: (contactAdded: C) => void
 }
 
 export class ContactList<C extends { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {

package/src/dht/contact/RandomContactList.ts

@@ -30,8 +30,7 @@ export class RandomContactList<C extends { getNodeId: () => DhtAddress }> extend
                 this.contactsById.set(contact.getNodeId(), contact)
                 this.emit(
                     'contactAdded',
-                    contact,
-                    this.getContacts()
+                    contact
                 )
             }
         }
@@ -43,7 +42,7 @@ export class RandomContactList<C extends { getNodeId: () => DhtAddress }> extend
             const index = this.contactIds.findIndex((nodeId) => (nodeId === id))
             this.contactIds.splice(index, 1)
             this.contactsById.delete(id)
-            this.emit('contactRemoved', removed, this.getContacts())
+            this.emit('contactRemoved', removed)
             return true
         }
         return false