@streamr/dht 100.0.0-pretestnet.2 → 100.0.0-pretestnet.4

package/src/dht/DhtNode.ts

@@ -1,9 +1,8 @@
-import { RemoteDhtNode } from './RemoteDhtNode'
+import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
 import KBucket from 'k-bucket'
 import { EventEmitter } from 'eventemitter3'
 import { SortedContactList } from './contact/SortedContactList'
 import { RoutingRpcCommunicator } from '../transport/RoutingRpcCommunicator'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { PeerID, PeerIDKey } from '../helpers/PeerID'
 import {
     ClosestPeersRequest,
@@ -16,10 +15,14 @@ import {
     PingRequest,
     PingResponse,
     DataEntry,
+    ExternalFindDataRequest,
+    ExternalFindDataResponse,
+    ExternalStoreDataRequest,
+    ExternalStoreDataResponse,
 } from '../proto/packages/dht/protos/DhtRpc'
-import { DisconnectionType, ITransport, TransportEvents } from '../transport/ITransport'
+import { ITransport, TransportEvents } from '../transport/ITransport'
 import { ConnectionManager, PortRange, TlsCertificate } from '../connection/ConnectionManager'
-import { DhtRpcServiceClient, ExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
+import { DhtNodeRpcClient, ExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import {
     Logger,
     MetricsContext,
@@ -29,32 +32,33 @@ import {
 } 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 { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import {
+    areEqualPeerDescriptors,
+    getNodeIdFromPeerDescriptor,
+    keyFromPeerDescriptor,
+    peerIdFromPeerDescriptor
+} from '../helpers/peerIdFromPeerDescriptor'
 import { Router } from './routing/Router'
-import { RecursiveFinder, RecursiveFindResult } from './find/RecursiveFinder'
+import { Finder, FindResult } from './find/Finder'
 import { StoreRpcLocal } from './store/StoreRpcLocal'
 import { PeerDiscovery } from './discovery/PeerDiscovery'
 import { LocalDataStore } from './store/LocalDataStore'
-import { IceServer } from '../connection/WebRTC/WebRtcConnectorRpcLocal'
-import { registerExternalApiRpcMethods } from './registerExternalApiRpcMethods'
+import { IceServer } from '../connection/webrtc/WebrtcConnector'
 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'
+import { DhtNodeRpcLocal } from './DhtNodeRpcLocal'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { ExternalApiRpcLocal } from './ExternalApiRpcLocal'
 
 export interface DhtNodeEvents {
     newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     joinCompleted: () => void
-    newKbucketContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    kbucketContactRemoved: (peerDescriptor: PeerDescriptor) => void
-    newOpenInternetContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    openInternetContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     newRandomContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
 }
@@ -78,6 +82,7 @@ export interface DhtNodeOptions {
     entryPoints?: PeerDescriptor[]
     websocketHost?: string
     websocketPortRange?: PortRange
+    websocketServerEnableTls?: boolean
     peerId?: string
 
     rpcRequestTimeout?: number
@@ -91,6 +96,8 @@ export interface DhtNodeOptions {
     maxConnections?: number
     tlsCertificate?: TlsCertificate
     externalIp?: string
+    autoCertifierUrl?: string
+    autoCertifierConfigFile?: string
 }
 
 type StrictDhtNodeOptions = MarkRequired<DhtNodeOptions, 
@@ -124,7 +131,6 @@ export const createPeerDescriptor = (msg?: ConnectivityResponse, peerId?: string
     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
     }
     return ret
 }
@@ -132,18 +138,17 @@ export const createPeerDescriptor = (msg?: ConnectivityResponse, peerId?: string
 export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     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 bucket?: KBucket<DhtNodeRpcRemote>
+    private connections: Map<PeerIDKey, DhtNodeRpcRemote> = new Map()
+    private neighborList?: SortedContactList<DhtNodeRpcRemote>
+    private randomPeers?: RandomContactList<DhtNodeRpcRemote>
     private rpcCommunicator?: RoutingRpcCommunicator
     private transport?: ITransport
-    private ownPeerDescriptor?: PeerDescriptor
+    private localPeerDescriptor?: PeerDescriptor
     public router?: Router
     private storeRpcLocal?: StoreRpcLocal
     private localDataStore = new LocalDataStore()
-    private recursiveFinder?: RecursiveFinder
+    private finder?: Finder
     private peerDiscovery?: PeerDiscovery
 
     public connectionManager?: ConnectionManager
@@ -188,7 +193,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         // If transport is given, do not create a ConnectionManager
         if (this.config.transport) {
             this.transport = this.config.transport
-            this.ownPeerDescriptor = this.transport.getPeerDescriptor()
+            this.localPeerDescriptor = this.transport.getLocalPeerDescriptor()
             if (this.config.transport instanceof ConnectionManager) {
                 this.connectionManager = this.config.transport
             }
@@ -203,9 +208,12 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 webrtcNewConnectionTimeout: this.config.webrtcNewConnectionTimeout,
                 webrtcPortRange: this.config.webrtcPortRange,
                 maxMessageSize: this.config.maxMessageSize,
+                websocketServerEnableTls: this.config.websocketServerEnableTls,
                 tlsCertificate: this.config.tlsCertificate,
                 externalIp: this.config.externalIp,
-                createOwnPeerDescriptor: (connectivityResponse: ConnectivityResponse) => this.generatePeerDescriptorCallBack(connectivityResponse),
+                autoCertifierUrl: this.config.autoCertifierUrl,
+                autoCertifierConfigFile: this.config.autoCertifierConfigFile,
+                createLocalPeerDescriptor: (connectivityResponse: ConnectivityResponse) => this.generatePeerDescriptorCallBack(connectivityResponse),
             }
             // If own PeerDescriptor is given in config, create a ConnectionManager with ws server
             if (this.config.peerDescriptor?.websocket) {
@@ -238,38 +246,35 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
         this.transport.on('message', (message: Message) => this.handleMessage(message))
 
-        this.bindDefaultServerMethods()
-        this.initKBuckets(peerIdFromPeerDescriptor(this.ownPeerDescriptor!))
+        this.initKBuckets(peerIdFromPeerDescriptor(this.localPeerDescriptor!))
         this.peerDiscovery = new PeerDiscovery({
             rpcCommunicator: this.rpcCommunicator,
-            ownPeerDescriptor: this.ownPeerDescriptor!,
+            localPeerDescriptor: this.localPeerDescriptor!,
             bucket: this.bucket!,
-            connections: this.connections,
             neighborList: this.neighborList!,
-            randomPeers: this.randomPeers!,
-            openInternetPeers: this.openInternetPeers!,
             joinNoProgressLimit: this.config.joinNoProgressLimit,
             peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
             joinTimeout: this.config.dhtJoinTimeout,
             serviceId: this.config.serviceId,
             parallelism: this.config.joinParallelism,
             addContact: this.addNewContact.bind(this),
-            connectionManager: this.connectionManager
+            connectionManager: this.connectionManager,
+            rpcRequestTimeout: this.config.rpcRequestTimeout
         })
         this.router = new Router({
             rpcCommunicator: this.rpcCommunicator,
             connections: this.connections,
-            ownPeerDescriptor: this.ownPeerDescriptor!,
+            localPeerDescriptor: this.localPeerDescriptor!,
             addContact: this.addNewContact.bind(this),
             serviceId: this.config.serviceId,
             connectionManager: this.connectionManager
         })
-        this.recursiveFinder = new RecursiveFinder({
+        this.finder = new Finder({
             rpcCommunicator: this.rpcCommunicator,
             router: this.router,
             sessionTransport: this,
             connections: this.connections,
-            ownPeerDescriptor: this.ownPeerDescriptor!,
+            localPeerDescriptor: this.localPeerDescriptor!,
             serviceId: this.config.serviceId,
             addContact: this.addNewContact.bind(this),
             isPeerCloserToIdThanSelf: this.isPeerCloserToIdThanSelf.bind(this),
@@ -277,8 +282,8 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         })
         this.storeRpcLocal = new StoreRpcLocal({
             rpcCommunicator: this.rpcCommunicator,
-            recursiveFinder: this.recursiveFinder,
-            ownPeerDescriptor: this.ownPeerDescriptor!,
+            finder: this.finder,
+            localPeerDescriptor: this.localPeerDescriptor!,
             serviceId: this.config.serviceId,
             highestTtl: this.config.storeHighestTtl,
             maxTtl: this.config.storeMaxTtl,
@@ -287,168 +292,187 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             dhtNodeEmitter: this,
             getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => {
                 return this.bucket!.closest(id, n)
-            }
+            },
+            rpcRequestTimeout: this.config.rpcRequestTimeout
         })
-        registerExternalApiRpcMethods(this)
+        this.bindRpcLocalMethods()
         if (this.connectionManager! && this.config.entryPoints && this.config.entryPoints.length > 0 
-            && !areEqualPeerDescriptors(this.config.entryPoints[0], this.ownPeerDescriptor!)) {
+            && !areEqualPeerDescriptors(this.config.entryPoints[0], this.localPeerDescriptor!)) {
             this.connectToEntryPoint(this.config.entryPoints[0])
         }
     }
 
-    private initKBuckets = (selfId: PeerID) => {
-        this.bucket = new KBucket<RemoteDhtNode>({
+    private initKBuckets(selfId: PeerID) {
+        this.bucket = new KBucket<DhtNodeRpcRemote>({
             localNodeId: selfId.value,
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
             numberOfNodesToPing: this.config.numberOfNodesPerKBucket
         })
-        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('ping', (oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote) => this.onKBucketPing(oldContacts, newContact))
+        this.bucket.on('removed', (contact: DhtNodeRpcRemote) => this.onKBucketRemoved(contact))
+        this.bucket.on('added', (contact: DhtNodeRpcRemote) => 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: RemoteDhtNode, activeContacts: RemoteDhtNode[]) => {
+        this.neighborList.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) => {
             if (this.stopped) {
                 return
             }
             this.emit('contactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
             this.randomPeers!.addContact(
-                new RemoteDhtNode(
-                    this.ownPeerDescriptor!,
+                new DhtNodeRpcRemote(
+                    this.localPeerDescriptor!,
                     removedContact.getPeerDescriptor(),
-                    toProtoRpcClient(new DhtRpcServiceClient(this.rpcCommunicator!.getRpcClientTransport())),
-                    this.config.serviceId
+                    toProtoRpcClient(new DhtNodeRpcClient(this.rpcCommunicator!.getRpcClientTransport())),
+                    this.config.serviceId,
+                    this.config.rpcRequestTimeout
                 )
             )
         })
-        this.neighborList.on('newContact', (newContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
+        this.neighborList.on('newContact', (newContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
             this.emit('newContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
-        this.openInternetPeers = new SortedContactList(selfId, this.config.maxNeighborListSize / 2)
-        this.openInternetPeers.on('contactRemoved', (removedContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
-            this.emit('openInternetContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
-        )
-        this.openInternetPeers.on('newContact', (newContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
-            this.emit('newOpenInternetContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
-        )
         this.transport!.on('connected', (peerDescriptor: PeerDescriptor) => this.onTransportConnected(peerDescriptor))
 
-        this.transport!.on('disconnected', (peerDescriptor: PeerDescriptor, disonnectionType: DisconnectionType) => {
-            this.onTransportDisconnected(peerDescriptor, disonnectionType)
+        this.transport!.on('disconnected', (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => {
+            this.onTransportDisconnected(peerDescriptor, gracefulLeave)
         })
 
         this.transport!.getAllConnectionPeerDescriptors().forEach((peer) => {
-            const remoteDhtNode = new RemoteDhtNode(
-                this.ownPeerDescriptor!,
+            const rpcRemote = new DhtNodeRpcRemote(
+                this.localPeerDescriptor!,
                 peer,
-                toProtoRpcClient(new DhtRpcServiceClient(this.rpcCommunicator!.getRpcClientTransport())),
-                this.config.serviceId
+                toProtoRpcClient(new DhtNodeRpcClient(this.rpcCommunicator!.getRpcClientTransport())),
+                this.config.serviceId,
+                this.config.rpcRequestTimeout
             )
-            if (areEqualPeerDescriptors(peer, this.ownPeerDescriptor!)) {
+            if (areEqualPeerDescriptors(peer, this.localPeerDescriptor!)) {
                 logger.error('own peerdescriptor added to connections in initKBucket')
             }
-            this.connections.set(keyFromPeerDescriptor(peer), remoteDhtNode)
+            this.connections.set(keyFromPeerDescriptor(peer), rpcRemote)
         })
         this.randomPeers = new RandomContactList(selfId, this.config.maxNeighborListSize)
-        this.randomPeers.on('contactRemoved', (removedContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
+        this.randomPeers.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
             this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
-        this.randomPeers.on('newContact', (newContact: RemoteDhtNode, activeContacts: RemoteDhtNode[]) =>
+        this.randomPeers.on('newContact', (newContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
             this.emit('newRandomContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
     }
 
     private onTransportConnected(peerDescriptor: PeerDescriptor): void {
 
-        if (areEqualPeerDescriptors(this.ownPeerDescriptor!, peerDescriptor)) {
+        if (areEqualPeerDescriptors(this.localPeerDescriptor!, peerDescriptor)) {
             logger.error('onTransportConnected() to self')
         }
 
-        const remoteDhtNode = new RemoteDhtNode(
-            this.ownPeerDescriptor!,
+        const rpcRemote = new DhtNodeRpcRemote(
+            this.localPeerDescriptor!,
             peerDescriptor,
-            toProtoRpcClient(new DhtRpcServiceClient(this.rpcCommunicator!.getRpcClientTransport())),
-            this.config.serviceId
+            toProtoRpcClient(new DhtNodeRpcClient(this.rpcCommunicator!.getRpcClientTransport())),
+            this.config.serviceId,
+            this.config.rpcRequestTimeout
         )
-        if (!this.connections.has(PeerID.fromValue(remoteDhtNode.id).toKey())) {
-            this.connections.set(PeerID.fromValue(remoteDhtNode.id).toKey(), remoteDhtNode)
+        if (!this.connections.has(PeerID.fromValue(rpcRemote.id).toKey())) {
+            this.connections.set(PeerID.fromValue(rpcRemote.id).toKey(), rpcRemote)
             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')
         }
-        logger.trace('connected: ' + keyFromPeerDescriptor(peerDescriptor) + ' ' + this.connections.size)
+        logger.trace('connected: ' + getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + this.connections.size)
         this.emit('connected', peerDescriptor)
     }
 
-    private onTransportDisconnected(peerDescriptor: PeerDescriptor, dicsonnectionType: DisconnectionType): void {
-        logger.trace('disconnected: ' + keyFromPeerDescriptor(peerDescriptor))
+    private onTransportDisconnected(peerDescriptor: PeerDescriptor, gracefulLeave: boolean): void {
+        logger.trace('disconnected: ' + getNodeIdFromPeerDescriptor(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(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with type ' + dicsonnectionType)
-                this.removeContact(peerDescriptor, true)
+            if (gracefulLeave === true) {
+                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+                this.removeContact(peerDescriptor)
             } else {
-                logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with type ' + dicsonnectionType)
+                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
             }
         }
 
-        this.emit('disconnected', peerDescriptor, dicsonnectionType)
+        this.emit('disconnected', peerDescriptor, gracefulLeave)
     }
 
-    private bindDefaultServerMethods(): void {
+    private bindRpcLocalMethods(): void {
         if (!this.started || this.stopped) {
             return
         }
-        logger.trace(`Binding default DHT RPC methods`)
+        const dhtNodeRpcLocal = new DhtNodeRpcLocal({
+            bucket: this.bucket!,
+            serviceId: this.config.serviceId,
+            peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
+            addNewContact: (contact: PeerDescriptor) => this.addNewContact(contact),
+            removeContact: (contact: PeerDescriptor) => this.removeContact(contact)
+        })
         this.rpcCommunicator!.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers',
-            (req: ClosestPeersRequest, context) => this.getClosestPeers(req, context))
+            (req: ClosestPeersRequest, context) => dhtNodeRpcLocal.getClosestPeers(req, context))
         this.rpcCommunicator!.registerRpcMethod(PingRequest, PingResponse, 'ping',
-            (req: PingRequest, context) => this.ping(req, context))
+            (req: PingRequest, context) => dhtNodeRpcLocal.ping(req, context))
         this.rpcCommunicator!.registerRpcNotification(LeaveNotice, 'leaveNotice',
-            (req: LeaveNotice, context) => this.leaveNotice(req, context))
+            (req: LeaveNotice, context) => dhtNodeRpcLocal.leaveNotice(req, context))
+        const externalApiRpcLocal = new ExternalApiRpcLocal({
+            startFind: (idToFind: Uint8Array, fetchData: boolean, excludedPeer: PeerDescriptor) => {
+                return this.startFind(idToFind, fetchData, excludedPeer)
+            },
+            storeDataToDht: (key: Uint8Array, data: Any) => this.storeDataToDht(key, data)
+        })
+        this.rpcCommunicator!.registerRpcMethod(
+            ExternalFindDataRequest,
+            ExternalFindDataResponse,
+            'externalFindData', 
+            (req: ExternalFindDataRequest, context: ServerCallContext) => externalApiRpcLocal.externalFindData(req, context),
+            { timeout: 10000 }
+        )
+        this.rpcCommunicator!.registerRpcMethod(
+            ExternalStoreDataRequest,
+            ExternalStoreDataResponse,
+            'externalStoreData',
+            (req: ExternalStoreDataRequest) => externalApiRpcLocal.externalStoreData(req),
+            { timeout: 10000 }
+        )
     }
 
     private isPeerCloserToIdThanSelf(peer1: PeerDescriptor, compareToId: PeerID): boolean {
         const distance1 = this.bucket!.distance(peer1.kademliaId, compareToId.value)
-        const distance2 = this.bucket!.distance(this.ownPeerDescriptor!.kademliaId, compareToId.value)
+        const distance2 = this.bucket!.distance(this.localPeerDescriptor!.kademliaId, compareToId.value)
         return distance1 < distance2
     }
 
     private handleMessage(message: Message): void {
         if (message.serviceId === this.config.serviceId) {
-            logger.trace('callig this.handleMessageFromPeer ' + keyFromPeerDescriptor(message.sourceDescriptor!)
+            logger.trace('callig this.handleMessageFromPeer ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             this.rpcCommunicator?.handleMessageFromPeer(message)
         } else {
-            logger.trace('emit "message" ' + keyFromPeerDescriptor(message.sourceDescriptor!) + ' ' + message.serviceId + ' ' + message.messageId)
+            logger.trace('emit "message" ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
+                + ' ' + message.serviceId + ' ' + message.messageId)
             this.emit('message', message)
         }
     }
 
-    private generatePeerDescriptorCallBack = (connectivityResponse: ConnectivityResponse) => {
+    private generatePeerDescriptorCallBack(connectivityResponse: ConnectivityResponse) {
         if (this.config.peerDescriptor) {
-            this.ownPeerDescriptor = this.config.peerDescriptor
+            this.localPeerDescriptor = this.config.peerDescriptor
         } else {
-            this.ownPeerDescriptor = createPeerDescriptor(connectivityResponse, this.config.peerId)
+            this.localPeerDescriptor = 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((remoteDhtNode: RemoteDhtNode) => remoteDhtNode.getPeerDescriptor())
+        return this.localPeerDescriptor
     }
 
-    private onKBucketPing(oldContacts: RemoteDhtNode[], newContact: RemoteDhtNode): void {
+    private onKBucketPing(oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote): void {
         if (this.stopped) {
             return
         }
-        const sortingList: SortedContactList<RemoteDhtNode> = new SortedContactList(this.getNodeId(), 100)
+        const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList(this.getNodeId(), 100)
         sortingList.addContacts(oldContacts)
         const sortedContacts = sortingList.getAllContacts()
         this.connectionManager?.weakUnlockConnection(sortedContacts[sortedContacts.length - 1].getPeerDescriptor())
@@ -456,16 +480,12 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         this.bucket!.add(newContact)
     }
 
-    private onKBucketRemoved(contact: RemoteDhtNode): void {
+    private onKBucketRemoved(contact: DhtNodeRpcRemote): void {
         if (this.stopped) {
             return
         }
         this.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
-        logger.trace(`Removed contact ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
-        this.emit(
-            'kbucketContactRemoved',
-            contact.getPeerDescriptor()
-        )
+        logger.trace(`Removed contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
         if (this.bucket!.count() === 0
             && !this.peerDiscovery!.isJoinOngoing()
             && this.config.entryPoints
@@ -479,32 +499,22 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         }
     }
 
-    private onKBucketAdded(contact: RemoteDhtNode): void {
+    private onKBucketAdded(contact: DhtNodeRpcRemote): void {
         if (this.stopped) {
             return
         }
-        if (!this.stopped && !contact.getPeerId().equals(this.getNodeId())) {
+        if (!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 ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
-                this.emit(
-                    'newKbucketContact',
-                    contact.getPeerDescriptor(),
-                    this.neighborList!.getClosestContacts(this.config.peerDiscoveryQueryBatchSize).map((peer) => peer.getPeerDescriptor())
-                )
+                logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
             } else {    // open connection by pinging
-                logger.trace('starting ping ' + keyFromPeerDescriptor(contact.getPeerDescriptor()))
+                logger.trace('starting ping ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
                 contact.ping().then((result) => {
                     if (result) {
-                        logger.trace(`Added new contact ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
-                        this.emit(
-                            'newKbucketContact',
-                            contact.getPeerDescriptor(),
-                            this.neighborList!.getClosestContacts(this.config.peerDiscoveryQueryBatchSize).map((peer) => peer.getPeerDescriptor())
-                        )
+                        logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
                     } else {
-                        logger.trace('ping failed ' + keyFromPeerDescriptor(contact.getPeerDescriptor()))
+                        logger.trace('ping failed ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
                         this.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
                         this.removeContact(contact.getPeerDescriptor())
                         this.addClosestContactToBucket()
@@ -529,7 +539,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         }
     }
 
-    private getClosestActiveContactNotInBucket(): RemoteDhtNode | undefined {
+    private getClosestActiveContactNotInBucket(): DhtNodeRpcRemote | undefined {
         for (const contactId of this.neighborList!.getContactIds()) {
             if (!this.bucket!.get(contactId.value) && this.neighborList!.isActive(contactId)) {
                 return this.neighborList!.getContact(contactId).contact
@@ -543,7 +553,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public getNodeId(): PeerID {
-        return peerIdFromPeerDescriptor(this.ownPeerDescriptor!)
+        return peerIdFromPeerDescriptor(this.localPeerDescriptor!)
     }
 
     public getBucketSize(): number {
@@ -554,27 +564,24 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (!this.started || this.stopped) {
             return
         }
-        if (!areEqualPeerDescriptors(contact, this.ownPeerDescriptor!)) {
-            logger.trace(`Adding new contact ${keyFromPeerDescriptor(contact)}`)
-            const remoteDhtNode = new RemoteDhtNode(
-                this.ownPeerDescriptor!,
+        if (!areEqualPeerDescriptors(contact, this.localPeerDescriptor!)) {
+            logger.trace(`Adding new contact ${getNodeIdFromPeerDescriptor(contact)}`)
+            const rpcRemote = new DhtNodeRpcRemote(
+                this.localPeerDescriptor!,
                 contact,
-                toProtoRpcClient(new DhtRpcServiceClient(this.rpcCommunicator!.getRpcClientTransport())),
-                this.config.serviceId
+                toProtoRpcClient(new DhtNodeRpcClient(this.rpcCommunicator!.getRpcClientTransport())),
+                this.config.serviceId,
+                this.config.rpcRequestTimeout
             )
             if (!this.bucket!.get(contact.kademliaId) && !this.neighborList!.getContact(peerIdFromPeerDescriptor(contact))) {
-                this.neighborList!.addContact(remoteDhtNode)
-                if (contact.openInternet) {
-                    this.openInternetPeers!.addContact(remoteDhtNode)
-                }
+                this.neighborList!.addContact(rpcRemote)
                 if (setActive) {
                     const peerId = peerIdFromPeerDescriptor(contact)
                     this.neighborList!.setActive(peerId)
-                    this.openInternetPeers!.setActive(peerId)
                 }
-                this.bucket!.add(remoteDhtNode)
+                this.bucket!.add(rpcRemote)
             } else {
-                this.randomPeers!.addContact(remoteDhtNode)
+                this.randomPeers!.addContact(rpcRemote)
             }
         }
     }
@@ -586,25 +593,22 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         }, 10 * 1000)
     }
 
-    public removeContact(contact: PeerDescriptor, removeFromOpenInternetPeers = false): void {
+    public removeContact(contact: PeerDescriptor): void {
         if (!this.started || this.stopped) {
             return
         }
-        logger.trace(`Removing contact ${keyFromPeerDescriptor(contact)}`)
+        logger.trace(`Removing contact ${getNodeIdFromPeerDescriptor(contact)}`)
         const peerId = peerIdFromPeerDescriptor(contact)
         this.bucket!.remove(peerId.value)
         this.neighborList!.removeContact(peerId)
         this.randomPeers!.removeContact(peerId)
-        if (removeFromOpenInternetPeers) {
-            this.openInternetPeers!.removeContact(peerId)
-        }
     }
 
     public async send(msg: Message): Promise<void> {
         if (!this.started || this.stopped) {
             return
         }
-        const reachableThrough = this.peerDiscovery!.isJoinOngoing() ? this.config.entryPoints || [] : []
+        const reachableThrough = this.peerDiscovery!.isJoinOngoing() ? this.config.entryPoints ?? [] : []
         await this.router!.send(msg, reachableThrough)
     }
 
@@ -617,8 +621,8 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         ))
     }
 
-    public async startRecursiveFind(idToFind: Uint8Array, fetchData?: boolean, excludedPeer?: PeerDescriptor): Promise<RecursiveFindResult> {
-        return this.recursiveFinder!.startRecursiveFind(idToFind, fetchData, excludedPeer)
+    public async startFind(idToFind: Uint8Array, fetchData?: boolean, excludedPeer?: PeerDescriptor): Promise<FindResult> {
+        return this.finder!.startFind(idToFind, fetchData, excludedPeer)
     }
 
     public async storeDataToDht(key: Uint8Array, data: Any): Promise<PeerDescriptor[]> {
@@ -630,7 +634,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     public async storeDataViaPeer(key: Uint8Array, data: Any, peer: PeerDescriptor): Promise<PeerDescriptor[]> {
         const rpcRemote = new ExternalApiRpcRemote(
-            this.ownPeerDescriptor!,
+            this.localPeerDescriptor!,
             peer,
             this.config.serviceId,
             toProtoRpcClient(new ExternalApiRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
@@ -642,7 +646,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         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)
+        const result = await this.finder!.startFind(idToFind, true)
         return result.dataEntries ?? []
     }
 
@@ -654,24 +658,20 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     public async findDataViaPeer(idToFind: Uint8Array, peer: PeerDescriptor): Promise<DataEntry[]> {
         const rpcRemote = new ExternalApiRpcRemote(
-            this.ownPeerDescriptor!,
+            this.localPeerDescriptor!,
             peer,
             this.config.serviceId,
             toProtoRpcClient(new ExternalApiRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
-        return await rpcRemote.findData(idToFind)
-    }
-
-    public getRpcCommunicator(): RoutingRpcCommunicator {
-        return this.rpcCommunicator!
+        return await rpcRemote.externalFindData(idToFind)
     }
 
     public getTransport(): ITransport {
         return this.transport!
     }
 
-    public getPeerDescriptor(): PeerDescriptor {
-        return this.ownPeerDescriptor!
+    public getLocalPeerDescriptor(): PeerDescriptor {
+        return this.localPeerDescriptor!
     }
 
     public getAllConnectionPeerDescriptors(): PeerDescriptor[] {
@@ -679,7 +679,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public getKBucketPeers(): PeerDescriptor[] {
-        return this.bucket!.toArray().map((remoteDhtNode: RemoteDhtNode) => remoteDhtNode.getPeerDescriptor())
+        return this.bucket!.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
     }
 
     public getNumberOfConnections(): number {
@@ -716,53 +716,26 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (this.entryPointDisconnectTimeout) {
             clearTimeout(this.entryPointDisconnectTimeout)
         }
-        this.bucket!.toArray().forEach((remoteDhtNode: RemoteDhtNode) => this.bucket!.remove(remoteDhtNode.id))
+        this.bucket!.toArray().forEach((rpcRemote: DhtNodeRpcRemote) => { 
+            rpcRemote.leaveNotice()
+            this.bucket!.remove(rpcRemote.id)
+        })
         this.bucket!.removeAllListeners()
         this.localDataStore.clear()
         this.neighborList!.stop()
         this.randomPeers!.stop()
-        this.openInternetPeers!.stop()
         this.rpcCommunicator!.stop()
         this.router!.stop()
-        this.recursiveFinder!.stop()
+        this.finder!.stop()
         this.peerDiscovery!.stop()
-        if (this.connectionManager) {
-            await this.connectionManager.stop()
+        if (this.config.transport === undefined) {
+            // if the transport was not given in config, the instance was created in start() and 
+            // this component is responsible for stopping it
+            await this.transport!.stop()
         }
         this.transport = undefined
         this.connectionManager = undefined
         this.connections.clear()
         this.removeAllListeners()
     }
-
-    // IDHTRpcService implementation
-    private async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
-        this.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
-        const response = {
-            peers: this.getClosestPeerDescriptors(request.kademliaId, this.config.peerDiscoveryQueryBatchSize),
-            requestId: request.requestId
-        }
-        return response
-    }
-
-    // IDHTRpcService implementation
-    private async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
-        logger.trace('received ping request: ' + keyFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
-        setImmediate(() => {
-            this.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
-        })
-        const response: PingResponse = {
-            requestId: request.requestId
-        }
-        return response
-    }
-
-    // IDHTRpcService implementation
-    private async leaveNotice(request: LeaveNotice, context: ServerCallContext): Promise<Empty> {
-        // TODO check signature??
-        if (request.serviceId === this.config.serviceId) {
-            this.removeContact((context as DhtCallContext).incomingSourceDescriptor!)
-        }
-        return {}
-    }
 }