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

package/src/dht/DhtNode.ts

@@ -11,7 +11,7 @@ import { sample } from 'lodash'
 import { MarkRequired } from 'ts-essentials'
 import { ConnectionLocker, ConnectionManager, PortRange, TlsCertificate } from '../connection/ConnectionManager'
 import { ConnectionsView } from '../connection/ConnectionsView'
-import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../connection/ConnectorFacade'
+import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../connection/ConnectorFacade'
 import { IceServer } from '../connection/webrtc/WebrtcConnector'
 import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
 import { createPeerDescriptor } from '../helpers/createPeerDescriptor'
@@ -67,7 +67,7 @@ export interface DhtNodeEvents {
 export interface DhtNodeOptions {
     serviceId?: ServiceID
     joinParallelism?: number
-    maxNeighborListSize?: number
+    maxContactCount?: number
     numberOfNodesPerKBucket?: number
     joinNoProgressLimit?: number
     peerDiscoveryQueryBatchSize?: number
@@ -96,7 +96,6 @@ export interface DhtNodeOptions {
     webrtcAllowPrivateAddresses?: boolean
     webrtcDatachannelBufferThresholdLow?: number
     webrtcDatachannelBufferThresholdHigh?: number
-    webrtcNewConnectionTimeout?: number
     webrtcPortRange?: PortRange
     maxMessageSize?: number
     maxConnections?: number
@@ -110,7 +109,7 @@ export interface DhtNodeOptions {
 type StrictDhtNodeOptions = MarkRequired<DhtNodeOptions,
     'serviceId' |
     'joinParallelism' |
-    'maxNeighborListSize' |
+    'maxContactCount' |
     'numberOfNodesPerKBucket' |
     'joinNoProgressLimit' |
     'dhtJoinTimeout' |
@@ -126,11 +125,14 @@ const logger = new Logger(module)
 
 const PERIODICAL_PING_INTERVAL = 60 * 1000
 
+// TODO move this to trackerless-network package and change serviceId to be a required paramater
+export const CONTROL_LAYER_NODE_SERVICE_ID = 'layer0'
+
 export type Events = TransportEvents & DhtNodeEvents
 
 export class DhtNode extends EventEmitter<Events> implements ITransport {
 
-    private readonly config: StrictDhtNodeOptions
+    private readonly options: StrictDhtNodeOptions
     private rpcCommunicator?: RoutingRpcCommunicator
     private transport?: ITransport
     private localPeerDescriptor?: PeerDescriptor
@@ -147,10 +149,10 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     constructor(conf: DhtNodeOptions) {
         super()
-        this.config = merge({
-            serviceId: 'layer0',
+        this.options = merge({
+            serviceId: CONTROL_LAYER_NODE_SERVICE_ID,
             joinParallelism: 3,
-            maxNeighborListSize: 200,
+            maxContactCount: 200,
             numberOfNodesPerKBucket: 8,
             joinNoProgressLimit: 5,
             dhtJoinTimeout: 60000,
@@ -162,26 +164,26 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             storageRedundancyFactor: 5, // TODO validate that this is > 1 (as each node should replicate the data to other node)
             metricsContext: new MetricsContext()
         }, conf)
-        this.validateConfig()
-        this.localDataStore = new LocalDataStore(this.config.storeMaxTtl)
+        this.validateOptions()
+        this.localDataStore = new LocalDataStore(this.options.storeMaxTtl)
         this.send = this.send.bind(this)
     }
 
-    private validateConfig(): void {
+    private validateOptions(): void {
         const expectedNodeIdLength = KADEMLIA_ID_LENGTH_IN_BYTES * 2
-        if (this.config.nodeId !== undefined) {
-            if (!/^[0-9a-fA-F]+$/.test(this.config.nodeId)) {
+        if (this.options.nodeId !== undefined) {
+            if (!/^[0-9a-fA-F]+$/.test(this.options.nodeId)) {
                 throw new Error('Invalid nodeId, the nodeId should be a hex string')
-            } else if (this.config.nodeId.length !== expectedNodeIdLength) {
+            } else if (this.options.nodeId.length !== expectedNodeIdLength) {
                 throw new Error(`Invalid nodeId, the length of the nodeId should be ${expectedNodeIdLength}`)
             }
         }
-        if (this.config.peerDescriptor !== undefined) {
-            if (this.config.peerDescriptor.nodeId.length !== KADEMLIA_ID_LENGTH_IN_BYTES) {
+        if (this.options.peerDescriptor !== undefined) {
+            if (this.options.peerDescriptor.nodeId.length !== KADEMLIA_ID_LENGTH_IN_BYTES) {
                 throw new Error(`Invalid peerDescriptor, the length of the nodeId should be ${KADEMLIA_ID_LENGTH_IN_BYTES} bytes`)
             }
         }
-        if (this.config.transport !== undefined && this.config.connectionsView === undefined) {
+        if (this.options.transport !== undefined && this.options.connectionsView === undefined) {
             throw new Error('connectionsView is required when transport is given')
         }
     }
@@ -190,58 +192,57 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (this.started || this.abortController.signal.aborted) {
             return
         }
-        logger.trace(`Starting new Streamr Network DHT Node with serviceId ${this.config.serviceId}`)
+        logger.trace(`Starting new Streamr Network DHT Node with serviceId ${this.options.serviceId}`)
         this.started = true
 
         if (isBrowserEnvironment()) {
-            this.config.websocketPortRange = undefined
-            if (this.config.peerDescriptor) {
-                this.config.peerDescriptor.websocket = undefined
+            this.options.websocketPortRange = undefined
+            if (this.options.peerDescriptor) {
+                this.options.peerDescriptor.websocket = undefined
             }
         } 
           
         // If transport is given, do not create a ConnectionManager
-        if (this.config.transport) {
-            this.transport = this.config.transport
-            this.connectionsView = this.config.connectionsView
-            this.connectionLocker = this.config.connectionLocker
+        if (this.options.transport) {
+            this.transport = this.options.transport
+            this.connectionsView = this.options.connectionsView
+            this.connectionLocker = this.options.connectionLocker
             this.localPeerDescriptor = this.transport.getLocalPeerDescriptor()
         } else {
-            const connectorFacadeConfig: DefaultConnectorFacadeConfig = {
+            const connectorFacadeOptions: DefaultConnectorFacadeOptions = {
                 transport: this,
-                entryPoints: this.config.entryPoints,
-                iceServers: this.config.iceServers,
-                webrtcAllowPrivateAddresses: this.config.webrtcAllowPrivateAddresses,
-                webrtcDatachannelBufferThresholdLow: this.config.webrtcDatachannelBufferThresholdLow,
-                webrtcDatachannelBufferThresholdHigh: this.config.webrtcDatachannelBufferThresholdHigh,
-                webrtcNewConnectionTimeout: this.config.webrtcNewConnectionTimeout,
-                webrtcPortRange: this.config.webrtcPortRange,
-                maxMessageSize: this.config.maxMessageSize,
-                websocketServerEnableTls: this.config.websocketServerEnableTls,
-                tlsCertificate: this.config.tlsCertificate,
-                externalIp: this.config.externalIp,
-                autoCertifierUrl: this.config.autoCertifierUrl,
-                autoCertifierConfigFile: this.config.autoCertifierConfigFile,
-                geoIpDatabaseFolder: this.config.geoIpDatabaseFolder,
+                entryPoints: this.options.entryPoints,
+                iceServers: this.options.iceServers,
+                webrtcAllowPrivateAddresses: this.options.webrtcAllowPrivateAddresses,
+                webrtcDatachannelBufferThresholdLow: this.options.webrtcDatachannelBufferThresholdLow,
+                webrtcDatachannelBufferThresholdHigh: this.options.webrtcDatachannelBufferThresholdHigh,
+                webrtcPortRange: this.options.webrtcPortRange,
+                maxMessageSize: this.options.maxMessageSize,
+                websocketServerEnableTls: this.options.websocketServerEnableTls,
+                tlsCertificate: this.options.tlsCertificate,
+                externalIp: this.options.externalIp,
+                autoCertifierUrl: this.options.autoCertifierUrl,
+                autoCertifierConfigFile: this.options.autoCertifierConfigFile,
+                geoIpDatabaseFolder: this.options.geoIpDatabaseFolder,
                 createLocalPeerDescriptor: (connectivityResponse: ConnectivityResponse) => this.generatePeerDescriptorCallBack(connectivityResponse)
             }
-            // If own PeerDescriptor is given in config, create a ConnectionManager with ws server
-            if (this.config.peerDescriptor?.websocket) {
-                connectorFacadeConfig.websocketHost = this.config.peerDescriptor.websocket.host
-                connectorFacadeConfig.websocketPortRange = {
-                    min: this.config.peerDescriptor.websocket.port,
-                    max: this.config.peerDescriptor.websocket.port
+            // If own PeerDescriptor is given in options, create a ConnectionManager with ws server
+            if (this.options.peerDescriptor?.websocket) {
+                connectorFacadeOptions.websocketHost = this.options.peerDescriptor.websocket.host
+                connectorFacadeOptions.websocketPortRange = {
+                    min: this.options.peerDescriptor.websocket.port,
+                    max: this.options.peerDescriptor.websocket.port
                 }
                 // If websocketPortRange is given, create ws server using it, websocketHost can be undefined
-            } else if (this.config.websocketPortRange) {
-                connectorFacadeConfig.websocketHost = this.config.websocketHost
-                connectorFacadeConfig.websocketPortRange = this.config.websocketPortRange
+            } else if (this.options.websocketPortRange) {
+                connectorFacadeOptions.websocketHost = this.options.websocketHost
+                connectorFacadeOptions.websocketPortRange = this.options.websocketPortRange
             }
 
             const connectionManager = new ConnectionManager({
-                createConnectorFacade: () => new DefaultConnectorFacade(connectorFacadeConfig),
-                maxConnections: this.config.maxConnections,
-                metricsContext: this.config.metricsContext
+                createConnectorFacade: () => new DefaultConnectorFacade(connectorFacadeOptions),
+                maxConnections: this.options.maxConnections,
+                metricsContext: this.options.metricsContext
             })
             await connectionManager.start()
             this.connectionsView = connectionManager
@@ -250,9 +251,9 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         }
 
         this.rpcCommunicator = new RoutingRpcCommunicator(
-            this.config.serviceId,
+            this.options.serviceId,
             (msg, opts) => this.transport!.send(msg, opts),
-            { rpcRequestTimeout: this.config.rpcRequestTimeout }
+            { rpcRequestTimeout: this.options.rpcRequestTimeout }
         )
 
         this.transport.on('message', (message: Message) => this.handleMessageFromTransport(message))
@@ -261,10 +262,10 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
         this.peerDiscovery = new PeerDiscovery({
             localPeerDescriptor: this.localPeerDescriptor!,
-            joinNoProgressLimit: this.config.joinNoProgressLimit,
-            joinTimeout: this.config.dhtJoinTimeout,
-            serviceId: this.config.serviceId,
-            parallelism: this.config.joinParallelism,
+            joinNoProgressLimit: this.options.joinNoProgressLimit,
+            joinTimeout: this.options.dhtJoinTimeout,
+            serviceId: this.options.serviceId,
+            parallelism: this.options.joinParallelism,
             connectionLocker: this.connectionLocker,
             peerManager: this.peerManager!,
             abortSignal: this.abortController.signal,
@@ -282,7 +283,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             sessionTransport: this,
             connectionsView: this.connectionsView!,
             localPeerDescriptor: this.localPeerDescriptor!,
-            serviceId: this.config.serviceId,
+            serviceId: this.options.serviceId,
             localDataStore: this.localDataStore,
             addContact: (contact: PeerDescriptor) => this.peerManager!.addContact(contact),
             createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => this.createDhtNodeRpcRemote(peerDescriptor),
@@ -291,9 +292,9 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             rpcCommunicator: this.rpcCommunicator,
             recursiveOperationManager: this.recursiveOperationManager,
             localPeerDescriptor: this.localPeerDescriptor!,
-            serviceId: this.config.serviceId,
-            highestTtl: this.config.storeHighestTtl,
-            redundancyFactor: this.config.storageRedundancyFactor,
+            serviceId: this.options.serviceId,
+            highestTtl: this.options.storeHighestTtl,
+            redundancyFactor: this.options.storageRedundancyFactor,
             localDataStore: this.localDataStore,
             getNeighbors: () => this.peerManager!.getNeighbors().map((n) => n.getPeerDescriptor()),
             createRpcRemote: (contact: PeerDescriptor) => {
@@ -302,7 +303,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                     contact,
                     this.rpcCommunicator!,
                     StoreRpcClient,
-                    this.config.rpcRequestTimeout
+                    this.options.rpcRequestTimeout
                 )
             }
         })
@@ -312,10 +313,10 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         this.bindRpcLocalMethods()
 
         const pruneTargets = []
-        if (this.config.periodicallyPingNeighbors === true) {
+        if (this.options.periodicallyPingNeighbors === true) {
             pruneTargets.push(() => this.peerManager!.getNeighbors().map((node) => this.createDhtNodeRpcRemote(node.getPeerDescriptor())))
         }
-        if (this.config.periodicallyPingRingContacts === true) {
+        if (this.options.periodicallyPingRingContacts === true) {
             pruneTargets.push(() => this.peerManager!.getRingContacts().getAllContacts())
         }
         for (const pruneTarget of pruneTargets) {
@@ -330,12 +331,12 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     private initPeerManager() {
         this.peerManager = new PeerManager({
-            numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
-            maxContactListSize: this.config.maxNeighborListSize,
+            numberOfNodesPerKBucket: this.options.numberOfNodesPerKBucket,
+            maxContactCount: this.options.maxContactCount,
             localNodeId: this.getNodeId(),
             localPeerDescriptor: this.localPeerDescriptor!,
             connectionLocker: this.connectionLocker,
-            lockId: this.config.serviceId,
+            lockId: this.options.serviceId,
             createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => this.createDhtNodeRpcRemote(peerDescriptor),
             hasConnection: (nodeId: DhtAddress) => this.connectionsView!.hasConnection(nodeId)
         })
@@ -359,12 +360,12 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         })
         this.peerManager.on('kBucketEmpty', () => {
             if (!this.peerDiscovery!.isJoinOngoing()) {
-                if (this.config.entryPoints && this.config.entryPoints.length > 0) {
+                if (this.options.entryPoints && this.options.entryPoints.length > 0) {
                     setImmediate(async () => {
                         const contactedPeers = new Set<DhtAddress>()
                         const distantJoinContactPeers = new Set<DhtAddress>()
                         // TODO should we catch possible promise rejection?
-                        await Promise.all(this.config.entryPoints!.map((entryPoint) =>
+                        await Promise.all(this.options.entryPoints!.map((entryPoint) =>
                             this.peerDiscovery!.rejoinDht(entryPoint, contactedPeers, distantJoinContactPeers)
                         ))
                     })
@@ -378,8 +379,8 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             this.emit('connected', peerDescriptor)
         })
         this.transport!.on('disconnected', (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => {
-            const isLayer0 = (this.connectionLocker !== undefined)
-            if (isLayer0) {
+            const isControlLayerNode = (this.connectionLocker !== undefined)
+            if (isControlLayerNode) {
                 const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
                 if (gracefulLeave) {
                     this.peerManager!.removeContact(nodeId)
@@ -397,7 +398,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             return
         }
         const dhtNodeRpcLocal = new DhtNodeRpcLocal({
-            peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
+            peerDiscoveryQueryBatchSize: this.options.peerDiscoveryQueryBatchSize,
             getNeighbors: () => this.peerManager!.getNeighbors().map((n) => n.getPeerDescriptor()),
             getClosestRingContactsTo: (ringIdRaw: RingIdRaw, limit: number) => {
                 return this.getClosestRingContactsTo(ringIdRaw, limit)
@@ -424,25 +425,25 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             ExternalFetchDataResponse,
             'externalFetchData',
             (req: ExternalFetchDataRequest, context: ServerCallContext) => externalApiRpcLocal.externalFetchData(req, context),
-            { timeout: 10000 }  // TODO use config option or named constant?
+            { timeout: 10000 }  // TODO use options option or named constant?
         )
         this.rpcCommunicator!.registerRpcMethod(
             ExternalStoreDataRequest,
             ExternalStoreDataResponse,
             'externalStoreData',
             (req: ExternalStoreDataRequest, context: ServerCallContext) => externalApiRpcLocal.externalStoreData(req, context),
-            { timeout: 10000 }  // TODO use config option or named constant?
+            { timeout: 10000 }  // TODO use options option or named constant?
         )
     }
 
     private handleMessageFromTransport(message: Message): void {
-        if (message.serviceId === this.config.serviceId) {
+        if (message.serviceId === this.options.serviceId) {
             this.rpcCommunicator?.handleMessageFromPeer(message)
         } 
     }
     
     private handleMessageFromRouter(message: Message): void {
-        if (message.serviceId === this.config.serviceId) {
+        if (message.serviceId === this.options.serviceId) {
             this.rpcCommunicator?.handleMessageFromPeer(message)
         } else {
             this.emit('message', message)
@@ -450,13 +451,13 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     private async generatePeerDescriptorCallBack(connectivityResponse: ConnectivityResponse) {
-        if (this.config.peerDescriptor !== undefined) {
-            this.localPeerDescriptor = this.config.peerDescriptor
+        if (this.options.peerDescriptor !== undefined) {
+            this.localPeerDescriptor = this.options.peerDescriptor
         } else {
             let region: number | undefined = undefined
-            if (this.config.region !== undefined) {
-                region = this.config.region
-                logger.debug(`Using region ${region} from config when generating local PeerDescriptor`)
+            if (this.options.region !== undefined) {
+                region = this.options.region
+                logger.debug(`Using region ${region} from options when generating local PeerDescriptor`)
             } else if (connectivityResponse.latitude !== undefined && connectivityResponse.longitude !== undefined) {
                 region = getLocalRegionByCoordinates(connectivityResponse.latitude, connectivityResponse.longitude)
                 logger.debug(`Using region ${region} from GeoIP when generating local PeerDescriptor`)
@@ -467,7 +468,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 logger.debug(`Using region ${region} from CDN when generating local PeerDescriptor`)
             }
             
-            this.localPeerDescriptor = createPeerDescriptor(connectivityResponse, region, this.config.nodeId)
+            this.localPeerDescriptor = createPeerDescriptor(connectivityResponse, region, this.options.nodeId)
         }
         return this.localPeerDescriptor
     }
@@ -522,7 +523,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     private getConnectedEntryPoints(): PeerDescriptor[] {
-        return this.config.entryPoints !== undefined ? this.config.entryPoints.filter((entryPoint) =>
+        return this.options.entryPoints !== undefined ? this.options.entryPoints.filter((entryPoint) =>
             this.connectionsView!.hasConnection(getNodeIdFromPeerDescriptor(entryPoint))
         ) : []
     }
@@ -620,7 +621,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     public async waitForNetworkConnectivity(): Promise<void> {
         await waitForCondition(
             () => this.connectionsView!.getConnectionCount() > 0,
-            this.config.networkConnectivityTimeout,
+            this.options.networkConnectivityTimeout,
             100,
             this.abortController.signal
         )
@@ -642,8 +643,8 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         this.rpcCommunicator!.stop()
         this.router!.stop()
         this.recursiveOperationManager!.stop()
-        if (this.config.transport === undefined) {
-            // if the transport was not given in config, the instance was created in start() and
+        if (this.options.transport === undefined) {
+            // if the transport was not given in options, the instance was created in start() and
             // this component is responsible for stopping it
             await this.transport!.stop()
         }
@@ -656,9 +657,9 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return new DhtNodeRpcRemote(
             this.localPeerDescriptor!,
             peerDescriptor,
-            this.config.serviceId,
+            this.options.serviceId,
             this.rpcCommunicator!,
-            this.config.rpcRequestTimeout
+            this.options.rpcRequestTimeout
         )
     }
 }

package/src/dht/DhtNodeRpcLocal.ts

@@ -17,7 +17,7 @@ import { RingContacts } from './contact/RingContactList'
 import { getClosestNodes } from './contact/getClosestNodes'
 import { RingIdRaw } from './contact/ringIdentifiers'
 
-interface DhtNodeRpcLocalConfig {
+interface DhtNodeRpcLocalOptions {
     peerDiscoveryQueryBatchSize: number
     getNeighbors: () => ReadonlyArray<PeerDescriptor>
     getClosestRingContactsTo: (id: RingIdRaw, limit: number) => RingContacts
@@ -29,19 +29,19 @@ const logger = new Logger(module)
 
 export class DhtNodeRpcLocal implements IDhtNodeRpc {
 
-    private readonly config: DhtNodeRpcLocalConfig
+    private readonly options: DhtNodeRpcLocalOptions
 
-    constructor(config: DhtNodeRpcLocalConfig) {
-        this.config = config
+    constructor(options: DhtNodeRpcLocalOptions) {
+        this.options = options
     }
 
     // TODO rename to getClosestNeighbors (breaking change)
     async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
-        this.config.addContact((context as DhtCallContext).incomingSourceDescriptor!)
+        this.options.addContact((context as DhtCallContext).incomingSourceDescriptor!)
         const peers = getClosestNodes(
             getDhtAddressFromRaw(request.nodeId), 
-            this.config.getNeighbors(),
-            { maxCount: this.config.peerDiscoveryQueryBatchSize }
+            this.options.getNeighbors(),
+            { maxCount: this.options.peerDiscoveryQueryBatchSize }
         )
         const response = {
             peers,
@@ -52,8 +52,8 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
 
     // TODO rename to getClosestRingContacts (breaking change)
     async getClosestRingPeers(request: ClosestRingPeersRequest, context: ServerCallContext): Promise<ClosestRingPeersResponse> {
-        this.config.addContact((context as DhtCallContext).incomingSourceDescriptor!)
-        const closestContacts = this.config.getClosestRingContactsTo(request.ringId as RingIdRaw, this.config.peerDiscoveryQueryBatchSize)
+        this.options.addContact((context as DhtCallContext).incomingSourceDescriptor!)
+        const closestContacts = this.options.getClosestRingContactsTo(request.ringId as RingIdRaw, this.options.peerDiscoveryQueryBatchSize)
         const response = {
             leftPeers: closestContacts.left,
             rightPeers: closestContacts.right,
@@ -65,7 +65,7 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
     async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
         logger.trace('received ping request: ' + getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
         setImmediate(() => {
-            this.config.addContact((context as DhtCallContext).incomingSourceDescriptor!)
+            this.options.addContact((context as DhtCallContext).incomingSourceDescriptor!)
         })
         const response: PingResponse = {
             requestId: request.requestId
@@ -78,7 +78,7 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
         const sender = (context as DhtCallContext).incomingSourceDescriptor!
         const senderNodeId = getNodeIdFromPeerDescriptor(sender)
         logger.trace('received leave notice: ' + senderNodeId)
-        this.config.removeContact(senderNodeId)
+        this.options.removeContact(senderNodeId)
         return {}
     }
 }

package/src/dht/ExternalApiRpcLocal.ts

@@ -14,7 +14,7 @@ import { Any } from '../proto/google/protobuf/any'
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { getDhtAddressFromRaw } from '../identifiers'
 
-interface ExternalApiRpcLocalConfig {
+interface ExternalApiRpcLocalOptions {
     executeRecursiveOperation: (
         targetId: DhtAddress,
         operation: RecursiveOperation,
@@ -29,15 +29,15 @@ interface ExternalApiRpcLocalConfig {
 
 export class ExternalApiRpcLocal implements IExternalApiRpc {
 
-    private readonly config: ExternalApiRpcLocalConfig
+    private readonly options: ExternalApiRpcLocalOptions
 
-    constructor(config: ExternalApiRpcLocalConfig) {
-        this.config = config
+    constructor(options: ExternalApiRpcLocalOptions) {
+        this.options = options
     }
 
     async externalFetchData(request: ExternalFetchDataRequest, context: ServerCallContext): Promise<ExternalFetchDataResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const result = await this.config.executeRecursiveOperation(
+        const result = await this.options.executeRecursiveOperation(
             getDhtAddressFromRaw(request.key),
             RecursiveOperation.FETCH_DATA,
             getNodeIdFromPeerDescriptor(senderPeerDescriptor)
@@ -47,7 +47,7 @@ export class ExternalApiRpcLocal implements IExternalApiRpc {
 
     async externalStoreData(request: ExternalStoreDataRequest, context: ServerCallContext): Promise<ExternalStoreDataResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const result = await this.config.storeDataToDht(
+        const result = await this.options.storeDataToDht(
             getDhtAddressFromRaw(request.key),
             request.data!,
             getNodeIdFromPeerDescriptor(senderPeerDescriptor)

package/src/dht/ExternalApiRpcRemote.ts

@@ -11,7 +11,7 @@ export class ExternalApiRpcRemote extends RpcRemote<ExternalApiRpcClient> {
             key: getRawFromDhtAddress(key)
         }
         const options = this.formDhtRpcOptions({
-            // TODO use config option or named constant?
+            // TODO use options option or named constant?
             timeout: 10000
         })
         try {
@@ -28,7 +28,7 @@ export class ExternalApiRpcRemote extends RpcRemote<ExternalApiRpcClient> {
             data
         }
         const options = this.formDhtRpcOptions({
-            // TODO use config option or named constant?
+            // TODO use options option or named constant?
             timeout: 10000
         })
         try {