@streamr/trackerless-network 0.0.1-tatum.5 → 0.0.1-tatum.6

package/src/logic/StreamPartEntryPointDiscovery.ts

@@ -1,15 +1,14 @@
-import { createHash } from 'crypto'
 import {
-    isSamePeerDescriptor,
+    DataEntry,
     PeerDescriptor,
     RecursiveFindResult,
-    DataEntry
+    isSamePeerDescriptor
 } from '@streamr/dht'
-import { Any } from '../proto/google/protobuf/any'
-import { Logger, setAbortableTimeout, wait } from '@streamr/utils'
-import { StreamPartDelivery } from './StreamrNode'
 import { StreamPartID } from '@streamr/protocol'
+import { Logger, scheduleAtInterval, wait } from '@streamr/utils'
+import { createHash } from 'crypto'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { Any } from '../proto/google/protobuf/any'
 import { ILayer1 } from './ILayer1'
 
 export const streamPartIdToDataKey = (streamPartId: StreamPartID): Uint8Array => {
@@ -57,8 +56,9 @@ const ENTRYPOINT_STORE_LIMIT = 8
 export const NETWORK_SPLIT_AVOIDANCE_LIMIT = 4
 
 interface StreamPartEntryPointDiscoveryConfig {
-    streamParts: Map<string, StreamPartDelivery>
+    streamPartId: StreamPartID
     ownPeerDescriptor: PeerDescriptor
+    layer1: ILayer1
     getEntryPointData: (key: Uint8Array) => Promise<RecursiveFindResult>
     getEntryPointDataViaNode: (key: Uint8Array, node: PeerDescriptor) => Promise<DataEntry[]>
     storeEntryPointData: (key: Uint8Array, data: Any) => Promise<PeerDescriptor[]>
@@ -69,19 +69,16 @@ interface StreamPartEntryPointDiscoveryConfig {
 export class StreamPartEntryPointDiscovery {
     private readonly abortController: AbortController
     private readonly config: StreamPartEntryPointDiscoveryConfig
-    private readonly servicedStreamParts: Map<StreamPartID, NodeJS.Timeout>
     private readonly cacheInterval: number
-    private readonly networkSplitAvoidedNodes: Map<StreamPartID, Set<NodeID>> = new Map()
+    private readonly networkSplitAvoidedNodes: Set<NodeID> = new Set()
 
     constructor(config: StreamPartEntryPointDiscoveryConfig) {
         this.config = config
         this.abortController = new AbortController()
         this.cacheInterval = this.config.cacheInterval ?? 60000
-        this.servicedStreamParts = new Map()
     }
 
     async discoverEntryPointsFromDht(
-        streamPartId: StreamPartID,
         knownEntryPointCount: number,
         forwardingNode?: PeerDescriptor
     ): Promise<FindEntryPointsResult> {
@@ -91,7 +88,7 @@ export class StreamPartEntryPointDiscovery {
                 discoveredEntryPoints: []
             }
         }
-        const discoveredEntryPoints = await this.discoverEntryPoints(streamPartId, forwardingNode)
+        const discoveredEntryPoints = await this.discoverEntryPoints(forwardingNode)
         if (discoveredEntryPoints.length === 0) {
             discoveredEntryPoints.push(this.config.ownPeerDescriptor)
         }
@@ -101,20 +98,19 @@ export class StreamPartEntryPointDiscovery {
         }
     }
 
-    private async discoverEntryPoints(streamPartId: StreamPartID, forwardingNode?: PeerDescriptor): Promise<PeerDescriptor[]> {
-        const dataKey = streamPartIdToDataKey(streamPartId)
-        let discoveredEntryPoints = forwardingNode ? 
+    private async discoverEntryPoints(forwardingNode?: PeerDescriptor): Promise<PeerDescriptor[]> {
+        const dataKey = streamPartIdToDataKey(this.config.streamPartId)
+        const discoveredEntryPoints = forwardingNode ? 
             await this.queryEntryPointsViaNode(dataKey, forwardingNode) : await this.queryEntrypoints(dataKey)
     
-        if (this.networkSplitAvoidedNodes.has(streamPartId)) {
-            const filtered = discoveredEntryPoints.filter((node) => 
-                !this.networkSplitAvoidedNodes.get(streamPartId)!.has(getNodeIdFromPeerDescriptor(node)))
-            // If all discovered entry points have previously beed detected as offline, try again
-            if (filtered.length > 0) {
-                discoveredEntryPoints = filtered
-            }
+        const filtered = discoveredEntryPoints.filter((node) => 
+            !this.networkSplitAvoidedNodes.has(getNodeIdFromPeerDescriptor(node)))
+        // If all discovered entry points have previously been detected as offline, try again
+        if (filtered.length > 0) {
+            return filtered
+        } else {
+            return discoveredEntryPoints
         }
-        return discoveredEntryPoints
     }
 
     private async queryEntrypoints(key: Uint8Array): Promise<PeerDescriptor[]> {
@@ -131,6 +127,7 @@ export class StreamPartEntryPointDiscovery {
         }
     }
 
+    // TODO remove this method in NET-1122
     private async queryEntryPointsViaNode(key: Uint8Array, node: PeerDescriptor): Promise<PeerDescriptor[]> {
         logger.trace(`Finding data via node ${this.config.ownPeerDescriptor.nodeName}`)
         try {
@@ -145,96 +142,64 @@ export class StreamPartEntryPointDiscovery {
         }
     }
 
-    async storeSelfAsEntryPointIfNecessary(
-        streamPartId: StreamPartID,
-        entryPointsFromDht: boolean,
-        currentEntrypointCount: number
-    ): Promise<void> {
-        if (!this.config.streamParts.has(streamPartId) || !entryPointsFromDht) {
+    async storeSelfAsEntryPointIfNecessary(currentEntrypointCount: number): Promise<void> {
+        if (this.abortController.signal.aborted) {
             return
         }
-        if ((this.config.streamParts.get(streamPartId)! as { layer1: ILayer1 }).layer1!.getBucketSize() < NETWORK_SPLIT_AVOIDANCE_LIMIT) {
-            await this.storeSelfAsEntryPoint(streamPartId)
-            setImmediate(() => this.avoidNetworkSplit(streamPartId))
-        } else if (currentEntrypointCount < ENTRYPOINT_STORE_LIMIT) {
-            await this.storeSelfAsEntryPoint(streamPartId)
+        const possibleNetworkSplitDetected = this.config.layer1.getBucketSize() < NETWORK_SPLIT_AVOIDANCE_LIMIT
+        if ((currentEntrypointCount < ENTRYPOINT_STORE_LIMIT) || possibleNetworkSplitDetected) {
+            await this.storeSelfAsEntryPoint()
+            await this.keepSelfAsEntryPoint()
+        }
+        if (possibleNetworkSplitDetected) {
+            setImmediate(() => this.avoidNetworkSplit())
         }
     }
 
-    private async storeSelfAsEntryPoint(streamPartId: StreamPartID): Promise<void> {
+    private async storeSelfAsEntryPoint(): Promise<void> {
         const ownPeerDescriptor = this.config.ownPeerDescriptor
         const dataToStore = Any.pack(ownPeerDescriptor, PeerDescriptor)
         try {
-            await this.config.storeEntryPointData(streamPartIdToDataKey(streamPartId), dataToStore)
-            this.keepSelfAsEntryPoint(streamPartId)
+            await this.config.storeEntryPointData(streamPartIdToDataKey(this.config.streamPartId), dataToStore)
         } catch (err) {
-            logger.warn(`Failed to store self as entrypoint for ${streamPartId}`)
+            logger.warn(`Failed to store self as entrypoint for ${this.config.streamPartId}`)
         }
     }
 
-    private keepSelfAsEntryPoint(streamPartId: StreamPartID): void {
-        if (!this.config.streamParts.has(streamPartId) || this.servicedStreamParts.has(streamPartId)) {
-            return
-        }
-        this.servicedStreamParts.set(streamPartId, setTimeout(async () => {
-            if (!this.config.streamParts.has(streamPartId)) {
-                this.servicedStreamParts.delete(streamPartId)
-                return
-            }
-            logger.trace(`Attempting to keep self as entrypoint for ${streamPartId}`)
+    private async keepSelfAsEntryPoint(): Promise<void> {
+        await scheduleAtInterval(async () => {
+            logger.trace(`Attempting to keep self as entrypoint for ${this.config.streamPartId}`)
             try {
-                const discovered = await this.discoverEntryPoints(streamPartId)
+                const discovered = await this.discoverEntryPoints()
                 if (discovered.length < ENTRYPOINT_STORE_LIMIT 
                     || discovered.some((peerDescriptor) => isSamePeerDescriptor(peerDescriptor, this.config.ownPeerDescriptor))) {
-                    await this.storeSelfAsEntryPoint(streamPartId)
-                    this.servicedStreamParts.delete(streamPartId)
-                    this.keepSelfAsEntryPoint(streamPartId)
-                } else {
-                    this.servicedStreamParts.delete(streamPartId)
+                    await this.storeSelfAsEntryPoint()
                 }
             } catch (err) {
-                logger.debug(`Failed to keep self as entrypoint for ${streamPartId}`)
+                logger.debug(`Failed to keep self as entrypoint for ${this.config.streamPartId}`)
             }
-        }, this.cacheInterval))
+        }, this.cacheInterval, false, this.abortController.signal)
     }
 
-    private async avoidNetworkSplit(streamPartId: StreamPartID): Promise<void> {
+    private async avoidNetworkSplit(): Promise<void> {
         await exponentialRunOff(async () => {
-            if (this.config.streamParts.has(streamPartId)) {
-                const stream = this.config.streamParts.get(streamPartId)! as { layer1: ILayer1 }
-                const rediscoveredEntrypoints = await this.discoverEntryPoints(streamPartId)
-                await stream.layer1!.joinDht(rediscoveredEntrypoints, false, false)
-                if (stream.layer1!.getBucketSize() < NETWORK_SPLIT_AVOIDANCE_LIMIT) {
-                    // Filter out nodes that are not in the k-bucket, assumed to be offline
-                    const nodesToAvoid = rediscoveredEntrypoints.filter((peer) => !stream.layer1!.getKBucketPeers().includes(peer))
-                    this.addAvoidedNodes(streamPartId, nodesToAvoid)
-                    throw new Error(`Network split is still possible`)
-                }
+            const rediscoveredEntrypoints = await this.discoverEntryPoints()
+            await this.config.layer1.joinDht(rediscoveredEntrypoints, false, false)
+            if (this.config.layer1!.getBucketSize() < NETWORK_SPLIT_AVOIDANCE_LIMIT) {
+                // Filter out nodes that are not in the k-bucket, assumed to be offline
+                const nodesToAvoid = rediscoveredEntrypoints
+                    .filter((peer) => !this.config.layer1!.getKBucketPeers().includes(peer))
+                    .map((peer) => getNodeIdFromPeerDescriptor(peer))
+                nodesToAvoid.forEach((node) => this.networkSplitAvoidedNodes.add(node))
+                throw new Error(`Network split is still possible`)
             }
         }, 'avoid network split', this.abortController.signal)
-        this.networkSplitAvoidedNodes.delete(streamPartId)
+        this.networkSplitAvoidedNodes.clear()
         logger.trace(`Network split avoided`)
     }
 
-    private addAvoidedNodes(streamPartId: StreamPartID, nodesToAvoid: PeerDescriptor[]): void {
-        if (!this.networkSplitAvoidedNodes.has(streamPartId)) {
-            this.networkSplitAvoidedNodes.set(streamPartId, new Set())
-        }
-        nodesToAvoid.forEach((node) => this.networkSplitAvoidedNodes.get(streamPartId)!.add(getNodeIdFromPeerDescriptor(node)))
-    }
-
-    removeSelfAsEntryPoint(streamPartId: StreamPartID): void {
-        if (this.servicedStreamParts.has(streamPartId)) {
-            setAbortableTimeout(() => this.config.deleteEntryPointData(streamPartIdToDataKey(streamPartId)), 0, this.abortController.signal)
-            clearTimeout(this.servicedStreamParts.get(streamPartId))
-            this.servicedStreamParts.delete(streamPartId)
-        }
-    }
-
     async destroy(): Promise<void> {
-        this.servicedStreamParts.forEach((_, streamPartId) => this.removeSelfAsEntryPoint(streamPartId))
-        this.servicedStreamParts.clear()
         this.abortController.abort()
+        await this.config.deleteEntryPointData(streamPartIdToDataKey(this.config.streamPartId))
     }
-
 }

package/src/logic/StreamrNode.ts

@@ -31,6 +31,7 @@ export type StreamPartDelivery = {
     proxied: false
     layer1: ILayer1
     node: RandomGraphNode
+    entryPointDiscovery: StreamPartEntryPointDiscovery
 } | {
     proxied: true
     client: ProxyStreamConnectionClient
@@ -63,7 +64,6 @@ export class StreamrNode extends EventEmitter<Events> {
     private P2PTransport?: ITransport
     private connectionLocker?: ConnectionLocker
     private layer0?: ILayer0
-    private streamPartEntryPointDiscovery?: StreamPartEntryPointDiscovery
     private readonly metricsContext: MetricsContext
     private readonly metrics: Metrics
     public config: StreamrNodeConfig
@@ -93,14 +93,6 @@ export class StreamrNode extends EventEmitter<Events> {
         this.layer0 = startedAndJoinedLayer0
         this.P2PTransport = transport
         this.connectionLocker = connectionLocker
-        this.streamPartEntryPointDiscovery = new StreamPartEntryPointDiscovery({
-            ownPeerDescriptor: this.getPeerDescriptor(),
-            streamParts: this.streamParts,
-            getEntryPointData: (key) => this.layer0!.getDataFromDht(key),
-            getEntryPointDataViaNode: (key, node) => this.layer0!.findDataViaPeer(key, node),
-            storeEntryPointData: (key, data) => this.layer0!.storeDataToDht(key, data),
-            deleteEntryPointData: (key) => this.layer0!.deleteDataFromDht(key)
-        })
         cleanUp = () => this.destroy()
     }
 
@@ -111,14 +103,12 @@ export class StreamrNode extends EventEmitter<Events> {
         logger.trace('Destroying StreamrNode...')
         this.destroyed = true
         this.streamParts.forEach((stream) => stream.stop())
-        await this.streamPartEntryPointDiscovery!.destroy()
         this.streamParts.clear()
         this.removeAllListeners()
         await this.layer0!.stop()
         await this.P2PTransport!.stop()
         this.layer0 = undefined
         this.P2PTransport = undefined
-        this.streamPartEntryPointDiscovery = undefined
         this.connectionLocker = undefined
     }
 
@@ -136,7 +126,6 @@ export class StreamrNode extends EventEmitter<Events> {
             stream.stop()
             this.streamParts.delete(streamPartId)
         }
-        this.streamPartEntryPointDiscovery!.removeSelfAsEntryPoint(streamPartId)
     }
 
     joinStreamPart(streamPartId: StreamPartID): void {
@@ -147,12 +136,28 @@ export class StreamrNode extends EventEmitter<Events> {
         }
         const layer1 = this.createLayer1Node(streamPartId, this.knownStreamPartEntryPoints.get(streamPartId) ?? [])
         const node = this.createRandomGraphNode(streamPartId, layer1)
+        const entryPointDiscovery = new StreamPartEntryPointDiscovery({
+            streamPartId,
+            ownPeerDescriptor: this.getPeerDescriptor(),
+            layer1,
+            getEntryPointData: (key) => this.layer0!.getDataFromDht(key),
+            getEntryPointDataViaNode: (key, node) => this.layer0!.findDataViaPeer(key, node),
+            storeEntryPointData: (key, data) => this.layer0!.storeDataToDht(key, data),
+            deleteEntryPointData: async (key) => {
+                if (this.destroyed) {
+                    return 
+                }
+                return this.layer0!.deleteDataFromDht(key)
+            }
+        })
         stream = {
             proxied: false,
             layer1,
             node,
+            entryPointDiscovery,
             broadcast: (msg: StreamMessage) => node.broadcast(msg),
             stop: () => {
+                entryPointDiscovery.destroy()
                 node.stop()
                 layer1.stop()
             }
@@ -163,14 +168,14 @@ export class StreamrNode extends EventEmitter<Events> {
         })
         setImmediate(async () => {
             try {
-                await this.startLayersAndJoinDht(streamPartId)
+                await this.startLayersAndJoinDht(streamPartId, entryPointDiscovery)
             } catch (err) {
                 logger.warn(`Failed to join to stream ${streamPartId} with error: ${err}`)
             }
         })
     }
 
-    private async startLayersAndJoinDht(streamPartId: StreamPartID): Promise<void> {
+    private async startLayersAndJoinDht(streamPartId: StreamPartID, entryPointDiscovery: StreamPartEntryPointDiscovery): Promise<void> {
         logger.debug(`Start layers and join DHT for stream part ${streamPartId}`)
         const stream = this.streamParts.get(streamPartId)
         if ((stream === undefined) || stream.proxied) {
@@ -181,18 +186,15 @@ export class StreamrNode extends EventEmitter<Events> {
         await stream.node.start()
         let entryPoints = this.knownStreamPartEntryPoints.get(streamPartId) ?? []
         const forwardingNode = this.layer0!.isJoinOngoing() ? this.layer0!.getKnownEntryPoints()[0] : undefined
-        const discoveryResult = await this.streamPartEntryPointDiscovery!.discoverEntryPointsFromDht(
-            streamPartId,
+        const discoveryResult = await entryPointDiscovery.discoverEntryPointsFromDht(
             entryPoints.length,
             forwardingNode
         )
         entryPoints = entryPoints.concat(discoveryResult.discoveredEntryPoints)
         await stream.layer1.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_LIMIT))
-        await this.streamPartEntryPointDiscovery!.storeSelfAsEntryPointIfNecessary(
-            streamPartId,
-            discoveryResult.entryPointsFromDht,
-            entryPoints.length
-        )
+        if (discoveryResult.entryPointsFromDht) {
+            await entryPointDiscovery.storeSelfAsEntryPointIfNecessary(entryPoints.length)
+        }
     }
 
     private createLayer1Node = (streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): ILayer1 => {

package/src/logic/createRandomGraphNode.ts

@@ -45,7 +45,7 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const propagation = config.propagation ?? new Propagation({
         minPropagationTargets,
         sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
-            const remote = targetNeighbors.getNeighborById(neighborId) ?? temporaryConnectionServer.getNodes().getNeighborById(neighborId)
+            const remote = targetNeighbors.get(neighborId) ?? temporaryConnectionServer.getNodes().get(neighborId)
             const proxyConnection = proxyConnectionServer?.getConnection(neighborId)
             if (remote) {
                 await remote.sendStreamMessage(msg)

package/src/logic/neighbor-discovery/NeighborFinder.ts

@@ -9,8 +9,8 @@ interface FindNeighborsSessionConfig {
     N: number
 }
 
-const INITIAL_TIMEOUT = 100
-const INTERVAL_TIMEOUT = 250
+const INITIAL_WAIT = 100
+const INTERVAL = 250
 
 export interface INeighborFinder {
     start(excluded?: NodeID[]): void
@@ -34,7 +34,7 @@ export class NeighborFinder implements INeighborFinder {
         }
         const newExcludes = await this.config.doFindNeighbors(excluded)
         if (this.config.targetNeighbors.size() < this.config.N && newExcludes.length < this.config.nearbyNodeView.size()) {
-            setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL_TIMEOUT, this.abortController.signal)
+            setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL, this.abortController.signal)
         } else {
             this.running = false
         }
@@ -49,7 +49,7 @@ export class NeighborFinder implements INeighborFinder {
             return
         }
         this.running = true
-        setAbortableTimeout(() => this.findNeighbors(excluded), INITIAL_TIMEOUT, this.abortController.signal)
+        setAbortableTimeout(() => this.findNeighbors(excluded), INITIAL_WAIT, this.abortController.signal)
     }
 
     stop(): void {

package/src/logic/neighbor-discovery/NeighborUpdateManager.ts

@@ -50,8 +50,8 @@ export class NeighborUpdateManager implements INeighborUpdateManager {
 
     private async updateNeighborInfo(): Promise<void> {
         logger.trace(`Updating neighbor info to nodes`)
-        const neighborDescriptors = this.config.targetNeighbors.getNodes().map((neighbor) => neighbor.getPeerDescriptor())
-        await Promise.allSettled(this.config.targetNeighbors.getNodes().map(async (neighbor) => {
+        const neighborDescriptors = this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
+        await Promise.allSettled(this.config.targetNeighbors.getAll().map(async (neighbor) => {
             const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(neighborDescriptors)
             if (res.removeMe) {
                 this.config.targetNeighbors.remove(neighbor.getPeerDescriptor())

package/src/logic/neighbor-discovery/NeighborUpdateManagerServer.ts

@@ -49,14 +49,14 @@ export class NeighborUpdateManagerServer implements INeighborUpdateRpc {
             this.config.neighborFinder.start()
             const response: NeighborUpdate = {
                 randomGraphId: this.config.randomGraphId,
-                neighborDescriptors: this.config.targetNeighbors.getNodes().map((neighbor) => neighbor.getPeerDescriptor()),
+                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
                 removeMe: false
             }
             return response
         } else {
             const response: NeighborUpdate = {
                 randomGraphId: this.config.randomGraphId,
-                neighborDescriptors: this.config.targetNeighbors.getNodes().map((neighbor) => neighbor.getPeerDescriptor()),
+                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
                 removeMe: true
             }
             return response

package/src/logic/proxy/ProxyStreamConnectionClient.ts

@@ -83,7 +83,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
             broadcast: (message: StreamMessage, previousNode?: NodeID) => this.broadcast(message, previousNode),
             onLeaveNotice: (senderId: NodeID) => {
-                const contact = this.targetNeighbors.getNeighborById(senderId)
+                const contact = this.targetNeighbors.get(senderId)
                 if (contact) {
                     setImmediate(() => this.onNodeDisconnected(contact.getPeerDescriptor()))
                 }
@@ -94,7 +94,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
         this.propagation = new Propagation({
             minPropagationTargets: config.minPropagationTargets ?? 2,
             sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
-                const remote = this.targetNeighbors.getNeighborById(neighborId)
+                const remote = this.targetNeighbors.get(neighborId)
                 if (remote) {
                     await remote.sendStreamMessage(msg)
                 } else {
@@ -202,7 +202,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
             logger.info('Close proxy connection', {
                 nodeId
             })
-            const server = this.targetNeighbors.getNeighborById(nodeId)
+            const server = this.targetNeighbors.get(nodeId)
             server?.leaveStreamPartNotice()
             this.removeConnection(nodeId)
         }
@@ -221,11 +221,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
         this.propagation.feedUnseenMessage(msg, this.targetNeighbors.getIds(), previousNode ?? null)
     }
 
-    getTargetNeighborIds(): NodeID[] {
-        return this.targetNeighbors.getIds()
-    }
-
-    hasProxyConnection(nodeId: NodeID, direction: ProxyDirection): boolean {
+    hasConnection(nodeId: NodeID, direction: ProxyDirection): boolean {
         return this.connections.has(nodeId) && this.connections.get(nodeId) === direction
     }
 
@@ -233,7 +229,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
         return this.definition!.direction
     }
 
-    async onNodeDisconnected(peerDescriptor: PeerDescriptor): Promise<void> {
+    private async onNodeDisconnected(peerDescriptor: PeerDescriptor): Promise<void> {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         if (this.connections.has(nodeId)) {
             this.config.connectionLocker.unlockConnection(peerDescriptor, 'proxy-stream-connection-client')
@@ -253,7 +249,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
     }
 
     stop(): void {
-        this.targetNeighbors.getNodes().map((remote) => {
+        this.targetNeighbors.getAll().map((remote) => {
             this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), 'proxy-stream-connection-client')
             remote.leaveStreamPartNotice()
         })

package/src/logic/proxy/ProxyStreamConnectionServer.ts

@@ -66,14 +66,6 @@ export class ProxyStreamConnectionServer extends EventEmitter<Events> implements
         this.removeAllListeners()
     }
 
-    getConnectedNodeIds(): NodeID[] {
-        return Array.from(this.connections.keys())
-    }
-
-    getConnections(): ProxyConnection[] {
-        return Array.from(this.connections.values())
-    }
-
     getPropagationTargets(msg: StreamMessage): NodeID[] {
         if (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST) {
             try {

package/test/end-to-end/proxy-connections.test.ts

@@ -42,7 +42,7 @@ describe('Proxy connections', () => {
     
     const hasConnectionToProxy = (proxyNodeId: NodeID, direction: ProxyDirection): boolean => {
         const client = (proxiedNode.stack.getStreamrNode()!.getStream(STREAM_PART_ID) as { client: ProxyStreamConnectionClient }).client
-        return client.hasProxyConnection(proxyNodeId, direction)
+        return client.hasConnection(proxyNodeId, direction)
     }
 
     beforeEach(async () => {

package/test/end-to-end/websocket-full-node-network.test.ts

@@ -60,7 +60,7 @@ describe('Full node network with WebSocket connections only', () => {
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
             waitForCondition(() => {
-                return node.getStreamrNode()!.getNeighbors(randomGraphId).length >= 3
+                return node.getStreamrNode()!.getNeighbors(randomGraphId).length >= 4
             }
             , 120000)
         ))

package/test/unit/RandomGraphNode.test.ts

@@ -68,8 +68,8 @@ describe('RandomGraphNode', () => {
         const peerDescriptor2 = createMockPeerDescriptor()
         layer1.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => nearbyNodeView.size() === 2)
-        expect(nearbyNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
+        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
     })
 
     it('Adds Random Nodes from layer1 newRandomContact event to randomNodeView', async () => {
@@ -77,8 +77,8 @@ describe('RandomGraphNode', () => {
         const peerDescriptor2 = createMockPeerDescriptor()
         layer1.emit('newRandomContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => randomNodeView.size() === 2)
-        expect(randomNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(randomNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
+        expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
     })
 
     it('Adds Nodes from layer1 KBucket to nearbyNodeView if its size is below nodeViewSize', async () => {
@@ -87,8 +87,8 @@ describe('RandomGraphNode', () => {
         layer1.addNewRandomPeerToKBucket()
         layer1.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => nearbyNodeView.size() === 3)
-        expect(nearbyNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.getNeighborById(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
+        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
     })
 
 })