@streamr/trackerless-network 0.0.1-tatum.0

package/test/benchmark/first-message.ts

@@ -0,0 +1,155 @@
+/* eslint-disable no-console */
+
+import { PeerID, LatencyType, Simulator, getRandomRegion } from '@streamr/dht'
+import fs from 'fs'
+import { createNetworkNodeWithSimulator } from '../utils/utils'
+import { NetworkNode } from '../../src/NetworkNode'
+import { PeerDescriptor } from '../../../dht/src/exports'
+import { StreamMessage, toStreamID, MessageID, StreamPartIDUtils, StreamMessageType, toStreamPartID, StreamPartID } from '@streamr/protocol'
+import { waitForEvent3 } from '@streamr/utils'
+import { streamPartIdToDataKey } from '../../src/logic/StreamEntryPointDiscovery'
+
+const numNodes = 10000
+
+let nodes: NetworkNode[]
+let simulator: Simulator
+let layer0Ep: PeerDescriptor
+const publishIntervals: NodeJS.Timeout[] = []
+const streams: Map<StreamPartID, NetworkNode> = new Map()
+let currentNode: NetworkNode
+let publishInterval: NodeJS.Timeout | undefined
+let i = 0
+
+const prepareLayer0 = async () => {
+    console.log('Preparing network')
+    nodes = []
+    simulator = new Simulator(LatencyType.REAL)
+    const entryPointId = PeerID.generateRandom()
+    const peerDescriptor = {
+        kademliaId: entryPointId.value,
+        region: getRandomRegion(),
+        type: 0,
+        nodeName: 'entrypoint'
+    }
+    layer0Ep = peerDescriptor
+    const entryPoint = createNetworkNodeWithSimulator(peerDescriptor, simulator, [peerDescriptor])
+    await entryPoint.start()    
+    nodes.push(entryPoint)
+
+    console.log('Entrypoint ready')
+}
+
+const prepareStream = async (streamId: string) => {
+    console.log('Preparing stream ')
+    const publisherId = PeerID.generateRandom()
+    const peerDescriptor = {
+        kademliaId: publisherId.value,
+        region: getRandomRegion(),
+        type: 0,
+        nodeName: streamId
+    }
+    const streamPartId = toStreamPartID(toStreamID(streamId), 0)
+    const streamPublisher = createNetworkNodeWithSimulator(peerDescriptor, simulator, [layer0Ep])
+    await streamPublisher.start()
+    streamPublisher.subscribe(streamPartId)
+    nodes.push(streamPublisher)
+    streams.set(streamPartId, streamPublisher)
+}
+
+const shutdownNetwork = async () => {
+    publishIntervals.map((interval) => clearInterval(interval))
+    await Promise.all([
+        ...nodes.map((node) => node.stop())
+    ])
+    simulator.stop()
+}
+
+const measureJoiningTime = async (count: number) => {
+    const nodeId = PeerID.generateRandom()
+    const peerDescriptor = {
+        kademliaId: nodeId.value,
+        type: 0,
+        region: getRandomRegion(),
+        nodeName: `${count}`
+    }
+    console.log('starting node with id ', nodeId.toKey())
+
+    // start publishing ons stream
+    const stream = Array.from(streams.keys())[Math.floor(Math.random() * streams.size)]
+    console.log(stream)
+    publishInterval = setInterval(() => {
+        i += 1
+        const streamMessage = new StreamMessage({
+            messageId: new MessageID(
+                StreamPartIDUtils.getStreamID(stream),
+                0,
+                i,
+                Math.floor(Math.random() * 20000),
+                'peer' as any,
+                'msgChainId'
+            ),
+            prevMsgRef: null,
+            content: {
+                hello: 'world'
+            },
+            messageType: StreamMessageType.MESSAGE,
+            signature: 'signature',
+        })
+        streams.get(stream)!.publish(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.getLayer0DhtNode().getPeerDescriptor()])
+    currentNode = streamSubscriber
+    const start = performance.now()
+    await streamSubscriber.start()
+
+    await Promise.all([
+        waitForEvent3(streamSubscriber.stack.getStreamrNode() as any, 'newMessage', 60000),
+        streamSubscriber.subscribe(stream)
+    ])
+
+    const end = performance.now()
+
+    nodes.push(streamSubscriber)
+    clearInterval(publishInterval)
+    publishInterval = undefined
+    return end - start
+}
+
+const run = async () => {
+    Simulator.useFakeTimers()
+    await prepareLayer0()
+    for (let i = 0; i < 20; i++) {
+        await prepareStream(`stream-${i}`)
+    }
+    const logFile = fs.openSync('FirstMessageTime.log', 'w')
+    
+    fs.writeSync(logFile, 'Network size' + '\t' + 'Time to receive first message time (ms)' + '\n')
+    for (let i = 0; i < numNodes; i++) {
+        const time = await measureJoiningTime(i)
+        console.log(`Time to receive first message for ${i + 1} nodes network: ${time}ms`)
+        fs.writeSync(logFile, `${i + 1}` + '\t' + `${Math.round(time)}\n`)
+    }
+    fs.closeSync(logFile)
+    await shutdownNetwork()
+    Simulator.useFakeTimers(false)
+} 
+
+// eslint-disable-next-line promise/catch-or-return
+run().then(() => {
+    console.log('done')
+}).catch((err) => {
+    console.error(err)
+    const streamParts = currentNode.stack.getStreamrNode()!.getStreamParts()
+    const foundData = nodes[0].stack.getLayer0DhtNode().getDataFromDht(streamPartIdToDataKey(streamParts[0]))
+    console.log(foundData)
+    console.log(currentNode.stack.getLayer0DhtNode().getKBucketPeers().length)
+    console.log(currentNode.stack.getLayer0DhtNode().getNumberOfConnections())
+    console.log(currentNode.stack.getStreamrNode().getStream(streamParts[0])!.layer1!.getKBucketPeers())
+    console.log(currentNode.stack.getStreamrNode().getStream(streamParts[0])!.layer2.getTargetNeighborStringIds())
+    console.log(nodes[nodes.length - 1])
+    if (publishInterval) {
+        clearInterval(publishInterval)
+    }
+})

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

@@ -0,0 +1,119 @@
+import { PeerDescriptor, NodeType, PeerID } from '@streamr/dht'
+import { NetworkNode } from '../../src/NetworkNode'
+import { MessageID, MessageRef, StreamMessage, StreamMessageType, toStreamID, toStreamPartID } from '@streamr/protocol'
+import { EthereumAddress } from 'streamr-client'
+import { waitForCondition } from '@streamr/utils'
+
+describe('inspect', () => {
+
+    const publisherDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('publisher').value,
+        type: NodeType.NODEJS,
+        websocket: {
+            ip: 'localhost',
+            port: 15478
+        }
+    }
+
+    const inspectedDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('inspected').value,
+        type: NodeType.NODEJS,
+        websocket: {
+            ip: 'localhost',
+            port: 15479
+        }
+    }
+
+    const inspectorDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString('inspector').value,
+        type: NodeType.NODEJS,
+        websocket: {
+            ip: 'localhost',
+            port: 15480
+        }
+    }
+
+    const streamPartId = toStreamPartID(toStreamID('stream'), 0)
+
+    let publisherNode: NetworkNode
+
+    let inspectedNode: NetworkNode
+
+    let inspectorNode: NetworkNode
+
+    const message = new StreamMessage({ 
+        messageId: new MessageID(
+            toStreamID('stream'),
+            0,
+            666,
+            0,
+            'peer' as EthereumAddress,
+            'msgChainId'
+        ),
+        prevMsgRef: new MessageRef(665, 0),
+        content: {
+            hello: 'world'
+        },
+        messageType: StreamMessageType.MESSAGE,
+        signature: 'signature',
+    })
+    
+    beforeEach(async () => {
+        publisherNode = new NetworkNode({
+            layer0: {
+                entryPoints: [publisherDescriptor],
+                peerDescriptor: publisherDescriptor
+            },
+            networkNode: {}
+        })
+
+        inspectedNode = new NetworkNode({
+            layer0: {
+                entryPoints: [publisherDescriptor],
+                peerDescriptor: inspectedDescriptor
+            },
+            networkNode: {}
+        })
+
+        inspectorNode = new NetworkNode({
+            layer0: {
+                entryPoints: [publisherDescriptor],
+                peerDescriptor: inspectorDescriptor
+            },
+            networkNode: {}
+        })
+
+        await publisherNode.start()
+        await inspectedNode.start()
+        await inspectorNode.start()    
+
+        await Promise.all([
+            publisherNode.stack.getStreamrNode()!.joinStream(streamPartId),
+            inspectedNode.stack.getStreamrNode()!.joinStream(streamPartId),
+            inspectorNode.stack.getStreamrNode()!.joinStream(streamPartId)
+        ])
+
+        await waitForCondition(() => 
+            publisherNode.getNeighbors().length === 2 
+            && inspectedNode.getNeighbors().length === 2 
+            && inspectorNode.getNeighbors().length === 2
+        )
+    }, 30000)
+
+    afterEach(async () => {
+        await Promise.all([
+            publisherNode.stop(),
+            inspectedNode.stop(),
+            inspectorNode.stop()
+        ])
+    })
+
+    it('should inspect succesfully', async () => {
+        setTimeout(async () => {
+            await publisherNode.publish(message)
+        }, 250)
+        const success = await inspectorNode.inspect(inspectedDescriptor, streamPartId)
+        expect(success).toBe(true)
+    })
+
+})

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

@@ -0,0 +1,140 @@
+import { NodeType, PeerDescriptor, PeerID } from '@streamr/dht'
+import { NetworkNode } from '../../src/NetworkNode'
+import { MessageID, MessageRef, StreamID, StreamMessage, StreamMessageType, toStreamID, toStreamPartID } from '@streamr/protocol'
+import { EthereumAddress, waitForEvent3 } from '@streamr/utils'
+import { ProxyDirection, StreamMessage as InternalStreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { StreamNodeType } from '../../src/logic/StreamrNode'
+
+const createMessage = (streamId: StreamID): StreamMessage => {
+    return new StreamMessage({ 
+        messageId: new MessageID(
+            streamId,
+            0,
+            666,
+            0,
+            'peer' as EthereumAddress,
+            'msgChainId'
+        ),
+        prevMsgRef: new MessageRef(665, 0),
+        content: {
+            hello: 'world'
+        },
+        messageType: StreamMessageType.MESSAGE,
+        signature: 'signature',
+    })
+}
+
+describe('proxy and full node', () => {
+
+    const proxyNodeDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`proxyNode`).value,
+        type: NodeType.NODEJS,
+        nodeName: 'proxyNode',
+        websocket: { ip: 'localhost', port: 23135 }
+    }
+    const proxiedNodeDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`proxiedNode`).value,
+        type: NodeType.NODEJS,
+    }
+
+    const proxyStreamId = toStreamPartID(toStreamID('proxy-stream'), 0)
+    const regularStreamId1 = toStreamPartID(toStreamID('regular-stream1'), 0)
+    const regularStreamId2 = toStreamPartID(toStreamID('regular-stream2'), 0)
+    const regularStreamId3 = toStreamPartID(toStreamID('regular-stream3'), 0)
+    const regularStreamId4 = toStreamPartID(toStreamID('regular-stream4'), 0)
+
+    const proxiedMessage = createMessage(toStreamID('proxy-stream'))
+    const regularMessage1 = createMessage(toStreamID('regular-stream1'))
+    const regularMessage2 = createMessage(toStreamID('regular-stream2'))
+    const regularMessage3 = createMessage(toStreamID('regular-stream3'))
+    const regularMessage4 = createMessage(toStreamID('regular-stream4'))
+
+    let proxyNode: NetworkNode
+    let proxiedNode: NetworkNode
+
+    beforeEach(async () => {
+        proxyNode = new NetworkNode({
+            layer0: {
+                entryPoints: [proxyNodeDescriptor],
+                peerDescriptor: proxyNodeDescriptor,
+            },
+            networkNode: {
+                acceptProxyConnections: true
+            }
+        })
+        await proxyNode.start()
+        await proxyNode.stack.getStreamrNode()!.joinStream(proxyStreamId)
+        await proxyNode.stack.getStreamrNode()!.joinStream(regularStreamId1)
+        await proxyNode.stack.getStreamrNode()!.joinStream(regularStreamId2)
+        await proxyNode.stack.getStreamrNode()!.joinStream(regularStreamId3)
+        await proxyNode.stack.getStreamrNode()!.joinStream(regularStreamId4)
+
+        proxiedNode = new NetworkNode({
+            layer0: {
+                entryPoints: [proxyNodeDescriptor],
+                peerDescriptor: proxiedNodeDescriptor,
+            },
+            networkNode: {}
+        })
+        await proxiedNode.start(false)
+    })
+
+    afterEach(async () => {
+        await proxyNode.stop()
+        await proxiedNode.stop()
+    })
+
+    it('proxied node can act as full node on another stream', async () => {
+        await proxiedNode.setProxies(proxyStreamId, [proxyNodeDescriptor], ProxyDirection.PUBLISH, async () => 'proxiedNode', 1)
+        expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(false)
+
+        await Promise.all([
+            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage'),
+            proxiedNode.publish(regularMessage1)
+        ])
+
+        expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(true)
+
+        await Promise.all([
+            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage'),
+            proxiedNode.publish(proxiedMessage)
+        ])
+
+        expect(proxiedNode.stack.getStreamrNode().getStream(proxyStreamId)!.type).toBe(StreamNodeType.PROXY)
+        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamId1)!.type).toBe(StreamNodeType.RANDOM_GRAPH)
+    })
+
+    it('proxied node can act as full node on multiple streams', async () => {
+        await proxiedNode.setProxies(proxyStreamId, [proxyNodeDescriptor], ProxyDirection.PUBLISH, async () => 'proxiedNode', 1)
+        expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(false)
+
+        await Promise.all([
+            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
+                (streamMessage: InternalStreamMessage) => streamMessage.messageRef!.streamId === 'regular-stream1'),
+            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
+                (streamMessage: InternalStreamMessage) => streamMessage.messageRef!.streamId === 'regular-stream2'),
+            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
+                (streamMessage: InternalStreamMessage) => streamMessage.messageRef!.streamId === 'regular-stream3'),
+            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
+                (streamMessage: InternalStreamMessage) => streamMessage.messageRef!.streamId === 'regular-stream4'),
+            proxiedNode.publish(regularMessage1),
+            proxiedNode.publish(regularMessage2),
+            proxiedNode.publish(regularMessage3),
+            proxiedNode.publish(regularMessage4)
+        ])
+
+        expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(true)
+
+        await Promise.all([
+            waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage'),
+            proxiedNode.publish(proxiedMessage)
+        ])
+
+        expect(proxiedNode.stack.getStreamrNode().getStream(proxyStreamId)!.type).toBe(StreamNodeType.PROXY)
+        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamId1)!.type).toBe(StreamNodeType.RANDOM_GRAPH)
+        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamId2)!.type).toBe(StreamNodeType.RANDOM_GRAPH)
+        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamId3)!.type).toBe(StreamNodeType.RANDOM_GRAPH)
+        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamId4)!.type).toBe(StreamNodeType.RANDOM_GRAPH)
+    })
+
+})

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

@@ -0,0 +1,228 @@
+import { NodeType, PeerDescriptor, PeerID, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '@streamr/dht'
+import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { EthereumAddress, waitForCondition, waitForEvent3 } from '@streamr/utils'
+import { NetworkNode } from '../../src/NetworkNode'
+import { MessageID, MessageRef, StreamMessage, StreamMessageType, toStreamID, toStreamPartID } from '@streamr/protocol'
+
+describe('Proxy connections', () => {
+
+    const proxyNodeDescriptor1: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`proxyNode1`).value,
+        type: NodeType.NODEJS,
+        nodeName: 'proxyNode',
+        websocket: { ip: 'localhost', port: 23132 }
+    }
+    const proxyNodeDescriptor2: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`proxyNode2`).value,
+        type: NodeType.NODEJS,
+        nodeName: 'proxyNode',
+        websocket: { ip: 'localhost', port: 23133 }
+    }
+    const proxiedNodeDescriptor: PeerDescriptor = {
+        kademliaId: PeerID.fromString(`proxiedNode`).value,
+        type: NodeType.NODEJS,
+    }
+    const proxiedPeerId = peerIdFromPeerDescriptor(proxiedNodeDescriptor)
+
+    const streamPartId = toStreamPartID(toStreamID('proxy-test'), 0)
+
+    const message = new StreamMessage({
+        messageId: new MessageID(
+            toStreamID('proxy-test'),
+            0,
+            666,
+            0,
+            'peer' as EthereumAddress,
+            'msgChainId'
+        ),
+        prevMsgRef: new MessageRef(665, 0),
+        content: {
+            hello: 'world'
+        },
+        messageType: StreamMessageType.MESSAGE,
+        signature: 'signature',
+    })
+
+    let proxyNode1: NetworkNode
+    let proxyNode2: NetworkNode
+    let proxiedNode: NetworkNode
+
+    beforeEach(async () => {
+        proxyNode1 = new NetworkNode({
+            layer0: {
+                entryPoints: [proxyNodeDescriptor1],
+                peerDescriptor: proxyNodeDescriptor1,
+            },
+            networkNode: {
+                acceptProxyConnections: true
+            }
+        })
+        await proxyNode1.start()
+        await proxyNode1.setStreamPartEntryPoints(streamPartId, [proxyNodeDescriptor1])
+        await proxyNode1.stack.getStreamrNode()!.joinStream(streamPartId)
+       
+        proxyNode2 = new NetworkNode({
+            layer0: {
+                entryPoints: [proxyNodeDescriptor1],
+                peerDescriptor: proxyNodeDescriptor2,
+            },
+            networkNode: {
+                acceptProxyConnections: true
+            }
+        })
+        await proxyNode2.start()
+        proxyNode2.setStreamPartEntryPoints(streamPartId, [proxyNodeDescriptor1])
+        await proxyNode2.stack.getStreamrNode()!.joinStream(streamPartId)
+
+        proxiedNode = new NetworkNode({
+            layer0: {
+                entryPoints: [proxyNodeDescriptor1],
+                peerDescriptor: proxiedNodeDescriptor,
+            },
+            networkNode: {}
+        })
+        await proxiedNode.start(false)
+    }, 30000)
+
+    afterEach(async () => {
+        await proxyNode1.stop()
+        await proxyNode2.stop()
+        await proxiedNode.stop()
+    })
+
+    it('happy path publishing', async () => {
+        await proxiedNode.setProxies(streamPartId, [proxyNodeDescriptor1], ProxyDirection.PUBLISH, async () => 'proxiedNode', 1)
+
+        await Promise.all([
+            waitForEvent3(proxyNode1.stack.getStreamrNode()! as any, 'newMessage'),
+            proxiedNode.publish(message)
+        ])
+    })
+
+    it('happy path subscribing', async () => {
+        await proxiedNode.setProxies(streamPartId, [proxyNodeDescriptor1], ProxyDirection.SUBSCRIBE, async () => 'proxiedNode', 1)
+        proxiedNode.subscribe(streamPartId)
+        await Promise.all([
+            waitForEvent3(proxiedNode.stack.getStreamrNode()! as any, 'newMessage'),
+            proxyNode1.publish(message)
+        ])
+    })
+
+    it('can leave proxy publish connection', async () => {
+        await proxiedNode.setProxies(streamPartId, [proxyNodeDescriptor1], ProxyDirection.PUBLISH, async () => 'proxiedNode', 1)
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(true) 
+        expect(proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.PUBLISH)).toBe(true) 
+
+        await proxiedNode.setProxies(streamPartId, [], ProxyDirection.PUBLISH, async () => 'proxiedNode', 0)
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(false) 
+        await waitForCondition(() => 
+            proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.PUBLISH) === false)
+    })
+
+    it('can leave proxy subscribe connection', async () => {
+        await proxiedNode.setProxies(streamPartId, [proxyNodeDescriptor1], ProxyDirection.SUBSCRIBE, async () => 'proxiedNode', 1)
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(true) 
+        expect(proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(true) 
+
+        await proxiedNode.setProxies(streamPartId, [], ProxyDirection.SUBSCRIBE, async () => 'proxiedNode', 0)
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(false)
+        await waitForCondition(() => 
+            proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE) === false)
+
+    })
+
+    it('can open multiple proxy connections', async () => {
+        await proxiedNode.setProxies(
+            streamPartId,
+            [proxyNodeDescriptor1, proxyNodeDescriptor2],
+            ProxyDirection.SUBSCRIBE,
+            async () => 'proxiedNode'
+        )
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(true)
+        expect(proxiedNode.stack.getStreamrNode().getStream(streamPartId)!.layer2.getTargetNeighborStringIds().length).toBe(2)
+        expect(proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(true) 
+        expect(proxyNode2.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(true) 
+    })
+
+    it('can open multiple proxy connections and close one', async () => {
+        await proxiedNode.setProxies(
+            streamPartId,
+            [proxyNodeDescriptor1, proxyNodeDescriptor2],
+            ProxyDirection.SUBSCRIBE,
+            async () => 'proxiedNode'
+        )
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(true)
+        expect(proxiedNode.stack.getStreamrNode().getStream(streamPartId)!.layer2.getTargetNeighborStringIds().length).toBe(2)
+        expect(proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(true) 
+        expect(proxyNode2.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(true)
+        
+        await proxiedNode.setProxies(streamPartId, [proxyNodeDescriptor1], ProxyDirection.SUBSCRIBE, async () => 'proxiedNode')
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(true)
+        expect(proxiedNode.stack.getStreamrNode().getStream(streamPartId)!.layer2.getTargetNeighborStringIds().length).toBe(1)
+        await waitForCondition(() => 
+            proxyNode2.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE) === false)
+        expect(proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(true)
+    })
+
+    it('can open and close all connections', async () => {
+        await proxiedNode.setProxies(
+            streamPartId,
+            [proxyNodeDescriptor1, proxyNodeDescriptor2],
+            ProxyDirection.SUBSCRIBE,
+            async () => 'proxiedNode'
+        )
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(true)
+        expect(proxiedNode.stack.getStreamrNode().getStream(streamPartId)!.layer2.getTargetNeighborStringIds().length).toBe(2)
+        expect(proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(true) 
+        expect(proxyNode2.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(true)
+
+        await proxiedNode.setProxies(streamPartId, [], ProxyDirection.SUBSCRIBE, async () => 'proxiedNode')
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(false)
+        await waitForCondition(() => 
+            proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE) === false)
+        await waitForCondition(() => 
+            proxyNode2.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE) === false)
+    })
+
+    it('will reconnect if proxy node goes offline and comes back online', async () => {
+        await proxiedNode.setProxies(
+            streamPartId,
+            [proxyNodeDescriptor1],
+            ProxyDirection.SUBSCRIBE,
+            async () => 'proxiedNode'
+        )
+        expect(proxiedNode.hasStreamPart(streamPartId)).toBe(true)
+        proxyNode1.unsubscribe(streamPartId)
+        await waitForCondition(() => 
+            proxiedNode.hasProxyConnection(streamPartId, keyFromPeerDescriptor(proxyNodeDescriptor1), ProxyDirection.SUBSCRIBE))
+        expect(proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(false)
+    
+        await proxyNode1.stack.getStreamrNode()!.joinStream(streamPartId)
+        await waitForCondition(() => 
+            proxiedNode.hasProxyConnection(streamPartId, keyFromPeerDescriptor(proxyNodeDescriptor1), ProxyDirection.SUBSCRIBE)
+        , 25000)
+        expect(proxyNode1.hasProxyConnection(streamPartId, proxiedPeerId.toKey(), ProxyDirection.SUBSCRIBE)).toBe(false)
+
+    }, 30000)
+
+    it('cannot subscribe on proxy publish streams', async () => {
+        await proxiedNode.setProxies(
+            streamPartId,
+            [proxyNodeDescriptor1],
+            ProxyDirection.PUBLISH,
+            async () => 'proxiedNode'
+        )
+        await expect(proxiedNode.subscribe(streamPartId)).rejects.toThrow('Cannot subscribe')
+    })
+
+    it('connect publish on proxy subscribe streams', async () => {
+        await proxiedNode.setProxies(
+            streamPartId,
+            [proxyNodeDescriptor1],
+            ProxyDirection.SUBSCRIBE,
+            async () => 'proxiedNode'
+        )
+        await expect(proxiedNode.publish(message)).rejects.toThrow('Cannot publish')
+    })
+
+})