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

package/src/dht/routing/RouterRpcLocal.ts

@@ -6,7 +6,7 @@ import { RoutingMode } from './RoutingSession'
 import { areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { v4 } from 'uuid'
 
-interface RouterRpcLocalConfig {
+interface RouterRpcLocalOptions {
     doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => RouteMessageAck
     setForwardingEntries: (routedMessage: RouteMessageWrapper) => void
     handleMessage: (message: Message) => void
@@ -26,53 +26,53 @@ export const createRouteMessageAck = (routedMessage: RouteMessageWrapper, error?
 
 export class RouterRpcLocal implements IRouterRpc {
 
-    private readonly config: RouterRpcLocalConfig
+    private readonly options: RouterRpcLocalOptions
 
-    constructor(config: RouterRpcLocalConfig) {
-        this.config = config
+    constructor(options: RouterRpcLocalOptions) {
+        this.options = options
     }
 
     async routeMessage(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
-        if (this.config.duplicateRequestDetector.isMostLikelyDuplicate(routedMessage.requestId)) {
+        if (this.options.duplicateRequestDetector.isMostLikelyDuplicate(routedMessage.requestId)) {
             logger.trace(`Routing message ${routedMessage.requestId} from ${getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)} `
                 + `to ${getDhtAddressFromRaw(routedMessage.target)} is likely a duplicate`)
             return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
         }
         logger.trace(`Processing received routeMessage ${routedMessage.requestId}`)
-        this.config.duplicateRequestDetector.add(routedMessage.requestId)
-        if (areEqualBinaries(this.config.localPeerDescriptor.nodeId, routedMessage.target)) {
+        this.options.duplicateRequestDetector.add(routedMessage.requestId)
+        if (areEqualBinaries(this.options.localPeerDescriptor.nodeId, routedMessage.target)) {
             logger.trace(`routing message targeted to self ${routedMessage.requestId}`)
-            this.config.setForwardingEntries(routedMessage)
-            this.config.handleMessage(routedMessage.message!)
+            this.options.setForwardingEntries(routedMessage)
+            this.options.handleMessage(routedMessage.message!)
             return createRouteMessageAck(routedMessage)
         } else {
-            return this.config.doRouteMessage(routedMessage)
+            return this.options.doRouteMessage(routedMessage)
         }
     }
 
     async forwardMessage(forwardMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
-        if (this.config.duplicateRequestDetector.isMostLikelyDuplicate(forwardMessage.requestId)) {
+        if (this.options.duplicateRequestDetector.isMostLikelyDuplicate(forwardMessage.requestId)) {
             logger.trace(`Forwarding message ${forwardMessage.requestId} from ${getNodeIdFromPeerDescriptor(forwardMessage.sourcePeer!)} `
                 + `to ${getDhtAddressFromRaw(forwardMessage.target)} is likely a duplicate`)
             return createRouteMessageAck(forwardMessage, RouteMessageError.DUPLICATE)
         }
         logger.trace(`Processing received forward routeMessage ${forwardMessage.requestId}`)
-        this.config.duplicateRequestDetector.add(forwardMessage.requestId)
-        if (areEqualBinaries(this.config.localPeerDescriptor.nodeId, forwardMessage.target)) {
+        this.options.duplicateRequestDetector.add(forwardMessage.requestId)
+        if (areEqualBinaries(this.options.localPeerDescriptor.nodeId, forwardMessage.target)) {
             return this.forwardToDestination(forwardMessage)
         } else {
-            return this.config.doRouteMessage(forwardMessage, RoutingMode.FORWARD)
+            return this.options.doRouteMessage(forwardMessage, RoutingMode.FORWARD)
         }
     }
 
     private forwardToDestination(routedMessage: RouteMessageWrapper): RouteMessageAck {
         logger.trace(`Forwarding found message targeted to self ${routedMessage.requestId}`)
         const forwardedMessage = routedMessage.message!
-        if (areEqualPeerDescriptors(this.config.localPeerDescriptor, forwardedMessage.targetDescriptor!)) {
-            this.config.handleMessage(forwardedMessage)
+        if (areEqualPeerDescriptors(this.options.localPeerDescriptor, forwardedMessage.targetDescriptor!)) {
+            this.options.handleMessage(forwardedMessage)
             return createRouteMessageAck(routedMessage)
         }
-        return this.config.doRouteMessage({ ...routedMessage, requestId: v4(), target: forwardedMessage.targetDescriptor!.nodeId })
+        return this.options.doRouteMessage({ ...routedMessage, requestId: v4(), target: forwardedMessage.targetDescriptor!.nodeId })
     }
 
 }

package/src/dht/routing/RoutingSession.ts

@@ -64,7 +64,7 @@ export interface RoutingSessionEvents {
 
 export enum RoutingMode { ROUTE, FORWARD, RECURSIVE }
 
-interface RoutingSessionConfig {
+interface RoutingSessionOptions {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
     routedMessage: RouteMessageWrapper
@@ -83,11 +83,11 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
     private failedHopCounter = 0
     private successfulHopCounter = 0
     private stopped = false
-    private readonly config: RoutingSessionConfig
+    private readonly options: RoutingSessionOptions
 
-    constructor(config: RoutingSessionConfig) {
+    constructor(options: RoutingSessionOptions) {
         super()
-        this.config = config
+        this.options = options
     }
 
     private onRequestFailed(nodeId: DhtAddress) {
@@ -129,7 +129,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             return
         }
         this.successfulHopCounter += 1
-        if (this.successfulHopCounter >= this.config.parallelism) {
+        if (this.successfulHopCounter >= this.options.parallelism) {
             this.emit('routingSucceeded')
             return
         }
@@ -146,12 +146,12 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             return false
         }
         const msg = {
-            ...this.config.routedMessage,
-            routingPath: this.config.routedMessage.routingPath.concat([this.config.localPeerDescriptor])
+            ...this.options.routedMessage,
+            routingPath: this.options.routedMessage.routingPath.concat([this.options.localPeerDescriptor])
         }
-        if (this.config.mode === RoutingMode.FORWARD) {
+        if (this.options.mode === RoutingMode.FORWARD) {
             return contact.getRouterRpcRemote().forwardMessage(msg)
-        } else if (this.config.mode === RoutingMode.RECURSIVE) {
+        } else if (this.options.mode === RoutingMode.RECURSIVE) {
             return contact.getRecursiveOperationRpcRemote().routeRequest(msg)
         } else {
             return contact.getRouterRpcRemote().routeMessage(msg)
@@ -160,30 +160,30 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     updateAndGetRoutablePeers(): RoutingRemoteContact[] {
         logger.trace('getRoutablePeers() sessionId: ' + this.sessionId)
-        const previousPeer = getPreviousPeer(this.config.routedMessage)
+        const previousPeer = getPreviousPeer(this.options.routedMessage)
         const previousId = previousPeer ? getNodeIdFromPeerDescriptor(previousPeer) : undefined
-        const targetId = getDhtAddressFromRaw(this.config.routedMessage.target)
+        const targetId = getDhtAddressFromRaw(this.options.routedMessage.target)
         let routingTable: RoutingTable
-        if (this.config.routingTablesCache.has(targetId, previousId)) {
-            routingTable = this.config.routingTablesCache.get(targetId, previousId)!
+        if (this.options.routingTablesCache.has(targetId, previousId)) {
+            routingTable = this.options.routingTablesCache.get(targetId, previousId)!
         } else {
             routingTable = new SortedContactList<RoutingRemoteContact>({
-                referenceId: getDhtAddressFromRaw(this.config.routedMessage.target),
+                referenceId: getDhtAddressFromRaw(this.options.routedMessage.target),
                 maxSize: ROUTING_TABLE_MAX_SIZE,
                 allowToContainReferenceId: true,
                 nodeIdDistanceLimit: previousId
             })
-            const contacts = this.config.getConnections()
+            const contacts = this.options.getConnections()
                 .map((peer) => new RoutingRemoteContact(
                     peer,
-                    this.config.localPeerDescriptor,
-                    this.config.rpcCommunicator
+                    this.options.localPeerDescriptor,
+                    this.options.rpcCommunicator
                 ))
             routingTable.addContacts(contacts)
-            this.config.routingTablesCache.set(targetId, routingTable, previousId)
+            this.options.routingTablesCache.set(targetId, routingTable, previousId)
         }
         return routingTable.getClosestContacts()
-            .filter((contact) => !this.contactedPeers.has(contact.getNodeId()) && !this.config.excludedNodeIds.has(contact.getNodeId()))
+            .filter((contact) => !this.contactedPeers.has(contact.getNodeId()) && !this.options.excludedNodeIds.has(contact.getNodeId()))
     }
 
     sendMoreRequests(uncontacted: RoutingRemoteContact[]): void {
@@ -195,7 +195,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             this.emitFailure()
             return
         }
-        while ((this.ongoingRequests.size < this.config.parallelism) && (uncontacted.length > 0) && !this.stopped) {
+        while ((this.ongoingRequests.size < this.options.parallelism) && (uncontacted.length > 0) && !this.stopped) {
             const nextPeer = uncontacted.shift()
             // eslint-disable-next-line max-len
             logger.trace(`Sending routeMessage request to contact: ${getNodeIdFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
@@ -221,19 +221,19 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     private addParallelRootIfSource(nodeId: DhtAddress) {
         if (
-            this.config.mode === RoutingMode.RECURSIVE
-            && areEqualPeerDescriptors(this.config.localPeerDescriptor, this.config.routedMessage.sourcePeer!)
+            this.options.mode === RoutingMode.RECURSIVE
+            && areEqualPeerDescriptors(this.options.localPeerDescriptor, this.options.routedMessage.sourcePeer!)
         ) {
-            this.config.routedMessage.parallelRootNodeIds.push(nodeId)
+            this.options.routedMessage.parallelRootNodeIds.push(nodeId)
         }
     }
 
     private deleteParallelRootIfSource(nodeId: DhtAddress) {
         if (
-            this.config.mode === RoutingMode.RECURSIVE
-            && areEqualPeerDescriptors(this.config.localPeerDescriptor, this.config.routedMessage.sourcePeer!)
+            this.options.mode === RoutingMode.RECURSIVE
+            && areEqualPeerDescriptors(this.options.localPeerDescriptor, this.options.routedMessage.sourcePeer!)
         ) {
-            pull(this.config.routedMessage.parallelRootNodeIds, nodeId)
+            pull(this.options.routedMessage.parallelRootNodeIds, nodeId)
         }
     }
 

package/src/dht/store/StoreManager.ts

@@ -24,7 +24,7 @@ import { LocalDataStore } from './LocalDataStore'
 import { StoreRpcLocal } from './StoreRpcLocal'
 import { StoreRpcRemote } from './StoreRpcRemote'
 
-interface StoreManagerConfig {
+interface StoreManagerOptions {
     rpcCommunicator: RoutingRpcCommunicator
     recursiveOperationManager: RecursiveOperationManager
     localPeerDescriptor: PeerDescriptor
@@ -40,28 +40,28 @@ const logger = new Logger(module)
 
 export class StoreManager {
 
-    private readonly config: StoreManagerConfig
+    private readonly options: StoreManagerOptions
 
-    constructor(config: StoreManagerConfig) {
-        this.config = config
+    constructor(options: StoreManagerOptions) {
+        this.options = options
         this.registerLocalRpcMethods()
     }
 
     private registerLocalRpcMethods() {
         const rpcLocal = new StoreRpcLocal({
-            localPeerDescriptor: this.config.localPeerDescriptor,
-            localDataStore: this.config.localDataStore,
+            localPeerDescriptor: this.options.localPeerDescriptor,
+            localDataStore: this.options.localDataStore,
             replicateDataToContact: (dataEntry: DataEntry, contact: PeerDescriptor) => this.replicateDataToContact(dataEntry, contact),
             getStorers: (dataKey: DhtAddress) => this.getStorers(dataKey)
         })
-        this.config.rpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData',
+        this.options.rpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData',
             (request: StoreDataRequest) => rpcLocal.storeData(request))
-        this.config.rpcCommunicator.registerRpcNotification(ReplicateDataRequest, 'replicateData',
+        this.options.rpcCommunicator.registerRpcNotification(ReplicateDataRequest, 'replicateData',
             (request: ReplicateDataRequest, context: ServerCallContext) => rpcLocal.replicateData(request, context))
     }
 
     onContactAdded(peerDescriptor: PeerDescriptor): void {
-        for (const key of this.config.localDataStore.keys()) {
+        for (const key of this.options.localDataStore.keys()) {
             this.replicateAndUpdateStaleState(key, peerDescriptor)
         }
     }
@@ -69,21 +69,21 @@ export class StoreManager {
     private replicateAndUpdateStaleState(dataKey: DhtAddress, newNode: PeerDescriptor): void {
         const storers = this.getStorers(dataKey)
         const storersBeforeContactAdded = storers.filter((p) => !areEqualPeerDescriptors(p, newNode))
-        const selfWasPrimaryStorer = areEqualPeerDescriptors(storersBeforeContactAdded[0], this.config.localPeerDescriptor)
+        const selfWasPrimaryStorer = areEqualPeerDescriptors(storersBeforeContactAdded[0], this.options.localPeerDescriptor)
         if (selfWasPrimaryStorer) {
             if (storers.some((p) => areEqualPeerDescriptors(p, newNode))) {
                 setImmediate(async () => {
-                    const dataEntries = Array.from(this.config.localDataStore.values(dataKey))
+                    const dataEntries = Array.from(this.options.localDataStore.values(dataKey))
                     await Promise.all(dataEntries.map(async (dataEntry) => this.replicateDataToContact(dataEntry, newNode)))
                 })
             }
-        } else if (!storers.some((p) => areEqualPeerDescriptors(p, this.config.localPeerDescriptor))) {
-            this.config.localDataStore.setAllEntriesAsStale(dataKey)
+        } else if (!storers.some((p) => areEqualPeerDescriptors(p, this.options.localPeerDescriptor))) {
+            this.options.localDataStore.setAllEntriesAsStale(dataKey)
         }
     }
 
     private async replicateDataToContact(dataEntry: DataEntry, contact: PeerDescriptor): Promise<void> {
-        const rpcRemote = this.config.createRpcRemote(contact)
+        const rpcRemote = this.options.createRpcRemote(contact)
         try {
             await rpcRemote.replicateData({ entry: dataEntry })
         } catch (e) {
@@ -92,17 +92,17 @@ export class StoreManager {
     }
 
     public async storeDataToDht(key: DhtAddress, data: Any, creator: DhtAddress): Promise<PeerDescriptor[]> {
-        logger.debug(`Storing data to DHT ${this.config.serviceId}`)
-        const result = await this.config.recursiveOperationManager.execute(key, RecursiveOperation.FIND_CLOSEST_NODES)
+        logger.debug(`Storing data to DHT ${this.options.serviceId}`)
+        const result = await this.options.recursiveOperationManager.execute(key, RecursiveOperation.FIND_CLOSEST_NODES)
         const closestNodes = result.closestNodes
         const successfulNodes: PeerDescriptor[] = []
-        const ttl = this.config.highestTtl // ToDo: make TTL decrease according to some nice curve
+        const ttl = this.options.highestTtl // ToDo: make TTL decrease according to some nice curve
         const createdAt = Timestamp.now()
-        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.config.redundancyFactor; i++) {
+        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.options.redundancyFactor; i++) {
             const keyRaw = getRawFromDhtAddress(key)
             const creatorRaw = getRawFromDhtAddress(creator)
-            if (areEqualPeerDescriptors(this.config.localPeerDescriptor, closestNodes[i])) {
-                this.config.localDataStore.storeEntry({
+            if (areEqualPeerDescriptors(this.options.localPeerDescriptor, closestNodes[i])) {
+                this.options.localDataStore.storeEntry({
                     key: keyRaw,
                     data,
                     creator: creatorRaw,
@@ -115,7 +115,7 @@ export class StoreManager {
                 successfulNodes.push(closestNodes[i])
                 continue
             }
-            const rpcRemote = this.config.createRpcRemote(closestNodes[i])
+            const rpcRemote = this.options.createRpcRemote(closestNodes[i])
             try {
                 await rpcRemote.storeData({
                     key: keyRaw,
@@ -134,16 +134,16 @@ export class StoreManager {
     }
 
     private async replicateDataToClosestNodes(): Promise<void> {
-        const dataEntries = Array.from(this.config.localDataStore.values())
+        const dataEntries = Array.from(this.options.localDataStore.values())
         await Promise.all(dataEntries.map(async (dataEntry) => {
             const dataKey = getDhtAddressFromRaw(dataEntry.key)
             const neighbors = getClosestNodes(
                 dataKey,
-                this.config.getNeighbors(),
-                { maxCount: this.config.redundancyFactor }
+                this.options.getNeighbors(),
+                { maxCount: this.options.redundancyFactor }
             )
             await Promise.all(neighbors.map(async (neighbor) => {
-                const rpcRemote = this.config.createRpcRemote(neighbor)
+                const rpcRemote = this.options.createRpcRemote(neighbor)
                 try {
                     await rpcRemote.replicateData({ entry: dataEntry })
                 } catch (err) {
@@ -156,9 +156,9 @@ export class StoreManager {
     private getStorers(dataKey: DhtAddress, excludedNode?: PeerDescriptor): PeerDescriptor[] {
         return getClosestNodes(
             dataKey,
-            [...this.config.getNeighbors(), this.config.localPeerDescriptor],
+            [...this.options.getNeighbors(), this.options.localPeerDescriptor],
             { 
-                maxCount: this.config.redundancyFactor,
+                maxCount: this.options.redundancyFactor,
                 excludedNodeIds: excludedNode !== undefined ? new Set([getNodeIdFromPeerDescriptor(excludedNode)]) : undefined
             }
         )

package/src/dht/store/StoreRpcLocal.ts

@@ -13,7 +13,7 @@ import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { LocalDataStore } from './LocalDataStore'
 import { areEqualPeerDescriptors, DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
 
-interface StoreRpcLocalConfig {
+interface StoreRpcLocalOptions {
     localDataStore: LocalDataStore
     localPeerDescriptor: PeerDescriptor
     replicateDataToContact: (dataEntry: DataEntry, contact: PeerDescriptor) => Promise<void>
@@ -24,17 +24,17 @@ const logger = new Logger(module)
 
 export class StoreRpcLocal implements IStoreRpc {
 
-    private readonly config: StoreRpcLocalConfig
+    private readonly options: StoreRpcLocalOptions
 
-    constructor(config: StoreRpcLocalConfig) {
-        this.config = config
+    constructor(options: StoreRpcLocalOptions) {
+        this.options = options
     }
 
     async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
         logger.trace('storeData()')
         const key = getDhtAddressFromRaw(request.key)
         const isLocalNodeStorer = this.isLocalNodeStorer(key)
-        this.config.localDataStore.storeEntry({ 
+        this.options.localDataStore.storeEntry({ 
             key: request.key,
             data: request.data,
             creator: request.creator,
@@ -45,7 +45,7 @@ export class StoreRpcLocal implements IStoreRpc {
             deleted: false
         })
         if (!isLocalNodeStorer) {
-            this.config.localDataStore.setAllEntriesAsStale(key)
+            this.options.localDataStore.setAllEntriesAsStale(key)
         }
         return {}
     }
@@ -53,35 +53,35 @@ export class StoreRpcLocal implements IStoreRpc {
     public async replicateData(request: ReplicateDataRequest, context: ServerCallContext): Promise<Empty> {
         logger.trace('server-side replicateData()')
         const dataEntry = request.entry!
-        const wasStored = this.config.localDataStore.storeEntry(dataEntry)
+        const wasStored = this.options.localDataStore.storeEntry(dataEntry)
         if (wasStored) {
             this.replicateDataToNeighbors((context as DhtCallContext).incomingSourceDescriptor!, request.entry!)
         }
         const key = getDhtAddressFromRaw(dataEntry.key)
         if (!this.isLocalNodeStorer(key)) {
-            this.config.localDataStore.setAllEntriesAsStale(key)
+            this.options.localDataStore.setAllEntriesAsStale(key)
         }
         logger.trace('server-side replicateData() at end')
         return {}
     }
 
     private isLocalNodeStorer(dataKey: DhtAddress): boolean {
-        return this.config.getStorers(dataKey).some((p) => areEqualPeerDescriptors(p, this.config.localPeerDescriptor))    
+        return this.options.getStorers(dataKey).some((p) => areEqualPeerDescriptors(p, this.options.localPeerDescriptor))    
     }
 
     private replicateDataToNeighbors(requestor: PeerDescriptor, dataEntry: DataEntry): void {
         const dataKey = getDhtAddressFromRaw(dataEntry.key)
-        const storers = this.config.getStorers(dataKey)
-        const isLocalNodePrimaryStorer = areEqualPeerDescriptors(storers[0], this.config.localPeerDescriptor)
+        const storers = this.options.getStorers(dataKey)
+        const isLocalNodePrimaryStorer = areEqualPeerDescriptors(storers[0], this.options.localPeerDescriptor)
         // If we are the closest to the data, get storageRedundancyFactor - 1 nearest node to the data, and
         // replicate to all those node. Otherwise replicate only to the one closest one. And never replicate 
         // to the requestor nor to itself.
         const targets = (isLocalNodePrimaryStorer ? storers : [storers[0]]).filter(
-            (p) => !areEqualPeerDescriptors(p, requestor) && !areEqualPeerDescriptors(p, this.config.localPeerDescriptor)
+            (p) => !areEqualPeerDescriptors(p, requestor) && !areEqualPeerDescriptors(p, this.options.localPeerDescriptor)
         )
         targets.forEach((target) => {
             setImmediate(() => {
-                executeSafePromise(() => this.config.replicateDataToContact(dataEntry, target))
+                executeSafePromise(() => this.options.replicateDataToContact(dataEntry, target))
             })
         })
     }

package/src/exports.ts

@@ -16,9 +16,12 @@ export { IceServer } from './connection/webrtc/WebrtcConnector'
 export { DhtCallContext } from './rpc-protocol/DhtCallContext'
 export { WebsocketClientConnection } from './connection/websocket/NodeWebsocketClientConnection'
 export { ManagedConnection } from './connection/ManagedConnection'
+export { PendingConnection } from './connection/PendingConnection'
+export { IConnection } from './connection/IConnection'
 export { ConnectionType } from './connection/IConnection'
 export { ServiceID } from './types/ServiceID'
 export { RingContacts } from './dht/contact/RingContactList'
+export { createOutgoingHandshaker } from './connection/Handshaker'
 export { 
     DhtAddress,
     DhtAddressRaw,

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
 //
@@ -74,7 +74,7 @@ import { MessageType } from "@protobuf-ts/runtime";
  *       foo = any.unpack(Foo.class);
  *     }
  *
- * Example 3: Pack and unpack a message in Python.
+ *  Example 3: Pack and unpack a message in Python.
  *
  *     foo = Foo(...)
  *     any = Any()
@@ -84,16 +84,13 @@ import { MessageType } from "@protobuf-ts/runtime";
  *       any.Unpack(foo)
  *       ...
  *
- * Example 4: Pack and unpack a message in Go
+ *  Example 4: Pack and unpack a message in Go
  *
  *      foo := &pb.Foo{...}
- *      any, err := anypb.New(foo)
- *      if err != nil {
- *        ...
- *      }
+ *      any, err := ptypes.MarshalAny(foo)
  *      ...
  *      foo := &pb.Foo{}
- *      if err := any.UnmarshalTo(foo); err != nil {
+ *      if err := ptypes.UnmarshalAny(any, foo); err != nil {
  *        ...
  *      }
  *
@@ -105,7 +102,7 @@ import { MessageType } from "@protobuf-ts/runtime";
  *
  *
  * JSON
- *
+ * ====
  * The JSON representation of an `Any` value uses the regular
  * representation of the deserialized, embedded message, with an
  * additional field `@type` which contains the type URL. Example:

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
 //
@@ -49,6 +49,7 @@ import { MessageType } from "@protobuf-ts/runtime";
  *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
  *     }
  *
+ * The JSON representation for `Empty` is empty JSON object `{}`.
  *
  * @generated from protobuf message google.protobuf.Empty
  */

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
 //
@@ -98,16 +98,7 @@ import { MessageType } from "@protobuf-ts/runtime";
  *         .setNanos((int) ((millis % 1000) * 1000000)).build();
  *
  *
- * Example 5: Compute Timestamp from Java `Instant.now()`.
- *
- *     Instant now = Instant.now();
- *
- *     Timestamp timestamp =
- *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
- *             .setNanos(now.getNano()).build();
- *
- *
- * Example 6: Compute Timestamp from current time in Python.
+ * Example 5: Compute Timestamp from current time in Python.
  *
  *     timestamp = Timestamp()
  *     timestamp.GetCurrentTime()

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
  */
@@ -1213,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/transport/ListeningRpcCommunicator.ts

@@ -1,6 +1,6 @@
 import { ITransport } from './ITransport' 
 import { RoutingRpcCommunicator } from './RoutingRpcCommunicator'
-import { RpcCommunicatorConfig } from '@streamr/proto-rpc'
+import { RpcCommunicatorOptions } from '@streamr/proto-rpc'
 import { Message } from '../proto/packages/dht/protos/DhtRpc'
 import { ServiceID } from '../types/ServiceID'
 
@@ -8,8 +8,8 @@ export class ListeningRpcCommunicator extends RoutingRpcCommunicator {
     private readonly transport: ITransport
     private readonly listener: (msg: Message) => void
 
-    constructor(ownServiceId: ServiceID, transport: ITransport, config?: RpcCommunicatorConfig) {
-        super(ownServiceId, (msg, opts) => transport.send(msg, opts), config)
+    constructor(ownServiceId: ServiceID, transport: ITransport, options?: RpcCommunicatorOptions) {
+        super(ownServiceId, (msg, opts) => transport.send(msg, opts), options)
         this.listener = (msg: Message) => {
             this.handleMessageFromPeer(msg)
         }