@streamr/dht 100.1.2 → 100.2.1

package/src/dht/contact/SortedContactList.ts

@@ -1,4 +1,4 @@
-import { ContactState, Events } from './ContactList'
+import { Events } from './ContactList'
 import { sortedIndexBy } from 'lodash'
 import EventEmitter from 'eventemitter3'
 import { getDistance } from '../PeerManager'
@@ -7,9 +7,6 @@ import { DhtAddress, getRawFromDhtAddress } from '../../identifiers'
 export interface SortedContactListConfig {
     referenceId: DhtAddress  // all contacts in this list are in sorted by the distance to this ID
     allowToContainReferenceId: boolean
-    // TODO could maybe optimize this by removing the flag and then we'd check whether we have 
-    // any listeners before we emit the event
-    emitEvents: boolean
     maxSize?: number
     // if set, the list can't contain any contacts which are futher away than this limit
     nodeIdDistanceLimit?: DhtAddress
@@ -20,7 +17,7 @@ export interface SortedContactListConfig {
 export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {
 
     private config: SortedContactListConfig
-    private contactsById: Map<DhtAddress, ContactState<C>> = new Map()
+    private contactsById: Map<DhtAddress, C> = new Map()
     private contactIds: DhtAddress[] = []
 
     constructor(
@@ -50,10 +47,10 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         }
         if (!this.contactsById.has(contactId)) {
             if ((this.config.maxSize === undefined) || (this.contactIds.length < this.config.maxSize)) {
-                this.contactsById.set(contactId, new ContactState(contact))
+                this.contactsById.set(contactId, contact)
                 const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
                 this.contactIds.splice(index, 0, contactId)
-                if (this.config.emitEvents) {
+                if (this.hasEventListeners()) {
                     this.emit(
                         'contactAdded',
                         contact,
@@ -62,12 +59,12 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
                 }
             } else if (this.compareIds(this.contactIds[this.config.maxSize - 1], contactId) > 0) {
                 const removedId = this.contactIds.pop()
-                const removedContact = this.contactsById.get(removedId!)!.contact
+                const removedContact = this.contactsById.get(removedId!)!
                 this.contactsById.delete(removedId!)
-                this.contactsById.set(contactId, new ContactState(contact))
+                this.contactsById.set(contactId, contact)
                 const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
                 this.contactIds.splice(index, 0, contactId)
-                if (this.config.emitEvents) {
+                if (this.hasEventListeners()) {
                     const closestContacts = this.getClosestContacts()
                     this.emit(
                         'contactRemoved',
@@ -88,7 +85,7 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         contacts.forEach((contact) => this.addContact(contact))
     }
 
-    public getContact(id: DhtAddress): ContactState<C> | undefined {
+    public getContact(id: DhtAddress): C | undefined {
         return this.contactsById.get(id)
     }
 
@@ -96,32 +93,22 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         return this.contactsById.has(id)
     }
 
-    public setActive(contactId: DhtAddress): void {
-        if (this.contactsById.has(contactId)) {
-            this.contactsById.get(contactId)!.active = true
-        }
+    /*
+     * Closest first then others in ascending distance order
+     */
+    public getClosestContacts(limit?: number): C[] {
+        const limitedContactIds = (limit === undefined) ? this.contactIds : this.contactIds.slice(0, Math.max(limit, 0)) 
+        return limitedContactIds.map((nodeId) => this.contactsById.get(nodeId)!)
     }
 
-    public getClosestContacts(limit?: number): C[] {
-        const ret = this.getAllContacts()
+    /*
+     * Furthest first then others in descending distance order
+     */
+    getFurthestContacts(limit?: number): C[] {
+        const ret = [...this.getClosestContacts()].reverse()
         return (limit === undefined) 
             ? ret 
-            : ret.slice(0, limit)
-    }
-
-    public getActiveContacts(limit?: number): C[] {
-        const ret: C[] = []
-        this.contactIds.forEach((contactId) => {
-            const contact = this.contactsById.get(contactId)!
-            if (contact.active) {
-                ret.push(contact.contact)
-            }
-        })
-        if (limit !== undefined) {
-            return ret.slice(0, limit)
-        } else {
-            return ret
-        }
+            : ret.slice(0, Math.max(limit, 0))
     }
 
     public compareIds(id1: DhtAddress, id2: DhtAddress): number {
@@ -138,12 +125,12 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
 
     public removeContact(id: DhtAddress): boolean {
         if (this.contactsById.has(id)) {
-            const removed = this.contactsById.get(id)!.contact
+            const removed = this.contactsById.get(id)!
             // TODO use sortedIndexBy?
             const index = this.contactIds.findIndex((nodeId) => (nodeId === id))
             this.contactIds.splice(index, 1)
             this.contactsById.delete(id)
-            if (this.config.emitEvents) {
+            if (this.hasEventListeners()) {
                 this.emit(
                     'contactRemoved',
                     removed,
@@ -155,12 +142,8 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         return false
     }
 
-    public isActive(id: DhtAddress): boolean {
-        return this.contactsById.has(id) ? this.contactsById.get(id)!.active : false
-    }
-
-    public getAllContacts(): C[] {
-        return this.contactIds.map((nodeId) => this.contactsById.get(nodeId)!.contact)
+    public getAllContactsInUndefinedOrder(): IterableIterator<C> {
+        return this.contactsById.values()
     }
 
     public getSize(excludedNodeIds?: Set<DhtAddress>): number {
@@ -184,4 +167,8 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
         this.removeAllListeners()
         this.clear()
     }
+
+    private hasEventListeners(): boolean {
+        return this.eventNames().length > 0
+    }
 }

package/src/dht/discovery/PeerDiscovery.ts

@@ -60,7 +60,7 @@ export class PeerDiscovery {
         )))
     }
 
-    async joinThroughEntryPoint(
+    private async joinThroughEntryPoint(
         entryPointDescriptor: PeerDescriptor,
         // Note that this set is mutated by DiscoverySession
         contactedPeers: Set<DhtAddress>,
@@ -155,14 +155,18 @@ export class PeerDiscovery {
         }
     }
 
-    public async rejoinDht(entryPoint: PeerDescriptor): Promise<void> {
+    public async rejoinDht(
+        entryPoint: PeerDescriptor,
+        contactedPeers: Set<DhtAddress> = new Set(),
+        distantJoinContactPeers: Set<DhtAddress> = new Set()
+    ): Promise<void> {
         if (this.isStopped() || this.rejoinOngoing) {
             return
         }
         logger.debug(`Rejoining DHT ${this.config.serviceId}`)
         this.rejoinOngoing = true
         try {
-            await this.joinThroughEntryPoint(entryPoint, new Set(), { enabled: false })
+            await this.joinThroughEntryPoint(entryPoint, contactedPeers, { enabled: true, contactedPeers: distantJoinContactPeers })
             logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
         } catch (err) {
             logger.warn(`Rejoining DHT ${this.config.serviceId} failed`)

package/src/dht/recursive-operation/RecursiveOperationManager.ts

@@ -222,8 +222,7 @@ export class RecursiveOperationManager {
         const closestPeers = new SortedContactList<DhtNodeRpcRemote>({
             referenceId,
             maxSize: limit,
-            allowToContainReferenceId: true,
-            emitEvents: false
+            allowToContainReferenceId: true
         })
         closestPeers.addContacts(connectedPeers)
         return closestPeers.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())

package/src/dht/recursive-operation/RecursiveOperationSession.ts

@@ -53,8 +53,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
         this.results = new SortedContactList({
             referenceId: config.targetId, 
             maxSize: 10,  // TODO use config option or named constant?
-            allowToContainReferenceId: true,
-            emitEvents: false
+            allowToContainReferenceId: true
         })
         this.rpcCommunicator = new ListeningRpcCommunicator(this.id, config.transport, {
             rpcRequestTimeout: 15000  // TODO use config option or named constant?
@@ -212,7 +211,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
 
     public getResults(): RecursiveOperationResult {
         return {
-            closestNodes: this.results.getAllContacts().map((contact) => contact.getPeerDescriptor()),
+            closestNodes: this.results.getClosestContacts().map((contact) => contact.getPeerDescriptor()),
             dataEntries: Array.from(this.foundData.values())
         }
     }

package/src/dht/routing/RoutingSession.ts

@@ -172,8 +172,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
                 referenceId: getDhtAddressFromRaw(this.config.routedMessage.target),
                 maxSize: ROUTING_TABLE_MAX_SIZE,
                 allowToContainReferenceId: true,
-                nodeIdDistanceLimit: previousId,
-                emitEvents: false
+                nodeIdDistanceLimit: previousId
             })
             const contacts = Array.from(this.config.connections.values())
                 .map((peer) => new RoutingRemoteContact(
@@ -184,7 +183,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             routingTable.addContacts(contacts)
             this.config.routingTablesCache.set(targetId, routingTable, previousId)
         }
-        return routingTable.getAllContacts()
+        return routingTable.getClosestContacts()
             .filter((contact) => !this.contactedPeers.has(contact.getNodeId()) && !this.config.excludedNodeIds.has(contact.getNodeId()))
     }
 

package/src/dht/routing/RoutingTablesCache.ts

@@ -4,7 +4,9 @@ import { RoutingRemoteContact } from './RoutingSession'
 import { LRUCache } from 'lru-cache'
 
 type RoutingTableID = string
-export type RoutingTable = Pick<SortedContactList<RoutingRemoteContact>, 'getAllContacts' | 'addContacts' | 'addContact' | 'removeContact' | 'stop'>
+export type RoutingTable = Pick<
+    SortedContactList<RoutingRemoteContact>,
+    'getClosestContacts' | 'addContacts' | 'addContact' | 'removeContact' | 'stop'>
 
 const createRoutingTableId = (targetId: DhtAddress, previousId?: DhtAddress): RoutingTableID => {
     return targetId + (previousId ? previousId : '')

package/src/dht/store/StoreManager.ts

@@ -64,8 +64,7 @@ export class StoreManager {
         const sortedList = new SortedContactList<Contact>({
             referenceId: key, 
             maxSize: this.config.redundancyFactor,
-            allowToContainReferenceId: true,
-            emitEvents: false
+            allowToContainReferenceId: true
         })
         sortedList.addContact(new Contact(this.config.localPeerDescriptor))
         closestToData.forEach((neighbor) => {
@@ -173,20 +172,20 @@ export class StoreManager {
         const closestToData = this.config.getClosestNeighborsTo(key, 10)
         const sortedList = new SortedContactList<Contact>({
             referenceId: key, 
-            maxSize: this.config.redundancyFactor, 
-            allowToContainReferenceId: true, 
-            emitEvents: false
+            maxSize: this.config.redundancyFactor,
+            allowToContainReferenceId: true
         })
         sortedList.addContact(new Contact(this.config.localPeerDescriptor))
         closestToData.forEach((neighbor) => {
             sortedList.addContact(new Contact(neighbor))
         })
         const selfIsPrimaryStorer = (sortedList.getClosestContactId() === localNodeId)
-        const targets = selfIsPrimaryStorer
+        const targetLimit = selfIsPrimaryStorer
             // if we are the closest to the data, replicate to all storageRedundancyFactor nearest
-            ? sortedList.getAllContacts()
+            ? undefined
             // if we are not the closest node to the data, replicate only to the closest one to the data
-            : [sortedList.getAllContacts()[0]]
+            : 1
+        const targets = sortedList.getClosestContacts(targetLimit)
         targets.forEach((contact) => {
             const contactNodeId = contact.getNodeId()
             if ((incomingNodeId !== contactNodeId) && (localNodeId !== contactNodeId)) {

package/test/benchmark/SortedContactListBenchmark.test.ts

@@ -39,27 +39,14 @@ describe('SortedContactListBenchmark', () => {
         }
         const list = new SortedContactList({
             referenceId: createRandomDhtAddress(),
-            allowToContainReferenceId: true,
-            emitEvents: true
+            allowToContainReferenceId: true
         })
 
-        console.time('SortedContactList.addContact() with emitEvents=true')
+        console.time('SortedContactList.addContact()')
         for (let i = 0; i < NUM_ADDS; i++) {
             list.addContact(randomIds[i])
         }
-        console.timeEnd('SortedContactList.addContact() with emitEvents=true')
-
-        const list2 = new SortedContactList({
-            referenceId: createRandomDhtAddress(),
-            allowToContainReferenceId: true,
-            emitEvents: false
-        })
-
-        console.time('SortedContactList.addContact() with emitEvents=false')
-        for (let i = 0; i < NUM_ADDS; i++) {
-            list2.addContact(randomIds[i])
-        }
-        console.timeEnd('SortedContactList.addContact() with emitEvents=false')
+        console.timeEnd('SortedContactList.addContact()')
 
         const kBucket = new KBucket<Item>({ localNodeId: getRawFromDhtAddress(createRandomDhtAddress()) })
         console.time('KBucket.add()')
@@ -81,61 +68,31 @@ describe('SortedContactListBenchmark', () => {
         }
         console.timeEnd('kBucket closest()')
 
-        console.time('SortedContactList.getClosestContacts() with emitEvents=true')
-        for (let i = 0; i < NUM_ADDS; i++) {
-            const closest = new SortedContactList<Item>({
-                referenceId: createRandomDhtAddress(),
-                allowToContainReferenceId: true,
-                emitEvents: true
-            })
-
-            const arrayFromBucket = kBucket.toArray()
-            arrayFromBucket.forEach((contact) => closest.addContact(contact))
-            closest.getClosestContacts(20)
-        }
-        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=true')
-
-        console.time('SortedContactList.getClosestContacts() with emitEvents=false')
-        for (let i = 0; i < NUM_ADDS; i++) {
-            const closest = new SortedContactList<Item>({
-                referenceId: createRandomDhtAddress(),
-                allowToContainReferenceId: true,
-                emitEvents: false
-            })
-
-            const arrayFromBucket = kBucket.toArray()
-            arrayFromBucket.forEach((contact) => closest.addContact(contact))
-            closest.getClosestContacts(20)
-        }
-        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false')
-
-        console.time('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
+        console.time('SortedContactList.getClosestContacts()')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
                 referenceId: createRandomDhtAddress(),
-                allowToContainReferenceId: true,
-                emitEvents: false
+                allowToContainReferenceId: true
             })
 
             const arrayFromBucket = kBucket.toArray()
             arrayFromBucket.forEach((contact) => closest.addContact(contact))
             closest.getClosestContacts(20)
         }
-        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
+        console.timeEnd('SortedContactList.getClosestContacts()')
 
-        console.time('SortedContactList.getClosestContacts() with emitEvents=false and addContacts()')
+        console.time('SortedContactList.getClosestContacts() and addContacts()')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
                 referenceId: createRandomDhtAddress(),
-                allowToContainReferenceId: true,
-                emitEvents: false
+                allowToContainReferenceId: true
             })
 
             const arrayFromBucket = kBucket.toArray()
             closest.addContacts(arrayFromBucket)
             closest.getClosestContacts(20)
         }
-        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false and addContacts()')
+        console.timeEnd('SortedContactList.getClosestContacts() and addContacts()')
 
         const shuffled = shuffleArray(kBucket.toArray())
         console.time('kbucket add and closest')

package/test/benchmark/hybrid-network-simulation/RingContactList.test.ts

@@ -61,8 +61,7 @@ const mockData: Array< [number, string] > = [
 const mockNodes: MockNode[] = mockData.map(([region, ipAddress]) => new MockNode(region, ipAddress))
 const referenceNode = mockNodes[5]
 const ringContactList: RingContactList<MockNode> = new RingContactList<MockNode>(
-    getRingIdRawFromPeerDescriptor(referenceNode.getPeerDescriptor()),
-    false
+    getRingIdRawFromPeerDescriptor(referenceNode.getPeerDescriptor())
 )
 
 mockNodes.forEach((node) => ringContactList.addContact(node))

package/test/integration/ReplicateData.test.ts

@@ -56,12 +56,11 @@ describe('Replicate data from node to node in DHT', () => {
         const sortedList = new SortedContactList<DhtNode>({ 
             referenceId: getDhtAddressFromRaw(DATA.key),
             maxSize: 10000, 
-            allowToContainReferenceId: true, 
-            emitEvents: false 
+            allowToContainReferenceId: true
         })
         nodes.forEach((node) => sortedList.addContact(node))
 
-        const closest = sortedList.getAllContacts()
+        const closest = sortedList.getClosestContacts()
         const successfulStorers = await nodes[0].storeDataToDht(getDhtAddressFromRaw(DATA.key), DATA.data!)
         expect(successfulStorers.length).toBe(1)
 

package/test/unit/PeerManager.test.ts

@@ -1,18 +1,31 @@
+import { waitForCondition } from '@streamr/utils'
+import { range, sample, sampleSize, sortBy, without } from 'lodash'
+import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { PeerManager, getDistance } from '../../src/dht/PeerManager'
+import { Contact } from '../../src/dht/contact/Contact'
+import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { range, sample, sampleSize, sortBy, without } from 'lodash'
-import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 import { createMockPeerDescriptor } from '../utils/utils'
 
-const createPeerManager = (nodeIds: DhtAddress[]) => {
-    const peerDescriptor = createMockPeerDescriptor()
+const createPeerManager = (
+    nodeIds: DhtAddress[], 
+    localPeerDescriptor = createMockPeerDescriptor(),
+    pingFailures: Set<DhtAddress> = new Set()
+) => {
     const manager = new PeerManager({
-        localNodeId: getNodeIdFromPeerDescriptor(peerDescriptor),
-        localPeerDescriptor: peerDescriptor,
+        localNodeId: getNodeIdFromPeerDescriptor(localPeerDescriptor),
+        localPeerDescriptor: localPeerDescriptor,
+        isLayer0: true,
         createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => {
-            return new DhtNodeRpcRemote(undefined as any, peerDescriptor, undefined as any, new MockRpcCommunicator())
+            const remote = new class extends DhtNodeRpcRemote {
+                // eslint-disable-next-line class-methods-use-this
+                async ping(): Promise<boolean> {
+                    return !pingFailures.has(getNodeIdFromPeerDescriptor(peerDescriptor))
+                }
+            }(localPeerDescriptor, peerDescriptor, undefined as any, new MockRpcCommunicator())
+            return remote
         }
     } as any)
     const contacts = nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS }))
@@ -22,6 +35,22 @@ const createPeerManager = (nodeIds: DhtAddress[]) => {
     return manager
 }
 
+const getClosestContact = (contacts: PeerDescriptor[], referenceId: DhtAddress): PeerDescriptor | undefined => {
+    const list = new SortedContactList({
+        referenceId,
+        allowToContainReferenceId: false
+    })
+    for (const contact of contacts) {
+        list.addContact(new Contact(contact))
+    }
+    const id = list.getClosestContactId()
+    if (id !== undefined) {
+        return contacts.find((c) => getNodeIdFromPeerDescriptor(c) === id)
+    } else {
+        return undefined
+    }
+}
+
 describe('PeerManager', () => {
 
     it('getClosestContactsTo', () => {
@@ -61,4 +90,24 @@ describe('PeerManager', () => {
         expect(manager.getContactCount(new Set(sampleSize(nodeIds, 2)))).toBe(8)
         expect(manager.getContactCount(new Set([sample(nodeIds)!, createRandomDhtAddress()]))).toBe(9)
     })
+
+    it('addContact: ping fails', async () => {
+        const localPeerDescriptor = createMockPeerDescriptor()
+        const successContacts = range(5).map(() => createMockPeerDescriptor())
+        const failureContact = createMockPeerDescriptor()
+        const manager = createPeerManager([], localPeerDescriptor, new Set([getNodeIdFromPeerDescriptor(failureContact)]))
+        for (const successContact of successContacts) {
+            manager.addContact(successContact)
+            manager.setContactActive(getNodeIdFromPeerDescriptor(successContact))
+            manager.onContactDisconnected(getNodeIdFromPeerDescriptor(successContact), false)
+        }
+        expect(manager.getNeighborCount()).toBe(0)
+        manager.addContact(failureContact)
+        const closesSuccessContact = getClosestContact(successContacts, getNodeIdFromPeerDescriptor(localPeerDescriptor))!
+        await waitForCondition(() => {
+            const neighborNodeIds = manager.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+            return neighborNodeIds.includes(getNodeIdFromPeerDescriptor(closesSuccessContact))
+        })
+        expect(manager.getNeighbors()).toEqual([closesSuccessContact])
+    })
 })

package/test/unit/SortedContactList.test.ts

@@ -16,7 +16,7 @@ describe('SortedContactList', () => {
     const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
 
     it('compares Ids correctly', async () => {
-        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 10, allowToContainReferenceId: true, emitEvents: false })
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 10, allowToContainReferenceId: true })
         expect(list.compareIds(item0.getNodeId(), item0.getNodeId())).toBe(0)
         expect(list.compareIds(item1.getNodeId(), item1.getNodeId())).toBe(0)
         expect(list.compareIds(item0.getNodeId(), item1.getNodeId())).toBe(-1)
@@ -28,7 +28,7 @@ describe('SortedContactList', () => {
     })
 
     it('cannot exceed maxSize', async () => {
-        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 3, allowToContainReferenceId: false, emitEvents: true })
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 3, allowToContainReferenceId: false })
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
         list.addContact(item1)
@@ -36,14 +36,14 @@ describe('SortedContactList', () => {
         list.addContact(item3)
         list.addContact(item2)
         expect(list.getSize()).toEqual(3)
-        expect(list.getAllContacts()).toEqual([item1, item2, item3])
+        expect(list.getClosestContacts()).toEqual([item1, item2, item3])
         expect(list.getContactIds()).toEqual([item1.getNodeId(), item2.getNodeId(), item3.getNodeId()])
         expect(onContactRemoved).toBeCalledWith(item4, [item1, item2, item3])
         expect(list.getContact(item4.getNodeId())).toBeFalsy()
     })
 
     it('removing contacts', async () => {
-        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: true })
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 8, allowToContainReferenceId: false })
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
         list.removeContact(createRandomDhtAddress())
@@ -57,12 +57,12 @@ describe('SortedContactList', () => {
         expect(list.getSize()).toEqual(3)
         expect(list.getContact(item2.getNodeId())).toBeFalsy()
         expect(list.getContactIds()).toEqual(list.getContactIds().sort(list.compareIds))
-        expect(list.getAllContacts()).toEqual([item1, item3, item4])
+        expect(list.getClosestContacts()).toEqual([item1, item3, item4])
         const ret = list.removeContact(getDhtAddressFromRaw(Buffer.from([0, 0, 0, 6])))
         expect(ret).toEqual(false)
         list.removeContact(item3.getNodeId())
         list.removeContact(createRandomDhtAddress())
-        expect(list.getAllContacts()).toEqual([item1, item4])
+        expect(list.getClosestContacts()).toEqual([item1, item4])
         expect(onContactRemoved).toHaveBeenNthCalledWith(1, item3, [])
         expect(onContactRemoved).toHaveBeenNthCalledWith(2, item2, [item1, item3, item4])
         expect(onContactRemoved).toHaveBeenNthCalledWith(3, item3, [item1, item4])
@@ -72,31 +72,36 @@ describe('SortedContactList', () => {
         const list = new SortedContactList({
             referenceId: item0.getNodeId(), 
             maxSize: 8, 
-            allowToContainReferenceId: false, 
-            emitEvents: false 
+            allowToContainReferenceId: false
         })
         list.addContact(item1)
         list.addContact(item3)
         list.addContact(item4)
         list.addContact(item2)
         expect(list.getClosestContacts(2)).toEqual([item1, item2])
+        expect(list.getClosestContacts(10)).toEqual([item1, item2, item3, item4])
         expect(list.getClosestContacts()).toEqual([item1, item2, item3, item4])
+        expect(list.getClosestContacts(-2)).toEqual([])
     })
 
-    it('get active contacts', () => {
-        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: false })
+    it('get furthest contacts', () => {
+        const list = new SortedContactList({
+            referenceId: item0.getNodeId(), 
+            maxSize: 8, 
+            allowToContainReferenceId: false
+        })
         list.addContact(item1)
         list.addContact(item3)
         list.addContact(item4)
         list.addContact(item2)
-        list.setActive(item2.getNodeId())
-        list.setActive(item3.getNodeId())
-        list.setActive(item4.getNodeId())
-        expect(list.getActiveContacts()).toEqual([item2, item3, item4])
+        expect(list.getFurthestContacts(2)).toEqual([item4, item3])
+        expect(list.getFurthestContacts(10)).toEqual([item4, item3, item2, item1])
+        expect(list.getFurthestContacts()).toEqual([item4, item3, item2, item1])
+        expect(list.getFurthestContacts(-2)).toEqual([])
     })
 
     it('does not emit contactAdded if contact did not fit the structure', () => {
-        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 2, allowToContainReferenceId: false, emitEvents: true })
+        const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 2, allowToContainReferenceId: false })
         const onContactAdded = jest.fn()
         list.on('contactAdded', onContactAdded)
         list.addContact(item1)
@@ -104,7 +109,7 @@ describe('SortedContactList', () => {
         expect(onContactAdded).toBeCalledTimes(2)
         list.addContact(item3)
         expect(onContactAdded).toBeCalledTimes(2)
-        expect(list.getAllContacts().length).toEqual(2)
+        expect(list.getClosestContacts().length).toEqual(2)
     })
 
 })

package/test/utils/utils.ts

@@ -56,6 +56,7 @@ export const createMockRingNode = async (
     const opts = {
         peerDescriptor: peerDescriptor,
         transport: mockConnectionManager,
+        connectionLocker: mockConnectionManager,
         numberOfNodesPerKBucket: 8,
         maxConnections: maxConnections,
         dhtJoinTimeout,
@@ -88,6 +89,7 @@ export const createMockConnectionDhtNode = async (
     const opts = {
         peerDescriptor: peerDescriptor,
         transport: mockConnectionManager,
+        connectionLocker: mockConnectionManager,
         numberOfNodesPerKBucket,
         maxConnections: maxConnections,
         dhtJoinTimeout,