@streamr/trackerless-network 100.0.0-testnet-two.4 → 100.0.0-testnet-three.0

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

@@ -1,7 +1,6 @@
-import { ConnectionLocker, DhtAddress, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ConnectionLocker, DhtAddress, PeerDescriptor, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
-import { RpcCommunicator } from '@streamr/proto-rpc'
 import {
     DeliveryRpcClient, HandshakeRpcClient
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
@@ -21,10 +20,10 @@ interface HandshakerConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     connectionLocker: ConnectionLocker
-    targetNeighbors: NodeList
+    neighbors: NodeList
     nearbyNodeView: NodeList
     randomNodeView: NodeList
-    rpcCommunicator: RpcCommunicator
+    rpcCommunicator: ListeningRpcCommunicator
     maxNeighborCount: number
     rpcRequestTimeout?: number
 }
@@ -43,7 +42,7 @@ export class Handshaker {
         this.config = config
         this.rpcLocal = new HandshakeRpcLocal({
             streamPartId: this.config.streamPartId,
-            targetNeighbors: this.config.targetNeighbors,
+            neighbors: this.config.neighbors,
             connectionLocker: this.config.connectionLocker,
             ongoingHandshakes: this.ongoingHandshakes,
             ongoingInterleaves: new Set(),
@@ -60,10 +59,10 @@ export class Handshaker {
 
     async attemptHandshakesOnContacts(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         // TODO use config option or named constant? or why the value 2?
-        if (this.config.targetNeighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount - 2) {
+        if (this.config.neighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount - 2) {
             logger.trace(`Attempting parallel handshakes with ${PARALLEL_HANDSHAKE_COUNT} targets`)
             return this.selectParallelTargetsAndHandshake(excludedIds)
-        } else if (this.config.targetNeighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount) {
+        } else if (this.config.neighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount) {
             logger.trace(`Attempting handshake with new target`)
             return this.selectNewTargetAndHandshake(excludedIds)
         }
@@ -71,21 +70,21 @@ export class Handshaker {
     }
 
     private async selectParallelTargetsAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
-        const exclude = excludedIds.concat(this.config.targetNeighbors.getIds())
-        const targetNeighbors = this.selectParallelTargets(exclude)
-        targetNeighbors.forEach((contact) => this.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
-        return this.doParallelHandshakes(targetNeighbors, exclude)
+        const exclude = excludedIds.concat(this.config.neighbors.getIds())
+        const neighbors = this.selectParallelTargets(exclude)
+        neighbors.forEach((contact) => this.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
+        return this.doParallelHandshakes(neighbors, exclude)
     }
 
     private selectParallelTargets(excludedIds: DhtAddress[]): HandshakeRpcRemote[] {
-        const targetNeighbors = this.config.nearbyNodeView.getClosestAndFurthest(excludedIds)
-        while (targetNeighbors.length < PARALLEL_HANDSHAKE_COUNT && this.config.randomNodeView.size(excludedIds) > 0) {
+        const neighbors = this.config.nearbyNodeView.getFirstAndLast(excludedIds)
+        while (neighbors.length < PARALLEL_HANDSHAKE_COUNT && this.config.randomNodeView.size(excludedIds) > 0) {
             const random = this.config.randomNodeView.getRandom(excludedIds)
             if (random) {
-                targetNeighbors.push(random)
+                neighbors.push(random)
             }
         }
-        return targetNeighbors.map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
+        return neighbors.map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
     }
 
     private async doParallelHandshakes(targets: HandshakeRpcRemote[], excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
@@ -106,28 +105,28 @@ export class Handshaker {
     }
 
     private async selectNewTargetAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
-        const exclude = excludedIds.concat(this.config.targetNeighbors.getIds())
-        const targetNeighbor = this.config.nearbyNodeView.getClosest(exclude) ?? this.config.randomNodeView.getRandom(exclude)
-        if (targetNeighbor) {
-            const accepted = await this.handshakeWithTarget(this.createRpcRemote(targetNeighbor.getPeerDescriptor()))
+        const exclude = excludedIds.concat(this.config.neighbors.getIds())
+        const neighbor = this.config.nearbyNodeView.getFirst(exclude) ?? this.config.randomNodeView.getRandom(exclude)
+        if (neighbor) {
+            const accepted = await this.handshakeWithTarget(this.createRpcRemote(neighbor.getPeerDescriptor()))
             if (!accepted) {
-                excludedIds.push(getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor()))
+                excludedIds.push(getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor()))
             }
         }
         return excludedIds
     }
 
-    private async handshakeWithTarget(targetNeighbor: HandshakeRpcRemote, concurrentNodeId?: DhtAddress): Promise<boolean> {
-        const targetNodeId = getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
+    private async handshakeWithTarget(neighbor: HandshakeRpcRemote, concurrentNodeId?: DhtAddress): Promise<boolean> {
+        const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
         this.ongoingHandshakes.add(targetNodeId)
-        const result = await targetNeighbor.handshake(
+        const result = await neighbor.handshake(
             this.config.streamPartId,
-            this.config.targetNeighbors.getIds(),
+            this.config.neighbors.getIds(),
             concurrentNodeId
         )
         if (result.accepted) {
-            this.config.targetNeighbors.add(this.createDeliveryRpcRemote(targetNeighbor.getPeerDescriptor()))
-            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.streamPartId)
+            this.config.neighbors.add(this.createDeliveryRpcRemote(neighbor.getPeerDescriptor()))
+            this.config.connectionLocker.lockConnection(neighbor.getPeerDescriptor(), this.config.streamPartId)
         }
         if (result.interleaveTargetDescriptor) {
             await this.handshakeWithInterleaving(result.interleaveTargetDescriptor, targetNodeId)
@@ -137,18 +136,18 @@ export class Handshaker {
     }
 
     private async handshakeWithInterleaving(target: PeerDescriptor, interleaveSourceId: DhtAddress): Promise<boolean> {
-        const targetNeighbor = this.createRpcRemote(target)
-        const targetNodeId = getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
+        const neighbor = this.createRpcRemote(target)
+        const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
         this.ongoingHandshakes.add(targetNodeId)
-        const result = await targetNeighbor.handshake(
+        const result = await neighbor.handshake(
             this.config.streamPartId,
-            this.config.targetNeighbors.getIds(),
+            this.config.neighbors.getIds(),
             undefined,
             interleaveSourceId
         )
         if (result.accepted) {
-            this.config.targetNeighbors.add(this.createDeliveryRpcRemote(targetNeighbor.getPeerDescriptor()))
-            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.streamPartId)
+            this.config.neighbors.add(this.createDeliveryRpcRemote(neighbor.getPeerDescriptor()))
+            this.config.connectionLocker.lockConnection(neighbor.getPeerDescriptor(), this.config.streamPartId)
         }
         this.ongoingHandshakes.delete(targetNodeId)
         return result.accepted

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

@@ -3,7 +3,7 @@ import { NodeList } from '../NodeList'
 import { DhtAddress } from '@streamr/dht'
 
 interface FindNeighborsSessionConfig {
-    targetNeighbors: NodeList
+    neighbors: NodeList
     nearbyNodeView: NodeList
     doFindNeighbors: (excludedNodes: DhtAddress[]) => Promise<DhtAddress[]>
     minCount: number
@@ -27,7 +27,7 @@ export class NeighborFinder {
             return
         }
         const newExcludes = await this.config.doFindNeighbors(excluded)
-        if (this.config.targetNeighbors.size() < this.config.minCount && newExcludes.length < this.config.nearbyNodeView.size()) {
+        if (this.config.neighbors.size() < this.config.minCount && newExcludes.length < this.config.nearbyNodeView.size()) {
             // TODO should we catch possible promise rejection?
             setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL, this.abortController.signal)
         } else {

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

@@ -10,7 +10,7 @@ import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateManagerConfig {
     localPeerDescriptor: PeerDescriptor
-    targetNeighbors: NodeList
+    neighbors: NodeList
     nearbyNodeView: NodeList
     neighborFinder: NeighborFinder
     streamPartId: StreamPartID
@@ -44,12 +44,13 @@ export class NeighborUpdateManager {
 
     private async updateNeighborInfo(): Promise<void> {
         logger.trace(`Updating neighbor info to nodes`)
-        const neighborDescriptors = this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
-        await Promise.allSettled(this.config.targetNeighbors.getAll().map(async (neighbor) => {
+        const neighborDescriptors = this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
+        await Promise.allSettled(this.config.neighbors.getAll().map(async (neighbor) => {
             const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(this.config.streamPartId, neighborDescriptors)
             if (res.removeMe) {
-                this.config.targetNeighbors.remove(neighbor.getPeerDescriptor())
-                this.config.neighborFinder.start([getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())])
+                const nodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
+                this.config.neighbors.remove(nodeId)
+                this.config.neighborFinder.start([nodeId])
             }
         }))
     }

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

@@ -11,7 +11,7 @@ import { StreamPartID } from '@streamr/protocol'
 interface NeighborUpdateRpcLocalConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
-    targetNeighbors: NodeList
+    neighbors: NodeList
     nearbyNodeView: NodeList
     neighborFinder: NeighborFinder
     rpcCommunicator: ListeningRpcCommunicator
@@ -29,11 +29,11 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
     async neighborUpdate(message: NeighborUpdate, context: ServerCallContext): Promise<NeighborUpdate> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
-        if (this.config.targetNeighbors.hasNodeById(senderId)) {
+        if (this.config.neighbors.has(senderId)) {
             const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
             const newPeerDescriptors = message.neighborDescriptors.filter((peerDescriptor) => {
                 const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-                return nodeId !== ownNodeId && !this.config.targetNeighbors.getIds().includes(nodeId)
+                return nodeId !== ownNodeId && !this.config.neighbors.getIds().includes(nodeId)
             })
             newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
                 new DeliveryRpcRemote(
@@ -46,14 +46,14 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
             this.config.neighborFinder.start()
             const response: NeighborUpdate = {
                 streamPartId: this.config.streamPartId,
-                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
+                neighborDescriptors: this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
                 removeMe: false
             }
             return response
         } else {
             const response: NeighborUpdate = {
                 streamPartId: this.config.streamPartId,
-                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
+                neighborDescriptors: this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
                 removeMe: true
             }
             return response

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

@@ -0,0 +1,21 @@
+import { DhtCallContext, PeerDescriptor } from '@streamr/dht'
+import { NodeInfoResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { NodeInfoRpcRemote } from './NodeInfoRpcRemote'
+import { RpcCommunicator } from '@streamr/proto-rpc'
+import { NodeInfoRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+
+export class NodeInfoClient {
+    private readonly ownPeerDescriptor: PeerDescriptor
+    private readonly rpcCommunicator: RpcCommunicator<DhtCallContext>
+
+    constructor(ownPeerDescriptor: PeerDescriptor, rpcCommunicator: RpcCommunicator<DhtCallContext>) {
+        this.ownPeerDescriptor = ownPeerDescriptor
+        this.rpcCommunicator = rpcCommunicator
+    }
+
+    async getInfo(node: PeerDescriptor): Promise<NodeInfoResponse> {
+        const remote = new NodeInfoRpcRemote(this.ownPeerDescriptor, node, this.rpcCommunicator, NodeInfoRpcClient)
+        return remote.getInfo()
+    }
+
+}

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

@@ -0,0 +1,35 @@
+import { NodeInfoRequest, NodeInfoResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { INodeInfoRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { NetworkStack } from '../../NetworkStack'
+import { ListeningRpcCommunicator } from '@streamr/dht'
+
+export const NODE_INFO_RPC_SERVICE_ID = 'system/node-info-rpc'
+
+export class NodeInfoRpcLocal implements INodeInfoRpc {
+    
+    private readonly stack: NetworkStack
+    private readonly rpcCommunicator: ListeningRpcCommunicator
+ 
+    constructor(stack: NetworkStack, rpcCommunicator: ListeningRpcCommunicator) {
+        this.stack = stack
+        this.rpcCommunicator = rpcCommunicator
+        this.registerDefaultServerMethods()
+    }
+
+    private registerDefaultServerMethods(): void {
+        this.rpcCommunicator.registerRpcMethod(NodeInfoRequest, NodeInfoResponse, 'getInfo',
+            () => this.getInfo())
+    }
+ 
+    async getInfo(): Promise<NodeInfoResponse> {
+        return {
+            peerDescriptor: this.stack.getLayer0Node().getLocalPeerDescriptor(),
+            controlLayer: {
+                connections: this.stack.getLayer0Node().getConnections(),
+                neighbors: this.stack.getLayer0Node().getNeighbors()
+            },
+            streamPartitions: this.stack.getStreamrNode().getNodeInfo()
+        }
+    }
+
+}

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

@@ -0,0 +1,11 @@
+import { NodeInfoResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { NodeInfoRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { RpcRemote } from '@streamr/dht'
+
+export class NodeInfoRpcRemote extends RpcRemote<NodeInfoRpcClient> {
+
+    async getInfo(): Promise<NodeInfoResponse> {
+        return this.getClient().getInfo({}, this.formDhtRpcOptions())
+    }
+
+}

package/src/logic/protocol-integration/stream-message/GroupKeyRequestTranslator.ts

@@ -10,7 +10,7 @@ export class GroupKeyRequestTranslator {
             recipientId: hexToBinary(msg.recipient),
             requestId: msg.requestId,
             rsaPublicKey: utf8ToBinary(msg.rsaPublicKey),
-            groupKeyIds: msg.groupKeyIds
+            groupKeyIds: [...msg.groupKeyIds]
         }
         return translated
     }

package/src/logic/protocol-integration/stream-message/GroupKeyResponseTranslator.ts

@@ -10,7 +10,7 @@ export class GroupKeyResponseTranslator {
         const groupKeys = msg.encryptedGroupKeys.map((groupKey) => {
             return {
                 data: groupKey.data,
-                id: groupKey.groupKeyId
+                id: groupKey.id
             }
         })
         const translated: GroupKeyResponse = {

package/src/logic/protocol-integration/stream-message/StreamMessageTranslator.ts

@@ -4,11 +4,14 @@ import {
     StreamMessageType as OldStreamMessageType,
     MessageRef as OldMessageRef,
     EncryptedGroupKey as OldEncryptedGroupKey,
-    GroupKeyRequest as OldGroupKeyRequest,
-    GroupKeyResponse as OldGroupKeyResponse,
     StreamID,
     EncryptionType as OldEncryptionType,
-    ContentType as OldContentType
+    SignatureType as OldSignatureType,
+    ContentType as OldContentType,
+    serializeGroupKeyRequest as serializeOldGroupKeyRequest,
+    serializeGroupKeyResponse as serializeOldGroupKeyResponse,
+    deserializeGroupKeyRequest as deserializeOldGroupKeyRequest,
+    deserializeGroupKeyResponse as deserializeOldGroupKeyResponse
 } from '@streamr/protocol'
 import {
     ContentType,
@@ -17,11 +20,12 @@ import {
     GroupKeyRequest,
     GroupKeyResponse,
     MessageRef,
+    SignatureType,
     StreamMessage,
     StreamMessageType,
     MessageID
 } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { toEthereumAddress, binaryToHex, binaryToUtf8, hexToBinary, utf8ToBinary } from '@streamr/utils'
+import { toEthereumAddress, binaryToHex, hexToBinary } from '@streamr/utils'
 import { GroupKeyRequestTranslator } from './GroupKeyRequestTranslator'
 import { GroupKeyResponseTranslator } from './GroupKeyResponseTranslator'
 
@@ -39,6 +43,35 @@ const newToOldEncryptionType = (type: EncryptionType): OldEncryptionType => {
     return OldEncryptionType.NONE
 }
 
+const oldToNewContentType = (type: OldContentType): ContentType => {
+    if (type === OldContentType.JSON) {
+        return ContentType.JSON
+    }
+    return ContentType.BINARY
+}
+
+const newToOldContentType = (type: ContentType): OldContentType => {
+    if (type === ContentType.JSON) {
+        return OldContentType.JSON
+    }
+    return OldContentType.BINARY
+}
+
+const oldToNewSignatureType = (type: OldSignatureType): SignatureType => {
+    if (type === OldSignatureType.LEGACY_SECP256K1) {
+        return SignatureType.LEGACY_SECP256K1
+    }
+    return SignatureType.SECP256K1
+}
+
+const newToOldSignatureType = (type: SignatureType): OldSignatureType => {
+    if (type === SignatureType.LEGACY_SECP256K1) {
+        return OldSignatureType.LEGACY_SECP256K1
+    }
+    return OldSignatureType.SECP256K1
+
+}
+
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export class StreamMessageTranslator {
 
@@ -46,24 +79,16 @@ export class StreamMessageTranslator {
         let content: Uint8Array
         let messageType: StreamMessageType
         if (msg.messageType === OldStreamMessageType.MESSAGE) {
-            content = msg.serializedContent
+            content = msg.content
             messageType = StreamMessageType.MESSAGE
         } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_REQUEST) {
             content = GroupKeyRequest.toBinary(
-                GroupKeyRequestTranslator.toProtobuf(
-                    OldGroupKeyRequest.deserialize(
-                        binaryToUtf8(msg.serializedContent),
-                        OldStreamMessageType.GROUP_KEY_REQUEST) as OldGroupKeyRequest
-                )
+                GroupKeyRequestTranslator.toProtobuf(deserializeOldGroupKeyRequest(msg.content))
             )
             messageType = StreamMessageType.GROUP_KEY_REQUEST
         } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_RESPONSE) {
             content = GroupKeyResponse.toBinary(
-                GroupKeyResponseTranslator.toProtobuf(
-                    OldGroupKeyResponse.deserialize(
-                        binaryToUtf8(msg.serializedContent),
-                        OldStreamMessageType.GROUP_KEY_RESPONSE) as OldGroupKeyResponse
-                )
+                GroupKeyResponseTranslator.toProtobuf(deserializeOldGroupKeyResponse(msg.content))
             )
             messageType = StreamMessageType.GROUP_KEY_RESPONSE
         } else {
@@ -78,17 +103,17 @@ export class StreamMessageTranslator {
             messageChainId: msg.getMsgChainId()
         }
         let previousMessageRef: MessageRef | undefined = undefined
-        if (msg.getPreviousMessageRef()) {
+        if (msg.prevMsgRef) {
             previousMessageRef = {
-                timestamp: msg.getPreviousMessageRef()!.timestamp,
-                sequenceNumber: msg.getPreviousMessageRef()!.sequenceNumber,
+                timestamp: msg.prevMsgRef.timestamp,
+                sequenceNumber: msg.prevMsgRef.sequenceNumber,
             }
         }
         let newGroupKey: GroupKey | undefined = undefined
-        if (msg.getNewGroupKey()) {
+        if (msg.newGroupKey) {
             newGroupKey = {
-                id: msg.getNewGroupKey()!.groupKeyId,
-                data: msg.getNewGroupKey()!.data
+                id: msg.newGroupKey.id,
+                data: msg.newGroupKey.data
             }
         }
         const translated: StreamMessage = {
@@ -96,11 +121,12 @@ export class StreamMessageTranslator {
             previousMessageRef,
             content,
             messageType,
-            contentType: ContentType.JSON,
+            contentType: oldToNewContentType(msg.contentType),
             encryptionType: oldToNewEncryptionType(msg.encryptionType),
             groupKeyId: msg.groupKeyId ?? undefined,
             newGroupKey,
-            signature: msg.signature
+            signature: msg.signature,
+            signatureType: oldToNewSignatureType(msg.signatureType),
         }
         return translated
     }
@@ -115,7 +141,8 @@ export class StreamMessageTranslator {
             messageType = OldStreamMessageType.GROUP_KEY_REQUEST
             try {
                 const parsedRequest = GroupKeyRequest.fromBinary(msg.content)
-                content = utf8ToBinary(GroupKeyRequestTranslator.toClientProtocol(parsedRequest).serialize())
+                const oldGroupKeyRequest = GroupKeyRequestTranslator.toClientProtocol(parsedRequest)
+                content = serializeOldGroupKeyRequest(oldGroupKeyRequest)
             } catch (err) {
                 throw new Error(`invalid group key request: ${err}`)
             }
@@ -123,7 +150,8 @@ export class StreamMessageTranslator {
             messageType = OldStreamMessageType.GROUP_KEY_RESPONSE
             try {
                 const parsedResponse = GroupKeyResponse.fromBinary(msg.content)
-                content = utf8ToBinary(GroupKeyResponseTranslator.toClientProtocol(parsedResponse).serialize())
+                const oldGroupKeyResponse = GroupKeyResponseTranslator.toClientProtocol(parsedResponse)
+                content = serializeOldGroupKeyResponse(oldGroupKeyResponse)
             } catch (err) {
                 throw new Error(`invalid group key response: ${err}`)
             }
@@ -154,11 +182,12 @@ export class StreamMessageTranslator {
             prevMsgRef,
             content,
             messageType,
-            contentType: OldContentType.JSON,
+            contentType: newToOldContentType(msg.contentType),
             encryptionType: newToOldEncryptionType(msg.encryptionType),
             groupKeyId: msg.groupKeyId,
             newGroupKey,
-            signature: msg.signature
+            signature: msg.signature,
+            signatureType: newToOldSignatureType(msg.signatureType)
         })
         return translated
     }

package/src/logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils.ts

@@ -0,0 +1,11 @@
+import { StreamMessage as OldStreamMessage } from '@streamr/protocol'
+import { StreamMessageTranslator } from './StreamMessageTranslator'
+import { StreamMessage } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+
+export function convertStreamMessageToBytes(oldStreamMessage: OldStreamMessage): Uint8Array {
+    return StreamMessage.toBinary(StreamMessageTranslator.toProtobuf(oldStreamMessage))
+}
+
+export function convertBytesToStreamMessage(bytes: Uint8Array): OldStreamMessage {
+    return StreamMessageTranslator.toClientProtocol(StreamMessage.fromBinary(bytes))
+}

package/src/logic/proxy/ProxyClient.ts

@@ -75,7 +75,7 @@ export class ProxyClient extends EventEmitter<Events> {
     private definition?: ProxyDefinition
     private readonly connections: Map<DhtAddress, ProxyDirection> = new Map()
     private readonly propagation: Propagation
-    private readonly targetNeighbors: NodeList
+    private readonly neighbors: NodeList
     private readonly abortController: AbortController
 
     constructor(config: ProxyClientConfig) {
@@ -83,14 +83,14 @@ export class ProxyClient extends EventEmitter<Events> {
         this.config = config
         this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(config.streamPartId), config.transport)
         // TODO use config option or named constant?
-        this.targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), 1000)
+        this.neighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), 1000)
         this.deliveryRpcLocal = new DeliveryRpcLocal({
             localPeerDescriptor: this.config.localPeerDescriptor,
             streamPartId: this.config.streamPartId,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
             broadcast: (message: StreamMessage, previousNode?: DhtAddress) => this.broadcast(message, previousNode),
             onLeaveNotice: (senderId: DhtAddress) => {
-                const contact = this.targetNeighbors.get(senderId)
+                const contact = this.neighbors.get(senderId)
                 if (contact) {
                     // TODO should we catch possible promise rejection?
                     setImmediate(() => this.onNodeDisconnected(contact.getPeerDescriptor()))
@@ -103,7 +103,7 @@ export class ProxyClient extends EventEmitter<Events> {
             // TODO use config option or named constant?
             minPropagationTargets: config.minPropagationTargets ?? 2,
             sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
-                const remote = this.targetNeighbors.get(neighborId)
+                const remote = this.neighbors.get(neighborId)
                 if (remote) {
                     await remote.sendStreamMessage(msg)
                 } else {
@@ -190,7 +190,7 @@ export class ProxyClient extends EventEmitter<Events> {
                 this.rpcCommunicator,
                 DeliveryRpcClient
             )
-            this.targetNeighbors.add(remote)
+            this.neighbors.add(remote)
             this.propagation.onNeighborJoined(nodeId)
             logger.info('Open proxy connection', {
                 nodeId,
@@ -214,7 +214,7 @@ export class ProxyClient extends EventEmitter<Events> {
             logger.info('Close proxy connection', {
                 nodeId
             })
-            const server = this.targetNeighbors.get(nodeId)
+            const server = this.neighbors.get(nodeId)
             server?.leaveStreamPartNotice(this.config.streamPartId, false)
             this.removeConnection(nodeId)
         }
@@ -222,7 +222,7 @@ export class ProxyClient extends EventEmitter<Events> {
 
     private removeConnection(nodeId: DhtAddress): void {
         this.connections.delete(nodeId)
-        this.targetNeighbors.removeById(nodeId)
+        this.neighbors.remove(nodeId)
     }
 
     broadcast(msg: StreamMessage, previousNode?: DhtAddress): void {
@@ -230,7 +230,7 @@ export class ProxyClient extends EventEmitter<Events> {
             markAndCheckDuplicate(this.duplicateDetectors, msg.messageId!, msg.previousMessageRef)
         }
         this.emit('message', msg)
-        this.propagation.feedUnseenMessage(msg, this.targetNeighbors.getIds(), previousNode ?? null)
+        this.propagation.feedUnseenMessage(msg, this.neighbors.getIds(), previousNode ?? null)
     }
 
     hasConnection(nodeId: DhtAddress, direction: ProxyDirection): boolean {
@@ -262,11 +262,11 @@ export class ProxyClient extends EventEmitter<Events> {
     }
 
     stop(): void {
-        this.targetNeighbors.getAll().forEach((remote) => {
+        this.neighbors.getAll().forEach((remote) => {
             this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)
             remote.leaveStreamPartNotice(this.config.streamPartId, false)
         })
-        this.targetNeighbors.stop()
+        this.neighbors.stop()
         this.rpcCommunicator.destroy()
         this.connections.clear()
         this.abortController.abort()

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

@@ -1,7 +1,7 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { TemporaryConnectionRequest, TemporaryConnectionResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
@@ -27,8 +27,8 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
         return this.temporaryNodes
     }
 
-    removeNode(peerDescriptor: PeerDescriptor): void {
-        this.temporaryNodes.remove(peerDescriptor)
+    removeNode(nodeId: DhtAddress): void {
+        this.temporaryNodes.remove(nodeId)
     }
 
     async openConnection(

package/src/proto/packages/dht/protos/DhtRpc.client.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/dht/protos/DhtRpc.proto" (package "dht", syntax proto3)
 // tslint:disable
 import { ExternalApiRpc } from "./DhtRpc";
@@ -7,7 +7,6 @@ import type { ExternalStoreDataRequest } from "./DhtRpc";
 import type { ExternalFindDataResponse } from "./DhtRpc";
 import type { ExternalFindDataRequest } from "./DhtRpc";
 import { ConnectionLockRpc } from "./DhtRpc";
-import type { DisconnectNoticeResponse } from "./DhtRpc";
 import type { DisconnectNotice } from "./DhtRpc";
 import type { UnlockRequest } from "./DhtRpc";
 import type { LockResponse } from "./DhtRpc";
@@ -313,9 +312,9 @@ export interface IConnectionLockRpcClient {
      */
     unlockRequest(input: UnlockRequest, options?: RpcOptions): UnaryCall<UnlockRequest, Empty>;
     /**
-     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (dht.DisconnectNoticeResponse);
+     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (google.protobuf.Empty);
      */
-    gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, DisconnectNoticeResponse>;
+    gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, Empty>;
 }
 /**
  * @generated from protobuf service dht.ConnectionLockRpc
@@ -341,11 +340,11 @@ export class ConnectionLockRpcClient implements IConnectionLockRpcClient, Servic
         return stackIntercept<UnlockRequest, Empty>("unary", this._transport, method, opt, input);
     }
     /**
-     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (dht.DisconnectNoticeResponse);
+     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (google.protobuf.Empty);
      */
-    gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, DisconnectNoticeResponse> {
+    gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, Empty> {
         const method = this.methods[2], opt = this._transport.mergeOptions(options);
-        return stackIntercept<DisconnectNotice, DisconnectNoticeResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<DisconnectNotice, Empty>("unary", this._transport, method, opt, input);
     }
 }
 /**