@streamr/trackerless-network 100.2.5-beta.1 → 101.0.0-beta.0

package/src/logic/ContentDeliveryManager.ts

@@ -5,6 +5,7 @@ import {
     EXISTING_CONNECTION_TIMEOUT,
     ITransport,
     PeerDescriptor,
+    getDhtAddressFromRaw,
     getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import { StreamID, StreamPartID, StreamPartIDUtils, toStreamPartID } from '@streamr/protocol'
@@ -16,26 +17,26 @@ import {
     MetricsDefinition,
     RateMetric
 } from '@streamr/utils'
+import { createHash } from 'crypto'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
 import { ProxyDirection, StreamMessage, StreamPartitionInfo } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ENTRYPOINT_STORE_LIMIT, EntryPointDiscovery } from './EntryPointDiscovery'
-import { Layer0Node } from './Layer0Node'
-import { Layer1Node } from './Layer1Node'
 import { ContentDeliveryLayerNode } from './ContentDeliveryLayerNode'
+import { ControlLayerNode } from './ControlLayerNode'
+import { DiscoveryLayerNode } from './DiscoveryLayerNode'
+import { MAX_NODE_COUNT, PeerDescriptorStoreManager } from './PeerDescriptorStoreManager'
+import { MIN_NEIGHBOR_COUNT as NETWORK_SPLIT_AVOIDANCE_MIN_NEIGHBOR_COUNT, StreamPartNetworkSplitAvoidance } from './StreamPartNetworkSplitAvoidance'
+import { StreamPartReconnect } from './StreamPartReconnect'
 import { createContentDeliveryLayerNode } from './createContentDeliveryLayerNode'
 import { ProxyClient } from './proxy/ProxyClient'
-import { StreamPartReconnect } from './StreamPartReconnect'
-import { MIN_NEIGHBOR_COUNT as NETWORK_SPLIT_AVOIDANCE_MIN_NEIGHBOR_COUNT, StreamPartNetworkSplitAvoidance } from './StreamPartNetworkSplitAvoidance'
 
 export type StreamPartDelivery = {
     broadcast: (msg: StreamMessage) => void
     stop: () => Promise<void>
 } & ({ 
     proxied: false
-    layer1Node: Layer1Node
+    discoveryLayerNode: DiscoveryLayerNode
     node: ContentDeliveryLayerNode
-    entryPointDiscovery: EntryPointDiscovery
     networkSplitAvoidance: StreamPartNetworkSplitAvoidance
 } | {
     proxied: true
@@ -53,7 +54,7 @@ interface Metrics extends MetricsDefinition {
     broadcastBytesPerSecond: Metric
 }
 
-export interface ContentDeliveryManagerConfig {
+export interface ContentDeliveryManagerOptions {
     metricsContext?: MetricsContext
     streamPartitionNeighborTargetCount?: number
     streamPartitionMinPropagationTargets?: number
@@ -61,24 +62,28 @@ export interface ContentDeliveryManagerConfig {
     rpcRequestTimeout?: number
 }
 
+export const streamPartIdToDataKey = (streamPartId: StreamPartID): DhtAddress => {
+    return getDhtAddressFromRaw(new Uint8Array((createHash('sha1').update(streamPartId).digest())))
+}
+
 export class ContentDeliveryManager extends EventEmitter<Events> {
 
     private transport?: ITransport
     private connectionLocker?: ConnectionLocker
-    private layer0Node?: Layer0Node
+    private controlLayerNode?: ControlLayerNode
     private readonly metricsContext: MetricsContext
     private readonly metrics: Metrics
-    private readonly config: ContentDeliveryManagerConfig
+    private readonly options: ContentDeliveryManagerOptions
     private readonly streamParts: Map<StreamPartID, StreamPartDelivery>
     private readonly knownStreamPartEntryPoints: Map<StreamPartID, PeerDescriptor[]> = new Map()
     private started = false
     private destroyed = false
 
-    constructor(config: ContentDeliveryManagerConfig) {
+    constructor(options: ContentDeliveryManagerOptions) {
         super()
-        this.config = config
+        this.options = options
         this.streamParts = new Map()
-        this.metricsContext = config.metricsContext ?? new MetricsContext()
+        this.metricsContext = options.metricsContext ?? new MetricsContext()
         this.metrics = {
             broadcastMessagesPerSecond: new RateMetric(),
             broadcastBytesPerSecond: new RateMetric()
@@ -86,12 +91,12 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
         this.metricsContext.addMetrics('node', this.metrics)
     }
 
-    async start(startedAndJoinedLayer0Node: Layer0Node, transport: ITransport, connectionLocker: ConnectionLocker): Promise<void> {
+    async start(startedAndJoinedControlLayerNode: ControlLayerNode, transport: ITransport, connectionLocker: ConnectionLocker): Promise<void> {
         if (this.started || this.destroyed) {
             return
         }
         this.started = true
-        this.layer0Node = startedAndJoinedLayer0Node
+        this.controlLayerNode = startedAndJoinedControlLayerNode
         this.transport = transport
         this.connectionLocker = connectionLocker
     }
@@ -105,7 +110,7 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
         await Promise.all(Array.from(this.streamParts.values()).map((streamPart) => streamPart.stop()))
         this.streamParts.clear()
         this.removeAllListeners()
-        this.layer0Node = undefined
+        this.controlLayerNode = undefined
         this.transport = undefined
         this.connectionLocker = undefined
     }
@@ -135,37 +140,36 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
             return
         }
         logger.debug(`Join stream part ${streamPartId}`)
-        const layer1Node = this.createLayer1Node(streamPartId, this.knownStreamPartEntryPoints.get(streamPartId) ?? [])
-        const entryPointDiscovery = new EntryPointDiscovery({
-            streamPartId,
+        const discoveryLayerNode = this.createDiscoveryLayerNode(streamPartId, this.knownStreamPartEntryPoints.get(streamPartId) ?? [])
+        const peerDescriptorStoreManager = new PeerDescriptorStoreManager({
+            key: streamPartIdToDataKey(streamPartId),
             localPeerDescriptor: this.getPeerDescriptor(),
-            fetchEntryPointData: (key) => this.layer0Node!.fetchDataFromDht(key),
-            storeEntryPointData: (key, data) => this.layer0Node!.storeDataToDht(key, data),
-            deleteEntryPointData: async (key) => this.layer0Node!.deleteDataFromDht(key, false)
+            fetchDataFromDht: (key) => this.controlLayerNode!.fetchDataFromDht(key),
+            storeDataToDht: (key, data) => this.controlLayerNode!.storeDataToDht(key, data),
+            deleteDataFromDht: async (key, waitForCompletion) => this.controlLayerNode!.deleteDataFromDht(key, waitForCompletion)
         })
         const networkSplitAvoidance = new StreamPartNetworkSplitAvoidance({
-            layer1Node,
-            discoverEntryPoints: async () => entryPointDiscovery.discoverEntryPoints()
+            discoveryLayerNode,
+            discoverEntryPoints: async () => peerDescriptorStoreManager.fetchNodes()
         })
         const node = this.createContentDeliveryLayerNode(
             streamPartId,
-            layer1Node, 
-            () => entryPointDiscovery.isLocalNodeEntryPoint()
+            discoveryLayerNode, 
+            () => peerDescriptorStoreManager.isLocalNodeStored()
         )
-        const streamPartReconnect = new StreamPartReconnect(layer1Node, entryPointDiscovery)
+        const streamPartReconnect = new StreamPartReconnect(discoveryLayerNode, peerDescriptorStoreManager)
         streamPart = {
             proxied: false,
-            layer1Node,
+            discoveryLayerNode,
             node,
-            entryPointDiscovery,
             networkSplitAvoidance,
             broadcast: (msg: StreamMessage) => node.broadcast(msg),
             stop: async () => {
                 streamPartReconnect.destroy()
                 networkSplitAvoidance.destroy()
-                await entryPointDiscovery.destroy()
+                await peerDescriptorStoreManager.destroy()
                 node.stop()
-                await layer1Node.stop()
+                await discoveryLayerNode.stop()
             }
         }
         this.streamParts.set(streamPartId, streamPart)
@@ -173,15 +177,15 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
             this.emit('newMessage', message)
         })
         const handleEntryPointLeave = async () => {
-            if (this.destroyed || entryPointDiscovery.isLocalNodeEntryPoint() || this.knownStreamPartEntryPoints.has(streamPartId)) {
+            if (this.destroyed || peerDescriptorStoreManager.isLocalNodeStored() || this.knownStreamPartEntryPoints.has(streamPartId)) {
                 return
             }
-            const entryPoints = await entryPointDiscovery.discoverEntryPoints()
-            if (entryPoints.length < ENTRYPOINT_STORE_LIMIT) {
-                await entryPointDiscovery.storeAndKeepLocalNodeAsEntryPoint()
+            const entryPoints = await peerDescriptorStoreManager.fetchNodes()
+            if (entryPoints.length < MAX_NODE_COUNT) {
+                await peerDescriptorStoreManager.storeAndKeepLocalNode()
             }
         }
-        layer1Node.on('manualRejoinRequired', async () => {
+        discoveryLayerNode.on('manualRejoinRequired', async () => {
             if (!streamPartReconnect.isRunning() && !networkSplitAvoidance.isRunning()) {
                 logger.debug('Manual rejoin required for stream part', { streamPartId })
                 await streamPartReconnect.reconnect()
@@ -190,53 +194,53 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
         node.on('entryPointLeaveDetected', () => handleEntryPointLeave())
         setImmediate(async () => {
             try {
-                await this.startLayersAndJoinDht(streamPartId, entryPointDiscovery)
+                await this.startLayersAndJoinDht(streamPartId, peerDescriptorStoreManager)
             } catch (err) {
                 logger.warn(`Failed to join to stream part ${streamPartId}`, { err })
             }
         })
     }
 
-    private async startLayersAndJoinDht(streamPartId: StreamPartID, entryPointDiscovery: EntryPointDiscovery): Promise<void> {
+    private async startLayersAndJoinDht(streamPartId: StreamPartID, peerDescriptorStoreManager: PeerDescriptorStoreManager): Promise<void> {
         logger.debug(`Start layers and join DHT for stream part ${streamPartId}`)
         const streamPart = this.streamParts.get(streamPartId)
         if ((streamPart === undefined) || streamPart.proxied) {
             // leaveStreamPart has been called (or leaveStreamPart called, and then setProxies called)
             return
         }
-        await streamPart.layer1Node.start()
+        await streamPart.discoveryLayerNode.start()
         await streamPart.node.start()
         const knownEntryPoints = this.knownStreamPartEntryPoints.get(streamPartId)
         if (knownEntryPoints !== undefined) {
             await Promise.all([
-                streamPart.layer1Node.joinDht(knownEntryPoints),
-                streamPart.layer1Node.joinRing()
+                streamPart.discoveryLayerNode.joinDht(knownEntryPoints),
+                streamPart.discoveryLayerNode.joinRing()
             ])
         } else {
-            const entryPoints = await entryPointDiscovery.discoverEntryPoints()
+            const entryPoints = await peerDescriptorStoreManager.fetchNodes()
             await Promise.all([
-                streamPart.layer1Node.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_MIN_NEIGHBOR_COUNT)),
-                streamPart.layer1Node.joinRing()
+                streamPart.discoveryLayerNode.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_MIN_NEIGHBOR_COUNT)),
+                streamPart.discoveryLayerNode.joinRing()
             ])
-            if (entryPoints.length < ENTRYPOINT_STORE_LIMIT) {
-                await entryPointDiscovery.storeAndKeepLocalNodeAsEntryPoint()
-                if (streamPart.layer1Node.getNeighborCount() < NETWORK_SPLIT_AVOIDANCE_MIN_NEIGHBOR_COUNT) {
+            if (entryPoints.length < MAX_NODE_COUNT) {
+                await peerDescriptorStoreManager.storeAndKeepLocalNode()
+                if (streamPart.discoveryLayerNode.getNeighborCount() < NETWORK_SPLIT_AVOIDANCE_MIN_NEIGHBOR_COUNT) {
                     setImmediate(() => streamPart.networkSplitAvoidance.avoidNetworkSplit())
                 }
             }
         }
     }
 
-    private createLayer1Node(streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): Layer1Node {
+    private createDiscoveryLayerNode(streamPartId: StreamPartID, entryPoints: PeerDescriptor[]): DiscoveryLayerNode {
         return new DhtNode({
-            transport: this.layer0Node!,
-            connectionsView: this.layer0Node!.getConnectionsView(),
+            transport: this.controlLayerNode!,
+            connectionsView: this.controlLayerNode!.getConnectionsView(),
             serviceId: 'layer1::' + streamPartId,
-            peerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
+            peerDescriptor: this.controlLayerNode!.getLocalPeerDescriptor(),
             entryPoints,
-            numberOfNodesPerKBucket: 4,  // TODO use config option or named constant?
+            numberOfNodesPerKBucket: 4,  // TODO use options option or named constant?
             rpcRequestTimeout: EXISTING_CONNECTION_TIMEOUT,
-            dhtJoinTimeout: 20000,  // TODO use config option or named constant?
+            dhtJoinTimeout: 20000,  // TODO use options option or named constant?
             periodicallyPingNeighbors: true,
             periodicallyPingRingContacts: true
         })
@@ -244,19 +248,19 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
 
     private createContentDeliveryLayerNode(
         streamPartId: StreamPartID,
-        layer1Node: Layer1Node,
+        discoveryLayerNode: DiscoveryLayerNode,
         isLocalNodeEntryPoint: () => boolean
     ) {
         return createContentDeliveryLayerNode({
             streamPartId,
             transport: this.transport!,
-            layer1Node,
+            discoveryLayerNode,
             connectionLocker: this.connectionLocker!,
-            localPeerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
-            minPropagationTargets: this.config.streamPartitionMinPropagationTargets,
-            neighborTargetCount: this.config.streamPartitionNeighborTargetCount,
-            acceptProxyConnections: this.config.acceptProxyConnections,
-            rpcRequestTimeout: this.config.rpcRequestTimeout,
+            localPeerDescriptor: this.controlLayerNode!.getLocalPeerDescriptor(),
+            minPropagationTargets: this.options.streamPartitionMinPropagationTargets,
+            neighborTargetCount: this.options.streamPartitionNeighborTargetCount,
+            acceptProxyConnections: this.options.acceptProxyConnections,
+            rpcRequestTimeout: this.options.rpcRequestTimeout,
             isLocalNodeEntryPoint
         })
     }
@@ -269,7 +273,7 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
         connectionCount?: number
     ): Promise<void> {
         // TODO explicit default value for "acceptProxyConnections" or make it required
-        if (this.config.acceptProxyConnections) {
+        if (this.options.acceptProxyConnections) {
             throw new Error('cannot set proxies when acceptProxyConnections=true')
         }
         const enable = (nodes.length > 0) && ((connectionCount === undefined) || (connectionCount > 0))
@@ -301,10 +305,10 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
     private createProxyClient(streamPartId: StreamPartID): ProxyClient {
         return new ProxyClient({
             transport: this.transport!,
-            localPeerDescriptor: this.layer0Node!.getLocalPeerDescriptor(),
+            localPeerDescriptor: this.controlLayerNode!.getLocalPeerDescriptor(),
             streamPartId,
             connectionLocker: this.connectionLocker!,
-            minPropagationTargets: this.config.streamPartitionMinPropagationTargets
+            minPropagationTargets: this.options.streamPartitionMinPropagationTargets
         })
     }
 
@@ -320,10 +324,10 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
     getNodeInfo(): StreamPartitionInfo[] {
         const streamParts = Array.from(this.streamParts.entries()).filter(([_, node]) => node.proxied === false)
         return streamParts.map(([streamPartId]) => {
-            const stream = this.streamParts.get(streamPartId)! as { node: ContentDeliveryLayerNode, layer1Node: Layer1Node }
+            const stream = this.streamParts.get(streamPartId)! as { node: ContentDeliveryLayerNode, discoveryLayerNode: DiscoveryLayerNode }
             return {
                 id: streamPartId,
-                controlLayerNeighbors: stream.layer1Node.getNeighbors(),
+                controlLayerNeighbors: stream.discoveryLayerNode.getNeighbors(),
                 contentDeliveryLayerNeighbors: stream.node.getNeighbors()
             }
         })
@@ -350,11 +354,11 @@ export class ContentDeliveryManager extends EventEmitter<Events> {
     }
 
     getPeerDescriptor(): PeerDescriptor {
-        return this.layer0Node!.getLocalPeerDescriptor()
+        return this.controlLayerNode!.getLocalPeerDescriptor()
     }
 
     getNodeId(): DhtAddress {
-        return getNodeIdFromPeerDescriptor(this.layer0Node!.getLocalPeerDescriptor())
+        return getNodeIdFromPeerDescriptor(this.controlLayerNode!.getLocalPeerDescriptor())
     }
 
     getNeighbors(streamPartId: StreamPartID): DhtAddress[] {

package/src/logic/ContentDeliveryRpcLocal.ts

@@ -10,38 +10,38 @@ import { IContentDeliveryRpc } from '../proto/packages/trackerless-network/proto
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { StreamPartID } from '@streamr/protocol'
 
-export interface ContentDeliveryRpcLocalConfig {
+export interface ContentDeliveryRpcLocalOptions {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     markAndCheckDuplicate: (messageId: MessageID, previousMessageRef?: MessageRef) => boolean
     broadcast: (message: StreamMessage, previousNode?: DhtAddress) => void
-    onLeaveNotice(senderId: DhtAddress, isLocalNodeEntryPoint: boolean): void
-    markForInspection(senderId: DhtAddress, messageId: MessageID): void
+    onLeaveNotice(remoteNodeId: DhtAddress, isLocalNodeEntryPoint: boolean): void
+    markForInspection(remoteNodeId: DhtAddress, messageId: MessageID): void
     rpcCommunicator: ListeningRpcCommunicator
 }
 
 export class ContentDeliveryRpcLocal implements IContentDeliveryRpc {
     
-    private readonly config: ContentDeliveryRpcLocalConfig
+    private readonly options: ContentDeliveryRpcLocalOptions
 
-    constructor(config: ContentDeliveryRpcLocalConfig) {
-        this.config = config
+    constructor(options: ContentDeliveryRpcLocalOptions) {
+        this.options = options
     }
 
     async sendStreamMessage(message: StreamMessage, context: ServerCallContext): Promise<Empty> {
         const previousNode = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
-        this.config.markForInspection(previousNode, message.messageId!)
-        if (this.config.markAndCheckDuplicate(message.messageId!, message.previousMessageRef)) {
-            this.config.broadcast(message, previousNode)
+        this.options.markForInspection(previousNode, message.messageId!)
+        if (this.options.markAndCheckDuplicate(message.messageId!, message.previousMessageRef)) {
+            this.options.broadcast(message, previousNode)
         }
         return Empty
     }
 
     async leaveStreamPartNotice(message: LeaveStreamPartNotice, context: ServerCallContext): Promise<Empty> {
-        if (message.streamPartId === this.config.streamPartId) {
+        if (message.streamPartId === this.options.streamPartId) {
             const sourcePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-            const sourceId = getNodeIdFromPeerDescriptor(sourcePeerDescriptor)
-            this.config.onLeaveNotice(sourceId, message.isEntryPoint)
+            const remoteNodeId = getNodeIdFromPeerDescriptor(sourcePeerDescriptor)
+            this.options.onLeaveNotice(remoteNodeId, message.isEntryPoint)
         }
         return Empty
     }

package/src/logic/{Layer0Node.ts → ControlLayerNode.ts}

@@ -1,7 +1,7 @@
 import { ConnectionsView, DataEntry, DhtAddress, ITransport, PeerDescriptor } from '@streamr/dht'
 import { Any } from '../proto/google/protobuf/any'
 
-export interface Layer0Node extends ITransport {
+export interface ControlLayerNode extends ITransport {
     joinDht(entryPointDescriptors: PeerDescriptor[]): Promise<void>
     hasJoined(): boolean
     getLocalPeerDescriptor(): PeerDescriptor

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

@@ -1,6 +1,6 @@
 import { DhtAddress, PeerDescriptor, RingContacts } from '@streamr/dht'
 
-export interface Layer1NodeEvents {
+export interface DiscoveryLayerNodeEvents {
     manualRejoinRequired: () => void
     nearbyContactAdded: (peerDescriptor: PeerDescriptor) => void
     nearbyContactRemoved: (peerDescriptor: PeerDescriptor) => void
@@ -10,13 +10,13 @@ export interface Layer1NodeEvents {
     ringContactRemoved: (peerDescriptor: PeerDescriptor) => void
 }
 
-export interface Layer1Node {
-    on<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
-    once<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
-    off<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
-    on<T extends keyof Layer1NodeEvents>(eventName: T, listener: () => void): void
-    once<T extends keyof Layer1NodeEvents>(eventName: T, listener: () => void): void
-    off<T extends keyof Layer1NodeEvents>(eventName: T, listener: () => void): void
+export interface DiscoveryLayerNode {
+    on<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
+    once<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
+    off<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
+    on<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: () => void): void
+    once<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: () => void): void
+    off<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: () => void): void
     removeContact: (nodeId: DhtAddress) => void
     getClosestContacts: (maxCount?: number) => PeerDescriptor[]
     getRandomContacts: (maxCount?: number) => PeerDescriptor[]

package/src/logic/PeerDescriptorStoreManager.ts

@@ -0,0 +1,97 @@
+import {
+    DataEntry,
+    DhtAddress,
+    PeerDescriptor,
+    areEqualPeerDescriptors
+} from '@streamr/dht'
+import { Logger, scheduleAtInterval } from '@streamr/utils'
+import { Any } from '../proto/google/protobuf/any'
+
+const parsePeerDescriptor = (dataEntries: DataEntry[]): PeerDescriptor[] => {
+    return dataEntries.filter((entry) => !entry.deleted).map((entry) => Any.unpack(entry.data!, PeerDescriptor))
+}
+
+const logger = new Logger(module)
+
+export const MAX_NODE_COUNT = 8
+
+interface PeerDescriptorStoreManagerOptions {
+    key: DhtAddress
+    localPeerDescriptor: PeerDescriptor
+    storeInterval?: number
+    fetchDataFromDht: (key: DhtAddress) => Promise<DataEntry[]>
+    storeDataToDht: (key: DhtAddress, data: Any) => Promise<PeerDescriptor[]>
+    deleteDataFromDht: (key: DhtAddress, waitForCompletion: boolean) => Promise<void>
+}
+
+/**
+ * For each key there is usually 0-MAX_NODE_COUNT PeerDescriptors stored in the DHT. If there are fewer node,
+ * the peer descriptor of the local node is stored to the DHT.
+ */
+export class PeerDescriptorStoreManager {
+
+    private readonly abortController: AbortController
+    private readonly options: PeerDescriptorStoreManagerOptions
+    // eslint-disable-next-line no-underscore-dangle
+    private isLocalNodeStored_ = false
+
+    constructor(options: PeerDescriptorStoreManagerOptions) {
+        this.options = options
+        this.abortController = new AbortController()
+    }
+
+    async fetchNodes(): Promise<PeerDescriptor[]> {
+        logger.trace('Fetch data', { key: this.options.key })
+        try {
+            const result = await this.options.fetchDataFromDht(this.options.key)
+            return parsePeerDescriptor(result)
+        } catch (err) {
+            return []
+        }
+    }
+
+    async storeAndKeepLocalNode(): Promise<void> {
+        if (this.abortController.signal.aborted) {
+            return
+        }
+        // eslint-disable-next-line no-underscore-dangle
+        this.isLocalNodeStored_ = true
+        await this.storeLocalNode()
+        await this.keepLocalNode()
+    }
+
+    private async storeLocalNode(): Promise<void> {
+        const localPeerDescriptor = this.options.localPeerDescriptor
+        const dataToStore = Any.pack(localPeerDescriptor, PeerDescriptor)
+        try {
+            await this.options.storeDataToDht(this.options.key, dataToStore)
+        } catch (err) {
+            logger.warn('Failed to store local node', { key: this.options.key })
+        }
+    }
+
+    private async keepLocalNode(): Promise<void> {
+        await scheduleAtInterval(async () => {
+            logger.trace('Attempting to keep local node', { key: this.options.key })
+            try {
+                const discovered = await this.fetchNodes()
+                if (discovered.length < MAX_NODE_COUNT
+                    || discovered.some((peerDescriptor) => areEqualPeerDescriptors(peerDescriptor, this.options.localPeerDescriptor))) {
+                    await this.storeLocalNode()
+                }
+            } catch (err) {
+                logger.debug('Failed to keep local node', { key: this.options.key })
+            }
+        }, this.options.storeInterval ?? 60000, false, this.abortController.signal)
+    }
+
+    public isLocalNodeStored(): boolean {
+        // eslint-disable-next-line no-underscore-dangle
+        return this.isLocalNodeStored_
+    }
+
+    async destroy(): Promise<void> {
+        this.abortController.abort()
+        await this.options.deleteDataFromDht(this.options.key, false)
+    }
+}

package/src/logic/StreamPartNetworkSplitAvoidance.ts

@@ -1,6 +1,6 @@
 import { areEqualPeerDescriptors, DhtAddress, getNodeIdFromPeerDescriptor, PeerDescriptor } from '@streamr/dht'
 import { Logger, wait } from '@streamr/utils'
-import { Layer1Node } from './Layer1Node'
+import { DiscoveryLayerNode } from './DiscoveryLayerNode'
 
 /*
  * Tries to find new neighbors if we currently have less than MIN_NEIGHBOR_COUNT neigbors. It does so by
@@ -40,8 +40,8 @@ const exponentialRunOff = async (
 
 export const MIN_NEIGHBOR_COUNT = 4
 
-export interface StreamPartNetworkSplitAvoidanceConfig {
-    layer1Node: Layer1Node
+export interface StreamPartNetworkSplitAvoidanceOptions {
+    discoveryLayerNode: DiscoveryLayerNode
     discoverEntryPoints: (excludedNodes?: Set<DhtAddress>) => Promise<PeerDescriptor[]>
     exponentialRunOfBaseDelay?: number
 }
@@ -49,31 +49,31 @@ export interface StreamPartNetworkSplitAvoidanceConfig {
 export class StreamPartNetworkSplitAvoidance {
 
     private readonly abortController: AbortController
-    private readonly config: StreamPartNetworkSplitAvoidanceConfig
+    private readonly options: StreamPartNetworkSplitAvoidanceOptions
     private readonly excludedNodes: Set<DhtAddress> = new Set()
     private running = false
 
-    constructor(config: StreamPartNetworkSplitAvoidanceConfig) {
-        this.config = config
+    constructor(options: StreamPartNetworkSplitAvoidanceOptions) {
+        this.options = options
         this.abortController = new AbortController()
     }
 
     public async avoidNetworkSplit(): Promise<void> {
         this.running = true
         await exponentialRunOff(async () => {
-            const discoveredEntrypoints = await this.config.discoverEntryPoints()
+            const discoveredEntrypoints = await this.options.discoverEntryPoints()
             const filteredEntryPoints = discoveredEntrypoints.filter((peer) => !this.excludedNodes.has(getNodeIdFromPeerDescriptor(peer)))
-            await this.config.layer1Node.joinDht(filteredEntryPoints, false, false)
-            if (this.config.layer1Node.getNeighborCount() < MIN_NEIGHBOR_COUNT) {
+            await this.options.discoveryLayerNode.joinDht(filteredEntryPoints, false, false)
+            if (this.options.discoveryLayerNode.getNeighborCount() < MIN_NEIGHBOR_COUNT) {
                 // Filter out nodes that are not neighbors as those nodes are assumed to be offline
                 const newExcludes = filteredEntryPoints
-                    .filter((peer) => !this.config.layer1Node.getNeighbors()
+                    .filter((peer) => !this.options.discoveryLayerNode.getNeighbors()
                         .some((neighbor) => areEqualPeerDescriptors(neighbor, peer)))
                     .map((peer) => getNodeIdFromPeerDescriptor(peer))
                 newExcludes.forEach((node) => this.excludedNodes.add(node))
                 throw new Error(`Network split is still possible`)
             }
-        }, 'avoid network split', this.abortController.signal, this.config.exponentialRunOfBaseDelay)
+        }, 'avoid network split', this.abortController.signal, this.options.exponentialRunOfBaseDelay)
         this.running = false
         this.excludedNodes.clear()
         logger.trace(`Network split avoided`)

package/src/logic/StreamPartReconnect.ts

@@ -1,27 +1,27 @@
 import { scheduleAtInterval } from '@streamr/utils'
-import { EntryPointDiscovery } from './EntryPointDiscovery'
-import { Layer1Node } from './Layer1Node'
+import { PeerDescriptorStoreManager } from './PeerDescriptorStoreManager'
+import { DiscoveryLayerNode } from './DiscoveryLayerNode'
 
 const DEFAULT_RECONNECT_INTERVAL = 30 * 1000
 export class StreamPartReconnect {
     private abortController?: AbortController
-    private readonly layer1Node: Layer1Node
-    private readonly entryPointDiscovery: EntryPointDiscovery
+    private readonly discoveryLayerNode: DiscoveryLayerNode
+    private readonly peerDescriptorStoreManager: PeerDescriptorStoreManager
 
-    constructor(layer1Node: Layer1Node, entryPointDiscovery: EntryPointDiscovery) {
-        this.layer1Node = layer1Node
-        this.entryPointDiscovery = entryPointDiscovery
+    constructor(discoveryLayerNode: DiscoveryLayerNode, peerDescriptorStoreManager: PeerDescriptorStoreManager) {
+        this.discoveryLayerNode = discoveryLayerNode
+        this.peerDescriptorStoreManager = peerDescriptorStoreManager
     }
 
     async reconnect(timeout = DEFAULT_RECONNECT_INTERVAL): Promise<void> {
         this.abortController = new AbortController()
         await scheduleAtInterval(async () => {
-            const entryPoints = await this.entryPointDiscovery.discoverEntryPoints()
-            await this.layer1Node.joinDht(entryPoints)
-            if (this.entryPointDiscovery.isLocalNodeEntryPoint()) {
-                await this.entryPointDiscovery.storeAndKeepLocalNodeAsEntryPoint()
+            const entryPoints = await this.peerDescriptorStoreManager.fetchNodes()
+            await this.discoveryLayerNode.joinDht(entryPoints)
+            if (this.peerDescriptorStoreManager.isLocalNodeStored()) {
+                await this.peerDescriptorStoreManager.storeAndKeepLocalNode()
             }
-            if (this.layer1Node.getNeighborCount() > 0) {
+            if (this.discoveryLayerNode.getNeighborCount() > 0) {
                 this.abortController!.abort()
             }
         }, timeout, true, this.abortController.signal)