@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.2

package/test/utils/FakeTransport.ts

@@ -1,79 +0,0 @@
-import { EventEmitter } from 'eventemitter3'
-import { DhtAddress, toDhtAddress, toNodeId } from '../../src/identifiers'
-import { Message, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { DEFAULT_SEND_OPTIONS, ITransport, SendOptions, TransportEvents } from '../../src/transport/ITransport'
-import { ConnectionsView } from '../../src/exports'
-
-// TODO extract ConnectionsView functionality to FakeConnectionsView
-class FakeTransport extends EventEmitter<TransportEvents> implements ITransport, ConnectionsView {
-
-    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()
-        this.onSend = onSend
-        this.localPeerDescriptor = peerDescriptor
-    }
-
-    async send(msg: Message, opts?: SendOptions): Promise<void> {
-        const connect = opts?.connect ?? DEFAULT_SEND_OPTIONS.connect
-        const targetNodeId = toNodeId(msg.targetDescriptor!)
-        if (connect && !this.connections.some((c) => toNodeId(c) === targetNodeId)) {
-            this.connect(msg.targetDescriptor!)
-        }
-        msg.sourceDescriptor = this.localPeerDescriptor
-        this.onSend(msg)
-    }
-
-    getLocalPeerDescriptor(): PeerDescriptor {
-        return this.localPeerDescriptor
-    }
-
-    private connect(peerDescriptor: PeerDescriptor) {
-        this.connections.push(peerDescriptor)
-        this.emit('connected', peerDescriptor)
-    }
-
-    getConnections(): PeerDescriptor[] {
-        return this.connections
-    }
-
-    getConnectionCount(): number {
-        return this.connections.length
-    }
-
-    hasConnection(nodeId: DhtAddress): boolean {
-        return this.connections.some((c) => toNodeId(c) === nodeId)
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    stop(): void | Promise<void> {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getDiagnosticInfo(): Record<string, unknown> {
-        return {}
-    }
-}
-
-export class FakeEnvironment {
-
-    private transports: FakeTransport[] = []
-
-    createTransport(peerDescriptor: PeerDescriptor): FakeTransport {
-        const transport = new FakeTransport(peerDescriptor, (msg) => {
-            const targetNode = toDhtAddress(msg.targetDescriptor!.nodeId)
-            const targetTransport = this.transports.find((t) => toNodeId(t.getLocalPeerDescriptor()) === targetNode)
-            if (targetTransport !== undefined) {
-                targetTransport.emit('message', msg)
-            }
-        })
-        this.transports.push(transport)
-        return transport
-    }
-}

package/test/utils/customMatchers.ts

@@ -1,71 +0,0 @@
-import { areEqualBinaries } from '@streamr/utils'
-import { printExpected, printReceived } from 'jest-matcher-utils'
-import { isEqual } from 'lodash'
-import { ConnectivityMethod, NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { toDhtAddress } from '../../src/identifiers'
-
-// we could ES2015 module syntax (https://jestjs.io/docs/expect#expectextendmatchers),
-// but the IDE doesn't find custom matchers if we do that
-declare global {
-    // eslint-disable-next-line @typescript-eslint/no-namespace
-    namespace jest {
-        interface Matchers<R> {
-            toEqualPeerDescriptor(expected: PeerDescriptor): R
-        }
-    }
-}
-
-const formErrorMessage = (field: keyof PeerDescriptor, expected: string | number | undefined, actual: string | number | undefined): string => {
-    return `PeerDescriptor ${field} values don't match:\nExpected: ${printExpected(expected)}\nReceived: ${printReceived(actual)}`
-}
-
-const toEqualPeerDescriptor = (
-    actual: PeerDescriptor,
-    expected: PeerDescriptor
-): jest.CustomMatcherResult => {
-    const messages: string[] = []
-    if (!areEqualBinaries(expected.nodeId, actual.nodeId)) {
-        messages.push(formErrorMessage('nodeId', toDhtAddress(expected.nodeId), toDhtAddress(actual.nodeId)))
-    }
-    if (!isEqual(expected.type, actual.type)) {
-        const typeNames = { [NodeType.NODEJS]: 'NODEJS', [NodeType.BROWSER]: 'BROWSER' }
-        messages.push(formErrorMessage('type', typeNames[expected.type], typeNames[actual.type]))
-    }
-    expectEqualConnectivityMethod('udp', expected.udp, actual.udp, messages)
-    expectEqualConnectivityMethod('tcp', expected.tcp, actual.tcp, messages)
-    expectEqualConnectivityMethod('websocket', expected.websocket, actual.websocket, messages)
-    if (expected.region !== actual.region) {
-        messages.push(formErrorMessage('region', expected?.region, actual?.region))
-    } 
-    if (messages.length > 0) {
-        return {
-            pass: false,
-            message: () => messages.join('\n\n')
-        }
-    } else {
-        return {
-            pass: true,
-            message: () => 'PeerDescriptors are equal'
-        }
-    }
-}
-
-const expectEqualConnectivityMethod = (
-    field: keyof PeerDescriptor,
-    method1: ConnectivityMethod | undefined,
-    method2: ConnectivityMethod | undefined,
-    messages: string[]
-) => {
-    const toOutput = (method?: ConnectivityMethod) => {
-        return (method !== undefined)
-            ? `{port: ${method.port}, host: '${method.host}', tls: ${method.tls}}`
-            : undefined
-    }
-    if (!isEqual(method1, method2)) {
-        messages.push(formErrorMessage(field, toOutput(method1), toOutput(method2)))
-    }
-}
-
-expect.extend({
-    toEqualPeerDescriptor
-})

package/test/utils/mock/MockConnection.ts

@@ -1,26 +0,0 @@
-import EventEmitter from 'eventemitter3'
-import { ConnectionEvents, IConnection } from '../../../src/connection/IConnection'
-
-export class MockConnection extends EventEmitter<ConnectionEvents> implements IConnection {
-
-    public sentData: Uint8Array[] = []
-
-    send(data: Uint8Array): Promise<void> {
-        this.sentData.push(data)
-        return Promise.resolve()
-    }
-
-    close(graceful: boolean): Promise<void> {
-        this.emit('disconnected', graceful)
-        return Promise.resolve()
-    }
-
-    destroy(): void {
-        this.removeAllListeners()
-    }
-
-    emitData(message: Uint8Array): void {
-        this.emit('data', message)
-    }
-
-}

package/test/utils/mock/MockConnectionsView.ts

@@ -1,18 +0,0 @@
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-
-export class MockConnectionsView {
-    // eslint-disable-next-line class-methods-use-this
-    getConnections(): PeerDescriptor[] {
-        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
-    }
-}

package/test/utils/mock/MockRouter.ts

@@ -1,62 +0,0 @@
-import { Methods } from '@streamr/test-utils'
-import { Router } from '../../../src/dht/routing/Router'
-import { RouteMessageAck } from '../../../generated/packages/dht/protos/DhtRpc'
-
-export class MockRouter implements Methods<Router> {
-
-    // eslint-disable-next-line class-methods-use-this
-    addRoutingSession(): void {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    removeRoutingSession(): void {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    addToDuplicateDetector(): void {
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    isMostLikelyDuplicate(): boolean {
-        return false
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    doRouteMessage(): RouteMessageAck {
-        return RouteMessageAck.create()
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    send(): Promise<void> {
-        throw new Error('Not implemented')
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    stop(): void {
-
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async routeMessage(): Promise<RouteMessageAck> {
-        return RouteMessageAck.create()
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    async forwardMessage(): Promise<RouteMessageAck> {
-        return RouteMessageAck.create()
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    onNodeConnected(): void {}
-
-    // eslint-disable-next-line class-methods-use-this
-    onNodeDisconnected(): void {}
-
-    // eslint-disable-next-line class-methods-use-this
-    resetCache(): void {}
-
-    // eslint-disable-next-line class-methods-use-this
-    getDiagnosticInfo(): Record<string, unknown> {
-        return {}
-    }
-}

package/test/utils/mock/MockRpcCommunicator.ts

@@ -1,7 +0,0 @@
-import { RoutingRpcCommunicator } from '../../../src/transport/RoutingRpcCommunicator'
-
-export class MockRpcCommunicator extends RoutingRpcCommunicator {
-    constructor() {
-        super('mock-service', async () => {})
-    }
-}

package/test/utils/mock/MockTransport.ts

@@ -1,26 +0,0 @@
-import { ITransport, TransportEvents } from '../../../src/transport/ITransport'
-import { EventEmitter } from 'eventemitter3'
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-
-export class MockTransport extends EventEmitter<TransportEvents> implements ITransport {
-
-    // eslint-disable-next-line class-methods-use-this
-    async send(): Promise<void> {
-
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getLocalPeerDescriptor(): PeerDescriptor {
-        return PeerDescriptor.create()
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    stop(): void {
-
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    getDiagnosticInfo(): Record<string, unknown> {
-        return {}
-    }
-}

package/test/utils/mock/mockDataEntry.ts

@@ -1,38 +0,0 @@
-import { MessageType as MessageType$, ScalarType } from '@protobuf-ts/runtime'
-import { randomString } from '@streamr/utils'
-import { Timestamp } from '../../../generated/google/protobuf/timestamp'
-import { Any } from '../../../generated/google/protobuf/any'
-import { DataEntry } from '../../../generated/packages/dht/protos/DhtRpc'
-import { DhtAddress, randomDhtAddress, toDhtAddressRaw } from '../../../src/identifiers'
-import { omit } from 'lodash'
-
-const MockData = new class extends MessageType$<{ foo: string }> {
-    constructor() {
-        super('MockData', [
-            { no: 1, name: 'foo', kind: 'scalar', opt: false, T: ScalarType.STRING }
-        ])
-    }
-}
-
-export const createMockDataEntry = (
-    entry: Partial<Omit<DataEntry, 'key' | 'creator'> & { key: DhtAddress, creator: DhtAddress }> = {}
-): DataEntry => {
-    return { 
-        key: toDhtAddressRaw(entry.key ?? randomDhtAddress()),
-        data: Any.pack({ foo: randomString(5) }, MockData),
-        creator: toDhtAddressRaw(entry.creator ?? randomDhtAddress()),
-        ttl: 10000,
-        stale: false,
-        deleted: false,
-        createdAt: Timestamp.now(),
-        ...omit(entry, 'key', 'creator')
-    }
-}
-
-export const unpackData = (entry: DataEntry): { foo: string } => {
-    return Any.unpack(entry.data!, MockData)
-}
-
-export const expectEqualData = (entry1: DataEntry, entry2: DataEntry): void => {
-    expect(unpackData(entry1).foo).toBe(unpackData(entry2).foo)
-}

package/test/utils/topology.ts

@@ -1,79 +0,0 @@
-import { Multimap } from '@streamr/utils'
-import { DhtAddress, randomDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
-import { minBy, range, without } from 'lodash'
-import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import { getDistance } from '../../src/dht/PeerManager'
-
-export const getTopologyPartitions = (topology: Multimap<DhtAddress, DhtAddress>): Set<DhtAddress>[] => {
-    let partitions: Set<DhtAddress>[] = []
-    for (const nodeId of topology.keys()) {
-        const neighbors = topology.get(nodeId)
-        const existingPartition = partitions.find((partition) => partition.has(nodeId))
-        if (existingPartition !== undefined) {
-            for (const neighbor of neighbors) {
-                if (!existingPartition.has(neighbor)) {
-                    const otherPartition = partitions.find((partition) => partition.has(neighbor))
-                    if (otherPartition !== undefined) {
-                        for (const otherNode of otherPartition) {
-                            existingPartition.add(otherNode)
-                        }
-                        partitions = without(partitions, otherPartition)
-                    } else {
-                        existingPartition.add(neighbor)
-                    }
-                }
-            }
-        } else {
-            const partition = new Set([nodeId, ...neighbors])
-            partitions.push(partition)
-        }
-    }
-    return partitions
-}
-
-const getClosestNodes = (referenceId: DhtAddress, nodeIds: DhtAddress[], count: number, allowToContainReferenceId: boolean): DhtAddress[] => {
-    const list = new SortedContactList({
-        referenceId,
-        allowToContainReferenceId,
-        maxSize: count
-    })
-    list.addContacts(nodeIds.map((n) => ({ getNodeId: () => n })))
-    return list.getClosestContacts().map((c) => c.getNodeId())
-}
-
-/* 
- * There are no network splits, and each node has only neighbors which are globally closest
- * to the node's ID.
- */
-export const createTestTopology = (nodeCount: number, minNeighorCount: number): Multimap<DhtAddress, DhtAddress> => {
-    const topology: Multimap<DhtAddress, DhtAddress> = new Multimap()
-    const nodeIds = range(nodeCount).map(() => randomDhtAddress())
-    for (const nodeId of nodeIds) {
-        const closestNodes = getClosestNodes(nodeId, nodeIds, minNeighorCount, false)
-        for (const closestNode of closestNodes) {
-            if (!topology.has(nodeId, closestNode)) {
-                topology.add(nodeId, closestNode)
-            }
-            if (!topology.has(closestNode, nodeId)) {
-                topology.add(closestNode, nodeId)
-            }
-        }
-    }
-    while (true) {
-        const partitions = getTopologyPartitions(topology)
-        if (partitions.length === 1) {
-            break
-        } else {
-            const closestPairs = nodeIds.map((nodeId: DhtAddress) => {
-                const ownPartition = partitions.find((partition) => partition.has(nodeId))!
-                const otherNodes = without(nodeIds, ...[...ownPartition])
-                const closestNodedId = getClosestNodes(nodeId, otherNodes, 1, false)[0]
-                return [nodeId, closestNodedId]
-            })
-            const mergePair = minBy(closestPairs, (pair) => getDistance(toDhtAddressRaw(pair[0]), toDhtAddressRaw(pair[1])))!
-            topology.add(mergePair[0], mergePair[1])
-            topology.add(mergePair[1], mergePair[0])
-        }
-    }
-    return topology
-}

package/test/utils/utils.ts

@@ -1,268 +0,0 @@
-import { DhtNode } from '../../src/dht/DhtNode'
-import {
-    ClosestPeersRequest,
-    ClosestPeersResponse,
-    NodeType,
-    PeerDescriptor,
-    PingRequest,
-    PingResponse,
-    RouteMessageAck,
-    RouteMessageWrapper,
-    StoreDataRequest,
-    StoreDataResponse,
-    ClosestRingPeersResponse
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import {
-    IDhtNodeRpc,
-    IRouterRpc,
-    IStoreRpc,
-    IWebsocketClientConnectorRpc
-} from '../../generated/packages/dht/protos/DhtRpc.server'
-import { Simulator } from '../../src/connection/simulator/Simulator'
-import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { v4 } from 'uuid'
-import { getRandomRegion } from '../../src/connection/simulator/pings'
-import { Empty } from '../../generated/google/protobuf/empty'
-import { Any } from '../../generated/google/protobuf/any'
-import { wait, until } from '@streamr/utils'
-import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { DhtAddress, randomDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
-
-export const createMockPeerDescriptor = (opts?: Partial<Omit<PeerDescriptor, 'nodeId'>>): PeerDescriptor => {
-    return {
-        nodeId: toDhtAddressRaw(randomDhtAddress()),
-        type: NodeType.NODEJS,
-        ...opts
-    }
-}
-
-export const createMockRingNode = async (
-    simulator: Simulator,
-    nodeId: DhtAddress,
-    region: number
-): Promise<DhtNode> => {
-    const maxConnections = 80
-    const dhtJoinTimeout = 45000
-
-    const peerDescriptor: PeerDescriptor = {
-        nodeId: toDhtAddressRaw(nodeId ?? randomDhtAddress()),
-        type: NodeType.NODEJS,
-        region
-        //ipAddress: ipv4ToNumber(ipAddress)
-    }
-    const mockConnectionManager = new SimulatorTransport(peerDescriptor, simulator)
-    await mockConnectionManager.start()
-    const opts = {
-        peerDescriptor: peerDescriptor,
-        transport: mockConnectionManager,
-        connectionLocker: mockConnectionManager,
-        numberOfNodesPerKBucket: 8,
-        maxConnections: maxConnections,
-        dhtJoinTimeout,
-        rpcRequestTimeout: 5000
-    }
-    const node = new class extends DhtNode {
-        async stop(): Promise<void> {
-            await super.stop()
-            await mockConnectionManager.stop()
-        }
-    }(opts)
-    await node.start()
-    return node
-}
-
-export const createMockConnectionDhtNode = async (
-    simulator: Simulator,
-    nodeId?: DhtAddress,
-    numberOfNodesPerKBucket?: number,
-    maxConnections = 80,
-    dhtJoinTimeout = 45000
-): Promise<DhtNode> => {
-    const peerDescriptor: PeerDescriptor = {
-        nodeId: toDhtAddressRaw(nodeId ?? randomDhtAddress()),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
-    const mockConnectionManager = new SimulatorTransport(peerDescriptor, simulator)
-    await mockConnectionManager.start()
-    const opts = {
-        peerDescriptor: peerDescriptor,
-        transport: mockConnectionManager,
-        connectionsView: mockConnectionManager,
-        connectionLocker: mockConnectionManager,
-        numberOfNodesPerKBucket,
-        maxConnections: maxConnections,
-        dhtJoinTimeout,
-        rpcRequestTimeout: 5000
-    }
-    const node = new class extends DhtNode {
-        async stop(): Promise<void> {
-            await super.stop()
-            await mockConnectionManager.stop()
-        }
-    }(opts)
-    await node.start()
-    return node
-}
-
-export const createMockConnectionLayer1Node = async (
-    layer0Node: DhtNode,
-    serviceId?: string,
-    numberOfNodesPerKBucket = 8
-): Promise<DhtNode> => {
-    const descriptor: PeerDescriptor = {
-        nodeId: layer0Node.getLocalPeerDescriptor().nodeId,
-        type: NodeType.NODEJS,
-    }
-    const node = new DhtNode({
-        peerDescriptor: descriptor,
-        transport: layer0Node,
-        connectionsView: layer0Node.getConnectionsView(),
-        serviceId: serviceId ? serviceId : 'layer1', numberOfNodesPerKBucket,
-        rpcRequestTimeout: 10000
-    })
-    await node.start()
-    return node
-}
-
-export const createWrappedClosestPeersRequest = (
-    sourceDescriptor: PeerDescriptor
-): RpcMessage => {
-
-    const routedMessage: ClosestPeersRequest = {
-        nodeId: sourceDescriptor.nodeId,
-        requestId: v4()
-    }
-    const rpcWrapper: RpcMessage = {
-        body: Any.pack(routedMessage, ClosestPeersRequest),
-        header: {
-            method: 'closestPeersRequest',
-            request: 'request'
-        },
-        requestId: v4()
-    }
-    return rpcWrapper
-}
-
-interface IDhtRpcWithError extends IDhtNodeRpc {
-    throwPingError: (request: PingRequest) => Promise<PingResponse>
-    respondPingWithTimeout: (request: PingRequest) => Promise<PingResponse>
-    throwGetClosestPeersError: (request: ClosestPeersRequest) => Promise<ClosestPeersResponse>
-}
-
-export const createMockDhtRpc = (neighbors: PeerDescriptor[]): IDhtRpcWithError => {
-    return {
-        async getClosestPeers(): Promise<ClosestPeersResponse> {
-            const response: ClosestPeersResponse = {
-                peers: neighbors,
-                requestId: 'why am i still here'
-            }
-            return response
-        },
-        async getClosestRingPeers(): Promise<ClosestRingPeersResponse> {
-            const response: ClosestRingPeersResponse = {
-                leftPeers: neighbors,
-                rightPeers: neighbors,
-                requestId: 'why am i still here'
-            }
-            return response
-        },
-        async ping(request: PingRequest): Promise<PingResponse> {
-            const response: PingResponse = {
-                requestId: request.requestId
-            }
-            return response
-        },
-        async leaveNotice(): Promise<Empty> {
-            return {}
-        },
-        async throwPingError(): Promise<PingResponse> {
-            throw new Error()
-        },
-        async respondPingWithTimeout(request: PingRequest): Promise<PingResponse> {
-            const response: PingResponse = {
-                requestId: request.requestId
-            }
-            await wait(2000)
-            return response
-        },
-        async throwGetClosestPeersError(): Promise<ClosestPeersResponse> {
-            throw new Error('Closest peers error')
-        }
-    }
-}
-
-interface IRouterRpcWithError extends IRouterRpc {
-    throwRouteMessageError: (request: RouteMessageWrapper) => Promise<RouteMessageAck>
-}
-
-export const mockRouterRpc: IRouterRpcWithError = {
-    async routeMessage(routed: RouteMessageWrapper): Promise<RouteMessageAck> {
-        const response: RouteMessageAck = {
-            requestId: routed.requestId
-        }
-        return response
-    },
-    async forwardMessage(routed: RouteMessageWrapper): Promise<RouteMessageAck> {
-        const response: RouteMessageAck = {
-            requestId: routed.requestId
-        }
-        return response
-    },
-    async throwRouteMessageError(): Promise<RouteMessageAck> {
-        throw new Error()
-    }
-}
-
-interface IStoreRpcWithError extends IStoreRpc {
-    throwStoreDataError: (request: StoreDataRequest) => Promise<StoreDataResponse>
-}
-
-export const mockStoreRpc: IStoreRpcWithError = {
-    async storeData(): Promise<StoreDataResponse> {
-        return {}
-    },
-    async throwStoreDataError(): Promise<StoreDataResponse> {
-        throw new Error('Mock')
-    },
-    async replicateData(): Promise<Empty> {
-        return {}
-    }
-}
-
-export const mockWebsocketClientConnectorRpc: IWebsocketClientConnectorRpc = {
-    async requestConnection(): Promise<Empty> {
-        return {}
-    }
-}
-
-export const createMockPeers = (): PeerDescriptor[] => {
-    const n1 = createMockPeerDescriptor()
-    const n2 = createMockPeerDescriptor()
-    const n3 = createMockPeerDescriptor()
-    const n4 = createMockPeerDescriptor()
-    return [
-        n1, n2, n3, n4
-    ]
-}
-
-/*
- * When we start multiple nodes, most of the nodes have unlocked connections. This promise will resolve when some of those 
- * unlocked connections have been garbage collected, i.e. we typically have connections only to the nodes which
- * are neighbors.
- */
-export const waitForStableTopology = async (nodes: DhtNode[], maxConnectionCount: number = 10000, waitTime = 20000): Promise<void> => {
-    const MAX_IDLE_TIME = 100
-    const connectionManagers = nodes.map((n) => n.getTransport() as ConnectionManager)
-    await Promise.all(connectionManagers.map(async (connectionManager) => {
-        connectionManager.garbageCollectConnections(maxConnectionCount, MAX_IDLE_TIME)
-        try {
-            await until(() => connectionManager.getConnections().length <= maxConnectionCount, waitTime)
-        } catch {
-            // the topology is very likely stable, but we can't be sure (maybe the node has more than maxConnectionCount
-            // locked connections and therefore it is ok to that garbage collector was not able to remove any of those
-            // connections
-        }
-    }))
-}