@streamr/dht 100.0.0 → 100.1.0

package/src/connection/websocket/{ClientWebsocket.ts → AbstractWebsocketClientConnection.ts}

@@ -1,10 +1,14 @@
-import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
-import { ICloseEvent, IMessageEvent, w3cwebsocket as Websocket } from 'websocket'
-import { ConnectionEvents, ConnectionID, ConnectionType, IConnection } from '../IConnection'
 import { createRandomConnectionId } from '../Connection'
+import { ConnectionEvents, ConnectionID, ConnectionType, IConnection } from '../IConnection'
+import { Logger } from '@streamr/utils'
 
-const logger = new Logger(module)
+export interface Socket {
+    binaryType: string
+    readyState: number
+    close(code?: number, reason?: string): void
+    send(data: string | Buffer | ArrayBuffer | ArrayBufferView): void
+}
 
 // https://kapeli.com/cheat_sheets/WebSocket_Status_Codes.docset/Contents/Resources/Documents/index
 // Browsers send this automatically when closing a tab
@@ -12,78 +16,33 @@ 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
+// https://github.com/websockets/ws/blob/master/doc/ws.md#ready-state-constants
+const OPEN = 1
 
-const BINARY_TYPE = 'arraybuffer'
+const logger = new Logger(module)
 
-export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements IConnection {
+export abstract class AbstractWebsocketClientConnection extends EventEmitter<ConnectionEvents> implements IConnection {
 
     public readonly connectionId: ConnectionID
-    private socket?: Websocket
+    protected abstract socket?: Socket
     public connectionType = ConnectionType.WEBSOCKET_CLIENT
-
-    private destroyed = false
-
+    protected destroyed = false
+    
     constructor() {
         super()
         this.connectionId = createRandomConnectionId()
     }
 
     // TODO explicit default value for "selfSigned" or make it required
-    public connect(address: string, selfSigned?: boolean): void {
-        if (!this.destroyed) {
-            this.socket = new Websocket(address, undefined, undefined, undefined, { rejectUnauthorized: !selfSigned })
-            this.socket.binaryType = BINARY_TYPE
-            this.socket.onerror = (error: Error) => {
-                if (!this.destroyed) {
-                    logger.trace('WebSocket Client error: ' + error?.message, { error })
-                    this.emit('error', error.name)
-                }
-            }
-
-            this.socket.onopen = () => {
-                if (!this.destroyed) {
-                    logger.trace('WebSocket Client Connected')
-                    if (this.socket && this.socket.readyState === this.socket.OPEN) {
-                        this.emit('connected')
-                    }
-                }
-            }
-
-            this.socket.onclose = (event: ICloseEvent) => {
-                if (!this.destroyed) {
-                    logger.trace('Websocket Closed')
-                    this.doDisconnect(event.code, event.reason)
-                }
-            }
-
-            this.socket.onmessage = (message: IMessageEvent) => {
-                if (!this.destroyed) {
-                    if (typeof message.data === 'string') {
-                        logger.debug('Received string: \'' + message.data + '\'')
-                    } else {
-                        this.emit('data', new Uint8Array(message.data))
-                    }
-                }
-            }
-        } else {
-            logger.debug('Tried to connect() a stopped connection')
-        }
-    }
-
-    private doDisconnect(code?: number, reason?: string) {
-        this.destroyed = true
-        this.stopListening()
-        this.socket = undefined
-        const gracefulLeave = (code === GOING_AWAY) || (code === CUSTOM_GOING_AWAY)
-        this.emit('disconnected', gracefulLeave, code, reason)
-        this.removeAllListeners()
-    }
+    public abstract connect(address: string, selfSigned?: boolean): void
+    
+    protected abstract stopListening(): void
 
     public send(data: Uint8Array): void {
         if (!this.destroyed) {
-            if (this.socket && this.socket.readyState === this.socket.OPEN) {
+            if (this.socket && this.socket.readyState === OPEN) {
                 logger.trace(`Sending data with size ${data.byteLength}`)
-                this.socket?.send(data.buffer)
+                this.socket?.send(data)
             } else {
                 logger.debug('Tried to send data on a non-open connection')
             }
@@ -103,15 +62,6 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
         }
     }
 
-    private stopListening(): void {
-        if (this.socket) {
-            this.socket.onopen = undefined as unknown as (() => void)
-            this.socket.onclose = undefined as unknown as (() => void)
-            this.socket.onerror = undefined as unknown as (() => void)
-            this.socket.onmessage = undefined as unknown as (() => void)
-        }
-    }
-
     public destroy(): void {
         logger.trace('destroy() a connection')
         if (!this.destroyed) {
@@ -126,4 +76,41 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
             logger.debug('Tried to destroy() a stopped connection')
         }
     }
+
+    protected onOpen(): void {
+        if (!this.destroyed) {
+            logger.trace('WebSocket Client Connected')
+            if (this.socket && this.socket.readyState === OPEN) {
+                this.emit('connected')
+            }
+        }
+    }
+
+    protected onMessage(message: Uint8Array): void {
+        this.emit('data', message)
+    }
+
+    protected onClose(code: number, reason: string): void {
+        if (!this.destroyed) {
+            logger.trace('Websocket Closed')
+            this.doDisconnect(code, reason)
+        }
+    }
+
+    protected onError(error: Error): void {
+        if (!this.destroyed) {
+            logger.trace('WebSocket Client error: ' + error?.message, { error })
+            this.emit('error', error.name)
+        }
+    }
+
+    protected doDisconnect(code?: number, reason?: string): void {
+        this.destroyed = true
+        this.stopListening()
+        this.socket = undefined
+        const gracefulLeave = (code === GOING_AWAY) || (code === CUSTOM_GOING_AWAY)
+        this.emit('disconnected', gracefulLeave, code, reason)
+        this.removeAllListeners()
+    }
+
 }

package/src/connection/websocket/BrowserWebsocketClientConnection.ts

@@ -0,0 +1,44 @@
+import { Logger } from '@streamr/utils'
+import { ICloseEvent, IMessageEvent, w3cwebsocket as Websocket } from 'websocket'
+import { AbstractWebsocketClientConnection } from './AbstractWebsocketClientConnection'
+
+const logger = new Logger(module)
+
+const BINARY_TYPE = 'arraybuffer'
+
+export class WebsocketClientConnection extends AbstractWebsocketClientConnection {
+
+    protected socket?: Websocket 
+
+    // TODO explicit default value for "selfSigned" or make it required
+    public connect(address: string, selfSigned?: boolean): void {
+        if (!this.destroyed) {
+            this.socket = new Websocket(address, undefined, undefined, undefined, { rejectUnauthorized: !selfSigned })
+            this.socket.binaryType = BINARY_TYPE
+            this.socket.onerror = (error: Error) => this.onError(error)
+            this.socket.onopen = () => this.onOpen()
+            this.socket.onclose = (event: ICloseEvent) => this.onClose(event.code, event.reason)
+            this.socket.onmessage = (message: IMessageEvent) => {
+                if (!this.destroyed) {
+                    if (typeof message.data === 'string') {
+                        logger.debug('Received string data, only binary data is supported')
+                    } else {
+                        this.onMessage(new Uint8Array(message.data))
+                    }
+                }
+            }
+        } else {
+            logger.debug('Tried to connect() a stopped connection')
+        }
+    }
+
+    protected stopListening(): void {
+        if (this.socket) {
+            this.socket.onopen = undefined as unknown as (() => void)
+            this.socket.onclose = undefined as unknown as (() => void)
+            this.socket.onerror = undefined as unknown as (() => void)
+            this.socket.onmessage = undefined as unknown as (() => void)
+        }
+    }
+
+}

package/src/connection/websocket/NodeWebsocketClientConnection.ts

@@ -0,0 +1,39 @@
+import { Logger, binaryToUtf8 } from '@streamr/utils'
+import { WebSocket } from 'ws'
+import { AbstractWebsocketClientConnection } from './AbstractWebsocketClientConnection'
+
+const logger = new Logger(module)
+
+const BINARY_TYPE = 'nodebuffer'
+
+export class WebsocketClientConnection extends AbstractWebsocketClientConnection {
+
+    protected socket?: WebSocket
+
+    // TODO explicit default value for "selfSigned" or make it required
+    public connect(address: string, selfSigned?: boolean): void {
+        if (!this.destroyed) {
+            this.socket = new WebSocket(address, { rejectUnauthorized: !selfSigned })
+            this.socket.binaryType = BINARY_TYPE
+            this.socket.on('error', (error: Error) => this.onError(error))
+            this.socket.on('open', () => this.onOpen())
+            this.socket.on('close', (code: number, reason: Buffer) => this.onClose(code, binaryToUtf8(reason)))
+            this.socket.on('message', (message: Buffer, isBinary: boolean) => {
+                if (!this.destroyed) {
+                    if (isBinary === false) {
+                        logger.debug('Received string data, only binary data is supported')
+                    } else {
+                        this.onMessage(new Uint8Array(message))
+                    }
+                }
+            })
+        } else {
+            logger.debug('Tried to connect() a stopped connection')
+        }
+    }
+
+    protected stopListening(): void {
+        this.socket?.removeAllListeners()
+    }
+
+}

package/src/connection/websocket/WebsocketConnector.ts

@@ -1,4 +1,4 @@
-import { ClientWebsocket } from './ClientWebsocket'
+import { WebsocketClientConnection } from './NodeWebsocketClientConnection'
 import { IConnection, ConnectionType } from '../IConnection'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
@@ -211,7 +211,7 @@ export class WebsocketConnector {
             } catch (err) {
                 const error = `Failed to connect to entrypoint with id ${getNodeIdFromPeerDescriptor(entryPoint)} `
                     + `and URL ${connectivityMethodToWebsocketUrl(entryPoint.websocket!)}`
-                logger.error(error, { error: err })
+                logger.error(error, { err })
                 shuffledEntrypoints.shift()
                 await wait(2000, this.abortController.signal)
             }
@@ -234,7 +234,7 @@ export class WebsocketConnector {
         if (this.localPeerDescriptor!.websocket && !targetPeerDescriptor.websocket) {
             return this.requestConnectionFromPeer(this.localPeerDescriptor!, targetPeerDescriptor)
         } else {
-            const socket = new ClientWebsocket()
+            const socket = new WebsocketClientConnection()
 
             const url = connectivityMethodToWebsocketUrl(targetPeerDescriptor.websocket!)
 

package/src/connection/websocket/WebsocketServerConnection.ts

@@ -3,7 +3,7 @@ import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../
 import WebSocket from 'ws'
 import { Logger } from '@streamr/utils'
 import { Url } from 'url'
-import { CUSTOM_GOING_AWAY, GOING_AWAY } from './ClientWebsocket'
+import { CUSTOM_GOING_AWAY, GOING_AWAY } from './AbstractWebsocketClientConnection'
 import { createRandomConnectionId } from '../Connection'
 
 const logger = new Logger(module)

package/src/dht/DhtNode.ts

@@ -8,7 +8,7 @@ import {
 import { EventEmitter } from 'eventemitter3'
 import { sample } from 'lodash'
 import { MarkRequired } from 'ts-essentials'
-import { ConnectionManager, PortRange, TlsCertificate } from '../connection/ConnectionManager'
+import { ConnectionLocker, ConnectionManager, PortRange, TlsCertificate } from '../connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../connection/ConnectorFacade'
 import { IceServer } from '../connection/webrtc/WebrtcConnector'
 import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
@@ -130,7 +130,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     private recursiveOperationManager?: RecursiveOperationManager
     private peerDiscovery?: PeerDiscovery
     private peerManager?: PeerManager
-    public connectionManager?: ConnectionManager
+    public connectionLocker?: ConnectionLocker
     private region?: number
     private started = false
     private abortController = new AbortController()
@@ -198,7 +198,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             this.transport = this.config.transport
             this.localPeerDescriptor = this.transport.getLocalPeerDescriptor()
             if (this.config.transport instanceof ConnectionManager) {
-                this.connectionManager = this.config.transport
+                this.connectionLocker = this.config.transport
             }
         } else {
             const connectorFacadeConfig: DefaultConnectorFacadeConfig = {
@@ -237,7 +237,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 metricsContext: this.config.metricsContext
             })
             await connectionManager.start()
-            this.connectionManager = connectionManager
+            this.connectionLocker = connectionManager
             this.transport = connectionManager
         }
 
@@ -258,14 +258,13 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             joinTimeout: this.config.dhtJoinTimeout,
             serviceId: this.config.serviceId,
             parallelism: this.config.joinParallelism,
-            connectionManager: this.connectionManager,
+            connectionLocker: this.connectionLocker,
             peerManager: this.peerManager!
         })
         this.router = new Router({
             rpcCommunicator: this.rpcCommunicator,
             connections: this.peerManager!.connections,
             localPeerDescriptor: this.localPeerDescriptor!,
-            addContact: (contact: PeerDescriptor, setActive?: boolean) => this.peerManager!.addContact([contact], setActive),
             handleMessage: (message: Message) => this.handleMessageFromRouter(message),
         })
         this.recursiveOperationManager = new RecursiveOperationManager({
@@ -275,7 +274,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             connections: this.peerManager!.connections,
             localPeerDescriptor: this.localPeerDescriptor!,
             serviceId: this.config.serviceId,
-            addContact: (contact: PeerDescriptor) => this.peerManager!.addContact([contact]),
+            addContact: (contact: PeerDescriptor) => this.peerManager!.addContact(contact),
             localDataStore: this.localDataStore
         })
         this.storeManager = new StoreManager({
@@ -311,9 +310,9 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             maxContactListSize: this.config.maxNeighborListSize,
             localNodeId: this.getNodeId(),
             localPeerDescriptor: this.localPeerDescriptor!,
-            connectionManager: this.connectionManager!,
+            connectionLocker: this.connectionLocker!,
             peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
-            isLayer0: (this.connectionManager !== undefined),
+            isLayer0: (this.connectionLocker !== undefined),
             createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => this.createDhtNodeRpcRemote(peerDescriptor),
             lockId: this.config.serviceId
         })
@@ -376,7 +375,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             getClosestRingPeersTo: (ringIdRaw: RingIdRaw, limit: number) => {
                 return this.getClosestRingContactsTo(ringIdRaw, limit)
             },
-            addContact: (contact: PeerDescriptor) => this.peerManager!.addContact([contact]),
+            addContact: (contact: PeerDescriptor) => this.peerManager!.addContact(contact),
             removeContact: (nodeId: DhtAddress) => this.removeContact(nodeId)
         })
         this.rpcCommunicator!.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers',
@@ -418,8 +417,6 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     private handleMessageFromRouter(message: Message): void {
         if (message.serviceId === this.config.serviceId) {
             this.rpcCommunicator?.handleMessageFromPeer(message)
-        } else if (this.connectionManager?.handleIncomingMessage(message)) {
-            // message was handled by connectionManager
         } else {
             this.emit('message', message)
         }
@@ -560,15 +557,15 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public getLocalLockedConnectionCount(): number {
-        return this.connectionManager!.getLocalLockedConnectionCount()
+        return this.connectionLocker!.getLocalLockedConnectionCount()
     }
 
     public getRemoteLockedConnectionCount(): number {
-        return this.connectionManager!.getRemoteLockedConnectionCount()
+        return this.connectionLocker!.getRemoteLockedConnectionCount()
     }
 
     public getWeakLockedConnectionCount(): number {
-        return this.connectionManager!.getWeakLockedConnectionCount()
+        return this.connectionLocker!.getWeakLockedConnectionCount()
     }
 
     public async waitForNetworkConnectivity(): Promise<void> {
@@ -604,7 +601,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             await this.transport!.stop()
         }
         this.transport = undefined
-        this.connectionManager = undefined
+        this.connectionLocker = undefined
         this.removeAllListeners()
     }
 

package/src/dht/DhtNodeRpcRemote.ts

@@ -85,7 +85,7 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
                 return true
             }
         } catch (err) {
-            logger.trace(`ping failed on ${this.serviceId} to ${this.getNodeId()}: ${err}`)
+            logger.trace(`ping failed on ${this.serviceId} to ${this.getNodeId()}`, { err })
         }
         return false
     }

package/src/dht/PeerManager.ts

@@ -8,12 +8,12 @@ import {
 import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
 import { RandomContactList } from './contact/RandomContactList'
 import { SortedContactList } from './contact/SortedContactList'
-import { ConnectionManager } from '../connection/ConnectionManager'
+import { ConnectionLocker } from '../connection/ConnectionManager'
 import EventEmitter from 'eventemitter3'
 import { DhtAddress, DhtAddressRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../identifiers'
 import { RingContactList, RingContacts } from './contact/RingContactList'
 import { RingIdRaw, getRingIdRawFromPeerDescriptor } from './contact/ringIdentifiers'
-import { LockID } from '../connection/ConnectionLockHandler'
+import { LockID } from '../connection/ConnectionLockStates'
 
 const logger = new Logger(module)
 
@@ -23,7 +23,7 @@ interface PeerManagerConfig {
     peerDiscoveryQueryBatchSize: number
     localNodeId: DhtAddress
     localPeerDescriptor: PeerDescriptor
-    connectionManager: ConnectionManager
+    connectionLocker?: ConnectionLocker
     isLayer0: boolean
     lockId: LockID
     createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
@@ -121,7 +121,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         sortingList.addContacts(oldContacts)
         const sortedContacts = sortingList.getAllContacts()
         const removableNodeId = sortedContacts[sortedContacts.length - 1].getNodeId()
-        this.config.connectionManager?.weakUnlockConnection(removableNodeId, this.config.lockId)
+        this.config.connectionLocker?.weakUnlockConnection(removableNodeId, this.config.lockId)
         this.bucket.remove(getRawFromDhtAddress(removableNodeId))
         this.bucket.add(newContact)
     }
@@ -130,7 +130,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        this.config.connectionManager?.weakUnlockConnection(nodeId, this.config.lockId)
+        this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
         logger.trace(`Removed contact ${nodeId}`)
         if (this.bucket.count() === 0) {
             this.emit('kBucketEmpty')
@@ -145,7 +145,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             const peerDescriptor = contact.getPeerDescriptor()
             const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
             // Important to lock here, before the ping result is known
-            this.config.connectionManager?.weakLockConnection(nodeId, this.config.lockId)
+            this.config.connectionLocker?.weakLockConnection(nodeId, this.config.lockId)
             if (this.connections.has(contact.getNodeId())) {
                 logger.trace(`Added new contact ${nodeId}`)
             } else {    // open connection by pinging
@@ -155,13 +155,13 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
                         logger.trace(`Added new contact ${nodeId}`)
                     } else {
                         logger.trace('ping failed ' + nodeId)
-                        this.config.connectionManager?.weakUnlockConnection(nodeId, this.config.lockId)
+                        this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
                         this.removeContact(nodeId)
                         this.addClosestContactToBucket()
                     }
                     return
                 }).catch((_e) => {
-                    this.config.connectionManager?.weakUnlockConnection(nodeId, this.config.lockId)
+                    this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
                     this.removeContact(nodeId)
                     this.addClosestContactToBucket()
                 })
@@ -175,7 +175,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         }
         const closest = this.getClosestActiveContactNotInBucket()
         if (closest) {
-            this.addContact([closest.getPeerDescriptor()])
+            this.addContact(closest.getPeerDescriptor())
         }
     }
 
@@ -249,10 +249,11 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             referenceId,
             allowToContainReferenceId: true,
             emitEvents: false,
-            excludedNodeIds
+            excludedNodeIds,
+            maxSize: limit
         })
         this.bucket.toArray().forEach((contact) => closest.addContact(contact))
-        return closest.getClosestContacts(limit)
+        return closest.getAllContacts()
     }
 
     // TODO reduce copy-paste?
@@ -261,11 +262,11 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             referenceId,
             allowToContainReferenceId: true,
             emitEvents: false,
-            excludedNodeIds
+            excludedNodeIds,
+            maxSize: limit
         })
         this.contacts.getAllContacts().map((contact) => closest.addContact(contact))
-        // TODO should set the excludeSet and limit to SortedContactList constructor and remove these line
-        return closest.getClosestContacts(limit)
+        return closest.getAllContacts()
     }
 
     getClosestRingContactsTo(
@@ -280,13 +281,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     }
 
     getContactCount(excludedNodeIds?: Set<DhtAddress>): number {
-        return this.contacts.getAllContacts().filter((contact) => {
-            if (!excludedNodeIds) {
-                return true
-            } else {
-                return !excludedNodeIds.has(contact.getNodeId())
-            }
-        }).length
+        return this.contacts.getSize(excludedNodeIds)
     }
 
     getConnectionCount(): number {
@@ -305,35 +300,30 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         this.contacts.setActive(nodeId)
     }
 
-    addContact(peerDescriptors: PeerDescriptor[], setActive?: boolean): void {
+    addContact(peerDescriptor: PeerDescriptor): void {
         if (this.stopped) {
             return
         }
-        peerDescriptors.forEach((contact) => {
-            const nodeId = getNodeIdFromPeerDescriptor(contact)
-            if (nodeId !== this.config.localNodeId) {
-                logger.trace(`Adding new contact ${nodeId}`)
-                const remote = this.config.createDhtNodeRpcRemote(contact)
-                const isInBucket = (this.bucket.get(contact.nodeId) !== null)
-                const isInContacts = (this.contacts.getContact(nodeId) !== undefined)
-                const isInRingContacts = this.ringContacts.getContact(contact) !== undefined
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        if (nodeId !== this.config.localNodeId) {
+            logger.trace(`Adding new contact ${nodeId}`)
+            const remote = this.config.createDhtNodeRpcRemote(peerDescriptor)
+            const isInBucket = (this.bucket.get(peerDescriptor.nodeId) !== null)
+            const isInContacts = (this.contacts.getContact(nodeId) !== undefined)
+            const isInRingContacts = this.ringContacts.getContact(peerDescriptor) !== undefined
 
-                if (isInBucket || isInContacts) {
-                    this.randomPeers.addContact(remote)
-                }
-                if (!isInBucket) {
-                    this.bucket.add(remote)
-                }
-                if (!isInContacts) {
-                    this.contacts.addContact(remote)
-                }
-                if (setActive) {
-                    this.contacts.setActive(nodeId)
-                }
-                if (!isInRingContacts) {
-                    this.ringContacts.addContact(remote)
-                }
+            if (isInBucket || isInContacts) {
+                this.randomPeers.addContact(remote)
             }
-        })
+            if (!isInBucket) {
+                this.bucket.add(remote)
+            }
+            if (!isInContacts) {
+                this.contacts.addContact(remote)
+            }
+            if (!isInRingContacts) {
+                this.ringContacts.addContact(remote)
+            }
+        }
     }
 }

package/src/dht/contact/SortedContactList.ts

@@ -92,6 +92,10 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         return this.contactsById.get(id)
     }
 
+    has(id: DhtAddress): boolean {
+        return this.contactsById.has(id)
+    }
+
     public setContacted(contactId: DhtAddress): void {
         if (this.contactsById.has(contactId)) {
             this.contactsById.get(contactId)!.contacted = true
@@ -105,25 +109,17 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
     }
 
     public getClosestContacts(limit?: number): C[] {
-        const ret: C[] = []
-        this.contactIds.forEach((contactId) => {
-            const contact = this.contactsById.get(contactId)
-            if (contact) {
-                ret.push(contact.contact)
-            }
-        })
-        if (limit === undefined) {
-            return ret
-        } else {
-            return ret.slice(0, limit)
-        }
+        const ret = this.getAllContacts()
+        return (limit === undefined) 
+            ? ret 
+            : ret.slice(0, limit)
     }
 
     public getUncontactedContacts(num: number): C[] {
         const ret: C[] = []
         for (const contactId of this.contactIds) {
-            const contact = this.contactsById.get(contactId)
-            if (contact && !contact.contacted) {
+            const contact = this.contactsById.get(contactId)!
+            if (!contact.contacted) {
                 ret.push(contact.contact)
                 if (ret.length >= num) {
                     return ret
@@ -136,8 +132,8 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
     public getActiveContacts(limit?: number): C[] {
         const ret: C[] = []
         this.contactIds.forEach((contactId) => {
-            const contact = this.contactsById.get(contactId)
-            if (contact && contact.active) {
+            const contact = this.contactsById.get(contactId)!
+            if (contact.active) {
                 ret.push(contact.contact)
             }
         })
@@ -187,8 +183,16 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         return this.contactIds.map((nodeId) => this.contactsById.get(nodeId)!.contact)
     }
 
-    public getSize(): number {
-        return this.contactIds.length
+    public getSize(excludedNodeIds?: Set<DhtAddress>): number {
+        let excludedCount = 0
+        if (excludedNodeIds !== undefined) {
+            for (const nodeId of excludedNodeIds) {
+                if (this.has(nodeId)) {
+                    excludedCount++
+                }
+            }
+        }
+        return this.contactIds.length - excludedCount
     }
 
     public clear(): void {