@streamr/trackerless-network 101.1.1 → 102.0.0-beta.0

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 {
@@ -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,4 +1,4 @@
-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'
@@ -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,4 +1,4 @@
-import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, toNodeId } from '@streamr/dht'
 import { Logger, StreamPartID } from '@streamr/utils'
 import {
     InterleaveRequest,
@@ -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,4 +1,4 @@
-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'
@@ -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,5 +1,5 @@
 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'
@@ -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,4 +1,4 @@
-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'
@@ -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/propagation/Propagation.ts

@@ -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/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 {
@@ -54,7 +54,7 @@ interface ProxyDefinition {
     nodes: Map<DhtAddress, PeerDescriptor>
     connectionCount: number
     direction: ProxyDirection
-    userId: EthereumAddress
+    userId: UserID
 }
 
 interface ProxyConnection {
@@ -87,7 +87,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 +128,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 +137,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 +176,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 +225,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 +248,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 +267,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,6 +1,6 @@
 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, UserID, binaryToHex, toEthereumAddress } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import {
     ProxyConnectionRequest,
@@ -16,7 +16,7 @@ const logger = new Logger(module)
 
 interface ProxyConnection {
     direction: ProxyDirection // Direction is from the client's point of view
-    userId: EthereumAddress
+    userId: UserID
     remote: ContentDeliveryRpcRemote
 }
 
@@ -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,7 +85,7 @@ 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)),

package/src/logic/proxy/ProxyConnectionRpcRemote.ts

@@ -1,5 +1,5 @@
 import { EXISTING_CONNECTION_TIMEOUT, RpcRemote } from '@streamr/dht'
-import { EthereumAddress, Logger, hexToBinary } from '@streamr/utils'
+import { Logger, UserID, hexToBinary } from '@streamr/utils'
 import { ProxyConnectionRequest, ProxyDirection } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
@@ -7,7 +7,7 @@ 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)

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

@@ -1,5 +1,5 @@
 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'
@@ -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 {}
     }

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

@@ -1,4 +1,4 @@
-import { RpcRemote, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { RpcRemote, toNodeId } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
 import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
@@ -11,7 +11,7 @@ export class TemporaryConnectionRpcRemote extends RpcRemote<TemporaryConnectionR
             const response = await this.getClient().openConnection({}, this.formDhtRpcOptions())
             return response.accepted
         } catch (err: any) {
-            logger.debug(`temporaryConnection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
+            logger.debug(`temporaryConnection to ${toNodeId(this.getPeerDescriptor())} failed`, { err })
             return false
         }
     }
@@ -23,7 +23,7 @@ export class TemporaryConnectionRpcRemote extends RpcRemote<TemporaryConnectionR
                 notification: true
             }))
         } catch (err) {
-            logger.trace(`closeConnection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
+            logger.trace(`closeConnection to ${toNodeId(this.getPeerDescriptor())} failed`, { err })
         }
     }
 }

package/src/proto/google/protobuf/any.ts

@@ -73,6 +73,10 @@ import { MessageType } from "@protobuf-ts/runtime";
  *     if (any.is(Foo.class)) {
  *       foo = any.unpack(Foo.class);
  *     }
+ *     // or ...
+ *     if (any.isSameTypeAs(Foo.getDefaultInstance())) {
+ *       foo = any.unpack(Foo.getDefaultInstance());
+ *     }
  *
  *  Example 3: Pack and unpack a message in Python.
  *
@@ -87,10 +91,13 @@ import { MessageType } from "@protobuf-ts/runtime";
  *  Example 4: Pack and unpack a message in Go
  *
  *      foo := &pb.Foo{...}
- *      any, err := ptypes.MarshalAny(foo)
+ *      any, err := anypb.New(foo)
+ *      if err != nil {
+ *        ...
+ *      }
  *      ...
  *      foo := &pb.Foo{}
- *      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+ *      if err := any.UnmarshalTo(foo); err != nil {
  *        ...
  *      }
  *
@@ -100,7 +107,6 @@ import { MessageType } from "@protobuf-ts/runtime";
  * in the type URL, for example "foo.bar.com/x/y.z" will yield type
  * name "y.z".
  *
- *
  * JSON
  * ====
  * The JSON representation of an `Any` value uses the regular
@@ -157,7 +163,8 @@ export interface Any {
      *
      * Note: this functionality is not currently available in the official
      * protobuf release, and it is not used for type URLs beginning with
-     * type.googleapis.com.
+     * type.googleapis.com. As of May 2023, there are no widely used type server
+     * implementations and no plans to implement one.
      *
      * Schemes other than `http`, `https` (or the empty scheme) might be
      * used with implementation specific semantics.

package/src/proto/google/protobuf/empty.ts

@@ -49,7 +49,6 @@ import { MessageType } from "@protobuf-ts/runtime";
  *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
  *     }
  *
- * The JSON representation for `Empty` is empty JSON object `{}`.
  *
  * @generated from protobuf message google.protobuf.Empty
  */

package/src/proto/google/protobuf/timestamp.ts

@@ -97,8 +97,15 @@ import { MessageType } from "@protobuf-ts/runtime";
  *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
  *         .setNanos((int) ((millis % 1000) * 1000000)).build();
  *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
  *
- * Example 5: Compute Timestamp from current time in Python.
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
  *
  *     timestamp = Timestamp()
  *     timestamp.GetCurrentTime()
@@ -127,11 +134,10 @@ import { MessageType } from "@protobuf-ts/runtime";
  * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
  * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
  * the Joda Time's [`ISODateTimeFormat.dateTime()`](
- * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
  * ) to obtain a formatter capable of generating timestamps in this format.
  *
  *
- *
  * @generated from protobuf message google.protobuf.Timestamp
  */
 export interface Timestamp {

package/src/proto/packages/trackerless-network/protos/NetworkRpc.ts

@@ -316,9 +316,26 @@ export interface StreamPartitionInfo {
      */
     controlLayerNeighbors: PeerDescriptor[];
     /**
-     * @generated from protobuf field: repeated dht.PeerDescriptor contentDeliveryLayerNeighbors = 3;
+     * @generated from protobuf field: repeated dht.PeerDescriptor deprecatedContentDeliveryLayerNeighbors = 3;
      */
-    contentDeliveryLayerNeighbors: PeerDescriptor[];
+    deprecatedContentDeliveryLayerNeighbors: PeerDescriptor[];
+    /**
+     * @generated from protobuf field: repeated ContentDeliveryLayerNeighborInfo contentDeliveryLayerNeighbors = 4;
+     */
+    contentDeliveryLayerNeighbors: ContentDeliveryLayerNeighborInfo[];
+}
+/**
+ * @generated from protobuf message ContentDeliveryLayerNeighborInfo
+ */
+export interface ContentDeliveryLayerNeighborInfo {
+    /**
+     * @generated from protobuf field: dht.PeerDescriptor peerDescriptor = 1;
+     */
+    peerDescriptor?: PeerDescriptor;
+    /**
+     * @generated from protobuf field: optional int32 rtt = 2;
+     */
+    rtt?: number;
 }
 /**
  * @generated from protobuf message ControlLayerInfo
@@ -665,7 +682,8 @@ class StreamPartitionInfo$Type extends MessageType<StreamPartitionInfo> {
         super("StreamPartitionInfo", [
             { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "controlLayerNeighbors", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
-            { no: 3, name: "contentDeliveryLayerNeighbors", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor }
+            { no: 3, name: "deprecatedContentDeliveryLayerNeighbors", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
+            { no: 4, name: "contentDeliveryLayerNeighbors", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => ContentDeliveryLayerNeighborInfo }
         ]);
     }
 }
@@ -674,6 +692,19 @@ class StreamPartitionInfo$Type extends MessageType<StreamPartitionInfo> {
  */
 export const StreamPartitionInfo = new StreamPartitionInfo$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ContentDeliveryLayerNeighborInfo$Type extends MessageType<ContentDeliveryLayerNeighborInfo> {
+    constructor() {
+        super("ContentDeliveryLayerNeighborInfo", [
+            { no: 1, name: "peerDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 2, name: "rtt", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message ContentDeliveryLayerNeighborInfo
+ */
+export const ContentDeliveryLayerNeighborInfo = new ContentDeliveryLayerNeighborInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class ControlLayerInfo$Type extends MessageType<ControlLayerInfo> {
     constructor() {
         super("ControlLayerInfo", [