@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.8

package/src/dht/DhtNode.ts

@@ -1,4 +1,4 @@
-import { DhtPeer } from './DhtPeer'
+import { RemoteDhtNode } from './RemoteDhtNode'
 import KBucket from 'k-bucket'
 import { EventEmitter } from 'eventemitter3'
 import { SortedContactList } from './contact/SortedContactList'
@@ -15,35 +15,37 @@ import {
     PeerDescriptor,
     PingRequest,
     PingResponse,
-    FindMode,
     DataEntry,
 } from '../proto/packages/dht/protos/DhtRpc'
 import { DisconnectionType, ITransport, TransportEvents } from '../transport/ITransport'
-import { ConnectionManager, ConnectionManagerConfig, PortRange, TlsCertificate } from '../connection/ConnectionManager'
-import { DhtRpcServiceClient, ExternalApiServiceClient } from '../proto/packages/dht/protos/DhtRpc.client'
+import { ConnectionManager, PortRange, TlsCertificate } from '../connection/ConnectionManager'
+import { DhtRpcServiceClient, ExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import {
     Logger,
     MetricsContext,
     hexToBinary,
-    binaryToHex
+    merge,
+    waitForCondition
 } from '@streamr/utils'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { RandomContactList } from './contact/RandomContactList'
 import { Empty } from '../proto/google/protobuf/empty'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 import { Any } from '../proto/google/protobuf/any'
-import { isSamePeerDescriptor, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { Router } from './routing/Router'
 import { RecursiveFinder, RecursiveFindResult } from './find/RecursiveFinder'
-import { DataStore } from './store/DataStore'
+import { StoreRpcLocal } from './store/StoreRpcLocal'
 import { PeerDiscovery } from './discovery/PeerDiscovery'
 import { LocalDataStore } from './store/LocalDataStore'
-import { IceServer } from '../connection/WebRTC/WebRtcConnector'
+import { IceServer } from '../connection/WebRTC/WebRtcConnectorRpcLocal'
 import { registerExternalApiRpcMethods } from './registerExternalApiRpcMethods'
-import { RemoteExternalApi } from './RemoteExternalApi'
-import { UUID } from '../exports'
-import { isNodeJS } from '../helpers/browser/isNodeJS'
+import { ExternalApiRpcRemote } from './ExternalApiRpcRemote'
+import { UUID } from '../helpers/UUID'
+import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
 import { sample } from 'lodash'
+import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../connection/ConnectorFacade'
+import { MarkRequired } from 'ts-essentials'
 
 export interface DhtNodeEvents {
     newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
@@ -63,19 +65,21 @@ export interface DhtNodeOptions {
     maxNeighborListSize?: number
     numberOfNodesPerKBucket?: number
     joinNoProgressLimit?: number
+    peerDiscoveryQueryBatchSize?: number
     dhtJoinTimeout?: number
     metricsContext?: MetricsContext
     storeHighestTtl?: number
     storeMaxTtl?: number
+    networkConnectivityTimeout?: number
+    storageRedundancyFactor?: number
 
-    transportLayer?: ITransport
+    transport?: ITransport
     peerDescriptor?: PeerDescriptor
     entryPoints?: PeerDescriptor[]
     websocketHost?: string
     websocketPortRange?: PortRange
     peerId?: string
 
-    nodeName?: string
     rpcRequestTimeout?: number
     iceServers?: IceServer[]
     webrtcAllowPrivateAddresses?: boolean
@@ -83,67 +87,41 @@ export interface DhtNodeOptions {
     webrtcDatachannelBufferThresholdHigh?: number
     webrtcNewConnectionTimeout?: number
     webrtcPortRange?: PortRange
+    maxMessageSize?: number
     maxConnections?: number
     tlsCertificate?: TlsCertificate
     externalIp?: string
 }
 
-export class DhtNodeConfig {
-    serviceId = 'layer0'
-    joinParallelism = 3
-    maxNeighborListSize = 200
-    numberOfNodesPerKBucket = 8
-    joinNoProgressLimit = 4
-    dhtJoinTimeout = 60000
-    getClosestContactsLimit = 5
-    maxConnections = 80
-    storeHighestTtl = 60000
-    storeMaxTtl = 60000
-    storeNumberOfCopies = 5
-    metricsContext = new MetricsContext()
-    peerId = new UUID().toHex()
-
-    transportLayer?: ITransport
-    peerDescriptor?: PeerDescriptor
-    entryPoints?: PeerDescriptor[]
-    websocketHost?: string
-    websocketPortRange?: PortRange
-    nodeName?: string
-    rpcRequestTimeout?: number
-    iceServers?: IceServer[]
-    webrtcAllowPrivateAddresses?: boolean
-    webrtcDatachannelBufferThresholdLow?: number
-    webrtcDatachannelBufferThresholdHigh?: number
-    webrtcNewConnectionTimeout?: number
-    externalIp?: string
-    webrtcPortRange?: PortRange
-    tlsCertificate?: TlsCertificate
-
-    constructor(conf: Partial<DhtNodeOptions>) {
-        // assign given non-undefined config vars over defaults
-        let k: keyof typeof conf
-        for (k in conf) {
-            if (conf[k] === undefined) {
-                delete conf[k]
-            }
-        }
-        Object.assign(this, conf)
-    }
-}
+type StrictDhtNodeOptions = MarkRequired<DhtNodeOptions, 
+    'serviceId' |
+    'joinParallelism' |
+    'maxNeighborListSize' |
+    'numberOfNodesPerKBucket' |
+    'joinNoProgressLimit' |
+    'dhtJoinTimeout' |
+    'peerDiscoveryQueryBatchSize' |
+    'maxConnections' |
+    'storeHighestTtl' |
+    'storeMaxTtl' |
+    'networkConnectivityTimeout' |
+    'storageRedundancyFactor' |
+    'metricsContext' |
+    'peerId'>
 
 const logger = new Logger(module)
 
 export type Events = TransportEvents & DhtNodeEvents
 
-export const createPeerDescriptor = (msg?: ConnectivityResponse, peerId?: string, nodeName?: string): PeerDescriptor => {
+export const createPeerDescriptor = (msg?: ConnectivityResponse, peerId?: string): PeerDescriptor => {
     let kademliaId: Uint8Array
     if (msg) {
         kademliaId = peerId ? hexToBinary(peerId) : PeerID.fromIp(msg.host).value
     } else {
         kademliaId = hexToBinary(peerId!)
     }
-    const nodeType = isNodeJS() ? NodeType.NODEJS : NodeType.BROWSER
-    const ret: PeerDescriptor = { kademliaId, nodeName: nodeName ? nodeName : binaryToHex(kademliaId), type: nodeType }
+    const nodeType = isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS 
+    const ret: PeerDescriptor = { kademliaId, type: nodeType }
     if (msg && msg.websocket) {
         ret.websocket = { host: msg.websocket.host, port: msg.websocket.port, tls: msg.websocket.tls }
         ret.openInternet = true
@@ -152,19 +130,18 @@ export const createPeerDescriptor = (msg?: ConnectivityResponse, peerId?: string
 }
 
 export class DhtNode extends EventEmitter<Events> implements ITransport {
-    private readonly config: DhtNodeConfig
 
-    private bucket?: KBucket<DhtPeer>
-    private connections: Map<PeerIDKey, DhtPeer> = new Map()
-    private neighborList?: SortedContactList<DhtPeer>
-    private openInternetPeers?: SortedContactList<DhtPeer>
-    private randomPeers?: RandomContactList<DhtPeer>
+    private readonly config: StrictDhtNodeOptions
+    private bucket?: KBucket<RemoteDhtNode>
+    private connections: Map<PeerIDKey, RemoteDhtNode> = new Map()
+    private neighborList?: SortedContactList<RemoteDhtNode>
+    private openInternetPeers?: SortedContactList<RemoteDhtNode>
+    private randomPeers?: RandomContactList<RemoteDhtNode>
     private rpcCommunicator?: RoutingRpcCommunicator
-    private transportLayer?: ITransport
+    private transport?: ITransport
     private ownPeerDescriptor?: PeerDescriptor
-    private ownPeerId?: PeerID
     public router?: Router
-    public dataStore?: DataStore
+    private storeRpcLocal?: StoreRpcLocal
     private localDataStore = new LocalDataStore()
     private recursiveFinder?: RecursiveFinder
     private peerDiscovery?: PeerDiscovery
@@ -174,12 +151,24 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     private stopped = false
     private entryPointDisconnectTimeout?: NodeJS.Timeout
 
-    public contactAddCounter = 0
-    public contactOnAddedCounter = 0
-
-    constructor(conf: Partial<DhtNodeConfig>) {
+    constructor(conf: DhtNodeOptions) {
         super()
-        this.config = new DhtNodeConfig(conf)
+        this.config = merge({
+            serviceId: 'layer0',
+            joinParallelism: 3,
+            maxNeighborListSize: 200,
+            numberOfNodesPerKBucket: 8,
+            joinNoProgressLimit: 4,
+            dhtJoinTimeout: 60000,
+            peerDiscoveryQueryBatchSize: 5,
+            maxConnections: 80,
+            storeHighestTtl: 60000,
+            storeMaxTtl: 60000,
+            networkConnectivityTimeout: 10000,
+            storageRedundancyFactor: 5,
+            metricsContext: new MetricsContext(),
+            peerId: new UUID().toHex()
+        }, conf)
         this.send = this.send.bind(this)
     }
 
@@ -190,75 +179,77 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         logger.trace(`Starting new Streamr Network DHT Node with serviceId ${this.config.serviceId}`)
         this.started = true
 
-        if (!isNodeJS()) {
+        if (isBrowserEnvironment()) {
             this.config.websocketPortRange = undefined
             if (this.config.peerDescriptor) {
                 this.config.peerDescriptor.websocket = undefined
             }
         }
-        // If transportLayer is given, do not create a ConnectionManager
-        if (this.config.transportLayer) {
-            this.transportLayer = this.config.transportLayer
-            this.ownPeerDescriptor = this.transportLayer.getPeerDescriptor()
-            if (this.config.transportLayer instanceof ConnectionManager) {
-                this.connectionManager = this.config.transportLayer
+        // If transport is given, do not create a ConnectionManager
+        if (this.config.transport) {
+            this.transport = this.config.transport
+            this.ownPeerDescriptor = this.transport.getPeerDescriptor()
+            if (this.config.transport instanceof ConnectionManager) {
+                this.connectionManager = this.config.transport
             }
         } else {
-            const connectionManagerConfig: ConnectionManagerConfig = {
-                transportLayer: this,
+            const connectorFacadeConfig: DefaultConnectorFacadeConfig = {
+                transport: this,
                 entryPoints: this.config.entryPoints,
                 iceServers: this.config.iceServers,
-                metricsContext: this.config.metricsContext,
                 webrtcAllowPrivateAddresses: this.config.webrtcAllowPrivateAddresses,
                 webrtcDatachannelBufferThresholdLow: this.config.webrtcDatachannelBufferThresholdLow,
                 webrtcDatachannelBufferThresholdHigh: this.config.webrtcDatachannelBufferThresholdHigh,
                 webrtcNewConnectionTimeout: this.config.webrtcNewConnectionTimeout,
                 webrtcPortRange: this.config.webrtcPortRange,
-                maxConnections: this.config.maxConnections,
+                maxMessageSize: this.config.maxMessageSize,
                 tlsCertificate: this.config.tlsCertificate,
-                externalIp: this.config.externalIp
+                externalIp: this.config.externalIp,
+                createOwnPeerDescriptor: (connectivityResponse: ConnectivityResponse) => this.generatePeerDescriptorCallBack(connectivityResponse),
             }
             // If own PeerDescriptor is given in config, create a ConnectionManager with ws server
             if (this.config.peerDescriptor?.websocket) {
-                connectionManagerConfig.websocketHost = this.config.peerDescriptor.websocket.host
-                connectionManagerConfig.websocketPortRange = { 
+                connectorFacadeConfig.websocketHost = this.config.peerDescriptor.websocket.host
+                connectorFacadeConfig.websocketPortRange = { 
                     min: this.config.peerDescriptor.websocket.port,
                     max: this.config.peerDescriptor.websocket.port
                 }
             // If websocketPortRange is given, create ws server using it, websocketHost can be undefined
             } else if (this.config.websocketPortRange) { 
-                connectionManagerConfig.websocketHost = this.config.websocketHost
-                connectionManagerConfig.websocketPortRange = this.config.websocketPortRange
+                connectorFacadeConfig.websocketHost = this.config.websocketHost
+                connectorFacadeConfig.websocketPortRange = this.config.websocketPortRange
             }
 
-            const connectionManager = new ConnectionManager(connectionManagerConfig)
-            await connectionManager.start(this.generatePeerDescriptorCallBack)
+            const connectionManager = new ConnectionManager({
+                createConnectorFacade: () => new DefaultConnectorFacade(connectorFacadeConfig),
+                maxConnections: this.config.maxConnections,
+                metricsContext: this.config.metricsContext
+            })
+            await connectionManager.start()
             this.connectionManager = connectionManager
-            this.transportLayer = connectionManager
+            this.transport = connectionManager
         }
 
         this.rpcCommunicator = new RoutingRpcCommunicator(
             this.config.serviceId,
-            this.transportLayer.send,
+            this.transport.send,
             { rpcRequestTimeout: this.config.rpcRequestTimeout }
         )
 
-        this.transportLayer.on('message', (message: Message) => this.handleMessage(message))
+        this.transport.on('message', (message: Message) => this.handleMessage(message))
 
         this.bindDefaultServerMethods()
-        this.ownPeerId = peerIdFromPeerDescriptor(this.ownPeerDescriptor!)
-        this.initKBuckets(this.ownPeerId)
+        this.initKBuckets(peerIdFromPeerDescriptor(this.ownPeerDescriptor!))
         this.peerDiscovery = new PeerDiscovery({
             rpcCommunicator: this.rpcCommunicator,
             ownPeerDescriptor: this.ownPeerDescriptor!,
-            ownPeerId: this.ownPeerId,
             bucket: this.bucket!,
             connections: this.connections,
             neighborList: this.neighborList!,
             randomPeers: this.randomPeers!,
             openInternetPeers: this.openInternetPeers!,
             joinNoProgressLimit: this.config.joinNoProgressLimit,
-            getClosestContactsLimit: this.config.getClosestContactsLimit,
+            peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
             joinTimeout: this.config.dhtJoinTimeout,
             serviceId: this.config.serviceId,
             parallelism: this.config.joinParallelism,
@@ -269,7 +260,6 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             rpcCommunicator: this.rpcCommunicator,
             connections: this.connections,
             ownPeerDescriptor: this.ownPeerDescriptor!,
-            ownPeerId: this.ownPeerId,
             addContact: this.addNewContact.bind(this),
             serviceId: this.config.serviceId,
             connectionManager: this.connectionManager
@@ -281,19 +271,18 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             connections: this.connections,
             ownPeerDescriptor: this.ownPeerDescriptor!,
             serviceId: this.config.serviceId,
-            ownPeerId: this.ownPeerId,
             addContact: this.addNewContact.bind(this),
             isPeerCloserToIdThanSelf: this.isPeerCloserToIdThanSelf.bind(this),
             localDataStore: this.localDataStore
         })
-        this.dataStore = new DataStore({
+        this.storeRpcLocal = new StoreRpcLocal({
             rpcCommunicator: this.rpcCommunicator,
             recursiveFinder: this.recursiveFinder,
             ownPeerDescriptor: this.ownPeerDescriptor!,
             serviceId: this.config.serviceId,
             highestTtl: this.config.storeHighestTtl,
             maxTtl: this.config.storeMaxTtl,
-            numberOfCopies: this.config.storeNumberOfCopies,
+            redundancyFactor: this.config.storageRedundancyFactor,
             localDataStore: this.localDataStore,
             dhtNodeEmitter: this,
             getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => {
@@ -302,31 +291,31 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         })
         registerExternalApiRpcMethods(this)
         if (this.connectionManager! && this.config.entryPoints && this.config.entryPoints.length > 0 
-            && !isSamePeerDescriptor(this.config.entryPoints[0], this.ownPeerDescriptor!)) {
+            && !areEqualPeerDescriptors(this.config.entryPoints[0], this.ownPeerDescriptor!)) {
             this.connectToEntryPoint(this.config.entryPoints[0])
         }
     }
 
     private initKBuckets = (selfId: PeerID) => {
-        this.bucket = new KBucket<DhtPeer>({
+        this.bucket = new KBucket<RemoteDhtNode>({
             localNodeId: selfId.value,
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
             numberOfNodesToPing: this.config.numberOfNodesPerKBucket
         })
-        this.bucket.on('ping', (oldContacts: DhtPeer[], newContact: DhtPeer) => this.onKBucketPing(oldContacts, newContact))
-        this.bucket.on('removed', (contact: DhtPeer) => this.onKBucketRemoved(contact))
-        this.bucket.on('added', (contact: DhtPeer) => this.onKBucketAdded(contact))
-        this.bucket.on('updated', (_oldContact: DhtPeer, _newContact: DhtPeer) => {
+        this.bucket.on('ping', (oldContacts: RemoteDhtNode[], newContact: RemoteDhtNode) => this.onKBucketPing(oldContacts, newContact))
+        this.bucket.on('removed', (contact: RemoteDhtNode) => this.onKBucketRemoved(contact))
+        this.bucket.on('added', (contact: RemoteDhtNode) => this.onKBucketAdded(contact))
+        this.bucket.on('updated', () => {
             // TODO: Update contact info to the connection manager and reconnect
         })
         this.neighborList = new SortedContactList(selfId, this.config.maxNeighborListSize)
-        this.neighborList.on('contactRemoved', (removedContact: DhtPeer, activeContacts: DhtPeer[]) => {
+        this.neighborList.on('contactRemoved', (removedContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) => {
             if (this.stopped) {
                 return
             }
             this.emit('contactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
             this.randomPeers!.addContact(
-                new DhtPeer(
+                new RemoteDhtNode(
                     this.ownPeerDescriptor!,
                     removedContact.getPeerDescriptor(),
                     toProtoRpcClient(new DhtRpcServiceClient(this.rpcCommunicator!.getRpcClientTransport())),
@@ -334,80 +323,77 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 )
             )
         })
-        this.neighborList.on('newContact', (newContact: DhtPeer, activeContacts: DhtPeer[]) =>
+        this.neighborList.on('newContact', (newContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
             this.emit('newContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
         this.openInternetPeers = new SortedContactList(selfId, this.config.maxNeighborListSize / 2)
-        this.openInternetPeers.on('contactRemoved', (removedContact: DhtPeer, activeContacts: DhtPeer[]) =>
+        this.openInternetPeers.on('contactRemoved', (removedContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
             this.emit('openInternetContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
-        this.openInternetPeers.on('newContact', (newContact: DhtPeer, activeContacts: DhtPeer[]) =>
+        this.openInternetPeers.on('newContact', (newContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
             this.emit('newOpenInternetContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
-        this.transportLayer!.on('connected', (peerDescriptor: PeerDescriptor) => this.onTransportConnected(peerDescriptor))
+        this.transport!.on('connected', (peerDescriptor: PeerDescriptor) => this.onTransportConnected(peerDescriptor))
 
-        this.transportLayer!.on('disconnected', (peerDescriptor: PeerDescriptor, disonnectionType: DisconnectionType) => {
+        this.transport!.on('disconnected', (peerDescriptor: PeerDescriptor, disonnectionType: DisconnectionType) => {
             this.onTransportDisconnected(peerDescriptor, disonnectionType)
         })
 
-        this.transportLayer!.getAllConnectionPeerDescriptors().map((peer) => {
-            const peerId = peerIdFromPeerDescriptor(peer)
-            const dhtPeer = new DhtPeer(
+        this.transport!.getAllConnectionPeerDescriptors().forEach((peer) => {
+            const remoteDhtNode = new RemoteDhtNode(
                 this.ownPeerDescriptor!,
                 peer,
                 toProtoRpcClient(new DhtRpcServiceClient(this.rpcCommunicator!.getRpcClientTransport())),
                 this.config.serviceId
             )
-            if (peerId.equals(this.ownPeerId!)) {
+            if (areEqualPeerDescriptors(peer, this.ownPeerDescriptor!)) {
                 logger.error('own peerdescriptor added to connections in initKBucket')
             }
-            this.connections.set(peerId.toKey(), dhtPeer)
+            this.connections.set(keyFromPeerDescriptor(peer), remoteDhtNode)
         })
         this.randomPeers = new RandomContactList(selfId, this.config.maxNeighborListSize)
-        this.randomPeers.on('contactRemoved', (removedContact: DhtPeer, activeContacts: DhtPeer[]) =>
+        this.randomPeers.on('contactRemoved', (removedContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
             this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
-        this.randomPeers.on('newContact', (newContact: DhtPeer, activeContacts: DhtPeer[]) =>
+        this.randomPeers.on('newContact', (newContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
             this.emit('newRandomContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
     }
 
     private onTransportConnected(peerDescriptor: PeerDescriptor): void {
 
-        if (this.ownPeerId!.equals(PeerID.fromValue(peerDescriptor.kademliaId))) {
+        if (areEqualPeerDescriptors(this.ownPeerDescriptor!, peerDescriptor)) {
             logger.error('onTransportConnected() to self')
         }
 
-        const dhtPeer = new DhtPeer(
+        const remoteDhtNode = new RemoteDhtNode(
             this.ownPeerDescriptor!,
             peerDescriptor,
             toProtoRpcClient(new DhtRpcServiceClient(this.rpcCommunicator!.getRpcClientTransport())),
             this.config.serviceId
         )
-        if (!this.connections.has(PeerID.fromValue(dhtPeer.id).toKey())) {
-            this.connections.set(PeerID.fromValue(dhtPeer.id).toKey(), dhtPeer)
-            logger.trace(' ' + this.config.nodeName + ' connectionschange add ' + this.connections.size)
+        if (!this.connections.has(PeerID.fromValue(remoteDhtNode.id).toKey())) {
+            this.connections.set(PeerID.fromValue(remoteDhtNode.id).toKey(), remoteDhtNode)
+            logger.trace('connectionschange add ' + this.connections.size)
         } else {
             logger.trace('new connection not set to connections, there is already a connection with the peer ID')
         }
-        if (this.ownPeerDescriptor!.nodeName === 'entrypoint') {
-            logger.trace('connected: ' + this.ownPeerDescriptor!.nodeName + ', ' + peerDescriptor.nodeName + ' ' + this.connections.size)
-        }
+        logger.trace('connected: ' + keyFromPeerDescriptor(peerDescriptor) + ' ' + this.connections.size)
         this.emit('connected', peerDescriptor)
     }
 
     private onTransportDisconnected(peerDescriptor: PeerDescriptor, dicsonnectionType: DisconnectionType): void {
-        logger.trace('disconnected: ' + this.config.nodeName + ', ' + peerDescriptor.nodeName + ' ')
+        logger.trace('disconnected: ' + keyFromPeerDescriptor(peerDescriptor))
         this.connections.delete(keyFromPeerDescriptor(peerDescriptor))
         // only remove from bucket if we are on layer 0
         if (this.connectionManager) {
             this.bucket!.remove(peerDescriptor.kademliaId)
 
             if (dicsonnectionType === 'OUTGOING_GRACEFUL_LEAVE' || dicsonnectionType === 'INCOMING_GRACEFUL_LEAVE') {
-                logger.trace( this.config.nodeName + ', ' + peerDescriptor.nodeName + ' ' + 'onTransportDisconnected with type ' + dicsonnectionType)
+                logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with type ' + dicsonnectionType)
                 this.removeContact(peerDescriptor, true)
             } else {
-                logger.trace( this.config.nodeName + ', ' + peerDescriptor.nodeName + ' ' + 'onTransportDisconnected with type ' + dicsonnectionType)
+                logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with type ' + dicsonnectionType)
             }
         }
 
@@ -433,14 +419,13 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return distance1 < distance2
     }
 
-    public handleMessage(message: Message): void {
+    private handleMessage(message: Message): void {
         if (message.serviceId === this.config.serviceId) {
-            logger.trace('callig this.handleMessageFromPeer ' + this.config.nodeName + ', ' +
-                message.sourceDescriptor?.nodeName + ' ' + message.serviceId + ' ' + message.messageId)
+            logger.trace('callig this.handleMessageFromPeer ' + keyFromPeerDescriptor(message.sourceDescriptor!)
+                + ' ' + message.serviceId + ' ' + message.messageId)
             this.rpcCommunicator?.handleMessageFromPeer(message)
         } else {
-            logger.trace('emit "message" ' + this.config.nodeName + ', ' + message.sourceDescriptor?.nodeName +
-                ' ' + message.serviceId + ' ' + message.messageId)
+            logger.trace('emit "message" ' + keyFromPeerDescriptor(message.sourceDescriptor!) + ' ' + message.serviceId + ' ' + message.messageId)
             this.emit('message', message)
         }
     }
@@ -449,23 +434,21 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (this.config.peerDescriptor) {
             this.ownPeerDescriptor = this.config.peerDescriptor
         } else {
-            this.ownPeerDescriptor = createPeerDescriptor(connectivityResponse,
-                this.config.peerId,
-                this.config.nodeName)
+            this.ownPeerDescriptor = createPeerDescriptor(connectivityResponse, this.config.peerId)
         }
         return this.ownPeerDescriptor
     }
 
     private getClosestPeerDescriptors(kademliaId: Uint8Array, limit: number): PeerDescriptor[] {
         const closestPeers = this.bucket!.closest(kademliaId, limit)
-        return closestPeers.map((dhtPeer: DhtPeer) => dhtPeer.getPeerDescriptor())
+        return closestPeers.map((remoteDhtNode: RemoteDhtNode) => remoteDhtNode.getPeerDescriptor())
     }
 
-    private onKBucketPing(oldContacts: DhtPeer[], newContact: DhtPeer): void {
+    private onKBucketPing(oldContacts: RemoteDhtNode[], newContact: RemoteDhtNode): void {
         if (this.stopped) {
             return
         }
-        const sortingList: SortedContactList<DhtPeer> = new SortedContactList(this.ownPeerId!, 100)
+        const sortingList: SortedContactList<RemoteDhtNode> = new SortedContactList(this.getNodeId(), 100)
         sortingList.addContacts(oldContacts)
         const sortedContacts = sortingList.getAllContacts()
         this.connectionManager?.weakUnlockConnection(sortedContacts[sortedContacts.length - 1].getPeerDescriptor())
@@ -473,12 +456,12 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         this.bucket!.add(newContact)
     }
 
-    private onKBucketRemoved(contact: DhtPeer): void {
+    private onKBucketRemoved(contact: RemoteDhtNode): void {
         if (this.stopped) {
             return
         }
         this.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
-        logger.trace(`Removed contact ${contact.getPeerId().value.toString()}`)
+        logger.trace(`Removed contact ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.emit(
             'kbucketContactRemoved',
             contact.getPeerDescriptor()
@@ -496,33 +479,32 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         }
     }
 
-    private onKBucketAdded(contact: DhtPeer): void {
+    private onKBucketAdded(contact: RemoteDhtNode): void {
         if (this.stopped) {
             return
         }
-        this.contactOnAddedCounter++
-        if (!this.stopped && !contact.getPeerId().equals(this.ownPeerId!)) {
+        if (!this.stopped && !contact.getPeerId().equals(this.getNodeId())) {
             // Important to lock here, before the ping result is known
             this.connectionManager?.weakLockConnection(contact.getPeerDescriptor())
             if (this.connections.has(contact.getPeerId().toKey())) {
-                logger.trace(`Added new contact ${contact.getPeerId().value.toString()}`)
+                logger.trace(`Added new contact ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
                 this.emit(
                     'newKbucketContact',
                     contact.getPeerDescriptor(),
-                    this.neighborList!.getClosestContacts(this.config.getClosestContactsLimit).map((peer) => peer.getPeerDescriptor())
+                    this.neighborList!.getClosestContacts(this.config.peerDiscoveryQueryBatchSize).map((peer) => peer.getPeerDescriptor())
                 )
             } else {    // open connection by pinging
-                logger.trace('starting ping ' + this.config.nodeName + ', ' + contact.getPeerDescriptor().nodeName + ' ')
+                logger.trace('starting ping ' + keyFromPeerDescriptor(contact.getPeerDescriptor()))
                 contact.ping().then((result) => {
                     if (result) {
-                        logger.trace(`Added new contact ${contact.getPeerId().value.toString()}`)
+                        logger.trace(`Added new contact ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
                         this.emit(
                             'newKbucketContact',
                             contact.getPeerDescriptor(),
-                            this.neighborList!.getClosestContacts(this.config.getClosestContactsLimit).map((peer) => peer.getPeerDescriptor())
+                            this.neighborList!.getClosestContacts(this.config.peerDiscoveryQueryBatchSize).map((peer) => peer.getPeerDescriptor())
                         )
                     } else {
-                        logger.trace('ping failed ' + this.config.nodeName + ', ' + contact.getPeerDescriptor().nodeName + ' ')
+                        logger.trace('ping failed ' + keyFromPeerDescriptor(contact.getPeerDescriptor()))
                         this.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
                         this.removeContact(contact.getPeerDescriptor())
                         this.addClosestContactToBucket()
@@ -547,7 +529,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         }
     }
 
-    private getClosestActiveContactNotInBucket(): DhtPeer | undefined {
+    private getClosestActiveContactNotInBucket(): RemoteDhtNode | undefined {
         for (const contactId of this.neighborList!.getContactIds()) {
             if (!this.bucket!.get(contactId.value) && this.neighborList!.isActive(contactId)) {
                 return this.neighborList!.getContact(contactId).contact
@@ -561,7 +543,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public getNodeId(): PeerID {
-        return this.ownPeerId!
+        return peerIdFromPeerDescriptor(this.ownPeerDescriptor!)
     }
 
     public getBucketSize(): number {
@@ -572,28 +554,27 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (!this.started || this.stopped) {
             return
         }
-        const peerId = peerIdFromPeerDescriptor(contact)
-        if (!peerId.equals(this.ownPeerId!)) {
-            logger.trace(`Adding new contact ${contact.kademliaId.toString()}`)
-            const dhtPeer = new DhtPeer(
+        if (!areEqualPeerDescriptors(contact, this.ownPeerDescriptor!)) {
+            logger.trace(`Adding new contact ${keyFromPeerDescriptor(contact)}`)
+            const remoteDhtNode = new RemoteDhtNode(
                 this.ownPeerDescriptor!,
                 contact,
                 toProtoRpcClient(new DhtRpcServiceClient(this.rpcCommunicator!.getRpcClientTransport())),
                 this.config.serviceId
             )
             if (!this.bucket!.get(contact.kademliaId) && !this.neighborList!.getContact(peerIdFromPeerDescriptor(contact))) {
-                this.neighborList!.addContact(dhtPeer)
+                this.neighborList!.addContact(remoteDhtNode)
                 if (contact.openInternet) {
-                    this.openInternetPeers!.addContact(dhtPeer)
+                    this.openInternetPeers!.addContact(remoteDhtNode)
                 }
                 if (setActive) {
+                    const peerId = peerIdFromPeerDescriptor(contact)
                     this.neighborList!.setActive(peerId)
                     this.openInternetPeers!.setActive(peerId)
                 }
-                this.contactAddCounter++
-                this.bucket!.add(dhtPeer)
+                this.bucket!.add(remoteDhtNode)
             } else {
-                this.randomPeers!.addContact(dhtPeer)
+                this.randomPeers!.addContact(remoteDhtNode)
             }
         }
     }
@@ -609,7 +590,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (!this.started || this.stopped) {
             return
         }
-        logger.trace(`Removing contact ${contact.kademliaId.toString()}`)
+        logger.trace(`Removing contact ${keyFromPeerDescriptor(contact)}`)
         const peerId = peerIdFromPeerDescriptor(contact)
         this.bucket!.remove(peerId.value)
         this.neighborList!.removeContact(peerId)
@@ -619,7 +600,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         }
     }
 
-    public async send(msg: Message, _doNotConnect?: boolean): Promise<void> {
+    public async send(msg: Message): Promise<void> {
         if (!this.started || this.stopped) {
             return
         }
@@ -627,54 +608,58 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         await this.router!.send(msg, reachableThrough)
     }
 
-    public async joinDht(entryPointDescriptors: PeerDescriptor[], doRandomJoin?: boolean, retry?: boolean): Promise<void> {
+    public async joinDht(entryPointDescriptors: PeerDescriptor[], doAdditionalRandomPeerDiscovery?: boolean, retry?: boolean): Promise<void> {
         if (!this.started) {
             throw new Error('Cannot join DHT before calling start() on DhtNode')
         }
         await Promise.all(entryPointDescriptors.map((entryPoint) => 
-            this.peerDiscovery!.joinDht(entryPoint, doRandomJoin, retry)
+            this.peerDiscovery!.joinDht(entryPoint, doAdditionalRandomPeerDiscovery, retry)
         ))
     }
 
-    public async startRecursiveFind(idToFind: Uint8Array, findMode?: FindMode, excludedPeer?: PeerDescriptor): Promise<RecursiveFindResult> {
-        return this.recursiveFinder!.startRecursiveFind(idToFind, findMode, excludedPeer)
+    public async startRecursiveFind(idToFind: Uint8Array, fetchData?: boolean, excludedPeer?: PeerDescriptor): Promise<RecursiveFindResult> {
+        return this.recursiveFinder!.startRecursiveFind(idToFind, fetchData, excludedPeer)
     }
 
     public async storeDataToDht(key: Uint8Array, data: Any): Promise<PeerDescriptor[]> {
-        if (this.isJoinOngoing() && this.config.entryPoints && this.config.entryPoints.length > 0) {
+        if (this.peerDiscovery!.isJoinOngoing() && this.config.entryPoints && this.config.entryPoints.length > 0) {
             return this.storeDataViaPeer(key, data, sample(this.config.entryPoints)!)
         }
-        return this.dataStore!.storeDataToDht(key, data)
+        return this.storeRpcLocal!.storeDataToDht(key, data)
     }
 
     public async storeDataViaPeer(key: Uint8Array, data: Any, peer: PeerDescriptor): Promise<PeerDescriptor[]> {
-        const target = new RemoteExternalApi(
+        const rpcRemote = new ExternalApiRpcRemote(
             this.ownPeerDescriptor!,
             peer,
             this.config.serviceId,
-            toProtoRpcClient(new ExternalApiServiceClient(this.rpcCommunicator!.getRpcClientTransport()))
+            toProtoRpcClient(new ExternalApiRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
-        return await target.storeData(key, data)
+        return await rpcRemote.storeData(key, data)
     }
 
-    public async getDataFromDht(idToFind: Uint8Array): Promise<RecursiveFindResult> {
-        return this.recursiveFinder!.startRecursiveFind(idToFind, FindMode.DATA)
+    public async getDataFromDht(idToFind: Uint8Array): Promise<DataEntry[]> {
+        if (this.peerDiscovery!.isJoinOngoing() && this.config.entryPoints && this.config.entryPoints.length > 0) {
+            return this.findDataViaPeer(idToFind, sample(this.config.entryPoints)!)
+        }
+        const result = await this.recursiveFinder!.startRecursiveFind(idToFind, true)
+        return result.dataEntries ?? []
     }
 
     public async deleteDataFromDht(idToDelete: Uint8Array): Promise<void> {
         if (!this.stopped) {
-            return this.dataStore!.deleteDataFromDht(idToDelete)
+            return this.storeRpcLocal!.deleteDataFromDht(idToDelete)
         }
     }
 
     public async findDataViaPeer(idToFind: Uint8Array, peer: PeerDescriptor): Promise<DataEntry[]> {
-        const target = new RemoteExternalApi(
+        const rpcRemote = new ExternalApiRpcRemote(
             this.ownPeerDescriptor!,
             peer,
             this.config.serviceId,
-            toProtoRpcClient(new ExternalApiServiceClient(this.rpcCommunicator!.getRpcClientTransport()))
+            toProtoRpcClient(new ExternalApiRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
-        return await target.findData(idToFind)
+        return await rpcRemote.findData(idToFind)
     }
 
     public getRpcCommunicator(): RoutingRpcCommunicator {
@@ -682,7 +667,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public getTransport(): ITransport {
-        return this.transportLayer!
+        return this.transport!
     }
 
     public getPeerDescriptor(): PeerDescriptor {
@@ -693,16 +678,8 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return Array.from(this.connections.values()).map((peer) => peer.getPeerDescriptor())
     }
 
-    public getK(): number {
-        return this.config.numberOfNodesPerKBucket
-    }
-
     public getKBucketPeers(): PeerDescriptor[] {
-        return this.bucket!.toArray().map((dhtPeer: DhtPeer) => dhtPeer.getPeerDescriptor())
-    }
-
-    public getOpenInternetPeerDescriptors(): PeerDescriptor[] {
-        return this.openInternetPeers!.getAllContacts().map((contact) => contact.getPeerDescriptor())
+        return this.bucket!.toArray().map((remoteDhtNode: RemoteDhtNode) => remoteDhtNode.getPeerDescriptor())
     }
 
     public getNumberOfConnections(): number {
@@ -721,18 +698,14 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return this.connectionManager!.getNumberOfWeakLockedConnections()
     }
 
-    public isJoinOngoing(): boolean {
-        return this.peerDiscovery!.isJoinOngoing()
+    public async waitForNetworkConnectivity(): Promise<void> {
+        await waitForCondition(() => this.connections.size > 0, this.config.networkConnectivityTimeout)
     }
 
     public hasJoined(): boolean {
         return this.peerDiscovery!.isJoinCalled()
     }
 
-    public getKnownEntryPoints(): PeerDescriptor[] {
-        return this.config.entryPoints || []
-    }
-
     public async stop(): Promise<void> {
         if (this.stopped || !this.started) {
             return
@@ -743,7 +716,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (this.entryPointDisconnectTimeout) {
             clearTimeout(this.entryPointDisconnectTimeout)
         }
-        this.bucket!.toArray().map((dhtPeer: DhtPeer) => this.bucket!.remove(dhtPeer.id))
+        this.bucket!.toArray().forEach((remoteDhtNode: RemoteDhtNode) => this.bucket!.remove(remoteDhtNode.id))
         this.bucket!.removeAllListeners()
         this.localDataStore.clear()
         this.neighborList!.stop()
@@ -756,7 +729,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (this.connectionManager) {
             await this.connectionManager.stop()
         }
-        this.transportLayer = undefined
+        this.transport = undefined
         this.connectionManager = undefined
         this.connections.clear()
         this.removeAllListeners()
@@ -766,7 +739,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     private async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
         this.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
         const response = {
-            peers: this.getClosestPeerDescriptors(request.kademliaId, this.config.getClosestContactsLimit),
+            peers: this.getClosestPeerDescriptors(request.kademliaId, this.config.peerDiscoveryQueryBatchSize),
             requestId: request.requestId
         }
         return response
@@ -774,7 +747,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     // IDHTRpcService implementation
     private async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
-        logger.trace('received ping request: ' + this.config.nodeName + ', ' + (context as DhtCallContext).incomingSourceDescriptor?.nodeName)
+        logger.trace('received ping request: ' + keyFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
         setImmediate(() => {
             this.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
         })
@@ -785,7 +758,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     // IDHTRpcService implementation
-    public async leaveNotice(request: LeaveNotice, context: ServerCallContext): Promise<Empty> {
+    private async leaveNotice(request: LeaveNotice, context: ServerCallContext): Promise<Empty> {
         // TODO check signature??
         if (request.serviceId === this.config.serviceId) {
             this.removeContact((context as DhtCallContext).incomingSourceDescriptor!)