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

package/test/unit/{StreamPartEntrypointDiscovery.test.ts → EntrypointDiscovery.test.ts}

@@ -1,28 +1,23 @@
-import { PeerDescriptor, RecursiveFindResult, isSamePeerDescriptor } from '@streamr/dht'
+import { PeerDescriptor, areEqualPeerDescriptors } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { wait } from '@streamr/utils'
 import { range } from 'lodash'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
-import { StreamPartEntryPointDiscovery } from '../../src/logic/StreamPartEntryPointDiscovery'
+import { EntryPointDiscovery } from '../../src/logic/EntryPointDiscovery'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { DataEntry } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { MockLayer1 } from '../utils/mock/MockLayer1'
+import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
 
-describe('StreamPartEntryPointDiscovery', () => {
+describe('EntryPointDiscovery', () => {
 
-    let entryPointDiscoveryWithData: StreamPartEntryPointDiscovery
-    let entryPointDiscoveryWithoutData: StreamPartEntryPointDiscovery
+    let entryPointDiscoveryWithData: EntryPointDiscovery
+    let entryPointDiscoveryWithoutData: EntryPointDiscovery
     let storeCalled: number
 
-    const peerDescriptor = createMockPeerDescriptor({
-        nodeName: 'fake'
-    })
-    const deletedPeerDescriptor = createMockPeerDescriptor({
-        nodeName: 'deleted'
-    })
+    const peerDescriptor = createMockPeerDescriptor()
+    const deletedPeerDescriptor = createMockPeerDescriptor()
 
     const fakeData: DataEntry = {
         data: Any.pack(peerDescriptor, PeerDescriptor),
@@ -42,32 +37,22 @@ describe('StreamPartEntryPointDiscovery', () => {
         deleted: true
     }
 
-    const fakeGetEntryPointData = async (_key: Uint8Array): Promise<RecursiveFindResult> => {
-        return {
-            closestNodes: [peerDescriptor],
-            dataEntries: [fakeData, fakeDeletedData]
-        }
-    }
-
-    const fakegetEntryPointDataViaNode = async (_key: Uint8Array, _node: PeerDescriptor): Promise<DataEntry[]> => {
-        return [fakeData]
+    const fakeGetEntryPointData = async (): Promise<DataEntry[]> => {
+        return [fakeData, fakeDeletedData]
     }
 
-    const fakeStoreEntryPointData = async (_key: Uint8Array, _data: Any): Promise<PeerDescriptor[]> => {
+    const fakeStoreEntryPointData = async (): Promise<PeerDescriptor[]> => {
         storeCalled++
         return [peerDescriptor]
     }
 
-    const fakeEmptyGetEntryPointData = async (_key: Uint8Array): Promise<RecursiveFindResult> => {
-        return {
-            closestNodes: [],
-            dataEntries: []
-        }
+    const fakeEmptyGetEntryPointData = async (): Promise<DataEntry[]> => {
+        return []
     }
 
-    const fakeDeleteEntryPointData = async (_key: Uint8Array): Promise<void> => {}
+    const fakeDeleteEntryPointData = async (): Promise<void> => {}
 
-    const addNodesToStream = (layer1: MockLayer1, count: number) => {
+    const addNodesToStreamPart = (layer1: MockLayer1Node, count: number) => {
         range(count).forEach(() => {
             layer1.addNewRandomPeerToKBucket()
             layer1.addNewRandomPeerToKBucket()
@@ -76,30 +61,28 @@ describe('StreamPartEntryPointDiscovery', () => {
         })
     } 
 
-    let layer1: MockLayer1
+    let layer1Node: MockLayer1Node
 
     beforeEach(() => {
         storeCalled = 0
-        layer1 = new MockLayer1(getNodeIdFromPeerDescriptor(peerDescriptor))
-        entryPointDiscoveryWithData = new StreamPartEntryPointDiscovery({
+        layer1Node = new MockLayer1Node()
+        entryPointDiscoveryWithData = new EntryPointDiscovery({
             ownPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
-            layer1,
+            layer1Node,
             getEntryPointData: fakeGetEntryPointData,
-            getEntryPointDataViaNode: fakegetEntryPointDataViaNode,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
-            cacheInterval: 2000
+            storeInterval: 2000
         })
-        entryPointDiscoveryWithoutData = new StreamPartEntryPointDiscovery({
+        entryPointDiscoveryWithoutData = new EntryPointDiscovery({
             ownPeerDescriptor: peerDescriptor,
             streamPartId: STREAM_PART_ID,
-            layer1,
+            layer1Node,
             getEntryPointData: fakeEmptyGetEntryPointData,
-            getEntryPointDataViaNode: fakegetEntryPointDataViaNode,
             storeEntryPointData: fakeStoreEntryPointData,
             deleteEntryPointData: fakeDeleteEntryPointData,
-            cacheInterval: 2000
+            storeInterval: 2000
         })
     })
 
@@ -116,14 +99,14 @@ describe('StreamPartEntryPointDiscovery', () => {
     it('discoverEntryPointsFromDht does not have known entrypoints', async () => {
         const res = await entryPointDiscoveryWithData.discoverEntryPointsFromDht(0)
         expect(res.discoveredEntryPoints.length).toBe(1)
-        expect(isSamePeerDescriptor(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)
+        expect(areEqualPeerDescriptors(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)
     })
 
     it('discoverEntryPointsfromDht on an empty stream', async () => {
         const res = await entryPointDiscoveryWithoutData.discoverEntryPointsFromDht(0)
         expect(res.entryPointsFromDht).toEqual(true)
         expect(res.discoveredEntryPoints.length).toBe(1)
-        expect(isSamePeerDescriptor(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)  // ownPeerDescriptor
+        expect(areEqualPeerDescriptors(res.discoveredEntryPoints[0], peerDescriptor)).toBe(true)  // ownPeerDescriptor
     })
 
     it('store on empty stream', async () => {
@@ -132,7 +115,7 @@ describe('StreamPartEntryPointDiscovery', () => {
     })
 
     it('store on stream without saturated entrypoint count', async () => {
-        addNodesToStream(layer1, 4)
+        addNodesToStreamPart(layer1Node, 4)
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
     })
@@ -142,7 +125,7 @@ describe('StreamPartEntryPointDiscovery', () => {
         expect(storeCalled).toEqual(1)
         await wait(4500)
         await entryPointDiscoveryWithData.destroy()
-        // we have configured cacheInterval to 2 seconds, i.e. after 4.5 seconds it should have been called 2 more items 
+        // we have configured storeInterval to 2 seconds, i.e. after 4.5 seconds it should have been called 2 more items 
         expect(storeCalled).toEqual(3)
     })
 

package/test/unit/{HandshakerServer.test.ts → HandshakeRpcLocal.test.ts}

@@ -2,13 +2,16 @@ import { NodeType } from '@streamr/dht'
 import { hexToBinary } from '@streamr/utils'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { NodeList } from '../../src/logic/NodeList'
-import { HandshakerServer } from '../../src/logic/neighbor-discovery/HandshakerServer'
+import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
 import { InterleaveNotice, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { createMockPeerDescriptor, createMockRemoteHandshaker, createMockRemoteNode, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
-describe('HandshakerServer', () => {
+const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
 
-    let handshakerServer: HandshakerServer
+describe('HandshakeRpcLocal', () => {
+
+    let rpcLocal: HandshakeRpcLocal
 
     const ownPeerDescriptor = createMockPeerDescriptor()
 
@@ -22,28 +25,27 @@ describe('HandshakerServer', () => {
 
         handshakeWithInterleaving = jest.fn()
 
-        handshakerServer = new HandshakerServer({
-            randomGraphId: 'random-graph',
-            ownPeerDescriptor,
+        rpcLocal = new HandshakeRpcLocal({
+            streamPartId: STREAM_PART_ID,
             connectionLocker: mockConnectionLocker,
             ongoingHandshakes,
-            createRemoteHandshaker: (_p) => createMockRemoteHandshaker(),
-            createRemoteNode: (_p) => createMockRemoteNode(),
+            createRpcRemote: (_p) => createMockHandshakeRpcRemote(),
+            createDeliveryRpcRemote: (_p) => createMockDeliveryRpcRemote(),
             handshakeWithInterleaving: async (_p, _t) => {
                 handshakeWithInterleaving()
                 return true
             },
             targetNeighbors,
-            N: 4
+            maxNeighborCount: 4
         })
     })
 
     it('handshake', async () => {
         const req = StreamPartHandshakeRequest.create({
-            randomGraphId: 'random-graph',
+            streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
         })
-        const res = await handshakerServer.handshake(req, {
+        const res = await rpcLocal.handshake(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(res.accepted).toEqual(true)
@@ -52,15 +54,15 @@ describe('HandshakerServer', () => {
     })
 
     it('handshake interleave', async () => {
-        targetNeighbors.add(createMockRemoteNode())
-        targetNeighbors.add(createMockRemoteNode())
-        targetNeighbors.add(createMockRemoteNode())
-        targetNeighbors.add(createMockRemoteNode())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
         const req = StreamPartHandshakeRequest.create({
-            randomGraphId: 'random-graph',
+            streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
         })
-        const res = await handshakerServer.handshake(req, {
+        const res = await rpcLocal.handshake(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(res.accepted).toEqual(true)
@@ -73,10 +75,10 @@ describe('HandshakerServer', () => {
         ongoingHandshakes.add('0x4444' as NodeID)
         ongoingHandshakes.add('0x5555' as NodeID)
         const req = StreamPartHandshakeRequest.create({
-            randomGraphId: 'random-graph',
+            streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
         })
-        const res = await handshakerServer.handshake(req, {
+        const res = await rpcLocal.handshake(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(res.accepted).toEqual(false)
@@ -84,14 +86,14 @@ describe('HandshakerServer', () => {
 
     it('handshakeWithInterleaving success', async () => {
         const req: InterleaveNotice = {
-            randomGraphId: 'random-graph',
+            streamPartId: STREAM_PART_ID,
             interleaveTargetDescriptor: {
                 kademliaId: hexToBinary('0x2222'),
                 type: NodeType.NODEJS
             }
 
         }
-        await handshakerServer.interleaveNotice(req, {
+        await rpcLocal.interleaveNotice(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
@@ -99,13 +101,13 @@ describe('HandshakerServer', () => {
 
     it('handshakeWithInterleaving success', async () => {
         const req: InterleaveNotice = {
-            randomGraphId: 'wrong-random-graph',
+            streamPartId: StreamPartIDUtils.parse('other-stream#0'),
             interleaveTargetDescriptor: {
                 kademliaId: hexToBinary('0x2222'),
                 type: NodeType.NODEJS
             }
         }
-        await handshakerServer.interleaveNotice(req, {
+        await rpcLocal.interleaveNotice(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)

package/test/unit/Handshaker.test.ts

@@ -3,15 +3,16 @@ import { range } from 'lodash'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { NodeList } from '../../src/logic/NodeList'
 import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
-import { createMockPeerDescriptor, createMockRemoteNode, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Handshaker', () => {
 
     let handshaker: Handshaker
     const peerDescriptor = createMockPeerDescriptor()
 
-    const N = 4
-    const stream = 'stream#0'
+    const maxNeighborCount = 4
+    const streamPartId = StreamPartIDUtils.parse('stream#0')
 
     let targetNeighbors: NodeList
     let nearbyNodeView: NodeList
@@ -20,10 +21,11 @@ describe('Handshaker', () => {
     let simulator: Simulator
     let simulatorTransport: SimulatorTransport
     
-    beforeEach(() => {
+    beforeEach(async () => {
         simulator = new Simulator()
         simulatorTransport = new SimulatorTransport(peerDescriptor, simulator)
-        const rpcCommunicator = new ListeningRpcCommunicator(stream, simulatorTransport)
+        await simulatorTransport.start()
+        const rpcCommunicator = new ListeningRpcCommunicator(streamPartId, simulatorTransport)
 
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         targetNeighbors = new NodeList(nodeId, 10)
@@ -32,13 +34,13 @@ describe('Handshaker', () => {
 
         handshaker = new Handshaker({
             ownPeerDescriptor: peerDescriptor,
-            randomGraphId: stream,
+            streamPartId,
             connectionLocker: mockConnectionLocker,
             targetNeighbors,
             nearbyNodeView,
             randomNodeView,
             rpcCommunicator,
-            N
+            maxNeighborCount
         })
     })
 
@@ -53,7 +55,7 @@ describe('Handshaker', () => {
     })
 
     it('attemptHandshakesOnContact with known nodes that cannot be connected to', async () => {
-        range(2).forEach(() => nearbyNodeView.add(createMockRemoteNode()))
+        range(2).forEach(() => nearbyNodeView.add(createMockDeliveryRpcRemote()))
         const res = await handshaker.attemptHandshakesOnContacts([])
         expect(res.length).toEqual(2)
     })

package/test/unit/Inspector.test.ts

@@ -1,9 +1,10 @@
-import { ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
+import { ListeningRpcCommunicator } from '@streamr/dht'
 import { utf8ToBinary } from '@streamr/utils'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { Inspector } from '../../src/logic/inspect/Inspector'
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor, createRandomNodeId, mockConnectionLocker } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Inspector', () => {
     
@@ -28,10 +29,10 @@ describe('Inspector', () => {
         mockConnect = jest.fn(() => {})
         inspector = new Inspector({
             ownPeerDescriptor: inspectorDescriptor,
-            graphId: 'test',
+            streamPartId: StreamPartIDUtils.parse('stream#0'),
             rpcCommunicator: new ListeningRpcCommunicator('inspector', new MockTransport()),
             connectionLocker: mockConnectionLocker,
-            openInspectConnection: async (_peerDescriptor: PeerDescriptor, _lockId: string) => mockConnect()
+            openInspectConnection: async () => mockConnect()
         })
     })
 

package/test/unit/NeighborFinder.test.ts

@@ -3,7 +3,7 @@ import { NodeList } from '../../src/logic/NodeList'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { expect } from 'expect'
-import { createMockRemoteNode, createRandomNodeId } from '../utils/utils'
+import { createMockDeliveryRpcRemote, createRandomNodeId } from '../utils/utils'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 describe('NeighborFinder', () => {
@@ -13,12 +13,12 @@ describe('NeighborFinder', () => {
     let nearbyNodeView: NodeList
     let neighborFinder: NeighborFinder
 
-    const N = 4
+    const minCount = 4
 
     beforeEach(() => {
         targetNeighbors = new NodeList(nodeId, 15)
         nearbyNodeView = new NodeList(nodeId, 30)
-        range(30).forEach(() => nearbyNodeView.add(createMockRemoteNode()))
+        range(30).forEach(() => nearbyNodeView.add(createMockDeliveryRpcRemote()))
         const mockDoFindNeighbors = async (excluded: NodeID[]) => {
             const target = nearbyNodeView.getRandom(excluded)
             if (Math.random() < 0.5) {
@@ -32,7 +32,7 @@ describe('NeighborFinder', () => {
             targetNeighbors,
             nearbyNodeView,
             doFindNeighbors: (excluded) => mockDoFindNeighbors(excluded),
-            N
+            minCount
         })
     })
 
@@ -42,7 +42,7 @@ describe('NeighborFinder', () => {
 
     it('Finds target number of nodes', async () => {
         neighborFinder.start()
-        await waitForCondition(() => targetNeighbors.size() >= N, 10000)
+        await waitForCondition(() => targetNeighbors.size() >= minCount, 10000)
         expect(neighborFinder.isRunning()).toEqual(false)
     })
 })

package/test/unit/NodeList.test.ts

@@ -1,5 +1,5 @@
 import { NodeList } from '../../src/logic/NodeList'
-import { RemoteRandomGraphNode } from '../../src/logic/RemoteRandomGraphNode'
+import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
 import {
     PeerDescriptor,
     ListeningRpcCommunicator,
@@ -7,12 +7,16 @@ import {
     SimulatorTransport,
     NodeType,
 } from '@streamr/dht'
-import { NetworkRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { expect } from 'expect'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { createMockPeerDescriptor, createRandomNodeId } from '../utils/utils'
 import { binaryToHex } from '@streamr/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { formStreamPartDeliveryServiceId } from '../../src/logic/formStreamPartDeliveryServiceId'
+
+const streamPartId = StreamPartIDUtils.parse('stream#0')
 
 describe('NodeList', () => {
 
@@ -24,31 +28,36 @@ describe('NodeList', () => {
         new Uint8Array([1, 1, 5])
     ]
     const ownId = createRandomNodeId()
-    const graphId = 'test'
     let nodeList: NodeList
     let simulator: Simulator
     let mockTransports: SimulatorTransport[]
 
-    const createRemoteGraphNode = (peerDescriptor: PeerDescriptor) => {
+    const createRemoteGraphNode = async (peerDescriptor: PeerDescriptor) => {
         const mockTransport = new SimulatorTransport(peerDescriptor, simulator)
-        const mockCommunicator = new ListeningRpcCommunicator(`layer2-${ graphId }`, mockTransport)
+        await mockTransport.start()
+        const mockCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(streamPartId), mockTransport)
         const mockClient = mockCommunicator.getRpcClientTransport()
         
         mockTransports.push(mockTransport)
-        return new RemoteRandomGraphNode(createMockPeerDescriptor(), peerDescriptor, graphId, toProtoRpcClient(new NetworkRpcClient(mockClient)))
+        return new DeliveryRpcRemote(
+            createMockPeerDescriptor(),
+            peerDescriptor,
+            streamPartId,
+            toProtoRpcClient(new DeliveryRpcClient(mockClient))
+        )
     }
 
-    beforeEach(() => {
+    beforeEach(async () => {
         simulator = new Simulator()
         mockTransports = []
         nodeList = new NodeList(ownId, 6)
-        ids.forEach((id) => {
+        for (const id of ids) {
             const peerDescriptor: PeerDescriptor = {
                 kademliaId: id,
                 type: NodeType.NODEJS
             }
-            nodeList.add(createRemoteGraphNode(peerDescriptor))
-        })
+            nodeList.add(await createRemoteGraphNode(peerDescriptor))
+        }
     })
 
     afterEach(async ()=> {
@@ -59,12 +68,12 @@ describe('NodeList', () => {
         simulator.stop()
     })
 
-    it('add', () => {
+    it('add', async () => {
         const newDescriptor = {
             kademliaId: new Uint8Array([1, 2, 3]),
             type: NodeType.NODEJS
         }
-        const newNode = createRemoteGraphNode(newDescriptor)
+        const newNode = await createRemoteGraphNode(newDescriptor)
         nodeList.add(newNode)
         expect(nodeList.hasNode(newDescriptor)).toEqual(true)
 
@@ -72,7 +81,7 @@ describe('NodeList', () => {
             kademliaId: new Uint8Array([1, 2, 4]),
             type: NodeType.NODEJS
         }
-        const newNode2 = createRemoteGraphNode(newDescriptor2)
+        const newNode2 = await createRemoteGraphNode(newDescriptor2)
         nodeList.add(newNode2)
         expect(nodeList.hasNode(newDescriptor2)).toEqual(false)
     })

package/test/unit/{RemoteProxyServer.test.ts → ProxyConnectionRpcRemote.test.ts}

@@ -1,11 +1,11 @@
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary } from '@streamr/utils'
-import { RemoteProxyServer } from '../../src/logic/proxy/RemoteProxyServer'
+import { ProxyConnectionRpcRemote } from '../../src/logic/proxy/ProxyConnectionRpcRemote'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
-describe('RemoteProxyServer', () => {
+describe('ProxyConnectionRpcRemote', () => {
 
     it('happy path', () => {
         const client = {
@@ -13,14 +13,14 @@ describe('RemoteProxyServer', () => {
         }
         const clientPeerDescriptor = createMockPeerDescriptor()
         const serverPeerDescriptor = createMockPeerDescriptor()
-        const server = new RemoteProxyServer(
+        const rpcRemote = new ProxyConnectionRpcRemote(
             clientPeerDescriptor,
             serverPeerDescriptor,
             StreamPartIDUtils.parse('stream#0'),
             client
         )
         const userId = randomEthereumAddress()
-        server.requestConnection(ProxyDirection.PUBLISH, userId)
+        rpcRemote.requestConnection(ProxyDirection.PUBLISH, userId)
         expect(client.requestConnection).toBeCalledWith({
             direction: ProxyDirection.PUBLISH,
             userId: hexToBinary(userId)

package/test/unit/RandomGraphNode.test.ts

@@ -4,11 +4,12 @@ import { NodeList } from '../../src/logic/NodeList'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
 import { MockHandshaker } from '../utils/mock/MockHandshaker'
-import { MockLayer1 } from '../utils/mock/MockLayer1'
+import { MockLayer1Node } from '../utils/mock/MockLayer1Node'
 import { MockNeighborFinder } from '../utils/mock/MockNeighborFinder'
 import { MockNeighborUpdateManager } from '../utils/mock/MockNeighborUpdateManager'
 import { MockTransport } from '../utils/mock/Transport'
-import { createMockPeerDescriptor, createMockRemoteNode, mockConnectionLocker } from '../utils/utils'
+import { createMockPeerDescriptor, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('RandomGraphNode', () => {
 
@@ -19,27 +20,28 @@ describe('RandomGraphNode', () => {
     let nearbyNodeView: NodeList
     let randomNodeView: NodeList
 
-    let layer1: MockLayer1
+    let layer1Node: MockLayer1Node
+
     beforeEach(async () => {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
 
         targetNeighbors = new NodeList(nodeId, 10)
         randomNodeView = new NodeList(nodeId, 10)
         nearbyNodeView = new NodeList(nodeId, 10)
-        layer1 = new MockLayer1(nodeId)
+        layer1Node = new MockLayer1Node()
 
         randomGraphNode = createRandomGraphNode({
             targetNeighbors,
             randomNodeView,
             nearbyNodeView,
-            P2PTransport: new MockTransport(),
+            transport: new MockTransport(),
             ownPeerDescriptor: peerDescriptor,
-            layer1,
+            layer1Node,
             connectionLocker: mockConnectionLocker,
             handshaker: new MockHandshaker(),
             neighborUpdateManager: new MockNeighborUpdateManager(),
             neighborFinder: new MockNeighborFinder(),
-            randomGraphId: 'random-graph'
+            streamPartId: StreamPartIDUtils.parse('stream#0')
         })
         await randomGraphNode.start()
     })
@@ -49,7 +51,7 @@ describe('RandomGraphNode', () => {
     })
 
     it('getTargetNeighborIds', () => {
-        const mockRemote = createMockRemoteNode()
+        const mockRemote = createMockDeliveryRpcRemote()
         targetNeighbors.add(mockRemote)
         const ids = randomGraphNode.getTargetNeighborIds()
         expect(ids[0]).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
@@ -57,7 +59,7 @@ describe('RandomGraphNode', () => {
     })
 
     it('getNearbyNodeView', () => {
-        const mockRemote = createMockRemoteNode()
+        const mockRemote = createMockDeliveryRpcRemote()
         nearbyNodeView.add(mockRemote)
         const ids = randomGraphNode.getNearbyNodeView().getIds()
         expect(ids[0]).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
@@ -66,7 +68,7 @@ describe('RandomGraphNode', () => {
     it('Adds Closest Nodes from layer1 newContact event to nearbyNodeView', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
-        layer1.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
+        layer1Node.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => nearbyNodeView.size() === 2)
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
@@ -75,7 +77,7 @@ describe('RandomGraphNode', () => {
     it('Adds Random Nodes from layer1 newRandomContact event to randomNodeView', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
-        layer1.emit('newRandomContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
+        layer1Node.emit('newRandomContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => randomNodeView.size() === 2)
         expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
@@ -84,8 +86,8 @@ describe('RandomGraphNode', () => {
     it('Adds Nodes from layer1 KBucket to nearbyNodeView if its size is below nodeViewSize', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
-        layer1.addNewRandomPeerToKBucket()
-        layer1.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
+        layer1Node.addNewRandomPeerToKBucket()
+        layer1Node.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => nearbyNodeView.size() === 3)
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()