@streamr/trackerless-network 101.1.2 → 102.0.0-beta.1

package/src/logic/neighbor-discovery/HandshakeRpcLocal.ts

@@ -4,8 +4,8 @@ import {
     DhtAddressRaw,
     DhtCallContext,
     PeerDescriptor,
-    getDhtAddressFromRaw,
-    getNodeIdFromPeerDescriptor
+    toDhtAddress,
+    toNodeId
 } from '@streamr/dht'
 import { Logger, StreamPartID } from '@streamr/utils'
 import {
@@ -13,8 +13,8 @@ import {
     InterleaveResponse,
     StreamPartHandshakeRequest,
     StreamPartHandshakeResponse
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+} from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { IHandshakeRpc } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.server'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { NodeList } from '../NodeList'
 import { HandshakeRpcRemote } from './HandshakeRpcRemote'
@@ -46,8 +46,8 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
 
     private handleRequest(request: StreamPartHandshakeRequest, context: ServerCallContext): StreamPartHandshakeResponse {
         const senderDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const getInterleaveNodeIds = () => (request.interleaveNodeId !== undefined) ? [getDhtAddressFromRaw(request.interleaveNodeId)] : []
-        const senderNodeId = getNodeIdFromPeerDescriptor(senderDescriptor)
+        const getInterleaveNodeIds = () => (request.interleaveNodeId !== undefined) ? [toDhtAddress(request.interleaveNodeId)] : []
+        const senderNodeId = toNodeId(senderDescriptor)
         if (this.options.ongoingInterleaves.has(senderNodeId)) {
             return this.rejectHandshake(request)
         } else if (this.options.neighbors.has(senderNodeId)
@@ -88,16 +88,16 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
 
     private acceptHandshakeWithInterleaving(request: StreamPartHandshakeRequest, requester: PeerDescriptor): StreamPartHandshakeResponse {
         const exclude: DhtAddress[] = []
-        request.neighborNodeIds.forEach((id: DhtAddressRaw) => exclude.push(getDhtAddressFromRaw(id)))
+        request.neighborNodeIds.forEach((id: DhtAddressRaw) => exclude.push(toDhtAddress(id)))
         this.options.ongoingInterleaves.forEach((id) => exclude.push(id))
-        exclude.push(getNodeIdFromPeerDescriptor(requester))
+        exclude.push(toNodeId(requester))
         if (request.interleaveNodeId !== undefined) {
-            exclude.push(getDhtAddressFromRaw(request.interleaveNodeId))
+            exclude.push(toDhtAddress(request.interleaveNodeId))
         }
         const last = this.options.neighbors.getLast(exclude)
         const lastPeerDescriptor = last ? last.getPeerDescriptor() : undefined
         if (last) {
-            const nodeId = getNodeIdFromPeerDescriptor(last.getPeerDescriptor())
+            const nodeId = toNodeId(last.getPeerDescriptor())
             const remote = this.options.createRpcRemote(last.getPeerDescriptor())
             this.options.ongoingInterleaves.add(nodeId)
             // Run this with then catch instead of setImmediate to avoid changes in state
@@ -107,7 +107,7 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
                 // and unlock the connection
                 // If response is not accepted, keep the last node as a neighbor
                 if (response.accepted) {
-                    this.options.neighbors.remove(getNodeIdFromPeerDescriptor(lastPeerDescriptor!))
+                    this.options.neighbors.remove(toNodeId(lastPeerDescriptor!))
                 }
             }).catch(() => {
                 // no-op: InterleaveRequest cannot reject
@@ -125,13 +125,13 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
 
     async interleaveRequest(message: InterleaveRequest, context: ServerCallContext): Promise<InterleaveResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const remoteNodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        const remoteNodeId = toNodeId(senderPeerDescriptor)
         try {
             await this.options.handshakeWithInterleaving(message.interleaveTargetDescriptor!, remoteNodeId)
             this.options.neighbors.remove(remoteNodeId)
             return { accepted: true }
         } catch (err) {
-            logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(message.interleaveTargetDescriptor!)} failed`, { err })
+            logger.debug(`interleaveRequest to ${toNodeId(message.interleaveTargetDescriptor!)} failed`, { err })
             return { accepted: false }
         }
     }

package/src/logic/neighbor-discovery/HandshakeRpcRemote.ts

@@ -1,8 +1,8 @@
-import { DhtAddress, PeerDescriptor, RpcRemote, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '@streamr/dht'
+import { DhtAddress, PeerDescriptor, RpcRemote, toNodeId, toDhtAddressRaw } from '@streamr/dht'
 import { Logger, StreamPartID } from '@streamr/utils'
 import { v4 } from 'uuid'
-import { InterleaveRequest, InterleaveResponse, StreamPartHandshakeRequest } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { HandshakeRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { InterleaveRequest, InterleaveResponse, StreamPartHandshakeRequest } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { HandshakeRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
@@ -24,9 +24,9 @@ export class HandshakeRpcRemote extends RpcRemote<HandshakeRpcClient> {
         const request: StreamPartHandshakeRequest = {
             streamPartId,
             requestId: v4(),
-            neighborNodeIds: neighborNodeIds.map((id) => getRawFromDhtAddress(id)),
-            concurrentHandshakeNodeId: (concurrentHandshakeNodeId !== undefined) ? getRawFromDhtAddress(concurrentHandshakeNodeId) : undefined,
-            interleaveNodeId: (interleaveNodeId !== undefined) ? getRawFromDhtAddress(interleaveNodeId) : undefined
+            neighborNodeIds: neighborNodeIds.map((id) => toDhtAddressRaw(id)),
+            concurrentHandshakeNodeId: (concurrentHandshakeNodeId !== undefined) ? toDhtAddressRaw(concurrentHandshakeNodeId) : undefined,
+            interleaveNodeId: (interleaveNodeId !== undefined) ? toDhtAddressRaw(interleaveNodeId) : undefined
         }
         try {
             const response = await this.getClient().handshake(request, this.formDhtRpcOptions())
@@ -35,7 +35,7 @@ export class HandshakeRpcRemote extends RpcRemote<HandshakeRpcClient> {
                 interleaveTargetDescriptor: response.interleaveTargetDescriptor
             }
         } catch (err: any) {
-            logger.debug(`handshake to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
+            logger.debug(`handshake to ${toNodeId(this.getPeerDescriptor())} failed`, { err })
             return {
                 accepted: false
             }
@@ -56,7 +56,7 @@ export class HandshakeRpcRemote extends RpcRemote<HandshakeRpcClient> {
                 accepted: res.accepted
             }
         } catch (err) {
-            logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
+            logger.debug(`interleaveRequest to ${toNodeId(this.getPeerDescriptor())} failed`, { err })
             return {
                 accepted: false
             }

package/src/logic/neighbor-discovery/Handshaker.ts

@@ -1,14 +1,14 @@
-import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, toNodeId } from '@streamr/dht'
 import { Logger, StreamPartID } from '@streamr/utils'
 import {
     InterleaveRequest,
     InterleaveResponse,
     StreamPartHandshakeRequest,
     StreamPartHandshakeResponse
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+} from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
 import {
     ContentDeliveryRpcClient, HandshakeRpcClient
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+} from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { NodeList } from '../NodeList'
 import { HandshakeRpcLocal } from './HandshakeRpcLocal'
@@ -70,7 +70,7 @@ export class Handshaker {
     private async selectParallelTargetsAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         const exclude = excludedIds.concat(this.options.neighbors.getIds())
         const neighbors = this.selectParallelTargets(exclude)
-        neighbors.forEach((contact) => this.options.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
+        neighbors.forEach((contact) => this.options.ongoingHandshakes.add(toNodeId(contact.getPeerDescriptor())))
         return this.doParallelHandshakes(neighbors, exclude)
     }
 
@@ -83,7 +83,7 @@ export class Handshaker {
                 true
             )
             if (wsNode) {
-                const wsNodeId = getNodeIdFromPeerDescriptor(wsNode.getPeerDescriptor())
+                const wsNodeId = toNodeId(wsNode.getPeerDescriptor())
                 excludedIds.push(wsNodeId)
                 neighbors.set(wsNodeId, wsNode)
             }   
@@ -92,21 +92,21 @@ export class Handshaker {
         const left = this.options.leftNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
         const right = this.options.rightNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
         if (left) {
-            neighbors.set(getNodeIdFromPeerDescriptor(left.getPeerDescriptor()), left)
+            neighbors.set(toNodeId(left.getPeerDescriptor()), left)
         }
         if (right) {
-            neighbors.set(getNodeIdFromPeerDescriptor(right.getPeerDescriptor()), right)
+            neighbors.set(toNodeId(right.getPeerDescriptor()), right)
         }
         // If there is still room add the closest contact based on the kademlia metric
         if (neighbors.size < PARALLEL_HANDSHAKE_COUNT) {
             const first = this.options.nearbyNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
             if (first) {
-                neighbors.set(getNodeIdFromPeerDescriptor(first.getPeerDescriptor()), first)
+                neighbors.set(toNodeId(first.getPeerDescriptor()), first)
             }
         }
         const getExcludedFromRandomView = () => [
             ...excludedIds,
-            ...Array.from(neighbors.values()).map((neighbor) => getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor()))
+            ...Array.from(neighbors.values()).map((neighbor) => toNodeId(neighbor.getPeerDescriptor()))
         ]
         // If there is still room add a random contact until PARALLEL_HANDSHAKE_COUNT is reached
         while (
@@ -115,7 +115,7 @@ export class Handshaker {
         ) {
             const random = this.options.randomNodeView.getRandom([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
             if (random) {
-                neighbors.set(getNodeIdFromPeerDescriptor(random.getPeerDescriptor()), random)
+                neighbors.set(toNodeId(random.getPeerDescriptor()), random)
             }
         }
         return Array.from(neighbors.values()).map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
@@ -126,13 +126,13 @@ export class Handshaker {
             Array.from(targets.values()).map(async (target: HandshakeRpcRemote, i) => {
                 const otherNode = i === 0 ? targets[1] : targets[0]
                 // TODO better check (currently this condition is always true)
-                const otherNodeId = otherNode ? getNodeIdFromPeerDescriptor(otherNode.getPeerDescriptor()) : undefined
+                const otherNodeId = otherNode ? toNodeId(otherNode.getPeerDescriptor()) : undefined
                 return this.handshakeWithTarget(target, otherNodeId)
             })
         )
         results.forEach((res, i) => {
             if (res.status !== 'fulfilled' || !res.value) {
-                excludedIds.push(getNodeIdFromPeerDescriptor(targets[i].getPeerDescriptor()))
+                excludedIds.push(toNodeId(targets[i].getPeerDescriptor()))
             }
         })
         return excludedIds
@@ -147,14 +147,14 @@ export class Handshaker {
         if (neighbor) {
             const accepted = await this.handshakeWithTarget(this.createRpcRemote(neighbor.getPeerDescriptor()))
             if (!accepted) {
-                excludedIds.push(getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor()))
+                excludedIds.push(toNodeId(neighbor.getPeerDescriptor()))
             }
         }
         return excludedIds
     }
 
     private async handshakeWithTarget(neighbor: HandshakeRpcRemote, concurrentNodeId?: DhtAddress): Promise<boolean> {
-        const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
+        const targetNodeId = toNodeId(neighbor.getPeerDescriptor())
         this.options.ongoingHandshakes.add(targetNodeId)
         const result = await neighbor.handshake(
             this.options.streamPartId,
@@ -173,7 +173,7 @@ export class Handshaker {
 
     private async handshakeWithInterleaving(target: PeerDescriptor, remoteNodeId: DhtAddress): Promise<boolean> {
         const neighbor = this.createRpcRemote(target)
-        const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
+        const targetNodeId = toNodeId(neighbor.getPeerDescriptor())
         this.options.ongoingHandshakes.add(targetNodeId)
         const result = await neighbor.handshake(
             this.options.streamPartId,

package/src/logic/neighbor-discovery/NeighborFinder.ts

@@ -1,4 +1,4 @@
-import { setAbortableTimeout } from '@streamr/utils'
+import { Logger, setAbortableTimeout } from '@streamr/utils'
 import { NodeList } from '../NodeList'
 import { DhtAddress } from '@streamr/dht'
 
@@ -15,6 +15,8 @@ interface FindNeighborsSessionOptions {
 const INITIAL_WAIT = 100
 const INTERVAL = 250
 
+const logger = new Logger(module)
+
 export class NeighborFinder {
     private readonly abortController: AbortController
     private readonly options: FindNeighborsSessionOptions
@@ -39,6 +41,9 @@ export class NeighborFinder {
         if (this.options.neighbors.size() < this.options.minCount && newExcludes.length < uniqueContactCount) {
             // TODO should we catch possible promise rejection?
             setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL, this.abortController.signal)
+        } else if (this.options.neighbors.size() === 0 && uniqueContactCount > 0) {
+            logger.debug('No neighbors found yet contacts are available, restarting handshaking process')
+            setAbortableTimeout(() => this.findNeighbors([]), INTERVAL, this.abortController.signal)
         } else {
             this.running = false
         }

package/src/logic/neighbor-discovery/NeighborUpdateManager.ts

@@ -1,7 +1,7 @@
-import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, toNodeId } from '@streamr/dht'
 import { Logger, StreamPartID, scheduleAtInterval } from '@streamr/utils'
-import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { NeighborUpdate } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { NeighborUpdateRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../NodeList'
 import { NeighborFinder } from './NeighborFinder'
 import { NeighborUpdateRpcLocal } from './NeighborUpdateRpcLocal'
@@ -46,10 +46,12 @@ export class NeighborUpdateManager {
     private async updateNeighborInfo(): Promise<void> {
         logger.trace(`Updating neighbor info to nodes`)
         const neighborDescriptors = this.options.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
+        const startTime = Date.now()
         await Promise.allSettled(this.options.neighbors.getAll().map(async (neighbor) => {
             const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(this.options.streamPartId, neighborDescriptors)
+            const nodeId = toNodeId(neighbor.getPeerDescriptor())
+            this.options.neighbors.get(nodeId)!.setRtt(Date.now() - startTime)
             if (res.removeMe) {
-                const nodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
                 this.options.neighbors.remove(nodeId)
                 this.options.neighborFinder.start([nodeId])
             }

package/src/logic/neighbor-discovery/NeighborUpdateRpcLocal.ts

@@ -1,9 +1,9 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, toNodeId } from '@streamr/dht'
 import { StreamPartID } from '@streamr/utils'
-import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { INeighborUpdateRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { NeighborUpdate } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { ContentDeliveryRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
+import { INeighborUpdateRpc } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.server'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { NodeList } from '../NodeList'
 import { NeighborFinder } from './NeighborFinder'
@@ -28,9 +28,9 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
     }
 
     private updateContacts(neighborDescriptors: PeerDescriptor[]): void {
-        const ownNodeId = getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor)
+        const ownNodeId = toNodeId(this.options.localPeerDescriptor)
         const newPeerDescriptors = neighborDescriptors.filter((peerDescriptor) => {
-            const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+            const nodeId = toNodeId(peerDescriptor)
             return nodeId !== ownNodeId && !this.options.neighbors.getIds().includes(nodeId)
         })
         newPeerDescriptors.forEach((peerDescriptor) => this.options.nearbyNodeView.add(
@@ -54,7 +54,7 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
     // INeighborUpdateRpc server method
     async neighborUpdate(message: NeighborUpdate, context: ServerCallContext): Promise<NeighborUpdate> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const remoteNodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        const remoteNodeId = toNodeId(senderPeerDescriptor)
         this.updateContacts(message.neighborDescriptors)
         if (!this.options.neighbors.has(remoteNodeId) && !this.options.ongoingHandshakes.has(remoteNodeId)) {
             return this.createResponse(true)

package/src/logic/neighbor-discovery/NeighborUpdateRpcRemote.ts

@@ -1,7 +1,7 @@
-import { PeerDescriptor, RpcRemote, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { PeerDescriptor, RpcRemote, toNodeId } from '@streamr/dht'
 import { Logger, StreamPartID } from '@streamr/utils'
-import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { NeighborUpdate } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { NeighborUpdateRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
@@ -25,7 +25,7 @@ export class NeighborUpdateRpcRemote extends RpcRemote<NeighborUpdateRpcClient>
                 removeMe: response.removeMe
             }
         } catch (err: any) {
-            logger.debug(`updateNeighbors to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
+            logger.debug(`updateNeighbors to ${toNodeId(this.getPeerDescriptor())} failed`, { err })
             return {
                 peerDescriptors: [],
                 removeMe: true

package/src/logic/node-info/NodeInfoClient.ts

@@ -1,7 +1,7 @@
 import { DhtCallContext, PeerDescriptor } from '@streamr/dht'
 import { RpcCommunicator } from '@streamr/proto-rpc'
-import { NodeInfo } from '../../NetworkStack'
-import { NodeInfoRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { NodeInfo } from '../../types'
+import { NodeInfoRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeInfoRpcRemote } from './NodeInfoRpcRemote'
 
 export class NodeInfoClient {

package/src/logic/node-info/NodeInfoRpcLocal.ts

@@ -1,5 +1,5 @@
-import { NodeInfoRequest, NodeInfoResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { INodeInfoRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { NodeInfoRequest, NodeInfoResponse } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { INodeInfoRpc } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.server'
 import { NetworkStack } from '../../NetworkStack'
 import { ListeningRpcCommunicator } from '@streamr/dht'
 

package/src/logic/node-info/NodeInfoRpcRemote.ts

@@ -1,5 +1,5 @@
-import { NodeInfoResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { NodeInfoRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { NodeInfoResponse } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { NodeInfoRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 import { RpcRemote } from '@streamr/dht'
 
 export class NodeInfoRpcRemote extends RpcRemote<NodeInfoRpcClient> {

package/src/logic/propagation/Propagation.ts

@@ -1,5 +1,5 @@
 import { DhtAddress } from '@streamr/dht'
-import { StreamMessage } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { StreamMessage } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { PropagationTask, PropagationTaskStore } from './PropagationTaskStore'
 
 type SendToNeighborFn = (neighborId: DhtAddress, msg: StreamMessage) => Promise<void>
@@ -65,7 +65,6 @@ export class Propagation {
 
     private sendAndAwaitThenMark({ message, source, handledNeighbors }: PropagationTask, neighborId: DhtAddress): void {
         if (!handledNeighbors.has(neighborId) && neighborId !== source) {
-            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             (async () => {
                 try {
                     await this.sendToNeighbor(neighborId, message)

package/src/logic/propagation/PropagationTaskStore.ts

@@ -1,5 +1,5 @@
 import { DhtAddress } from '@streamr/dht'
-import { MessageRef, StreamMessage } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { MessageRef, StreamMessage } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { FifoMapWithTTL } from './FifoMapWithTTL'
 
 export interface PropagationTask {

package/src/logic/proxy/ProxyClient.ts

@@ -4,9 +4,9 @@ import {
     ITransport,
     ListeningRpcCommunicator,
     PeerDescriptor,
-    getNodeIdFromPeerDescriptor
+    toNodeId
 } from '@streamr/dht'
-import { EthereumAddress, Logger, StreamPartID, addManagedEventListener, wait } from '@streamr/utils'
+import { Logger, StreamPartID, UserID, addManagedEventListener, wait } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
 import {
@@ -15,8 +15,8 @@ import {
     MessageRef,
     ProxyDirection,
     StreamMessage
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient, ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+} from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { ContentDeliveryRpcClient, ProxyConnectionRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 import { ContentDeliveryRpcLocal } from '../ContentDeliveryRpcLocal'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { DuplicateMessageDetector } from '../DuplicateMessageDetector'
@@ -28,7 +28,6 @@ import { ProxyConnectionRpcRemote } from './ProxyConnectionRpcRemote'
 
 // TODO use options option or named constant?
 export const retry = async <T>(task: () => Promise<T>, description: string, abortSignal: AbortSignal, delay = 10000): Promise<T> => {
-    // eslint-disable-next-line no-constant-condition
     while (true) {
         try {
             const result = await task()
@@ -54,7 +53,7 @@ interface ProxyDefinition {
     nodes: Map<DhtAddress, PeerDescriptor>
     connectionCount: number
     direction: ProxyDirection
-    userId: EthereumAddress
+    userId: UserID
 }
 
 interface ProxyConnection {
@@ -87,7 +86,7 @@ export class ProxyClient extends EventEmitter<Events> {
         this.options = options
         this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartContentDeliveryServiceId(options.streamPartId), options.transport)
         // TODO use options option or named constant?
-        this.neighbors = new NodeList(getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor), 1000)
+        this.neighbors = new NodeList(toNodeId(this.options.localPeerDescriptor), 1000)
         this.contentDeliveryRpcLocal = new ContentDeliveryRpcLocal({
             localPeerDescriptor: this.options.localPeerDescriptor,
             streamPartId: this.options.streamPartId,
@@ -128,7 +127,7 @@ export class ProxyClient extends EventEmitter<Events> {
     async setProxies(
         nodes: PeerDescriptor[],
         direction: ProxyDirection,
-        userId: EthereumAddress,
+        userId: UserID,
         connectionCount?: number
     ): Promise<void> {
         logger.trace('Setting proxies', { streamPartId: this.options.streamPartId, peerDescriptors: nodes, direction, userId, connectionCount })
@@ -137,7 +136,7 @@ export class ProxyClient extends EventEmitter<Events> {
         }
         const nodesIds = new Map<DhtAddress, PeerDescriptor>()
         nodes.forEach((peerDescriptor) => {
-            nodesIds.set(getNodeIdFromPeerDescriptor(peerDescriptor), peerDescriptor)
+            nodesIds.set(toNodeId(peerDescriptor), peerDescriptor)
         })
         this.definition = {
             nodes: nodesIds,
@@ -176,7 +175,7 @@ export class ProxyClient extends EventEmitter<Events> {
         ))
     }
 
-    private async attemptConnection(nodeId: DhtAddress, direction: ProxyDirection, userId: EthereumAddress): Promise<void> {
+    private async attemptConnection(nodeId: DhtAddress, direction: ProxyDirection, userId: UserID): Promise<void> {
         const peerDescriptor = this.definition!.nodes.get(nodeId)!
         const rpcRemote = new ProxyConnectionRpcRemote(
             this.options.localPeerDescriptor,
@@ -225,7 +224,7 @@ export class ProxyClient extends EventEmitter<Events> {
     }
 
     private removeConnection(peerDescriptor: PeerDescriptor): void {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         this.connections.delete(nodeId)
         this.neighbors.remove(nodeId)
         this.options.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
@@ -248,7 +247,7 @@ export class ProxyClient extends EventEmitter<Events> {
     }
 
     private async onNodeDisconnected(peerDescriptor: PeerDescriptor): Promise<void> {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         if (this.connections.has(nodeId)) {
             this.options.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
             this.removeConnection(peerDescriptor)
@@ -267,6 +266,12 @@ export class ProxyClient extends EventEmitter<Events> {
         )
     }
 
+    public getDiagnosticInfo(): Record<string, unknown> {
+        return {
+            neighbors: this.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
+        }
+    }
+
     stop(): void {
         this.neighbors.getAll().forEach((remote) => {
             this.options.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -1,22 +1,22 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
-import { EthereumAddress, Logger, StreamPartID, binaryToHex, toEthereumAddress } from '@streamr/utils'
+import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, toNodeId } from '@streamr/dht'
+import { Logger, StreamPartID, toUserId, UserID } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import {
     ProxyConnectionRequest,
     ProxyConnectionResponse,
     ProxyDirection,
     StreamMessage
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { IProxyConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+} from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { ContentDeliveryRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
+import { IProxyConnectionRpc } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.server'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 
 const logger = new Logger(module)
 
 interface ProxyConnection {
     direction: ProxyDirection // Direction is from the client's point of view
-    userId: EthereumAddress
+    userId: UserID
     remote: ContentDeliveryRpcRemote
 }
 
@@ -64,7 +64,7 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
         if (msg.body.oneofKind === 'groupKeyRequest') {
             try {
                 const recipientId = msg.body.groupKeyRequest.recipientId
-                return this.getNodeIdsForUserId(toEthereumAddress(binaryToHex(recipientId, true)))
+                return this.getNodeIdsForUserId(toUserId(recipientId))
             } catch (err) {
                 logger.trace(`Could not parse GroupKeyRequest`, { err })
                 return []
@@ -74,7 +74,7 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
         }
     }
 
-    private getNodeIdsForUserId(userId: EthereumAddress): DhtAddress[] {
+    private getNodeIdsForUserId(userId: UserID): DhtAddress[] {
         return Array.from(this.connections.keys()).filter((nodeId) => this.connections.get(nodeId)!.userId === userId)
     }
 
@@ -85,10 +85,10 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
     // IProxyConnectionRpc server method
     async requestConnection(request: ProxyConnectionRequest, context: ServerCallContext): Promise<ProxyConnectionResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const remoteNodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        const remoteNodeId = toNodeId(senderPeerDescriptor)
         this.connections.set(remoteNodeId, {
             direction: request.direction,
-            userId: toEthereumAddress(binaryToHex(request.userId, true)),
+            userId: toUserId(request.userId),
             remote: new ContentDeliveryRpcRemote(
                 this.options.localPeerDescriptor,
                 senderPeerDescriptor,

package/src/logic/proxy/ProxyConnectionRpcRemote.ts

@@ -1,16 +1,16 @@
 import { EXISTING_CONNECTION_TIMEOUT, RpcRemote } from '@streamr/dht'
-import { EthereumAddress, Logger, hexToBinary } from '@streamr/utils'
-import { ProxyConnectionRequest, ProxyDirection } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { Logger, UserID, toUserIdRaw } from '@streamr/utils'
+import { ProxyConnectionRequest, ProxyDirection } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyConnectionRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
 export class ProxyConnectionRpcRemote extends RpcRemote<ProxyConnectionRpcClient> {
 
-    async requestConnection(direction: ProxyDirection, userId: EthereumAddress): Promise<boolean> {
+    async requestConnection(direction: ProxyDirection, userId: UserID): Promise<boolean> {
         const request: ProxyConnectionRequest = {
             direction,
-            userId: hexToBinary(userId)
+            userId: toUserIdRaw(userId)
         }
         const options = this.formDhtRpcOptions({
             timeout: EXISTING_CONNECTION_TIMEOUT

package/src/logic/temporary-connection/TemporaryConnectionRpcLocal.ts

@@ -1,15 +1,15 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, toNodeId } from '@streamr/dht'
 import { StreamPartID } from '@streamr/utils'
-import { Empty } from '../../proto/google/protobuf/empty'
-import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { Empty } from '../../../generated/google/protobuf/empty'
+import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
 import {
     CloseTemporaryConnection,
     TemporaryConnectionRequest,
     TemporaryConnectionResponse
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+} from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { ContentDeliveryRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
+import { ITemporaryConnectionRpc } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.server'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { NodeList } from '../NodeList'
 
@@ -30,7 +30,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
     constructor(options: TemporaryConnectionRpcLocalOptions) {
         this.options = options
         // TODO use options option or named constant?
-        this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(options.localPeerDescriptor), 10)
+        this.temporaryNodes = new NodeList(toNodeId(options.localPeerDescriptor), 10)
         this.lockId = LOCK_ID_BASE + options.streamPartId
     }
 
@@ -59,14 +59,14 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
             ContentDeliveryRpcClient
         )
         this.temporaryNodes.add(remote)
-        this.options.connectionLocker.weakLockConnection(getNodeIdFromPeerDescriptor(sender), this.lockId)
+        this.options.connectionLocker.weakLockConnection(toNodeId(sender), this.lockId)
         return {
             accepted: true
         }
     }
 
     async closeConnection(_request: CloseTemporaryConnection, context: ServerCallContext): Promise<Empty> {
-        const remoteNodeId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
+        const remoteNodeId = toNodeId((context as DhtCallContext).incomingSourceDescriptor!)
         this.removeNode(remoteNodeId)
         return {}
     }