@streamr/trackerless-network 100.2.5-beta.1 → 101.0.0-beta.1

package/src/logic/createContentDeliveryLayerNode.ts

@@ -2,7 +2,7 @@ import { DhtAddress, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } fro
 import { Handshaker } from './neighbor-discovery/Handshaker'
 import { NeighborFinder } from './neighbor-discovery/NeighborFinder'
 import { NeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
-import { StrictContentDeliveryLayerNodeConfig, ContentDeliveryLayerNode } from './ContentDeliveryLayerNode'
+import { StrictContentDeliveryLayerNodeOptions, ContentDeliveryLayerNode } from './ContentDeliveryLayerNode'
 import { NodeList } from './NodeList'
 import { Propagation } from './propagation/Propagation'
 import { StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
@@ -12,7 +12,7 @@ import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
 import { formStreamPartContentDeliveryServiceId } from './formStreamPartDeliveryServiceId'
 
-type ContentDeliveryLayerNodeConfig = MarkOptional<StrictContentDeliveryLayerNodeConfig,
+type ContentDeliveryLayerNodeOptions = MarkOptional<StrictContentDeliveryLayerNodeOptions,
     'nearbyNodeView' | 'randomNodeView' | 'neighbors' | 'leftNodeView' | 'rightNodeView' | 'propagation'
     | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'neighborTargetCount'
     | 'rpcCommunicator' | 'nodeViewSize'
@@ -23,36 +23,36 @@ type ContentDeliveryLayerNodeConfig = MarkOptional<StrictContentDeliveryLayerNod
         neighborUpdateInterval?: number
     }
 
-const createConfigWithDefaults = (config: ContentDeliveryLayerNodeConfig): StrictContentDeliveryLayerNodeConfig => {
-    const ownNodeId = getNodeIdFromPeerDescriptor(config.localPeerDescriptor)
-    const rpcCommunicator = config.rpcCommunicator ?? new ListeningRpcCommunicator(
-        formStreamPartContentDeliveryServiceId(config.streamPartId),
-        config.transport
+const createConfigWithDefaults = (options: ContentDeliveryLayerNodeOptions): StrictContentDeliveryLayerNodeOptions => {
+    const ownNodeId = getNodeIdFromPeerDescriptor(options.localPeerDescriptor)
+    const rpcCommunicator = options.rpcCommunicator ?? new ListeningRpcCommunicator(
+        formStreamPartContentDeliveryServiceId(options.streamPartId),
+        options.transport
     )
-    const neighborTargetCount = config.neighborTargetCount ?? 4
-    const maxContactCount = config.maxContactCount ?? 20
-    const minPropagationTargets = config.minPropagationTargets ?? 2
-    const acceptProxyConnections = config.acceptProxyConnections ?? false
-    const neighborUpdateInterval = config.neighborUpdateInterval ?? 10000
-    const neighbors = config.neighbors ?? new NodeList(ownNodeId, maxContactCount)
-    const leftNodeView = config.leftNodeView ?? new NodeList(ownNodeId, maxContactCount)
-    const rightNodeView = config.rightNodeView ?? new NodeList(ownNodeId, maxContactCount)
-    const nearbyNodeView = config.nearbyNodeView ?? new NodeList(ownNodeId, maxContactCount)
-    const randomNodeView = config.randomNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const neighborTargetCount = options.neighborTargetCount ?? 4
+    const maxContactCount = options.maxContactCount ?? 20
+    const minPropagationTargets = options.minPropagationTargets ?? 2
+    const acceptProxyConnections = options.acceptProxyConnections ?? false
+    const neighborUpdateInterval = options.neighborUpdateInterval ?? 10000
+    const neighbors = options.neighbors ?? new NodeList(ownNodeId, maxContactCount)
+    const leftNodeView = options.leftNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const rightNodeView = options.rightNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const nearbyNodeView = options.nearbyNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const randomNodeView = options.randomNodeView ?? new NodeList(ownNodeId, maxContactCount)
     const ongoingHandshakes = new Set<DhtAddress>()
 
     const temporaryConnectionRpcLocal = new TemporaryConnectionRpcLocal({
         rpcCommunicator,
-        localPeerDescriptor: config.localPeerDescriptor,
-        streamPartId: config.streamPartId,
-        connectionLocker: config.connectionLocker
+        localPeerDescriptor: options.localPeerDescriptor,
+        streamPartId: options.streamPartId,
+        connectionLocker: options.connectionLocker
     })
     const proxyConnectionRpcLocal = acceptProxyConnections ? new ProxyConnectionRpcLocal({
-        localPeerDescriptor: config.localPeerDescriptor,
-        streamPartId: config.streamPartId,
+        localPeerDescriptor: options.localPeerDescriptor,
+        streamPartId: options.streamPartId,
         rpcCommunicator
     }) : undefined
-    const propagation = config.propagation ?? new Propagation({
+    const propagation = options.propagation ?? new Propagation({
         minPropagationTargets,
         sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
             const remote = neighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId)
@@ -66,9 +66,9 @@ const createConfigWithDefaults = (config: ContentDeliveryLayerNodeConfig): Stric
             }
         }
     })
-    const handshaker = config.handshaker ?? new Handshaker({
-        localPeerDescriptor: config.localPeerDescriptor,
-        streamPartId: config.streamPartId,
+    const handshaker = options.handshaker ?? new Handshaker({
+        localPeerDescriptor: options.localPeerDescriptor,
+        streamPartId: options.streamPartId,
         rpcCommunicator,
         neighbors,
         leftNodeView,
@@ -76,10 +76,10 @@ const createConfigWithDefaults = (config: ContentDeliveryLayerNodeConfig): Stric
         nearbyNodeView,
         randomNodeView,
         maxNeighborCount: neighborTargetCount,
-        rpcRequestTimeout: config.rpcRequestTimeout,
+        rpcRequestTimeout: options.rpcRequestTimeout,
         ongoingHandshakes
     })
-    const neighborFinder = config.neighborFinder ?? new NeighborFinder({
+    const neighborFinder = options.neighborFinder ?? new NeighborFinder({
         neighbors,
         leftNodeView,
         rightNodeView,
@@ -88,25 +88,25 @@ const createConfigWithDefaults = (config: ContentDeliveryLayerNodeConfig): Stric
         doFindNeighbors: (excludedIds) => handshaker.attemptHandshakesOnContacts(excludedIds),
         minCount: neighborTargetCount
     })
-    const neighborUpdateManager = config.neighborUpdateManager ?? new NeighborUpdateManager({
+    const neighborUpdateManager = options.neighborUpdateManager ?? new NeighborUpdateManager({
         neighbors,
         nearbyNodeView,
-        localPeerDescriptor: config.localPeerDescriptor,
+        localPeerDescriptor: options.localPeerDescriptor,
         neighborFinder,
-        streamPartId: config.streamPartId,
+        streamPartId: options.streamPartId,
         rpcCommunicator,
         neighborUpdateInterval,
         neighborTargetCount,
         ongoingHandshakes
     })
-    const inspector = config.inspector ?? new Inspector({
-        localPeerDescriptor: config.localPeerDescriptor,
+    const inspector = options.inspector ?? new Inspector({
+        localPeerDescriptor: options.localPeerDescriptor,
         rpcCommunicator,
-        streamPartId: config.streamPartId,
-        connectionLocker: config.connectionLocker
+        streamPartId: options.streamPartId,
+        connectionLocker: options.connectionLocker
     })
     return {
-        ...config,
+        ...options,
         neighbors,
         leftNodeView,
         rightNodeView,
@@ -125,6 +125,6 @@ const createConfigWithDefaults = (config: ContentDeliveryLayerNodeConfig): Stric
     }
 }
 
-export const createContentDeliveryLayerNode = (config: ContentDeliveryLayerNodeConfig): ContentDeliveryLayerNode => {
-    return new ContentDeliveryLayerNode(createConfigWithDefaults(config))
+export const createContentDeliveryLayerNode = (options: ContentDeliveryLayerNodeOptions): ContentDeliveryLayerNode => {
+    return new ContentDeliveryLayerNode(createConfigWithDefaults(options))
 }

package/src/logic/inspect/InspectSession.ts

@@ -7,7 +7,7 @@ export interface Events {
     done: () => void
 }
 
-interface InspectSessionConfig {
+interface InspectSessionOptions {
     inspectedNode: DhtAddress
 }
 
@@ -20,18 +20,18 @@ export class InspectSession extends EventEmitter<Events> {
     private readonly inspectionMessages: Map<string, boolean> = new Map()
     private readonly inspectedNode: DhtAddress
 
-    constructor(config: InspectSessionConfig) {
+    constructor(options: InspectSessionOptions) {
         super()
-        this.inspectedNode = config.inspectedNode
+        this.inspectedNode = options.inspectedNode
     }
 
-    markMessage(senderId: DhtAddress, messageId: MessageID): void {
+    markMessage(remoteNodeId: DhtAddress, messageId: MessageID): void {
         const messageKey = createMessageKey(messageId)
         if (!this.inspectionMessages.has(messageKey)) {
-            this.inspectionMessages.set(messageKey, senderId === this.inspectedNode)
+            this.inspectionMessages.set(messageKey, remoteNodeId === this.inspectedNode)
         } else if (this.inspectionMessages.has(messageKey)
             && this.inspectionMessages.get(messageKey) === false
-            && senderId === this.inspectedNode
+            && remoteNodeId === this.inspectedNode
         ) {
             this.emit('done')
         } else if (this.inspectionMessages.has(messageKey)

package/src/logic/inspect/Inspector.ts

@@ -6,7 +6,7 @@ import { Logger, waitForEvent3 } from '@streamr/utils'
 import { TemporaryConnectionRpcRemote } from '../temporary-connection/TemporaryConnectionRpcRemote'
 import { StreamPartID } from '@streamr/protocol'
 
-interface InspectorConfig {
+interface InspectorOptions {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
@@ -30,14 +30,14 @@ export class Inspector {
     private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
     private readonly closeInspectConnection: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
 
-    constructor(config: InspectorConfig) {
-        this.streamPartId = config.streamPartId
-        this.localPeerDescriptor = config.localPeerDescriptor
-        this.rpcCommunicator = config.rpcCommunicator
-        this.connectionLocker = config.connectionLocker
-        this.inspectionTimeout = config.inspectionTimeout ?? DEFAULT_TIMEOUT
-        this.openInspectConnection = config.openInspectConnection ?? this.defaultOpenInspectConnection
-        this.closeInspectConnection = config.closeInspectConnection ?? this.defaultCloseInspectConnection
+    constructor(options: InspectorOptions) {
+        this.streamPartId = options.streamPartId
+        this.localPeerDescriptor = options.localPeerDescriptor
+        this.rpcCommunicator = options.rpcCommunicator
+        this.connectionLocker = options.connectionLocker
+        this.inspectionTimeout = options.inspectionTimeout ?? DEFAULT_TIMEOUT
+        this.openInspectConnection = options.openInspectConnection ?? this.defaultOpenInspectConnection
+        this.closeInspectConnection = options.closeInspectConnection ?? this.defaultCloseInspectConnection
     }
 
     async defaultOpenInspectConnection(peerDescriptor: PeerDescriptor, lockId: LockID): Promise<void> {

package/src/logic/neighbor-discovery/HandshakeRpcLocal.ts

@@ -20,7 +20,7 @@ import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { Logger } from '@streamr/utils'
 import { StreamPartID } from '@streamr/protocol'
 
-interface HandshakeRpcLocalConfig {
+interface HandshakeRpcLocalOptions {
     streamPartId: StreamPartID
     neighbors: NodeList
     ongoingHandshakes: Set<DhtAddress>
@@ -28,17 +28,17 @@ interface HandshakeRpcLocalConfig {
     maxNeighborCount: number
     createRpcRemote: (target: PeerDescriptor) => HandshakeRpcRemote
     createContentDeliveryRpcRemote: (peerDescriptor: PeerDescriptor) => ContentDeliveryRpcRemote
-    handshakeWithInterleaving: (target: PeerDescriptor, senderId: DhtAddress) => Promise<boolean>
+    handshakeWithInterleaving: (target: PeerDescriptor, remoteNodeId: DhtAddress) => Promise<boolean>
 }
 
 const logger = new Logger(module)
 
 export class HandshakeRpcLocal implements IHandshakeRpc {
 
-    private readonly config: HandshakeRpcLocalConfig
+    private readonly options: HandshakeRpcLocalOptions
 
-    constructor(config: HandshakeRpcLocalConfig) {
-        this.config = config
+    constructor(options: HandshakeRpcLocalOptions) {
+        this.options = options
     }
 
     async handshake(request: StreamPartHandshakeRequest, context: ServerCallContext): Promise<StreamPartHandshakeResponse> {
@@ -47,19 +47,19 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
 
     private handleRequest(request: StreamPartHandshakeRequest, context: ServerCallContext): StreamPartHandshakeResponse {
         const senderDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const getInterleaveSourceIds = () => (request.interleaveSourceId !== undefined) ? [getDhtAddressFromRaw(request.interleaveSourceId)] : []
+        const getInterleaveNodeIds = () => (request.interleaveNodeId !== undefined) ? [getDhtAddressFromRaw(request.interleaveNodeId)] : []
         const senderNodeId = getNodeIdFromPeerDescriptor(senderDescriptor)
-        if (this.config.ongoingInterleaves.has(senderNodeId)) {
+        if (this.options.ongoingInterleaves.has(senderNodeId)) {
             return this.rejectHandshake(request)
-        } else if (this.config.neighbors.has(senderNodeId)
-            || this.config.ongoingHandshakes.has(senderNodeId)
+        } else if (this.options.neighbors.has(senderNodeId)
+            || this.options.ongoingHandshakes.has(senderNodeId)
         ) {
             return this.acceptHandshake(request, senderDescriptor)
-        } else if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
+        } else if (this.options.neighbors.size() + this.options.ongoingHandshakes.size < this.options.maxNeighborCount) {
             return this.acceptHandshake(request, senderDescriptor)
         } else if (
-            this.config.neighbors.size(getInterleaveSourceIds()) - this.config.ongoingInterleaves.size >= 2
-            && this.config.neighbors.size() <= this.config.maxNeighborCount
+            this.options.neighbors.size(getInterleaveNodeIds()) - this.options.ongoingInterleaves.size >= 2
+            && this.options.neighbors.size() <= this.options.maxNeighborCount
         ) {
             // Do not accept the handshakes requests if the target neighbor count can potentially drop below 2 
             // due to interleaving. This ensures that a stable number of connections is kept during high churn.
@@ -74,7 +74,7 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
             requestId: request.requestId,
             accepted: true
         }
-        this.config.neighbors.add(this.config.createContentDeliveryRpcRemote(requester))
+        this.options.neighbors.add(this.options.createContentDeliveryRpcRemote(requester))
         return res
     }
 
@@ -89,18 +89,18 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
 
     private acceptHandshakeWithInterleaving(request: StreamPartHandshakeRequest, requester: PeerDescriptor): StreamPartHandshakeResponse {
         const exclude: DhtAddress[] = []
-        request.neighborIds.forEach((id: DhtAddressRaw) => exclude.push(getDhtAddressFromRaw(id)))
-        this.config.ongoingInterleaves.forEach((id) => exclude.push(id))
+        request.neighborNodeIds.forEach((id: DhtAddressRaw) => exclude.push(getDhtAddressFromRaw(id)))
+        this.options.ongoingInterleaves.forEach((id) => exclude.push(id))
         exclude.push(getNodeIdFromPeerDescriptor(requester))
-        if (request.interleaveSourceId !== undefined) {
-            exclude.push(getDhtAddressFromRaw(request.interleaveSourceId))
+        if (request.interleaveNodeId !== undefined) {
+            exclude.push(getDhtAddressFromRaw(request.interleaveNodeId))
         }
-        const last = this.config.neighbors.getLast(exclude)
+        const last = this.options.neighbors.getLast(exclude)
         const lastPeerDescriptor = last ? last.getPeerDescriptor() : undefined
         if (last) {
             const nodeId = getNodeIdFromPeerDescriptor(last.getPeerDescriptor())
-            const remote = this.config.createRpcRemote(last.getPeerDescriptor())
-            this.config.ongoingInterleaves.add(nodeId)
+            const remote = this.options.createRpcRemote(last.getPeerDescriptor())
+            this.options.ongoingInterleaves.add(nodeId)
             // Run this with then catch instead of setImmediate to avoid changes in state
             // eslint-disable-next-line promise/catch-or-return
             remote.interleaveRequest(requester).then((response) => {
@@ -108,15 +108,15 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
                 // and unlock the connection
                 // If response is not accepted, keep the last node as a neighbor
                 if (response.accepted) {
-                    this.config.neighbors.remove(getNodeIdFromPeerDescriptor(lastPeerDescriptor!))
+                    this.options.neighbors.remove(getNodeIdFromPeerDescriptor(lastPeerDescriptor!))
                 }
             }).catch(() => {
                 // no-op: InterleaveRequest cannot reject
             }).finally(() => {
-                this.config.ongoingInterleaves.delete(nodeId)
+                this.options.ongoingInterleaves.delete(nodeId)
             })
         }
-        this.config.neighbors.add(this.config.createContentDeliveryRpcRemote(requester))
+        this.options.neighbors.add(this.options.createContentDeliveryRpcRemote(requester))
         return {
             requestId: request.requestId,
             accepted: true,
@@ -126,10 +126,10 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
 
     async interleaveRequest(message: InterleaveRequest, context: ServerCallContext): Promise<InterleaveResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        const remoteNodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
         try {
-            await this.config.handshakeWithInterleaving(message.interleaveTargetDescriptor!, senderId)
-            this.config.neighbors.remove(senderId)
+            await this.options.handshakeWithInterleaving(message.interleaveTargetDescriptor!, remoteNodeId)
+            this.options.neighbors.remove(remoteNodeId)
             return { accepted: true }
         } catch (err) {
             logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(message.interleaveTargetDescriptor!)} failed`, { err })

package/src/logic/neighbor-discovery/HandshakeRpcRemote.ts

@@ -18,16 +18,16 @@ export class HandshakeRpcRemote extends RpcRemote<HandshakeRpcClient> {
 
     async handshake(
         streamPartId: StreamPartID,
-        neighborIds: DhtAddress[],
-        concurrentHandshakeTargetId?: DhtAddress,
-        interleaveSourceId?: DhtAddress
+        neighborNodeIds: DhtAddress[],
+        concurrentHandshakeNodeId?: DhtAddress,
+        interleaveNodeId?: DhtAddress
     ): Promise<HandshakeResponse> {
         const request: StreamPartHandshakeRequest = {
             streamPartId,
             requestId: v4(),
-            neighborIds: neighborIds.map((id) => getRawFromDhtAddress(id)),
-            concurrentHandshakeTargetId: (concurrentHandshakeTargetId !== undefined) ? getRawFromDhtAddress(concurrentHandshakeTargetId) : undefined,
-            interleaveSourceId: (interleaveSourceId !== undefined) ? getRawFromDhtAddress(interleaveSourceId) : undefined
+            neighborNodeIds: neighborNodeIds.map((id) => getRawFromDhtAddress(id)),
+            concurrentHandshakeNodeId: (concurrentHandshakeNodeId !== undefined) ? getRawFromDhtAddress(concurrentHandshakeNodeId) : undefined,
+            interleaveNodeId: (interleaveNodeId !== undefined) ? getRawFromDhtAddress(interleaveNodeId) : undefined
         }
         try {
             const response = await this.getClient().handshake(request, this.formDhtRpcOptions())

package/src/logic/neighbor-discovery/Handshaker.ts

@@ -15,7 +15,7 @@ import { HandshakeRpcRemote, INTERLEAVE_REQUEST_TIMEOUT } from './HandshakeRpcRe
 import { HandshakeRpcLocal } from './HandshakeRpcLocal'
 import { StreamPartID } from '@streamr/protocol'
 
-interface HandshakerConfig {
+interface HandshakerOptions {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     neighbors: NodeList
@@ -35,33 +35,33 @@ const PARALLEL_HANDSHAKE_COUNT = 2
 
 export class Handshaker {
 
-    private config: HandshakerConfig
+    private options: HandshakerOptions
     private readonly rpcLocal: HandshakeRpcLocal
 
-    constructor(config: HandshakerConfig) {
-        this.config = config
+    constructor(options: HandshakerOptions) {
+        this.options = options
         this.rpcLocal = new HandshakeRpcLocal({
-            streamPartId: this.config.streamPartId,
-            neighbors: this.config.neighbors,
-            ongoingHandshakes: this.config.ongoingHandshakes,
+            streamPartId: this.options.streamPartId,
+            neighbors: this.options.neighbors,
+            ongoingHandshakes: this.options.ongoingHandshakes,
             ongoingInterleaves: new Set(),
-            maxNeighborCount: this.config.maxNeighborCount,
-            handshakeWithInterleaving: (target: PeerDescriptor, senderId: DhtAddress) => this.handshakeWithInterleaving(target, senderId),
+            maxNeighborCount: this.options.maxNeighborCount,
+            handshakeWithInterleaving: (target: PeerDescriptor, remoteNodeId: DhtAddress) => this.handshakeWithInterleaving(target, remoteNodeId),
             createRpcRemote: (target: PeerDescriptor) => this.createRpcRemote(target),
             createContentDeliveryRpcRemote: (target: PeerDescriptor) => this.createContentDeliveryRpcRemote(target)
         })
-        this.config.rpcCommunicator.registerRpcMethod(InterleaveRequest, InterleaveResponse, 'interleaveRequest',
+        this.options.rpcCommunicator.registerRpcMethod(InterleaveRequest, InterleaveResponse, 'interleaveRequest',
             (req: InterleaveRequest, context) => this.rpcLocal.interleaveRequest(req, context), { timeout: INTERLEAVE_REQUEST_TIMEOUT })
-        this.config.rpcCommunicator.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake',
+        this.options.rpcCommunicator.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake',
             (req: StreamPartHandshakeRequest, context) => this.rpcLocal.handshake(req, context))
     }
 
     async attemptHandshakesOnContacts(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
-        // TODO use config option or named constant? or why the value 2?
-        if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount - 2) {
+        // TODO use options option or named constant? or why the value 2?
+        if (this.options.neighbors.size() + this.options.ongoingHandshakes.size < this.options.maxNeighborCount - 2) {
             logger.trace(`Attempting parallel handshakes with ${PARALLEL_HANDSHAKE_COUNT} targets`)
             return this.selectParallelTargetsAndHandshake(excludedIds)
-        } else if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
+        } else if (this.options.neighbors.size() + this.options.ongoingHandshakes.size < this.options.maxNeighborCount) {
             logger.trace(`Attempting handshake with new target`)
             return this.selectNewTargetAndHandshake(excludedIds)
         }
@@ -69,17 +69,17 @@ export class Handshaker {
     }
 
     private async selectParallelTargetsAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
-        const exclude = excludedIds.concat(this.config.neighbors.getIds())
+        const exclude = excludedIds.concat(this.options.neighbors.getIds())
         const neighbors = this.selectParallelTargets(exclude)
-        neighbors.forEach((contact) => this.config.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
+        neighbors.forEach((contact) => this.options.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
         return this.doParallelHandshakes(neighbors, exclude)
     }
 
     private selectParallelTargets(excludedIds: DhtAddress[]): HandshakeRpcRemote[] {
         const neighbors: Map<DhtAddress, ContentDeliveryRpcRemote> = new Map()
         // First add the closest left and then right contacts from the ring if possible.
-        const left = this.config.leftNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
-        const right = this.config.rightNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
+        const left = this.options.leftNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
+        const right = this.options.rightNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
         if (left) {
             neighbors.set(getNodeIdFromPeerDescriptor(left.getPeerDescriptor()), left)
         }
@@ -88,7 +88,7 @@ export class Handshaker {
         }
         // If there is still room add the closest contact based on the kademlia metric
         if (neighbors.size < PARALLEL_HANDSHAKE_COUNT) {
-            const first = this.config.nearbyNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
+            const first = this.options.nearbyNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
             if (first) {
                 neighbors.set(getNodeIdFromPeerDescriptor(first.getPeerDescriptor()), first)
             }
@@ -100,9 +100,9 @@ export class Handshaker {
         // If there is still room add a random contact until PARALLEL_HANDSHAKE_COUNT is reached
         while (
             neighbors.size < PARALLEL_HANDSHAKE_COUNT 
-            && this.config.randomNodeView.size(getExcludedFromRandomView()) > 0
+            && this.options.randomNodeView.size(getExcludedFromRandomView()) > 0
         ) {
-            const random = this.config.randomNodeView.getRandom([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
+            const random = this.options.randomNodeView.getRandom([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
             if (random) {
                 neighbors.set(getNodeIdFromPeerDescriptor(random.getPeerDescriptor()), random)
             }
@@ -128,11 +128,11 @@ export class Handshaker {
     }
 
     private async selectNewTargetAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
-        const exclude = excludedIds.concat(this.config.neighbors.getIds())
-        const neighbor = this.config.leftNodeView.getFirst(exclude) 
-            ?? this.config.rightNodeView.getFirst(exclude)
-            ?? this.config.nearbyNodeView.getFirst(exclude)
-            ?? this.config.randomNodeView.getRandom(exclude)
+        const exclude = excludedIds.concat(this.options.neighbors.getIds())
+        const neighbor = this.options.leftNodeView.getFirst(exclude) 
+            ?? this.options.rightNodeView.getFirst(exclude)
+            ?? this.options.nearbyNodeView.getFirst(exclude)
+            ?? this.options.randomNodeView.getRandom(exclude)
         if (neighbor) {
             const accepted = await this.handshakeWithTarget(this.createRpcRemote(neighbor.getPeerDescriptor()))
             if (!accepted) {
@@ -144,61 +144,61 @@ export class Handshaker {
 
     private async handshakeWithTarget(neighbor: HandshakeRpcRemote, concurrentNodeId?: DhtAddress): Promise<boolean> {
         const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
-        this.config.ongoingHandshakes.add(targetNodeId)
+        this.options.ongoingHandshakes.add(targetNodeId)
         const result = await neighbor.handshake(
-            this.config.streamPartId,
-            this.config.neighbors.getIds(),
+            this.options.streamPartId,
+            this.options.neighbors.getIds(),
             concurrentNodeId
         )
         if (result.accepted) {
-            this.config.neighbors.add(this.createContentDeliveryRpcRemote(neighbor.getPeerDescriptor()))
+            this.options.neighbors.add(this.createContentDeliveryRpcRemote(neighbor.getPeerDescriptor()))
         }
         if (result.interleaveTargetDescriptor) {
             await this.handshakeWithInterleaving(result.interleaveTargetDescriptor, targetNodeId)
         }
-        this.config.ongoingHandshakes.delete(targetNodeId)
+        this.options.ongoingHandshakes.delete(targetNodeId)
         return result.accepted
     }
 
-    private async handshakeWithInterleaving(target: PeerDescriptor, interleaveSourceId: DhtAddress): Promise<boolean> {
+    private async handshakeWithInterleaving(target: PeerDescriptor, remoteNodeId: DhtAddress): Promise<boolean> {
         const neighbor = this.createRpcRemote(target)
         const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
-        this.config.ongoingHandshakes.add(targetNodeId)
+        this.options.ongoingHandshakes.add(targetNodeId)
         const result = await neighbor.handshake(
-            this.config.streamPartId,
-            this.config.neighbors.getIds(),
+            this.options.streamPartId,
+            this.options.neighbors.getIds(),
             undefined,
-            interleaveSourceId
+            remoteNodeId
         )
         if (result.accepted) {
-            this.config.neighbors.add(this.createContentDeliveryRpcRemote(neighbor.getPeerDescriptor()))
+            this.options.neighbors.add(this.createContentDeliveryRpcRemote(neighbor.getPeerDescriptor()))
         }
-        this.config.ongoingHandshakes.delete(targetNodeId)
+        this.options.ongoingHandshakes.delete(targetNodeId)
         return result.accepted
     }
 
     private createRpcRemote(targetPeerDescriptor: PeerDescriptor): HandshakeRpcRemote {
         return new HandshakeRpcRemote(
-            this.config.localPeerDescriptor,
+            this.options.localPeerDescriptor,
             targetPeerDescriptor,
-            this.config.rpcCommunicator,
+            this.options.rpcCommunicator,
             HandshakeRpcClient,
-            this.config.rpcRequestTimeout
+            this.options.rpcRequestTimeout
         )
     }
 
     private createContentDeliveryRpcRemote(targetPeerDescriptor: PeerDescriptor): ContentDeliveryRpcRemote {
         return new ContentDeliveryRpcRemote(
-            this.config.localPeerDescriptor,
+            this.options.localPeerDescriptor,
             targetPeerDescriptor,
-            this.config.rpcCommunicator,
+            this.options.rpcCommunicator,
             ContentDeliveryRpcClient,
-            this.config.rpcRequestTimeout
+            this.options.rpcRequestTimeout
         )
     }
 
     getOngoingHandshakes(): Set<DhtAddress> {
-        return this.config.ongoingHandshakes
+        return this.options.ongoingHandshakes
     }
 
 }

package/src/logic/neighbor-discovery/NeighborFinder.ts

@@ -2,7 +2,7 @@ import { setAbortableTimeout } from '@streamr/utils'
 import { NodeList } from '../NodeList'
 import { DhtAddress } from '@streamr/dht'
 
-interface FindNeighborsSessionConfig {
+interface FindNeighborsSessionOptions {
     neighbors: NodeList
     nearbyNodeView: NodeList
     leftNodeView: NodeList
@@ -17,11 +17,11 @@ const INTERVAL = 250
 
 export class NeighborFinder {
     private readonly abortController: AbortController
-    private readonly config: FindNeighborsSessionConfig
+    private readonly options: FindNeighborsSessionOptions
     private running = false
 
-    constructor(config: FindNeighborsSessionConfig) {
-        this.config = config
+    constructor(options: FindNeighborsSessionOptions) {
+        this.options = options
         this.abortController = new AbortController()
     }
 
@@ -29,14 +29,14 @@ export class NeighborFinder {
         if (!this.running) {
             return
         }
-        const newExcludes = await this.config.doFindNeighbors(excluded)
+        const newExcludes = await this.options.doFindNeighbors(excluded)
         const uniqueContactCount = new Set([
-            ...this.config.nearbyNodeView.getIds(),
-            ...this.config.leftNodeView.getIds(),
-            ...this.config.rightNodeView.getIds(),
-            ...this.config.randomNodeView.getIds()
+            ...this.options.nearbyNodeView.getIds(),
+            ...this.options.leftNodeView.getIds(),
+            ...this.options.rightNodeView.getIds(),
+            ...this.options.randomNodeView.getIds()
         ]).size
-        if (this.config.neighbors.size() < this.config.minCount && newExcludes.length < uniqueContactCount) {
+        if (this.options.neighbors.size() < this.options.minCount && newExcludes.length < uniqueContactCount) {
             // TODO should we catch possible promise rejection?
             setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL, this.abortController.signal)
         } else {