@streamr/trackerless-network 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/test/benchmark/first-message.ts

@@ -1,12 +1,28 @@
 /* eslint-disable no-console */
 
-import { DhtNode, LatencyType, Simulator, getRandomRegion } from '@streamr/dht'
-import { MessageID, StreamMessage, StreamMessageType, StreamPartID, StreamPartIDUtils, toStreamID, toStreamPartID } from '@streamr/protocol'
+import {
+    DhtNode,
+    getNodeIdFromPeerDescriptor,
+    getRandomRegion,
+    LatencyType,
+    PeerDescriptor,
+    Simulator
+} from '@streamr/dht'
+import {
+    ContentType,
+    EncryptionType,
+    MessageID,
+    SignatureType,
+    StreamMessage,
+    StreamMessageType,
+    StreamPartID,
+    StreamPartIDUtils,
+    toStreamID,
+    toStreamPartID
+} from '@streamr/protocol'
 import { hexToBinary, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
 import fs from 'fs'
-import { PeerDescriptor } from '@streamr/dht'
 import { NetworkNode } from '../../src/NetworkNode'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { createMockPeerDescriptor, createNetworkNodeWithSimulator } from '../utils/utils'
 import { Layer1Node } from '../../src/logic/Layer1Node'
@@ -31,7 +47,7 @@ const prepareLayer0 = async () => {
         region: getRandomRegion()
     })
     layer0Ep = peerDescriptor
-    const entryPoint = createNetworkNodeWithSimulator(peerDescriptor, simulator, [peerDescriptor])
+    const entryPoint = await createNetworkNodeWithSimulator(peerDescriptor, simulator, [peerDescriptor])
     await entryPoint.start()    
     nodes.push(entryPoint)
 
@@ -44,7 +60,7 @@ const prepareStream = async (streamId: string) => {
         region: getRandomRegion()
     })
     const streamPartId = toStreamPartID(toStreamID(streamId), 0)
-    const streamPublisher = createNetworkNodeWithSimulator(peerDescriptor, simulator, [layer0Ep])
+    const streamPublisher = await createNetworkNodeWithSimulator(peerDescriptor, simulator, [layer0Ep])
     await streamPublisher.start()
     streamPublisher.join(streamPartId)
     nodes.push(streamPublisher)
@@ -52,7 +68,7 @@ const prepareStream = async (streamId: string) => {
 }
 
 const shutdownNetwork = async () => {
-    publishIntervals.map((interval) => clearInterval(interval))
+    publishIntervals.forEach((interval) => clearInterval(interval))
     await Promise.all([
         ...nodes.map((node) => node.stop())
     ])
@@ -76,21 +92,28 @@ const measureJoiningTime = async () => {
                 0,
                 i,
                 Math.floor(Math.random() * 20000),
-                'node' as any,
+                '2222' as any,
                 'msgChainId'
             ),
-            prevMsgRef: null,
             content: utf8ToBinary(JSON.stringify({
                 hello: 'world'
             })),
             messageType: StreamMessageType.MESSAGE,
+            contentType: ContentType.JSON,
+            encryptionType: EncryptionType.NONE,
             signature: hexToBinary('0x1234'),
+            signatureType: SignatureType.SECP256K1,
+
         })
         streamParts.get(stream)!.broadcast(streamMessage)
     }, 1000)
     // get random node from network to use as entrypoint
     const randomNode = nodes[Math.floor(Math.random() * nodes.length)]
-    const streamSubscriber = createNetworkNodeWithSimulator(peerDescriptor, simulator, [randomNode.stack.getLayer0Node().getLocalPeerDescriptor()])
+    const streamSubscriber = await createNetworkNodeWithSimulator(
+        peerDescriptor,
+        simulator,
+        [randomNode.stack.getLayer0Node().getLocalPeerDescriptor()]
+    )
     currentNode = streamSubscriber
     const start = performance.now()
     await streamSubscriber.start()
@@ -109,7 +132,6 @@ const measureJoiningTime = async () => {
 }
 
 const run = async () => {
-    Simulator.useFakeTimers()
     await prepareLayer0()
     for (let i = 0; i < 20; i++) {
         await prepareStream(`stream-${i}`)
@@ -124,7 +146,6 @@ const run = async () => {
     }
     fs.closeSync(logFile)
     await shutdownNetwork()
-    Simulator.useFakeTimers(false)
 } 
 
 // eslint-disable-next-line promise/catch-or-return, promise/always-return
@@ -134,14 +155,14 @@ run().then(() => {
     console.error(err)
     const streamrNode = currentNode.stack.getStreamrNode()
     const streamParts = streamrNode.getStreamParts()
-    const foundData = nodes[0].stack.getLayer0Node().getDataFromDht(streamPartIdToDataKey(streamParts[0]))
+    const foundData = nodes[0].stack.getLayer0Node().fetchDataFromDht(streamPartIdToDataKey(streamParts[0]))
     console.log(foundData)
     const layer0Node = currentNode.stack.getLayer0Node() as DhtNode
-    console.log(layer0Node.getKBucketPeers().length)
-    console.log(layer0Node.getNumberOfConnections())
+    console.log(layer0Node.getNeighbors().length)
+    console.log(layer0Node.getConnectionCount())
     const streamPartDelivery = streamrNode.getStreamPartDelivery(streamParts[0])! as { layer1Node: Layer1Node, node: RandomGraphNode }
-    console.log(streamPartDelivery.layer1Node.getKBucketPeers())
-    console.log(streamPartDelivery.node.getTargetNeighborIds())
+    console.log(streamPartDelivery.layer1Node.getNeighbors())
+    console.log(streamPartDelivery.node.getNeighbors())
     console.log(nodes[nodes.length - 1])
     if (publishInterval) {
         clearInterval(publishInterval)

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

@@ -1,4 +1,13 @@
-import { MessageID, MessageRef, StreamMessage, StreamMessageType, StreamPartIDUtils } from '@streamr/protocol'
+import {
+    ContentType,
+    EncryptionType,
+    MessageID,
+    MessageRef,
+    SignatureType,
+    StreamMessage,
+    StreamMessageType,
+    StreamPartIDUtils
+} from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
@@ -52,6 +61,9 @@ describe('inspect', () => {
             hello: 'world'
         })),
         messageType: StreamMessageType.MESSAGE,
+        contentType: ContentType.JSON,
+        encryptionType: EncryptionType.NONE,
+        signatureType: SignatureType.SECP256K1,
         signature: hexToBinary('0x1234'),
     })
     
@@ -84,9 +96,9 @@ describe('inspect', () => {
         await inspectedNode.start()
         await inspectorNode.start()
 
-        publisherNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
-        inspectedNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
-        inspectorNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
+        publisherNode.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
+        inspectedNode.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
+        inspectorNode.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
 
         await waitForCondition(() => 
             publisherNode.stack.getStreamrNode().getNeighbors(STREAM_PART_ID).length === 2 

package/test/end-to-end/proxy-and-full-node.test.ts

@@ -1,4 +1,14 @@
-import { MessageID, MessageRef, StreamMessage, StreamMessageType, StreamPartID, StreamPartIDUtils } from '@streamr/protocol'
+import {
+    ContentType,
+    EncryptionType,
+    MessageID,
+    MessageRef,
+    SignatureType,
+    StreamMessage,
+    StreamMessageType,
+    StreamPartID,
+    StreamPartIDUtils
+} from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
@@ -22,6 +32,9 @@ const createMessage = (streamPartId: StreamPartID): StreamMessage => {
             hello: 'world'
         })),
         messageType: StreamMessageType.MESSAGE,
+        contentType: ContentType.JSON,
+        encryptionType: EncryptionType.NONE,
+        signatureType: SignatureType.SECP256K1,
         signature: hexToBinary('0x1234'),
     })
 }
@@ -52,11 +65,11 @@ describe('proxy and full node', () => {
             }
         })
         await proxyNode.start()
-        proxyNode.stack.getStreamrNode()!.joinStreamPart(proxiedStreamPart)
-        proxyNode.stack.getStreamrNode()!.joinStreamPart(regularStreamPart1)
-        proxyNode.stack.getStreamrNode()!.joinStreamPart(regularStreamPart2)
-        proxyNode.stack.getStreamrNode()!.joinStreamPart(regularStreamPart3)
-        proxyNode.stack.getStreamrNode()!.joinStreamPart(regularStreamPart4)
+        proxyNode.stack.getStreamrNode().joinStreamPart(proxiedStreamPart)
+        proxyNode.stack.getStreamrNode().joinStreamPart(regularStreamPart1)
+        proxyNode.stack.getStreamrNode().joinStreamPart(regularStreamPart2)
+        proxyNode.stack.getStreamrNode().joinStreamPart(regularStreamPart3)
+        proxyNode.stack.getStreamrNode().joinStreamPart(regularStreamPart4)
 
         proxiedNode = createNetworkNode({
             layer0: {
@@ -77,14 +90,14 @@ describe('proxy and full node', () => {
         expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(false)
 
         await Promise.all([
-            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage'),
+            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage'),
             proxiedNode.broadcast(createMessage(regularStreamPart1))
         ])
 
         expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(true)
 
         await Promise.all([
-            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage'),
+            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage'),
             proxiedNode.broadcast(createMessage(proxiedStreamPart))
         ])
 
@@ -97,13 +110,13 @@ describe('proxy and full node', () => {
         expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(false)
 
         await Promise.all([
-            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
+            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage', 5000, 
                 (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart1)),
-            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
+            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage', 5000, 
                 (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart2)),
-            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
+            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage', 5000, 
                 (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart3)),
-            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
+            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage', 5000, 
                 (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart4)),
             proxiedNode.broadcast(createMessage(regularStreamPart1)),
             proxiedNode.broadcast(createMessage(regularStreamPart2)),
@@ -114,7 +127,7 @@ describe('proxy and full node', () => {
         expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(true)
 
         await Promise.all([
-            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage'),
+            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage'),
             proxiedNode.broadcast(createMessage(proxiedStreamPart))
         ])
 

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

@@ -1,12 +1,21 @@
-import { MessageID, MessageRef, StreamMessage, StreamMessageType, StreamPartIDUtils } from '@streamr/protocol'
+import {
+    ContentType,
+    EncryptionType,
+    MessageID,
+    MessageRef,
+    SignatureType,
+    StreamMessage,
+    StreamMessageType,
+    StreamPartIDUtils
+} from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary, utf8ToBinary, wait, waitForCondition, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { NodeID } from '../../src/identifiers'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { ProxyClient } from '../../src/logic/proxy/ProxyClient'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
+import { DhtAddress } from '@streamr/dht'
 
 const PROXIED_NODE_USER_ID = randomEthereumAddress()
 const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
@@ -24,7 +33,10 @@ const MESSAGE = new StreamMessage({
         hello: 'world'
     })),
     messageType: StreamMessageType.MESSAGE,
-    signature: hexToBinary('0x1234')
+    encryptionType: EncryptionType.NONE,
+    signatureType: SignatureType.SECP256K1,
+    signature: hexToBinary('0x1234'),
+    contentType: ContentType.JSON
 })
 
 describe('Proxy connections', () => {
@@ -34,14 +46,14 @@ describe('Proxy connections', () => {
     let proxiedNode: NetworkNode
 
     const hasConnectionFromProxy = (proxyNode: NetworkNode): boolean => {
-        const delivery = proxyNode.stack.getStreamrNode()!.getStreamPartDelivery(STREAM_PART_ID)
+        const delivery = proxyNode.stack.getStreamrNode().getStreamPartDelivery(STREAM_PART_ID)
         return (delivery !== undefined)
             ? ((delivery as { node: RandomGraphNode }).node).hasProxyConnection(proxiedNode.getNodeId())
             : false
     }
     
-    const hasConnectionToProxy = (proxyNodeId: NodeID, direction: ProxyDirection): boolean => {
-        const client = (proxiedNode.stack.getStreamrNode()!.getStreamPartDelivery(STREAM_PART_ID) as { client: ProxyClient }).client
+    const hasConnectionToProxy = (proxyNodeId: DhtAddress, direction: ProxyDirection): boolean => {
+        const client = (proxiedNode.stack.getStreamrNode().getStreamPartDelivery(STREAM_PART_ID) as { client: ProxyClient }).client
         return client.hasConnection(proxyNodeId, direction)
     }
 
@@ -65,7 +77,7 @@ describe('Proxy connections', () => {
         })
         await proxyNode1.start()
         proxyNode1.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor1])
-        proxyNode1.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
+        proxyNode1.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
         proxyNode2 = createNetworkNode({
             layer0: {
                 entryPoints: [proxyNodeDescriptor1],
@@ -78,7 +90,7 @@ describe('Proxy connections', () => {
         })
         await proxyNode2.start()
         proxyNode2.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor1])
-        proxyNode2.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
+        proxyNode2.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
         proxiedNode = createNetworkNode({
             layer0: {
                 entryPoints: [proxyNode1.getPeerDescriptor()],
@@ -97,7 +109,7 @@ describe('Proxy connections', () => {
     it('happy path publishing', async () => {
         await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
         await Promise.all([
-            waitForEvent3(proxyNode1.stack.getStreamrNode()! as any, 'newMessage'),
+            waitForEvent3(proxyNode1.stack.getStreamrNode() as any, 'newMessage'),
             proxiedNode.broadcast(MESSAGE)
         ])
     })
@@ -105,7 +117,7 @@ describe('Proxy connections', () => {
     it('happy path subscribing', async () => {
         await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID, 1)
         await Promise.all([
-            waitForEvent3(proxiedNode.stack.getStreamrNode()! as any, 'newMessage'),
+            waitForEvent3(proxiedNode.stack.getStreamrNode() as any, 'newMessage'),
             proxyNode1.broadcast(MESSAGE)
         ])
     })
@@ -184,7 +196,7 @@ describe('Proxy connections', () => {
         await proxyNode1.leave(STREAM_PART_ID)
         await waitForCondition(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE))
         expect(hasConnectionFromProxy(proxyNode1)).toBe(false)
-        proxyNode1.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
+        proxyNode1.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
         await waitForCondition(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE), 25000)
         // TODO why wait is needed?
         await wait(100)

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

@@ -1,14 +1,20 @@
 import {
+    ContentType,
     EncryptionType,
-    GroupKeyRequest,
-    GroupKeyResponse,
     MessageID,
+    GroupKeyRequest as OldGroupKeyRequest,
+    GroupKeyResponse as OldGroupKeyResponse,
+    SignatureType,
     StreamMessage,
     StreamMessageType,
     StreamPartIDUtils
 } from '@streamr/protocol'
-import { hexToBinary, toEthereumAddress, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
+import { hexToBinary, toEthereumAddress, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
+import {
+    convertGroupKeyRequestToBytes,
+    convertGroupKeyResponseToBytes
+} from '../../src/logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
@@ -41,10 +47,10 @@ describe('proxy group key exchange', () => {
         })
         await proxyNode.start()
         proxyNode.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor])
-        proxyNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
+        proxyNode.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
         publisher = createNetworkNode({
             layer0: {
-                entryPoints: [publisherDescriptor],
+                entryPoints: [proxyNodeDescriptor],
                 peerDescriptor: publisherDescriptor,
             }
         })
@@ -52,7 +58,7 @@ describe('proxy group key exchange', () => {
 
         subscriber = createNetworkNode({
             layer0: {
-                entryPoints: [subscriberDescriptor],
+                entryPoints: [proxyNodeDescriptor],
                 peerDescriptor: subscriberDescriptor,
             }
         })
@@ -69,14 +75,14 @@ describe('proxy group key exchange', () => {
         await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
         await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
-        const requestContent = utf8ToBinary(new GroupKeyRequest({
+        const groupKeyRequest = new OldGroupKeyRequest({
             recipient: publisherUserId,
             requestId: 'requestId',
             rsaPublicKey: 'mockKey',
             groupKeyIds: [
                 'mock'
             ],
-        }).serialize())
+        })
         const request = new StreamMessage({
             messageId: new MessageID(
                 StreamPartIDUtils.getStreamID(STREAM_PART_ID),
@@ -87,13 +93,15 @@ describe('proxy group key exchange', () => {
                 '0'
             ),
             messageType: StreamMessageType.GROUP_KEY_REQUEST,
+            contentType: ContentType.BINARY,
             encryptionType: EncryptionType.NONE,
-            content: requestContent,
+            content: convertGroupKeyRequestToBytes(groupKeyRequest),
+            signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('1234')
         })
 
         await Promise.all([
-            waitForEvent3(publisher.stack.getStreamrNode()! as any, 'newMessage'),
+            waitForEvent3(publisher.stack.getStreamrNode() as any, 'newMessage'),
             subscriber.broadcast(request)
         ])
     })
@@ -102,11 +110,11 @@ describe('proxy group key exchange', () => {
         await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
         await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
-        const responseContent = utf8ToBinary(new GroupKeyResponse({
+        const groupKeyResponse = new OldGroupKeyResponse({
             recipient: publisherUserId,
             requestId: 'requestId',
             encryptedGroupKeys: []
-        }).serialize())
+        })
         const response = new StreamMessage({
             messageId: new MessageID(
                 StreamPartIDUtils.getStreamID(STREAM_PART_ID),
@@ -117,13 +125,15 @@ describe('proxy group key exchange', () => {
                 '0'
             ),
             messageType: StreamMessageType.GROUP_KEY_RESPONSE,
-            encryptionType: EncryptionType.RSA,
-            content: responseContent,
+            contentType: ContentType.BINARY,
+            encryptionType: EncryptionType.NONE,
+            content: convertGroupKeyResponseToBytes(groupKeyResponse),
+            signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('1234')
         })
 
         await Promise.all([
-            waitForEvent3(subscriber.stack.getStreamrNode()! as any, 'newMessage'),
+            waitForEvent3(subscriber.stack.getStreamrNode() as any, 'newMessage'),
             publisher.broadcast(response)
         ])
     })

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 = {
-        kademliaId: 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
@@ -50,7 +48,8 @@ describe('random graph with real connections', () => {
                 layer1Node: epDhtNode,
                 transport: epDhtNode.getTransport(),
                 connectionLocker: epDhtNode.getTransport() as ConnectionManager,
-                localPeerDescriptor: epPeerDescriptor
+                localPeerDescriptor: epPeerDescriptor,
+                isLocalNodeEntryPoint: () => false
             }
         )
         randomGraphNode2 = createRandomGraphNode({
@@ -58,28 +57,32 @@ describe('random graph with real connections', () => {
             layer1Node: dhtNode1,
             transport: dhtNode1.getTransport(),
             connectionLocker: dhtNode1.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode1.getLocalPeerDescriptor()
+            localPeerDescriptor: dhtNode1.getLocalPeerDescriptor(),
+            isLocalNodeEntryPoint: () => false
         })
         randomGraphNode3 = createRandomGraphNode({
             streamPartId,
             layer1Node: dhtNode2,
             transport: dhtNode2.getTransport(),
             connectionLocker: dhtNode2.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode2.getLocalPeerDescriptor()
+            localPeerDescriptor: dhtNode2.getLocalPeerDescriptor(),
+            isLocalNodeEntryPoint: () => false
         })
         randomGraphNode4 = createRandomGraphNode({
             streamPartId,
             layer1Node: dhtNode3,
             transport: dhtNode3.getTransport(),
             connectionLocker: dhtNode3.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode3.getLocalPeerDescriptor()
+            localPeerDescriptor: dhtNode3.getLocalPeerDescriptor(),
+            isLocalNodeEntryPoint: () => false
         })
         randomGraphNode5 = createRandomGraphNode({
             streamPartId,
             layer1Node: dhtNode4,
             transport: dhtNode4.getTransport(),
             connectionLocker: dhtNode4.getTransport() as ConnectionManager,
-            localPeerDescriptor: dhtNode4.getLocalPeerDescriptor()
+            localPeerDescriptor: dhtNode4.getLocalPeerDescriptor(),
+            isLocalNodeEntryPoint: () => false
         })
         await epDhtNode.joinDht([epPeerDescriptor])
         await Promise.all([
@@ -119,32 +122,32 @@ describe('random graph with real connections', () => {
 
     it('can fully connected topologies ', async () => {
         await waitForCondition(() => {
-            return randomGraphNode1.getTargetNeighborIds().length >= 3
-                && randomGraphNode2.getTargetNeighborIds().length >= 3
-                && randomGraphNode3.getTargetNeighborIds().length >= 3
-                && randomGraphNode4.getTargetNeighborIds().length >= 3
-                && randomGraphNode5.getTargetNeighborIds().length >= 3
+            return randomGraphNode1.getNeighbors().length >= 3
+                && randomGraphNode2.getNeighbors().length >= 3
+                && randomGraphNode3.getNeighbors().length >= 3
+                && randomGraphNode4.getNeighbors().length >= 3
+                && randomGraphNode5.getNeighbors().length >= 3
         }, 10000)
-        expect(randomGraphNode1.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode2.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode3.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode4.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode5.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
+        expect(randomGraphNode1.getNeighbors().length).toBeGreaterThanOrEqual(3)
+        expect(randomGraphNode2.getNeighbors().length).toBeGreaterThanOrEqual(3)
+        expect(randomGraphNode3.getNeighbors().length).toBeGreaterThanOrEqual(3)
+        expect(randomGraphNode4.getNeighbors().length).toBeGreaterThanOrEqual(3)
+        expect(randomGraphNode5.getNeighbors().length).toBeGreaterThanOrEqual(3)
     })
 
     it('can propagate messages', async () => {
-        let numOfMessagesReceived = 0
-        randomGraphNode2.on('message', () => numOfMessagesReceived += 1)
-        randomGraphNode3.on('message', () => numOfMessagesReceived += 1)
-        randomGraphNode4.on('message', () => numOfMessagesReceived += 1)
-        randomGraphNode5.on('message', () => numOfMessagesReceived += 1)
+        let receivedMessageCount = 0
+        randomGraphNode2.on('message', () => receivedMessageCount += 1)
+        randomGraphNode3.on('message', () => receivedMessageCount += 1)
+        randomGraphNode4.on('message', () => receivedMessageCount += 1)
+        randomGraphNode5.on('message', () => receivedMessageCount += 1)
 
         await waitForCondition(() => {
-            return randomGraphNode1.getTargetNeighborIds().length >= 3
-                && randomGraphNode2.getTargetNeighborIds().length >= 3
-                && randomGraphNode3.getTargetNeighborIds().length >= 3
-                && randomGraphNode4.getTargetNeighborIds().length >= 3
-                && randomGraphNode5.getTargetNeighborIds().length >= 3
+            return randomGraphNode1.getNeighbors().length >= 3
+                && randomGraphNode2.getNeighbors().length >= 3
+                && randomGraphNode3.getNeighbors().length >= 3
+                && randomGraphNode4.getNeighbors().length >= 3
+                && randomGraphNode5.getNeighbors().length >= 3
         }, 10000)
 
         const msg = createStreamMessage(
@@ -153,6 +156,6 @@ describe('random graph with real connections', () => {
             randomEthereumAddress()
         )
         randomGraphNode1.broadcast(msg)
-        await waitForCondition(() => numOfMessagesReceived >= 4)
+        await waitForCondition(() => receivedMessageCount >= 4)
     })
 })

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

@@ -1,10 +1,9 @@
-import { getRandomRegion } from '@streamr/dht'
+import { getNodeIdFromPeerDescriptor, getRandomRegion } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
 describe('Full node network with WebRTC connections', () => {
@@ -34,8 +33,8 @@ describe('Full node network with WebRTC connections', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
-        entryPoint.getStreamrNode()!.joinStreamPart(streamPartId)
+        entryPoint.getStreamrNode().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+        entryPoint.getStreamrNode().joinStreamPart(streamPartId)
 
         await Promise.all(range(NUM_OF_NODES).map(async () => {
             const peerDescriptor = createMockPeerDescriptor()
@@ -63,16 +62,16 @@ describe('Full node network with WebRTC connections', () => {
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
             waitForCondition(() => {
-                return node.getStreamrNode()!.getNeighbors(streamPartId).length >= 3
+                return node.getStreamrNode().getNeighbors(streamPartId).length >= 3
             }
-            , 120000)
+            , 30000)
         ))
-        let numOfMessagesReceived = 0
+        let receivedMessageCount = 0
         const successIds: string[] = []
         nodes.forEach((node) => {
-            node.getStreamrNode()!.on('newMessage', () => {
-                successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
-                numOfMessagesReceived += 1
+            node.getStreamrNode().on('newMessage', () => {
+                successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode().getPeerDescriptor()))
+                receivedMessageCount += 1
             })
         })
         const msg = createStreamMessage(
@@ -80,8 +79,8 @@ describe('Full node network with WebRTC connections', () => {
             streamPartId,
             randomEthereumAddress()
         )
-        entryPoint.getStreamrNode()!.broadcast(msg)
-        await waitForCondition(() => numOfMessagesReceived === NUM_OF_NODES)
+        entryPoint.getStreamrNode().broadcast(msg)
+        await waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
     }, 120000)
 
 })