@streamr/trackerless-network 100.0.0-pretestnet.6 → 100.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamr/trackerless-network",
-  "version": "100.0.0-pretestnet.6",
+  "version": "100.0.0-rc.1",
   "description": "Minimal and extendable implementation of the Streamr Network node.",
   "repository": {
     "type": "git",
@@ -30,11 +30,11 @@
   "dependencies": {
     "@protobuf-ts/runtime": "^2.8.2",
     "@protobuf-ts/runtime-rpc": "^2.8.2",
-    "@streamr/dht": "100.0.0-pretestnet.6",
-    "@streamr/proto-rpc": "100.0.0-pretestnet.6",
-    "@streamr/protocol": "100.0.0-pretestnet.6",
-    "@streamr/test-utils": "100.0.0-pretestnet.6",
-    "@streamr/utils": "100.0.0-pretestnet.6",
+    "@streamr/dht": "100.0.0-rc.1",
+    "@streamr/proto-rpc": "100.0.0-rc.1",
+    "@streamr/protocol": "100.0.0-rc.1",
+    "@streamr/test-utils": "100.0.0-rc.1",
+    "@streamr/utils": "100.0.0-rc.1",
     "eventemitter3": "^5.0.0",
     "lodash": "^4.17.21",
     "uuid": "^9.0.1",
@@ -42,14 +42,14 @@
   },
   "devDependencies": {
     "@streamr/browser-test-runner": "^0.0.1",
-    "@types/lodash": "^4.14.201",
-    "@types/uuid": "^9.0.7",
+    "@types/lodash": "^4.14.202",
+    "@types/uuid": "^9.0.8",
     "@types/yallist": "^4.0.1",
-    "commander": "^11.1.0",
+    "commander": "^12.0.0",
     "expect": "^29.6.2",
-    "express": "^4.17.1",
+    "express": "^4.18.3",
     "ts-essentials": "^9.4.1",
-    "ts-loader": "^9.5.0",
-    "ts-node": "^10.9.1"
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2"
   }
 }

package/protos/NetworkRpc.proto

@@ -17,7 +17,7 @@ service ProxyConnectionRpc {
 
 service HandshakeRpc {
   rpc handshake (StreamPartHandshakeRequest) returns (StreamPartHandshakeResponse);
-  rpc interleaveNotice (InterleaveNotice) returns (google.protobuf.Empty);
+  rpc interleaveRequest (InterleaveRequest) returns (InterleaveResponse);
 }
 
 service NeighborUpdateRpc {
@@ -26,6 +26,11 @@ service NeighborUpdateRpc {
 
 service TemporaryConnectionRpc {
   rpc openConnection (TemporaryConnectionRequest) returns (TemporaryConnectionResponse);
+  rpc closeConnection (CloseTemporaryConnection) returns (google.protobuf.Empty);
+}
+
+service NodeInfoRpc {
+  rpc getInfo (NodeInfoRequest) returns (NodeInfoResponse);
 }
 
 message MessageID {
@@ -58,17 +63,30 @@ enum EncryptionType {
   AES = 1;
 }
 
+enum SignatureType {
+  LEGACY_SECP256K1 = 0;
+  SECP256K1 = 1;
+}
+
 message StreamMessage {
-  StreamMessageType messageType = 1;
+  // this is a required field but in generated NetworkRpc.ts it is incorrectly annotated as optional (NET-1082)
+  MessageID messageId = 1;
+  optional MessageRef previousMessageRef = 2;
+  bytes signature = 3;
+  SignatureType signatureType = 4;
+  oneof body {
+    ContentMessage contentMessage = 5;
+    GroupKeyRequest groupKeyRequest = 6;
+    GroupKeyResponse groupKeyResponse = 7;
+  }
+}
+
+message ContentMessage {
+  bytes content = 1;
   ContentType contentType = 2;
   EncryptionType encryptionType = 3;
-  bytes content = 4;
-  bytes signature = 5;
-  // this is a required field but in generated NetworkRpc.ts it is incorrectly annotated as optional (NET-1082)
-  MessageID messageId = 6;
-  optional MessageRef previousMessageRef = 7;
-  optional string groupKeyId = 8;
-  optional GroupKey newGroupKey = 9;
+  optional string groupKeyId = 4;
+  optional GroupKey newGroupKey = 5;
 }
 
 message GroupKeyRequest {
@@ -103,14 +121,18 @@ message StreamPartHandshakeResponse {
   optional dht.PeerDescriptor interleaveTargetDescriptor = 3;
 }
 
-message InterleaveNotice {
-  string streamPartId = 1;
+message InterleaveRequest {
   // this is a required field but in generated NetworkRpc.ts it is incorrectly annotated as optional (NET-1082)
-  dht.PeerDescriptor interleaveTargetDescriptor = 2;
+  dht.PeerDescriptor interleaveTargetDescriptor = 1;
+}
+
+message InterleaveResponse {
+  bool accepted = 1;
 }
 
 message LeaveStreamPartNotice {
   string streamPartId = 1;
+  bool isEntryPoint = 2;
 }
 
 message NeighborUpdate {
@@ -135,7 +157,30 @@ message TemporaryConnectionResponse {
   bool accepted = 1;
 }
 
+message CloseTemporaryConnection {
+}
+
 enum ProxyDirection {
   PUBLISH = 0;
   SUBSCRIBE = 1;
 }
+
+message StreamPartitionInfo {
+  string id = 1;
+  repeated dht.PeerDescriptor controlLayerNeighbors = 2;
+  repeated dht.PeerDescriptor deliveryLayerNeighbors = 3;
+}
+
+message ControlLayerInfo {
+  repeated dht.PeerDescriptor neighbors = 1;
+  repeated dht.PeerDescriptor connections = 2;
+}
+
+message NodeInfoRequest {}
+
+message NodeInfoResponse {
+  dht.PeerDescriptor peerDescriptor = 1;
+  repeated StreamPartitionInfo streamPartitions = 2;
+  optional ControlLayerInfo controlLayer = 3;
+  string version = 4;
+}

package/src/NetworkNode.ts

@@ -1,10 +1,9 @@
 import { StreamMessage, StreamPartID } from '@streamr/protocol'
-import { PeerDescriptor } from '@streamr/dht'
+import { DhtAddress, PeerDescriptor } from '@streamr/dht'
 import { StreamMessageTranslator } from './logic/protocol-integration/stream-message/StreamMessageTranslator'
-import { NetworkOptions, NetworkStack } from './NetworkStack'
+import { NetworkOptions, NetworkStack, NodeInfo } from './NetworkStack'
 import { EthereumAddress, Logger, MetricsContext } from '@streamr/utils'
 import { ProxyDirection } from './proto/packages/trackerless-network/protos/NetworkRpc'
-import { NodeID } from './identifiers'
 import { pull } from 'lodash'
 
 export const createNetworkNode = (opts: NetworkOptions): NetworkNode => {
@@ -74,7 +73,7 @@ export class NetworkNode {
     }
 
     setStreamPartEntryPoints(streamPartId: StreamPartID, contactPeerDescriptors: PeerDescriptor[]): void {
-        this.stack.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, contactPeerDescriptors)
+        this.stack.getStreamrNode().setStreamPartEntryPoints(streamPartId, contactPeerDescriptors)
     }
 
     removeMessageListener(cb: (msg: StreamMessage) => void): void {
@@ -88,7 +87,7 @@ export class NetworkNode {
         await this.stack.getStreamrNode().leaveStreamPart(streamPartId)
     }
 
-    getNeighbors(streamPartId: StreamPartID): ReadonlyArray<NodeID> {
+    getNeighbors(streamPartId: StreamPartID): ReadonlyArray<DhtAddress> {
         return this.stack.getStreamrNode().getNeighbors(streamPartId)
     }
 
@@ -109,14 +108,22 @@ export class NetworkNode {
         return this.stack.getMetricsContext()
     }
 
-    getNodeId(): NodeID {
+    getNodeId(): DhtAddress {
         return this.stack.getStreamrNode().getNodeId()
     }
 
+    getOptions(): NetworkOptions {
+        return this.stack.getOptions()
+    }
+
     getStreamParts(): StreamPartID[] {
         return this.stack.getStreamrNode().getStreamParts()
     }
 
+    async fetchNodeInfo(node: PeerDescriptor): Promise<NodeInfo> {
+        return this.stack.fetchNodeInfo(node)
+    }
+
     // eslint-disable-next-line class-methods-use-this
     getDiagnosticInfo(): Record<string, unknown> {
         return {}

package/src/NetworkStack.ts

@@ -1,10 +1,20 @@
-import { ConnectionManager, DhtNode, DhtNodeOptions, areEqualPeerDescriptors } from '@streamr/dht'
-import { StreamrNode, StreamrNodeConfig } from './logic/StreamrNode'
-import { MetricsContext, waitForCondition } from '@streamr/utils'
-import { EventEmitter } from 'eventemitter3'
+import {
+    ConnectionManager,
+    DhtNode,
+    DhtNodeOptions,
+    ListeningRpcCommunicator,
+    PeerDescriptor,
+    areEqualPeerDescriptors
+} from '@streamr/dht'
 import { StreamID, StreamPartID, toStreamPartID } from '@streamr/protocol'
-import { ProxyDirection, StreamMessage, StreamMessageType } from './proto/packages/trackerless-network/protos/NetworkRpc'
+import { Logger, MetricsContext, waitForCondition } from '@streamr/utils'
+import { pull } from 'lodash'
+import { version as applicationVersion } from '../package.json'
 import { Layer0Node } from './logic/Layer0Node'
+import { StreamrNode, StreamrNodeConfig } from './logic/StreamrNode'
+import { NodeInfoClient } from './logic/node-info/NodeInfoClient'
+import { NODE_INFO_RPC_SERVICE_ID, NodeInfoRpcLocal } from './logic/node-info/NodeInfoRpcLocal'
+import { NodeInfoResponse, ProxyDirection, StreamMessage } from './proto/packages/trackerless-network/protos/NetworkRpc'
 
 export interface NetworkOptions {
     layer0?: DhtNodeOptions
@@ -12,19 +22,46 @@ export interface NetworkOptions {
     metricsContext?: MetricsContext
 }
 
-export interface NetworkStackEvents {
-    stopped: () => void
+const logger = new Logger(module)
+
+const instances: NetworkStack[] = []
+const stopInstances = async () => {
+    // make a clone so that it is ok for each instance.stop() to remove itself from the list (at line 139)
+    // while the map function is iterating the list
+    const clonedInstances = [...instances]
+    await Promise.all(clonedInstances.map((instance) => instance.stop()))
+}
+const EXIT_EVENTS = [`exit`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `unhandledRejection`, `SIGTERM`]
+EXIT_EVENTS.forEach((event) => {
+    process.on(event, async (eventArg) => {
+        const isError = (event === 'uncaughtException') || (event === 'unhandledRejection')
+        if (isError) {
+            logger.error(`exit event: ${event}`, eventArg)
+        }
+        await stopInstances()
+        process.exit(isError ? 1 : 0)
+    })
+})
+declare let window: any
+if (typeof window === 'object') {
+    window.addEventListener('unload', async () => {
+        await stopInstances()
+    })
 }
 
-export class NetworkStack extends EventEmitter<NetworkStackEvents> {
+export type NodeInfo = Required<NodeInfoResponse>
+
+export class NetworkStack {
 
     private layer0Node?: Layer0Node
     private streamrNode?: StreamrNode
+    private stopped = false
     private readonly metricsContext: MetricsContext
     private readonly options: NetworkOptions
+    private nodeInfoRpcLocal?: NodeInfoRpcLocal
+    private nodeInfoClient?: NodeInfoClient
 
     constructor(options: NetworkOptions) {
-        super()
         this.options = options
         this.metricsContext = options.metricsContext ?? new MetricsContext()
         this.layer0Node = new DhtNode({
@@ -35,6 +72,7 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
             ...options.networkNode,
             metricsContext: this.metricsContext
         })
+        instances.push(this)
     }
 
     async joinStreamPart(streamPartId: StreamPartID, neighborRequirement?: { minCount: number, timeout: number }): Promise<void> {
@@ -52,7 +90,7 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
 
     async broadcast(msg: StreamMessage): Promise<void> {
         const streamPartId = toStreamPartID(msg.messageId!.streamId as StreamID, msg.messageId!.streamPartition)
-        if (this.getStreamrNode().isProxiedStreamPart(streamPartId, ProxyDirection.SUBSCRIBE) && (msg.messageType === StreamMessageType.MESSAGE)) {
+        if (this.getStreamrNode().isProxiedStreamPart(streamPartId, ProxyDirection.SUBSCRIBE) && (msg.body.oneofKind === 'contentMessage')) {
             throw new Error(`Cannot broadcast to ${streamPartId} as proxy subscribe connections have been set`)
         }
         // TODO could combine these two calls to isProxiedStreamPart?
@@ -75,7 +113,16 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
                 await this.ensureConnectedToControlLayer()
             }
         }
+        // TODO: remove undefined checks here. Assume that start is approproately awaited before stop is called.
         await this.streamrNode?.start(this.layer0Node!, connectionManager, connectionManager)
+        if (this.streamrNode) {
+            const infoRpcCommunicator = new ListeningRpcCommunicator(NODE_INFO_RPC_SERVICE_ID, this.getConnectionManager())
+            this.nodeInfoRpcLocal = new NodeInfoRpcLocal(this, infoRpcCommunicator)
+            this.nodeInfoClient = new NodeInfoClient(
+                this.layer0Node!.getLocalPeerDescriptor(),
+                infoRpcCommunicator
+            )
+        }
     }
 
     private async ensureConnectedToControlLayer(): Promise<void> {
@@ -89,8 +136,8 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
                     await this.layer0Node?.joinDht(this.options.layer0.entryPoints)
                 }
             })
+            await this.layer0Node!.waitForNetworkConnectivity()
         }
-        await this.layer0Node!.waitForNetworkConnectivity()
     }
 
     getStreamrNode(): StreamrNode {
@@ -105,12 +152,43 @@ export class NetworkStack extends EventEmitter<NetworkStackEvents> {
         return this.metricsContext
     }
 
+    async fetchNodeInfo(node: PeerDescriptor): Promise<NodeInfo> {
+        if (!areEqualPeerDescriptors(node, this.getLayer0Node().getLocalPeerDescriptor())) {
+            return this.nodeInfoClient!.getInfo(node)
+        } else {
+            return this.createNodeInfo()
+        }
+    }
+
+    createNodeInfo(): NodeInfo {
+        return {
+            peerDescriptor: this.getLayer0Node().getLocalPeerDescriptor(),
+            controlLayer: {
+                connections: this.getLayer0Node().getConnections(),
+                neighbors: this.getLayer0Node().getNeighbors()
+            },
+            streamPartitions: this.getStreamrNode().getNodeInfo(),
+            version: applicationVersion
+        }
+    }
+
+    getOptions(): NetworkOptions {
+        return this.options
+    }
+
+    private getConnectionManager(): ConnectionManager {
+        return this.layer0Node!.getTransport() as ConnectionManager
+    }
+
     async stop(): Promise<void> {
-        await this.streamrNode!.destroy()
-        await this.layer0Node!.stop()
-        this.streamrNode = undefined
-        this.layer0Node = undefined
-        this.emit('stopped')
+        if (!this.stopped) {
+            this.stopped = true
+            pull(instances, this)
+            await this.streamrNode!.destroy()
+            await this.layer0Node!.stop()
+            this.streamrNode = undefined
+            this.layer0Node = undefined
+        }
     }
 
 }

package/src/exports.ts

@@ -1,5 +1,13 @@
-export { NetworkStack, NetworkOptions } from './NetworkStack'
+export { NetworkStack, NetworkOptions, NodeInfo } from './NetworkStack'
 export { NetworkNode, createNetworkNode } from './NetworkNode'
 export { StreamrNodeConfig } from './logic/StreamrNode'
-export { NodeID } from './identifiers'
-export { ProxyDirection } from './proto/packages/trackerless-network/protos/NetworkRpc'
+export { ProxyDirection, GroupKeyRequest, GroupKeyResponse } from './proto/packages/trackerless-network/protos/NetworkRpc'
+export { streamPartIdToDataKey } from './logic/EntryPointDiscovery'
+export {
+    convertStreamMessageToBytes,
+    convertBytesToStreamMessage,
+    convertGroupKeyRequestToBytes,
+    convertBytesToGroupKeyRequest,
+    convertGroupKeyResponseToBytes,
+    convertBytesToGroupKeyResponse
+} from './logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils'

package/src/logic/DeliveryRpcLocal.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator, PeerDescriptor, DhtCallContext } from '@streamr/dht'
+import { ListeningRpcCommunicator, PeerDescriptor, DhtCallContext, DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { Empty } from '../proto/google/protobuf/empty'
 import {
     LeaveStreamPartNotice,
@@ -8,16 +8,15 @@ import {
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 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 DeliveryRpcLocalConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     markAndCheckDuplicate: (messageId: MessageID, previousMessageRef?: MessageRef) => boolean
-    broadcast: (message: StreamMessage, previousNode?: NodeID) => void
-    onLeaveNotice(senderId: NodeID): void
-    markForInspection(senderId: NodeID, messageId: MessageID): void
+    broadcast: (message: StreamMessage, previousNode?: DhtAddress) => void
+    onLeaveNotice(senderId: DhtAddress, isLocalNodeEntryPoint: boolean): void
+    markForInspection(senderId: DhtAddress, messageId: MessageID): void
     rpcCommunicator: ListeningRpcCommunicator
 }
 
@@ -40,9 +39,9 @@ export class DeliveryRpcLocal implements IDeliveryRpc {
 
     async leaveStreamPartNotice(message: LeaveStreamPartNotice, context: ServerCallContext): Promise<Empty> {
         if (message.streamPartId === this.config.streamPartId) {
-            const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-            const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
-            this.config.onLeaveNotice(senderId)
+            const sourcePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+            const sourceId = getNodeIdFromPeerDescriptor(sourcePeerDescriptor)
+            this.config.onLeaveNotice(sourceId, message.isEntryPoint)
         }
         return Empty
     }

package/src/logic/DeliveryRpcRemote.ts

@@ -1,14 +1,15 @@
-import { Remote } from '@streamr/dht'
+import { RpcRemote } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
 import {
     LeaveStreamPartNotice,
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { IDeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 
-export class DeliveryRpcRemote extends Remote<IDeliveryRpcClient> {
+export class DeliveryRpcRemote extends RpcRemote<DeliveryRpcClient> {
 
     async sendStreamMessage(msg: StreamMessage): Promise<void> {
         const options = this.formDhtRpcOptions({
@@ -19,9 +20,10 @@ export class DeliveryRpcRemote extends Remote<IDeliveryRpcClient> {
         })
     }
 
-    leaveStreamPartNotice(): void {
+    leaveStreamPartNotice(streamPartId: StreamPartID, isLocalNodeEntryPoint: boolean): void {
         const notification: LeaveStreamPartNotice = {
-            streamPartId: this.getServiceId()
+            streamPartId,
+            isEntryPoint: isLocalNodeEntryPoint
         }
         const options = this.formDhtRpcOptions({
             notification: true

package/src/logic/DuplicateMessageDetector.ts

@@ -82,11 +82,11 @@ export class GapMisMatchError extends Error {
  *
  */
 export class DuplicateMessageDetector {
-    private readonly maxNumberOfGaps: number
+    private readonly maxGapCount: number
     private readonly gaps: Array<[NumberPair, NumberPair]>
 
-    constructor(maxNumberOfGaps = 10000) {
-        this.maxNumberOfGaps = maxNumberOfGaps
+    constructor(maxGapCount = 10000) {
+        this.maxGapCount = maxGapCount
         this.gaps = [] // ascending order of half-closed intervals (x,y] representing gaps that contain unseen message(s)
     }
 
@@ -144,7 +144,7 @@ export class DuplicateMessageDetector {
                 //   - last gap is [n, Infinity]
                 //   - anything not covered by a gap is considered seen
 
-                this.dropLowestGapIfOverMaxNumberOfGaps()
+                this.dropLowestGapIfOverMaxGapCount()
                 return true
             }
             if (number.greaterThan(lowerBound)) {
@@ -154,9 +154,9 @@ export class DuplicateMessageDetector {
         return false
     }
 
-    private dropLowestGapIfOverMaxNumberOfGaps(): void {
-        // invariant: this.gaps.length <= this.maxNumberOfGaps + 1
-        if (this.gaps.length > this.maxNumberOfGaps) {
+    private dropLowestGapIfOverMaxGapCount(): void {
+        // invariant: this.gaps.length <= this.maxGapCount + 1
+        if (this.gaps.length > this.maxGapCount) {
             this.gaps.shift()
         }
     }

package/src/logic/EntryPointDiscovery.ts

@@ -1,17 +1,19 @@
 import {
     DataEntry,
+    DhtAddress,
     PeerDescriptor,
-    areEqualPeerDescriptors
+    areEqualPeerDescriptors,
+    getDhtAddressFromRaw,
+    getNodeIdFromPeerDescriptor
 } 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 { Layer1Node } from './Layer1Node'
 
-export const streamPartIdToDataKey = (streamPartId: StreamPartID): Uint8Array => {
-    return new Uint8Array(createHash('md5').update(streamPartId).digest())
+export const streamPartIdToDataKey = (streamPartId: StreamPartID): DhtAddress => {
+    return getDhtAddressFromRaw(new Uint8Array((createHash('sha1').update(streamPartId).digest())))
 }
 
 const parseEntryPointData = (dataEntries: DataEntry[]): PeerDescriptor[] => {
@@ -51,16 +53,16 @@ const exponentialRunOff = async (
 
 const logger = new Logger(module)
 
-const ENTRYPOINT_STORE_LIMIT = 20
+export const ENTRYPOINT_STORE_LIMIT = 8
 export const NETWORK_SPLIT_AVOIDANCE_LIMIT = 4
 
 interface EntryPointDiscoveryConfig {
     streamPartId: StreamPartID
     localPeerDescriptor: PeerDescriptor
     layer1Node: Layer1Node
-    getEntryPointData: (key: Uint8Array) => Promise<DataEntry[]>
-    storeEntryPointData: (key: Uint8Array, data: Any) => Promise<PeerDescriptor[]>
-    deleteEntryPointData: (key: Uint8Array) => Promise<void>
+    fetchEntryPointData: (key: DhtAddress) => Promise<DataEntry[]>
+    storeEntryPointData: (key: DhtAddress, data: Any) => Promise<PeerDescriptor[]>
+    deleteEntryPointData: (key: DhtAddress) => Promise<void>
     storeInterval?: number
 }
 
@@ -68,17 +70,15 @@ export class EntryPointDiscovery {
     private readonly abortController: AbortController
     private readonly config: EntryPointDiscoveryConfig
     private readonly storeInterval: number
-    private readonly networkSplitAvoidedNodes: Set<NodeID> = new Set()
-
+    private readonly networkSplitAvoidedNodes: Set<DhtAddress> = new Set()
+    private isLocalNodeStoredAsEntryPoint = false
     constructor(config: EntryPointDiscoveryConfig) {
         this.config = config
         this.abortController = new AbortController()
         this.storeInterval = this.config.storeInterval ?? 60000
     }
 
-    async discoverEntryPointsFromDht(
-        knownEntryPointCount: number
-    ): Promise<FindEntryPointsResult> {
+    async discoverEntryPointsFromDht(knownEntryPointCount: number): Promise<FindEntryPointsResult> {
         if (knownEntryPointCount > 0) {
             return {
                 entryPointsFromDht: false,
@@ -108,10 +108,10 @@ export class EntryPointDiscovery {
         }
     }
 
-    private async queryEntrypoints(key: Uint8Array): Promise<PeerDescriptor[]> {
+    private async queryEntrypoints(key: DhtAddress): Promise<PeerDescriptor[]> {
         logger.trace(`Finding data from dht node ${getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)}`)
         try {
-            const result = await this.config.getEntryPointData(key)
+            const result = await this.config.fetchEntryPointData(key)
             return parseEntryPointData(result)
         } catch (err) {
             return []
@@ -122,12 +122,14 @@ export class EntryPointDiscovery {
         if (this.abortController.signal.aborted) {
             return
         }
-        const possibleNetworkSplitDetected = this.config.layer1Node.getBucketSize() < NETWORK_SPLIT_AVOIDANCE_LIMIT
+        const possibleNetworkSplitDetected = this.config.layer1Node.getNeighborCount() < NETWORK_SPLIT_AVOIDANCE_LIMIT
         if ((currentEntrypointCount < ENTRYPOINT_STORE_LIMIT) || possibleNetworkSplitDetected) {
+            this.isLocalNodeStoredAsEntryPoint = true
             await this.storeSelfAsEntryPoint()
             await this.keepSelfAsEntryPoint()
         }
         if (possibleNetworkSplitDetected) {
+            // TODO should we catch possible promise rejection?
             setImmediate(() => this.avoidNetworkSplit())
         }
     }
@@ -161,10 +163,11 @@ export class EntryPointDiscovery {
         await exponentialRunOff(async () => {
             const rediscoveredEntrypoints = await this.discoverEntryPoints()
             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
+            if (this.config.layer1Node.getNeighborCount() < NETWORK_SPLIT_AVOIDANCE_LIMIT) {
+                // Filter out nodes that are not neighbors as those nodes are assumed to be offline
                 const nodesToAvoid = rediscoveredEntrypoints
-                    .filter((peer) => !this.config.layer1Node!.getKBucketPeers().includes(peer))
+                    .filter((peer) => !this.config.layer1Node.getNeighbors()
+                        .some((neighbor) => areEqualPeerDescriptors(neighbor, peer)))
                     .map((peer) => getNodeIdFromPeerDescriptor(peer))
                 nodesToAvoid.forEach((node) => this.networkSplitAvoidedNodes.add(node))
                 throw new Error(`Network split is still possible`)
@@ -174,6 +177,10 @@ export class EntryPointDiscovery {
         logger.trace(`Network split avoided`)
     }
 
+    public isLocalNodeEntryPoint(): boolean {
+        return this.isLocalNodeStoredAsEntryPoint
+    }
+
     async destroy(): Promise<void> {
         this.abortController.abort()
         await this.config.deleteEntryPointData(streamPartIdToDataKey(this.config.streamPartId))

package/src/logic/Layer0Node.ts

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