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

package/src/NetworkStack.ts

@@ -1,39 +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)
-        }
-    }
-}
+import { Layer0Node } from './logic/Layer0Node'
 
 export interface NetworkOptions {
     layer0?: DhtNodeOptions
@@ -45,11 +16,9 @@ export interface NetworkStackEvents {
     stopped: () => void
 }
 
-const DEFAULT_FIRST_CONNECTION_TIMEOUT = 5000
-
 export class NetworkStack extends EventEmitter<NetworkStackEvents> {
 
-    private layer0DhtNode?: DhtNode
+    private layer0Node?: Layer0Node
     private streamrNode?: StreamrNode
     private readonly metricsContext: MetricsContext
     private readonly options: NetworkOptions
@@ -58,13 +27,12 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
         super()
         this.options = options
         this.metricsContext = options.metricsContext ?? new MetricsContext()
-        this.layer0DhtNode = new DhtNode({
+        this.layer0Node = new DhtNode({
             ...options.layer0,
             metricsContext: this.metricsContext
         })
         this.streamrNode = new StreamrNode({
             ...options.networkNode,
-            nodeName: options.networkNode?.nodeName ?? options.layer0?.nodeName,
             metricsContext: this.metricsContext
         })
     }
@@ -73,7 +41,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,59 +55,50 @@ 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)
     }
 
     async start(doJoin = true): Promise<void> {
-        await this.layer0DhtNode!.start()
-        const connectionManager = this.layer0DhtNode!.getTransport() as ConnectionManager
+        await this.layer0Node!.start()
+        const connectionManager = this.layer0Node!.getTransport() as ConnectionManager
         if ((this.options.layer0?.entryPoints !== undefined) && (this.options.layer0.entryPoints.some((entryPoint) => 
-            isSamePeerDescriptor(entryPoint, this.layer0DhtNode!.getPeerDescriptor())
+            areEqualPeerDescriptors(entryPoint, this.layer0Node!.getPeerDescriptor())
         ))) {
-            await this.layer0DhtNode?.joinDht(this.options.layer0.entryPoints)
+            await this.layer0Node?.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()
+        await this.streamrNode?.start(this.layer0Node!, connectionManager, connectionManager)
     }
 
-    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()
+        if (!this.layer0Node!.hasJoined()) {
+            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.layer0Node?.joinDht(this.options.layer0.entryPoints)
+                }
+            })
         }
+        await this.layer0Node!.waitForNetworkConnectivity()
     }
 
     getStreamrNode(): StreamrNode {
         return this.streamrNode!
     }
 
-    getLayer0DhtNode(): DhtNode {
-        return this.layer0DhtNode!
+    getLayer0Node(): Layer0Node {
+        return this.layer0Node!
     }
 
     getMetricsContext(): MetricsContext {
@@ -149,7 +108,7 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
     async stop(): Promise<void> {
         await this.streamrNode!.destroy()
         this.streamrNode = undefined
-        this.layer0DhtNode = undefined
+        this.layer0Node = undefined
         this.emit('stopped')
     }
 

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,15 +1,14 @@
 import {
     DataEntry,
     PeerDescriptor,
-    RecursiveFindResult,
-    isSamePeerDescriptor
+    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'
+import { Layer1Node } from './Layer1Node'
 
 export const streamPartIdToDataKey = (streamPartId: StreamPartID): Uint8Array => {
     return new Uint8Array(createHash('md5').update(streamPartId).digest())
@@ -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[]>
+    layer1Node: Layer1Node
+    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 []
         }
@@ -146,7 +122,7 @@ export class StreamPartEntryPointDiscovery {
         if (this.abortController.signal.aborted) {
             return
         }
-        const possibleNetworkSplitDetected = this.config.layer1.getBucketSize() < NETWORK_SPLIT_AVOIDANCE_LIMIT
+        const possibleNetworkSplitDetected = this.config.layer1Node.getBucketSize() < NETWORK_SPLIT_AVOIDANCE_LIMIT
         if ((currentEntrypointCount < ENTRYPOINT_STORE_LIMIT) || possibleNetworkSplitDetected) {
             await this.storeSelfAsEntryPoint()
             await this.keepSelfAsEntryPoint()
@@ -172,23 +148,23 @@ 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> {
         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) {
+            await this.config.layer1Node.joinDht(rediscoveredEntrypoints, false, false)
+            if (this.config.layer1Node!.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))
+                    .filter((peer) => !this.config.layer1Node!.getKBucketPeers().includes(peer))
                     .map((peer) => getNodeIdFromPeerDescriptor(peer))
                 nodesToAvoid.forEach((node) => this.networkSplitAvoidedNodes.add(node))
                 throw new Error(`Network split is still possible`)

package/src/logic/Layer0Node.ts

@@ -0,0 +1,15 @@
+import { DataEntry, ITransport, PeerDescriptor } from '@streamr/dht'
+import { Any } from '../proto/google/protobuf/any'
+
+export interface Layer0Node extends ITransport {
+    joinDht(entryPointDescriptors: PeerDescriptor[]): Promise<void>
+    hasJoined(): boolean
+    getPeerDescriptor(): PeerDescriptor
+    getDataFromDht(key: Uint8Array): Promise<DataEntry[]>
+    storeDataToDht(key: Uint8Array, data: Any): Promise<PeerDescriptor[]>
+    deleteDataFromDht(key: Uint8Array): Promise<void>
+    waitForNetworkConnectivity(): Promise<void>
+    getTransport(): ITransport
+    start(): Promise<void>
+    stop(): Promise<void>
+}

package/src/logic/{ILayer1.ts → Layer1Node.ts}

@@ -1,16 +1,16 @@
 import { PeerDescriptor } from '@streamr/dht'
 
-export interface ILayer1Events {
+export interface Layer1NodeEvents {
     newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     newRandomContact: (peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => void
 }
 
-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
+export interface Layer1Node {
+    on<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
+    once<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
+    off<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
     removeContact: (peerDescriptor: PeerDescriptor, removeFromOpenInternetPeers?: boolean) => void
     getClosestContacts: (maxCount?: number) => PeerDescriptor[]
     getKBucketPeers: () => PeerDescriptor[]

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())
     }