@streamr/dht 100.2.5-beta.1 → 101.0.0-beta.0

package/src/dht/PeerManager.ts

@@ -17,9 +17,9 @@ import { RingIdRaw, getRingIdRawFromPeerDescriptor } from './contact/ringIdentif
 
 const logger = new Logger(module)
 
-interface PeerManagerConfig {
+interface PeerManagerOptions {
     numberOfNodesPerKBucket: number
-    maxContactListSize: number
+    maxContactCount: number
     localNodeId: DhtAddress
     localPeerDescriptor: PeerDescriptor
     connectionLocker?: ConnectionLocker
@@ -71,17 +71,17 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     private ringContacts: RingContactList<DhtNodeRpcRemote>
     private randomContacts: RandomContactList<DhtNodeRpcRemote>
     private stopped: boolean = false
-    private readonly config: PeerManagerConfig
+    private readonly options: PeerManagerOptions
 
-    constructor(config: PeerManagerConfig) {
+    constructor(options: PeerManagerOptions) {
         super()
-        this.config = config
+        this.options = options
         this.neighbors = new KBucket<DhtNodeRpcRemote>({
-            localNodeId: getRawFromDhtAddress(this.config.localNodeId),
-            numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
-            numberOfNodesToPing: this.config.numberOfNodesPerKBucket
+            localNodeId: getRawFromDhtAddress(this.options.localNodeId),
+            numberOfNodesPerKBucket: this.options.numberOfNodesPerKBucket,
+            numberOfNodesToPing: this.options.numberOfNodesPerKBucket
         })
-        this.ringContacts = new RingContactList<DhtNodeRpcRemote>(getRingIdRawFromPeerDescriptor(this.config.localPeerDescriptor))
+        this.ringContacts = new RingContactList<DhtNodeRpcRemote>(getRingIdRawFromPeerDescriptor(this.options.localPeerDescriptor))
         this.ringContacts.on('contactAdded', (contact: DhtNodeRpcRemote) => {
             this.emit('ringContactAdded', contact.getPeerDescriptor())
         })
@@ -95,8 +95,8 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             // TODO: Update contact info to the connection manager and reconnect
         })
         this.nearbyContacts = new SortedContactList({
-            referenceId: this.config.localNodeId,
-            maxSize: this.config.maxContactListSize,
+            referenceId: this.options.localNodeId,
+            maxSize: this.options.maxContactCount,
             allowToContainReferenceId: false
         })
         this.nearbyContacts.on('contactRemoved', (contact: DhtNodeRpcRemote) => {
@@ -104,13 +104,13 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
                 return
             }
             this.emit('nearbyContactRemoved', contact.getPeerDescriptor())
-            this.randomContacts.addContact(this.config.createDhtNodeRpcRemote(contact.getPeerDescriptor()))
+            this.randomContacts.addContact(this.options.createDhtNodeRpcRemote(contact.getPeerDescriptor()))
         })
         this.nearbyContacts.on('contactAdded', (contact: DhtNodeRpcRemote) =>
             this.emit('nearbyContactAdded', contact.getPeerDescriptor())
         )
         this.activeContacts = new Set()
-        this.randomContacts = new RandomContactList(this.config.localNodeId, this.config.maxContactListSize)
+        this.randomContacts = new RandomContactList(this.options.localNodeId, this.options.maxContactCount)
         this.randomContacts.on('contactRemoved', (removedContact: DhtNodeRpcRemote) =>
             this.emit('randomContactRemoved', removedContact.getPeerDescriptor())
         )
@@ -124,12 +124,12 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList({
-            referenceId: this.config.localNodeId,
+            referenceId: this.options.localNodeId,
             allowToContainReferenceId: false
         })
         sortingList.addContacts(oldContacts)
         const removableNodeId = sortingList.getFurthestContacts(1)[0].getNodeId()
-        this.config.connectionLocker?.weakUnlockConnection(removableNodeId, this.config.lockId)
+        this.options.connectionLocker?.weakUnlockConnection(removableNodeId, this.options.lockId)
         this.neighbors.remove(getRawFromDhtAddress(removableNodeId))
         this.neighbors.add(newContact)
     }
@@ -138,7 +138,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
+        this.options.connectionLocker?.weakUnlockConnection(nodeId, this.options.lockId)
         logger.trace(`Removed contact ${nodeId}`)
         if (this.neighbors.count() === 0) {
             this.emit('kBucketEmpty')
@@ -149,12 +149,12 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        if (contact.getNodeId() !== this.config.localNodeId) {
+        if (contact.getNodeId() !== this.options.localNodeId) {
             const peerDescriptor = contact.getPeerDescriptor()
             const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
             // Important to lock here, before the ping result is known
-            this.config.connectionLocker?.weakLockConnection(nodeId, this.config.lockId)
-            if (this.config.hasConnection(contact.getNodeId())) {
+            this.options.connectionLocker?.weakLockConnection(nodeId, this.options.lockId)
+            if (this.options.hasConnection(contact.getNodeId())) {
                 logger.trace(`Added new contact ${nodeId}`)
             } else {    // open connection by pinging
                 logger.trace('starting ping ' + nodeId)
@@ -163,12 +163,12 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
                         logger.trace(`Added new contact ${nodeId}`)
                     } else {
                         logger.trace('ping failed ' + nodeId)
-                        this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
+                        this.options.connectionLocker?.weakUnlockConnection(nodeId, this.options.lockId)
                         this.removeContact(nodeId)
                         this.addNearbyContactToNeighbors()
                     }
                 }).catch((_e) => {
-                    this.config.connectionLocker?.weakUnlockConnection(nodeId, this.config.lockId)
+                    this.options.connectionLocker?.weakUnlockConnection(nodeId, this.options.lockId)
                     this.removeContact(nodeId)
                     this.addNearbyContactToNeighbors()
                 })
@@ -246,7 +246,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     ): { left: DhtNodeRpcRemote[], right: DhtNodeRpcRemote[] } {
         const closest = new RingContactList<DhtNodeRpcRemote>(ringIdRaw, excludedIds)
         this.ringContacts.getAllContacts().map((contact) => closest.addContact(contact))
-        // TODO use config option or named constant?
+        // TODO use options option or named constant?
         return closest.getClosestContacts(limit ?? 8)
     }
     
@@ -279,9 +279,9 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-        if (nodeId !== this.config.localNodeId) {
+        if (nodeId !== this.options.localNodeId) {
             logger.trace(`Adding new contact ${nodeId}`)
-            const remote = this.config.createDhtNodeRpcRemote(peerDescriptor)
+            const remote = this.options.createDhtNodeRpcRemote(peerDescriptor)
             const isInNeighbors = (this.neighbors.get(peerDescriptor.nodeId) !== null)
             const isInNearbyContacts = (this.nearbyContacts.getContact(nodeId) !== undefined)
             const isInRingContacts = this.ringContacts.getContact(peerDescriptor) !== undefined

package/src/dht/contact/SortedContactList.ts

@@ -8,7 +8,7 @@ import { DhtAddress, getRawFromDhtAddress } from '../../identifiers'
 export type ReadonlySortedContactList<C extends { getNodeId: () => DhtAddress }> =
     Pick<SortedContactList<C>, 'getClosestContacts' | 'getAllContactsInUndefinedOrder'>
 
-export interface SortedContactListConfig {
+export interface SortedContactListOptions {
     referenceId: DhtAddress  // all contacts in this list are in sorted by the distance to this ID
     allowToContainReferenceId: boolean
     maxSize?: number
@@ -20,15 +20,15 @@ export interface SortedContactListConfig {
 
 export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {
 
-    private config: SortedContactListConfig
+    private options: SortedContactListOptions
     private contactsById: Map<DhtAddress, C> = new Map()
     private contactIds: DhtAddress[] = []
 
     constructor(
-        config: SortedContactListConfig
+        options: SortedContactListOptions
     ) {
         super()
-        this.config = config
+        this.options = options
         this.compareIds = this.compareIds.bind(this)
     }
 
@@ -42,15 +42,15 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
 
     public addContact(contact: C): void {
         const contactId = contact.getNodeId()
-        if (this.config.excludedNodeIds !== undefined && this.config.excludedNodeIds.has(contactId)) {
+        if (this.options.excludedNodeIds !== undefined && this.options.excludedNodeIds.has(contactId)) {
             return
         }
-        if ((!this.config.allowToContainReferenceId && (this.config.referenceId === contactId)) ||
-            (this.config.nodeIdDistanceLimit !== undefined && this.compareIds(this.config.nodeIdDistanceLimit, contactId) < 0)) {
+        if ((!this.options.allowToContainReferenceId && (this.options.referenceId === contactId)) ||
+            (this.options.nodeIdDistanceLimit !== undefined && this.compareIds(this.options.nodeIdDistanceLimit, contactId) < 0)) {
             return
         }
         if (!this.contactsById.has(contactId)) {
-            if ((this.config.maxSize === undefined) || (this.contactIds.length < this.config.maxSize)) {
+            if ((this.options.maxSize === undefined) || (this.contactIds.length < this.options.maxSize)) {
                 this.contactsById.set(contactId, contact)
                 const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
                 this.contactIds.splice(index, 0, contactId)
@@ -60,7 +60,7 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
                         contact
                     )
                 }
-            } else if (this.compareIds(this.contactIds[this.config.maxSize - 1], contactId) > 0) {
+            } else if (this.compareIds(this.contactIds[this.options.maxSize - 1], contactId) > 0) {
                 const removedId = this.contactIds.pop()
                 const removedContact = this.contactsById.get(removedId!)!
                 this.contactsById.delete(removedId!)
@@ -120,7 +120,7 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
     // TODO inline this method?
     private distanceToReferenceId(id: DhtAddress): number {
         // TODO maybe this class should store the referenceId also as DhtAddressRaw so that we don't need to convert it here?
-        return getDistance(getRawFromDhtAddress(this.config.referenceId), getRawFromDhtAddress(id))
+        return getDistance(getRawFromDhtAddress(this.options.referenceId), getRawFromDhtAddress(id))
     }
 
     public removeContact(id: DhtAddress): boolean {

package/src/dht/discovery/DiscoverySession.ts

@@ -8,7 +8,7 @@ import { getClosestNodes } from '../contact/getClosestNodes'
 
 const logger = new Logger(module)
 
-interface DiscoverySessionConfig {
+interface DiscoverySessionOptions {
     targetId: DhtAddress
     parallelism: number
     noProgressLimit: number
@@ -25,31 +25,31 @@ export class DiscoverySession {
     private noProgressCounter = 0
     private ongoingRequests: Set<DhtAddress> = new Set()
     private doneGate = new Gate(false)
-    private readonly config: DiscoverySessionConfig
+    private readonly options: DiscoverySessionOptions
 
-    constructor(config: DiscoverySessionConfig) {
-        this.config = config
+    constructor(options: DiscoverySessionOptions) {
+        this.options = options
     }
 
     private addContacts(contacts: PeerDescriptor[]): void {
-        if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
+        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
             return
         }
         for (const contact of contacts) {
-            this.config.peerManager.addContact(contact)
+            this.options.peerManager.addContact(contact)
         }
     }
 
     private async fetchClosestNeighborsFromRemote(peerDescriptor: PeerDescriptor): Promise<PeerDescriptor[]> {
-        if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
+        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
             return []
         }
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         logger.trace(`Getting closest neighbors from remote: ${nodeId}`)
-        this.config.contactedPeers.add(nodeId)
-        const remote = this.config.createDhtNodeRpcRemote(peerDescriptor)
-        const returnedContacts = await remote.getClosestPeers(this.config.targetId)
-        this.config.peerManager.setContactActive(nodeId)
+        this.options.contactedPeers.add(nodeId)
+        const remote = this.options.createDhtNodeRpcRemote(peerDescriptor)
+        const returnedContacts = await remote.getClosestPeers(this.options.targetId)
+        this.options.peerManager.setContactActive(nodeId)
         return returnedContacts
     }
 
@@ -58,7 +58,7 @@ export class DiscoverySession {
             return
         }
         this.ongoingRequests.delete(nodeId)
-        const targetId = getRawFromDhtAddress(this.config.targetId)
+        const targetId = getRawFromDhtAddress(this.options.targetId)
         const oldClosestNeighbor = this.getClosestNeighbor()
         const oldClosestDistance = getDistance(targetId, oldClosestNeighbor.nodeId)
         this.addContacts(contacts)
@@ -71,8 +71,8 @@ export class DiscoverySession {
 
     private getClosestNeighbor(): PeerDescriptor {
         return getClosestNodes(
-            this.config.targetId,
-            this.config.peerManager.getNeighbors().map((n) => n.getPeerDescriptor()),
+            this.options.targetId,
+            this.options.peerManager.getNeighbors().map((n) => n.getPeerDescriptor()),
             { maxCount: 1 }
         )[0]
     }
@@ -82,27 +82,27 @@ export class DiscoverySession {
             return
         }
         this.ongoingRequests.delete(nodeId)
-        this.config.peerManager.removeContact(nodeId)
+        this.options.peerManager.removeContact(nodeId)
     }
 
     private findMoreContacts(): void {
-        if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
+        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
             return
         }
         const uncontacted = getClosestNodes(
-            this.config.targetId,
-            Array.from(this.config.peerManager.getNearbyContacts().getAllContactsInUndefinedOrder(), (c) => c.getPeerDescriptor()), 
+            this.options.targetId,
+            Array.from(this.options.peerManager.getNearbyContacts().getAllContactsInUndefinedOrder(), (c) => c.getPeerDescriptor()), 
             {
-                maxCount: this.config.parallelism,
-                excludedNodeIds: this.config.contactedPeers
+                maxCount: this.options.parallelism,
+                excludedNodeIds: this.options.contactedPeers
             }
         )
-        if ((uncontacted.length === 0 && this.ongoingRequests.size === 0) || (this.noProgressCounter >= this.config.noProgressLimit)) {
+        if ((uncontacted.length === 0 && this.ongoingRequests.size === 0) || (this.noProgressCounter >= this.options.noProgressLimit)) {
             this.doneGate.open()
             return
         }
         for (const node of uncontacted) {
-            if (this.ongoingRequests.size >= this.config.parallelism) {
+            if (this.ongoingRequests.size >= this.options.parallelism) {
                 break
             }
             const nodeId = getNodeIdFromPeerDescriptor(node)
@@ -118,12 +118,12 @@ export class DiscoverySession {
     }
 
     public async findClosestNodes(timeout: number): Promise<void> {
-        if (this.config.peerManager.getNearbyContactCount(this.config.contactedPeers) === 0) {
+        if (this.options.peerManager.getNearbyContactCount(this.options.contactedPeers) === 0) {
             return
         }
         setImmediate(() => {
             this.findMoreContacts()
         })
-        await withTimeout(this.doneGate.waitUntilOpen(), timeout, 'discovery session timed out', this.config.abortSignal)
+        await withTimeout(this.doneGate.waitUntilOpen(), timeout, 'discovery session timed out', this.options.abortSignal)
     }
 }

package/src/dht/discovery/PeerDiscovery.ts

@@ -16,8 +16,9 @@ import { getClosestNodes } from '../contact/getClosestNodes'
 import { RingIdRaw, getRingIdRawFromPeerDescriptor } from '../contact/ringIdentifiers'
 import { DiscoverySession } from './DiscoverySession'
 import { RingDiscoverySession } from './RingDiscoverySession'
+import { CONTROL_LAYER_NODE_SERVICE_ID } from '../DhtNode'
 
-interface PeerDiscoveryConfig {
+interface PeerDiscoveryOptions {
     localPeerDescriptor: PeerDescriptor
     joinNoProgressLimit: number
     serviceId: ServiceID
@@ -45,10 +46,10 @@ export class PeerDiscovery {
     private rejoinOngoing = false
     private joinCalled = false
     private recoveryIntervalStarted = false
-    private readonly config: PeerDiscoveryConfig
+    private readonly options: PeerDiscoveryOptions
 
-    constructor(config: PeerDiscoveryConfig) {
-        this.config = config
+    constructor(options: PeerDiscoveryOptions) {
+        this.options = options
     }
 
     async joinDht(
@@ -57,12 +58,12 @@ export class PeerDiscovery {
         retry = true
     ): Promise<void> {
         const contactedPeers = new Set<DhtAddress>()
-        const distantJoinConfig = doAdditionalDistantPeerDiscovery 
+        const distantJoinOptions = doAdditionalDistantPeerDiscovery 
             ? { enabled: true, contactedPeers: new Set<DhtAddress>() } : { enabled: false } as const
         await Promise.all(entryPoints.map((entryPoint) => this.joinThroughEntryPoint(
             entryPoint,
             contactedPeers,
-            distantJoinConfig,
+            distantJoinOptions,
             retry
         )))
     }
@@ -79,39 +80,40 @@ export class PeerDiscovery {
         }
         this.joinCalled = true
         logger.debug(
-            `Joining ${this.config.serviceId === 'layer0' ? 'The Streamr Network' : `Control Layer for ${this.config.serviceId}`}`
+            `Joining ${this.options.serviceId === CONTROL_LAYER_NODE_SERVICE_ID
+                ? 'The Streamr Network' : `Control Layer for ${this.options.serviceId}`}`
             + ` via entrypoint ${getNodeIdFromPeerDescriptor(entryPointDescriptor)}`
         )
-        if (areEqualPeerDescriptors(entryPointDescriptor, this.config.localPeerDescriptor)) {
+        if (areEqualPeerDescriptors(entryPointDescriptor, this.options.localPeerDescriptor)) {
             return
         }
-        this.config.connectionLocker?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
-        this.config.peerManager.addContact(entryPointDescriptor)
-        const targetId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        this.options.connectionLocker?.lockConnection(entryPointDescriptor, `${this.options.serviceId}::joinDht`)
+        this.options.peerManager.addContact(entryPointDescriptor)
+        const targetId = getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor)
         const sessions = [this.createSession(targetId, contactedPeers)]
         if (additionalDistantJoin.enabled) {
             sessions.push(this.createSession(createDistantDhtAddress(targetId), additionalDistantJoin.contactedPeers))
         }
         await this.runSessions(sessions, entryPointDescriptor, retry)
-        this.config.connectionLocker?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
+        this.options.connectionLocker?.unlockConnection(entryPointDescriptor, `${this.options.serviceId}::joinDht`)
 
     }
 
     async joinRing(): Promise<void> {
         const contactedPeers = new Set<DhtAddress>()
-        const sessions = [this.createRingSession(getRingIdRawFromPeerDescriptor(this.config.localPeerDescriptor), contactedPeers)]
+        const sessions = [this.createRingSession(getRingIdRawFromPeerDescriptor(this.options.localPeerDescriptor), contactedPeers)]
         await this.runRingSessions(sessions)
     }
 
     private createSession(targetId: DhtAddress, contactedPeers: Set<DhtAddress>): DiscoverySession {
         const sessionOptions = {
             targetId,
-            parallelism: this.config.parallelism,
-            noProgressLimit: this.config.joinNoProgressLimit,
-            peerManager: this.config.peerManager,
+            parallelism: this.options.parallelism,
+            noProgressLimit: this.options.joinNoProgressLimit,
+            peerManager: this.options.peerManager,
             contactedPeers,
-            abortSignal: this.config.abortSignal,
-            createDhtNodeRpcRemote: this.config.createDhtNodeRpcRemote
+            abortSignal: this.options.abortSignal,
+            createDhtNodeRpcRemote: this.options.createDhtNodeRpcRemote
         }
         return new DiscoverySession(sessionOptions)
     }
@@ -119,12 +121,12 @@ export class PeerDiscovery {
     private createRingSession(targetId: RingIdRaw, contactedPeers: Set<DhtAddress>): RingDiscoverySession {
         const sessionOptions = {
             targetId,
-            parallelism: this.config.parallelism,
-            noProgressLimit: this.config.joinNoProgressLimit,
-            peerManager: this.config.peerManager,
+            parallelism: this.options.parallelism,
+            noProgressLimit: this.options.joinNoProgressLimit,
+            peerManager: this.options.peerManager,
             contactedPeers,
-            abortSignal: this.config.abortSignal,
-            createDhtNodeRpcRemote: this.config.createDhtNodeRpcRemote
+            abortSignal: this.options.abortSignal,
+            createDhtNodeRpcRemote: this.options.createDhtNodeRpcRemote
         }
         return new RingDiscoverySession(sessionOptions)
     }
@@ -133,17 +135,17 @@ export class PeerDiscovery {
         try {
             for (const session of sessions) {
                 this.ongoingDiscoverySessions.set(session.id, session)
-                await session.findClosestNodes(this.config.joinTimeout)
+                await session.findClosestNodes(this.options.joinTimeout)
             }
         } catch (_e) {
-            logger.debug(`DHT join on ${this.config.serviceId} timed out`)
+            logger.debug(`DHT join on ${this.options.serviceId} timed out`)
         } finally {
             if (!this.isStopped()) {
-                if (this.config.peerManager.getNeighborCount() === 0) {
+                if (this.options.peerManager.getNeighborCount() === 0) {
                     if (retry) {
                         // TODO should we catch possible promise rejection?
-                        // TODO use config option or named constant?
-                        setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.config.abortSignal)
+                        // TODO use options option or named constant?
+                        setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.options.abortSignal)
                     }
                 } else {
                     await this.ensureRecoveryIntervalIsRunning()
@@ -157,10 +159,10 @@ export class PeerDiscovery {
         try {
             for (const session of sessions) {
                 this.ongoingRingDiscoverySessions.set(session.id, session)
-                await session.findClosestNodes(this.config.joinTimeout)
+                await session.findClosestNodes(this.options.joinTimeout)
             }
         } catch (_e) {
-            logger.debug(`Ring join on ${this.config.serviceId} timed out`)
+            logger.debug(`Ring join on ${this.options.serviceId} timed out`)
         } finally {
             sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.id))
         }
@@ -174,17 +176,17 @@ export class PeerDiscovery {
         if (this.isStopped() || this.rejoinOngoing) {
             return
         }
-        logger.debug(`Rejoining DHT ${this.config.serviceId}`)
+        logger.debug(`Rejoining DHT ${this.options.serviceId}`)
         this.rejoinOngoing = true
         try {
             await this.joinThroughEntryPoint(entryPoint, contactedPeers, { enabled: true, contactedPeers: distantJoinContactPeers })
-            logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
+            logger.debug(`Rejoined DHT successfully ${this.options.serviceId}!`)
         } catch (err) {
-            logger.warn(`Rejoining DHT ${this.config.serviceId} failed`)
+            logger.warn(`Rejoining DHT ${this.options.serviceId} failed`)
             if (!this.isStopped()) {
                 // TODO should we catch possible promise rejection?
-                // TODO use config option or named constant?
-                setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.config.abortSignal)
+                // TODO use options option or named constant?
+                setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.options.abortSignal)
             }
         } finally {
             this.rejoinOngoing = false
@@ -194,8 +196,8 @@ export class PeerDiscovery {
     private async ensureRecoveryIntervalIsRunning(): Promise<void> {
         if (!this.recoveryIntervalStarted) {
             this.recoveryIntervalStarted = true
-            // TODO use config option or named constant?
-            await scheduleAtInterval(() => this.fetchClosestAndRandomNeighbors(), 60000, true, this.config.abortSignal)
+            // TODO use options option or named constant?
+            await scheduleAtInterval(() => this.fetchClosestAndRandomNeighbors(), 60000, true, this.options.abortSignal)
         }
     }
 
@@ -203,29 +205,29 @@ export class PeerDiscovery {
         if (this.isStopped()) {
             return
         }
-        const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
-        const nodes = this.getClosestNeighbors(localNodeId, this.config.parallelism)
+        const localNodeId = getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor)
+        const nodes = this.getClosestNeighbors(localNodeId, this.options.parallelism)
         const randomNodes = this.getClosestNeighbors(createRandomDhtAddress(), 1)
         await Promise.allSettled([
             ...nodes.map(async (node: PeerDescriptor) => {
-                const remote = this.config.createDhtNodeRpcRemote(node)
+                const remote = this.options.createDhtNodeRpcRemote(node)
                 const contacts = await remote.getClosestPeers(localNodeId)
                 for (const contact of contacts) {
-                    this.config.peerManager.addContact(contact)
+                    this.options.peerManager.addContact(contact)
                 }
             }),
             ...randomNodes.map(async (node: PeerDescriptor) => {
-                const remote = this.config.createDhtNodeRpcRemote(node)
+                const remote = this.options.createDhtNodeRpcRemote(node)
                 const contacts = await remote.getClosestPeers(createRandomDhtAddress())
                 for (const contact of contacts) {
-                    this.config.peerManager.addContact(contact)
+                    this.options.peerManager.addContact(contact)
                 }
             })
         ])
     }
 
     private getClosestNeighbors(referenceId: DhtAddress, maxCount: number): PeerDescriptor[] {
-        return getClosestNodes(referenceId, this.config.peerManager.getNeighbors().map((n) => n.getPeerDescriptor()), { maxCount })
+        return getClosestNodes(referenceId, this.options.peerManager.getNeighbors().map((n) => n.getPeerDescriptor()), { maxCount })
     }
 
     public isJoinOngoing(): boolean {
@@ -237,6 +239,6 @@ export class PeerDiscovery {
     }
 
     private isStopped() {
-        return this.config.abortSignal.aborted
+        return this.options.abortSignal.aborted
     }
 }