@streamr/dht 100.0.0-testnet-three.6 → 100.0.0

package/src/dht/DhtNode.ts

@@ -17,10 +17,12 @@ import { Any } from '../proto/google/protobuf/any'
 import {
     ClosestPeersRequest,
     ClosestPeersResponse,
+    ClosestRingPeersRequest,
+    ClosestRingPeersResponse,
     ConnectivityResponse,
     DataEntry,
-    ExternalFindDataRequest,
-    ExternalFindDataResponse,
+    ExternalFetchDataRequest,
+    ExternalFetchDataResponse,
     ExternalStoreDataRequest,
     ExternalStoreDataResponse,
     LeaveNotice,
@@ -40,18 +42,23 @@ import { ExternalApiRpcLocal } from './ExternalApiRpcLocal'
 import { ExternalApiRpcRemote } from './ExternalApiRpcRemote'
 import { PeerManager } from './PeerManager'
 import { PeerDiscovery } from './discovery/PeerDiscovery'
-import { RecursiveOperationManager, RecursiveOperationResult } from './recursive-operation/RecursiveOperationManager'
+import { RecursiveOperationManager } from './recursive-operation/RecursiveOperationManager'
 import { Router } from './routing/Router'
 import { LocalDataStore } from './store/LocalDataStore'
 import { StoreManager } from './store/StoreManager'
 import { StoreRpcRemote } from './store/StoreRpcRemote'
 import { createPeerDescriptor } from '../helpers/createPeerDescriptor'
+import { RingIdRaw } from './contact/ringIdentifiers'
+import { getLocalRegion } from '@streamr/cdn-location'
+import { RingContacts } from './contact/RingContactList'
 
 export interface DhtNodeEvents {
     contactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
 }
 
 export interface DhtNodeOptions {
@@ -67,6 +74,7 @@ export interface DhtNodeOptions {
     storeMaxTtl?: number
     networkConnectivityTimeout?: number
     storageRedundancyFactor?: number
+    region?: number
 
     transport?: ITransport
     peerDescriptor?: PeerDescriptor
@@ -123,9 +131,9 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     private peerDiscovery?: PeerDiscovery
     private peerManager?: PeerManager
     public connectionManager?: ConnectionManager
+    private region?: number
     private started = false
     private abortController = new AbortController()
-
     constructor(conf: DhtNodeOptions) {
         super()
         this.config = merge({
@@ -150,7 +158,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     private validateConfig(): void {
         const expectedNodeIdLength = KADEMLIA_ID_LENGTH_IN_BYTES * 2
-        if (this.config.nodeId !== undefined ) {
+        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) {
@@ -177,6 +185,14 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 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 getLocalRegion()
+        }
+            
         // If transport is given, do not create a ConnectionManager
         if (this.config.transport) {
             this.transport = this.config.transport
@@ -294,10 +310,12 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             numberOfNodesPerKBucket: 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: PeerDescriptor) => this.createDhtNodeRpcRemote(peerDescriptor)
+            createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => this.createDhtNodeRpcRemote(peerDescriptor),
+            lockId: this.config.serviceId
         })
         this.peerManager.on('contactRemoved', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) => {
             this.emit('contactRemoved', peerDescriptor, activeContacts)
@@ -311,6 +329,12 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         this.peerManager.on('randomContactAdded', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) =>
             this.emit('randomContactAdded', peerDescriptor, activeContacts)
         )
+        this.peerManager.on('ringContactRemoved', (peerDescriptor: PeerDescriptor, activeContacts: RingContacts) => {
+            this.emit('ringContactRemoved', peerDescriptor, activeContacts)
+        })
+        this.peerManager.on('ringContactAdded', (peerDescriptor: PeerDescriptor, activeContacts: RingContacts) => {
+            this.emit('ringContactAdded', peerDescriptor, activeContacts)
+        })
         this.peerManager.on('kBucketEmpty', () => {
             if (!this.peerDiscovery!.isJoinOngoing()
                 && this.config.entryPoints
@@ -349,26 +373,31 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 return this.peerManager!.getClosestNeighborsTo(nodeId, limit)
                     .map((dhtPeer: DhtNodeRpcRemote) => dhtPeer.getPeerDescriptor())
             },
+            getClosestRingPeersTo: (ringIdRaw: RingIdRaw, limit: number) => {
+                return this.getClosestRingContactsTo(ringIdRaw, limit)
+            },
             addContact: (contact: PeerDescriptor) => this.peerManager!.addContact([contact]),
             removeContact: (nodeId: DhtAddress) => this.removeContact(nodeId)
         })
         this.rpcCommunicator!.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers',
             (req: ClosestPeersRequest, context) => dhtNodeRpcLocal.getClosestPeers(req, context))
+        this.rpcCommunicator!.registerRpcMethod(ClosestRingPeersRequest, ClosestRingPeersResponse, 'getClosestRingPeers',
+            (req: ClosestRingPeersRequest, context) => dhtNodeRpcLocal.getClosestRingPeers(req, context))
         this.rpcCommunicator!.registerRpcMethod(PingRequest, PingResponse, 'ping',
             (req: PingRequest, context) => dhtNodeRpcLocal.ping(req, context))
         this.rpcCommunicator!.registerRpcNotification(LeaveNotice, 'leaveNotice',
             (_req: LeaveNotice, context) => dhtNodeRpcLocal.leaveNotice(context))
         const externalApiRpcLocal = new ExternalApiRpcLocal({
             executeRecursiveOperation: (key: DhtAddress, operation: RecursiveOperation, excludedPeer: DhtAddress) => {
-                return this.executeRecursiveOperation(key, operation, excludedPeer)
+                return this.recursiveOperationManager!.execute(key, operation, excludedPeer)
             },
             storeDataToDht: (key: DhtAddress, data: Any, creator?: DhtAddress) => this.storeDataToDht(key, data, creator)
         })
         this.rpcCommunicator!.registerRpcMethod(
-            ExternalFindDataRequest,
-            ExternalFindDataResponse,
-            'externalFindData',
-            (req: ExternalFindDataRequest, context: ServerCallContext) => externalApiRpcLocal.externalFindData(req, context),
+            ExternalFetchDataRequest,
+            ExternalFetchDataResponse,
+            'externalFetchData',
+            (req: ExternalFetchDataRequest, context: ServerCallContext) => externalApiRpcLocal.externalFetchData(req, context),
             { timeout: 10000 }  // TODO use config option or named constant?
         )
         this.rpcCommunicator!.registerRpcMethod(
@@ -400,7 +429,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (this.config.peerDescriptor !== undefined) {
             this.localPeerDescriptor = this.config.peerDescriptor
         } else {
-            this.localPeerDescriptor = createPeerDescriptor(connectivityResponse, this.config.nodeId)
+            this.localPeerDescriptor = createPeerDescriptor(connectivityResponse, this.region!, this.config.nodeId)
         }
         return this.localPeerDescriptor
     }
@@ -408,8 +437,15 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     public getClosestContacts(limit?: number): PeerDescriptor[] {
         return this.peerManager!.getClosestContactsTo(
             this.getNodeId(),
-            limit).map((peer) => peer.getPeerDescriptor()
-        )
+            limit).map((peer) => peer.getPeerDescriptor())
+    }
+
+    public getClosestRingContactsTo(ringIdRaw: RingIdRaw, limit?: number): RingContacts {
+        const closest = this.peerManager!.getClosestRingContactsTo(ringIdRaw, limit)
+        return {
+            left: closest.left.map((dhtPeer: DhtNodeRpcRemote) => dhtPeer.getPeerDescriptor()),
+            right: closest.right.map((dhtPeer: DhtNodeRpcRemote) => dhtPeer.getPeerDescriptor())
+        }
     }
 
     public getNodeId(): DhtAddress {
@@ -448,25 +484,22 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         await this.peerDiscovery!.joinDht(entryPointDescriptors, doAdditionalDistantPeerDiscovery, retry)
     }
 
-    // TODO make this private and unify the public API of find/fetch/store/delete methods
-    // (we already have storeDataToDht etc. here)
-    public async executeRecursiveOperation(
-        key: DhtAddress,
-        operation: RecursiveOperation,
-        excludedPeer?: DhtAddress
-    ): Promise<RecursiveOperationResult> {
-        return this.recursiveOperationManager!.execute(key, operation, excludedPeer)
+    public async joinRing(): Promise<void> {
+        if (!this.started) {
+            throw new Error('Cannot join ring before calling start() on DhtNode')
+        }
+        await this.peerDiscovery!.joinRing()
     }
 
     public async storeDataToDht(key: DhtAddress, data: Any, creator?: DhtAddress): Promise<PeerDescriptor[]> {
         const connectedEntryPoints = this.getConnectedEntryPoints()
         if (this.peerDiscovery!.isJoinOngoing() && connectedEntryPoints.length > 0) {
-            return this.storeDataViaPeer(key, data, sample(connectedEntryPoints)!)
+            return this.storeDataToDhtViaPeer(key, data, sample(connectedEntryPoints)!)
         }
         return this.storeManager!.storeDataToDht(key, data, creator ?? this.getNodeId())
     }
 
-    public async storeDataViaPeer(key: DhtAddress, data: Any, peer: PeerDescriptor): Promise<PeerDescriptor[]> {
+    public async storeDataToDhtViaPeer(key: DhtAddress, data: Any, peer: PeerDescriptor): Promise<PeerDescriptor[]> {
         const rpcRemote = new ExternalApiRpcRemote(
             this.localPeerDescriptor!,
             peer,
@@ -476,29 +509,34 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return await rpcRemote.storeData(key, data)
     }
 
-    public async getDataFromDht(key: DhtAddress): Promise<DataEntry[]> {
+    public async fetchDataFromDht(key: DhtAddress): Promise<DataEntry[]> {
         const connectedEntryPoints = this.getConnectedEntryPoints()
         if (this.peerDiscovery!.isJoinOngoing() && connectedEntryPoints.length > 0) {
-            return this.findDataViaPeer(key, sample(connectedEntryPoints)!)
+            return this.fetchDataFromDhtViaPeer(key, sample(connectedEntryPoints)!)
         }
         const result = await this.recursiveOperationManager!.execute(key, RecursiveOperation.FETCH_DATA)
         return result.dataEntries ?? []  // TODO is this fallback needed?
     }
 
-    public async deleteDataFromDht(key: DhtAddress, waitForCompletion: boolean): Promise<void> {
-        if (!this.abortController.signal.aborted) {
-            await this.recursiveOperationManager!.execute(key, RecursiveOperation.DELETE_DATA, undefined, waitForCompletion)
-        }
-    }
-
-    public async findDataViaPeer(key: DhtAddress, peer: PeerDescriptor): Promise<DataEntry[]> {
+    public async fetchDataFromDhtViaPeer(key: DhtAddress, peer: PeerDescriptor): Promise<DataEntry[]> {
         const rpcRemote = new ExternalApiRpcRemote(
             this.localPeerDescriptor!,
             peer,
             this.rpcCommunicator!,
             ExternalApiRpcClient
         )
-        return await rpcRemote.externalFindData(key)
+        return await rpcRemote.externalFetchData(key)
+    }
+
+    public async deleteDataFromDht(key: DhtAddress, waitForCompletion: boolean): Promise<void> {
+        if (!this.abortController.signal.aborted) {
+            await this.recursiveOperationManager!.execute(key, RecursiveOperation.DELETE_DATA, undefined, waitForCompletion)
+        }
+    }
+
+    async findClosestNodesFromDht(key: DhtAddress): Promise<PeerDescriptor[]> {
+        const result = await this.recursiveOperationManager!.execute(key, RecursiveOperation.FIND_CLOSEST_NODES)
+        return result.closestNodes
     }
 
     public getTransport(): ITransport {

package/src/dht/DhtNodeRpcLocal.ts

@@ -4,6 +4,8 @@ import { Empty } from '../proto/google/protobuf/empty'
 import {
     ClosestPeersRequest,
     ClosestPeersResponse,
+    ClosestRingPeersRequest,
+    ClosestRingPeersResponse,
     PeerDescriptor,
     PingRequest,
     PingResponse
@@ -11,10 +13,13 @@ import {
 import { IDhtNodeRpc } from '../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { RingIdRaw } from './contact/ringIdentifiers'
+import { RingContacts } from './contact/RingContactList'
 
 interface DhtNodeRpcLocalConfig {
     peerDiscoveryQueryBatchSize: number
     getClosestPeersTo: (nodeId: DhtAddress, limit: number) => PeerDescriptor[]
+    getClosestRingPeersTo: (id: RingIdRaw, limit: number) => RingContacts
     addContact: (contact: PeerDescriptor) => void
     removeContact: (nodeId: DhtAddress) => void
 }
@@ -38,6 +43,17 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
         return response
     }
 
+    async getClosestRingPeers(request: ClosestRingPeersRequest, context: ServerCallContext): Promise<ClosestRingPeersResponse> {
+        this.config.addContact((context as DhtCallContext).incomingSourceDescriptor!)
+        const closestPeers = this.config.getClosestRingPeersTo(request.ringId as RingIdRaw, this.config.peerDiscoveryQueryBatchSize)
+        const response = {
+            leftPeers: closestPeers.left,
+            rightPeers: closestPeers.right,
+            requestId: request.requestId
+        }
+        return response
+    }
+
     async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
         logger.trace('received ping request: ' + getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
         setImmediate(() => {

package/src/dht/DhtNodeRpcRemote.ts

@@ -4,6 +4,7 @@ import { v4 } from 'uuid'
 import { DhtAddress, DhtAddressRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../identifiers'
 import {
     ClosestPeersRequest,
+    ClosestRingPeersRequest,
     PeerDescriptor,
     PingRequest
 } from '../proto/packages/dht/protos/DhtRpc'
@@ -11,6 +12,8 @@ import { DhtNodeRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import { ServiceID } from '../types/ServiceID'
 import { RpcRemote } from './contact/RpcRemote'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
+import { RingIdRaw } from './contact/ringIdentifiers'
+import { RingContacts } from './contact/RingContactList'
 
 const logger = new Logger(module)
 
@@ -55,6 +58,21 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
         }
     }
 
+    async getClosestRingPeers(ringIdRaw: RingIdRaw): Promise<RingContacts> {
+        logger.trace(`Requesting getClosestRingPeers on ${this.serviceId} from ${this.getNodeId()}`)
+        const request: ClosestRingPeersRequest = {
+            ringId: ringIdRaw,
+            requestId: v4()
+        }
+        try {
+            const response = await this.getClient().getClosestRingPeers(request, this.formDhtRpcOptions())
+            return { left: response.leftPeers ?? [], right: response.rightPeers ?? [] }
+        } catch (err) {
+            logger.trace(`getClosestRingPeers error ${this.serviceId}`, { err })
+            throw err
+        }
+    }
+
     async ping(): Promise<boolean> {
         logger.trace(`Requesting ping on ${this.serviceId} from ${this.getNodeId()}`)
         const request: PingRequest = {

package/src/dht/ExternalApiRpcLocal.ts

@@ -1,7 +1,7 @@
 import { IExternalApiRpc } from '../proto/packages/dht/protos/DhtRpc.server'
 import {
-    ExternalFindDataRequest,
-    ExternalFindDataResponse,
+    ExternalFetchDataRequest,
+    ExternalFetchDataResponse,
     ExternalStoreDataRequest,
     ExternalStoreDataResponse,
     RecursiveOperation,
@@ -35,14 +35,14 @@ export class ExternalApiRpcLocal implements IExternalApiRpc {
         this.config = config
     }
 
-    async externalFindData(findDataRequest: ExternalFindDataRequest, context: ServerCallContext): Promise<ExternalFindDataResponse> {
+    async externalFetchData(request: ExternalFetchDataRequest, context: ServerCallContext): Promise<ExternalFetchDataResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const result = await this.config.executeRecursiveOperation(
-            getDhtAddressFromRaw(findDataRequest.key),
+            getDhtAddressFromRaw(request.key),
             RecursiveOperation.FETCH_DATA,
             getNodeIdFromPeerDescriptor(senderPeerDescriptor)
         )
-        return ExternalFindDataResponse.create({ entries: result.dataEntries ?? [] })
+        return ExternalFetchDataResponse.create({ entries: result.dataEntries ?? [] })
     }
 
     async externalStoreData(request: ExternalStoreDataRequest, context: ServerCallContext): Promise<ExternalStoreDataResponse> {

package/src/dht/ExternalApiRpcRemote.ts

@@ -1,13 +1,13 @@
 import { DhtAddress, getRawFromDhtAddress } from '../identifiers'
 import { Any } from '../proto/google/protobuf/any'
-import { DataEntry, ExternalFindDataRequest, ExternalStoreDataRequest, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { DataEntry, ExternalFetchDataRequest, ExternalStoreDataRequest, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { ExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import { RpcRemote } from './contact/RpcRemote'
 
 export class ExternalApiRpcRemote extends RpcRemote<ExternalApiRpcClient> {
 
-    async externalFindData(key: DhtAddress): Promise<DataEntry[]> {
-        const request: ExternalFindDataRequest = {
+    async externalFetchData(key: DhtAddress): Promise<DataEntry[]> {
+        const request: ExternalFetchDataRequest = {
             key: getRawFromDhtAddress(key)
         }
         const options = this.formDhtRpcOptions({
@@ -15,7 +15,7 @@ export class ExternalApiRpcRemote extends RpcRemote<ExternalApiRpcClient> {
             timeout: 10000
         })
         try {
-            const data = await this.getClient().externalFindData(request, options)
+            const data = await this.getClient().externalFetchData(request, options)
             return data.entries
         } catch (err) {
             return []

package/src/dht/PeerManager.ts

@@ -11,6 +11,9 @@ import { SortedContactList } from './contact/SortedContactList'
 import { ConnectionManager } from '../connection/ConnectionManager'
 import EventEmitter from 'eventemitter3'
 import { DhtAddress, DhtAddressRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../identifiers'
+import { RingContactList, RingContacts } from './contact/RingContactList'
+import { RingIdRaw, getRingIdRawFromPeerDescriptor } from './contact/ringIdentifiers'
+import { LockID } from '../connection/ConnectionLockHandler'
 
 const logger = new Logger(module)
 
@@ -19,8 +22,10 @@ interface PeerManagerConfig {
     maxContactListSize: number
     peerDiscoveryQueryBatchSize: number
     localNodeId: DhtAddress
+    localPeerDescriptor: PeerDescriptor
     connectionManager: ConnectionManager
     isLayer0: boolean
+    lockId: LockID
     createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
 }
 
@@ -29,6 +34,8 @@ export interface PeerManagerEvents {
     contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
     kBucketEmpty: () => void
 }
 
@@ -51,6 +58,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     // All nodes that we know about
     private contacts: SortedContactList<DhtNodeRpcRemote>
     private randomPeers: RandomContactList<DhtNodeRpcRemote>
+    private ringContacts: RingContactList<DhtNodeRpcRemote>
     private stopped: boolean = false
     private readonly config: PeerManagerConfig
 
@@ -62,6 +70,13 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
             numberOfNodesToPing: this.config.numberOfNodesPerKBucket
         })
+        this.ringContacts = new RingContactList<DhtNodeRpcRemote>(getRingIdRawFromPeerDescriptor(this.config.localPeerDescriptor), true)
+        this.ringContacts.on('ringContactAdded', (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => {
+            this.emit('ringContactAdded', peerDescriptor, closestPeers)
+        })
+        this.ringContacts.on('ringContactRemoved', (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => {
+            this.emit('ringContactRemoved', peerDescriptor, closestPeers)
+        })
         this.bucket.on('ping', (oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote) => this.onKBucketPing(oldContacts, newContact))
         this.bucket.on('removed', (contact: DhtNodeRpcRemote) => this.onKBucketRemoved(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
         this.bucket.on('added', (contact: DhtNodeRpcRemote) => this.onKBucketAdded(contact))
@@ -69,7 +84,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             // TODO: Update contact info to the connection manager and reconnect
         })
         this.contacts = new SortedContactList({
-            referenceId: this.config.localNodeId, 
+            referenceId: this.config.localNodeId,
             maxSize: this.config.maxContactListSize,
             allowToContainReferenceId: false,
             emitEvents: true
@@ -98,7 +113,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList({
-            referenceId: this.config.localNodeId, 
+            referenceId: this.config.localNodeId,
             maxSize: 100,  // TODO use config option or named constant?
             allowToContainReferenceId: false,
             emitEvents: false
@@ -106,7 +121,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         sortingList.addContacts(oldContacts)
         const sortedContacts = sortingList.getAllContacts()
         const removableNodeId = sortedContacts[sortedContacts.length - 1].getNodeId()
-        this.config.connectionManager?.weakUnlockConnection(removableNodeId)
+        this.config.connectionManager?.weakUnlockConnection(removableNodeId, this.config.lockId)
         this.bucket.remove(getRawFromDhtAddress(removableNodeId))
         this.bucket.add(newContact)
     }
@@ -115,7 +130,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        this.config.connectionManager?.weakUnlockConnection(nodeId)
+        this.config.connectionManager?.weakUnlockConnection(nodeId, this.config.lockId)
         logger.trace(`Removed contact ${nodeId}`)
         if (this.bucket.count() === 0) {
             this.emit('kBucketEmpty')
@@ -130,7 +145,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             const peerDescriptor = contact.getPeerDescriptor()
             const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
             // Important to lock here, before the ping result is known
-            this.config.connectionManager?.weakLockConnection(nodeId)
+            this.config.connectionManager?.weakLockConnection(nodeId, this.config.lockId)
             if (this.connections.has(contact.getNodeId())) {
                 logger.trace(`Added new contact ${nodeId}`)
             } else {    // open connection by pinging
@@ -140,13 +155,13 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
                         logger.trace(`Added new contact ${nodeId}`)
                     } else {
                         logger.trace('ping failed ' + nodeId)
-                        this.config.connectionManager?.weakUnlockConnection(nodeId)
+                        this.config.connectionManager?.weakUnlockConnection(nodeId, this.config.lockId)
                         this.removeContact(nodeId)
                         this.addClosestContactToBucket()
                     }
                     return
                 }).catch((_e) => {
-                    this.config.connectionManager?.weakUnlockConnection(nodeId)
+                    this.config.connectionManager?.weakUnlockConnection(nodeId, this.config.lockId)
                     this.removeContact(nodeId)
                     this.addClosestContactToBucket()
                 })
@@ -207,6 +222,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         logger.trace(`Removing contact ${nodeId}`)
+        this.ringContacts.removeContact(this.contacts.getContact(nodeId)?.contact)
         this.bucket.remove(getRawFromDhtAddress(nodeId))
         this.contacts.removeContact(nodeId)
         this.randomPeers.removeContact(nodeId)
@@ -219,6 +235,10 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             this.bucket.remove(rpcRemote.id)
         })
         this.bucket.removeAllListeners()
+        this.ringContacts.getAllContacts().forEach((rpcRemote) => {
+            rpcRemote.leaveNotice()
+            this.ringContacts.removeContact(rpcRemote)
+        })
         this.contacts.stop()
         this.randomPeers.stop()
         this.connections.clear()
@@ -230,7 +250,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             allowToContainReferenceId: true,
             emitEvents: false,
             excludedNodeIds
-        }) 
+        })
         this.bucket.toArray().forEach((contact) => closest.addContact(contact))
         return closest.getClosestContacts(limit)
     }
@@ -248,13 +268,24 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return closest.getClosestContacts(limit)
     }
 
+    getClosestRingContactsTo(
+        ringIdRaw: RingIdRaw,
+        limit?: number,
+        excludedIds?: Set<DhtAddress>
+    ): { left: DhtNodeRpcRemote[], right: DhtNodeRpcRemote[] } {
+        const closest = new RingContactList<DhtNodeRpcRemote>(ringIdRaw, false, excludedIds)
+        this.contacts.getAllContacts().map((contact) => closest.addContact(contact))
+        this.ringContacts.getAllContacts().map((contact) => closest.addContact(contact))
+        return closest.getClosestContacts(limit ?? 8)
+    }
+
     getContactCount(excludedNodeIds?: Set<DhtAddress>): number {
         return this.contacts.getAllContacts().filter((contact) => {
             if (!excludedNodeIds) {
                 return true
             } else {
                 return !excludedNodeIds.has(contact.getNodeId())
-            } 
+            }
         }).length
     }
 
@@ -274,7 +305,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         this.contacts.setActive(nodeId)
     }
 
-    addContact(peerDescriptors: PeerDescriptor[], setActive?: boolean): void { 
+    addContact(peerDescriptors: PeerDescriptor[], setActive?: boolean): void {
         if (this.stopped) {
             return
         }
@@ -285,18 +316,23 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
                 const remote = this.config.createDhtNodeRpcRemote(contact)
                 const isInBucket = (this.bucket.get(contact.nodeId) !== null)
                 const isInContacts = (this.contacts.getContact(nodeId) !== undefined)
+                const isInRingContacts = this.ringContacts.getContact(contact) !== undefined
+
                 if (isInBucket || isInContacts) {
                     this.randomPeers.addContact(remote)
                 }
                 if (!isInBucket) {
                     this.bucket.add(remote)
-                } 
+                }
                 if (!isInContacts) {
                     this.contacts.addContact(remote)
-                } 
+                }
                 if (setActive) {
                     this.contacts.setActive(nodeId)
                 }
+                if (!isInRingContacts) {
+                    this.ringContacts.addContact(remote)
+                }
             }
         })
     }