@streamr/trackerless-network 0.0.1-tatum.0

package/src/logic/DuplicateMessageDetector.ts

@@ -0,0 +1,167 @@
+/**
+ * Represent a pair of numbers (a,b). Ordering between two pairs is defined as
+ * follows. First compare first numbers. Compare second numbers if first are
+ * equal.
+ */
+export class NumberPair {
+    private readonly a
+    private readonly b
+
+    constructor(a: number, b: number) {
+        this.a = a
+        this.b = b
+    }
+
+    greaterThanOrEqual(otherPair: NumberPair): boolean {
+        return this.greaterThan(otherPair) || this.equalTo(otherPair)
+    }
+
+    greaterThan(otherPair: NumberPair): boolean {
+        return this.compareTo(otherPair) === 1
+    }
+
+    equalTo(otherPair: NumberPair): boolean {
+        return this.compareTo(otherPair) === 0
+    }
+
+    private compareTo(otherPair: NumberPair): number {
+        if (this.a > otherPair.a) {
+            return 1
+        }
+        if (this.a < otherPair.a) {
+            return -1
+        }
+        if (this.b > otherPair.b) {
+            return 1
+        }
+        if (this.b < otherPair.b) {
+            return -1
+        }
+        return 0
+    }
+
+    toString(): string {
+        return `${this.a}|${this.b}`
+    }
+}
+
+export class InvalidNumberingError extends Error {
+    constructor() {
+        super('pre-condition: previousNumber < number')
+    }
+}
+
+export class GapMisMatchError extends Error {
+    constructor(state: string, previousNumber: NumberPair, number: NumberPair) {
+        super('pre-condition: gap overlap in given numbers:'
+            + ` previousNumber=${previousNumber}, number=${number}, state=${state}`)
+    }
+}
+
+/**
+ *
+ * Keeps track of a stream's message numbers and reports already seen numbers
+ * as duplicates.
+ *
+ * Leverages the fact that message are assigned numbers from a strictly
+ * increasing integer sequence for lowered space complexity. For example,
+ * if we know that all messages up to number N have been seen, we can only
+ * store the number N to provide message identity check. This is because
+ * anything less than N can be deemed a duplicate.
+ *
+ * Messages arriving out-of-order makes this a bit harder since gaps form.
+ * Most of the code in this class is built to deal with this complexity.
+ * Basically, we need to keep track of which intervals [N,M] could still
+ * contain unseen messages. We should also remove intervals after we are sure
+ * that they contain no unseen messages.
+ *
+ * In addition to the above, there needs to be a limit to the number of
+ * intervals we store, as it could well be that some messages never
+ * arrive. The strategy is to start removing the lowest numbered
+ * intervals when storage limits are hit.
+ *
+ */
+export class DuplicateMessageDetector {
+    private readonly maxNumberOfGaps: number
+    private readonly gaps: Array<[NumberPair, NumberPair]>
+
+    constructor(maxNumberOfGaps = 10000) {
+        this.maxNumberOfGaps = maxNumberOfGaps
+        this.gaps = [] // ascending order of half-closed intervals (x,y] representing gaps that contain unseen message(s)
+    }
+
+    /**
+     * returns true if number has not yet been seen (i.e. is not a duplicate)
+     */
+    markAndCheck(previousNumber: NumberPair | null, number: NumberPair): boolean | never {
+        if (previousNumber && previousNumber.greaterThanOrEqual(number)) {
+            throw new InvalidNumberingError()
+        }
+
+        if (this.gaps.length === 0) {
+            this.gaps.push([number, new NumberPair(Infinity, Infinity)])
+            return true
+        }
+
+        // Handle special case where previousNumber is not provided. Only
+        // minimal duplicate detection is provided (comparing against latest
+        // known message number).
+        if (previousNumber === null) {
+            if (number.greaterThan(this.gaps[this.gaps.length - 1][0])) {
+                this.gaps[this.gaps.length - 1][0] = number
+                return true
+            }
+            return false
+        }
+
+        for (let i = this.gaps.length - 1; i >= 0; --i) {
+            const [lowerBound, upperBound] = this.gaps[i] // invariant: upperBound > lowerBound
+
+            // implies number > upperBound (would've been handled in previous iteration if gap exists)
+            if (previousNumber.greaterThanOrEqual(upperBound)) {
+                return false
+            }
+            if (previousNumber.greaterThanOrEqual(lowerBound)) {
+                if (number.greaterThan(upperBound)) {
+                    throw new GapMisMatchError(this.toString(), previousNumber, number)
+                }
+                if (previousNumber.equalTo(lowerBound)) {
+                    if (number.equalTo(upperBound)) {
+                        this.gaps.splice(i, 1)
+                    } else {
+                        this.gaps[i] = [number, upperBound]
+                    }
+                } else if (number.equalTo(upperBound)) {
+                    this.gaps[i] = [lowerBound, previousNumber]
+                } else {
+                    this.gaps.splice(i, 1, [lowerBound, previousNumber], [number, upperBound])
+                }
+
+                // invariants after:
+                //   - gaps are in ascending order
+                //   - the intersection between any two gaps is empty
+                //   - there are no gaps that define the empty set
+                //   - last gap is [n, Infinity]
+                //   - anything not covered by a gap is considered seen
+
+                this.dropLowestGapIfOverMaxNumberOfGaps()
+                return true
+            }
+            if (number.greaterThan(lowerBound)) {
+                throw new GapMisMatchError(this.toString(), previousNumber, number)
+            }
+        }
+        return false
+    }
+
+    private dropLowestGapIfOverMaxNumberOfGaps(): void {
+        // invariant: this.gaps.length <= this.maxNumberOfGaps + 1
+        if (this.gaps.length > this.maxNumberOfGaps) {
+            this.gaps.shift()
+        }
+    }
+
+    toString(): string {
+        return this.gaps.map(([lower, upper]) => `(${lower}, ${upper}]`).join(', ')
+    }
+}

package/src/logic/ILayer0.ts

@@ -0,0 +1,14 @@
+import { DataEntry, ITransport, PeerDescriptor, PeerID, RecursiveFindResult } from '@streamr/dht'
+import { Any } from '../proto/google/protobuf/any'
+
+export interface ILayer0 extends ITransport {
+    getPeerDescriptor(): PeerDescriptor
+    getNodeId(): PeerID
+    getDataFromDht(key: Uint8Array): Promise<RecursiveFindResult>
+    findDataViaPeer(key: Uint8Array, peer: PeerDescriptor): Promise<DataEntry[]>
+    storeDataToDht(key: Uint8Array, data: Any): Promise<PeerDescriptor[]>
+    deleteDataFromDht(key: Uint8Array): Promise<void>
+    getKnownEntryPoints(): PeerDescriptor[]
+    isJoinOngoing(): boolean
+    stop(): Promise<void>
+}

package/src/logic/IStreamNode.ts

@@ -0,0 +1,17 @@
+import { PeerIDKey } from '@streamr/dht'
+import { ProxyDirection, StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+
+export interface IStreamNode {
+        
+    on(event: 'message', listener: (message: StreamMessage) => void): this
+
+    once(event: 'message', listener: (message: StreamMessage) => void): this
+
+    off(event: 'message', listener: (message: StreamMessage) => void): void
+
+    broadcast(msg: StreamMessage, previousPeer?: string): void
+    hasProxyConnection(peerKey: PeerIDKey, direction: ProxyDirection): boolean
+    stop(): void
+    start(): Promise<void>
+    getTargetNeighborStringIds(): string[]
+}

package/src/logic/PeerList.ts

@@ -0,0 +1,106 @@
+import { keyFromPeerDescriptor, PeerDescriptor, PeerID, peerIdFromPeerDescriptor } from '@streamr/dht'
+import { sample } from 'lodash'
+import { RemoteRandomGraphNode } from './RemoteRandomGraphNode'
+import { EventEmitter } from 'eventemitter3'
+
+export interface Events {
+    peerAdded: (id: string, remote: RemoteRandomGraphNode) => any
+}
+
+const getValuesOfIncludedKeys = (peers: Map<string, RemoteRandomGraphNode>, exclude: string[]): RemoteRandomGraphNode[] => {
+    return Array.from(peers.entries())
+        .filter(([id, _peer]) => !exclude.includes(id))
+        .map(([_id, peer]) => peer)
+}
+
+export class PeerList extends EventEmitter<Events> {
+    private readonly peers: Map<string, RemoteRandomGraphNode>
+    private readonly limit: number
+    private ownPeerID: PeerID
+
+    constructor(ownPeerId: PeerID, limit: number) {
+        super()
+        this.peers = new Map()
+        this.limit = limit
+        this.ownPeerID = ownPeerId
+    }
+
+    add(remote: RemoteRandomGraphNode): void {
+        if (!this.ownPeerID.equals(peerIdFromPeerDescriptor(remote.getPeerDescriptor())) && this.peers.size < this.limit) {
+            const stringId = keyFromPeerDescriptor(remote.getPeerDescriptor())
+            const isExistingPeer = this.peers.has(stringId)
+            this.peers.set(stringId, remote)
+            
+            if (!isExistingPeer) {
+                this.emit('peerAdded', stringId, remote)
+            }
+        }
+    }
+
+    remove(peerDescriptor: PeerDescriptor): void {
+        this.peers.delete(keyFromPeerDescriptor(peerDescriptor))
+    }
+
+    removeById(stringId: string): void {
+        this.peers.delete(stringId)
+    }
+
+    hasPeer(peerDescriptor: PeerDescriptor): boolean {
+        return this.peers.has(keyFromPeerDescriptor(peerDescriptor))
+    }
+
+    hasPeerWithStringId(stringId: string): boolean {
+        return this.peers.has(stringId)
+    }
+
+    replaceAll(neighbors: RemoteRandomGraphNode[]): void {
+        this.peers.clear()
+        const limited = neighbors.splice(0, this.limit)
+        limited.forEach((remote) => {
+            this.add(remote)
+        })
+    }
+
+    getStringIds(): string[] {
+        return Array.from(this.peers.keys())
+    }
+
+    getNeighborById(id: string): RemoteRandomGraphNode | undefined {
+        return this.peers.get(id)
+    }
+
+    size(exclude: string[] = []): number {
+        return Array.from(this.peers.keys()).filter((peer) => !exclude.includes(peer)).length
+    }
+
+    getRandom(exclude: string[]): RemoteRandomGraphNode | undefined {
+        return sample(getValuesOfIncludedKeys(this.peers, exclude))
+    }
+
+    getClosest(exclude: string[]): RemoteRandomGraphNode | undefined {
+        const included = getValuesOfIncludedKeys(this.peers, exclude)
+        return included[0]
+    }
+
+    getClosestAndFurthest(exclude: string[]): RemoteRandomGraphNode[] {
+        const included = getValuesOfIncludedKeys(this.peers, exclude)
+        if (included.length === 0) {
+            return []
+        }
+        return included.length > 1 ? [this.getClosest(exclude)!, this.getFurthest(exclude)!] : [this.getClosest(exclude)!]
+    }
+
+    getFurthest(exclude: string[]): RemoteRandomGraphNode | undefined {
+        const included = getValuesOfIncludedKeys(this.peers, exclude)
+        return included[included.length - 1]
+    }
+
+    getPeers(): RemoteRandomGraphNode[] {
+        return Array.from(this.peers.values())
+    }
+
+    stop(): void {
+        this.peers.clear()
+        this.removeAllListeners()
+    }
+}

package/src/logic/RandomGraphNode.ts

@@ -0,0 +1,310 @@
+import { EventEmitter } from 'eventemitter3'
+import {
+    DhtNode,
+    PeerDescriptor,
+    DhtPeer,
+    ListeningRpcCommunicator,
+    ITransport,
+    ConnectionLocker,
+    keyFromPeerDescriptor,
+    PeerIDKey
+} from '@streamr/dht'
+import {
+    StreamMessage,
+    LeaveStreamNotice,
+    MessageRef,
+    StreamMessageType,
+    GroupKeyRequest,
+    TemporaryConnectionRequest,
+    TemporaryConnectionResponse,
+} from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { PeerList } from './PeerList'
+import { NetworkRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { RemoteRandomGraphNode } from './RemoteRandomGraphNode'
+import { INetworkRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { DuplicateMessageDetector } from './DuplicateMessageDetector'
+import { Logger } from '@streamr/utils'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { IHandshaker } from './neighbor-discovery/Handshaker'
+import { Propagation } from './propagation/Propagation'
+import { INeighborFinder } from './neighbor-discovery/NeighborFinder'
+import { INeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
+import { StreamNodeServer } from './StreamNodeServer'
+import { IStreamNode } from './IStreamNode'
+import { ProxyStreamConnectionServer } from './proxy/ProxyStreamConnectionServer'
+import { IInspector } from './inspect/Inspector'
+import { TemporaryConnectionRpcServer } from './temporary-connection/TemporaryConnectionRpcServer'
+import { markAndCheckDuplicate } from './utils'
+
+export interface Events {
+    message: (message: StreamMessage) => void
+    targetNeighborConnected: (stringId: string) => void
+    nearbyContactPoolIdAdded: () => void
+}
+
+export interface StrictRandomGraphNodeConfig {
+    randomGraphId: string
+    layer1: DhtNode
+    P2PTransport: ITransport
+    connectionLocker: ConnectionLocker
+    ownPeerDescriptor: PeerDescriptor
+    peerViewSize: number
+    nearbyContactPool: PeerList
+    randomContactPool: PeerList
+    targetNeighbors: PeerList
+    handshaker: IHandshaker
+    neighborFinder: INeighborFinder
+    neighborUpdateManager: INeighborUpdateManager
+    propagation: Propagation
+    rpcCommunicator: ListeningRpcCommunicator
+    numOfTargetNeighbors: number
+    maxNumberOfContacts: number
+    minPropagationTargets: number
+    name: string
+    acceptProxyConnections: boolean
+    neighborUpdateInterval: number
+    inspector: IInspector
+    temporaryConnectionServer: TemporaryConnectionRpcServer
+    proxyConnectionServer?: ProxyStreamConnectionServer
+}
+
+const logger = new Logger(module)
+
+export class RandomGraphNode extends EventEmitter<Events> implements IStreamNode {
+    private stopped = false
+    private started = false
+    private readonly duplicateDetectors: Map<string, DuplicateMessageDetector>
+    private config: StrictRandomGraphNodeConfig
+    private readonly server: INetworkRpc
+
+    constructor(config: StrictRandomGraphNodeConfig) {
+        super()
+        this.config = config
+        this.duplicateDetectors = new Map()
+        this.server = new StreamNodeServer({
+            ownPeerDescriptor: this.config.ownPeerDescriptor,
+            randomGraphId: this.config.randomGraphId,
+            rpcCommunicator: this.config.rpcCommunicator,
+            markAndCheckDuplicate: (msg: MessageRef, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
+            broadcast: (message: StreamMessage, previousPeer?: string) => this.broadcast(message, previousPeer),
+            onLeaveNotice: (notice: LeaveStreamNotice) => {
+                const senderId = notice.senderId
+                const contact = this.config.nearbyContactPool.getNeighborById(senderId)
+                || this.config.randomContactPool.getNeighborById(senderId)
+                || this.config.targetNeighbors.getNeighborById(senderId)
+                || this.config.proxyConnectionServer?.getConnection(senderId as PeerIDKey)?.remote
+                // TODO: check integrity of notifier?
+                if (contact) {
+                    this.config.layer1.removeContact(contact.getPeerDescriptor(), true)
+                    this.config.targetNeighbors.remove(contact.getPeerDescriptor())
+                    this.config.nearbyContactPool.remove(contact.getPeerDescriptor())
+                    this.config.connectionLocker.unlockConnection(contact.getPeerDescriptor(), this.config.randomGraphId)
+                    this.config.neighborFinder.start([senderId])
+                    this.config.proxyConnectionServer?.removeConnection(senderId as PeerIDKey)
+                }
+            },
+            markForInspection: (senderId: PeerIDKey, messageRef: MessageRef) => this.config.inspector.markMessage(senderId, messageRef)
+        })
+    }
+
+    async start(): Promise<void> {
+        this.started = true
+        this.registerDefaultServerMethods()
+        this.config.layer1.on('newContact', (peerDescriptor, closestPeers) => this.newContact(peerDescriptor, closestPeers))
+        this.config.layer1.on('contactRemoved', (peerDescriptor, closestPeers) => this.removedContact(peerDescriptor, closestPeers))
+        this.config.layer1.on('newRandomContact', (peerDescriptor, randomPeers) => this.newRandomContact(peerDescriptor, randomPeers))
+        this.config.layer1.on('randomContactRemoved', (peerDescriptor, randomPeers) => this.removedRandomContact(peerDescriptor, randomPeers))
+        this.config.P2PTransport.on('disconnected', (peerDescriptor: PeerDescriptor) => this.onPeerDisconnected(peerDescriptor))
+        this.config.targetNeighbors.on('peerAdded', (id, _remote) => {
+            this.config.propagation.onNeighborJoined(id)
+            this.emit('targetNeighborConnected', id)
+        })
+        this.config.proxyConnectionServer?.on('newConnection', (id: PeerIDKey) => {
+            this.config.propagation.onNeighborJoined(id)
+        })
+        const candidates = this.getNewNeighborCandidates()
+        if (candidates.length > 0) {
+            this.newContact(candidates[0], candidates)
+        } else {
+            logger.debug('layer1 had no closest contacts in the beginning')
+        }
+        this.config.neighborFinder.start()
+        await this.config.neighborUpdateManager.start()
+    }
+
+    private registerDefaultServerMethods(): void {
+        this.config.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendData',
+            (msg: StreamMessage, context) => this.server.sendData(msg, context))
+        this.config.rpcCommunicator.registerRpcNotification(LeaveStreamNotice, 'leaveStreamNotice',
+            (req: LeaveStreamNotice, context) => this.server.leaveStreamNotice(req, context))
+        this.config.rpcCommunicator.registerRpcMethod(TemporaryConnectionRequest, TemporaryConnectionResponse, 'openConnection',
+            (req: TemporaryConnectionRequest, context) => this.config.temporaryConnectionServer.openConnection(req, context))
+    }
+
+    private newContact(_newContact: PeerDescriptor, closestTen: PeerDescriptor[]): void {
+        logger.trace(`New nearby contact found`)
+        if (this.stopped) {
+            return
+        }
+      
+        const oldLength = this.config.nearbyContactPool.getStringIds().length
+        this.config.nearbyContactPool.replaceAll(closestTen.map((descriptor) =>
+            new RemoteRandomGraphNode(
+                descriptor,
+                this.config.randomGraphId,
+                toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            )
+        ))
+
+        if (oldLength < this.config.nearbyContactPool.getStringIds().length) {
+            this.emit('nearbyContactPoolIdAdded')
+        }
+        
+        if (this.config.targetNeighbors.size() < this.config.numOfTargetNeighbors) {
+            this.config.neighborFinder.start()
+        }
+    }
+
+    private removedContact(_removedContact: PeerDescriptor, closestTen: PeerDescriptor[]): void {
+        logger.trace(`Nearby contact removed`)
+        if (this.stopped) {
+            return
+        }
+        this.config.nearbyContactPool.replaceAll(closestTen.map((descriptor) =>
+            new RemoteRandomGraphNode(
+                descriptor,
+                this.config.randomGraphId,
+                toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            )
+        ))
+    }
+
+    private newRandomContact(_newDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]): void {
+        if (this.stopped) {
+            return
+        }
+        this.config.randomContactPool.replaceAll(randomPeers.map((descriptor) =>
+            new RemoteRandomGraphNode(
+                descriptor,
+                this.config.randomGraphId,
+                toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            )
+        ))
+        if (this.config.targetNeighbors.size() < this.config.numOfTargetNeighbors) {
+            this.config.neighborFinder.start()
+        }
+    }
+
+    private removedRandomContact(_removedDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]): void {
+        logger.trace(`New nearby contact found`)
+        if (this.stopped) {
+            return
+        }
+        this.config.randomContactPool!.replaceAll(randomPeers.map((descriptor) =>
+            new RemoteRandomGraphNode(
+                descriptor,
+                this.config.randomGraphId,
+                toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            )
+        ))
+    }
+
+    private onPeerDisconnected(peerDescriptor: PeerDescriptor): void {
+        if (this.config.targetNeighbors.hasPeer(peerDescriptor)) {
+            this.config.targetNeighbors.remove(peerDescriptor)
+            this.config.connectionLocker.unlockConnection(peerDescriptor, this.config.randomGraphId)
+            this.config.neighborFinder.start([keyFromPeerDescriptor(peerDescriptor)])
+            this.config.temporaryConnectionServer.removePeer(peerDescriptor)
+        }
+    }
+
+    private getNewNeighborCandidates(): PeerDescriptor[] {
+        return this.config.layer1.getNeighborList().getClosestContacts(this.config.peerViewSize).map((contact: DhtPeer) => {
+            return contact.getPeerDescriptor()
+        })
+    }
+
+    public hasProxyConnection(peerKey: PeerIDKey): boolean {
+        if (this.config.proxyConnectionServer) {
+            return this.config.proxyConnectionServer.hasConnection(peerKey)
+        }
+        return false
+    }
+
+    stop(): void {
+        if (!this.started) {
+            return
+        }
+        this.stopped = true
+        this.config.proxyConnectionServer?.stop()
+        this.config.targetNeighbors.getPeers().map((remote) => remote.leaveStreamNotice(this.config.ownPeerDescriptor))
+        this.config.rpcCommunicator.stop()
+        this.removeAllListeners()
+        this.config.layer1.off('newContact', (peerDescriptor, closestTen) => this.newContact(peerDescriptor, closestTen))
+        this.config.layer1.off('contactRemoved', (peerDescriptor, closestTen) => this.removedContact(peerDescriptor, closestTen))
+        this.config.layer1.off('newRandomContact', (peerDescriptor, randomPeers) => this.newRandomContact(peerDescriptor, randomPeers))
+        this.config.layer1.off('randomContactRemoved', (peerDescriptor, randomPeers) => this.removedRandomContact(peerDescriptor, randomPeers))
+        this.config.P2PTransport.off('disconnected', (peerDescriptor: PeerDescriptor) => this.onPeerDisconnected(peerDescriptor))
+        this.config.nearbyContactPool.stop()
+        this.config.targetNeighbors.stop()
+        this.config.randomContactPool.stop()
+        this.config.neighborFinder.stop()
+        this.config.neighborUpdateManager.stop()
+        this.config.inspector.stop()
+    }
+
+    broadcast(msg: StreamMessage, previousPeer?: string): void {
+        if (!previousPeer) {
+            markAndCheckDuplicate(this.duplicateDetectors, msg.messageRef!, msg.previousMessageRef)
+        }
+        this.emit('message', msg)
+        this.config.propagation.feedUnseenMessage(msg, this.getPropagationTargets(msg), previousPeer ?? null)
+    }
+
+    inspect(peerDescriptor: PeerDescriptor): Promise<boolean> {
+        return this.config.inspector.inspect(peerDescriptor)
+    }
+
+    private getPropagationTargets(msg: StreamMessage): string[] {
+        let propagationTargets = this.config.targetNeighbors.getStringIds()
+        if (this.config.proxyConnectionServer) {
+            const proxyTargets = (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST)
+                ? this.config.proxyConnectionServer.getPeerKeysForUserId(GroupKeyRequest.fromBinary(msg.content).recipient)
+                : this.config.proxyConnectionServer.getSubscribers()
+            propagationTargets = propagationTargets.concat(proxyTargets)
+        }
+
+        propagationTargets = propagationTargets.filter((target) => !this.config.inspector.isInspected(target as PeerIDKey))
+        propagationTargets = propagationTargets.concat(this.config.temporaryConnectionServer.getPeers().getStringIds())
+        return propagationTargets
+    }
+
+    getOwnStringId(): PeerIDKey {
+        return keyFromPeerDescriptor(this.config.ownPeerDescriptor)
+    }
+
+    getNumberOfOutgoingHandshakes(): number {
+        return this.config.handshaker.getOngoingHandshakes().size
+    }
+
+    getTargetNeighborStringIds(): string[] {
+        if (!this.started && this.stopped) {
+            return []
+        }
+        return this.config.targetNeighbors.getStringIds()
+    }
+
+    getNearbyContactPoolIds(): string[] {
+        if (!this.started && this.stopped) {
+            return []
+        }
+        return this.config.nearbyContactPool.getStringIds()
+    }
+
+    getRandomContactPoolIds(): string[] {
+        if (!this.started && this.stopped) {
+            return []
+        }
+        return this.config.randomContactPool.getStringIds()
+    }
+}

package/src/logic/Remote.ts

@@ -0,0 +1,19 @@
+import { PeerDescriptor } from '@streamr/dht'
+import { ProtoRpcClient } from '@streamr/proto-rpc'
+
+export abstract class Remote<T> {
+    protected remotePeerDescriptor: PeerDescriptor
+    protected client: ProtoRpcClient<T>
+    protected graphId: string
+
+    constructor(peerDescriptor: PeerDescriptor, graphId: string, client: ProtoRpcClient<T>) {
+        this.remotePeerDescriptor = peerDescriptor
+        this.client = client
+        this.graphId = graphId
+    }
+
+    getPeerDescriptor(): PeerDescriptor {
+        return this.remotePeerDescriptor
+    }
+
+}

package/src/logic/RemoteRandomGraphNode.ts

@@ -0,0 +1,39 @@
+import { INetworkRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { PeerDescriptor, DhtRpcOptions, keyFromPeerDescriptor } from '@streamr/dht'
+import {
+    StreamMessage,
+    LeaveStreamNotice
+} from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { Logger } from '@streamr/utils'
+import { Remote } from './Remote'
+
+const logger = new Logger(module)
+
+export class RemoteRandomGraphNode extends Remote<INetworkRpcClient> {
+
+    async sendData(ownPeerDescriptor: PeerDescriptor, msg: StreamMessage): Promise<void> {
+        const options: DhtRpcOptions = {
+            sourceDescriptor: ownPeerDescriptor as PeerDescriptor,
+            targetDescriptor: this.remotePeerDescriptor as PeerDescriptor,
+            notification: true
+        }
+        this.client.sendData(msg, options).catch(() => {
+            logger.trace('Failed to sendData')
+        })
+    }
+
+    leaveStreamNotice(ownPeerDescriptor: PeerDescriptor): void {
+        const options: DhtRpcOptions = {
+            sourceDescriptor: ownPeerDescriptor as PeerDescriptor,
+            targetDescriptor: this.remotePeerDescriptor as PeerDescriptor,
+            notification: true
+        }
+        const notification: LeaveStreamNotice = {
+            senderId: keyFromPeerDescriptor(ownPeerDescriptor),
+            randomGraphId: this.graphId
+        }
+        this.client.leaveStreamNotice(notification, options).catch(() => {
+            logger.debug('Failed to send leaveStreamNotice')
+        })
+    }
+}