@streamr/trackerless-network 0.0.1-tatum.5 → 0.0.1-tatum.7

package/src/NetworkStack.ts

@@ -1,40 +1,10 @@
-import { ConnectionManager, DhtNode, DhtNodeOptions, isSamePeerDescriptor } from '@streamr/dht'
+import { ConnectionManager, DhtNode, DhtNodeOptions, areEqualPeerDescriptors } from '@streamr/dht'
 import { StreamrNode, StreamrNodeConfig } from './logic/StreamrNode'
-import { MetricsContext, waitForCondition, waitForEvent3 } from '@streamr/utils'
+import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { StreamID, StreamPartID, toStreamPartID } from '@streamr/protocol'
 import { ProxyDirection, StreamMessage, StreamMessageType } from './proto/packages/trackerless-network/protos/NetworkRpc'
 
-interface ReadinessEvents {
-    done: () => void
-}
-
-class ReadinessListener {
-
-    private readonly emitter = new EventEmitter<ReadinessEvents>()
-    private readonly networkStack: NetworkStack
-    private readonly dhtNode: DhtNode
-
-    constructor(networkStack: NetworkStack, dhtNode: DhtNode) {
-        this.networkStack = networkStack
-        this.dhtNode = dhtNode
-        this.networkStack.on('stopped', this.onDone)
-        this.dhtNode.on('connected', this.onDone)
-    }
-
-    private onDone = () => {
-        this.networkStack.off('stopped', this.onDone)
-        this.dhtNode.off('connected', this.onDone)
-        this.emitter.emit('done')
-    }
-
-    public async waitUntilReady(timeout: number): Promise<void> {
-        if (this.dhtNode.getNumberOfConnections() === 0) {
-            await waitForEvent3<ReadinessEvents>(this.emitter, 'done', timeout)
-        }
-    }
-}
-
 export interface NetworkOptions {
     layer0?: DhtNodeOptions
     networkNode?: StreamrNodeConfig
@@ -45,8 +15,6 @@ export interface NetworkStackEvents {
     stopped: () => void
 }
 
-const DEFAULT_FIRST_CONNECTION_TIMEOUT = 5000
-
 export class NetworkStack extends EventEmitter<NetworkStackEvents> {
 
     private layer0DhtNode?: DhtNode
@@ -64,7 +32,6 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
         })
         this.streamrNode = new StreamrNode({
             ...options.networkNode,
-            nodeName: options.networkNode?.nodeName ?? options.layer0?.nodeName,
             metricsContext: this.metricsContext
         })
     }
@@ -73,7 +40,7 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
         if (this.getStreamrNode().isProxiedStreamPart(streamPartId)) {
             throw new Error(`Cannot join to ${streamPartId} as proxy connections have been set`)
         }
-        await this.joinLayer0IfRequired(streamPartId)
+        await this.ensureConnectedToControlLayer()
         this.getStreamrNode().joinStreamPart(streamPartId)
         if (neighborRequirement !== undefined) {
             await waitForCondition(() => {
@@ -87,7 +54,10 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
         if (this.getStreamrNode().isProxiedStreamPart(streamPartId, ProxyDirection.SUBSCRIBE) && (msg.messageType === StreamMessageType.MESSAGE)) {
             throw new Error(`Cannot broadcast to ${streamPartId} as proxy subscribe connections have been set`)
         }
-        await this.joinLayer0IfRequired(streamPartId)
+        // TODO could combine these two calls to isProxiedStreamPart?
+        if (!this.streamrNode!.isProxiedStreamPart(streamPartId)) {
+            await this.ensureConnectedToControlLayer()
+        }
         this.getStreamrNode().broadcast(msg)
     }
 
@@ -95,43 +65,31 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
         await this.layer0DhtNode!.start()
         const connectionManager = this.layer0DhtNode!.getTransport() as ConnectionManager
         if ((this.options.layer0?.entryPoints !== undefined) && (this.options.layer0.entryPoints.some((entryPoint) => 
-            isSamePeerDescriptor(entryPoint, this.layer0DhtNode!.getPeerDescriptor())
+            areEqualPeerDescriptors(entryPoint, this.layer0DhtNode!.getPeerDescriptor())
         ))) {
             await this.layer0DhtNode?.joinDht(this.options.layer0.entryPoints)
         } else {
             if (doJoin) {
-                await this.joinDht()
+                // in practice there aren't be existing connections and therefore this always connects
+                await this.ensureConnectedToControlLayer()
             }
         }
         await this.streamrNode?.start(this.layer0DhtNode!, connectionManager, connectionManager)
     }
 
-    private async joinDht(): Promise<void> {
-        setImmediate(async () => {
-            if (this.options.layer0?.entryPoints !== undefined) {
-                // TODO should catch possible rejection?
-                await this.layer0DhtNode?.joinDht(this.options.layer0.entryPoints)
-            }
-        })
-        await this.waitForFirstConnection()
-    }
-
-    private async waitForFirstConnection(): Promise<void> {
-        const readinessListener = new ReadinessListener(this, this.layer0DhtNode!)
-        const timeout = this.options.networkNode?.firstConnectionTimeout ?? DEFAULT_FIRST_CONNECTION_TIMEOUT
-        await readinessListener.waitUntilReady(timeout)
-    }
-
-    async joinLayer0IfRequired(streamPartId: StreamPartID): Promise<void> {
-        if (this.streamrNode!.isProxiedStreamPart(streamPartId)) {
-            return
-        }
+    private async ensureConnectedToControlLayer(): Promise<void> {
         // TODO we could wrap joinDht with pOnce and call it here (no else-if needed in that case)
         if (!this.layer0DhtNode!.hasJoined()) {
-            await this.joinDht()
-        } else if (this.layer0DhtNode!.getNumberOfConnections() < 1) {
-            await this.waitForFirstConnection()
+            setImmediate(async () => {
+                if (this.options.layer0?.entryPoints !== undefined) {
+                    // TODO should catch possible rejection?
+                    // the question mark is there to avoid problems when stop() is called before start()
+                    // -> TODO change to exlamation mark if we don't support that (and remove NetworkStackStoppedDuringStart.test)
+                    await this.layer0DhtNode?.joinDht(this.options.layer0.entryPoints)
+                }
+            })
         }
+        await this.layer0DhtNode!.waitForNetworkConnectivity()
     }
 
     getStreamrNode(): StreamrNode {

package/src/identifiers.ts

@@ -1,8 +1,8 @@
-import { PeerDescriptor, keyFromPeerDescriptor } from '@streamr/dht'
-import { BrandedString } from '@streamr/utils'
+import { PeerDescriptor } from '@streamr/dht'
+import { BrandedString, binaryToHex } from '@streamr/utils'
 
 export type NodeID = BrandedString<'NodeID'>
 
 export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): NodeID => {
-    return keyFromPeerDescriptor(peerDescriptor) as unknown as NodeID
+    return binaryToHex(peerDescriptor.kademliaId) as unknown as NodeID
 }

package/src/logic/{StreamNodeServer.ts → DeliveryRpcLocal.ts}

@@ -6,13 +6,14 @@ import {
     MessageRef,
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { INetworkRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { IDeliveryRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { StreamPartID } from '@streamr/protocol'
 
-export interface StreamNodeServerConfig {
+export interface DeliveryRpcLocalConfig {
     ownPeerDescriptor: PeerDescriptor
-    randomGraphId: string
+    streamPartId: StreamPartID
     markAndCheckDuplicate: (messageId: MessageID, previousMessageRef?: MessageRef) => boolean
     broadcast: (message: StreamMessage, previousNode?: NodeID) => void
     onLeaveNotice(senderId: NodeID): void
@@ -20,11 +21,11 @@ export interface StreamNodeServerConfig {
     rpcCommunicator: ListeningRpcCommunicator
 }
 
-export class StreamNodeServer implements INetworkRpc {
+export class DeliveryRpcLocal implements IDeliveryRpc {
     
-    private readonly config: StreamNodeServerConfig
+    private readonly config: DeliveryRpcLocalConfig
 
-    constructor(config: StreamNodeServerConfig) {
+    constructor(config: DeliveryRpcLocalConfig) {
         this.config = config
     }
 
@@ -38,7 +39,7 @@ export class StreamNodeServer implements INetworkRpc {
     }
 
     async leaveStreamPartNotice(message: LeaveStreamPartNotice, context: ServerCallContext): Promise<Empty> {
-        if (message.randomGraphId === this.config.randomGraphId) {
+        if (message.streamPartId === this.config.streamPartId) {
             const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
             const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
             this.config.onLeaveNotice(senderId)

package/src/logic/{RemoteRandomGraphNode.ts → DeliveryRpcRemote.ts}

@@ -4,11 +4,11 @@ import {
     LeaveStreamPartNotice,
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { INetworkRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { IDeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
-export class RemoteRandomGraphNode extends Remote<INetworkRpcClient> {
+export class DeliveryRpcRemote extends Remote<IDeliveryRpcClient> {
 
     async sendStreamMessage(msg: StreamMessage): Promise<void> {
         const options = this.formDhtRpcOptions({
@@ -21,7 +21,7 @@ export class RemoteRandomGraphNode extends Remote<INetworkRpcClient> {
 
     leaveStreamPartNotice(): void {
         const notification: LeaveStreamPartNotice = {
-            randomGraphId: this.getServiceId()
+            streamPartId: this.getServiceId()
         }
         const options = this.formDhtRpcOptions({
             notification: true

package/src/logic/EntryPointDiscovery.ts

@@ -0,0 +1,181 @@
+import {
+    DataEntry,
+    PeerDescriptor,
+    areEqualPeerDescriptors
+} from '@streamr/dht'
+import { StreamPartID } from '@streamr/protocol'
+import { Logger, scheduleAtInterval, wait } from '@streamr/utils'
+import { createHash } from 'crypto'
+import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { Any } from '../proto/google/protobuf/any'
+import { ILayer1 } from './ILayer1'
+
+export const streamPartIdToDataKey = (streamPartId: StreamPartID): Uint8Array => {
+    return new Uint8Array(createHash('md5').update(streamPartId).digest())
+}
+
+const parseEntryPointData = (dataEntries: DataEntry[]): PeerDescriptor[] => {
+    return dataEntries.filter((entry) => !entry.deleted).map((entry) => Any.unpack(entry.data!, PeerDescriptor))
+}
+
+interface FindEntryPointsResult {
+    entryPointsFromDht: boolean
+    discoveredEntryPoints: PeerDescriptor[]
+}
+
+const exponentialRunOff = async (
+    task: () => Promise<void>,
+    description: string,
+    abortSignal: AbortSignal,
+    baseDelay = 500,
+    maxAttempts = 6
+): Promise<void> => {
+    for (let i = 1; i <= maxAttempts; i++) {
+        if (abortSignal.aborted) {
+            return
+        }
+        const factor = 2 ** i
+        const delay = baseDelay * factor
+        try {
+            await task()
+        } catch (e: any) {
+            logger.trace(`${description} failed, retrying in ${delay} ms`)
+        }
+        try { // Abort controller throws unexpected errors in destroy?
+            await wait(delay, abortSignal)
+        } catch (err) {
+            logger.trace(`${err}`)
+        }
+    }
+}
+
+const logger = new Logger(module)
+
+const ENTRYPOINT_STORE_LIMIT = 8
+export const NETWORK_SPLIT_AVOIDANCE_LIMIT = 4
+
+interface EntryPointDiscoveryConfig {
+    streamPartId: StreamPartID
+    ownPeerDescriptor: PeerDescriptor
+    layer1: ILayer1
+    getEntryPointData: (key: Uint8Array) => Promise<DataEntry[]>
+    storeEntryPointData: (key: Uint8Array, data: Any) => Promise<PeerDescriptor[]>
+    deleteEntryPointData: (key: Uint8Array) => Promise<void>
+    storeInterval?: number
+}
+
+export class EntryPointDiscovery {
+    private readonly abortController: AbortController
+    private readonly config: EntryPointDiscoveryConfig
+    private readonly storeInterval: number
+    private readonly networkSplitAvoidedNodes: Set<NodeID> = new Set()
+
+    constructor(config: EntryPointDiscoveryConfig) {
+        this.config = config
+        this.abortController = new AbortController()
+        this.storeInterval = this.config.storeInterval ?? 60000
+    }
+
+    async discoverEntryPointsFromDht(
+        knownEntryPointCount: number
+    ): Promise<FindEntryPointsResult> {
+        if (knownEntryPointCount > 0) {
+            return {
+                entryPointsFromDht: false,
+                discoveredEntryPoints: []
+            }
+        }
+        const discoveredEntryPoints = await this.discoverEntryPoints()
+        if (discoveredEntryPoints.length === 0) {
+            discoveredEntryPoints.push(this.config.ownPeerDescriptor)
+        }
+        return {
+            discoveredEntryPoints,
+            entryPointsFromDht: true
+        }
+    }
+
+    private async discoverEntryPoints(): Promise<PeerDescriptor[]> {
+        const dataKey = streamPartIdToDataKey(this.config.streamPartId)
+        const discoveredEntryPoints = await this.queryEntrypoints(dataKey)
+        const filtered = discoveredEntryPoints.filter((node) => 
+            !this.networkSplitAvoidedNodes.has(getNodeIdFromPeerDescriptor(node)))
+        // If all discovered entry points have previously been detected as offline, try again
+        if (filtered.length > 0) {
+            return filtered
+        } else {
+            return discoveredEntryPoints
+        }
+    }
+
+    private async queryEntrypoints(key: Uint8Array): Promise<PeerDescriptor[]> {
+        logger.trace(`Finding data from dht node ${getNodeIdFromPeerDescriptor(this.config.ownPeerDescriptor)}`)
+        try {
+            const result = await this.config.getEntryPointData(key)
+            return parseEntryPointData(result)
+        } catch (err) {
+            return []
+        }
+    }
+
+    async storeSelfAsEntryPointIfNecessary(currentEntrypointCount: number): Promise<void> {
+        if (this.abortController.signal.aborted) {
+            return
+        }
+        const possibleNetworkSplitDetected = this.config.layer1.getBucketSize() < NETWORK_SPLIT_AVOIDANCE_LIMIT
+        if ((currentEntrypointCount < ENTRYPOINT_STORE_LIMIT) || possibleNetworkSplitDetected) {
+            await this.storeSelfAsEntryPoint()
+            await this.keepSelfAsEntryPoint()
+        }
+        if (possibleNetworkSplitDetected) {
+            setImmediate(() => this.avoidNetworkSplit())
+        }
+    }
+
+    private async storeSelfAsEntryPoint(): Promise<void> {
+        const ownPeerDescriptor = this.config.ownPeerDescriptor
+        const dataToStore = Any.pack(ownPeerDescriptor, PeerDescriptor)
+        try {
+            await this.config.storeEntryPointData(streamPartIdToDataKey(this.config.streamPartId), dataToStore)
+        } catch (err) {
+            logger.warn(`Failed to store self as entrypoint for ${this.config.streamPartId}`)
+        }
+    }
+
+    private async keepSelfAsEntryPoint(): Promise<void> {
+        await scheduleAtInterval(async () => {
+            logger.trace(`Attempting to keep self as entrypoint for ${this.config.streamPartId}`)
+            try {
+                const discovered = await this.discoverEntryPoints()
+                if (discovered.length < ENTRYPOINT_STORE_LIMIT 
+                    || discovered.some((peerDescriptor) => areEqualPeerDescriptors(peerDescriptor, this.config.ownPeerDescriptor))) {
+                    await this.storeSelfAsEntryPoint()
+                }
+            } catch (err) {
+                logger.debug(`Failed to keep self as entrypoint for ${this.config.streamPartId}`)
+            }
+        }, this.storeInterval, false, this.abortController.signal)
+    }
+
+    private async avoidNetworkSplit(): Promise<void> {
+        await exponentialRunOff(async () => {
+            const rediscoveredEntrypoints = await this.discoverEntryPoints()
+            await this.config.layer1.joinDht(rediscoveredEntrypoints, false, false)
+            if (this.config.layer1!.getBucketSize() < NETWORK_SPLIT_AVOIDANCE_LIMIT) {
+                // Filter out nodes that are not in the k-bucket, assumed to be offline
+                const nodesToAvoid = rediscoveredEntrypoints
+                    .filter((peer) => !this.config.layer1!.getKBucketPeers().includes(peer))
+                    .map((peer) => getNodeIdFromPeerDescriptor(peer))
+                nodesToAvoid.forEach((node) => this.networkSplitAvoidedNodes.add(node))
+                throw new Error(`Network split is still possible`)
+            }
+        }, 'avoid network split', this.abortController.signal)
+        this.networkSplitAvoidedNodes.clear()
+        logger.trace(`Network split avoided`)
+    }
+
+    async destroy(): Promise<void> {
+        this.abortController.abort()
+        await this.config.deleteEntryPointData(streamPartIdToDataKey(this.config.streamPartId))
+    }
+}

package/src/logic/ILayer0.ts

@@ -1,14 +1,11 @@
-import { DataEntry, ITransport, PeerDescriptor, PeerID, RecursiveFindResult } from '@streamr/dht'
+import { DataEntry, ITransport, PeerDescriptor } 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, node: PeerDescriptor): Promise<DataEntry[]>
+    getDataFromDht(key: Uint8Array): Promise<DataEntry[]>
     storeDataToDht(key: Uint8Array, data: Any): Promise<PeerDescriptor[]>
     deleteDataFromDht(key: Uint8Array): Promise<void>
-    getKnownEntryPoints(): PeerDescriptor[]
-    isJoinOngoing(): boolean
+    waitForNetworkConnectivity(): Promise<void>
     stop(): Promise<void>
 }

package/src/logic/ILayer1.ts

@@ -1,4 +1,4 @@
-import { PeerDescriptor, SortedContactList, DhtPeer } from '@streamr/dht'
+import { PeerDescriptor } from '@streamr/dht'
 
 export interface ILayer1Events {
     newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
@@ -9,13 +9,10 @@ export interface ILayer1Events {
 
 export interface ILayer1 {
     on<T extends keyof ILayer1Events>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
-
     once<T extends keyof ILayer1Events>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
-
     off<T extends keyof ILayer1Events>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
-    
     removeContact: (peerDescriptor: PeerDescriptor, removeFromOpenInternetPeers?: boolean) => void
-    getNeighborList: () => SortedContactList<DhtPeer>
+    getClosestContacts: (maxCount?: number) => PeerDescriptor[]
     getKBucketPeers: () => PeerDescriptor[]
     getBucketSize: () => number
     joinDht: (entryPoints: PeerDescriptor[], doRandomJoin?: boolean, retry?: boolean) => Promise<void>

package/src/logic/NodeList.ts

@@ -1,21 +1,21 @@
 import { PeerDescriptor } from '@streamr/dht'
 import { sample } from 'lodash'
-import { RemoteRandomGraphNode } from './RemoteRandomGraphNode'
+import { DeliveryRpcRemote } from './DeliveryRpcRemote'
 import { EventEmitter } from 'eventemitter3'
 import { getNodeIdFromPeerDescriptor, NodeID } from '../identifiers'
 
 export interface Events {
-    nodeAdded: (id: NodeID, remote: RemoteRandomGraphNode) => any
+    nodeAdded: (id: NodeID, remote: DeliveryRpcRemote) => any
 }
 
-const getValuesOfIncludedKeys = (nodes: Map<NodeID, RemoteRandomGraphNode>, exclude: NodeID[]): RemoteRandomGraphNode[] => {
+const getValuesOfIncludedKeys = (nodes: Map<NodeID, DeliveryRpcRemote>, exclude: NodeID[]): DeliveryRpcRemote[] => {
     return Array.from(nodes.entries())
         .filter(([id, _node]) => !exclude.includes(id))
         .map(([_id, node]) => node)
 }
 
 export class NodeList extends EventEmitter<Events> {
-    private readonly nodes: Map<NodeID, RemoteRandomGraphNode>
+    private readonly nodes: Map<NodeID, DeliveryRpcRemote>
     private readonly limit: number
     private ownId: NodeID
 
@@ -26,7 +26,7 @@ export class NodeList extends EventEmitter<Events> {
         this.ownId = ownId
     }
 
-    add(remote: RemoteRandomGraphNode): void {
+    add(remote: DeliveryRpcRemote): void {
         const nodeId = getNodeIdFromPeerDescriptor(remote.getPeerDescriptor())
         if ((this.ownId !== nodeId) && (this.nodes.size < this.limit)) {
             const isExistingNode = this.nodes.has(nodeId)
@@ -54,7 +54,7 @@ export class NodeList extends EventEmitter<Events> {
         return this.nodes.has(nodeId)
     }
 
-    replaceAll(neighbors: RemoteRandomGraphNode[]): void {
+    replaceAll(neighbors: DeliveryRpcRemote[]): void {
         this.nodes.clear()
         const limited = neighbors.splice(0, this.limit)
         limited.forEach((remote) => {
@@ -66,7 +66,7 @@ export class NodeList extends EventEmitter<Events> {
         return Array.from(this.nodes.keys())
     }
 
-    getNeighborById(id: NodeID): RemoteRandomGraphNode | undefined {
+    get(id: NodeID): DeliveryRpcRemote | undefined {
         return this.nodes.get(id)
     }
 
@@ -74,16 +74,16 @@ export class NodeList extends EventEmitter<Events> {
         return Array.from(this.nodes.keys()).filter((node) => !exclude.includes(node)).length
     }
 
-    getRandom(exclude: NodeID[]): RemoteRandomGraphNode | undefined {
+    getRandom(exclude: NodeID[]): DeliveryRpcRemote | undefined {
         return sample(getValuesOfIncludedKeys(this.nodes, exclude))
     }
 
-    getClosest(exclude: NodeID[]): RemoteRandomGraphNode | undefined {
+    getClosest(exclude: NodeID[]): DeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[0]
     }
 
-    getClosestAndFurthest(exclude: NodeID[]): RemoteRandomGraphNode[] {
+    getClosestAndFurthest(exclude: NodeID[]): DeliveryRpcRemote[] {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         if (included.length === 0) {
             return []
@@ -91,12 +91,12 @@ export class NodeList extends EventEmitter<Events> {
         return included.length > 1 ? [this.getClosest(exclude)!, this.getFurthest(exclude)!] : [this.getClosest(exclude)!]
     }
 
-    getFurthest(exclude: NodeID[]): RemoteRandomGraphNode | undefined {
+    getFurthest(exclude: NodeID[]): DeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[included.length - 1]
     }
 
-    getNodes(): RemoteRandomGraphNode[] {
+    getAll(): DeliveryRpcRemote[] {
         return Array.from(this.nodes.values())
     }