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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamr/trackerless-network",
-  "version": "0.0.1-tatum.6",
+  "version": "0.0.1-tatum.7",
   "description": "Minimal and extendable implementation of the Streamr Network node.",
   "repository": {
     "type": "git",
@@ -30,20 +30,22 @@
   "dependencies": {
     "@protobuf-ts/runtime": "^2.8.2",
     "@protobuf-ts/runtime-rpc": "^2.8.2",
-    "@streamr/dht": "0.0.1-tatum.6",
-    "@streamr/proto-rpc": "0.0.1-tatum.6",
-    "@streamr/protocol": "0.0.1-tatum.6",
-    "@streamr/test-utils": "0.0.1-tatum.6",
-    "@streamr/utils": "0.0.1-tatum.6",
+    "@streamr/dht": "0.0.1-tatum.7",
+    "@streamr/proto-rpc": "0.0.1-tatum.7",
+    "@streamr/protocol": "0.0.1-tatum.7",
+    "@streamr/test-utils": "0.0.1-tatum.7",
+    "@streamr/utils": "0.0.1-tatum.7",
     "eventemitter3": "^5.0.0",
     "lodash": "^4.17.21",
+    "uuid": "^9.0.1",
     "yallist": "^4.0.0"
   },
   "devDependencies": {
     "@streamr/browser-test-runner": "^0.0.1",
-    "@types/lodash": "^4.14.199",
+    "@types/lodash": "^4.14.200",
+    "@types/uuid": "^9.0.6",
     "@types/yallist": "^4.0.1",
-    "commander": "^11.0.0",
+    "commander": "^11.1.0",
     "expect": "^29.6.2",
     "express": "^4.17.1",
     "ts-essentials": "^9.4.1",

package/protos/NetworkRpc.proto

@@ -6,7 +6,7 @@ import "google/protobuf/empty.proto";
 import "google/protobuf/any.proto";
 import "packages/dht/protos/DhtRpc.proto";
 
-service NetworkRpc {
+service DeliveryRpc {
   rpc sendStreamMessage (StreamMessage) returns (google.protobuf.Empty);
   rpc leaveStreamPartNotice (LeaveStreamPartNotice) returns (google.protobuf.Empty);
 }
@@ -90,7 +90,7 @@ message GroupKey {
 }
 
 message StreamPartHandshakeRequest {
-  string randomGraphId = 1;
+  string streamPartId = 1;
   string requestId = 2;
   optional bytes concurrentHandshakeTargetId = 3;
   repeated bytes neighborIds = 4;
@@ -104,17 +104,17 @@ message StreamPartHandshakeResponse {
 }
 
 message InterleaveNotice {
-  string randomGraphId = 1;
+  string streamPartId = 1;
   // this is a required field but in generated NetworkRpc.ts it is incorrectly annotated as optional (NET-1082)
   dht.PeerDescriptor interleaveTargetDescriptor = 2;
 }
 
 message LeaveStreamPartNotice {
-  string randomGraphId = 1;
+  string streamPartId = 1;
 }
 
 message NeighborUpdate {
-  string randomGraphId = 1;
+  string streamPartId = 1;
   bool removeMe = 2;
   repeated dht.PeerDescriptor neighborDescriptors = 3;
 }

package/src/NetworkNode.ts

@@ -93,7 +93,7 @@ export class NetworkNode {
     }
 
     hasStreamPart(streamPartId: StreamPartID): boolean {
-        return this.stack.getStreamrNode().hasStream(streamPartId)
+        return this.stack.getStreamrNode().hasStreamPart(streamPartId)
     }
 
     async stop(): Promise<void> {

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)
-    }
-
-    private 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/{StreamPartEntryPointDiscovery.ts → EntryPointDiscovery.ts}

@@ -1,8 +1,7 @@
 import {
     DataEntry,
     PeerDescriptor,
-    RecursiveFindResult,
-    isSamePeerDescriptor
+    areEqualPeerDescriptors
 } from '@streamr/dht'
 import { StreamPartID } from '@streamr/protocol'
 import { Logger, scheduleAtInterval, wait } from '@streamr/utils'
@@ -55,32 +54,30 @@ const logger = new Logger(module)
 const ENTRYPOINT_STORE_LIMIT = 8
 export const NETWORK_SPLIT_AVOIDANCE_LIMIT = 4
 
-interface StreamPartEntryPointDiscoveryConfig {
+interface EntryPointDiscoveryConfig {
     streamPartId: StreamPartID
     ownPeerDescriptor: PeerDescriptor
     layer1: ILayer1
-    getEntryPointData: (key: Uint8Array) => Promise<RecursiveFindResult>
-    getEntryPointDataViaNode: (key: Uint8Array, node: PeerDescriptor) => Promise<DataEntry[]>
+    getEntryPointData: (key: Uint8Array) => Promise<DataEntry[]>
     storeEntryPointData: (key: Uint8Array, data: Any) => Promise<PeerDescriptor[]>
     deleteEntryPointData: (key: Uint8Array) => Promise<void>
-    cacheInterval?: number
+    storeInterval?: number
 }
 
-export class StreamPartEntryPointDiscovery {
+export class EntryPointDiscovery {
     private readonly abortController: AbortController
-    private readonly config: StreamPartEntryPointDiscoveryConfig
-    private readonly cacheInterval: number
+    private readonly config: EntryPointDiscoveryConfig
+    private readonly storeInterval: number
     private readonly networkSplitAvoidedNodes: Set<NodeID> = new Set()
 
-    constructor(config: StreamPartEntryPointDiscoveryConfig) {
+    constructor(config: EntryPointDiscoveryConfig) {
         this.config = config
         this.abortController = new AbortController()
-        this.cacheInterval = this.config.cacheInterval ?? 60000
+        this.storeInterval = this.config.storeInterval ?? 60000
     }
 
     async discoverEntryPointsFromDht(
-        knownEntryPointCount: number,
-        forwardingNode?: PeerDescriptor
+        knownEntryPointCount: number
     ): Promise<FindEntryPointsResult> {
         if (knownEntryPointCount > 0) {
             return {
@@ -88,7 +85,7 @@ export class StreamPartEntryPointDiscovery {
                 discoveredEntryPoints: []
             }
         }
-        const discoveredEntryPoints = await this.discoverEntryPoints(forwardingNode)
+        const discoveredEntryPoints = await this.discoverEntryPoints()
         if (discoveredEntryPoints.length === 0) {
             discoveredEntryPoints.push(this.config.ownPeerDescriptor)
         }
@@ -98,11 +95,9 @@ export class StreamPartEntryPointDiscovery {
         }
     }
 
-    private async discoverEntryPoints(forwardingNode?: PeerDescriptor): Promise<PeerDescriptor[]> {
+    private async discoverEntryPoints(): Promise<PeerDescriptor[]> {
         const dataKey = streamPartIdToDataKey(this.config.streamPartId)
-        const discoveredEntryPoints = forwardingNode ? 
-            await this.queryEntryPointsViaNode(dataKey, forwardingNode) : await this.queryEntrypoints(dataKey)
-    
+        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
@@ -114,29 +109,10 @@ export class StreamPartEntryPointDiscovery {
     }
 
     private async queryEntrypoints(key: Uint8Array): Promise<PeerDescriptor[]> {
-        logger.trace(`Finding data from dht node ${this.config.ownPeerDescriptor.nodeName}`)
+        logger.trace(`Finding data from dht node ${getNodeIdFromPeerDescriptor(this.config.ownPeerDescriptor)}`)
         try {
-            const results = await this.config.getEntryPointData(key)
-            if (results.dataEntries) {
-                return parseEntryPointData(results.dataEntries)
-            } else {
-                return []
-            }
-        } catch (err) {
-            return []
-        }
-    }
-
-    // TODO remove this method in NET-1122
-    private async queryEntryPointsViaNode(key: Uint8Array, node: PeerDescriptor): Promise<PeerDescriptor[]> {
-        logger.trace(`Finding data via node ${this.config.ownPeerDescriptor.nodeName}`)
-        try {
-            const results = await this.config.getEntryPointDataViaNode(key, node)
-            if (results) {
-                return parseEntryPointData(results)
-            } else {
-                return []
-            }
+            const result = await this.config.getEntryPointData(key)
+            return parseEntryPointData(result)
         } catch (err) {
             return []
         }
@@ -172,13 +148,13 @@ export class StreamPartEntryPointDiscovery {
             try {
                 const discovered = await this.discoverEntryPoints()
                 if (discovered.length < ENTRYPOINT_STORE_LIMIT 
-                    || discovered.some((peerDescriptor) => isSamePeerDescriptor(peerDescriptor, this.config.ownPeerDescriptor))) {
+                    || 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.cacheInterval, false, this.abortController.signal)
+        }, this.storeInterval, false, this.abortController.signal)
     }
 
     private async avoidNetworkSplit(): Promise<void> {

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/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())
     }
 
-    get(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]
     }
 
-    getAll(): RemoteRandomGraphNode[] {
+    getAll(): DeliveryRpcRemote[] {
         return Array.from(this.nodes.values())
     }