@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/dist/src/dht/DhtNode.js

@@ -1,64 +1,53 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DhtNode = exports.createPeerDescriptor = void 0;
-const DhtNodeRpcRemote_1 = require("./DhtNodeRpcRemote");
-const k_bucket_1 = __importDefault(require("k-bucket"));
-const eventemitter3_1 = require("eventemitter3");
-const SortedContactList_1 = require("./contact/SortedContactList");
-const RoutingRpcCommunicator_1 = require("../transport/RoutingRpcCommunicator");
-const PeerID_1 = require("../helpers/PeerID");
-const DhtRpc_1 = require("../proto/packages/dht/protos/DhtRpc");
-const ConnectionManager_1 = require("../connection/ConnectionManager");
-const DhtRpc_client_1 = require("../proto/packages/dht/protos/DhtRpc.client");
+exports.DhtNode = void 0;
 const utils_1 = require("@streamr/utils");
-const proto_rpc_1 = require("@streamr/proto-rpc");
-const RandomContactList_1 = require("./contact/RandomContactList");
-const peerIdFromPeerDescriptor_1 = require("../helpers/peerIdFromPeerDescriptor");
-const Router_1 = require("./routing/Router");
-const Finder_1 = require("./find/Finder");
-const StoreRpcLocal_1 = require("./store/StoreRpcLocal");
-const PeerDiscovery_1 = require("./discovery/PeerDiscovery");
-const LocalDataStore_1 = require("./store/LocalDataStore");
-const ExternalApiRpcRemote_1 = require("./ExternalApiRpcRemote");
-const UUID_1 = require("../helpers/UUID");
-const isBrowserEnvironment_1 = require("../helpers/browser/isBrowserEnvironment");
+const eventemitter3_1 = require("eventemitter3");
 const lodash_1 = require("lodash");
+const ConnectionManager_1 = require("../connection/ConnectionManager");
 const ConnectorFacade_1 = require("../connection/ConnectorFacade");
+const isBrowserEnvironment_1 = require("../helpers/browser/isBrowserEnvironment");
+const identifiers_1 = require("../identifiers");
+const DhtRpc_1 = require("../proto/packages/dht/protos/DhtRpc");
+const DhtRpc_client_1 = require("../proto/packages/dht/protos/DhtRpc.client");
+const RoutingRpcCommunicator_1 = require("../transport/RoutingRpcCommunicator");
 const DhtNodeRpcLocal_1 = require("./DhtNodeRpcLocal");
+const DhtNodeRpcRemote_1 = require("./DhtNodeRpcRemote");
 const ExternalApiRpcLocal_1 = require("./ExternalApiRpcLocal");
+const ExternalApiRpcRemote_1 = require("./ExternalApiRpcRemote");
+const PeerManager_1 = require("./PeerManager");
+const PeerDiscovery_1 = require("./discovery/PeerDiscovery");
+const RecursiveOperationManager_1 = require("./recursive-operation/RecursiveOperationManager");
+const Router_1 = require("./routing/Router");
+const LocalDataStore_1 = require("./store/LocalDataStore");
+const StoreManager_1 = require("./store/StoreManager");
+const StoreRpcRemote_1 = require("./store/StoreRpcRemote");
+const createPeerDescriptor_1 = require("../helpers/createPeerDescriptor");
+const cdn_location_1 = require("@streamr/cdn-location");
 const logger = new utils_1.Logger(module);
-const createPeerDescriptor = (msg, peerId) => {
-    let kademliaId;
-    if (msg) {
-        kademliaId = peerId ? (0, utils_1.hexToBinary)(peerId) : PeerID_1.PeerID.fromIp(msg.host).value;
-    }
-    else {
-        kademliaId = (0, utils_1.hexToBinary)(peerId);
-    }
-    const nodeType = (0, isBrowserEnvironment_1.isBrowserEnvironment)() ? DhtRpc_1.NodeType.BROWSER : DhtRpc_1.NodeType.NODEJS;
-    const ret = { kademliaId, type: nodeType };
-    if (msg && msg.websocket) {
-        ret.websocket = { host: msg.websocket.host, port: msg.websocket.port, tls: msg.websocket.tls };
-    }
-    return ret;
-};
-exports.createPeerDescriptor = createPeerDescriptor;
 class DhtNode extends eventemitter3_1.EventEmitter {
+    config;
+    rpcCommunicator;
+    transport;
+    localPeerDescriptor;
+    router;
+    storeManager;
+    localDataStore;
+    recursiveOperationManager;
+    peerDiscovery;
+    peerManager;
+    connectionManager;
+    region;
+    started = false;
+    abortController = new AbortController();
     constructor(conf) {
         super();
-        this.connections = new Map();
-        this.localDataStore = new LocalDataStore_1.LocalDataStore();
-        this.started = false;
-        this.stopped = false;
         this.config = (0, utils_1.merge)({
             serviceId: 'layer0',
             joinParallelism: 3,
             maxNeighborListSize: 200,
             numberOfNodesPerKBucket: 8,
-            joinNoProgressLimit: 4,
+            joinNoProgressLimit: 5,
             dhtJoinTimeout: 60000,
             peerDiscoveryQueryBatchSize: 5,
             maxConnections: 80,
@@ -66,13 +55,30 @@ class DhtNode extends eventemitter3_1.EventEmitter {
             storeMaxTtl: 60000,
             networkConnectivityTimeout: 10000,
             storageRedundancyFactor: 5,
-            metricsContext: new utils_1.MetricsContext(),
-            peerId: new UUID_1.UUID().toHex()
+            metricsContext: new utils_1.MetricsContext()
         }, conf);
+        this.validateConfig();
+        this.localDataStore = new LocalDataStore_1.LocalDataStore(this.config.storeMaxTtl);
         this.send = this.send.bind(this);
     }
+    validateConfig() {
+        const expectedNodeIdLength = identifiers_1.KADEMLIA_ID_LENGTH_IN_BYTES * 2;
+        if (this.config.nodeId !== undefined) {
+            if (!/^[0-9a-fA-F]+$/.test(this.config.nodeId)) {
+                throw new Error('Invalid nodeId, the nodeId should be a hex string');
+            }
+            else if (this.config.nodeId.length !== expectedNodeIdLength) {
+                throw new Error(`Invalid nodeId, the length of the nodeId should be ${expectedNodeIdLength}`);
+            }
+        }
+        if (this.config.peerDescriptor !== undefined) {
+            if (this.config.peerDescriptor.nodeId.length !== identifiers_1.KADEMLIA_ID_LENGTH_IN_BYTES) {
+                throw new Error(`Invalid peerDescriptor, the length of the nodeId should be ${identifiers_1.KADEMLIA_ID_LENGTH_IN_BYTES} bytes`);
+            }
+        }
+    }
     async start() {
-        if (this.started || this.stopped) {
+        if (this.started || this.abortController.signal.aborted) {
             return;
         }
         logger.trace(`Starting new Streamr Network DHT Node with serviceId ${this.config.serviceId}`);
@@ -83,6 +89,15 @@ class DhtNode extends eventemitter3_1.EventEmitter {
                 this.config.peerDescriptor.websocket = undefined;
             }
         }
+        if (this.region !== undefined) {
+            this.region = this.config.region;
+        }
+        else if (this.config.peerDescriptor?.region !== undefined) {
+            this.region = this.config.peerDescriptor.region;
+        }
+        else {
+            this.region = await (0, cdn_location_1.getLocalRegion)();
+        }
         // If transport is given, do not create a ConnectionManager
         if (this.config.transport) {
             this.transport = this.config.transport;
@@ -132,338 +147,234 @@ class DhtNode extends eventemitter3_1.EventEmitter {
             this.transport = connectionManager;
         }
         this.rpcCommunicator = new RoutingRpcCommunicator_1.RoutingRpcCommunicator(this.config.serviceId, this.transport.send, { rpcRequestTimeout: this.config.rpcRequestTimeout });
-        this.transport.on('message', (message) => this.handleMessage(message));
-        this.initKBuckets((0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(this.localPeerDescriptor));
+        this.transport.on('message', (message) => this.handleMessageFromTransport(message));
+        this.initPeerManager();
         this.peerDiscovery = new PeerDiscovery_1.PeerDiscovery({
-            rpcCommunicator: this.rpcCommunicator,
             localPeerDescriptor: this.localPeerDescriptor,
-            bucket: this.bucket,
-            neighborList: this.neighborList,
             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,
-            rpcRequestTimeout: this.config.rpcRequestTimeout
+            peerManager: this.peerManager
         });
         this.router = new Router_1.Router({
             rpcCommunicator: this.rpcCommunicator,
-            connections: this.connections,
+            connections: this.peerManager.connections,
             localPeerDescriptor: this.localPeerDescriptor,
-            addContact: this.addNewContact.bind(this),
-            serviceId: this.config.serviceId,
-            connectionManager: this.connectionManager
+            addContact: (contact, setActive) => this.peerManager.addContact([contact], setActive),
+            handleMessage: (message) => this.handleMessageFromRouter(message),
         });
-        this.finder = new Finder_1.Finder({
+        this.recursiveOperationManager = new RecursiveOperationManager_1.RecursiveOperationManager({
             rpcCommunicator: this.rpcCommunicator,
             router: this.router,
             sessionTransport: this,
-            connections: this.connections,
+            connections: this.peerManager.connections,
             localPeerDescriptor: this.localPeerDescriptor,
             serviceId: this.config.serviceId,
-            addContact: this.addNewContact.bind(this),
-            isPeerCloserToIdThanSelf: this.isPeerCloserToIdThanSelf.bind(this),
+            addContact: (contact) => this.peerManager.addContact([contact]),
             localDataStore: this.localDataStore
         });
-        this.storeRpcLocal = new StoreRpcLocal_1.StoreRpcLocal({
+        this.storeManager = new StoreManager_1.StoreManager({
             rpcCommunicator: this.rpcCommunicator,
-            finder: this.finder,
+            recursiveOperationManager: this.recursiveOperationManager,
             localPeerDescriptor: this.localPeerDescriptor,
             serviceId: this.config.serviceId,
             highestTtl: this.config.storeHighestTtl,
-            maxTtl: this.config.storeMaxTtl,
             redundancyFactor: this.config.storageRedundancyFactor,
             localDataStore: this.localDataStore,
-            dhtNodeEmitter: this,
-            getNodesClosestToIdFromBucket: (id, n) => {
-                return this.bucket.closest(id, n);
+            getClosestNeighborsTo: (key, n) => {
+                return this.peerManager.getClosestNeighborsTo(key, n).map((n) => n.getPeerDescriptor());
             },
-            rpcRequestTimeout: this.config.rpcRequestTimeout
+            createRpcRemote: (contact) => {
+                return new StoreRpcRemote_1.StoreRpcRemote(this.localPeerDescriptor, contact, this.rpcCommunicator, DhtRpc_client_1.StoreRpcClient, this.config.rpcRequestTimeout);
+            }
+        });
+        this.on('contactAdded', (peerDescriptor) => {
+            this.storeManager.onContactAdded(peerDescriptor);
         });
         this.bindRpcLocalMethods();
-        if (this.connectionManager && this.config.entryPoints && this.config.entryPoints.length > 0
-            && !(0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(this.config.entryPoints[0], this.localPeerDescriptor)) {
-            this.connectToEntryPoint(this.config.entryPoints[0]);
-        }
     }
-    initKBuckets(selfId) {
-        this.bucket = new k_bucket_1.default({
-            localNodeId: selfId.value,
+    initPeerManager() {
+        this.peerManager = new PeerManager_1.PeerManager({
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
-            numberOfNodesToPing: this.config.numberOfNodesPerKBucket
+            maxContactListSize: this.config.maxNeighborListSize,
+            localNodeId: this.getNodeId(),
+            localPeerDescriptor: this.localPeerDescriptor,
+            connectionManager: this.connectionManager,
+            peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
+            isLayer0: (this.connectionManager !== undefined),
+            createDhtNodeRpcRemote: (peerDescriptor) => this.createDhtNodeRpcRemote(peerDescriptor),
+            lockId: this.config.serviceId
+        });
+        this.peerManager.on('contactRemoved', (peerDescriptor, activeContacts) => {
+            this.emit('contactRemoved', peerDescriptor, activeContacts);
         });
-        this.bucket.on('ping', (oldContacts, newContact) => this.onKBucketPing(oldContacts, newContact));
-        this.bucket.on('removed', (contact) => this.onKBucketRemoved(contact));
-        this.bucket.on('added', (contact) => this.onKBucketAdded(contact));
-        this.bucket.on('updated', () => {
-            // TODO: Update contact info to the connection manager and reconnect
+        this.peerManager.on('contactAdded', (peerDescriptor, activeContacts) => this.emit('contactAdded', peerDescriptor, activeContacts));
+        this.peerManager.on('randomContactRemoved', (peerDescriptor, activeContacts) => this.emit('randomContactRemoved', peerDescriptor, activeContacts));
+        this.peerManager.on('randomContactAdded', (peerDescriptor, activeContacts) => this.emit('randomContactAdded', peerDescriptor, activeContacts));
+        this.peerManager.on('ringContactRemoved', (peerDescriptor, activeContacts) => {
+            this.emit('ringContactRemoved', peerDescriptor, activeContacts);
         });
-        this.neighborList = new SortedContactList_1.SortedContactList(selfId, this.config.maxNeighborListSize);
-        this.neighborList.on('contactRemoved', (removedContact, activeContacts) => {
-            if (this.stopped) {
-                return;
+        this.peerManager.on('ringContactAdded', (peerDescriptor, activeContacts) => {
+            this.emit('ringContactAdded', peerDescriptor, activeContacts);
+        });
+        this.peerManager.on('kBucketEmpty', () => {
+            if (!this.peerDiscovery.isJoinOngoing()
+                && this.config.entryPoints
+                && this.config.entryPoints.length > 0) {
+                setImmediate(async () => {
+                    // TODO should we catch possible promise rejection?
+                    await Promise.all(this.config.entryPoints.map((entryPoint) => this.peerDiscovery.rejoinDht(entryPoint)));
+                });
             }
-            this.emit('contactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()));
-            this.randomPeers.addContact(new DhtNodeRpcRemote_1.DhtNodeRpcRemote(this.localPeerDescriptor, removedContact.getPeerDescriptor(), (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.DhtNodeRpcClient(this.rpcCommunicator.getRpcClientTransport())), this.config.serviceId, this.config.rpcRequestTimeout));
         });
-        this.neighborList.on('newContact', (newContact, activeContacts) => this.emit('newContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor())));
-        this.transport.on('connected', (peerDescriptor) => this.onTransportConnected(peerDescriptor));
+        this.transport.on('connected', (peerDescriptor) => {
+            this.peerManager.onContactConnected(peerDescriptor);
+            this.router.onNodeConnected(peerDescriptor);
+            this.emit('connected', peerDescriptor);
+        });
         this.transport.on('disconnected', (peerDescriptor, gracefulLeave) => {
-            this.onTransportDisconnected(peerDescriptor, gracefulLeave);
+            this.peerManager.onContactDisconnected((0, identifiers_1.getNodeIdFromPeerDescriptor)(peerDescriptor), gracefulLeave);
+            this.router.onNodeDisconnected(peerDescriptor);
+            this.emit('disconnected', peerDescriptor, gracefulLeave);
         });
-        this.transport.getAllConnectionPeerDescriptors().forEach((peer) => {
-            const rpcRemote = new DhtNodeRpcRemote_1.DhtNodeRpcRemote(this.localPeerDescriptor, peer, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.DhtNodeRpcClient(this.rpcCommunicator.getRpcClientTransport())), this.config.serviceId, this.config.rpcRequestTimeout);
-            if ((0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(peer, this.localPeerDescriptor)) {
-                logger.error('own peerdescriptor added to connections in initKBucket');
-            }
-            this.connections.set((0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peer), rpcRemote);
+        this.transport.getConnections().forEach((peer) => {
+            this.peerManager.onContactConnected(peer);
         });
-        this.randomPeers = new RandomContactList_1.RandomContactList(selfId, this.config.maxNeighborListSize);
-        this.randomPeers.on('contactRemoved', (removedContact, activeContacts) => this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor())));
-        this.randomPeers.on('newContact', (newContact, activeContacts) => this.emit('newRandomContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor())));
-    }
-    onTransportConnected(peerDescriptor) {
-        if ((0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(this.localPeerDescriptor, peerDescriptor)) {
-            logger.error('onTransportConnected() to self');
-        }
-        const rpcRemote = new DhtNodeRpcRemote_1.DhtNodeRpcRemote(this.localPeerDescriptor, peerDescriptor, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.DhtNodeRpcClient(this.rpcCommunicator.getRpcClientTransport())), this.config.serviceId, this.config.rpcRequestTimeout);
-        if (!this.connections.has(PeerID_1.PeerID.fromValue(rpcRemote.id).toKey())) {
-            this.connections.set(PeerID_1.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: ' + (0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(peerDescriptor) + ' ' + this.connections.size);
-        this.emit('connected', peerDescriptor);
-    }
-    onTransportDisconnected(peerDescriptor, gracefulLeave) {
-        logger.trace('disconnected: ' + (0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(peerDescriptor));
-        this.connections.delete((0, peerIdFromPeerDescriptor_1.keyFromPeerDescriptor)(peerDescriptor));
-        // only remove from bucket if we are on layer 0
-        if (this.connectionManager) {
-            this.bucket.remove(peerDescriptor.kademliaId);
-            if (gracefulLeave === true) {
-                logger.trace((0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave);
-                this.removeContact(peerDescriptor);
-            }
-            else {
-                logger.trace((0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave);
-            }
-        }
-        this.emit('disconnected', peerDescriptor, gracefulLeave);
     }
     bindRpcLocalMethods() {
-        if (!this.started || this.stopped) {
+        if (!this.started || this.abortController.signal.aborted) {
             return;
         }
         const dhtNodeRpcLocal = new DhtNodeRpcLocal_1.DhtNodeRpcLocal({
-            bucket: this.bucket,
-            serviceId: this.config.serviceId,
             peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
-            addNewContact: (contact) => this.addNewContact(contact),
-            removeContact: (contact) => this.removeContact(contact)
+            getClosestPeersTo: (nodeId, limit) => {
+                return this.peerManager.getClosestNeighborsTo(nodeId, limit)
+                    .map((dhtPeer) => dhtPeer.getPeerDescriptor());
+            },
+            getClosestRingPeersTo: (ringIdRaw, limit) => {
+                return this.getClosestRingContactsTo(ringIdRaw, limit);
+            },
+            addContact: (contact) => this.peerManager.addContact([contact]),
+            removeContact: (nodeId) => this.removeContact(nodeId)
         });
         this.rpcCommunicator.registerRpcMethod(DhtRpc_1.ClosestPeersRequest, DhtRpc_1.ClosestPeersResponse, 'getClosestPeers', (req, context) => dhtNodeRpcLocal.getClosestPeers(req, context));
+        this.rpcCommunicator.registerRpcMethod(DhtRpc_1.ClosestRingPeersRequest, DhtRpc_1.ClosestRingPeersResponse, 'getClosestRingPeers', (req, context) => dhtNodeRpcLocal.getClosestRingPeers(req, context));
         this.rpcCommunicator.registerRpcMethod(DhtRpc_1.PingRequest, DhtRpc_1.PingResponse, 'ping', (req, context) => dhtNodeRpcLocal.ping(req, context));
-        this.rpcCommunicator.registerRpcNotification(DhtRpc_1.LeaveNotice, 'leaveNotice', (req, context) => dhtNodeRpcLocal.leaveNotice(req, context));
+        this.rpcCommunicator.registerRpcNotification(DhtRpc_1.LeaveNotice, 'leaveNotice', (_req, context) => dhtNodeRpcLocal.leaveNotice(context));
         const externalApiRpcLocal = new ExternalApiRpcLocal_1.ExternalApiRpcLocal({
-            startFind: (idToFind, fetchData, excludedPeer) => {
-                return this.startFind(idToFind, fetchData, excludedPeer);
+            executeRecursiveOperation: (key, operation, excludedPeer) => {
+                return this.recursiveOperationManager.execute(key, operation, excludedPeer);
             },
-            storeDataToDht: (key, data) => this.storeDataToDht(key, data)
+            storeDataToDht: (key, data, creator) => this.storeDataToDht(key, data, creator)
         });
-        this.rpcCommunicator.registerRpcMethod(DhtRpc_1.ExternalFindDataRequest, DhtRpc_1.ExternalFindDataResponse, 'externalFindData', (req, context) => externalApiRpcLocal.externalFindData(req, context), { timeout: 10000 });
-        this.rpcCommunicator.registerRpcMethod(DhtRpc_1.ExternalStoreDataRequest, DhtRpc_1.ExternalStoreDataResponse, 'externalStoreData', (req) => externalApiRpcLocal.externalStoreData(req), { timeout: 10000 });
+        this.rpcCommunicator.registerRpcMethod(DhtRpc_1.ExternalFetchDataRequest, DhtRpc_1.ExternalFetchDataResponse, 'externalFetchData', (req, context) => externalApiRpcLocal.externalFetchData(req, context), { timeout: 10000 } // TODO use config option or named constant?
+        );
+        this.rpcCommunicator.registerRpcMethod(DhtRpc_1.ExternalStoreDataRequest, DhtRpc_1.ExternalStoreDataResponse, 'externalStoreData', (req, context) => externalApiRpcLocal.externalStoreData(req, context), { timeout: 10000 } // TODO use config option or named constant?
+        );
     }
-    isPeerCloserToIdThanSelf(peer1, compareToId) {
-        const distance1 = this.bucket.distance(peer1.kademliaId, compareToId.value);
-        const distance2 = this.bucket.distance(this.localPeerDescriptor.kademliaId, compareToId.value);
-        return distance1 < distance2;
+    handleMessageFromTransport(message) {
+        if (message.serviceId === this.config.serviceId) {
+            this.rpcCommunicator?.handleMessageFromPeer(message);
+        }
     }
-    handleMessage(message) {
+    handleMessageFromRouter(message) {
         if (message.serviceId === this.config.serviceId) {
-            logger.trace('callig this.handleMessageFromPeer ' + (0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(message.sourceDescriptor)
-                + ' ' + message.serviceId + ' ' + message.messageId);
             this.rpcCommunicator?.handleMessageFromPeer(message);
         }
+        else if (this.connectionManager?.handleIncomingMessage(message)) {
+            // message was handled by connectionManager
+        }
         else {
-            logger.trace('emit "message" ' + (0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(message.sourceDescriptor)
-                + ' ' + message.serviceId + ' ' + message.messageId);
             this.emit('message', message);
         }
     }
     generatePeerDescriptorCallBack(connectivityResponse) {
-        if (this.config.peerDescriptor) {
+        if (this.config.peerDescriptor !== undefined) {
             this.localPeerDescriptor = this.config.peerDescriptor;
         }
         else {
-            this.localPeerDescriptor = (0, exports.createPeerDescriptor)(connectivityResponse, this.config.peerId);
+            this.localPeerDescriptor = (0, createPeerDescriptor_1.createPeerDescriptor)(connectivityResponse, this.region, this.config.nodeId);
         }
         return this.localPeerDescriptor;
     }
-    onKBucketPing(oldContacts, newContact) {
-        if (this.stopped) {
-            return;
-        }
-        const sortingList = new SortedContactList_1.SortedContactList(this.getNodeId(), 100);
-        sortingList.addContacts(oldContacts);
-        const sortedContacts = sortingList.getAllContacts();
-        this.connectionManager?.weakUnlockConnection(sortedContacts[sortedContacts.length - 1].getPeerDescriptor());
-        this.bucket?.remove(sortedContacts[sortedContacts.length - 1].getPeerId().value);
-        this.bucket.add(newContact);
-    }
-    onKBucketRemoved(contact) {
-        if (this.stopped) {
-            return;
-        }
-        this.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor());
-        logger.trace(`Removed contact ${(0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(contact.getPeerDescriptor())}`);
-        if (this.bucket.count() === 0
-            && !this.peerDiscovery.isJoinOngoing()
-            && this.config.entryPoints
-            && this.config.entryPoints.length > 0) {
-            setImmediate(async () => {
-                await Promise.all(this.config.entryPoints.map((entryPoint) => this.peerDiscovery.rejoinDht(entryPoint)));
-            });
-        }
+    getClosestContacts(limit) {
+        return this.peerManager.getClosestContactsTo(this.getNodeId(), limit).map((peer) => peer.getPeerDescriptor());
     }
-    onKBucketAdded(contact) {
-        if (this.stopped) {
-            return;
-        }
-        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 ${(0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(contact.getPeerDescriptor())}`);
-            }
-            else { // open connection by pinging
-                logger.trace('starting ping ' + (0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(contact.getPeerDescriptor()));
-                contact.ping().then((result) => {
-                    if (result) {
-                        logger.trace(`Added new contact ${(0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(contact.getPeerDescriptor())}`);
-                    }
-                    else {
-                        logger.trace('ping failed ' + (0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(contact.getPeerDescriptor()));
-                        this.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor());
-                        this.removeContact(contact.getPeerDescriptor());
-                        this.addClosestContactToBucket();
-                    }
-                    return;
-                }).catch((_e) => {
-                    this.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor());
-                    this.removeContact(contact.getPeerDescriptor());
-                    this.addClosestContactToBucket();
-                });
-            }
-        }
-    }
-    addClosestContactToBucket() {
-        if (!this.started || this.stopped) {
-            return;
-        }
-        const closest = this.getClosestActiveContactNotInBucket();
-        if (closest) {
-            this.addNewContact(closest.getPeerDescriptor());
-        }
-    }
-    getClosestActiveContactNotInBucket() {
-        for (const contactId of this.neighborList.getContactIds()) {
-            if (!this.bucket.get(contactId.value) && this.neighborList.isActive(contactId)) {
-                return this.neighborList.getContact(contactId).contact;
-            }
-        }
-        return undefined;
-    }
-    getClosestContacts(maxCount) {
-        return this.neighborList.getClosestContacts(maxCount).map((c) => c.getPeerDescriptor());
+    getClosestRingContactsTo(ringIdRaw, limit) {
+        const closest = this.peerManager.getClosestRingContactsTo(ringIdRaw, limit);
+        return {
+            left: closest.left.map((dhtPeer) => dhtPeer.getPeerDescriptor()),
+            right: closest.right.map((dhtPeer) => dhtPeer.getPeerDescriptor())
+        };
     }
     getNodeId() {
-        return (0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(this.localPeerDescriptor);
-    }
-    getBucketSize() {
-        return this.bucket.count();
-    }
-    addNewContact(contact, setActive = false) {
-        if (!this.started || this.stopped) {
-            return;
-        }
-        if (!(0, peerIdFromPeerDescriptor_1.areEqualPeerDescriptors)(contact, this.localPeerDescriptor)) {
-            logger.trace(`Adding new contact ${(0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(contact)}`);
-            const rpcRemote = new DhtNodeRpcRemote_1.DhtNodeRpcRemote(this.localPeerDescriptor, contact, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.DhtNodeRpcClient(this.rpcCommunicator.getRpcClientTransport())), this.config.serviceId, this.config.rpcRequestTimeout);
-            if (!this.bucket.get(contact.kademliaId) && !this.neighborList.getContact((0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(contact))) {
-                this.neighborList.addContact(rpcRemote);
-                if (setActive) {
-                    const peerId = (0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(contact);
-                    this.neighborList.setActive(peerId);
-                }
-                this.bucket.add(rpcRemote);
-            }
-            else {
-                this.randomPeers.addContact(rpcRemote);
-            }
-        }
+        return (0, identifiers_1.getNodeIdFromPeerDescriptor)(this.localPeerDescriptor);
     }
-    connectToEntryPoint(entryPoint) {
-        this.connectionManager.lockConnection(entryPoint, 'temporary-layer0-connection');
-        this.entryPointDisconnectTimeout = setTimeout(() => {
-            this.connectionManager.unlockConnection(entryPoint, 'temporary-layer0-connection');
-        }, 10 * 1000);
+    getNeighborCount() {
+        return this.peerManager.getNeighborCount();
     }
-    removeContact(contact) {
-        if (!this.started || this.stopped) {
+    removeContact(nodeId) {
+        if (!this.started) { // the stopped state is checked in PeerManager
             return;
         }
-        logger.trace(`Removing contact ${(0, peerIdFromPeerDescriptor_1.getNodeIdFromPeerDescriptor)(contact)}`);
-        const peerId = (0, peerIdFromPeerDescriptor_1.peerIdFromPeerDescriptor)(contact);
-        this.bucket.remove(peerId.value);
-        this.neighborList.removeContact(peerId);
-        this.randomPeers.removeContact(peerId);
+        this.peerManager.removeContact(nodeId);
     }
     async send(msg) {
-        if (!this.started || this.stopped) {
+        if (!this.started || this.abortController.signal.aborted) {
             return;
         }
-        const reachableThrough = this.peerDiscovery.isJoinOngoing() ? this.config.entryPoints ?? [] : [];
-        await this.router.send(msg, reachableThrough);
+        const reachableThrough = this.peerDiscovery.isJoinOngoing() ? this.getConnectedEntryPoints() : [];
+        this.router.send(msg, reachableThrough);
+    }
+    getConnectedEntryPoints() {
+        return this.config.entryPoints !== undefined ? this.config.entryPoints.filter((entryPoint) => this.peerManager.connections.has((0, identifiers_1.getNodeIdFromPeerDescriptor)(entryPoint))) : [];
     }
-    async joinDht(entryPointDescriptors, doAdditionalRandomPeerDiscovery, retry) {
+    async joinDht(entryPointDescriptors, doAdditionalDistantPeerDiscovery, retry) {
         if (!this.started) {
             throw new Error('Cannot join DHT before calling start() on DhtNode');
         }
-        await Promise.all(entryPointDescriptors.map((entryPoint) => this.peerDiscovery.joinDht(entryPoint, doAdditionalRandomPeerDiscovery, retry)));
+        await this.peerDiscovery.joinDht(entryPointDescriptors, doAdditionalDistantPeerDiscovery, retry);
     }
-    async startFind(idToFind, fetchData, excludedPeer) {
-        return this.finder.startFind(idToFind, fetchData, excludedPeer);
+    async joinRing() {
+        if (!this.started) {
+            throw new Error('Cannot join ring before calling start() on DhtNode');
+        }
+        await this.peerDiscovery.joinRing();
     }
-    async storeDataToDht(key, data) {
-        if (this.peerDiscovery.isJoinOngoing() && this.config.entryPoints && this.config.entryPoints.length > 0) {
-            return this.storeDataViaPeer(key, data, (0, lodash_1.sample)(this.config.entryPoints));
+    async storeDataToDht(key, data, creator) {
+        const connectedEntryPoints = this.getConnectedEntryPoints();
+        if (this.peerDiscovery.isJoinOngoing() && connectedEntryPoints.length > 0) {
+            return this.storeDataToDhtViaPeer(key, data, (0, lodash_1.sample)(connectedEntryPoints));
         }
-        return this.storeRpcLocal.storeDataToDht(key, data);
+        return this.storeManager.storeDataToDht(key, data, creator ?? this.getNodeId());
     }
-    async storeDataViaPeer(key, data, peer) {
-        const rpcRemote = new ExternalApiRpcRemote_1.ExternalApiRpcRemote(this.localPeerDescriptor, peer, this.config.serviceId, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.ExternalApiRpcClient(this.rpcCommunicator.getRpcClientTransport())));
+    async storeDataToDhtViaPeer(key, data, peer) {
+        const rpcRemote = new ExternalApiRpcRemote_1.ExternalApiRpcRemote(this.localPeerDescriptor, peer, this.rpcCommunicator, DhtRpc_client_1.ExternalApiRpcClient);
         return await rpcRemote.storeData(key, data);
     }
-    async getDataFromDht(idToFind) {
-        if (this.peerDiscovery.isJoinOngoing() && this.config.entryPoints && this.config.entryPoints.length > 0) {
-            return this.findDataViaPeer(idToFind, (0, lodash_1.sample)(this.config.entryPoints));
+    async fetchDataFromDht(key) {
+        const connectedEntryPoints = this.getConnectedEntryPoints();
+        if (this.peerDiscovery.isJoinOngoing() && connectedEntryPoints.length > 0) {
+            return this.fetchDataFromDhtViaPeer(key, (0, lodash_1.sample)(connectedEntryPoints));
         }
-        const result = await this.finder.startFind(idToFind, true);
-        return result.dataEntries ?? [];
+        const result = await this.recursiveOperationManager.execute(key, DhtRpc_1.RecursiveOperation.FETCH_DATA);
+        return result.dataEntries ?? []; // TODO is this fallback needed?
+    }
+    async fetchDataFromDhtViaPeer(key, peer) {
+        const rpcRemote = new ExternalApiRpcRemote_1.ExternalApiRpcRemote(this.localPeerDescriptor, peer, this.rpcCommunicator, DhtRpc_client_1.ExternalApiRpcClient);
+        return await rpcRemote.externalFetchData(key);
     }
-    async deleteDataFromDht(idToDelete) {
-        if (!this.stopped) {
-            return this.storeRpcLocal.deleteDataFromDht(idToDelete);
+    async deleteDataFromDht(key, waitForCompletion) {
+        if (!this.abortController.signal.aborted) {
+            await this.recursiveOperationManager.execute(key, DhtRpc_1.RecursiveOperation.DELETE_DATA, undefined, waitForCompletion);
         }
     }
-    async findDataViaPeer(idToFind, peer) {
-        const rpcRemote = new ExternalApiRpcRemote_1.ExternalApiRpcRemote(this.localPeerDescriptor, peer, this.config.serviceId, (0, proto_rpc_1.toProtoRpcClient)(new DhtRpc_client_1.ExternalApiRpcClient(this.rpcCommunicator.getRpcClientTransport())));
-        return await rpcRemote.externalFindData(idToFind);
+    async findClosestNodesFromDht(key) {
+        const result = await this.recursiveOperationManager.execute(key, DhtRpc_1.RecursiveOperation.FIND_CLOSEST_NODES);
+        return result.closestNodes;
     }
     getTransport() {
         return this.transport;
@@ -471,61 +382,62 @@ class DhtNode extends eventemitter3_1.EventEmitter {
     getLocalPeerDescriptor() {
         return this.localPeerDescriptor;
     }
-    getAllConnectionPeerDescriptors() {
-        return Array.from(this.connections.values()).map((peer) => peer.getPeerDescriptor());
+    getConnections() {
+        return Array.from(this.peerManager.connections.values()).map((peer) => peer.getPeerDescriptor());
     }
-    getKBucketPeers() {
-        return this.bucket.toArray().map((rpcRemote) => rpcRemote.getPeerDescriptor());
+    getNeighbors() {
+        return this.started ? this.peerManager.getNeighbors() : [];
     }
-    getNumberOfConnections() {
-        return this.connections.size;
+    getConnectionCount() {
+        return this.peerManager.getConnectionCount();
     }
-    getNumberOfLocalLockedConnections() {
-        return this.connectionManager.getNumberOfLocalLockedConnections();
+    getLocalLockedConnectionCount() {
+        return this.connectionManager.getLocalLockedConnectionCount();
     }
-    getNumberOfRemoteLockedConnections() {
-        return this.connectionManager.getNumberOfRemoteLockedConnections();
+    getRemoteLockedConnectionCount() {
+        return this.connectionManager.getRemoteLockedConnectionCount();
     }
-    getNumberOfWeakLockedConnections() {
-        return this.connectionManager.getNumberOfWeakLockedConnections();
+    getWeakLockedConnectionCount() {
+        return this.connectionManager.getWeakLockedConnectionCount();
     }
     async waitForNetworkConnectivity() {
-        await (0, utils_1.waitForCondition)(() => this.connections.size > 0, this.config.networkConnectivityTimeout);
+        await (0, utils_1.waitForCondition)(() => {
+            if (!this.peerManager) {
+                return false;
+            }
+            else {
+                return (this.peerManager.getConnectionCount() > 0);
+            }
+        }, this.config.networkConnectivityTimeout, 100, this.abortController.signal);
     }
     hasJoined() {
         return this.peerDiscovery.isJoinCalled();
     }
     async stop() {
-        if (this.stopped || !this.started) {
+        if (this.abortController.signal.aborted || !this.started) {
             return;
         }
         logger.trace('stop()');
-        this.stopped = true;
-        if (this.entryPointDisconnectTimeout) {
-            clearTimeout(this.entryPointDisconnectTimeout);
-        }
-        this.bucket.toArray().forEach((rpcRemote) => {
-            rpcRemote.leaveNotice();
-            this.bucket.remove(rpcRemote.id);
-        });
-        this.bucket.removeAllListeners();
+        this.abortController.abort();
+        await this.storeManager.destroy();
         this.localDataStore.clear();
-        this.neighborList.stop();
-        this.randomPeers.stop();
+        this.peerManager?.stop();
         this.rpcCommunicator.stop();
         this.router.stop();
-        this.finder.stop();
+        this.recursiveOperationManager.stop();
         this.peerDiscovery.stop();
         if (this.config.transport === undefined) {
-            // if the transport was not given in config, the instance was created in start() and 
+            // 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();
     }
+    createDhtNodeRpcRemote(peerDescriptor) {
+        return new DhtNodeRpcRemote_1.DhtNodeRpcRemote(this.localPeerDescriptor, peerDescriptor, this.config.serviceId, this.rpcCommunicator, this.config.rpcRequestTimeout);
+    }
 }
 exports.DhtNode = DhtNode;
 //# sourceMappingURL=DhtNode.js.map