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

package/src/dht/routing/RoutingSession.ts

@@ -1,6 +1,5 @@
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { SortedContactList } from '../contact/SortedContactList'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
@@ -12,7 +11,8 @@ import { Contact } from '../contact/Contact'
 import { RecursiveOperationRpcRemote } from '../recursive-operation/RecursiveOperationRpcRemote'
 import { EXISTING_CONNECTION_TIMEOUT } from '../contact/RpcRemote'
 import { getPreviousPeer } from './getPreviousPeer'
-import { DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { pull } from 'lodash'
 
 const logger = new Logger(module)
 
@@ -106,6 +106,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         if (this.ongoingRequests.has(nodeId)) {
             this.ongoingRequests.delete(nodeId)
         }
+        this.deleteParallelRootIfSource(nodeId)
         const contacts = this.updateAndGetRoutablePeers()
         if (contacts.length === 0 && this.ongoingRequests.size === 0) {
             logger.trace('routing failed, emitting routingFailed sessionId: ' + this.sessionId)
@@ -194,6 +195,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             logger.trace(`Sending routeMessage request to contact: ${getNodeIdFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
             this.contactList.setContacted(nextPeer!.getNodeId())
             this.ongoingRequests.add(nextPeer!.getNodeId())
+            this.addParallelRootIfSource(nextPeer!.getNodeId())
             setImmediate(async () => {
                 try {
                     const succeeded = await this.sendRouteMessageRequest(nextPeer!)
@@ -211,6 +213,24 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
     }
 
+    private addParallelRootIfSource(nodeId: DhtAddress) {
+        if (
+            this.config.mode === RoutingMode.RECURSIVE
+            && areEqualPeerDescriptors(this.config.localPeerDescriptor, this.config.routedMessage.sourcePeer!)
+        ) {
+            this.config.routedMessage.parallelRootNodeIds.push(nodeId)
+        }
+    }
+
+    private deleteParallelRootIfSource(nodeId: DhtAddress) {
+        if (
+            this.config.mode === RoutingMode.RECURSIVE
+            && areEqualPeerDescriptors(this.config.localPeerDescriptor, this.config.routedMessage.sourcePeer!)
+        ) {
+            pull(this.config.routedMessage.parallelRootNodeIds, nodeId)
+        }
+    }
+
     public stop(): void {
         this.stopped = true
         this.contactList.stop()

package/src/dht/store/StoreManager.ts

@@ -6,7 +6,6 @@ import { Any } from '../../proto/google/protobuf/any'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { RecursiveOperationManager } from '../recursive-operation/RecursiveOperationManager'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger, executeSafePromise } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
 import { StoreRpcRemote } from './StoreRpcRemote'
@@ -15,7 +14,7 @@ import { SortedContactList } from '../contact/SortedContactList'
 import { Contact } from '../contact/Contact'
 import { ServiceID } from '../../types/ServiceID'
 import { findIndex } from 'lodash'
-import { DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 import { StoreRpcLocal } from './StoreRpcLocal'
 import { getDistance } from '../PeerManager'
 

package/src/dht/store/StoreRpcRemote.ts

@@ -1,4 +1,4 @@
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import {
     ReplicateDataRequest,
     StoreDataRequest

package/src/exports.ts

@@ -11,13 +11,18 @@ export { LockID } from './connection/ConnectionLockHandler'
 export { DefaultConnectorFacade } from './connection/ConnectorFacade'
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
 export { RpcRemote, EXISTING_CONNECTION_TIMEOUT } from './dht/contact/RpcRemote'
-export { areEqualPeerDescriptors } from './helpers/peerIdFromPeerDescriptor'
 export { IceServer } from './connection/webrtc/WebrtcConnector'
 export { DhtCallContext } from './rpc-protocol/DhtCallContext'
 export { ClientWebsocket } from './connection/websocket/ClientWebsocket'
 export { ManagedConnection } from './connection/ManagedConnection'
 export { ConnectionType } from './connection/IConnection'
-export { PeerID } from './helpers/PeerID'
 export { ServiceID } from './types/ServiceID'
-export { DhtAddress, DhtAddressRaw, getDhtAddressFromRaw, getRawFromDhtAddress } from './identifiers'
-export { getNodeIdFromPeerDescriptor } from './helpers/peerIdFromPeerDescriptor'
+export { 
+    DhtAddress,
+    DhtAddressRaw,
+    getDhtAddressFromRaw,
+    getRawFromDhtAddress,
+    createRandomDhtAddress,
+    areEqualPeerDescriptors,
+    getNodeIdFromPeerDescriptor
+} from './identifiers'

package/src/helpers/createPeerDescriptor.ts

@@ -0,0 +1,56 @@
+import {
+    createSignature,
+    hash
+} from '@streamr/utils'
+import crypto from 'crypto'
+import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
+import { createPeerDescriptorSignaturePayload } from '../helpers/createPeerDescriptorSignaturePayload'
+import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../identifiers'
+import {
+    ConnectivityResponse,
+    NodeType,
+    PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+
+const calculateNodeIdRaw = (ipAddress: number, privateKey: Uint8Array): DhtAddressRaw => {
+    // nodeId is calculated as 
+    // concatenate(
+    //   get104leastSignificatBits(hash(ipAddress)), 
+    //   get56leastSignificatBits(sign(ipAddress))
+    // )
+    const ipAsBuffer = Buffer.alloc(4)
+    ipAsBuffer.writeUInt32BE(ipAddress)
+    const ipHash = hash(ipAsBuffer)
+    const signature = createSignature(ipAsBuffer, privateKey)
+    const nodeIdRaw = Buffer.concat([
+        ipHash.subarray(ipHash.length - 13, ipHash.length),
+        signature.subarray(signature.length - 7, signature.length)
+    ])
+    return nodeIdRaw
+}
+
+export const createPeerDescriptor = (connectivityResponse: ConnectivityResponse, nodeId?: DhtAddress): PeerDescriptor => {
+    const privateKey = crypto.randomBytes(32)
+    const publicKey = crypto.randomBytes(20)  // TODO calculate publicKey from privateKey
+    let nodeIdRaw: DhtAddressRaw
+    if (nodeId !== undefined) {
+        nodeIdRaw = getRawFromDhtAddress(nodeId)
+    } else {
+        nodeIdRaw = calculateNodeIdRaw(connectivityResponse.ipAddress, privateKey)
+    }
+    const ret: PeerDescriptor = {
+        nodeId: nodeIdRaw,
+        type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
+        ipAddress: connectivityResponse.ipAddress,
+        publicKey 
+    }
+    if (connectivityResponse.websocket) {
+        ret.websocket = {
+            host: connectivityResponse.websocket.host,
+            port: connectivityResponse.websocket.port,
+            tls: connectivityResponse.websocket.tls
+        }
+    }
+    ret.signature = createSignature(createPeerDescriptorSignaturePayload(ret), privateKey)
+    return ret
+}

package/src/helpers/createPeerDescriptorSignaturePayload.ts

@@ -0,0 +1,28 @@
+import { ConnectivityMethod, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+
+function convertUnsignedIntegerToBuffer(number: number): Buffer {
+    const buffer = Buffer.alloc(4)
+    buffer.writeUInt32BE(number)
+    return buffer
+}
+
+export const createPeerDescriptorSignaturePayload = (peerDescriptor: PeerDescriptor): Uint8Array => {
+    const separator = Buffer.from(',')
+    const buffers = [
+        peerDescriptor.type !== undefined ? convertUnsignedIntegerToBuffer(peerDescriptor.type) : new Uint8Array(0),
+        separator,
+        peerDescriptor.udp !== undefined ? ConnectivityMethod.toBinary(peerDescriptor.udp) : new Uint8Array(0),
+        separator,
+        peerDescriptor.tcp !== undefined ? ConnectivityMethod.toBinary(peerDescriptor.tcp) : new Uint8Array(0),
+        separator,
+        peerDescriptor.websocket !== undefined ? ConnectivityMethod.toBinary(peerDescriptor.websocket) : new Uint8Array(0),
+        separator,
+        peerDescriptor.region !== undefined ? convertUnsignedIntegerToBuffer(peerDescriptor.region) : new Uint8Array(0),
+        separator,
+        peerDescriptor.ipAddress !== undefined ? convertUnsignedIntegerToBuffer(peerDescriptor.ipAddress) : new Uint8Array(0),
+        separator,
+        peerDescriptor.publicKey !== undefined ? Buffer.from(peerDescriptor.publicKey) : new Uint8Array(0)
+    ]
+    return Buffer.concat(buffers)
+}
+

package/src/helpers/offering.ts

@@ -0,0 +1,15 @@
+import crypto from 'crypto'
+import { DhtAddress } from '../identifiers'
+
+type Offerer = 'local' | 'remote'
+
+export const getOfferer = (localNodeId: DhtAddress, remoteNodeId: DhtAddress): Offerer => {
+    return getOfferingHash(localNodeId + ',' + remoteNodeId) < getOfferingHash(remoteNodeId + ',' + localNodeId)
+        ? 'local'
+        : 'remote'
+}
+
+const getOfferingHash = (idPair: string): number => {
+    const buffer = crypto.createHash('md5').update(idPair).digest()
+    return buffer.readInt32LE(0)
+}

package/src/identifiers.ts

@@ -1,5 +1,6 @@
-import { BrandedString, binaryToHex, hexToBinary } from '@streamr/utils'
+import { BrandedString, areEqualBinaries, binaryToHex, hexToBinary } from '@streamr/utils'
 import crypto from 'crypto'
+import { PeerDescriptor } from './proto/packages/dht/protos/DhtRpc'
 
 // https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
 const KADEMLIA_ID_LENGTH_IN_BYTES = 20
@@ -15,6 +16,14 @@ export const getRawFromDhtAddress = (address: DhtAddress): DhtAddressRaw => {
     return hexToBinary(address) as unknown as DhtAddressRaw
 }
 
+export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): DhtAddress => {
+    return getDhtAddressFromRaw(peerDescriptor.nodeId)
+}
+
+export const areEqualPeerDescriptors = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
+    return areEqualBinaries(peerDescriptor1.nodeId, peerDescriptor2.nodeId)
+}
+
 export const createRandomDhtAddress = (): DhtAddress => {
     return getDhtAddressFromRaw(crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES))
 }

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

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

@@ -1,11 +1,10 @@
-// @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 { ExternalStoreDataResponse } from "./DhtRpc";
 import { ExternalStoreDataRequest } from "./DhtRpc";
 import { ExternalFindDataResponse } from "./DhtRpc";
 import { ExternalFindDataRequest } from "./DhtRpc";
-import { DisconnectNoticeResponse } from "./DhtRpc";
 import { DisconnectNotice } from "./DhtRpc";
 import { UnlockRequest } from "./DhtRpc";
 import { LockResponse } from "./DhtRpc";
@@ -132,9 +131,9 @@ export interface IConnectionLockRpc<T = ServerCallContext> {
      */
     unlockRequest(request: UnlockRequest, context: T): Promise<Empty>;
     /**
-     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (dht.DisconnectNoticeResponse);
+     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (google.protobuf.Empty);
      */
-    gracefulDisconnect(request: DisconnectNotice, context: T): Promise<DisconnectNoticeResponse>;
+    gracefulDisconnect(request: DisconnectNotice, context: T): Promise<Empty>;
 }
 /**
  * @generated from protobuf service dht.ExternalApiRpc

package/src/proto/packages/dht/protos/DhtRpc.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 { Empty } from "../../../google/protobuf/empty";
@@ -218,6 +218,20 @@ export interface PeerDescriptor {
      * @generated from protobuf field: optional uint32 region = 6;
      */
     region?: number;
+    /**
+     * @generated from protobuf field: optional uint32 ipAddress = 7;
+     */
+    ipAddress?: number;
+    /**
+     * @generated from protobuf field: optional bytes publicKey = 8;
+     */
+    publicKey?: Uint8Array;
+    /**
+     * signature of fields 2-8
+     *
+     * @generated from protobuf field: optional bytes signature = 9;
+     */
+    signature?: Uint8Array;
 }
 /**
  * @generated from protobuf message dht.ConnectivityMethod
@@ -264,6 +278,10 @@ export interface RouteMessageWrapper {
      * @generated from protobuf field: repeated dht.PeerDescriptor routingPath = 6;
      */
     routingPath: PeerDescriptor[];
+    /**
+     * @generated from protobuf field: repeated string parallelRootNodeIds = 7;
+     */
+    parallelRootNodeIds: string[];
 }
 /**
  * @generated from protobuf message dht.RouteMessageAck
@@ -317,6 +335,14 @@ export interface ConnectivityResponse {
      * @generated from protobuf field: dht.ConnectivityMethod websocket = 3;
      */
     websocket?: ConnectivityMethod;
+    /**
+     * @generated from protobuf field: uint32 ipAddress = 4;
+     */
+    ipAddress: number;
+    /**
+     * @generated from protobuf field: string version = 5;
+     */
+    version: string;
 }
 /**
  * @generated from protobuf message dht.HandshakeRequest
@@ -514,11 +540,6 @@ export interface DisconnectNotice {
      */
     disconnectMode: DisconnectMode;
 }
-/**
- * @generated from protobuf message dht.DisconnectNoticeResponse
- */
-export interface DisconnectNoticeResponse {
-}
 /**
  * @generated from protobuf message dht.ExternalFindDataRequest
  */
@@ -848,7 +869,10 @@ class PeerDescriptor$Type extends MessageType$<PeerDescriptor> {
             { no: 3, name: "udp", kind: "message", T: () => ConnectivityMethod },
             { no: 4, name: "tcp", kind: "message", T: () => ConnectivityMethod },
             { no: 5, name: "websocket", kind: "message", T: () => ConnectivityMethod },
-            { no: 6, name: "region", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ }
+            { no: 6, name: "region", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
+            { no: 7, name: "ipAddress", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
+            { no: 8, name: "publicKey", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
+            { no: 9, name: "signature", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ }
         ]);
     }
 }
@@ -879,7 +903,8 @@ class RouteMessageWrapper$Type extends MessageType$<RouteMessageWrapper> {
             { no: 3, name: "target", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
             { no: 4, name: "message", kind: "message", T: () => Message },
             { no: 5, name: "reachableThrough", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
-            { no: 6, name: "routingPath", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor }
+            { no: 6, name: "routingPath", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
+            { no: 7, name: "parallelRootNodeIds", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
         ]);
     }
 }
@@ -921,7 +946,9 @@ class ConnectivityResponse$Type extends MessageType$<ConnectivityResponse> {
         super("dht.ConnectivityResponse", [
             { no: 1, name: "host", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "natType", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 3, name: "websocket", kind: "message", T: () => ConnectivityMethod }
+            { no: 3, name: "websocket", kind: "message", T: () => ConnectivityMethod },
+            { no: 4, name: "ipAddress", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 5, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
 }
@@ -1088,16 +1115,6 @@ class DisconnectNotice$Type extends MessageType$<DisconnectNotice> {
  */
 export const DisconnectNotice = new DisconnectNotice$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class DisconnectNoticeResponse$Type extends MessageType$<DisconnectNoticeResponse> {
-    constructor() {
-        super("dht.DisconnectNoticeResponse", []);
-    }
-}
-/**
- * @generated MessageType for protobuf message dht.DisconnectNoticeResponse
- */
-export const DisconnectNoticeResponse = new DisconnectNoticeResponse$Type();
-// @generated message type with reflection information, may provide speed optimized methods
 class ExternalFindDataRequest$Type extends MessageType$<ExternalFindDataRequest> {
     constructor() {
         super("dht.ExternalFindDataRequest", [
@@ -1176,7 +1193,7 @@ export const WebrtcConnectorRpc = new ServiceType("dht.WebrtcConnectorRpc", [
 export const ConnectionLockRpc = new ServiceType("dht.ConnectionLockRpc", [
     { name: "lockRequest", options: {}, I: LockRequest, O: LockResponse },
     { name: "unlockRequest", options: {}, I: UnlockRequest, O: Empty },
-    { name: "gracefulDisconnect", options: {}, I: DisconnectNotice, O: DisconnectNoticeResponse }
+    { name: "gracefulDisconnect", options: {}, I: DisconnectNotice, O: Empty }
 ]);
 /**
  * @generated ServiceType for protobuf service dht.ExternalApiRpc

package/src/proto/packages/proto-rpc/protos/ProtoRpc.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/proto-rpc/protos/ProtoRpc.proto" (package "protorpc", syntax proto3)
 // tslint:disable
 import { MessageType } from "@protobuf-ts/runtime";

package/src/rpc-protocol/DhtCallContext.ts

@@ -6,7 +6,6 @@ export class DhtCallContext extends ProtoCallContext implements DhtRpcOptions {
     // used by client
     targetDescriptor?: PeerDescriptor
     sourceDescriptor?: PeerDescriptor
-    notification?: boolean
     clientId?: number
     connect?: boolean
     sendIfStopped?: boolean

package/src/transport/ITransport.ts

@@ -32,6 +32,6 @@ export interface ITransport {
 
     send(msg: Message, opts?: SendOptions): Promise<void>
     getLocalPeerDescriptor(): PeerDescriptor
-    getAllConnectionPeerDescriptors(): PeerDescriptor[]
+    getConnections(): PeerDescriptor[]
     stop(): void | Promise<void>
 }

package/src/transport/RoutingRpcCommunicator.ts

@@ -6,7 +6,7 @@ import { RpcMessage } from '../proto/packages/proto-rpc/protos/ProtoRpc'
 import { ServiceID } from '../types/ServiceID'
 import { DEFAULT_SEND_OPTIONS, SendOptions } from './ITransport'
 
-export class RoutingRpcCommunicator extends RpcCommunicator {
+export class RoutingRpcCommunicator extends RpcCommunicator<DhtCallContext> {
     private ownServiceId: ServiceID
     private sendFn: (msg: Message, opts: SendOptions) => Promise<void>
 

package/test/benchmark/Find.test.ts

@@ -5,11 +5,9 @@ import { RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { PeerID } from '../../src/helpers/PeerID'
-import { getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger, wait } from '@streamr/utils'
 import { debugVars } from '../../src/helpers/debugHelpers'
-import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
@@ -59,17 +57,17 @@ describe('Find correctness', () => {
         logger.info('waiting over')
 
         nodes.forEach((node) => logger.info(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ': connections:' +
-            node.getNumberOfConnections() + ', kbucket: ' + node.getNumberOfNeighbors()
-            + ', localLocked: ' + node.getNumberOfLocalLockedConnections()
-            + ', remoteLocked: ' + node.getNumberOfRemoteLockedConnections()
-            + ', weakLocked: ' + node.getNumberOfWeakLockedConnections()))
+            node.getConnectionCount() + ', kbucket: ' + node.getNeighborCount()
+            + ', localLocked: ' + node.getLocalLockedConnectionCount()
+            + ', remoteLocked: ' + node.getRemoteLockedConnectionCount()
+            + ', weakLocked: ' + node.getWeakLockedConnectionCount()))
 
         logger.info('starting find')
         const targetId = Uint8Array.from(dhtIds[9].data)
         const results = await nodes[159].executeRecursiveOperation(getDhtAddressFromRaw(targetId), RecursiveOperation.FIND_NODE)
         logger.info('find over')
         expect(results.closestNodes).toBeGreaterThanOrEqual(5)
-        expect(PeerID.fromValue(targetId).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
+        expect(getDhtAddressFromRaw(targetId)).toEqual(getNodeIdFromPeerDescriptor(results.closestNodes[0]))
 
     }, 180000)
 })

package/test/benchmark/KademliaCorrectness.test.ts

@@ -1,11 +1,10 @@
 /* eslint-disable no-console */
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { DhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
+import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 describe('Kademlia correctness', () => {
     let entryPoint: DhtNode
@@ -93,7 +92,7 @@ describe('Kademlia correctness', () => {
             }
 
             if (i > 0) {
-                sumKbucketSize += nodes[i].getNumberOfNeighbors()
+                sumKbucketSize += nodes[i].getNeighborCount()
                 sumCorrectNeighbors += correctNeighbors
             }
         }