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

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

@@ -10,12 +10,13 @@ import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateManagerConfig {
     localPeerDescriptor: PeerDescriptor
-    targetNeighbors: NodeList
+    neighbors: NodeList
     nearbyNodeView: NodeList
     neighborFinder: NeighborFinder
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
     neighborUpdateInterval: number
+    neighborCount: number
 }
 
 const logger = new Logger(module)
@@ -44,12 +45,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,10 +11,11 @@ import { StreamPartID } from '@streamr/protocol'
 interface NeighborUpdateRpcLocalConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
-    targetNeighbors: NodeList
+    neighbors: NodeList
     nearbyNodeView: NodeList
     neighborFinder: NeighborFinder
     rpcCommunicator: ListeningRpcCommunicator
+    neighborCount: number
 }
 
 export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
@@ -25,38 +26,49 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
         this.config = config
     }
 
+    private updateContacts(neighborDescriptors: PeerDescriptor[]): void {
+        const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        const newPeerDescriptors = neighborDescriptors.filter((peerDescriptor) => {
+            const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+            return nodeId !== ownNodeId && !this.config.neighbors.getIds().includes(nodeId)
+        })
+        newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
+            new DeliveryRpcRemote(
+                this.config.localPeerDescriptor,
+                peerDescriptor,
+                this.config.rpcCommunicator,
+                DeliveryRpcClient
+            ))
+        )
+    }
+
+    private createResponse(removeMe: boolean): NeighborUpdate {
+        return {
+            streamPartId: this.config.streamPartId,
+            neighborDescriptors: this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
+            removeMe
+        }
+    }
+
     // INeighborUpdateRpc server method
     async neighborUpdate(message: NeighborUpdate, context: ServerCallContext): Promise<NeighborUpdate> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
-        if (this.config.targetNeighbors.hasNodeById(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)
-            })
-            newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
-                new DeliveryRpcRemote(
-                    this.config.localPeerDescriptor,
-                    peerDescriptor,
-                    this.config.rpcCommunicator,
-                    DeliveryRpcClient
-                ))
-            )
-            this.config.neighborFinder.start()
-            const response: NeighborUpdate = {
-                streamPartId: this.config.streamPartId,
-                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
-                removeMe: false
-            }
-            return response
+        this.updateContacts(message.neighborDescriptors)
+        if (!this.config.neighbors.has(senderId)) {
+            return this.createResponse(true)
         } else {
-            const response: NeighborUpdate = {
-                streamPartId: this.config.streamPartId,
-                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
-                removeMe: true
+            const isOverNeighborCount = this.config.neighbors.size() > this.config.neighborCount
+                // Motivation: We don't know the remote's neighborCount setting here. We only ask to cut connections
+                // if the remote has a "sufficient" number of neighbors, where "sufficient" means our neighborCount
+                // setting.
+                && message.neighborDescriptors.length > this.config.neighborCount
+            if (!isOverNeighborCount) {
+                this.config.neighborFinder.start()
+            } else {
+                this.config.neighbors.remove(senderId)
             }
-            return response
+            return this.createResponse(isOverNeighborCount)
         }
     }
 }

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,11 +1,16 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { TemporaryConnectionRequest, TemporaryConnectionResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { 
+    CloseTemporaryConnection,
+    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'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { Empty } from '../../proto/google/protobuf/empty'
 
 interface TemporaryConnectionRpcLocalConfig {
     rpcCommunicator: ListeningRpcCommunicator
@@ -27,8 +32,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(
@@ -47,4 +52,10 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
             accepted: true
         }
     }
+
+    async closeConnection(_request: CloseTemporaryConnection, context: ServerCallContext): Promise<Empty> {
+        const senderId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
+        this.removeNode(senderId)
+        return {}
+    }
 }

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

@@ -15,4 +15,15 @@ export class TemporaryConnectionRpcRemote extends RpcRemote<TemporaryConnectionR
             return false
         }
     }
+
+    async closeConnection(): Promise<void> {
+        try {
+            await this.getClient().closeConnection({}, this.formDhtRpcOptions({
+                connect: false,
+                notification: true
+            }))
+        } catch (err) {
+            logger.trace(`closeConnection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+        }
+    }
 }

package/src/proto/google/protobuf/any.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 "google/protobuf/any.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -39,7 +39,6 @@ import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { isJsonObject } from "@protobuf-ts/runtime";
 import { typeofJsonValue } from "@protobuf-ts/runtime";
 import type { JsonValue } from "@protobuf-ts/runtime";
@@ -272,8 +271,9 @@ class Any$Type extends MessageType<Any> {
         return name;
     }
     create(value?: PartialMessage<Any>): Any {
-        const message = { typeUrl: "", value: new Uint8Array(0) };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.typeUrl = "";
+        message.value = new Uint8Array(0);
         if (value !== undefined)
             reflectionMergePartial<Any>(this, message, value);
         return message;

package/src/proto/google/protobuf/empty.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 "google/protobuf/empty.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -39,7 +39,6 @@ import type { BinaryReadOptions } from "@protobuf-ts/runtime";
 import type { IBinaryReader } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
 /**
  * A generic empty message that you can re-use to avoid defining duplicated
@@ -62,8 +61,7 @@ class Empty$Type extends MessageType<Empty> {
         super("google.protobuf.Empty", []);
     }
     create(value?: PartialMessage<Empty>): Empty {
-        const message = {};
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
         if (value !== undefined)
             reflectionMergePartial<Empty>(this, message, value);
         return message;

package/src/proto/google/protobuf/timestamp.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 "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -40,7 +40,6 @@ import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { typeofJsonValue } from "@protobuf-ts/runtime";
 import type { JsonValue } from "@protobuf-ts/runtime";
 import type { JsonReadOptions } from "@protobuf-ts/runtime";
@@ -234,8 +233,9 @@ class Timestamp$Type extends MessageType<Timestamp> {
         return target;
     }
     create(value?: PartialMessage<Timestamp>): Timestamp {
-        const message = { seconds: 0, nanos: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.seconds = 0;
+        message.nanos = 0;
         if (value !== undefined)
             reflectionMergePartial<Timestamp>(this, message, value);
         return message;

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);
     }
 }
 /**