@streamr/trackerless-network 100.0.0-testnet-two.3 → 100.0.0-testnet-three.0

package/src/exports.ts

@@ -2,3 +2,7 @@ export { NetworkStack, NetworkOptions } from './NetworkStack'
 export { NetworkNode, createNetworkNode } from './NetworkNode'
 export { StreamrNodeConfig } from './logic/StreamrNode'
 export { ProxyDirection } from './proto/packages/trackerless-network/protos/NetworkRpc'
+export {
+    convertStreamMessageToBytes,
+    convertBytesToStreamMessage
+} from './logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils'

package/src/logic/DuplicateMessageDetector.ts

@@ -82,11 +82,11 @@ export class GapMisMatchError extends Error {
  *
  */
 export class DuplicateMessageDetector {
-    private readonly maxNumberOfGaps: number
+    private readonly maxGapCount: number
     private readonly gaps: Array<[NumberPair, NumberPair]>
 
-    constructor(maxNumberOfGaps = 10000) {
-        this.maxNumberOfGaps = maxNumberOfGaps
+    constructor(maxGapCount = 10000) {
+        this.maxGapCount = maxGapCount
         this.gaps = [] // ascending order of half-closed intervals (x,y] representing gaps that contain unseen message(s)
     }
 
@@ -144,7 +144,7 @@ export class DuplicateMessageDetector {
                 //   - last gap is [n, Infinity]
                 //   - anything not covered by a gap is considered seen
 
-                this.dropLowestGapIfOverMaxNumberOfGaps()
+                this.dropLowestGapIfOverMaxGapCount()
                 return true
             }
             if (number.greaterThan(lowerBound)) {
@@ -154,9 +154,9 @@ export class DuplicateMessageDetector {
         return false
     }
 
-    private dropLowestGapIfOverMaxNumberOfGaps(): void {
-        // invariant: this.gaps.length <= this.maxNumberOfGaps + 1
-        if (this.gaps.length > this.maxNumberOfGaps) {
+    private dropLowestGapIfOverMaxGapCount(): void {
+        // invariant: this.gaps.length <= this.maxGapCount + 1
+        if (this.gaps.length > this.maxGapCount) {
             this.gaps.shift()
         }
     }

package/src/logic/EntryPointDiscovery.ts

@@ -122,7 +122,7 @@ export class EntryPointDiscovery {
         if (this.abortController.signal.aborted) {
             return
         }
-        const possibleNetworkSplitDetected = this.config.layer1Node.getNumberOfNeighbors() < NETWORK_SPLIT_AVOIDANCE_LIMIT
+        const possibleNetworkSplitDetected = this.config.layer1Node.getNeighborCount() < NETWORK_SPLIT_AVOIDANCE_LIMIT
         if ((currentEntrypointCount < ENTRYPOINT_STORE_LIMIT) || possibleNetworkSplitDetected) {
             this.isLocalNodeStoredAsEntryPoint = true
             await this.storeSelfAsEntryPoint()
@@ -163,10 +163,10 @@ export class EntryPointDiscovery {
         await exponentialRunOff(async () => {
             const rediscoveredEntrypoints = await this.discoverEntryPoints()
             await this.config.layer1Node.joinDht(rediscoveredEntrypoints, false, false)
-            if (this.config.layer1Node.getNumberOfNeighbors() < NETWORK_SPLIT_AVOIDANCE_LIMIT) {
+            if (this.config.layer1Node.getNeighborCount() < NETWORK_SPLIT_AVOIDANCE_LIMIT) {
                 // Filter out nodes that are not neighbors as those nodes are assumed to be offline
                 const nodesToAvoid = rediscoveredEntrypoints
-                    .filter((peer) => !this.config.layer1Node.getAllNeighborPeerDescriptors()
+                    .filter((peer) => !this.config.layer1Node.getNeighbors()
                         .some((neighbor) => areEqualPeerDescriptors(neighbor, peer)))
                     .map((peer) => getNodeIdFromPeerDescriptor(peer))
                 nodesToAvoid.forEach((node) => this.networkSplitAvoidedNodes.add(node))

package/src/logic/Layer0Node.ts

@@ -10,6 +10,8 @@ export interface Layer0Node extends ITransport {
     deleteDataFromDht(key: DhtAddress, waitForCompletion: boolean): Promise<void>
     waitForNetworkConnectivity(): Promise<void>
     getTransport(): ITransport
+    getNeighbors(): PeerDescriptor[]
+    getConnections(): PeerDescriptor[]
     start(): Promise<void>
     stop(): Promise<void>
 }

package/src/logic/Layer1Node.ts

@@ -1,4 +1,4 @@
-import { PeerDescriptor } from '@streamr/dht'
+import { DhtAddress, PeerDescriptor } from '@streamr/dht'
 
 export interface Layer1NodeEvents {
     newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
@@ -11,10 +11,10 @@ export interface Layer1Node {
     on<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
     once<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
     off<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
-    removeContact: (peerDescriptor: PeerDescriptor) => void
+    removeContact: (nodeId: DhtAddress) => void
     getClosestContacts: (maxCount?: number) => PeerDescriptor[]
-    getAllNeighborPeerDescriptors: () => PeerDescriptor[]
-    getNumberOfNeighbors(): number
+    getNeighbors: () => PeerDescriptor[]
+    getNeighborCount(): number
     joinDht: (entryPoints: PeerDescriptor[], doRandomJoin?: boolean, retry?: boolean) => Promise<void>
     start: () => Promise<void>
     stop: () => Promise<void>

package/src/logic/NodeList.ts

@@ -1,4 +1,4 @@
-import { DhtAddress, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { sample } from 'lodash'
 import { DeliveryRpcRemote } from './DeliveryRpcRemote'
 import { EventEmitter } from 'eventemitter3'
@@ -13,6 +13,8 @@ const getValuesOfIncludedKeys = (nodes: Map<DhtAddress, DeliveryRpcRemote>, excl
         .map(([_id, node]) => node)
 }
 
+// The items in the list are in the insertion order
+
 export class NodeList extends EventEmitter<Events> {
     private readonly nodes: Map<DhtAddress, DeliveryRpcRemote>
     private readonly limit: number
@@ -37,19 +39,11 @@ export class NodeList extends EventEmitter<Events> {
         }
     }
 
-    remove(peerDescriptor: PeerDescriptor): void {
-        this.nodes.delete(getNodeIdFromPeerDescriptor(peerDescriptor))
-    }
-
-    removeById(nodeId: DhtAddress): void {
+    remove(nodeId: DhtAddress): void {
         this.nodes.delete(nodeId)
     }
 
-    hasNode(peerDescriptor: PeerDescriptor): boolean {
-        return this.nodes.has(getNodeIdFromPeerDescriptor(peerDescriptor))
-    }
-
-    hasNodeById(nodeId: DhtAddress): boolean {
+    has(nodeId: DhtAddress): boolean {
         return this.nodes.has(nodeId)
     }
 
@@ -77,20 +71,20 @@ export class NodeList extends EventEmitter<Events> {
         return sample(getValuesOfIncludedKeys(this.nodes, exclude))
     }
 
-    getClosest(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
+    getFirst(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[0]
     }
 
-    getClosestAndFurthest(exclude: DhtAddress[]): DeliveryRpcRemote[] {
+    getFirstAndLast(exclude: DhtAddress[]): DeliveryRpcRemote[] {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         if (included.length === 0) {
             return []
         }
-        return included.length > 1 ? [this.getClosest(exclude)!, this.getFurthest(exclude)!] : [this.getClosest(exclude)!]
+        return included.length > 1 ? [this.getFirst(exclude)!, this.getLast(exclude)!] : [this.getFirst(exclude)!]
     }
 
-    getFurthest(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
+    getLast(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[included.length - 1]
     }

package/src/logic/RandomGraphNode.ts

@@ -36,7 +36,7 @@ import { uniqBy } from 'lodash'
 
 export interface Events {
     message: (message: StreamMessage) => void
-    targetNeighborConnected: (nodeId: DhtAddress) => void
+    neighborConnected: (nodeId: DhtAddress) => void
     entryPointLeaveDetected: () => void
 }
 
@@ -49,13 +49,13 @@ export interface StrictRandomGraphNodeConfig {
     nodeViewSize: number
     nearbyNodeView: NodeList
     randomNodeView: NodeList
-    targetNeighbors: NodeList
+    neighbors: NodeList
     handshaker: Handshaker
     neighborFinder: NeighborFinder
     neighborUpdateManager: NeighborUpdateManager
     propagation: Propagation
     rpcCommunicator: ListeningRpcCommunicator
-    numOfTargetNeighbors: number
+    neighborCount: number
     inspector: Inspector
     temporaryConnectionRpcLocal: TemporaryConnectionRpcLocal
     isLocalNodeEntryPoint: () => boolean
@@ -90,13 +90,13 @@ export class RandomGraphNode extends EventEmitter<Events> {
                 }
                 const contact = this.config.nearbyNodeView.get(sourceId)
                 || this.config.randomNodeView.get(sourceId)
-                || this.config.targetNeighbors.get(sourceId)
+                || this.config.neighbors.get(sourceId)
                 || this.config.proxyConnectionRpcLocal?.getConnection(sourceId )?.remote
                 // TODO: check integrity of notifier?
                 if (contact) {
-                    this.config.layer1Node.removeContact(contact.getPeerDescriptor())
-                    this.config.targetNeighbors.remove(contact.getPeerDescriptor())
-                    this.config.nearbyNodeView.remove(contact.getPeerDescriptor())
+                    this.config.layer1Node.removeContact(sourceId)
+                    this.config.neighbors.remove(sourceId)
+                    this.config.nearbyNodeView.remove(sourceId)
                     this.config.connectionLocker.unlockConnection(contact.getPeerDescriptor(), this.config.streamPartId)
                     this.config.neighborFinder.start([sourceId])
                     this.config.proxyConnectionRpcLocal?.removeConnection(sourceId)
@@ -143,11 +143,11 @@ export class RandomGraphNode extends EventEmitter<Events> {
             this.abortController.signal
         )
         addManagedEventListener(
-            this.config.targetNeighbors,
+            this.config.neighbors,
             'nodeAdded',
             (id, _remote) => {
                 this.config.propagation.onNeighborJoined(id)
-                this.emit('targetNeighborConnected', id)
+                this.emit('neighborConnected', id)
             },
             this.abortController.signal
         )
@@ -182,7 +182,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
             return
         }
         this.updateNearbyNodeView(closestNodes)
-        if (this.config.targetNeighbors.size() < this.config.numOfTargetNeighbors) {
+        if (this.config.neighbors.size() < this.config.neighborCount) {
             this.config.neighborFinder.start()
         }
     }
@@ -205,7 +205,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
                 this.config.rpcRequestTimeout
             )
         ))
-        for (const descriptor of this.config.layer1Node.getAllNeighborPeerDescriptors()) {
+        for (const descriptor of this.config.layer1Node.getNeighbors()) {
             if (this.config.nearbyNodeView.size() >= this.config.nodeViewSize) {
                 break
             }
@@ -235,7 +235,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
                 this.config.rpcRequestTimeout
             )
         ))
-        if (this.config.targetNeighbors.size() < this.config.numOfTargetNeighbors) {
+        if (this.config.neighbors.size() < this.config.neighborCount) {
             this.config.neighborFinder.start()
         }
     }
@@ -257,11 +257,12 @@ export class RandomGraphNode extends EventEmitter<Events> {
     }
 
     private onNodeDisconnected(peerDescriptor: PeerDescriptor): void {
-        if (this.config.targetNeighbors.hasNode(peerDescriptor)) {
-            this.config.targetNeighbors.remove(peerDescriptor)
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        if (this.config.neighbors.has(nodeId)) {
+            this.config.neighbors.remove(nodeId)
             this.config.connectionLocker.unlockConnection(peerDescriptor, this.config.streamPartId)
-            this.config.neighborFinder.start([getNodeIdFromPeerDescriptor(peerDescriptor)])
-            this.config.temporaryConnectionRpcLocal.removeNode(peerDescriptor)
+            this.config.neighborFinder.start([nodeId])
+            this.config.temporaryConnectionRpcLocal.removeNode(nodeId)
         }
     }
 
@@ -270,7 +271,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
         this.config.layer1Node.getClosestContacts(this.config.nodeViewSize).forEach((peer: PeerDescriptor) => {
             nodes.push(peer)
         })
-        this.config.layer1Node.getAllNeighborPeerDescriptors().forEach((peer: PeerDescriptor) => {
+        this.config.layer1Node.getNeighbors().forEach((peer: PeerDescriptor) => {
             nodes.push(peer)
         })
         return uniqBy(nodes, (p) => getNodeIdFromPeerDescriptor(p))
@@ -289,13 +290,13 @@ export class RandomGraphNode extends EventEmitter<Events> {
         }
         this.abortController.abort()
         this.config.proxyConnectionRpcLocal?.stop()
-        this.config.targetNeighbors.getAll().map(
+        this.config.neighbors.getAll().map(
             (remote) => remote.leaveStreamPartNotice(this.config.streamPartId, this.config.isLocalNodeEntryPoint())
         )
         this.config.rpcCommunicator.destroy()
         this.removeAllListeners()
         this.config.nearbyNodeView.stop()
-        this.config.targetNeighbors.stop()
+        this.config.neighbors.stop()
         this.config.randomNodeView.stop()
         this.config.neighborFinder.stop()
         this.config.neighborUpdateManager.stop()
@@ -315,7 +316,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
     }
 
     private getPropagationTargets(msg: StreamMessage): DhtAddress[] {
-        let propagationTargets = this.config.targetNeighbors.getIds()
+        let propagationTargets = this.config.neighbors.getIds()
         if (this.config.proxyConnectionRpcLocal) {
             propagationTargets = propagationTargets.concat(this.config.proxyConnectionRpcLocal.getPropagationTargets(msg))
         }
@@ -328,15 +329,15 @@ export class RandomGraphNode extends EventEmitter<Events> {
         return getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
     }
 
-    getNumberOfOutgoingHandshakes(): number {
+    getOutgoingHandshakeCount(): number {
         return this.config.handshaker.getOngoingHandshakes().size
     }
 
-    getTargetNeighborIds(): DhtAddress[] {
+    getNeighbors(): PeerDescriptor[] {
         if (!this.started && this.isStopped()) {
             return []
         }
-        return this.config.targetNeighbors.getIds()
+        return this.config.neighbors.getAll().map((n) => n.getPeerDescriptor())
     }
 
     getNearbyNodeView(): NodeList {

package/src/logic/StreamrNode.ts

@@ -18,7 +18,7 @@ import {
 } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
-import { ProxyDirection, StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyDirection, StreamPartitionInfo, StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { Layer0Node } from './Layer0Node'
 import { Layer1Node } from './Layer1Node'
 import { RandomGraphNode } from './RandomGraphNode'
@@ -52,7 +52,7 @@ interface Metrics extends MetricsDefinition {
 
 export interface StreamrNodeConfig {
     metricsContext?: MetricsContext
-    streamPartitionNumOfNeighbors?: number
+    streamPartitionNeighborCount?: number
     streamPartitionMinPropagationTargets?: number
     acceptProxyConnections?: boolean
     rpcRequestTimeout?: number
@@ -222,7 +222,7 @@ export class StreamrNode extends EventEmitter<Events> {
             connectionLocker: this.connectionLocker!,
             localPeerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
             minPropagationTargets: this.config.streamPartitionMinPropagationTargets,
-            numOfTargetNeighbors: this.config.streamPartitionNumOfNeighbors,
+            neighborCount: this.config.streamPartitionNeighborCount,
             acceptProxyConnections: this.config.acceptProxyConnections,
             rpcRequestTimeout: this.config.rpcRequestTimeout,
             isLocalNodeEntryPoint
@@ -284,6 +284,20 @@ export class StreamrNode extends EventEmitter<Events> {
         return false
     }
 
+    // TODO inline this method?
+    getNodeInfo(): StreamPartitionInfo[] {
+        const streamParts = Array.from(this.streamParts.entries()).filter(([_, node]) => node.proxied === false)
+        return streamParts.map(([streamPartId]) => {
+            const stream = this.streamParts.get(streamPartId)! as { node: RandomGraphNode, layer1Node: Layer1Node }
+            return {
+                id: streamPartId,
+                controlLayerNeighbors: stream.layer1Node.getNeighbors(),
+                deliveryLayerNeighbors: stream.node.getNeighbors()
+            }
+        })
+
+    }
+
     setStreamPartEntryPoints(streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): void {
         this.knownStreamPartEntryPoints.set(streamPartId, entryPoints)
     }
@@ -314,7 +328,7 @@ export class StreamrNode extends EventEmitter<Events> {
     getNeighbors(streamPartId: StreamPartID): DhtAddress[] {
         const streamPart = this.streamParts.get(streamPartId)
         return (streamPart !== undefined) && (streamPart.proxied === false)
-            ? streamPart.node.getTargetNeighborIds()
+            ? streamPart.node.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
             : []
     }
 

package/src/logic/createRandomGraphNode.ts

@@ -13,11 +13,11 @@ import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryCon
 import { formStreamPartDeliveryServiceId } from './formStreamPartDeliveryServiceId'
 
 type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
-    'nearbyNodeView' | 'randomNodeView' | 'targetNeighbors' | 'propagation'
-    | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'numOfTargetNeighbors'
+    'nearbyNodeView' | 'randomNodeView' | 'neighbors' | 'propagation'
+    | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'neighborCount'
     | 'rpcCommunicator' | 'nodeViewSize'
     | 'inspector' | 'temporaryConnectionRpcLocal'> & {
-        maxNumberOfContacts?: number
+        maxContactCount?: number
         minPropagationTargets?: number
         acceptProxyConnections?: boolean
         neighborUpdateInterval?: number
@@ -29,14 +29,14 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
         formStreamPartDeliveryServiceId(config.streamPartId),
         config.transport
     )
-    const numOfTargetNeighbors = config.numOfTargetNeighbors ?? 4
-    const maxNumberOfContacts = config.maxNumberOfContacts ?? 20
+    const neighborCount = config.neighborCount ?? 4
+    const maxContactCount = config.maxContactCount ?? 20
     const minPropagationTargets = config.minPropagationTargets ?? 2
     const acceptProxyConnections = config.acceptProxyConnections ?? false
     const neighborUpdateInterval = config.neighborUpdateInterval ?? 10000
-    const nearbyNodeView = config.nearbyNodeView ?? new NodeList(ownNodeId, numOfTargetNeighbors + 1)
-    const randomNodeView = config.randomNodeView ?? new NodeList(ownNodeId, maxNumberOfContacts)
-    const targetNeighbors = config.targetNeighbors ?? new NodeList(ownNodeId, maxNumberOfContacts)
+    const nearbyNodeView = config.nearbyNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const randomNodeView = config.randomNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const neighbors = config.neighbors ?? new NodeList(ownNodeId, maxContactCount)
 
     const temporaryConnectionRpcLocal = new TemporaryConnectionRpcLocal({
         rpcCommunicator,
@@ -50,7 +50,7 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const propagation = config.propagation ?? new Propagation({
         minPropagationTargets,
         sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
-            const remote = targetNeighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId)
+            const remote = neighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId)
             const proxyConnection = proxyConnectionRpcLocal?.getConnection(neighborId)
             if (remote) {
                 await remote.sendStreamMessage(msg)
@@ -68,18 +68,18 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
         rpcCommunicator,
         nearbyNodeView,
         randomNodeView,
-        targetNeighbors,
-        maxNeighborCount: numOfTargetNeighbors,
+        neighbors,
+        maxNeighborCount: neighborCount,
         rpcRequestTimeout: config.rpcRequestTimeout
     })
     const neighborFinder = config.neighborFinder ?? new NeighborFinder({
-        targetNeighbors,
+        neighbors,
         nearbyNodeView,
         doFindNeighbors: (excludedIds) => handshaker.attemptHandshakesOnContacts(excludedIds),
-        minCount: numOfTargetNeighbors
+        minCount: neighborCount
     })
     const neighborUpdateManager = config.neighborUpdateManager ?? new NeighborUpdateManager({
-        targetNeighbors,
+        neighbors,
         nearbyNodeView,
         localPeerDescriptor: config.localPeerDescriptor,
         neighborFinder,
@@ -97,14 +97,14 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
         ...config,
         nearbyNodeView,
         randomNodeView,
-        targetNeighbors,
+        neighbors,
         rpcCommunicator,
         handshaker,
         neighborFinder,
         neighborUpdateManager,
         propagation,
-        numOfTargetNeighbors,
-        nodeViewSize: maxNumberOfContacts,
+        neighborCount,
+        nodeViewSize: maxContactCount,
         proxyConnectionRpcLocal,
         inspector,
         temporaryConnectionRpcLocal

package/src/logic/inspect/Inspector.ts

@@ -1,8 +1,7 @@
-import { PeerDescriptor, ConnectionLocker, LockID, DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { PeerDescriptor, ConnectionLocker, LockID, DhtAddress, getNodeIdFromPeerDescriptor, ListeningRpcCommunicator } from '@streamr/dht'
 import { MessageID } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { InspectSession, Events as InspectSessionEvents } from './InspectSession'
 import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { RpcCommunicator } from '@streamr/proto-rpc'
 import { Logger, waitForEvent3 } from '@streamr/utils'
 import { TemporaryConnectionRpcRemote } from '../temporary-connection/TemporaryConnectionRpcRemote'
 import { StreamPartID } from '@streamr/protocol'
@@ -10,7 +9,7 @@ import { StreamPartID } from '@streamr/protocol'
 interface InspectorConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
-    rpcCommunicator: RpcCommunicator
+    rpcCommunicator: ListeningRpcCommunicator
     connectionLocker: ConnectionLocker
     inspectionTimeout?: number
     openInspectConnection?: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
@@ -24,7 +23,7 @@ export class Inspector {
     private readonly sessions: Map<DhtAddress, InspectSession> = new Map()
     private readonly streamPartId: StreamPartID
     private readonly localPeerDescriptor: PeerDescriptor
-    private readonly rpcCommunicator: RpcCommunicator
+    private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly connectionLocker: ConnectionLocker
     private readonly inspectionTimeout: number
     private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>

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

@@ -23,7 +23,7 @@ import { StreamPartID } from '@streamr/protocol'
 
 interface HandshakeRpcLocalConfig {
     streamPartId: StreamPartID
-    targetNeighbors: NodeList
+    neighbors: NodeList
     connectionLocker: ConnectionLocker
     ongoingHandshakes: Set<DhtAddress>
     ongoingInterleaves: Set<DhtAddress>
@@ -53,13 +53,13 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
         const senderNodeId = getNodeIdFromPeerDescriptor(senderDescriptor)
         if (this.config.ongoingInterleaves.has(senderNodeId)) {
             return this.rejectHandshake(request)
-        } else if (this.config.targetNeighbors.hasNode(senderDescriptor)
+        } else if (this.config.neighbors.has(senderNodeId)
             || this.config.ongoingHandshakes.has(senderNodeId)
         ) {
             return this.acceptHandshake(request, senderDescriptor)
-        } else if (this.config.targetNeighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
+        } else if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
             return this.acceptHandshake(request, senderDescriptor)
-        } else if (this.config.targetNeighbors.size(getInterleaveSourceIds()) - this.config.ongoingInterleaves.size >= 2) {
+        } else if (this.config.neighbors.size(getInterleaveSourceIds()) - this.config.ongoingInterleaves.size >= 2) {
             // Do not accept the handshakes requests if the target neighbor count can potentially drop below 2 
             // due to interleaving. This ensures that a stable number of connections is kept during high churn.
             return this.acceptHandshakeWithInterleaving(request, senderDescriptor)
@@ -73,7 +73,7 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
             requestId: request.requestId,
             accepted: true
         }
-        this.config.targetNeighbors.add(this.config.createDeliveryRpcRemote(requester))
+        this.config.neighbors.add(this.config.createDeliveryRpcRemote(requester))
         this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
         return res
     }
@@ -95,21 +95,21 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
         if (request.interleaveSourceId !== undefined) {
             exclude.push(getDhtAddressFromRaw(request.interleaveSourceId))
         }
-        const furthest = this.config.targetNeighbors.getFurthest(exclude)
-        const furthestPeerDescriptor = furthest ? furthest.getPeerDescriptor() : undefined
-        if (furthest) {
-            const nodeId = getNodeIdFromPeerDescriptor(furthest.getPeerDescriptor())
-            const remote = this.config.createRpcRemote(furthest.getPeerDescriptor())
+        const last = this.config.neighbors.getLast(exclude)
+        const lastPeerDescriptor = last ? last.getPeerDescriptor() : undefined
+        if (last) {
+            const nodeId = getNodeIdFromPeerDescriptor(last.getPeerDescriptor())
+            const remote = this.config.createRpcRemote(last.getPeerDescriptor())
             this.config.ongoingInterleaves.add(nodeId)
             // Run this with then catch instead of setImmediate to avoid changes in state
             // eslint-disable-next-line promise/catch-or-return
             remote.interleaveRequest(requester).then((response) => {
-                // If response is accepted, remove the furthest node from the target neighbors
+                // If response is accepted, remove the last node from the target neighbors
                 // and unlock the connection
-                // If response is not accepted, keep the furthest node as a neighbor
+                // If response is not accepted, keep the last node as a neighbor
                 if (response.accepted) {
-                    this.config.targetNeighbors.remove(furthest.getPeerDescriptor())
-                    this.config.connectionLocker.unlockConnection(furthestPeerDescriptor!, this.config.streamPartId)
+                    this.config.neighbors.remove(getNodeIdFromPeerDescriptor(lastPeerDescriptor!))
+                    this.config.connectionLocker.unlockConnection(lastPeerDescriptor!, this.config.streamPartId)
                 }
                 return
             }).catch(() => {
@@ -118,12 +118,12 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
                 this.config.ongoingInterleaves.delete(nodeId)
             })
         }
-        this.config.targetNeighbors.add(this.config.createDeliveryRpcRemote(requester))
+        this.config.neighbors.add(this.config.createDeliveryRpcRemote(requester))
         this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
         return {
             requestId: request.requestId,
             accepted: true,
-            interleaveTargetDescriptor: furthestPeerDescriptor
+            interleaveTargetDescriptor: lastPeerDescriptor
         }
     }
 
@@ -132,9 +132,9 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
         const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
         try {
             await this.config.handshakeWithInterleaving(message.interleaveTargetDescriptor!, senderId)
-            if (this.config.targetNeighbors.hasNodeById(senderId)) {
+            if (this.config.neighbors.has(senderId)) {
                 this.config.connectionLocker.unlockConnection(senderPeerDescriptor, this.config.streamPartId)
-                this.config.targetNeighbors.remove(senderPeerDescriptor)
+                this.config.neighbors.remove(senderId)
             }
             return { accepted: true }
         } catch (err) {