@streamr/trackerless-network 100.0.0-testnet-three.2 → 100.0.0-testnet-three.4

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

@@ -25,6 +25,7 @@ interface HandshakerConfig {
     randomNodeView: NodeList
     rpcCommunicator: ListeningRpcCommunicator
     maxNeighborCount: number
+    ongoingHandshakes: Set<DhtAddress>
     rpcRequestTimeout?: number
 }
 
@@ -34,7 +35,6 @@ const PARALLEL_HANDSHAKE_COUNT = 2
 
 export class Handshaker {
 
-    private readonly ongoingHandshakes: Set<DhtAddress> = new Set()
     private config: HandshakerConfig
     private readonly rpcLocal: IHandshakeRpc
 
@@ -44,7 +44,7 @@ export class Handshaker {
             streamPartId: this.config.streamPartId,
             neighbors: this.config.neighbors,
             connectionLocker: this.config.connectionLocker,
-            ongoingHandshakes: this.ongoingHandshakes,
+            ongoingHandshakes: this.config.ongoingHandshakes,
             ongoingInterleaves: new Set(),
             maxNeighborCount: this.config.maxNeighborCount,
             handshakeWithInterleaving: (target: PeerDescriptor, senderId: DhtAddress) => this.handshakeWithInterleaving(target, senderId),
@@ -59,10 +59,10 @@ export class Handshaker {
 
     async attemptHandshakesOnContacts(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         // TODO use config option or named constant? or why the value 2?
-        if (this.config.neighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount - 2) {
+        if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount - 2) {
             logger.trace(`Attempting parallel handshakes with ${PARALLEL_HANDSHAKE_COUNT} targets`)
             return this.selectParallelTargetsAndHandshake(excludedIds)
-        } else if (this.config.neighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount) {
+        } else if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
             logger.trace(`Attempting handshake with new target`)
             return this.selectNewTargetAndHandshake(excludedIds)
         }
@@ -72,17 +72,22 @@ export class Handshaker {
     private async selectParallelTargetsAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         const exclude = excludedIds.concat(this.config.neighbors.getIds())
         const neighbors = this.selectParallelTargets(exclude)
-        neighbors.forEach((contact) => this.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
+        neighbors.forEach((contact) => this.config.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
         return this.doParallelHandshakes(neighbors, exclude)
     }
 
     private selectParallelTargets(excludedIds: DhtAddress[]): HandshakeRpcRemote[] {
         const neighbors = this.config.nearbyNodeView.getFirstAndLast(excludedIds)
-        while (neighbors.length < PARALLEL_HANDSHAKE_COUNT && this.config.randomNodeView.size(excludedIds) > 0) {
-            const random = this.config.randomNodeView.getRandom(excludedIds)
-            if (random) {
-                neighbors.push(random)
-            }
+        const getExcludedFromRandomView = () => [
+            ...excludedIds,
+            ...neighbors.map((neighbor) => getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor()))
+        ]
+        while (
+            neighbors.length < PARALLEL_HANDSHAKE_COUNT 
+            && this.config.randomNodeView.size(getExcludedFromRandomView()) > 0
+        ) {
+            const random = this.config.randomNodeView.getRandom(getExcludedFromRandomView())!
+            neighbors.push(random)
         }
         return neighbors.map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
     }
@@ -118,7 +123,7 @@ export class Handshaker {
 
     private async handshakeWithTarget(neighbor: HandshakeRpcRemote, concurrentNodeId?: DhtAddress): Promise<boolean> {
         const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
-        this.ongoingHandshakes.add(targetNodeId)
+        this.config.ongoingHandshakes.add(targetNodeId)
         const result = await neighbor.handshake(
             this.config.streamPartId,
             this.config.neighbors.getIds(),
@@ -131,14 +136,14 @@ export class Handshaker {
         if (result.interleaveTargetDescriptor) {
             await this.handshakeWithInterleaving(result.interleaveTargetDescriptor, targetNodeId)
         }
-        this.ongoingHandshakes.delete(targetNodeId)
+        this.config.ongoingHandshakes.delete(targetNodeId)
         return result.accepted
     }
 
     private async handshakeWithInterleaving(target: PeerDescriptor, interleaveSourceId: DhtAddress): Promise<boolean> {
         const neighbor = this.createRpcRemote(target)
         const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
-        this.ongoingHandshakes.add(targetNodeId)
+        this.config.ongoingHandshakes.add(targetNodeId)
         const result = await neighbor.handshake(
             this.config.streamPartId,
             this.config.neighbors.getIds(),
@@ -149,7 +154,7 @@ export class Handshaker {
             this.config.neighbors.add(this.createDeliveryRpcRemote(neighbor.getPeerDescriptor()))
             this.config.connectionLocker.lockConnection(neighbor.getPeerDescriptor(), this.config.streamPartId)
         }
-        this.ongoingHandshakes.delete(targetNodeId)
+        this.config.ongoingHandshakes.delete(targetNodeId)
         return result.accepted
     }
 
@@ -174,7 +179,7 @@ export class Handshaker {
     }
 
     getOngoingHandshakes(): Set<DhtAddress> {
-        return this.ongoingHandshakes
+        return this.config.ongoingHandshakes
     }
 
 }

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

@@ -1,5 +1,5 @@
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ConnectionLocker, DhtAddress, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { Logger, scheduleAtInterval } from '@streamr/utils'
 import { NeighborFinder } from './NeighborFinder'
@@ -13,10 +13,12 @@ interface NeighborUpdateManagerConfig {
     neighbors: NodeList
     nearbyNodeView: NodeList
     neighborFinder: NeighborFinder
+    connectionLocker: ConnectionLocker
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
     neighborUpdateInterval: number
     neighborTargetCount: number
+    ongoingHandshakes: Set<DhtAddress>
 }
 
 const logger = new Logger(module)
@@ -51,6 +53,7 @@ export class NeighborUpdateManager {
             if (res.removeMe) {
                 const nodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
                 this.config.neighbors.remove(nodeId)
+                this.config.connectionLocker.unlockConnection(neighbor.getPeerDescriptor(), this.config.streamPartId)
                 this.config.neighborFinder.start([nodeId])
             }
         }))

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

@@ -1,5 +1,5 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { INeighborUpdateRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
@@ -14,8 +14,10 @@ interface NeighborUpdateRpcLocalConfig {
     neighbors: NodeList
     nearbyNodeView: NodeList
     neighborFinder: NeighborFinder
+    connectionLocker: ConnectionLocker
     rpcCommunicator: ListeningRpcCommunicator
     neighborTargetCount: number
+    ongoingHandshakes: Set<DhtAddress>
 }
 
 export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
@@ -55,7 +57,7 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
         this.updateContacts(message.neighborDescriptors)
-        if (!this.config.neighbors.has(senderId)) {
+        if (!this.config.neighbors.has(senderId) && !this.config.ongoingHandshakes.has(senderId)) {
             return this.createResponse(true)
         } else {
             const isOverNeighborCount = this.config.neighbors.size() > this.config.neighborTargetCount
@@ -67,6 +69,7 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
                 this.config.neighborFinder.start()
             } else {
                 this.config.neighbors.remove(senderId)
+                this.config.connectionLocker.unlockConnection(senderPeerDescriptor, this.config.streamPartId)
             }
             return this.createResponse(isOverNeighborCount)
         }

package/src/logic/node-info/NodeInfoRpcLocal.ts

@@ -2,6 +2,7 @@ import { NodeInfoRequest, NodeInfoResponse } from '../../proto/packages/trackerl
 import { INodeInfoRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { NetworkStack } from '../../NetworkStack'
 import { ListeningRpcCommunicator } from '@streamr/dht'
+import { version as localVersion } from '../../../package.json'
 
 export const NODE_INFO_RPC_SERVICE_ID = 'system/node-info-rpc'
 
@@ -28,7 +29,8 @@ export class NodeInfoRpcLocal implements INodeInfoRpc {
                 connections: this.stack.getLayer0Node().getConnections(),
                 neighbors: this.stack.getLayer0Node().getNeighbors()
             },
-            streamPartitions: this.stack.getStreamrNode().getNodeInfo()
+            streamPartitions: this.stack.getStreamrNode().getNodeInfo(),
+            version: localVersion
         }
     }
 

package/src/logic/proxy/ProxyClient.ts

@@ -58,6 +58,11 @@ interface ProxyDefinition {
     userId: EthereumAddress
 }
 
+interface ProxyConnection {
+    peerDescriptor: PeerDescriptor
+    direction: ProxyDirection
+}
+
 interface Events {
     message: (message: StreamMessage) => void
 }
@@ -73,7 +78,7 @@ export class ProxyClient extends EventEmitter<Events> {
     private readonly config: ProxyClientConfig
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector> = new Map()
     private definition?: ProxyDefinition
-    private readonly connections: Map<DhtAddress, ProxyDirection> = new Map()
+    private readonly connections: Map<DhtAddress, ProxyConnection> = new Map()
     private readonly propagation: Propagation
     private readonly neighbors: NodeList
     private readonly abortController: AbortController
@@ -159,7 +164,7 @@ export class ProxyClient extends EventEmitter<Events> {
     private getInvalidConnections(): DhtAddress[] {
         return Array.from(this.connections.keys()).filter((id) => {
             return !this.definition!.nodes.has(id)
-                || this.definition!.direction !== this.connections.get(id)
+                || this.definition!.direction !== this.connections.get(id)!.direction
         })
     }
 
@@ -183,7 +188,7 @@ export class ProxyClient extends EventEmitter<Events> {
         const accepted = await rpcRemote.requestConnection(direction, userId)
         if (accepted) {
             this.config.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
-            this.connections.set(nodeId, direction)
+            this.connections.set(nodeId, { peerDescriptor, direction })
             const remote = new DeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 peerDescriptor,
@@ -216,13 +221,15 @@ export class ProxyClient extends EventEmitter<Events> {
             })
             const server = this.neighbors.get(nodeId)
             server?.leaveStreamPartNotice(this.config.streamPartId, false)
-            this.removeConnection(nodeId)
+            this.removeConnection(this.connections.get(nodeId)!.peerDescriptor)
         }
     }
 
-    private removeConnection(nodeId: DhtAddress): void {
+    private removeConnection(peerDescriptor: PeerDescriptor): void {
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         this.connections.delete(nodeId)
         this.neighbors.remove(nodeId)
+        this.config.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
     }
 
     broadcast(msg: StreamMessage, previousNode?: DhtAddress): void {
@@ -234,7 +241,7 @@ export class ProxyClient extends EventEmitter<Events> {
     }
 
     hasConnection(nodeId: DhtAddress, direction: ProxyDirection): boolean {
-        return this.connections.has(nodeId) && this.connections.get(nodeId) === direction
+        return this.connections.has(nodeId) && this.connections.get(nodeId)!.direction === direction
     }
 
     getDirection(): ProxyDirection {
@@ -245,7 +252,7 @@ export class ProxyClient extends EventEmitter<Events> {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         if (this.connections.has(nodeId)) {
             this.config.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
-            this.removeConnection(nodeId)
+            this.removeConnection(peerDescriptor)
             await retry(() => this.updateConnections(), 'updating proxy connections', this.abortController.signal)
         }
     }

package/src/logic/temporary-connection/TemporaryConnectionRpcLocal.ts

@@ -32,6 +32,10 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
         return this.temporaryNodes
     }
 
+    hasNode(node: DhtAddress): boolean {
+        return this.temporaryNodes.has(node)
+    }
+
     removeNode(nodeId: DhtAddress): void {
         this.temporaryNodes.remove(nodeId)
     }

package/src/proto/packages/trackerless-network/protos/NetworkRpc.ts

@@ -329,6 +329,10 @@ export interface NodeInfoResponse {
      * @generated from protobuf field: optional ControlLayerInfo controlLayer = 3;
      */
     controlLayer?: ControlLayerInfo;
+    /**
+     * @generated from protobuf field: string version = 4;
+     */
+    version: string;
 }
 /**
  * @generated from protobuf enum StreamMessageType
@@ -673,7 +677,8 @@ class NodeInfoResponse$Type extends MessageType<NodeInfoResponse> {
         super("NodeInfoResponse", [
             { no: 1, name: "peerDescriptor", kind: "message", T: () => PeerDescriptor },
             { no: 2, name: "streamPartitions", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => StreamPartitionInfo },
-            { no: 3, name: "controlLayer", kind: "message", T: () => ControlLayerInfo }
+            { no: 3, name: "controlLayer", kind: "message", T: () => ControlLayerInfo },
+            { no: 4, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
 }

package/test/end-to-end/proxy-key-exchange.test.ts

@@ -47,7 +47,7 @@ describe('proxy group key exchange', () => {
         proxyNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
         publisher = createNetworkNode({
             layer0: {
-                entryPoints: [publisherDescriptor],
+                entryPoints: [proxyNodeDescriptor],
                 peerDescriptor: publisherDescriptor,
             }
         })
@@ -55,7 +55,7 @@ describe('proxy group key exchange', () => {
 
         subscriber = createNetworkNode({
             layer0: {
-                entryPoints: [subscriberDescriptor],
+                entryPoints: [proxyNodeDescriptor],
                 peerDescriptor: subscriberDescriptor,
             }
         })

package/test/end-to-end/random-graph-with-real-connections.test.ts

@@ -1,7 +1,7 @@
-import { ConnectionManager, DhtNode, PeerDescriptor, NodeType } from '@streamr/dht'
+import { ConnectionManager, DhtNode, PeerDescriptor } from '@streamr/dht'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { waitForCondition } from '@streamr/utils'
-import { createStreamMessage } from '../utils/utils'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
@@ -10,11 +10,9 @@ import { Layer1Node } from '../../src/logic/Layer1Node'
 
 describe('random graph with real connections', () => {
 
-    const epPeerDescriptor: PeerDescriptor = {
-        nodeId: Uint8Array.from([1, 2, 3]),
-        type: NodeType.NODEJS,
+    const epPeerDescriptor: PeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 12221, tls: false }
-    }
+    })
 
     const streamPartId = StreamPartIDUtils.parse('random-graph#0')
     // Currently the nodes here are practically layer0 nodes acting as layer1 nodes, for the purpose of this test

package/test/integration/Handshakes.test.ts

@@ -92,7 +92,8 @@ describe('Handshakes', () => {
             neighbors,
             connectionLocker: mockConnectionLocker,
             rpcCommunicator: rpcCommunicator2,
-            maxNeighborCount: 4
+            maxNeighborCount: 4,
+            ongoingHandshakes: new Set()
         })
 
     })

package/test/integration/NetworkNode.test.ts

@@ -1,4 +1,4 @@
-import { NodeType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
+import { PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
 import {
     ContentType,
     EncryptionType,
@@ -10,6 +10,7 @@ import {
 } from '@streamr/protocol'
 import { EthereumAddress, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
 
@@ -21,15 +22,9 @@ describe('NetworkNode', () => {
     let node1: NetworkNode
     let node2: NetworkNode
 
-    const pd1: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS
-    }
+    const pd1: PeerDescriptor = createMockPeerDescriptor()
 
-    const pd2: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS
-    }
+    const pd2: PeerDescriptor = createMockPeerDescriptor()
 
     beforeEach(async () => {
         const simulator = new Simulator()

package/test/integration/NodeInfoRpc.test.ts

@@ -95,7 +95,8 @@ describe('NetworkStack NodeInfoRpc', () => {
                     controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
                     deliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
                 }
-            ]
+            ],
+            version: expect.any(String)
         })
         expect(result.streamPartitions.length).toEqual(2)
     })

package/test/integration/StreamrNode.test.ts

@@ -1,13 +1,7 @@
-import {
-    DhtNode,
-    PeerDescriptor,
-    Simulator,
-    SimulatorTransport,
-    NodeType
-} from '@streamr/dht'
+import { DhtNode, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
 import { StreamrNode, Events } from '../../src/logic/StreamrNode'
 import { waitForEvent3, waitForCondition } from '@streamr/utils'
-import { createStreamMessage } from '../utils/utils'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { Layer0Node } from '../../src/logic/Layer0Node'
@@ -21,14 +15,8 @@ describe('StreamrNode', () => {
     let node1: StreamrNode
     let node2: StreamrNode
 
-    const peerDescriptor1: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS
-    }
-    const peerDescriptor2: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS
-    }
+    const peerDescriptor1: PeerDescriptor = createMockPeerDescriptor()
+    const peerDescriptor2: PeerDescriptor = createMockPeerDescriptor()
     const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
 
     const msg = createStreamMessage(

package/test/integration/joining-streams-on-offline-peers.test.ts

@@ -1,9 +1,9 @@
-import { NodeType, PeerDescriptor, Simulator, SimulatorTransport, LatencyType, getRandomRegion } from '@streamr/dht'
+import { PeerDescriptor, Simulator, SimulatorTransport, LatencyType } from '@streamr/dht'
 import { NetworkStack } from '../../src/NetworkStack'
 import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { Any } from '../../src/proto/google/protobuf/any'
-import { createStreamMessage } from '../utils/utils'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 import { waitForCondition } from '@streamr/utils'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
@@ -11,35 +11,11 @@ const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
 
 describe('Joining stream parts on offline nodes', () => {
 
-    const entryPointPeerDescriptor: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
-
-    const node1PeerDescriptor: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 1, 1]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
-
-    const node2PeerDescriptor: PeerDescriptor = {
-        nodeId: new Uint8Array([2, 2, 2]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
-
-    const offlineDescriptor1: PeerDescriptor = {
-        nodeId: new Uint8Array([3, 3, 3]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
-
-    const offlineDescriptor2: PeerDescriptor = {
-        nodeId: new Uint8Array([4, 4, 4]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
+    const entryPointPeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
+    const node1PeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
+    const node2PeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
+    const offlineDescriptor1: PeerDescriptor = createMockPeerDescriptor()
+    const offlineDescriptor2: PeerDescriptor = createMockPeerDescriptor()
 
     let entryPoint: NetworkStack
     let node1: NetworkStack

package/test/integration/stream-without-default-entrypoints.test.ts

@@ -1,4 +1,4 @@
-import { LatencyType, NodeType, PeerDescriptor, Simulator, SimulatorTransport, getRandomRegion } from '@streamr/dht'
+import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
 import {
     ContentType,
     EncryptionType,
@@ -22,11 +22,7 @@ describe('stream without default entrypoints', () => {
     let entrypoint: NetworkNode
     let nodes: NetworkNode[]
     let receivedMessageCount: number
-    const entryPointPeerDescriptor: PeerDescriptor = {
-        nodeId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS,
-        region: getRandomRegion()
-    }
+    const entryPointPeerDescriptor: PeerDescriptor = createMockPeerDescriptor()
 
     const streamMessage = new StreamMessage({
         messageId: new MessageID(

package/test/unit/Handshaker.test.ts

@@ -40,7 +40,8 @@ describe('Handshaker', () => {
             randomNodeView,
             rpcCommunicator,
             maxNeighborCount,
-            rpcRequestTimeout: 5000
+            rpcRequestTimeout: 5000,
+            ongoingHandshakes: new Set()
         })
     })
 

package/test/unit/InspectSession.test.ts

@@ -2,8 +2,7 @@ import { InspectSession, Events } from '../../src/logic/inspect/InspectSession'
 import { MessageID } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { waitForEvent3 } from '../../../utils/dist/src/waitForEvent3'
 import { utf8ToBinary } from '@streamr/utils'
-import { createRandomNodeId } from '../utils/utils'
-import { DhtAddress } from '@streamr/dht'
+import { DhtAddress, createRandomDhtAddress } from '@streamr/dht'
 
 describe('InspectSession', () => {
 
@@ -31,8 +30,8 @@ describe('InspectSession', () => {
     }
 
     beforeEach(() => {
-        inspectedNode = createRandomNodeId()
-        anotherNode = createRandomNodeId()
+        inspectedNode = createRandomDhtAddress()
+        anotherNode = createRandomDhtAddress()
         inspectSession = new InspectSession({
             inspectedNode
         })

package/test/unit/Inspector.test.ts

@@ -1,8 +1,8 @@
-import { ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ListeningRpcCommunicator, createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { utf8ToBinary } from '@streamr/utils'
 import { Inspector } from '../../src/logic/inspect/Inspector'
 import { MockTransport } from '../utils/mock/Transport'
-import { createMockPeerDescriptor, createRandomNodeId, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, mockConnectionLocker } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Inspector', () => {
@@ -12,7 +12,7 @@ describe('Inspector', () => {
 
     const inspectedDescriptor = createMockPeerDescriptor()
 
-    const nodeId = createRandomNodeId()
+    const nodeId = createRandomDhtAddress()
     let mockConnect: jest.Mock
 
     const messageRef = {

package/test/unit/NeighborFinder.test.ts

@@ -3,12 +3,12 @@ import { NodeList } from '../../src/logic/NodeList'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { expect } from 'expect'
-import { createMockDeliveryRpcRemote, createRandomNodeId } from '../utils/utils'
-import { DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { createMockDeliveryRpcRemote } from '../utils/utils'
+import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 
 describe('NeighborFinder', () => {
 
-    const nodeId = createRandomNodeId()
+    const nodeId = createRandomDhtAddress()
     let neighbors: NodeList
     let nearbyNodeView: NodeList
     let neighborFinder: NeighborFinder

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NeighborFinder } from '../../src/logic/neighbor-discovery/NeighborFinder'
 import { NeighborUpdateRpcLocal } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcLocal'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -20,6 +20,7 @@ describe('NeighborUpdateRpcLocal', () => {
     let nearbyNodeView: NodeList
     let neighborFinder: NeighborFinder
     let rpcCommunicator: ListeningRpcCommunicator
+    let ongoingHandshakes: Set<DhtAddress>
 
     const addNeighbors = (count: number) => {
         for (let i = 0; i < count; i++) {
@@ -39,6 +40,10 @@ describe('NeighborUpdateRpcLocal', () => {
         neighborFinder = {
             start: jest.fn()
         } as any
+        const connectionLocker = {
+            unlockConnection: jest.fn()
+        } as any
+        ongoingHandshakes = new Set()
 
         rpcLocal = new NeighborUpdateRpcLocal({
             localPeerDescriptor,
@@ -47,7 +52,9 @@ describe('NeighborUpdateRpcLocal', () => {
             neighborFinder,
             streamPartId,
             rpcCommunicator,
-            neighborTargetCount
+            neighborTargetCount,
+            connectionLocker,
+            ongoingHandshakes
         })
     })
 
@@ -122,4 +129,15 @@ describe('NeighborUpdateRpcLocal', () => {
         expect(neighbors.has(getNodeIdFromPeerDescriptor(caller))).toEqual(false)
     })
 
+    it('does not ask to be removed if there is an ongoing handshake to the caller', async () => {
+        const caller = createMockPeerDescriptor()
+        ongoingHandshakes.add(getNodeIdFromPeerDescriptor(caller))
+        const res = await rpcLocal.neighborUpdate({
+            streamPartId,
+            neighborDescriptors: [localPeerDescriptor],
+            removeMe: false
+        }, { incomingSourceDescriptor: caller } as any)
+        expect(res.removeMe).toEqual(false)
+    })
+
 })