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

package/src/dht/discovery/RingDiscoverySession.ts

@@ -9,7 +9,7 @@ import { RingId, RingIdRaw, getLeftDistance, getRingIdFromPeerDescriptor, getRin
 
 const logger = new Logger(module)
 
-interface RingDiscoverySessionConfig {
+interface RingDiscoverySessionOptions {
     targetId: RingIdRaw
     parallelism: number
     noProgressLimit: number
@@ -25,33 +25,33 @@ export class RingDiscoverySession {
     private noProgressCounter = 0
     private ongoingRequests: Set<DhtAddress> = new Set()
     private doneGate = new Gate(false)
-    private readonly config: RingDiscoverySessionConfig
+    private readonly options: RingDiscoverySessionOptions
     private numContactedPeers = 0
     private targetIdAsRingId: RingId
 
-    constructor(config: RingDiscoverySessionConfig) {
-        this.config = config
-        this.targetIdAsRingId = getRingIdFromRaw(this.config.targetId)
+    constructor(options: RingDiscoverySessionOptions) {
+        this.options = options
+        this.targetIdAsRingId = getRingIdFromRaw(this.options.targetId)
     }
 
     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 fetchClosestContactsFromRemote(contact: DhtNodeRpcRemote): Promise<RingContacts> {
-        if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
+        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
             return { left: [], right: [] }
         }
         logger.trace(`Getting closest ring peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.numContactedPeers++
-        this.config.contactedPeers.add(contact.getNodeId())
-        const returnedContacts = await contact.getClosestRingPeers(this.config.targetId)
-        this.config.peerManager.setContactActive(contact.getNodeId())
+        this.options.contactedPeers.add(contact.getNodeId())
+        const returnedContacts = await contact.getClosestRingPeers(this.options.targetId)
+        this.options.peerManager.setContactActive(contact.getNodeId())
         return returnedContacts
     }
 
@@ -60,7 +60,7 @@ export class RingDiscoverySession {
             return
         }
         this.ongoingRequests.delete(nodeId)
-        const oldClosestContacts = this.config.peerManager.getClosestRingContactsTo(this.config.targetId, 1)
+        const oldClosestContacts = this.options.peerManager.getClosestRingContactsTo(this.options.targetId, 1)
         const oldClosestLeftDistance = getLeftDistance(
             this.targetIdAsRingId,
             getRingIdFromPeerDescriptor(oldClosestContacts.left[0].getPeerDescriptor())
@@ -70,7 +70,7 @@ export class RingDiscoverySession {
             getRingIdFromPeerDescriptor(oldClosestContacts.right[0].getPeerDescriptor())
         )
         this.addContacts(contacts.left.concat(contacts.right))
-        const newClosestContacts = this.config.peerManager.getClosestRingContactsTo(this.config.targetId, 1)
+        const newClosestContacts = this.options.peerManager.getClosestRingContactsTo(this.options.targetId, 1)
         const newClosestLeftDistance = getLeftDistance(this.targetIdAsRingId,
             getRingIdFromPeerDescriptor(newClosestContacts.left[0].getPeerDescriptor()))
         const newClosestRightDistance = getLeftDistance(this.targetIdAsRingId,
@@ -85,20 +85,20 @@ export class RingDiscoverySession {
             return
         }
         this.ongoingRequests.delete(peer.getNodeId())
-        this.config.peerManager.removeContact(peer.getNodeId())
+        this.options.peerManager.removeContact(peer.getNodeId())
     }
 
     private findMoreContacts(): void {
-        if (this.config.abortSignal.aborted || this.doneGate.isOpen()) {
+        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
             return
         }
-        const uncontacted = this.config.peerManager.getClosestRingContactsTo(
-            this.config.targetId,
-            this.config.parallelism,
-            this.config.contactedPeers
+        const uncontacted = this.options.peerManager.getClosestRingContactsTo(
+            this.options.targetId,
+            this.options.parallelism,
+            this.options.contactedPeers
         )
         if ((uncontacted.left.length === 0 && uncontacted.right.length === 0)
-            || this.noProgressCounter >= this.config.noProgressLimit) {
+            || this.noProgressCounter >= this.options.noProgressLimit) {
             this.doneGate.open()
             return
         }
@@ -122,7 +122,7 @@ export class RingDiscoverySession {
         }
 
         for (const nextPeer of merged) {
-            if (this.ongoingRequests.size >= this.config.parallelism) {
+            if (this.ongoingRequests.size >= this.options.parallelism) {
                 break
             }
             this.ongoingRequests.add(nextPeer.getNodeId())
@@ -137,12 +137,12 @@ export class RingDiscoverySession {
     }
 
     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/recursive-operation/RecursiveOperationManager.ts

@@ -27,7 +27,7 @@ import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFro
 import { getDistance } from '../PeerManager'
 import { ConnectionsView } from '../../exports'
 
-interface RecursiveOperationManagerConfig {
+interface RecursiveOperationManagerOptions {
     rpcCommunicator: RoutingRpcCommunicator
     sessionTransport: ITransport
     router: Router
@@ -47,21 +47,21 @@ export class RecursiveOperationManager {
 
     private ongoingSessions: Map<string, RecursiveOperationSession> = new Map()
     private stopped = false
-    private readonly config: RecursiveOperationManagerConfig
+    private readonly options: RecursiveOperationManagerOptions
 
-    constructor(config: RecursiveOperationManagerConfig) {
-        this.config = config
+    constructor(options: RecursiveOperationManagerOptions) {
+        this.options = options
         this.registerLocalRpcMethods()
     }
 
     private registerLocalRpcMethods() {
         const rpcLocal = new RecursiveOperationRpcLocal({
             doRouteRequest: (routedMessage: RouteMessageWrapper) => this.doRouteRequest(routedMessage),
-            addContact: (contact: PeerDescriptor) => this.config.addContact(contact),
-            isMostLikelyDuplicate: (requestId: string) => this.config.router.isMostLikelyDuplicate(requestId),
-            addToDuplicateDetector: (requestId: string) => this.config.router.addToDuplicateDetector(requestId)
+            addContact: (contact: PeerDescriptor) => this.options.addContact(contact),
+            isMostLikelyDuplicate: (requestId: string) => this.options.router.isMostLikelyDuplicate(requestId),
+            addToDuplicateDetector: (requestId: string) => this.options.router.addToDuplicateDetector(requestId)
         })
-        this.config.rpcCommunicator.registerRpcMethod(
+        this.options.rpcCommunicator.registerRpcMethod(
             RouteMessageWrapper,
             RouteMessageAck,
             'routeRequest',
@@ -85,23 +85,23 @@ export class RecursiveOperationManager {
             return { closestNodes: [] }
         }
         const session = new RecursiveOperationSession({
-            transport: this.config.sessionTransport,
+            transport: this.options.sessionTransport,
             targetId,
-            localPeerDescriptor: this.config.localPeerDescriptor,
-            // TODO use config option or named constant?
-            waitedRoutingPathCompletions: this.config.connectionsView.getConnectionCount() > 1 ? 2 : 1,
+            localPeerDescriptor: this.options.localPeerDescriptor,
+            // TODO use options option or named constant?
+            waitedRoutingPathCompletions: this.options.connectionsView.getConnectionCount() > 1 ? 2 : 1,
             operation,
             // TODO would it make sense to give excludedPeer as one of the fields RecursiveOperationSession?
             doRouteRequest: (routedMessage: RouteMessageWrapper) => {
                 return this.doRouteRequest(routedMessage, excludedPeer)
             }
         })
-        if (this.config.connectionsView.getConnectionCount() === 0) {
-            const dataEntries = Array.from(this.config.localDataStore.values(targetId))
+        if (this.options.connectionsView.getConnectionCount() === 0) {
+            const dataEntries = Array.from(this.options.localDataStore.values(targetId))
             session.onResponseReceived(
-                getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor),
-                [this.config.localPeerDescriptor],
-                [this.config.localPeerDescriptor],
+                getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor),
+                [this.options.localPeerDescriptor],
+                [this.options.localPeerDescriptor],
                 dataEntries,
                 true
             )
@@ -111,27 +111,27 @@ export class RecursiveOperationManager {
         if (waitForCompletion === true) {
             try {
                 await runAndWaitForEvents3<RecursiveOperationSessionEvents>(
-                    [() => session.start(this.config.serviceId)],
+                    [() => session.start(this.options.serviceId)],
                     [[session, 'completed']],
-                    // TODO use config option or named constant?
+                    // TODO use options option or named constant?
                     15000
                 )
             } catch (err) {
                 logger.debug('start failed', { err })
             }
         } else {
-            session.start(this.config.serviceId)
+            session.start(this.options.serviceId)
             // Wait for delete operation to be sent out by the router
             // TODO: Add a feature to wait for the router to pass the message?
             await wait(50)
         }
         if (operation === RecursiveOperation.FETCH_DATA) {
-            const dataEntries = Array.from(this.config.localDataStore.values(targetId))
+            const dataEntries = Array.from(this.options.localDataStore.values(targetId))
             if (dataEntries.length > 0) {
-                this.sendResponse([this.config.localPeerDescriptor], this.config.localPeerDescriptor, session.getId(), [], dataEntries, true)
+                this.sendResponse([this.options.localPeerDescriptor], this.options.localPeerDescriptor, session.getId(), [], dataEntries, true)
             }
         } else if (operation === RecursiveOperation.DELETE_DATA) {
-            this.config.localDataStore.markAsDeleted(targetId, getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor))
+            this.options.localDataStore.markAsDeleted(targetId, getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor))
         }
         this.ongoingSessions.delete(session.getId())
         session.stop()
@@ -146,25 +146,25 @@ export class RecursiveOperationManager {
         dataEntries: DataEntry[],
         noCloserNodesFound: boolean = false
     ): void {
-        const isOwnNode = areEqualPeerDescriptors(this.config.localPeerDescriptor, targetPeerDescriptor)
+        const isOwnNode = areEqualPeerDescriptors(this.options.localPeerDescriptor, targetPeerDescriptor)
         if (isOwnNode && this.ongoingSessions.has(serviceId)) {
             this.ongoingSessions.get(serviceId)!
                 .onResponseReceived(
-                    getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor),
+                    getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor),
                     routingPath,
                     closestConnectedNodes,
                     dataEntries,
                     noCloserNodesFound
                 )
         } else {
-            // TODO use config option or named constant?
-            const remoteCommunicator = new ListeningRpcCommunicator(serviceId, this.config.sessionTransport, { rpcRequestTimeout: 15000 })
+            // TODO use options option or named constant?
+            const remoteCommunicator = new ListeningRpcCommunicator(serviceId, this.options.sessionTransport, { rpcRequestTimeout: 15000 })
             const rpcRemote = new RecursiveOperationSessionRpcRemote(
-                this.config.localPeerDescriptor,
+                this.options.localPeerDescriptor,
                 targetPeerDescriptor,
                 remoteCommunicator,
                 RecursiveOperationSessionRpcClient,
-                // TODO use config option or named constant?
+                // TODO use options option or named constant?
                 10000
             )
             rpcRemote.sendResponse(routingPath, closestConnectedNodes, dataEntries, noCloserNodesFound)
@@ -178,15 +178,15 @@ export class RecursiveOperationManager {
         }
         const targetId = getDhtAddressFromRaw(routedMessage.target)
         const request = (routedMessage.message!.body as { recursiveOperationRequest: RecursiveOperationRequest }).recursiveOperationRequest
-        // TODO use config option or named constant?
+        // TODO use options option or named constant?
         const closestConnectedNodes = this.getClosestConnectedNodes(targetId, 5)
         const dataEntries = (request.operation === RecursiveOperation.FETCH_DATA) 
-            ? Array.from(this.config.localDataStore.values(targetId))
+            ? Array.from(this.options.localDataStore.values(targetId))
             : []
         if (request.operation === RecursiveOperation.DELETE_DATA) {
-            this.config.localDataStore.markAsDeleted(targetId, getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!))
+            this.options.localDataStore.markAsDeleted(targetId, getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!))
         }
-        if (areEqualBinaries(this.config.localPeerDescriptor.nodeId, routedMessage.target)) {
+        if (areEqualBinaries(this.options.localPeerDescriptor.nodeId, routedMessage.target)) {
             // TODO this is also very similar case to what we do at line 255, could simplify the code paths?
             this.sendResponse(
                 routedMessage.routingPath,
@@ -198,7 +198,7 @@ export class RecursiveOperationManager {
             )
             return createRouteMessageAck(routedMessage)
         } else {
-            const ack = this.config.router.doRouteMessage(routedMessage, RoutingMode.RECURSIVE, excludedPeer)
+            const ack = this.options.router.doRouteMessage(routedMessage, RoutingMode.RECURSIVE, excludedPeer)
             if ((ack.error === undefined) || (ack.error === RouteMessageError.NO_TARGETS)) {
                 const noCloserContactsFound = (ack.error === RouteMessageError.NO_TARGETS) ||
                     (
@@ -220,7 +220,7 @@ export class RecursiveOperationManager {
     }
 
     private getClosestConnectedNodes(referenceId: DhtAddress, limit: number): PeerDescriptor[] {
-        const connectedNodes = this.config.connectionsView.getConnections().map((c) => this.config.createDhtNodeRpcRemote(c))
+        const connectedNodes = this.options.connectionsView.getConnections().map((c) => this.options.createDhtNodeRpcRemote(c))
         const sorted = new SortedContactList<DhtNodeRpcRemote>({
             referenceId,
             maxSize: limit,
@@ -233,7 +233,7 @@ export class RecursiveOperationManager {
     private isPeerCloserToIdThanSelf(peer: PeerDescriptor, nodeIdOrDataKey: DhtAddress): boolean {
         const nodeIdOrDataKeyRaw = getRawFromDhtAddress(nodeIdOrDataKey)
         const distance1 = getDistance(peer.nodeId, nodeIdOrDataKeyRaw)
-        const distance2 = getDistance(this.config.localPeerDescriptor.nodeId, nodeIdOrDataKeyRaw)
+        const distance2 = getDistance(this.options.localPeerDescriptor.nodeId, nodeIdOrDataKeyRaw)
         return distance1 < distance2
     }
 

package/src/dht/recursive-operation/RecursiveOperationRpcLocal.ts

@@ -7,7 +7,7 @@ import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
-interface RecursiveOperationRpcLocalConfig {
+interface RecursiveOperationRpcLocalOptions {
     doRouteRequest: (routedMessage: RouteMessageWrapper) => RouteMessageAck
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     isMostLikelyDuplicate: (requestId: string) => boolean
@@ -16,19 +16,19 @@ interface RecursiveOperationRpcLocalConfig {
 
 export class RecursiveOperationRpcLocal implements IRecursiveOperationRpc {
 
-    private readonly config: RecursiveOperationRpcLocalConfig
+    private readonly options: RecursiveOperationRpcLocalOptions
 
-    constructor(config: RecursiveOperationRpcLocalConfig) {
-        this.config = config
+    constructor(options: RecursiveOperationRpcLocalOptions) {
+        this.options = options
     }
 
     async routeRequest(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
-        if (this.config.isMostLikelyDuplicate(routedMessage.requestId)) {
+        if (this.options.isMostLikelyDuplicate(routedMessage.requestId)) {
             return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
         }
-        const senderId = getNodeIdFromPeerDescriptor(getPreviousPeer(routedMessage) ?? routedMessage.sourcePeer!)
-        logger.trace(`Received routeRequest call from ${senderId}`)
-        this.config.addToDuplicateDetector(routedMessage.requestId)
-        return this.config.doRouteRequest(routedMessage)
+        const remoteNodeId = getNodeIdFromPeerDescriptor(getPreviousPeer(routedMessage) ?? routedMessage.sourcePeer!)
+        logger.trace(`Received routeRequest call from ${remoteNodeId}`)
+        this.options.addToDuplicateDetector(routedMessage.requestId)
+        return this.options.doRouteRequest(routedMessage)
     }
 }

package/src/dht/recursive-operation/RecursiveOperationSession.ts

@@ -24,7 +24,7 @@ export interface RecursiveOperationSessionEvents {
     completed: () => void
 }
 
-export interface RecursiveOperationSessionConfig {
+export interface RecursiveOperationSessionOptions {
     transport: ITransport
     targetId: DhtAddress
     localPeerDescriptor: PeerDescriptor
@@ -45,18 +45,18 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     private completionEventEmitted = false
     private noCloserNodesReceivedCounter = 0
     private readonly noCloserNodesReceivedFrom: Set<DhtAddress> = new Set()
-    private readonly config: RecursiveOperationSessionConfig
+    private readonly options: RecursiveOperationSessionOptions
 
-    constructor(config: RecursiveOperationSessionConfig) {
+    constructor(options: RecursiveOperationSessionOptions) {
         super()
-        this.config = config
+        this.options = options
         this.results = new SortedContactList({
-            referenceId: config.targetId, 
-            maxSize: 10,  // TODO use config option or named constant?
+            referenceId: options.targetId, 
+            maxSize: 10,  // TODO use options option or named constant?
             allowToContainReferenceId: true
         })
-        this.rpcCommunicator = new ListeningRpcCommunicator(this.id, config.transport, {
-            rpcRequestTimeout: 15000  // TODO use config option or named constant?
+        this.rpcCommunicator = new ListeningRpcCommunicator(this.id, options.transport, {
+            rpcRequestTimeout: 15000  // TODO use options option or named constant?
         })
         this.registerLocalRpcMethods()
     }
@@ -64,13 +64,13 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     private registerLocalRpcMethods() {
         const rpcLocal = new RecursiveOperationSessionRpcLocal({
             onResponseReceived: (
-                sourceId: DhtAddress,
+                remoteNodeId: DhtAddress,
                 routingPath: PeerDescriptor[],
                 closestConnectedNodes: PeerDescriptor[],
                 dataEntries: DataEntry[],
                 noCloserNodesFound: boolean
             ) => {
-                this.onResponseReceived(sourceId, routingPath, closestConnectedNodes, dataEntries, noCloserNodesFound)
+                this.onResponseReceived(remoteNodeId, routingPath, closestConnectedNodes, dataEntries, noCloserNodesFound)
             }
         })
         this.rpcCommunicator.registerRpcNotification(RecursiveOperationResponse, 'sendResponse',
@@ -79,13 +79,13 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
 
     public start(serviceId: ServiceID): void {
         const routeMessage = this.wrapRequest(serviceId)
-        this.config.doRouteRequest(routeMessage)
+        this.options.doRouteRequest(routeMessage)
     }
 
     private wrapRequest(serviceId: ServiceID): RouteMessageWrapper {
         const request: RecursiveOperationRequest = {
             sessionId: this.getId(),
-            operation: this.config.operation
+            operation: this.options.operation
         }
         const msg: Message = {
             messageId: v4(),
@@ -98,8 +98,8 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
         const routeMessage: RouteMessageWrapper = {
             message: msg,
             requestId: v4(),
-            target: getRawFromDhtAddress(this.config.targetId),
-            sourcePeer: this.config.localPeerDescriptor,
+            target: getRawFromDhtAddress(this.options.targetId),
+            sourcePeer: this.options.localPeerDescriptor,
             reachableThrough: [],
             routingPath: [],
             parallelRootNodeIds: []
@@ -113,10 +113,10 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
             unreportedHops.delete(id)
         })
         if (this.noCloserNodesReceivedCounter >= 1 && unreportedHops.size === 0) {
-            if (this.config.operation === RecursiveOperation.FETCH_DATA
-                && (this.hasNonStaleData() || this.noCloserNodesReceivedCounter >= this.config.waitedRoutingPathCompletions)) {
+            if (this.options.operation === RecursiveOperation.FETCH_DATA
+                && (this.hasNonStaleData() || this.noCloserNodesReceivedCounter >= this.options.waitedRoutingPathCompletions)) {
                 return true
-            } else if (this.config.operation === RecursiveOperation.FETCH_DATA) {
+            } else if (this.options.operation === RecursiveOperation.FETCH_DATA) {
                 return false
             }
             return true
@@ -129,7 +129,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     }
 
     public onResponseReceived(
-        sourceId: DhtAddress,
+        remoteNodeId: DhtAddress,
         routingPath: PeerDescriptor[],
         closestConnectedNodes: PeerDescriptor[],
         dataEntries: DataEntry[],
@@ -143,13 +143,13 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
             this.results.addContact(new Contact(descriptor))
         })
         this.processFoundData(dataEntries)
-        if (noCloserNodesFound || this.noCloserNodesReceivedFrom.has(sourceId)) {
-            this.onNoCloserPeersFound(sourceId)
+        if (noCloserNodesFound || this.noCloserNodesReceivedFrom.has(remoteNodeId)) {
+            this.onNoCloserPeersFound(remoteNodeId)
         }
     }
 
     private addKnownHops(routingPath: PeerDescriptor[]) {
-        const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        const localNodeId = getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor)
         routingPath.forEach((desc) => {
             const newNodeId = getNodeIdFromPeerDescriptor(desc)
             if (localNodeId !== newNodeId) {
@@ -159,7 +159,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     }
 
     private setHopAsReported(desc: PeerDescriptor) {
-        const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        const localNodeId = getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor)
         const newNodeId = getNodeIdFromPeerDescriptor(desc)
         if (localNodeId !== newNodeId) {
             this.reportedHops.add(newNodeId)
@@ -187,9 +187,9 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
         })
     }
 
-    private onNoCloserPeersFound(sourceId: DhtAddress): void {
+    private onNoCloserPeersFound(remoteNodeId: DhtAddress): void {
         this.noCloserNodesReceivedCounter += 1
-        this.noCloserNodesReceivedFrom.add(sourceId)
+        this.noCloserNodesReceivedFrom.add(remoteNodeId)
         if (this.isCompleted()) {
             this.emit('completed')
             this.completionEventEmitted = true
@@ -203,7 +203,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
                     this.emit('completed')
                     this.completionEventEmitted = true
                 }
-            }, 4000)  // TODO use config option or named constant?
+            }, 4000)  // TODO use options option or named constant?
         }
     }
 

package/src/dht/recursive-operation/RecursiveOperationSessionRpcLocal.ts

@@ -8,9 +8,9 @@ import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
-interface RecursiveOperationSessionRpcLocalConfig {
+interface RecursiveOperationSessionRpcLocalOptions {
     onResponseReceived: (
-        sourceId: DhtAddress,
+        remoteNodeId: DhtAddress,
         routingPath: PeerDescriptor[],
         nodes: PeerDescriptor[],
         dataEntries: DataEntry[],
@@ -20,16 +20,16 @@ interface RecursiveOperationSessionRpcLocalConfig {
 
 export class RecursiveOperationSessionRpcLocal implements IRecursiveOperationSessionRpc {
 
-    private readonly config: RecursiveOperationSessionRpcLocalConfig
+    private readonly options: RecursiveOperationSessionRpcLocalOptions
 
-    constructor(config: RecursiveOperationSessionRpcLocalConfig) {
-        this.config = config
+    constructor(options: RecursiveOperationSessionRpcLocalOptions) {
+        this.options = options
     }
     
     async sendResponse(report: RecursiveOperationResponse, context: ServerCallContext): Promise<Empty> {
-        const sourceId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
+        const remoteNodeId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
         logger.trace('RecursiveOperationResponse arrived: ' + JSON.stringify(report))
-        this.config.onResponseReceived(sourceId, report.routingPath, report.closestConnectedNodes, report.dataEntries, report.noCloserNodesFound)
+        this.options.onResponseReceived(remoteNodeId, report.routingPath, report.closestConnectedNodes, report.dataEntries, report.noCloserNodesFound)
         return {}
     }
 }

package/src/dht/routing/Router.ts

@@ -8,7 +8,7 @@ import { RouterRpcLocal, createRouteMessageAck } from './RouterRpcLocal'
 import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { RoutingTablesCache } from './RoutingTablesCache'
 
-export interface RouterConfig {
+export interface RouterOptions {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
     handleMessage: (message: Message) => void
@@ -27,13 +27,13 @@ export class Router {
     private readonly forwardingTable: Map<DhtAddress, ForwardingTableEntry> = new Map()
     private readonly routingTablesCache = new RoutingTablesCache()
     private ongoingRoutingSessions: Map<string, RoutingSession> = new Map()
-    // TODO use config option or named constant?
+    // TODO use options option or named constant?
     private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(10000)
     private stopped = false
-    private readonly config: RouterConfig
+    private readonly options: RouterOptions
 
-    constructor(config: RouterConfig) {
-        this.config = config
+    constructor(options: RouterOptions) {
+        this.options = options
         this.registerLocalRpcMethods()
     }
 
@@ -42,10 +42,10 @@ export class Router {
             doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => this.doRouteMessage(routedMessage, mode),
             setForwardingEntries: (routedMessage: RouteMessageWrapper) => this.setForwardingEntries(routedMessage),
             duplicateRequestDetector: this.duplicateRequestDetector,
-            localPeerDescriptor: this.config.localPeerDescriptor,
-            handleMessage: this.config.handleMessage
+            localPeerDescriptor: this.options.localPeerDescriptor,
+            handleMessage: this.options.handleMessage
         })
-        this.config.rpcCommunicator.registerRpcMethod(
+        this.options.rpcCommunicator.registerRpcMethod(
             RouteMessageWrapper,
             RouteMessageAck,
             'routeMessage',
@@ -56,7 +56,7 @@ export class Router {
                 return rpcLocal.routeMessage(routedMessage)
             }
         )
-        this.config.rpcCommunicator.registerRpcMethod(
+        this.options.rpcCommunicator.registerRpcMethod(
             RouteMessageWrapper,
             RouteMessageAck,
             'forwardMessage',
@@ -71,7 +71,7 @@ export class Router {
     }
 
     public send(msg: Message, reachableThrough: PeerDescriptor[]): void {
-        msg.sourceDescriptor = this.config.localPeerDescriptor
+        msg.sourceDescriptor = this.options.localPeerDescriptor
         const targetPeerDescriptor = msg.targetDescriptor!
         const forwardingEntry = this.forwardingTable.get(getNodeIdFromPeerDescriptor(targetPeerDescriptor))
         if (forwardingEntry && forwardingEntry.peerDescriptors.length > 0) {
@@ -79,7 +79,7 @@ export class Router {
                 message: msg,
                 requestId: v4(),
                 target: forwardingEntry.peerDescriptors[0].nodeId,
-                sourcePeer: this.config.localPeerDescriptor,
+                sourcePeer: this.options.localPeerDescriptor,
                 reachableThrough,
                 routingPath: [],
                 parallelRootNodeIds: []
@@ -95,7 +95,7 @@ export class Router {
                 message: msg,
                 requestId: v4(),
                 target: targetPeerDescriptor.nodeId,
-                sourcePeer: this.config.localPeerDescriptor,
+                sourcePeer: this.options.localPeerDescriptor,
                 reachableThrough,
                 routingPath: [],
                 parallelRootNodeIds: []
@@ -132,7 +132,7 @@ export class Router {
             })
             setImmediate(async () => {
                 try {
-                    // TODO use config option or named constant?
+                    // TODO use options option or named constant?
                     await withTimeout(eventReceived, 10000)
                     logger.trace('raceEvents ended from routingSession: ' + session.sessionId)
                 } catch (e) {
@@ -158,15 +158,15 @@ export class Router {
             excludedNodeIds.add(nodeId as DhtAddress)
         })
         return new RoutingSession({
-            rpcCommunicator: this.config.rpcCommunicator,
-            localPeerDescriptor: this.config.localPeerDescriptor,
+            rpcCommunicator: this.options.rpcCommunicator,
+            localPeerDescriptor: this.options.localPeerDescriptor,
             routedMessage,
-            // TODO use config option or named constant?
-            parallelism: areEqualPeerDescriptors(this.config.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
+            // TODO use options option or named constant?
+            parallelism: areEqualPeerDescriptors(this.options.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
             mode,
             excludedNodeIds,
             routingTablesCache: this.routingTablesCache,
-            getConnections: this.config.getConnections
+            getConnections: this.options.getConnections
         })
     }
 
@@ -187,7 +187,7 @@ export class Router {
     }
 
     onNodeConnected(peerDescriptor: PeerDescriptor): void {
-        const remote = new RoutingRemoteContact(peerDescriptor, this.config.localPeerDescriptor, this.config.rpcCommunicator)
+        const remote = new RoutingRemoteContact(peerDescriptor, this.options.localPeerDescriptor, this.options.rpcCommunicator)
         this.routingTablesCache.onNodeConnected(remote)
     }
 
@@ -215,7 +215,7 @@ export class Router {
 
     private setForwardingEntries(routedMessage: RouteMessageWrapper): void {
         const reachableThroughWithoutSelf = routedMessage.reachableThrough.filter((peer) => {
-            return !areEqualPeerDescriptors(peer, this.config.localPeerDescriptor)
+            return !areEqualPeerDescriptors(peer, this.options.localPeerDescriptor)
         })
         
         if (reachableThroughWithoutSelf.length > 0) {
@@ -229,7 +229,7 @@ export class Router {
                 peerDescriptors: reachableThroughWithoutSelf,
                 timeout: setTimeout(() => {
                     this.forwardingTable.delete(sourceNodeId)
-                }, 10000)  // TODO use config option or named constant?
+                }, 10000)  // TODO use options option or named constant?
             }
             this.forwardingTable.set(sourceNodeId, forwardingEntry)
         }