@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-testnet-one.1

package/src/dht/DhtNodeRpcLocal.ts

@@ -1,6 +1,5 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { Logger } from '@streamr/utils'
-import KBucket from 'k-bucket'
 import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { Empty } from '../proto/google/protobuf/empty'
 import {
@@ -13,12 +12,11 @@ import {
 } from '../proto/packages/dht/protos/DhtRpc'
 import { IDhtNodeRpc } from '../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
-import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
 
 interface DhtNodeRpcLocalConfig {
-    bucket: KBucket<DhtNodeRpcRemote>
     serviceId: string
     peerDiscoveryQueryBatchSize: number
+    getClosestPeersTo: (nodeId: Uint8Array, limit: number) => PeerDescriptor[]
     addNewContact: (contact: PeerDescriptor) => void
     removeContact: (contact: PeerDescriptor) => void
 }
@@ -36,17 +34,12 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
     async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
         this.config.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
         const response = {
-            peers: this.getClosestPeerDescriptors(request.kademliaId, this.config.peerDiscoveryQueryBatchSize),
+            peers: this.config.getClosestPeersTo(request.nodeId, this.config.peerDiscoveryQueryBatchSize),
             requestId: request.requestId
         }
         return response
     }
 
-    private getClosestPeerDescriptors(kademliaId: Uint8Array, limit: number): PeerDescriptor[] {
-        const closestPeers = this.config.bucket.closest(kademliaId, limit)
-        return closestPeers.map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
-    }
-
     async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
         logger.trace('received ping request: ' + getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
         setImmediate(() => {

package/src/dht/DhtNodeRpcRemote.ts

@@ -8,7 +8,7 @@ import {
 import { v4 } from 'uuid'
 import { Logger } from '@streamr/utils'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { Remote } from './contact/Remote'
+import { RpcRemote } from './contact/RpcRemote'
 import { PeerID } from '../helpers/PeerID'
 import { getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { ServiceID } from '../types/ServiceID'
@@ -21,7 +21,7 @@ export interface KBucketContact {
     vectorClock: number
 }
 
-export class DhtNodeRpcRemote extends Remote<IDhtNodeRpcClient> implements KBucketContact {
+export class DhtNodeRpcRemote extends RpcRemote<IDhtNodeRpcClient> implements KBucketContact {
 
     private static counter = 0
     public vectorClock: number
@@ -39,10 +39,10 @@ export class DhtNodeRpcRemote extends Remote<IDhtNodeRpcClient> implements KBuck
         this.vectorClock = DhtNodeRpcRemote.counter++
     }
 
-    async getClosestPeers(kademliaId: Uint8Array): Promise<PeerDescriptor[]> {
+    async getClosestPeers(nodeId: Uint8Array): Promise<PeerDescriptor[]> {
         logger.trace(`Requesting getClosestPeers on ${this.getServiceId()} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: ClosestPeersRequest = {
-            kademliaId,
+            nodeId,
             requestId: v4()
         }
         try {

package/src/dht/ExternalApiRpcLocal.ts

@@ -4,6 +4,7 @@ import {
     ExternalFindDataResponse,
     ExternalStoreDataRequest,
     ExternalStoreDataResponse,
+    FindAction,
     PeerDescriptor
 } from '../proto/packages/dht/protos/DhtRpc'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
@@ -12,8 +13,8 @@ import { FindResult } from './find/Finder'
 import { Any } from '../proto/google/protobuf/any'
 
 interface ExternalApiRpcLocalConfig {
-    startFind: (idToFind: Uint8Array, fetchData: boolean, excludedPeer: PeerDescriptor) => Promise<FindResult>
-    storeDataToDht: (key: Uint8Array, data: Any) => Promise<PeerDescriptor[]>
+    startFind: (idToFind: Uint8Array, action: FindAction, excludedPeer: PeerDescriptor) => Promise<FindResult>
+    storeDataToDht: (key: Uint8Array, data: Any, creator: PeerDescriptor) => Promise<PeerDescriptor[]>
 }
 
 export class ExternalApiRpcLocal implements IExternalApiRpc {
@@ -26,19 +27,13 @@ export class ExternalApiRpcLocal implements IExternalApiRpc {
 
     async externalFindData(findDataRequest: ExternalFindDataRequest, context: ServerCallContext): Promise<ExternalFindDataResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const result = await this.config.startFind(findDataRequest.kademliaId, true, senderPeerDescriptor)
-        if (result.dataEntries) {
-            return ExternalFindDataResponse.create({ dataEntries: result.dataEntries })
-        } else {
-            return ExternalFindDataResponse.create({ 
-                dataEntries: [],
-                error: 'Could not find data with the given key' 
-            })
-        }
+        const result = await this.config.startFind(findDataRequest.key, FindAction.FETCH_DATA, senderPeerDescriptor)
+        return ExternalFindDataResponse.create({ entries: result.dataEntries ?? [] })
     }
 
-    async externalStoreData(request: ExternalStoreDataRequest): Promise<ExternalStoreDataResponse> {
-        const result = await this.config.storeDataToDht(request.key, request.data!)
+    async externalStoreData(request: ExternalStoreDataRequest, context: ServerCallContext): Promise<ExternalStoreDataResponse> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const result = await this.config.storeDataToDht(request.key, request.data!, senderPeerDescriptor)
         return ExternalStoreDataResponse.create({
             storers: result
         })

package/src/dht/ExternalApiRpcRemote.ts

@@ -1,20 +1,20 @@
 import { Any } from '../proto/google/protobuf/any'
 import { DataEntry, ExternalStoreDataRequest, ExternalFindDataRequest, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { IExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
-import { Remote } from './contact/Remote'
+import { RpcRemote } from './contact/RpcRemote'
 
-export class ExternalApiRpcRemote extends Remote<IExternalApiRpcClient> {
+export class ExternalApiRpcRemote extends RpcRemote<IExternalApiRpcClient> {
 
-    async externalFindData(idToFind: Uint8Array): Promise<DataEntry[]> {
+    async externalFindData(key: Uint8Array): Promise<DataEntry[]> {
         const request: ExternalFindDataRequest = {
-            kademliaId: idToFind
+            key
         }
         const options = this.formDhtRpcOptions({
             timeout: 10000
         })
         try {
             const data = await this.getClient().externalFindData(request, options)
-            return data.dataEntries
+            return data.entries
         } catch (err) {
             return []
         }

package/src/dht/PeerManager.ts

@@ -0,0 +1,330 @@
+import {
+    Logger
+} from '@streamr/utils'
+import KBucket from 'k-bucket'
+import { PeerID, PeerIDKey } from '../helpers/PeerID'
+import {
+    getNodeIdFromPeerDescriptor,
+    keyFromPeerDescriptor,
+    peerIdFromPeerDescriptor
+} from '../helpers/peerIdFromPeerDescriptor'
+import {
+    PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
+import { RandomContactList } from './contact/RandomContactList'
+import { SortedContactList } from './contact/SortedContactList'
+import { ConnectionManager } from '../connection/ConnectionManager'
+import EventEmitter from 'eventemitter3'
+
+const logger = new Logger(module)
+
+interface PeerManagerConfig {
+    numberOfNodesPerKBucket: number
+    maxContactListSize: number
+    peerDiscoveryQueryBatchSize: number
+    ownPeerId: PeerID
+    connectionManager: ConnectionManager
+    isLayer0: boolean
+    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
+}
+
+export interface PeerManagerEvents {
+    newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    newRandomContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    kBucketEmpty: () => void
+}
+
+export const getDistance = (peerId1: Uint8Array, peerId2: Uint8Array): number => {
+    return KBucket.distance(peerId1, peerId2)
+}
+
+export class PeerManager extends EventEmitter<PeerManagerEvents> {
+
+    // Glossary: 
+    // * 'neighbors' are the nodes that are our neighbors according to 
+    //   the protocol of the layer we are in
+    // * 'connections' are the nodes that are connected to this node on Layer0
+    // * 'contacts' are all non-unresponsive nodes that we know about
+
+    // The kademlia k-bucket
+    private bucket?: KBucket<DhtNodeRpcRemote>
+    // Nodes that are connected to this node on Layer0
+    public readonly connections: Map<PeerIDKey, DhtNodeRpcRemote> = new Map()
+    // All nodes that we know about
+    private contacts?: SortedContactList<DhtNodeRpcRemote>
+    private randomPeers?: RandomContactList<DhtNodeRpcRemote>
+    private readonly config: PeerManagerConfig
+    private stopped: boolean = false
+
+    constructor(config: PeerManagerConfig) {
+        super()
+        this.config = config
+        this.initKBuckets()
+    }
+
+    private initKBuckets() {
+        this.bucket = new KBucket<DhtNodeRpcRemote>({
+            localNodeId: this.config.ownPeerId.value,
+            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))
+        this.bucket.on('updated', () => {
+            // TODO: Update contact info to the connection manager and reconnect
+        })
+        this.contacts = new SortedContactList({
+            referenceId: this.config.ownPeerId, 
+            maxSize: this.config.maxContactListSize,
+            allowToContainReferenceId: false,
+            emitEvents: true
+        })
+        this.contacts.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) => {
+            if (this.stopped) {
+                return
+            }
+            this.emit('contactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.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.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+            this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        )
+        this.randomPeers.on('newContact', (newContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+            this.emit('newRandomContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        )
+    }
+
+    private onKBucketPing(oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote): void {
+        if (this.stopped) {
+            return
+        }
+        const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList({
+            referenceId: this.config.ownPeerId, 
+            maxSize: 100,  // TODO use config option or named constant?
+            allowToContainReferenceId: false,
+            emitEvents: false
+        })
+        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)
+    }
+
+    private onKBucketRemoved(contact: DhtNodeRpcRemote): void {
+        if (this.stopped) {
+            return
+        }
+        this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
+        logger.trace(`Removed contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+        if (this.bucket!.count() === 0) {
+            this.emit('kBucketEmpty')
+        }
+    }
+
+    private onKBucketAdded(contact: DhtNodeRpcRemote): void {
+        if (this.stopped) {
+            return
+        }
+        if (!contact.getPeerId().equals(this.config.ownPeerId)) {
+            // Important to lock here, before the ping result is known
+            this.config.connectionManager?.weakLockConnection(contact.getPeerDescriptor())
+            if (this.connections.has(contact.getPeerId().toKey())) {
+                logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+            } else {    // open connection by pinging
+                logger.trace('starting ping ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
+                contact.ping().then((result) => {
+                    if (result) {
+                        logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+                    } else {
+                        logger.trace('ping failed ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
+                        this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
+                        this.removeContact(contact.getPeerDescriptor())
+                        this.addClosestContactToBucket()
+                    }
+                    return
+                }).catch((_e) => {
+                    this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
+                    this.removeContact(contact.getPeerDescriptor())
+                    this.addClosestContactToBucket()
+                })
+            }
+        }
+    }
+
+    private addClosestContactToBucket(): void {
+        if (this.stopped) {
+            return
+        }
+        const closest = this.getClosestActiveContactNotInBucket()
+        if (closest) {
+            this.handleNewPeers([closest.getPeerDescriptor()])
+        }
+    }
+
+    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
+            }
+        }
+        return undefined
+    }
+
+    handleConnected(peerDescriptor: PeerDescriptor): void {
+        if (PeerID.fromValue(peerDescriptor.nodeId).equals(this.config.ownPeerId)) {
+            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)
+            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')
+        }
+        logger.trace('connected: ' + getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + this.connections.size)
+    }
+
+    handleDisconnected(peerDescriptor: PeerDescriptor, gracefulLeave: boolean): void {
+        logger.trace('disconnected: ' + getNodeIdFromPeerDescriptor(peerDescriptor))
+        this.connections.delete(keyFromPeerDescriptor(peerDescriptor))
+        if (this.config.isLayer0) {
+            this.bucket!.remove(peerDescriptor.nodeId)
+            if (gracefulLeave === true) {
+                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+                this.removeContact(peerDescriptor)
+            } else {
+                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+            }
+        }
+    }
+
+    handlePeerLeaving(peerDescriptor: PeerDescriptor): void {
+        this.removeContact(peerDescriptor)
+    }
+
+    private removeContact(contact: PeerDescriptor): void {
+        if (this.stopped) {
+            return
+        }
+        logger.trace(`Removing contact ${getNodeIdFromPeerDescriptor(contact)}`)
+        const peerId = peerIdFromPeerDescriptor(contact)
+        this.bucket!.remove(peerId.value)
+        this.contacts!.removeContact(peerId)
+        this.randomPeers!.removeContact(peerId)
+    }
+
+    stop(): void {
+        this.stopped = true
+        this.bucket!.toArray().forEach((rpcRemote: DhtNodeRpcRemote) => {
+            rpcRemote.leaveNotice()
+            this.bucket!.remove(rpcRemote.id)
+        })
+        this.bucket!.removeAllListeners()
+        this.contacts!.stop()
+        this.randomPeers!.stop()
+        this.connections.clear()
+    }
+
+    getClosestNeighborsTo(kademliaId: Uint8Array, limit?: number, excludeSet?: Set<PeerIDKey>): DhtNodeRpcRemote[] {
+        const closest = new SortedContactList<DhtNodeRpcRemote>({
+            referenceId: PeerID.fromValue(kademliaId),
+            allowToContainReferenceId: true,
+            emitEvents: false
+        }) 
+        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())
+            } 
+        })
+    }
+
+    // TODO reduce copy-paste?
+    getClosestContactsTo(kademliaId: Uint8Array, limit?: number, excludeSet?: Set<PeerIDKey>): DhtNodeRpcRemote[] {
+        const closest = new SortedContactList<DhtNodeRpcRemote>({
+            referenceId: PeerID.fromValue(kademliaId),
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
+        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())
+            } 
+        })
+    }
+
+    getNumberOfContacts(excludeSet?: Set<PeerIDKey>): number {
+        return this.contacts!.getAllContacts().filter((contact) => {
+            if (!excludeSet) {
+                return true
+            } else {
+                return !excludeSet.has(contact.getPeerId().toKey())
+            } 
+        }).length
+    }
+
+    getNumberOfConnections(): number {
+        return this.connections.size
+    }
+
+    getNumberOfNeighbors(): number {
+        return this.bucket!.count()
+    }
+
+    getNeighbors(): PeerDescriptor[] {
+        return this.bucket!.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
+    }
+
+    handlePeerActive(peerId: PeerID): void {
+        this.contacts!.setActive(peerId)
+    }
+
+    handlePeerUnresponsive(peerId: PeerID): void {
+        this.bucket!.remove(peerId.value)
+        this.contacts!.removeContact(peerId)
+    }
+
+    handleNewPeers(peerDescriptors: PeerDescriptor[], setActive?: boolean): void { 
+        if (this.stopped) {
+            return
+        }
+        peerDescriptors.forEach((contact) => {
+            const peerId = peerIdFromPeerDescriptor(contact)
+            if (!peerId.equals(this.config.ownPeerId)) {
+                logger.trace(`Adding new contact ${getNodeIdFromPeerDescriptor(contact)}`)
+                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)
+                }
+                if (!isInBucket) {
+                    this.bucket!.add(remote)
+                } 
+                if (!isInNeighborList) {
+                    this.contacts!.addContact(remote)
+                } 
+                if (setActive) {
+                    this.contacts!.setActive(peerId)
+                }
+            }
+        })
+    }
+}

package/src/dht/contact/ContactList.ts

@@ -19,6 +19,7 @@ export interface Events<C> {
 export class ContactList<C extends { getPeerId: () => PeerID }> extends EventEmitter<Events<C>> {
 
     protected contactsById: Map<PeerIDKey, ContactState<C>> = new Map()
+    // TODO move this to SortedContactList
     protected contactIds: PeerID[] = []
     protected ownId: PeerID
     protected maxSize: number
@@ -35,8 +36,8 @@ export class ContactList<C extends { getPeerId: () => PeerID }> extends EventEmi
         this.defaultContactQueryLimit = defaultContactQueryLimit
     }
 
-    public getContact(id: PeerID): ContactState<C> {
-        return this.contactsById.get(id.toKey())!
+    public getContact(id: PeerID): ContactState<C> | undefined {
+        return this.contactsById.get(id.toKey())
     }
 
     public getSize(): number {

package/src/dht/contact/{Remote.ts → RpcRemote.ts}

@@ -15,7 +15,7 @@ const WEBRTC_TIMEOUT = 15000
 // default timeout for existing connections
 export const EXISTING_CONNECTION_TIMEOUT = 5000
 
-const getRpcTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): number => {
+const getTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): number => {
     const connectionType = expectedConnectionType(localPeerDescriptor, remotePeerDescriptor)
     if (connectionType === ConnectionType.WEBSOCKET_CLIENT) {
         return WEBSOCKET_CLIENT_TIMEOUT
@@ -27,25 +27,26 @@ const getRpcTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor
     return WEBRTC_TIMEOUT
 }
 
-export abstract class Remote<T> {
+export abstract class RpcRemote<T> {
 
     private readonly localPeerDescriptor: PeerDescriptor
     private readonly remotePeerDescriptor: PeerDescriptor
     private readonly serviceId: ServiceID
     private readonly client: ProtoRpcClient<T>
-    private readonly rpcTimeout?: number
+    private readonly timeout?: number
+
     constructor(
         localPeerDescriptor: PeerDescriptor,
         remotePeerDescriptor: PeerDescriptor,
         serviceId: ServiceID,
         client: ProtoRpcClient<T>,
-        rpcTimeout?: number
+        timeout?: number
     ) {
         this.localPeerDescriptor = localPeerDescriptor
         this.remotePeerDescriptor = remotePeerDescriptor
         this.client = client
         this.serviceId = serviceId
-        this.rpcTimeout = rpcTimeout
+        this.timeout = timeout
     }
 
     getPeerDescriptor(): PeerDescriptor {
@@ -68,7 +69,7 @@ export abstract class Remote<T> {
         return {
             sourceDescriptor: this.localPeerDescriptor,
             targetDescriptor: this.remotePeerDescriptor,
-            timeout: this.rpcTimeout ?? getRpcTimeout(this.localPeerDescriptor, this.remotePeerDescriptor),
+            timeout: this.timeout ?? getTimeout(this.localPeerDescriptor, this.remotePeerDescriptor),
             ...opts
         }
     }