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

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

@@ -8,7 +8,7 @@ import { NeighborUpdateRpcRemote } from './NeighborUpdateRpcRemote'
 import { NeighborUpdateRpcLocal } from './NeighborUpdateRpcLocal'
 import { StreamPartID } from '@streamr/protocol'
 
-interface NeighborUpdateManagerConfig {
+interface NeighborUpdateManagerOptions {
     localPeerDescriptor: PeerDescriptor
     neighbors: NodeList
     nearbyNodeView: NodeList
@@ -25,19 +25,19 @@ const logger = new Logger(module)
 export class NeighborUpdateManager {
 
     private readonly abortController: AbortController
-    private readonly config: NeighborUpdateManagerConfig
+    private readonly options: NeighborUpdateManagerOptions
     private readonly rpcLocal: NeighborUpdateRpcLocal
 
-    constructor(config: NeighborUpdateManagerConfig) {
+    constructor(options: NeighborUpdateManagerOptions) {
         this.abortController = new AbortController()
-        this.rpcLocal = new NeighborUpdateRpcLocal(config)
-        this.config = config
-        this.config.rpcCommunicator.registerRpcMethod(NeighborUpdate, NeighborUpdate, 'neighborUpdate',
+        this.rpcLocal = new NeighborUpdateRpcLocal(options)
+        this.options = options
+        this.options.rpcCommunicator.registerRpcMethod(NeighborUpdate, NeighborUpdate, 'neighborUpdate',
             (req: NeighborUpdate, context) => this.rpcLocal.neighborUpdate(req, context))
     }
 
     async start(): Promise<void> {
-        await scheduleAtInterval(() => this.updateNeighborInfo(), this.config.neighborUpdateInterval, false, this.abortController.signal)
+        await scheduleAtInterval(() => this.updateNeighborInfo(), this.options.neighborUpdateInterval, false, this.abortController.signal)
     }
 
     stop(): void {
@@ -46,22 +46,22 @@ export class NeighborUpdateManager {
 
     private async updateNeighborInfo(): Promise<void> {
         logger.trace(`Updating neighbor info to nodes`)
-        const neighborDescriptors = this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
-        await Promise.allSettled(this.config.neighbors.getAll().map(async (neighbor) => {
-            const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(this.config.streamPartId, neighborDescriptors)
+        const neighborDescriptors = this.options.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
+        await Promise.allSettled(this.options.neighbors.getAll().map(async (neighbor) => {
+            const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(this.options.streamPartId, neighborDescriptors)
             if (res.removeMe) {
                 const nodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
-                this.config.neighbors.remove(nodeId)
-                this.config.neighborFinder.start([nodeId])
+                this.options.neighbors.remove(nodeId)
+                this.options.neighborFinder.start([nodeId])
             }
         }))
     }
 
     private createRemote(targetPeerDescriptor: PeerDescriptor): NeighborUpdateRpcRemote {
         return new NeighborUpdateRpcRemote(
-            this.config.localPeerDescriptor,
+            this.options.localPeerDescriptor,
             targetPeerDescriptor,
-            this.config.rpcCommunicator,
+            this.options.rpcCommunicator,
             NeighborUpdateRpcClient
         )
     }

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

@@ -8,7 +8,7 @@ import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { NeighborFinder } from './NeighborFinder'
 import { StreamPartID } from '@streamr/protocol'
 
-interface NeighborUpdateRpcLocalConfig {
+interface NeighborUpdateRpcLocalOptions {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     neighbors: NodeList
@@ -21,23 +21,23 @@ interface NeighborUpdateRpcLocalConfig {
 
 export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
 
-    private readonly config: NeighborUpdateRpcLocalConfig
+    private readonly options: NeighborUpdateRpcLocalOptions
 
-    constructor(config: NeighborUpdateRpcLocalConfig) {
-        this.config = config
+    constructor(options: NeighborUpdateRpcLocalOptions) {
+        this.options = options
     }
 
     private updateContacts(neighborDescriptors: PeerDescriptor[]): void {
-        const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        const ownNodeId = getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor)
         const newPeerDescriptors = neighborDescriptors.filter((peerDescriptor) => {
             const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-            return nodeId !== ownNodeId && !this.config.neighbors.getIds().includes(nodeId)
+            return nodeId !== ownNodeId && !this.options.neighbors.getIds().includes(nodeId)
         })
-        newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
+        newPeerDescriptors.forEach((peerDescriptor) => this.options.nearbyNodeView.add(
             new ContentDeliveryRpcRemote(
-                this.config.localPeerDescriptor,
+                this.options.localPeerDescriptor,
                 peerDescriptor,
-                this.config.rpcCommunicator,
+                this.options.rpcCommunicator,
                 ContentDeliveryRpcClient
             ))
         )
@@ -45,8 +45,8 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
 
     private createResponse(removeMe: boolean): NeighborUpdate {
         return {
-            streamPartId: this.config.streamPartId,
-            neighborDescriptors: this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
+            streamPartId: this.options.streamPartId,
+            neighborDescriptors: this.options.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
             removeMe
         }
     }
@@ -54,20 +54,20 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
     // INeighborUpdateRpc server method
     async neighborUpdate(message: NeighborUpdate, context: ServerCallContext): Promise<NeighborUpdate> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        const remoteNodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
         this.updateContacts(message.neighborDescriptors)
-        if (!this.config.neighbors.has(senderId) && !this.config.ongoingHandshakes.has(senderId)) {
+        if (!this.options.neighbors.has(remoteNodeId) && !this.options.ongoingHandshakes.has(remoteNodeId)) {
             return this.createResponse(true)
         } else {
-            const isOverNeighborCount = this.config.neighbors.size() > this.config.neighborTargetCount
+            const isOverNeighborCount = this.options.neighbors.size() > this.options.neighborTargetCount
                 // Motivation: We don't know the remote's neighborTargetCount setting here. We only ask to cut connections
                 // if the remote has a "sufficient" number of neighbors, where "sufficient" means our neighborTargetCount
                 // setting.
-                && message.neighborDescriptors.length > this.config.neighborTargetCount
+                && message.neighborDescriptors.length > this.options.neighborTargetCount
             if (!isOverNeighborCount) {
-                this.config.neighborFinder.start()
+                this.options.neighborFinder.start()
             } else {
-                this.config.neighbors.remove(senderId)
+                this.options.neighbors.remove(remoteNodeId)
             }
             return this.createResponse(isOverNeighborCount)
         }

package/src/logic/proxy/ProxyClient.ts

@@ -27,7 +27,7 @@ import { markAndCheckDuplicate } from '../utils'
 import { ProxyConnectionRpcRemote } from './ProxyConnectionRpcRemote'
 import { formStreamPartContentDeliveryServiceId } from '../formStreamPartDeliveryServiceId'
 
-// TODO use config option or named constant?
+// TODO use options option or named constant?
 export const retry = async <T>(task: () => Promise<T>, description: string, abortSignal: AbortSignal, delay = 10000): Promise<T> => {
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -43,7 +43,7 @@ export const retry = async <T>(task: () => Promise<T>, description: string, abor
     }
 }
 
-interface ProxyClientConfig {
+interface ProxyClientOptions {
     transport: ITransport
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
@@ -75,7 +75,7 @@ export class ProxyClient extends EventEmitter<Events> {
 
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly contentDeliveryRpcLocal: ContentDeliveryRpcLocal
-    private readonly config: ProxyClientConfig
+    private readonly options: ProxyClientOptions
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector> = new Map()
     private definition?: ProxyDefinition
     private readonly connections: Map<DhtAddress, ProxyConnection> = new Map()
@@ -83,19 +83,19 @@ export class ProxyClient extends EventEmitter<Events> {
     private readonly neighbors: NodeList
     private readonly abortController: AbortController
 
-    constructor(config: ProxyClientConfig) {
+    constructor(options: ProxyClientOptions) {
         super()
-        this.config = config
-        this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartContentDeliveryServiceId(config.streamPartId), config.transport)
-        // TODO use config option or named constant?
-        this.neighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), 1000)
+        this.options = options
+        this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartContentDeliveryServiceId(options.streamPartId), options.transport)
+        // TODO use options option or named constant?
+        this.neighbors = new NodeList(getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor), 1000)
         this.contentDeliveryRpcLocal = new ContentDeliveryRpcLocal({
-            localPeerDescriptor: this.config.localPeerDescriptor,
-            streamPartId: this.config.streamPartId,
+            localPeerDescriptor: this.options.localPeerDescriptor,
+            streamPartId: this.options.streamPartId,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
             broadcast: (message: StreamMessage, previousNode?: DhtAddress) => this.broadcast(message, previousNode),
-            onLeaveNotice: (senderId: DhtAddress) => {
-                const contact = this.neighbors.get(senderId)
+            onLeaveNotice: (remoteNodeId: DhtAddress) => {
+                const contact = this.neighbors.get(remoteNodeId)
                 if (contact) {
                     // TODO should we catch possible promise rejection?
                     setImmediate(() => this.onNodeDisconnected(contact.getPeerDescriptor()))
@@ -105,8 +105,8 @@ export class ProxyClient extends EventEmitter<Events> {
             markForInspection: () => {}
         })
         this.propagation = new Propagation({
-            // TODO use config option or named constant?
-            minPropagationTargets: config.minPropagationTargets ?? 2,
+            // TODO use options option or named constant?
+            minPropagationTargets: options.minPropagationTargets ?? 2,
             sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
                 const remote = this.neighbors.get(neighborId)
                 if (remote) {
@@ -132,7 +132,7 @@ export class ProxyClient extends EventEmitter<Events> {
         userId: EthereumAddress,
         connectionCount?: number
     ): Promise<void> {
-        logger.trace('Setting proxies', { streamPartId: this.config.streamPartId, peerDescriptors: nodes, direction, userId, connectionCount })
+        logger.trace('Setting proxies', { streamPartId: this.options.streamPartId, peerDescriptors: nodes, direction, userId, connectionCount })
         if (connectionCount !== undefined && connectionCount > nodes.length) {
             throw new Error('Cannot set connectionCount above the size of the configured array of nodes')
         }
@@ -180,17 +180,17 @@ export class ProxyClient extends EventEmitter<Events> {
     private async attemptConnection(nodeId: DhtAddress, direction: ProxyDirection, userId: EthereumAddress): Promise<void> {
         const peerDescriptor = this.definition!.nodes.get(nodeId)!
         const rpcRemote = new ProxyConnectionRpcRemote(
-            this.config.localPeerDescriptor,
+            this.options.localPeerDescriptor,
             peerDescriptor,
             this.rpcCommunicator,
             ProxyConnectionRpcClient
         )
         const accepted = await rpcRemote.requestConnection(direction, userId)
         if (accepted) {
-            this.config.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
+            this.options.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
             this.connections.set(nodeId, { peerDescriptor, direction })
             const remote = new ContentDeliveryRpcRemote(
-                this.config.localPeerDescriptor,
+                this.options.localPeerDescriptor,
                 peerDescriptor,
                 this.rpcCommunicator,
                 ContentDeliveryRpcClient
@@ -199,12 +199,12 @@ export class ProxyClient extends EventEmitter<Events> {
             this.propagation.onNeighborJoined(nodeId)
             logger.info('Open proxy connection', {
                 nodeId,
-                streamPartId: this.config.streamPartId
+                streamPartId: this.options.streamPartId
             })
         } else {
             logger.warn('Unable to open proxy connection', {
                 nodeId,
-                streamPartId: this.config.streamPartId
+                streamPartId: this.options.streamPartId
             })
         }
     }
@@ -220,7 +220,7 @@ export class ProxyClient extends EventEmitter<Events> {
                 nodeId
             })
             const server = this.neighbors.get(nodeId)
-            server?.leaveStreamPartNotice(this.config.streamPartId, false)
+            server?.leaveStreamPartNotice(this.options.streamPartId, false)
             this.removeConnection(this.connections.get(nodeId)!.peerDescriptor)
         }
     }
@@ -229,7 +229,7 @@ export class ProxyClient extends EventEmitter<Events> {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         this.connections.delete(nodeId)
         this.neighbors.remove(nodeId)
-        this.config.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
+        this.options.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
     }
 
     broadcast(msg: StreamMessage, previousNode?: DhtAddress): void {
@@ -251,7 +251,7 @@ export class ProxyClient extends EventEmitter<Events> {
     private async onNodeDisconnected(peerDescriptor: PeerDescriptor): Promise<void> {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         if (this.connections.has(nodeId)) {
-            this.config.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
+            this.options.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
             this.removeConnection(peerDescriptor)
             await retry(() => this.updateConnections(), 'updating proxy connections', this.abortController.signal)
         }
@@ -260,7 +260,7 @@ export class ProxyClient extends EventEmitter<Events> {
     async start(): Promise<void> {
         this.registerDefaultServerMethods()
         addManagedEventListener<any, any>(
-            this.config.transport as any,
+            this.options.transport as any,
             'disconnected',
             // TODO should we catch possible promise rejection?
             (peerDescriptor: PeerDescriptor) => this.onNodeDisconnected(peerDescriptor),
@@ -270,8 +270,8 @@ export class ProxyClient extends EventEmitter<Events> {
 
     stop(): void {
         this.neighbors.getAll().forEach((remote) => {
-            this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)
-            remote.leaveStreamPartNotice(this.config.streamPartId, false)
+            this.options.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)
+            remote.leaveStreamPartNotice(this.options.streamPartId, false)
         })
         this.neighbors.stop()
         this.rpcCommunicator.destroy()

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -21,7 +21,7 @@ interface ProxyConnection {
     remote: ContentDeliveryRpcRemote
 }
 
-interface ProxyConnectionRpcLocalConfig {
+interface ProxyConnectionRpcLocalOptions {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
@@ -33,13 +33,13 @@ export interface Events {
 
 export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IProxyConnectionRpc {
 
-    private readonly config: ProxyConnectionRpcLocalConfig
+    private readonly options: ProxyConnectionRpcLocalOptions
     private readonly connections: Map<DhtAddress, ProxyConnection> = new Map()
 
-    constructor(config: ProxyConnectionRpcLocalConfig) {
+    constructor(options: ProxyConnectionRpcLocalOptions) {
         super()
-        this.config = config
-        this.config.rpcCommunicator.registerRpcMethod(ProxyConnectionRequest, ProxyConnectionResponse, 'requestConnection',
+        this.options = options
+        this.options.rpcCommunicator.registerRpcMethod(ProxyConnectionRequest, ProxyConnectionResponse, 'requestConnection',
             (msg: ProxyConnectionRequest, context) => this.requestConnection(msg, context))
     }
 
@@ -56,7 +56,7 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
     }
 
     stop(): void {
-        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice(this.config.streamPartId, false))
+        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice(this.options.streamPartId, false))
         this.connections.clear()
         this.removeAllListeners()
     }
@@ -86,22 +86,22 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
     // IProxyConnectionRpc server method
     async requestConnection(request: ProxyConnectionRequest, context: ServerCallContext): Promise<ProxyConnectionResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
-        this.connections.set(senderId, {
+        const remoteNodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        this.connections.set(remoteNodeId, {
             direction: request.direction,
             userId: toEthereumAddress(binaryToHex(request.userId, true)),
             remote: new ContentDeliveryRpcRemote(
-                this.config.localPeerDescriptor,
+                this.options.localPeerDescriptor,
                 senderPeerDescriptor,
-                this.config.rpcCommunicator,
+                this.options.rpcCommunicator,
                 ContentDeliveryRpcClient
             )
         })
         const response: ProxyConnectionResponse = {
             accepted: true
         }
-        logger.trace(`Accepted connection request from ${senderId} to ${this.config.streamPartId}`)
-        this.emit('newConnection', senderId)
+        logger.trace(`Accepted connection request from ${remoteNodeId} to ${this.options.streamPartId}`)
+        this.emit('newConnection', remoteNodeId)
         return response
     }
 }

package/src/logic/temporary-connection/TemporaryConnectionRpcLocal.ts

@@ -13,7 +13,7 @@ import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Empty } from '../../proto/google/protobuf/empty'
 import { StreamPartID } from '@streamr/protocol'
 
-interface TemporaryConnectionRpcLocalConfig {
+interface TemporaryConnectionRpcLocalOptions {
     rpcCommunicator: ListeningRpcCommunicator
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
@@ -24,14 +24,14 @@ const LOCK_ID_BASE = 'system/content-delivery/temporary-connection/'
 
 export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
-    private readonly config: TemporaryConnectionRpcLocalConfig
+    private readonly options: TemporaryConnectionRpcLocalOptions
     private readonly temporaryNodes: NodeList
     private readonly lockId: string
-    constructor(config: TemporaryConnectionRpcLocalConfig) {
-        this.config = config
-        // TODO use config option or named constant?
-        this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(config.localPeerDescriptor), 10)
-        this.lockId = LOCK_ID_BASE + config.streamPartId
+    constructor(options: TemporaryConnectionRpcLocalOptions) {
+        this.options = options
+        // TODO use options option or named constant?
+        this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(options.localPeerDescriptor), 10)
+        this.lockId = LOCK_ID_BASE + options.streamPartId
     }
 
     getNodes(): NodeList {
@@ -44,7 +44,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
     removeNode(nodeId: DhtAddress): void {
         this.temporaryNodes.remove(nodeId)
-        this.config.connectionLocker.weakUnlockConnection(nodeId, this.lockId)
+        this.options.connectionLocker.weakUnlockConnection(nodeId, this.lockId)
     }
 
     async openConnection(
@@ -53,21 +53,21 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
     ): Promise<TemporaryConnectionResponse> {
         const sender = (context as DhtCallContext).incomingSourceDescriptor!
         const remote = new ContentDeliveryRpcRemote(
-            this.config.localPeerDescriptor,
+            this.options.localPeerDescriptor,
             sender,
-            this.config.rpcCommunicator,
+            this.options.rpcCommunicator,
             ContentDeliveryRpcClient
         )
         this.temporaryNodes.add(remote)
-        this.config.connectionLocker.weakLockConnection(getNodeIdFromPeerDescriptor(sender), this.lockId)
+        this.options.connectionLocker.weakLockConnection(getNodeIdFromPeerDescriptor(sender), this.lockId)
         return {
             accepted: true
         }
     }
 
     async closeConnection(_request: CloseTemporaryConnection, context: ServerCallContext): Promise<Empty> {
-        const senderId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
-        this.removeNode(senderId)
+        const remoteNodeId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
+        this.removeNode(remoteNodeId)
         return {}
     }
 }

package/src/proto/google/protobuf/any.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.4 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/any.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //

package/src/proto/google/protobuf/empty.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.4 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/empty.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //

package/src/proto/google/protobuf/timestamp.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.4 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //

package/src/proto/packages/dht/protos/DhtRpc.client.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.4 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/dht/protos/DhtRpc.proto" (package "dht", syntax proto3)
 // tslint:disable
 import { ExternalApiRpc } from "./DhtRpc";
@@ -16,7 +16,7 @@ import type { IceCandidate } from "./DhtRpc";
 import type { RtcAnswer } from "./DhtRpc";
 import type { RtcOffer } from "./DhtRpc";
 import type { WebrtcConnectionRequest } from "./DhtRpc";
-import { WebsocketConnectorRpc } from "./DhtRpc";
+import { WebsocketClientConnectorRpc } from "./DhtRpc";
 import type { WebsocketConnectionRequest } from "./DhtRpc";
 import { RecursiveOperationSessionRpc } from "./DhtRpc";
 import type { RecursiveOperationResponse } from "./DhtRpc";
@@ -236,21 +236,21 @@ export class RecursiveOperationSessionRpcClient implements IRecursiveOperationSe
     }
 }
 /**
- * @generated from protobuf service dht.WebsocketConnectorRpc
+ * @generated from protobuf service dht.WebsocketClientConnectorRpc
  */
-export interface IWebsocketConnectorRpcClient {
+export interface IWebsocketClientConnectorRpcClient {
     /**
      * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (google.protobuf.Empty);
      */
     requestConnection(input: WebsocketConnectionRequest, options?: RpcOptions): UnaryCall<WebsocketConnectionRequest, Empty>;
 }
 /**
- * @generated from protobuf service dht.WebsocketConnectorRpc
+ * @generated from protobuf service dht.WebsocketClientConnectorRpc
  */
-export class WebsocketConnectorRpcClient implements IWebsocketConnectorRpcClient, ServiceInfo {
-    typeName = WebsocketConnectorRpc.typeName;
-    methods = WebsocketConnectorRpc.methods;
-    options = WebsocketConnectorRpc.options;
+export class WebsocketClientConnectorRpcClient implements IWebsocketClientConnectorRpcClient, ServiceInfo {
+    typeName = WebsocketClientConnectorRpc.typeName;
+    methods = WebsocketClientConnectorRpc.methods;
+    options = WebsocketClientConnectorRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**

package/src/proto/packages/dht/protos/DhtRpc.server.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.4 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/dht/protos/DhtRpc.proto" (package "dht", syntax proto3)
 // tslint:disable
 import { ExternalStoreDataResponse } from "./DhtRpc";
@@ -99,9 +99,9 @@ export interface IRecursiveOperationSessionRpc<T = ServerCallContext> {
     sendResponse(request: RecursiveOperationResponse, context: T): Promise<Empty>;
 }
 /**
- * @generated from protobuf service dht.WebsocketConnectorRpc
+ * @generated from protobuf service dht.WebsocketClientConnectorRpc
  */
-export interface IWebsocketConnectorRpc<T = ServerCallContext> {
+export interface IWebsocketClientConnectorRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (google.protobuf.Empty);
      */

package/src/proto/packages/dht/protos/DhtRpc.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.4 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/dht/protos/DhtRpc.proto" (package "dht", syntax proto3)
 // tslint:disable
 import { Empty } from "../../../google/protobuf/empty";
@@ -123,7 +123,7 @@ export interface ClosestPeersRequest {
     requestId: string;
 }
 /**
- * TODO rename to ClosestPeersResponse
+ * TODO rename to ClosestNeighborsResponse
  *
  * @generated from protobuf message dht.ClosestPeersResponse
  */
@@ -379,6 +379,14 @@ export interface ConnectivityResponse {
      * @generated from protobuf field: string version = 5;
      */
     version: string;
+    /**
+     * @generated from protobuf field: optional double latitude = 6;
+     */
+    latitude?: number;
+    /**
+     * @generated from protobuf field: optional double longitude = 7;
+     */
+    longitude?: number;
 }
 /**
  * @generated from protobuf message dht.HandshakeRequest
@@ -978,7 +986,9 @@ class ConnectivityResponse$Type extends MessageType<ConnectivityResponse> {
             { no: 2, name: "natType", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 3, name: "websocket", kind: "message", T: () => ConnectivityMethod },
             { no: 4, name: "ipAddress", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
-            { no: 5, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+            { no: 5, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "latitude", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 7, name: "longitude", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ }
         ]);
     }
 }
@@ -1203,9 +1213,9 @@ export const RecursiveOperationSessionRpc = new ServiceType("dht.RecursiveOperat
     { name: "sendResponse", options: {}, I: RecursiveOperationResponse, O: Empty }
 ]);
 /**
- * @generated ServiceType for protobuf service dht.WebsocketConnectorRpc
+ * @generated ServiceType for protobuf service dht.WebsocketClientConnectorRpc
  */
-export const WebsocketConnectorRpc = new ServiceType("dht.WebsocketConnectorRpc", [
+export const WebsocketClientConnectorRpc = new ServiceType("dht.WebsocketClientConnectorRpc", [
     { name: "requestConnection", options: {}, I: WebsocketConnectionRequest, O: Empty }
 ]);
 /**

package/src/proto/packages/proto-rpc/protos/ProtoRpc.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.4 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/proto-rpc/protos/ProtoRpc.proto" (package "protorpc", syntax proto3)
 // tslint:disable
 import { MessageType } from "@protobuf-ts/runtime";

package/src/proto/packages/trackerless-network/protos/NetworkRpc.client.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.4 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/trackerless-network/protos/NetworkRpc.proto" (syntax proto3)
 // tslint:disable
 import { NodeInfoRpc } from "./NetworkRpc";

package/src/proto/packages/trackerless-network/protos/NetworkRpc.server.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.4 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/trackerless-network/protos/NetworkRpc.proto" (syntax proto3)
 // tslint:disable
 import { NodeInfoResponse } from "./NetworkRpc";