@streamr/dht 100.2.2 → 100.2.4-beta.0

package/src/dht/routing/RoutingSession.ts

@@ -1,4 +1,3 @@
-import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { SortedContactList } from '../contact/SortedContactList'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
@@ -69,11 +68,11 @@ interface RoutingSessionConfig {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
     routedMessage: RouteMessageWrapper
-    connections: Map<DhtAddress, DhtNodeRpcRemote>
     parallelism: number
     mode: RoutingMode
     excludedNodeIds: Set<DhtAddress>
     routingTablesCache: RoutingTablesCache
+    getConnections: () => PeerDescriptor[]
 }
 
 export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
@@ -174,9 +173,9 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
                 allowToContainReferenceId: true,
                 nodeIdDistanceLimit: previousId
             })
-            const contacts = Array.from(this.config.connections.values())
+            const contacts = this.config.getConnections()
                 .map((peer) => new RoutingRemoteContact(
-                    peer.getPeerDescriptor(),
+                    peer,
                     this.config.localPeerDescriptor,
                     this.config.rpcCommunicator
                 ))

package/src/dht/store/StoreRpcLocal.ts

@@ -32,7 +32,7 @@ export class StoreRpcLocal implements IStoreRpc {
     async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
         logger.trace('storeData()')
         const key = getDhtAddressFromRaw(request.key)
-        const selfIsOneOfClosestPeers = this.config.selfIsWithinRedundancyFactor(key)
+        const selfIsWithinRedundancyFactor = this.config.selfIsWithinRedundancyFactor(key)
         this.config.localDataStore.storeEntry({ 
             key: request.key,
             data: request.data,
@@ -40,10 +40,10 @@ export class StoreRpcLocal implements IStoreRpc {
             createdAt: request.createdAt,
             storedAt: Timestamp.now(),
             ttl: request.ttl,
-            stale: !selfIsOneOfClosestPeers,
+            stale: !selfIsWithinRedundancyFactor,
             deleted: false
         })
-        if (!selfIsOneOfClosestPeers) {
+        if (!selfIsWithinRedundancyFactor) {
             this.config.localDataStore.setAllEntriesAsStale(key)
         }
         return {}

package/src/proto/packages/dht/protos/DhtRpc.client.ts

@@ -47,10 +47,14 @@ import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
  */
 export interface IDhtNodeRpcClient {
     /**
+     * TODO rename to getClosestNeighbors (breaking change)
+     *
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(input: ClosestPeersRequest, options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse>;
     /**
+     * TODO rename to getClosestRingContacts (breaking change)
+     *
      * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
      */
     getClosestRingPeers(input: ClosestRingPeersRequest, options?: RpcOptions): UnaryCall<ClosestRingPeersRequest, ClosestRingPeersResponse>;
@@ -73,6 +77,8 @@ export class DhtNodeRpcClient implements IDhtNodeRpcClient, ServiceInfo {
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
+     * TODO rename to getClosestNeighbors (breaking change)
+     *
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(input: ClosestPeersRequest, options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse> {
@@ -80,6 +86,8 @@ export class DhtNodeRpcClient implements IDhtNodeRpcClient, ServiceInfo {
         return stackIntercept<ClosestPeersRequest, ClosestPeersResponse>("unary", this._transport, method, opt, input);
     }
     /**
+     * TODO rename to getClosestRingContacts (breaking change)
+     *
      * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
      */
     getClosestRingPeers(input: ClosestRingPeersRequest, options?: RpcOptions): UnaryCall<ClosestRingPeersRequest, ClosestRingPeersResponse> {

package/src/proto/packages/dht/protos/DhtRpc.server.ts

@@ -34,10 +34,14 @@ import { ServerCallContext } from "@protobuf-ts/runtime-rpc";
  */
 export interface IDhtNodeRpc<T = ServerCallContext> {
     /**
+     * TODO rename to getClosestNeighbors (breaking change)
+     *
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(request: ClosestPeersRequest, context: T): Promise<ClosestPeersResponse>;
     /**
+     * TODO rename to getClosestRingContacts (breaking change)
+     *
      * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
      */
     getClosestRingPeers(request: ClosestRingPeersRequest, context: T): Promise<ClosestRingPeersResponse>;

package/src/proto/packages/dht/protos/DhtRpc.ts

@@ -108,6 +108,8 @@ export interface DataEntry {
     deleted: boolean;
 }
 /**
+ * TODO rename to ClosestNeighborsRequest
+ *
  * @generated from protobuf message dht.ClosestPeersRequest
  */
 export interface ClosestPeersRequest {
@@ -121,6 +123,8 @@ export interface ClosestPeersRequest {
     requestId: string;
 }
 /**
+ * TODO rename to ClosestPeersResponse
+ *
  * @generated from protobuf message dht.ClosestPeersResponse
  */
 export interface ClosestPeersResponse {
@@ -134,6 +138,8 @@ export interface ClosestPeersResponse {
     requestId: string;
 }
 /**
+ * TODO rename to ClosestRingContactsRequest
+ *
  * @generated from protobuf message dht.ClosestRingPeersRequest
  */
 export interface ClosestRingPeersRequest {
@@ -147,6 +153,8 @@ export interface ClosestRingPeersRequest {
     requestId: string;
 }
 /**
+ * TODO rename to ClosestRingContactsResponse
+ *
  * @generated from protobuf message dht.ClosestRingPeersResponse
  */
 export interface ClosestRingPeersResponse {
@@ -181,9 +189,9 @@ export interface RecursiveOperationRequest {
  */
 export interface RecursiveOperationResponse {
     /**
-     * @generated from protobuf field: repeated dht.PeerDescriptor closestConnectedPeers = 1;
+     * @generated from protobuf field: repeated dht.PeerDescriptor closestConnectedNodes = 1;
      */
-    closestConnectedPeers: PeerDescriptor[];
+    closestConnectedNodes: PeerDescriptor[];
     /**
      * @generated from protobuf field: repeated dht.DataEntry dataEntries = 2;
      */
@@ -837,7 +845,7 @@ export const RecursiveOperationRequest = new RecursiveOperationRequest$Type();
 class RecursiveOperationResponse$Type extends MessageType<RecursiveOperationResponse> {
     constructor() {
         super("dht.RecursiveOperationResponse", [
-            { no: 1, name: "closestConnectedPeers", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
+            { no: 1, name: "closestConnectedNodes", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
             { no: 2, name: "dataEntries", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => DataEntry },
             { no: 3, name: "noCloserNodesFound", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
             { no: 4, name: "routingPath", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor }

package/src/transport/ITransport.ts

@@ -1,3 +1,4 @@
+import { DhtAddress } from '../identifiers'
 import { Message, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 
 export interface TransportEvents {
@@ -33,5 +34,7 @@ export interface ITransport {
     send(msg: Message, opts?: SendOptions): Promise<void>
     getLocalPeerDescriptor(): PeerDescriptor
     getConnections(): PeerDescriptor[]
+    getConnectionCount(): number
+    hasConnection(nodeId: DhtAddress): boolean
     stop(): void | Promise<void>
 }

package/test/end-to-end/Layer0MixedConnectionTypes.test.ts

@@ -72,15 +72,13 @@ describe('Layer0MixedConnectionTypes', () => {
 
     it('2 non-server peers join first', async () => {
 
-        const promise = Promise.all([
+        await Promise.all([
             waitForEvent3<TransportEvents>((node3.getTransport() as ConnectionManager), 'connected'),
             waitForEvent3<TransportEvents>((node4.getTransport() as ConnectionManager), 'connected'),
+            node3.joinDht([epPeerDescriptor]),
+            node4.joinDht([epPeerDescriptor])
         ])
 
-        node3.joinDht([epPeerDescriptor])
-        node4.joinDht([epPeerDescriptor])
-
-        await promise
         await Promise.all([
             node1.joinDht([epPeerDescriptor]),
             node2.joinDht([epPeerDescriptor]),

package/test/integration/DhtNode.test.ts

@@ -0,0 +1,81 @@
+import { waitForCondition } from '@streamr/utils'
+import { range, without } from 'lodash'
+import { DhtNodeRpcLocal } from '../../src/dht/DhtNodeRpcLocal'
+import { Contact } from '../../src/dht/contact/Contact'
+import { SortedContactList } from '../../src/dht/contact/SortedContactList'
+import { DhtAddress, DhtNode, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '../../src/exports'
+import { ClosestPeersRequest, ClosestPeersResponse, PeerDescriptor, PingRequest, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { FakeEnvironment } from '../utils/FakeTransport'
+import { createMockPeerDescriptor } from '../utils/utils'
+
+const OTHER_NODE_COUNT = 3
+const SERVICE_ID_LAYER0 = 'layer0'
+
+const getClosestNodes = (
+    referenceId: DhtAddress,
+    nodes: PeerDescriptor[],
+    maxCount: number,
+    allowToContainReferenceId: boolean
+): PeerDescriptor[] => {
+    const list = new SortedContactList<Contact>({
+        referenceId,
+        allowToContainReferenceId,
+        maxSize: maxCount
+    })
+    list.addContacts(nodes.map((n) => new Contact(n)))
+    return list.getClosestContacts().map((c) => c.getPeerDescriptor())
+}
+
+describe('DhtNode', () => {
+
+    let localPeerDescriptor: PeerDescriptor
+    let entryPointPeerDescriptor: PeerDescriptor
+    let otherPeerDescriptors: PeerDescriptor[]
+
+    const startRemoteNode = (peerDescriptor: PeerDescriptor, environment: FakeEnvironment) => {
+        const epRpcCommunicator = new ListeningRpcCommunicator(SERVICE_ID_LAYER0, environment.createTransport(peerDescriptor))
+        const dhtNodeRpcLocal = new DhtNodeRpcLocal({
+            peerDiscoveryQueryBatchSize: undefined as any,
+            getClosestNeighborsTo: (nodeId: DhtAddress, maxCount: number) => getClosestNodes(nodeId, getAllPeerDescriptors(), maxCount, true),
+            getClosestRingContactsTo: undefined as any,
+            addContact: () => {},
+            removeContact: undefined as any,
+        })
+        epRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping',
+            (req: PingRequest, context) => dhtNodeRpcLocal.ping(req, context))
+        epRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers',
+            (req: ClosestPeersRequest, context) => dhtNodeRpcLocal.getClosestPeers(req, context))
+    }
+
+    const getAllPeerDescriptors = () => {
+        return [localPeerDescriptor, entryPointPeerDescriptor, ...otherPeerDescriptors]
+    }
+
+    beforeAll(() => {
+        localPeerDescriptor = createMockPeerDescriptor()
+        entryPointPeerDescriptor = createMockPeerDescriptor()
+        otherPeerDescriptors = range(OTHER_NODE_COUNT).map(() => createMockPeerDescriptor())
+    })
+      
+    it('start node and join DHT', async () => {
+        const environment = new FakeEnvironment()
+        startRemoteNode(entryPointPeerDescriptor, environment)
+        for (const other of otherPeerDescriptors) {
+            startRemoteNode(other, environment)
+        }
+
+        const localNode = new DhtNode({
+            peerDescriptor: localPeerDescriptor,
+            transport: environment.createTransport(localPeerDescriptor),
+            entryPoints: [entryPointPeerDescriptor]
+        })
+        await localNode.start()
+        await localNode.joinDht([entryPointPeerDescriptor])
+        await localNode.waitForNetworkConnectivity()
+
+        await waitForCondition(() => localNode.getNeighborCount() === otherPeerDescriptors.length + 1)
+        const expectedNodeIds = without(getAllPeerDescriptors(), localPeerDescriptor).map((n) => getNodeIdFromPeerDescriptor(n))
+        const actualNodeIds = localNode.getClosestContacts().map((n) => getNodeIdFromPeerDescriptor(n))
+        expect(actualNodeIds).toIncludeSameMembers(expectedNodeIds)
+    })
+})

package/test/integration/Layer1-scale.test.ts

@@ -38,8 +38,8 @@ describe('Layer1', () => {
     }, 30000)
 
     afterEach(async () => {
-        await Promise.all(nodes.map((node) => node.stop()))
         await Promise.all(layer1CleanUp.map((node) => node.stop()))
+        await Promise.all(nodes.map((node) => node.stop()))
         await layer0EntryPoint.stop()
         simulator.stop()
     })

package/test/integration/ScaleDownDht.test.ts

@@ -4,7 +4,7 @@ import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dh
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { Logger } from '@streamr/utils'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
-import { areEqualPeerDescriptors, createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
+import { DhtAddress, areEqualPeerDescriptors, createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
@@ -47,13 +47,16 @@ describe('Scaling down a Dht network', () => {
         for (let i = 1; i < nodes.length; i++) {
             randomIndices.push(i)
         }
+        const stoppedNodes: Set<DhtAddress> = new Set()
         while (randomIndices.length > 1) {
             const index = Math.floor(Math.random() * randomIndices.length)
             const nodeIndex = randomIndices[index]
             randomIndices.splice(index, 1)
-            const stoppingPeerDescriptor = nodes[nodeIndex].getLocalPeerDescriptor()
-            await nodes[nodeIndex].stop()
-            const nodeIsCleaned = nodes.every((node) =>
+            const nodeToStop = nodes[nodeIndex]
+            const stoppingPeerDescriptor = nodeToStop.getLocalPeerDescriptor()
+            stoppedNodes.add(getNodeIdFromPeerDescriptor(stoppingPeerDescriptor))
+            await nodeToStop.stop()
+            const nodeIsCleaned = nodes.filter((node) => !stoppedNodes.has(node.getNodeId())).every((node) =>
                 node.getConnections().every((peer) => {
                     if (areEqualPeerDescriptors(peer, stoppingPeerDescriptor)) {
                         logger.error(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ', ' 

package/test/unit/DiscoverySession.test.ts

@@ -0,0 +1,85 @@
+import { Multimap, wait } from '@streamr/utils'
+import { sampleSize } from 'lodash'
+import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
+import { PeerManager, getDistance } from '../../src/dht/PeerManager'
+import { DiscoverySession } from '../../src/dht/discovery/DiscoverySession'
+import { DhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createTestTopology } from '../utils/topology'
+
+const NODE_COUNT = 40
+const MIN_NEIGHBOR_COUNT = 2  // nodes can get more neighbors when we merge network partitions
+const PARALLELISM = 1
+const NO_PROGRESS_LIMIT = 1
+const QUERY_BATCH_SIZE = 5  // the default value in DhtNode's config, not relevant in this test
+
+const createPeerDescriptor = (nodeId: DhtAddress): PeerDescriptor => {
+    return {
+        nodeId: getRawFromDhtAddress(nodeId),
+        type: NodeType.NODEJS
+    }
+}
+
+describe('DiscoverySession', () => {
+
+    let topology: Multimap<DhtAddress, DhtAddress>
+    const queriedNodes: DhtAddress[] = []
+
+    beforeAll(() => {
+        topology = createTestTopology(NODE_COUNT, MIN_NEIGHBOR_COUNT)
+    })
+
+    const createPeerManager = (localNodeId: DhtAddress): PeerManager => {
+        const peerManager = new PeerManager({
+            localNodeId,
+            localPeerDescriptor: createPeerDescriptor(localNodeId),
+            isLayer0: true,
+            createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => createMockRpcRemote(peerDescriptor) as any,
+            hasConnection: () => true
+        } as any)
+        for (const neighbor of topology.get(localNodeId)) {
+            peerManager.addContact(createPeerDescriptor(neighbor))
+        }
+        return peerManager
+    }
+
+    const createMockRpcRemote = (peerDescriptor: PeerDescriptor): Partial<DhtNodeRpcRemote> => {
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        return {
+            id: getRawFromDhtAddress(nodeId),
+            getPeerDescriptor: () => peerDescriptor,
+            getNodeId: () => nodeId,
+            getClosestPeers: async (referenceId: DhtAddress) => {
+                queriedNodes.push(nodeId)
+                await wait(10)
+                const peerManager = createPeerManager(nodeId)
+                return peerManager.getClosestNeighborsTo(referenceId, QUERY_BATCH_SIZE).map((remote) => remote.getPeerDescriptor())
+            },
+            ping: async () => true
+        }
+    }
+
+    it('happy path', async () => {
+        const nodeIds = [...topology.keys()]
+        const [localNodeId, targetId] = sampleSize(nodeIds, 2)
+        const contactedPeers = new Set<DhtAddress>()
+        const peerManager = createPeerManager(localNodeId)
+        const session = new DiscoverySession({
+            targetId,
+            parallelism: PARALLELISM,
+            noProgressLimit: NO_PROGRESS_LIMIT,
+            peerManager,
+            contactedPeers,
+            abortSignal: new AbortController().signal
+        })
+        await session.findClosestNodes(1000)
+        expect(queriedNodes.length).toBeGreaterThanOrEqual(1)
+        // Each queried node should closer to the target than the previous queried node, because we
+        // use parallelism=1 and noProgressLimit=1
+        const distancesToTarget = queriedNodes
+            .map((nodeId) => getDistance(getRawFromDhtAddress(nodeId), getRawFromDhtAddress(targetId)))
+        for (let i = 1; i < distancesToTarget.length ; i++) {
+            expect(distancesToTarget[i]).toBeLessThan(distancesToTarget[i - 1])
+        }
+    })
+})

package/test/unit/PeerManager.test.ts

@@ -26,7 +26,8 @@ const createPeerManager = (
                 }
             }(localPeerDescriptor, peerDescriptor, undefined as any, new MockRpcCommunicator())
             return remote
-        }
+        },
+        hasConnection: () => false
     } as any)
     const contacts = nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS }))
     for (const contact of contacts) {
@@ -53,21 +54,6 @@ const getClosestContact = (contacts: PeerDescriptor[], referenceId: DhtAddress):
 
 describe('PeerManager', () => {
 
-    it('getClosestContactsTo', () => {
-        const nodeIds = range(10).map(() => createRandomDhtAddress())
-        const manager = createPeerManager(nodeIds)
-        const referenceId = createRandomDhtAddress()
-        const excluded = new Set<DhtAddress>(sampleSize(nodeIds, 2))
-
-        const actual = manager.getClosestContactsTo(referenceId, 5, excluded)
-
-        const expected = sortBy(
-            without(nodeIds, ...Array.from(excluded.values())),
-            (n: DhtAddress) => getDistance(getRawFromDhtAddress(n), getRawFromDhtAddress(referenceId))
-        ).slice(0, 5)
-        expect(actual.map((n) => n.getNodeId())).toEqual(expected)
-    })
-
     it('getClosestNeighborsTo', () => {
         const nodeIds = range(10).map(() => createRandomDhtAddress())
         const manager = createPeerManager(nodeIds)
@@ -99,7 +85,7 @@ describe('PeerManager', () => {
         for (const successContact of successContacts) {
             manager.addContact(successContact)
             manager.setContactActive(getNodeIdFromPeerDescriptor(successContact))
-            manager.onContactDisconnected(getNodeIdFromPeerDescriptor(successContact), false)
+            manager.removeNeighbor(getNodeIdFromPeerDescriptor(successContact))
         }
         expect(manager.getNeighborCount()).toBe(0)
         manager.addContact(failureContact)

package/test/unit/RecursiveOperationManager.test.ts

@@ -74,12 +74,12 @@ describe('RecursiveOperationManager', () => {
         return new RecursiveOperationManager({
             localPeerDescriptor: peerDescriptor1,
             router,
-            connections: new Map(),
             serviceId: 'RecursiveOperationManager',
             localDataStore: new LocalDataStore(30 * 100),
             sessionTransport: transport,
             addContact: () => {},
-            rpcCommunicator: rpcCommunicator as any
+            rpcCommunicator: rpcCommunicator as any,
+            createDhtNodeRpcRemote: () => undefined as any
         })
     }
 
@@ -126,6 +126,7 @@ describe('RecursiveOperationManager', () => {
         const send = jest.fn()
         const transport = { 
             send,
+            getConnections: () => [],
             on: () => {},
             off: () => {}
         }
@@ -143,7 +144,8 @@ describe('RecursiveOperationManager', () => {
         const router = createMockRouter(RouteMessageError.DUPLICATE)
         const send = jest.fn()
         const transport = { 
-            send
+            send,
+            getConnections: () => []
         }
         const recursiveOperationManager = createRecursiveOperationManager(router as any, transport as any)
         const ack = await rpcCommunicator.callRpcMethod('routeRequest', routedMessage)

package/test/unit/Router.test.ts

@@ -50,8 +50,8 @@ describe('Router', () => {
         router = new Router({
             localPeerDescriptor: peerDescriptor1,
             rpcCommunicator: rpcCommunicator as any,
-            connections,
-            handleMessage: () => {}
+            handleMessage: () => {},
+            getConnections: () => [...connections.values()].map((c) => c.getPeerDescriptor())
         })
     })
 

package/test/unit/RoutingSession.test.ts

@@ -49,11 +49,11 @@ describe('RoutingSession', () => {
             rpcCommunicator: rpcCommunicator,
             localPeerDescriptor: mockPeerDescriptor1,
             routedMessage,
-            connections, 
             parallelism: 2,
             mode: RoutingMode.ROUTE,
             excludedNodeIds: new Set(),
-            routingTablesCache
+            routingTablesCache,
+            getConnections: () => [...connections.values()].map((c) => c.getPeerDescriptor())
         })
     })
 

package/test/unit/SortedContactList.test.ts

@@ -38,7 +38,7 @@ describe('SortedContactList', () => {
         expect(list.getSize()).toEqual(3)
         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(onContactRemoved).toBeCalledWith(item4)
         expect(list.getContact(item4.getNodeId())).toBeFalsy()
     })
 
@@ -63,9 +63,9 @@ describe('SortedContactList', () => {
         list.removeContact(item3.getNodeId())
         list.removeContact(createRandomDhtAddress())
         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])
+        expect(onContactRemoved).toHaveBeenNthCalledWith(1, item3)
+        expect(onContactRemoved).toHaveBeenNthCalledWith(2, item2)
+        expect(onContactRemoved).toHaveBeenNthCalledWith(3, item3)
     })
 
     it('get closest contacts', () => {

package/test/unit/getClosestContacts.test.ts

@@ -0,0 +1,28 @@
+import { range, sampleSize, sortBy, without } from 'lodash'
+import { getDistance } from '../../src/dht/PeerManager'
+import { getClosestContacts } from '../../src/dht/contact/getClosestContacts'
+import { DhtAddress, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+
+describe('getClosestContacts', () => {
+
+    it('happy path', () => {
+        const nodeIds = range(10).map(() => createRandomDhtAddress())
+        const referenceId = createRandomDhtAddress()
+        const excluded = new Set<DhtAddress>(sampleSize(nodeIds, 2))
+
+        const actual = getClosestContacts(
+            referenceId,
+            nodeIds.map((nodeId) => ({ getNodeId: () => nodeId })),
+            {
+                maxCount: 5,
+                excludedNodeIds: excluded
+            }
+        )
+
+        const expected = sortBy(
+            without(nodeIds, ...Array.from(excluded.values())),
+            (n: DhtAddress) => getDistance(getRawFromDhtAddress(n), getRawFromDhtAddress(referenceId))
+        ).slice(0, 5)
+        expect(actual.map((n) => n.getNodeId())).toEqual(expected)
+    })
+})

package/test/utils/FakeTransport.ts

@@ -1,11 +1,16 @@
 import { EventEmitter } from 'eventemitter3'
-import { ITransport, TransportEvents } from '../../src/transport/ITransport'
+import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { Message, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DEFAULT_SEND_OPTIONS, ITransport, SendOptions, TransportEvents } from '../../src/transport/ITransport'
 
 class FakeTransport extends EventEmitter<TransportEvents> implements ITransport {
 
     private onSend: (msg: Message) => void
     private readonly localPeerDescriptor: PeerDescriptor
+    // currently adds a peerDescription to the connections array when a "connect" option is seen in
+    // in send() call and never disconnects (TODO could add some disconnection logic? and maybe
+    // the connection should be seen by another FakeTransport instance, too?)
+    private connections: PeerDescriptor[] = []
 
     constructor(peerDescriptor: PeerDescriptor, onSend: (msg: Message) => void) {
         super()
@@ -13,19 +18,37 @@ class FakeTransport extends EventEmitter<TransportEvents> implements ITransport
         this.localPeerDescriptor = peerDescriptor
     }
 
-    async send(msg: Message): Promise<void> {
+    async send(msg: Message, opts?: SendOptions): Promise<void> {
+        const connect = opts?.connect ?? DEFAULT_SEND_OPTIONS.connect
+        const targetNodeId = getNodeIdFromPeerDescriptor(msg.targetDescriptor!)
+        if (connect && !this.connections.some((c) => getNodeIdFromPeerDescriptor(c) === targetNodeId)) {
+            this.connect(msg.targetDescriptor!)
+        }
         msg.sourceDescriptor = this.localPeerDescriptor
         this.onSend(msg)
     }
 
-    // eslint-disable-next-line class-methods-use-this
     getLocalPeerDescriptor(): PeerDescriptor {
-        throw new Error('not implemented')
+        return this.localPeerDescriptor
+    }
+
+    private connect(peerDescriptor: PeerDescriptor) {
+        this.connections.push(peerDescriptor)
+        this.emit('connected', peerDescriptor)
     }
 
-    // eslint-disable-next-line class-methods-use-this
     getConnections(): PeerDescriptor[] {
-        throw new Error('not implemented')
+        return this.connections
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getConnectionCount(): number {
+        return this.connections.length
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    hasConnection(nodeId: DhtAddress): boolean {
+        return this.connections.some((c) => getNodeIdFromPeerDescriptor(c) === nodeId)
     }
 
     // eslint-disable-next-line class-methods-use-this
@@ -39,7 +62,11 @@ export class FakeEnvironment {
 
     createTransport(peerDescriptor: PeerDescriptor): ITransport {
         const transport = new FakeTransport(peerDescriptor, (msg) => {
-            this.transports.forEach((t) => t.emit('message', msg))
+            const targetNode = getDhtAddressFromRaw(msg.targetDescriptor!.nodeId)
+            const targetTransport = this.transports.find((t) => getNodeIdFromPeerDescriptor(t.getLocalPeerDescriptor()) === targetNode)
+            if (targetTransport !== undefined) {
+                targetTransport.emit('message', msg)
+            }
         })
         this.transports.push(transport)
         return transport

package/test/utils/mock/Transport.ts

@@ -19,6 +19,16 @@ export class MockTransport extends EventEmitter<TransportEvents> implements ITra
         return []
     }
 
+    // eslint-disable-next-line class-methods-use-this
+    getConnectionCount(): number {
+        return 0
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    hasConnection(): boolean {
+        return false
+    }
+
     // eslint-disable-next-line class-methods-use-this
     stop(): void {