@streamr/dht 100.0.0-testnet-one.3 → 100.0.0-testnet-two.0

package/src/dht/PeerManager.ts

@@ -1,12 +1,9 @@
 import {
-    Logger
+    Logger, hexToBinary
 } from '@streamr/utils'
 import KBucket from 'k-bucket'
-import { PeerID, PeerIDKey } from '../helpers/PeerID'
 import {
-    getNodeIdFromPeerDescriptor,
-    keyFromPeerDescriptor,
-    peerIdFromPeerDescriptor
+    getNodeIdFromPeerDescriptor
 } from '../helpers/peerIdFromPeerDescriptor'
 import {
     PeerDescriptor
@@ -16,6 +13,7 @@ import { RandomContactList } from './contact/RandomContactList'
 import { SortedContactList } from './contact/SortedContactList'
 import { ConnectionManager } from '../connection/ConnectionManager'
 import EventEmitter from 'eventemitter3'
+import { NodeID, areEqualNodeIds } from '../helpers/nodeId'
 
 const logger = new Logger(module)
 
@@ -23,7 +21,7 @@ interface PeerManagerConfig {
     numberOfNodesPerKBucket: number
     maxContactListSize: number
     peerDiscoveryQueryBatchSize: number
-    ownPeerId: PeerID
+    localNodeId: NodeID
     connectionManager: ConnectionManager
     isLayer0: boolean
     createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
@@ -37,8 +35,8 @@ export interface PeerManagerEvents {
     kBucketEmpty: () => void
 }
 
-export const getDistance = (peerId1: Uint8Array, peerId2: Uint8Array): number => {
-    return KBucket.distance(peerId1, peerId2)
+export const getDistance = (nodeId1: NodeID, nodeId2: NodeID): number => {
+    return KBucket.distance(hexToBinary(nodeId1), hexToBinary(nodeId2))
 }
 
 export class PeerManager extends EventEmitter<PeerManagerEvents> {
@@ -50,28 +48,23 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     // * 'contacts' are all non-unresponsive nodes that we know about
 
     // The kademlia k-bucket
-    private bucket?: KBucket<DhtNodeRpcRemote>
+    private bucket: KBucket<DhtNodeRpcRemote>
     // Nodes that are connected to this node on Layer0
-    public readonly connections: Map<PeerIDKey, DhtNodeRpcRemote> = new Map()
+    public readonly connections: Map<NodeID, DhtNodeRpcRemote> = new Map()
     // All nodes that we know about
-    private contacts?: SortedContactList<DhtNodeRpcRemote>
-    private randomPeers?: RandomContactList<DhtNodeRpcRemote>
-    private readonly config: PeerManagerConfig
+    private contacts: SortedContactList<DhtNodeRpcRemote>
+    private randomPeers: RandomContactList<DhtNodeRpcRemote>
     private stopped: boolean = false
+    private readonly config: PeerManagerConfig
 
     constructor(config: PeerManagerConfig) {
         super()
         this.config = config
-        this.initKBuckets()
-    }
-
-    private initKBuckets() {
         this.bucket = new KBucket<DhtNodeRpcRemote>({
-            localNodeId: this.config.ownPeerId.value,
+            localNodeId: hexToBinary(this.config.localNodeId),
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
             numberOfNodesToPing: this.config.numberOfNodesPerKBucket
         })
-
         this.bucket.on('ping', (oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote) => this.onKBucketPing(oldContacts, newContact))
         this.bucket.on('removed', (contact: DhtNodeRpcRemote) => this.onKBucketRemoved(contact))
         this.bucket.on('added', (contact: DhtNodeRpcRemote) => this.onKBucketAdded(contact))
@@ -79,7 +72,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             // TODO: Update contact info to the connection manager and reconnect
         })
         this.contacts = new SortedContactList({
-            referenceId: this.config.ownPeerId, 
+            referenceId: this.config.localNodeId, 
             maxSize: this.config.maxContactListSize,
             allowToContainReferenceId: false,
             emitEvents: true
@@ -89,12 +82,12 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
                 return
             }
             this.emit('contactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
-            this.randomPeers!.addContact(this.config.createDhtNodeRpcRemote(removedContact.getPeerDescriptor()))
+            this.randomPeers.addContact(this.config.createDhtNodeRpcRemote(removedContact.getPeerDescriptor()))
         })
         this.contacts.on('newContact', (newContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
             this.emit('newContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
-        this.randomPeers = new RandomContactList(this.config.ownPeerId, this.config.maxContactListSize)
+        this.randomPeers = new RandomContactList(this.config.localNodeId, this.config.maxContactListSize)
         this.randomPeers.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
             this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
@@ -108,7 +101,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList({
-            referenceId: this.config.ownPeerId, 
+            referenceId: this.config.localNodeId, 
             maxSize: 100,  // TODO use config option or named constant?
             allowToContainReferenceId: false,
             emitEvents: false
@@ -116,8 +109,8 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         sortingList.addContacts(oldContacts)
         const sortedContacts = sortingList.getAllContacts()
         this.config.connectionManager?.weakUnlockConnection(sortedContacts[sortedContacts.length - 1].getPeerDescriptor())
-        this.bucket?.remove(sortedContacts[sortedContacts.length - 1].getPeerId().value)    
-        this.bucket!.add(newContact)
+        this.bucket.remove(hexToBinary(sortedContacts[sortedContacts.length - 1].getNodeId()))
+        this.bucket.add(newContact)
     }
 
     private onKBucketRemoved(contact: DhtNodeRpcRemote): void {
@@ -126,7 +119,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         }
         this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
         logger.trace(`Removed contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
-        if (this.bucket!.count() === 0) {
+        if (this.bucket.count() === 0) {
             this.emit('kBucketEmpty')
         }
     }
@@ -135,10 +128,10 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        if (!contact.getPeerId().equals(this.config.ownPeerId)) {
+        if (!areEqualNodeIds(contact.getNodeId(), this.config.localNodeId)) {
             // Important to lock here, before the ping result is known
             this.config.connectionManager?.weakLockConnection(contact.getPeerDescriptor())
-            if (this.connections.has(contact.getPeerId().toKey())) {
+            if (this.connections.has(contact.getNodeId())) {
                 logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
             } else {    // open connection by pinging
                 logger.trace('starting ping ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
@@ -172,21 +165,22 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     }
 
     private getClosestActiveContactNotInBucket(): DhtNodeRpcRemote | undefined {
-        for (const contactId of this.contacts!.getContactIds()) {
-            if (!this.bucket!.get(contactId.value) && this.contacts!.isActive(contactId)) {
-                return this.contacts!.getContact(contactId)!.contact
+        for (const contactId of this.contacts.getContactIds()) {
+            if (!this.bucket.get(hexToBinary(contactId)) && this.contacts.isActive(contactId)) {
+                return this.contacts.getContact(contactId)!.contact
             }
         }
         return undefined
     }
 
     handleConnected(peerDescriptor: PeerDescriptor): void {
-        if (PeerID.fromValue(peerDescriptor.nodeId).equals(this.config.ownPeerId)) {
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        if (areEqualNodeIds(nodeId, this.config.localNodeId)) {
             logger.error('handleConnected() to self')
         }
         const rpcRemote = this.config.createDhtNodeRpcRemote(peerDescriptor)
-        if (!this.connections.has(PeerID.fromValue(rpcRemote.id).toKey())) {
-            this.connections.set(PeerID.fromValue(rpcRemote.id).toKey(), rpcRemote)
+        if (!this.connections.has(nodeId)) {
+            this.connections.set(nodeId, rpcRemote)
             logger.trace('connectionschange add ' + this.connections.size)
         } else {
             logger.trace('new connection not set to connections, there is already a connection with the peer ID')
@@ -196,9 +190,9 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
 
     handleDisconnected(peerDescriptor: PeerDescriptor, gracefulLeave: boolean): void {
         logger.trace('disconnected: ' + getNodeIdFromPeerDescriptor(peerDescriptor))
-        this.connections.delete(keyFromPeerDescriptor(peerDescriptor))
+        this.connections.delete(getNodeIdFromPeerDescriptor(peerDescriptor))
         if (this.config.isLayer0) {
-            this.bucket!.remove(peerDescriptor.nodeId)
+            this.bucket.remove(peerDescriptor.nodeId)
             if (gracefulLeave === true) {
                 logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
                 this.removeContact(peerDescriptor)
@@ -217,65 +211,54 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         logger.trace(`Removing contact ${getNodeIdFromPeerDescriptor(contact)}`)
-        const peerId = peerIdFromPeerDescriptor(contact)
-        this.bucket!.remove(peerId.value)
-        this.contacts!.removeContact(peerId)
-        this.randomPeers!.removeContact(peerId)
+        const nodeId = getNodeIdFromPeerDescriptor(contact)
+        this.bucket.remove(hexToBinary(nodeId))
+        this.contacts.removeContact(nodeId)
+        this.randomPeers.removeContact(nodeId)
     }
 
     stop(): void {
         this.stopped = true
-        this.bucket!.toArray().forEach((rpcRemote: DhtNodeRpcRemote) => {
+        this.bucket.toArray().forEach((rpcRemote: DhtNodeRpcRemote) => {
             rpcRemote.leaveNotice()
-            this.bucket!.remove(rpcRemote.id)
+            this.bucket.remove(rpcRemote.id)
         })
-        this.bucket!.removeAllListeners()
-        this.contacts!.stop()
-        this.randomPeers!.stop()
+        this.bucket.removeAllListeners()
+        this.contacts.stop()
+        this.randomPeers.stop()
         this.connections.clear()
     }
 
-    getClosestNeighborsTo(kademliaId: Uint8Array, limit?: number, excludeSet?: Set<PeerIDKey>): DhtNodeRpcRemote[] {
+    getClosestNeighborsTo(referenceId: NodeID, limit?: number, excludedNodeIds?: Set<NodeID>): DhtNodeRpcRemote[] {
         const closest = new SortedContactList<DhtNodeRpcRemote>({
-            referenceId: PeerID.fromValue(kademliaId),
+            referenceId,
             allowToContainReferenceId: true,
-            emitEvents: false
+            emitEvents: false,
+            excludedNodeIds
         }) 
-        this.bucket!.toArray().map((contact) => closest.addContact(contact))
-        // TODO should set the excludeSet and limit to SortedContactList constructor and remove these line
-        return closest.getClosestContacts(limit).filter((contact) => {
-            if (!excludeSet) {
-                return true
-            } else {
-                return !excludeSet.has(contact.getPeerId().toKey())
-            } 
-        })
+        this.bucket.toArray().map((contact) => closest.addContact(contact))
+        return closest.getClosestContacts(limit)
     }
 
     // TODO reduce copy-paste?
-    getClosestContactsTo(kademliaId: Uint8Array, limit?: number, excludeSet?: Set<PeerIDKey>): DhtNodeRpcRemote[] {
+    getClosestContactsTo(referenceId: NodeID, limit?: number, excludedNodeIds?: Set<NodeID>): DhtNodeRpcRemote[] {
         const closest = new SortedContactList<DhtNodeRpcRemote>({
-            referenceId: PeerID.fromValue(kademliaId),
+            referenceId,
             allowToContainReferenceId: true,
-            emitEvents: false
+            emitEvents: false,
+            excludedNodeIds
         })
-        this.contacts!.getAllContacts().map((contact) => closest.addContact(contact))
+        this.contacts.getAllContacts().map((contact) => closest.addContact(contact))
         // TODO should set the excludeSet and limit to SortedContactList constructor and remove these line
-        return closest.getClosestContacts(limit).filter((contact) => {
-            if (!excludeSet) {
-                return true
-            } else {
-                return !excludeSet.has(contact.getPeerId().toKey())
-            } 
-        })
+        return closest.getClosestContacts(limit)
     }
 
-    getNumberOfContacts(excludeSet?: Set<PeerIDKey>): number {
-        return this.contacts!.getAllContacts().filter((contact) => {
-            if (!excludeSet) {
+    getNumberOfContacts(excludedNodeIds?: Set<NodeID>): number {
+        return this.contacts.getAllContacts().filter((contact) => {
+            if (!excludedNodeIds) {
                 return true
             } else {
-                return !excludeSet.has(contact.getPeerId().toKey())
+                return !excludedNodeIds.has(contact.getNodeId())
             } 
         }).length
     }
@@ -285,20 +268,20 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     }
 
     getNumberOfNeighbors(): number {
-        return this.bucket!.count()
+        return this.bucket.count()
     }
 
     getNeighbors(): PeerDescriptor[] {
-        return this.bucket!.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
+        return this.bucket.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
     }
 
-    handlePeerActive(peerId: PeerID): void {
-        this.contacts!.setActive(peerId)
+    handlePeerActive(nodeId: NodeID): void {
+        this.contacts.setActive(nodeId)
     }
 
-    handlePeerUnresponsive(peerId: PeerID): void {
-        this.bucket!.remove(peerId.value)
-        this.contacts!.removeContact(peerId)
+    handlePeerUnresponsive(nodeId: NodeID): void {
+        this.bucket.remove(hexToBinary(nodeId))
+        this.contacts.removeContact(nodeId)
     }
 
     handleNewPeers(peerDescriptors: PeerDescriptor[], setActive?: boolean): void { 
@@ -306,23 +289,23 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         peerDescriptors.forEach((contact) => {
-            const peerId = peerIdFromPeerDescriptor(contact)
-            if (!peerId.equals(this.config.ownPeerId)) {
-                logger.trace(`Adding new contact ${getNodeIdFromPeerDescriptor(contact)}`)
+            const nodeId = getNodeIdFromPeerDescriptor(contact)
+            if (!areEqualNodeIds(nodeId, this.config.localNodeId)) {
+                logger.trace(`Adding new contact ${nodeId}`)
                 const remote = this.config.createDhtNodeRpcRemote(contact)
-                const isInBucket = (this.bucket!.get(contact.nodeId) !== null)
-                const isInNeighborList = (this.contacts!.getContact(peerId) !== undefined)
-                if (isInBucket || isInNeighborList) {
-                    this.randomPeers!.addContact(remote)
+                const isInBucket = (this.bucket.get(contact.nodeId) !== null)
+                const isInContacts = (this.contacts.getContact(nodeId) !== undefined)
+                if (isInBucket || isInContacts) {
+                    this.randomPeers.addContact(remote)
                 }
                 if (!isInBucket) {
-                    this.bucket!.add(remote)
+                    this.bucket.add(remote)
                 } 
-                if (!isInNeighborList) {
-                    this.contacts!.addContact(remote)
+                if (!isInContacts) {
+                    this.contacts.addContact(remote)
                 } 
                 if (setActive) {
-                    this.contacts!.setActive(peerId)
+                    this.contacts.setActive(nodeId)
                 }
             }
         })

package/src/dht/contact/Contact.ts

@@ -1,8 +1,9 @@
-import { PeerID } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { NodeID } from '../../helpers/nodeId'
 
 export class Contact {
+
     private peerDescriptor: PeerDescriptor
 
     constructor(peerDescriptor: PeerDescriptor) {
@@ -13,7 +14,7 @@ export class Contact {
         return this.peerDescriptor
     }
 
-    public getPeerId(): PeerID {
-        return peerIdFromPeerDescriptor(this.peerDescriptor)
+    public getNodeId(): NodeID {
+        return getNodeIdFromPeerDescriptor(this.peerDescriptor)
     }
 }

package/src/dht/contact/ContactList.ts

@@ -1,5 +1,5 @@
-import { PeerID, PeerIDKey } from '../../helpers/PeerID'
 import EventEmitter from 'eventemitter3'
+import { NodeID } from '../../helpers/nodeId'
 
 export class ContactState<C> {
     public contacted = false
@@ -16,28 +16,28 @@ export interface Events<C> {
     newContact: (newContact: C, closestContacts: C[]) => void
 }
 
-export class ContactList<C extends { getPeerId: () => PeerID }> extends EventEmitter<Events<C>> {
+export class ContactList<C extends { getNodeId: () => NodeID }> extends EventEmitter<Events<C>> {
 
-    protected contactsById: Map<PeerIDKey, ContactState<C>> = new Map()
+    protected contactsById: Map<NodeID, ContactState<C>> = new Map()
     // TODO move this to SortedContactList
-    protected contactIds: PeerID[] = []
-    protected ownId: PeerID
+    protected contactIds: NodeID[] = []
+    protected localNodeId: NodeID
     protected maxSize: number
     protected defaultContactQueryLimit
 
     constructor(
-        ownId: PeerID,
+        localNodeId: NodeID,
         maxSize: number,
         defaultContactQueryLimit = 20
     ) {
         super()
-        this.ownId = ownId
+        this.localNodeId = localNodeId
         this.maxSize = maxSize
         this.defaultContactQueryLimit = defaultContactQueryLimit
     }
 
-    public getContact(id: PeerID): ContactState<C> | undefined {
-        return this.contactsById.get(id.toKey())
+    public getContact(id: NodeID): ContactState<C> | undefined {
+        return this.contactsById.get(id)
     }
 
     public getSize(): number {

package/src/dht/contact/RandomContactList.ts

@@ -1,33 +1,33 @@
-import { PeerID } from '../../helpers/PeerID'
+import { NodeID, areEqualNodeIds } from '../../helpers/nodeId'
 import { ContactList, ContactState } from './ContactList'
 
-export class RandomContactList<C extends { getPeerId: () => PeerID }> extends ContactList<C> {
+export class RandomContactList<C extends { getNodeId: () => NodeID }> extends ContactList<C> {
 
     private randomness: number
 
     constructor(
-        ownId: PeerID,
+        localNodeId: NodeID,
         maxSize: number,
         randomness = 0.20,
         defaultContactQueryLimit?: number
     ) {
-        super(ownId, maxSize, defaultContactQueryLimit)
+        super(localNodeId, maxSize, defaultContactQueryLimit)
         this.randomness = randomness
     }
 
     addContact(contact: C): void {
-        if (this.ownId.equals(contact.getPeerId())) {
+        if (areEqualNodeIds(this.localNodeId, contact.getNodeId())) {
             return
         }
-        if (!this.contactsById.has(contact.getPeerId().toKey())) {
+        if (!this.contactsById.has(contact.getNodeId())) {
             const roll = Math.random()
             if (roll < this.randomness) {
                 if (this.getSize() === this.maxSize && this.getSize() > 0) {
                     const toRemove = this.contactIds[0]
                     this.removeContact(toRemove)
                 }
-                this.contactIds.push(contact.getPeerId())
-                this.contactsById.set(contact.getPeerId().toKey(), new ContactState(contact))
+                this.contactIds.push(contact.getNodeId())
+                this.contactsById.set(contact.getNodeId(), new ContactState(contact))
                 this.emit(
                     'newContact',
                     contact,
@@ -37,12 +37,12 @@ export class RandomContactList<C extends { getPeerId: () => PeerID }> extends Co
         }
     }
 
-    removeContact(id: PeerID): boolean {
-        if (this.contactsById.has(id.toKey())) {
-            const removed = this.contactsById.get(id.toKey())!.contact
-            const index = this.contactIds.findIndex((element) => element.equals(id))
+    removeContact(id: NodeID): boolean {
+        if (this.contactsById.has(id)) {
+            const removed = this.contactsById.get(id)!.contact
+            const index = this.contactIds.findIndex((nodeId) => areEqualNodeIds(nodeId, id))
             this.contactIds.splice(index, 1)
-            this.contactsById.delete(id.toKey())
+            this.contactsById.delete(id)
             this.emit('contactRemoved', removed, this.getContacts())
             return true
         }
@@ -52,7 +52,7 @@ export class RandomContactList<C extends { getPeerId: () => PeerID }> extends Co
     public getContacts(limit = this.defaultContactQueryLimit): C[] {
         const ret: C[] = []
         this.contactIds.forEach((contactId) => {
-            const contact = this.contactsById.get(contactId.toKey())
+            const contact = this.contactsById.get(contactId)
             if (contact) {
                 ret.push(contact.contact)
             }

package/src/dht/contact/RpcRemote.ts

@@ -1,9 +1,10 @@
+import type { ServiceInfo } from '@protobuf-ts/runtime-rpc'
+import { ClassType, ClientTransport, ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import { ConnectionType } from '../../connection/IConnection'
+import { expectedConnectionType } from '../../helpers/Connectivity'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
 import { ServiceID } from '../../types/ServiceID'
-import { ConnectionType } from '../../connection/IConnection'
-import { expectedConnectionType } from '../../helpers/Connectivity'
 
 // Should connect directly to the server, timeout can be low
 const WEBSOCKET_CLIENT_TIMEOUT = 5000
@@ -27,7 +28,7 @@ const getTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: P
     return WEBRTC_TIMEOUT
 }
 
-export abstract class RpcRemote<T> {
+export abstract class RpcRemote<T extends ServiceInfo & ClassType> {
 
     private readonly localPeerDescriptor: PeerDescriptor
     private readonly remotePeerDescriptor: PeerDescriptor
@@ -39,12 +40,14 @@ export abstract class RpcRemote<T> {
         localPeerDescriptor: PeerDescriptor,
         remotePeerDescriptor: PeerDescriptor,
         serviceId: ServiceID,
-        client: ProtoRpcClient<T>,
+        rpcCommunicator: RpcCommunicator,
+        // eslint-disable-next-line @typescript-eslint/prefer-function-type
+        clientClass: { new (clientTransport: ClientTransport): T },
         timeout?: number
     ) {
         this.localPeerDescriptor = localPeerDescriptor
         this.remotePeerDescriptor = remotePeerDescriptor
-        this.client = client
+        this.client = toProtoRpcClient(new clientClass(rpcCommunicator.getRpcClientTransport()))
         this.serviceId = serviceId
         this.timeout = timeout
     }
@@ -57,7 +60,7 @@ export abstract class RpcRemote<T> {
         return this.localPeerDescriptor
     }
 
-    getServiceId(): string {
+    getServiceId(): ServiceID {
         return this.serviceId
     }