@streamr/dht 102.0.0-beta.0 → 102.0.0-beta.2

package/src/dht/DhtNodeRpcLocal.ts

@@ -1,84 +0,0 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { Logger } from '@streamr/utils'
-import { DhtAddress, toDhtAddress, toNodeId } from '../identifiers'
-import { Empty } from '../../generated/google/protobuf/empty'
-import {
-    ClosestPeersRequest,
-    ClosestPeersResponse,
-    ClosestRingPeersRequest,
-    ClosestRingPeersResponse,
-    PeerDescriptor,
-    PingRequest,
-    PingResponse
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { IDhtNodeRpc } from '../../generated/packages/dht/protos/DhtRpc.server'
-import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
-import { RingContacts } from './contact/RingContactList'
-import { getClosestNodes } from './contact/getClosestNodes'
-import { RingIdRaw } from './contact/ringIdentifiers'
-
-interface DhtNodeRpcLocalOptions {
-    peerDiscoveryQueryBatchSize: number
-    getNeighbors: () => ReadonlyArray<PeerDescriptor>
-    getClosestRingContactsTo: (id: RingIdRaw, limit: number) => RingContacts
-    addContact: (contact: PeerDescriptor) => void
-    removeContact: (nodeId: DhtAddress) => void
-}
-
-const logger = new Logger(module)
-
-export class DhtNodeRpcLocal implements IDhtNodeRpc {
-
-    private readonly options: DhtNodeRpcLocalOptions
-
-    constructor(options: DhtNodeRpcLocalOptions) {
-        this.options = options
-    }
-
-    // TODO rename to getClosestNeighbors (breaking change)
-    async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
-        this.options.addContact((context as DhtCallContext).incomingSourceDescriptor!)
-        const peers = getClosestNodes(
-            toDhtAddress(request.nodeId), 
-            this.options.getNeighbors(),
-            { maxCount: this.options.peerDiscoveryQueryBatchSize }
-        )
-        const response = {
-            peers,
-            requestId: request.requestId
-        }
-        return response
-    }
-
-    // TODO rename to getClosestRingContacts (breaking change)
-    async getClosestRingPeers(request: ClosestRingPeersRequest, context: ServerCallContext): Promise<ClosestRingPeersResponse> {
-        this.options.addContact((context as DhtCallContext).incomingSourceDescriptor!)
-        const closestContacts = this.options.getClosestRingContactsTo(request.ringId as RingIdRaw, this.options.peerDiscoveryQueryBatchSize)
-        const response = {
-            leftPeers: closestContacts.left,
-            rightPeers: closestContacts.right,
-            requestId: request.requestId
-        }
-        return response
-    }
-
-    async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
-        logger.trace('received ping request: ' + toNodeId((context as DhtCallContext).incomingSourceDescriptor!))
-        setImmediate(() => {
-            this.options.addContact((context as DhtCallContext).incomingSourceDescriptor!)
-        })
-        const response: PingResponse = {
-            requestId: request.requestId
-        }
-        return response
-    }
-
-    async leaveNotice(context: ServerCallContext): Promise<Empty> {
-        // TODO check signature??
-        const sender = (context as DhtCallContext).incomingSourceDescriptor!
-        const senderNodeId = toNodeId(sender)
-        logger.trace('received leave notice: ' + senderNodeId)
-        this.options.removeContact(senderNodeId)
-        return {}
-    }
-}

package/src/dht/DhtNodeRpcRemote.ts

@@ -1,107 +0,0 @@
-import { RpcCommunicator } from '@streamr/proto-rpc'
-import { Logger } from '@streamr/utils'
-import { v4 } from 'uuid'
-import { DhtAddress, DhtAddressRaw, toNodeId, toDhtAddressRaw } from '../identifiers'
-import {
-    ClosestPeersRequest,
-    ClosestRingPeersRequest,
-    PeerDescriptor,
-    PingRequest
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { DhtNodeRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
-import { ServiceID } from '../types/ServiceID'
-import { RpcRemote } from './contact/RpcRemote'
-import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
-import { RingIdRaw } from './contact/ringIdentifiers'
-import { RingContacts } from './contact/RingContactList'
-
-const logger = new Logger(module)
-
-// Fields required by objects stored in the k-bucket library
-export interface KBucketContact {
-    id: DhtAddressRaw
-    vectorClock: number
-}
-
-export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBucketContact {
-
-    private static counter = 0
-    public vectorClock: number
-    public readonly id: DhtAddressRaw
-    private readonly serviceId: ServiceID
-
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        peerDescriptor: PeerDescriptor,
-        serviceId: ServiceID,
-        rpcCommunicator: RpcCommunicator<DhtCallContext>,
-        rpcRequestTimeout?: number
-    ) {
-        super(localPeerDescriptor, peerDescriptor, rpcCommunicator, DhtNodeRpcClient, rpcRequestTimeout)
-        this.id = this.getPeerDescriptor().nodeId
-        this.vectorClock = DhtNodeRpcRemote.counter++
-        this.serviceId = serviceId
-    }
-
-    async getClosestPeers(nodeId: DhtAddress): Promise<PeerDescriptor[]> {
-        logger.trace(`Requesting getClosestPeers on ${this.serviceId} from ${this.getNodeId()}`)
-        const request: ClosestPeersRequest = {
-            nodeId: toDhtAddressRaw(nodeId),
-            requestId: v4()
-        }
-        try {
-            const peers = await this.getClient().getClosestPeers(request, this.formDhtRpcOptions())
-            return peers.peers
-        } catch (err) {
-            logger.trace(`getClosestPeers error ${this.serviceId}`, { err })
-            throw err
-        }
-    }
-
-    // TODO rename to getClosestRingContacts (breaking change)
-    async getClosestRingPeers(ringIdRaw: RingIdRaw): Promise<RingContacts> {
-        logger.trace(`Requesting getClosestRingPeers on ${this.serviceId} from ${this.getNodeId()}`)
-        const request: ClosestRingPeersRequest = {
-            ringId: ringIdRaw,
-            requestId: v4()
-        }
-        try {
-            const response = await this.getClient().getClosestRingPeers(request, this.formDhtRpcOptions())
-            return { left: response.leftPeers ?? [], right: response.rightPeers ?? [] }
-        } catch (err) {
-            logger.trace(`getClosestRingPeers error ${this.serviceId}`, { err })
-            throw err
-        }
-    }
-
-    async ping(): Promise<boolean> {
-        logger.trace(`Requesting ping on ${this.serviceId} from ${this.getNodeId()}`)
-        const request: PingRequest = {
-            requestId: v4()
-        }
-        const options = this.formDhtRpcOptions()
-        try {
-            const pong = await this.getClient().ping(request, options)
-            if (pong.requestId === request.requestId) {
-                return true
-            }
-        } catch (err) {
-            logger.trace(`ping failed on ${this.serviceId} to ${this.getNodeId()}`, { err })
-        }
-        return false
-    }
-
-    leaveNotice(): void {
-        logger.trace(`Sending leaveNotice on ${this.serviceId} from ${this.getNodeId()}`)
-        const options = this.formDhtRpcOptions({
-            notification: true
-        })
-        this.getClient().leaveNotice({}, options).catch((e) => {
-            logger.trace('Failed to send leaveNotice' + e)
-        })
-    }
-
-    getNodeId(): DhtAddress {
-        return toNodeId(this.getPeerDescriptor())
-    }
-}

package/src/dht/ExternalApiRpcLocal.ts

@@ -1,58 +0,0 @@
-import { IExternalApiRpc } from '../../generated/packages/dht/protos/DhtRpc.server'
-import {
-    ExternalFetchDataRequest,
-    ExternalFetchDataResponse,
-    ExternalStoreDataRequest,
-    ExternalStoreDataResponse,
-    RecursiveOperation,
-    PeerDescriptor
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
-import { RecursiveOperationResult } from './recursive-operation/RecursiveOperationManager'
-import { Any } from '../../generated/google/protobuf/any'
-import { DhtAddress, toNodeId, toDhtAddress } from '../identifiers'
-
-interface ExternalApiRpcLocalOptions {
-    executeRecursiveOperation: (
-        targetId: DhtAddress,
-        operation: RecursiveOperation,
-        excludedPeer: DhtAddress
-    ) => Promise<RecursiveOperationResult>
-    storeDataToDht: (
-        key: DhtAddress,
-        data: Any,
-        creator: DhtAddress
-    ) => Promise<PeerDescriptor[]>
-}
-
-export class ExternalApiRpcLocal implements IExternalApiRpc {
-
-    private readonly options: ExternalApiRpcLocalOptions
-
-    constructor(options: ExternalApiRpcLocalOptions) {
-        this.options = options
-    }
-
-    async externalFetchData(request: ExternalFetchDataRequest, context: ServerCallContext): Promise<ExternalFetchDataResponse> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const result = await this.options.executeRecursiveOperation(
-            toDhtAddress(request.key),
-            RecursiveOperation.FETCH_DATA,
-            toNodeId(senderPeerDescriptor)
-        )
-        return ExternalFetchDataResponse.create({ entries: result.dataEntries ?? [] })
-    }
-
-    async externalStoreData(request: ExternalStoreDataRequest, context: ServerCallContext): Promise<ExternalStoreDataResponse> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const result = await this.options.storeDataToDht(
-            toDhtAddress(request.key),
-            request.data!,
-            toNodeId(senderPeerDescriptor)
-        )
-        return ExternalStoreDataResponse.create({
-            storers: result
-        })
-    }
-}

package/src/dht/ExternalApiRpcRemote.ts

@@ -1,41 +0,0 @@
-import { DhtAddress, toDhtAddressRaw } from '../identifiers'
-import { Any } from '../../generated/google/protobuf/any'
-import { DataEntry, ExternalFetchDataRequest, ExternalStoreDataRequest, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { ExternalApiRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
-import { RpcRemote } from './contact/RpcRemote'
-
-export class ExternalApiRpcRemote extends RpcRemote<ExternalApiRpcClient> {
-
-    async externalFetchData(key: DhtAddress): Promise<DataEntry[]> {
-        const request: ExternalFetchDataRequest = {
-            key: toDhtAddressRaw(key)
-        }
-        const options = this.formDhtRpcOptions({
-            // TODO use options option or named constant?
-            timeout: 10000
-        })
-        try {
-            const data = await this.getClient().externalFetchData(request, options)
-            return data.entries
-        } catch {
-            return []
-        }
-    }
-
-    async storeData(key: DhtAddress, data: Any): Promise<PeerDescriptor[]> {
-        const request: ExternalStoreDataRequest = {
-            key: toDhtAddressRaw(key),
-            data
-        }
-        const options = this.formDhtRpcOptions({
-            // TODO use options option or named constant?
-            timeout: 10000
-        })
-        try {
-            const response = await this.getClient().externalStoreData(request, options)
-            return response.storers
-        } catch {
-            return []
-        }
-    }
-}

package/src/dht/PeerManager.ts

@@ -1,303 +0,0 @@
-import {
-    Logger
-} from '@streamr/utils'
-import EventEmitter from 'eventemitter3'
-import KBucket from 'k-bucket'
-import { LockID } from '../connection/ConnectionLockStates'
-import { ConnectionLocker } from '../connection/ConnectionManager'
-import { DhtAddress, DhtAddressRaw, toNodeId, toDhtAddressRaw } from '../identifiers'
-import {
-    PeerDescriptor
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
-import { RandomContactList } from './contact/RandomContactList'
-import { RingContactList } from './contact/RingContactList'
-import { ReadonlySortedContactList, SortedContactList } from './contact/SortedContactList'
-import { RingIdRaw, getRingIdRawFromPeerDescriptor } from './contact/ringIdentifiers'
-
-const logger = new Logger(module)
-
-interface PeerManagerOptions {
-    numberOfNodesPerKBucket: number
-    maxContactCount: number
-    localNodeId: DhtAddress
-    localPeerDescriptor: PeerDescriptor
-    connectionLocker?: ConnectionLocker
-    lockId: LockID
-    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
-    hasConnection: (nodeId: DhtAddress) => boolean
-}
-
-// Returns all offline nodes, sets contacts as active if they are online
-const pingNodes = async (nodes: DhtNodeRpcRemote[], activeContacts: Set<DhtAddress>): Promise<PeerDescriptor[]> => {
-    const offlineNeighbors: PeerDescriptor[] = []
-    await Promise.allSettled(nodes.map(async (contact) => {
-        const isOnline = await contact.ping()
-        if (!isOnline) {
-            activeContacts.delete(contact.getNodeId())
-            offlineNeighbors.push(contact.getPeerDescriptor())
-        } else {
-            activeContacts.add(contact.getNodeId())
-        }
-    }))
-    return offlineNeighbors
-}
-
-export interface PeerManagerEvents {
-    nearbyContactAdded: (peerDescriptor: PeerDescriptor) => void
-    nearbyContactRemoved: (peerDescriptor: PeerDescriptor) => void
-    randomContactAdded: (peerDescriptor: PeerDescriptor) => void
-    randomContactRemoved: (peerDescriptor: PeerDescriptor) => void
-    ringContactAdded: (peerDescriptor: PeerDescriptor) => void
-    ringContactRemoved: (peerDescriptor: PeerDescriptor) => void
-    kBucketEmpty: () => void
-}
-
-export const getDistance = (nodeIdOrDataKeyRaw1: DhtAddressRaw, nodeIdOrDataKeyRaw2: DhtAddressRaw): number => {
-    return KBucket.distance(nodeIdOrDataKeyRaw1, nodeIdOrDataKeyRaw2)
-}
-
-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
-
-    private neighbors: KBucket<DhtNodeRpcRemote>
-    private nearbyContacts: SortedContactList<DhtNodeRpcRemote>
-    private activeContacts: Set<DhtAddress>
-    private ringContacts: RingContactList<DhtNodeRpcRemote>
-    private randomContacts: RandomContactList<DhtNodeRpcRemote>
-    private stopped: boolean = false
-    private readonly options: PeerManagerOptions
-
-    constructor(options: PeerManagerOptions) {
-        super()
-        this.options = options
-        this.neighbors = new KBucket<DhtNodeRpcRemote>({
-            localNodeId: toDhtAddressRaw(this.options.localNodeId),
-            numberOfNodesPerKBucket: this.options.numberOfNodesPerKBucket,
-            numberOfNodesToPing: this.options.numberOfNodesPerKBucket
-        })
-        this.ringContacts = new RingContactList<DhtNodeRpcRemote>(getRingIdRawFromPeerDescriptor(this.options.localPeerDescriptor))
-        this.ringContacts.on('contactAdded', (contact: DhtNodeRpcRemote) => {
-            this.emit('ringContactAdded', contact.getPeerDescriptor())
-        })
-        this.ringContacts.on('contactRemoved', (contact: DhtNodeRpcRemote) => {
-            this.emit('ringContactRemoved', contact.getPeerDescriptor())
-        })
-        this.neighbors.on('ping', (oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote) => this.onKBucketPing(oldContacts, newContact))
-        this.neighbors.on('removed', (contact: DhtNodeRpcRemote) => this.onKBucketRemoved(toNodeId(contact.getPeerDescriptor())))
-        this.neighbors.on('added', (contact: DhtNodeRpcRemote) => this.onKBucketAdded(contact))
-        this.neighbors.on('updated', () => {
-            // TODO: Update contact info to the connection manager and reconnect
-        })
-        this.nearbyContacts = new SortedContactList({
-            referenceId: this.options.localNodeId,
-            maxSize: this.options.maxContactCount,
-            allowToContainReferenceId: false
-        })
-        this.nearbyContacts.on('contactRemoved', (contact: DhtNodeRpcRemote) => {
-            if (this.stopped) {
-                return
-            }
-            this.emit('nearbyContactRemoved', contact.getPeerDescriptor())
-            this.randomContacts.addContact(this.options.createDhtNodeRpcRemote(contact.getPeerDescriptor()))
-        })
-        this.nearbyContacts.on('contactAdded', (contact: DhtNodeRpcRemote) =>
-            this.emit('nearbyContactAdded', contact.getPeerDescriptor())
-        )
-        this.activeContacts = new Set()
-        this.randomContacts = new RandomContactList(this.options.localNodeId, this.options.maxContactCount)
-        this.randomContacts.on('contactRemoved', (removedContact: DhtNodeRpcRemote) =>
-            this.emit('randomContactRemoved', removedContact.getPeerDescriptor())
-        )
-        this.randomContacts.on('contactAdded', (contactAdded: DhtNodeRpcRemote) =>
-            this.emit('randomContactAdded', contactAdded.getPeerDescriptor())
-        )
-    }
-
-    private onKBucketPing(oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote): void {
-        if (this.stopped) {
-            return
-        }
-        const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList({
-            referenceId: this.options.localNodeId,
-            allowToContainReferenceId: false
-        })
-        sortingList.addContacts(oldContacts)
-        const removableNodeId = sortingList.getFurthestContacts(1)[0].getNodeId()
-        this.options.connectionLocker?.weakUnlockConnection(removableNodeId, this.options.lockId)
-        this.neighbors.remove(toDhtAddressRaw(removableNodeId))
-        this.neighbors.add(newContact)
-    }
-
-    private onKBucketRemoved(nodeId: DhtAddress): void {
-        if (this.stopped) {
-            return
-        }
-        this.options.connectionLocker?.weakUnlockConnection(nodeId, this.options.lockId)
-        logger.trace(`Removed contact ${nodeId}`)
-        if (this.neighbors.count() === 0) {
-            this.emit('kBucketEmpty')
-        }
-    }
-
-    private onKBucketAdded(contact: DhtNodeRpcRemote): void {
-        if (this.stopped) {
-            return
-        }
-        if (contact.getNodeId() !== this.options.localNodeId) {
-            const peerDescriptor = contact.getPeerDescriptor()
-            const nodeId = toNodeId(peerDescriptor)
-            // Important to lock here, before the ping result is known
-            this.options.connectionLocker?.weakLockConnection(nodeId, this.options.lockId)
-            if (this.options.hasConnection(contact.getNodeId())) {
-                logger.trace(`Added new contact ${nodeId}`)
-            } else {    // open connection by pinging
-                logger.trace('starting ping ' + nodeId)
-                contact.ping().then((result) => {
-                    if (result) {
-                        logger.trace(`Added new contact ${nodeId}`)
-                    } else {
-                        logger.trace('ping failed ' + nodeId)
-                        this.options.connectionLocker?.weakUnlockConnection(nodeId, this.options.lockId)
-                        this.removeContact(nodeId)
-                        this.addNearbyContactToNeighbors()
-                    }
-                }).catch((_e) => {
-                    this.options.connectionLocker?.weakUnlockConnection(nodeId, this.options.lockId)
-                    this.removeContact(nodeId)
-                    this.addNearbyContactToNeighbors()
-                })
-            }
-        }
-    }
-
-    private addNearbyContactToNeighbors(): void {
-        if (this.stopped) {
-            return
-        }
-        const closest = this.getNearbyActiveContactNotInNeighbors()
-        if (closest) {
-            this.addContact(closest.getPeerDescriptor())
-        }
-    }
-
-    private getNearbyActiveContactNotInNeighbors(): DhtNodeRpcRemote | undefined {
-        for (const contactId of this.nearbyContacts.getContactIds()) {
-            if (!this.neighbors.get(toDhtAddressRaw(contactId)) && this.activeContacts.has(contactId)) {
-                return this.nearbyContacts.getContact(contactId)!
-            }
-        }
-        return undefined
-    }
-
-    removeContact(nodeId: DhtAddress): void {
-        if (this.stopped) {
-            return
-        }
-        logger.trace(`Removing contact ${nodeId}`)
-        this.ringContacts.removeContact(this.nearbyContacts.getContact(nodeId))
-        this.neighbors.remove(toDhtAddressRaw(nodeId))
-        this.nearbyContacts.removeContact(nodeId)
-        this.activeContacts.delete(nodeId)
-        this.randomContacts.removeContact(nodeId)
-    }
-
-    removeNeighbor(nodeId: DhtAddress): void {
-        this.neighbors.remove(toDhtAddressRaw(nodeId))
-    }
-
-    async pruneOfflineNodes(nodes: DhtNodeRpcRemote[]): Promise<void> {
-        logger.trace('Pruning offline nodes', { nodes: nodes.length })
-        const offlineNeighbors = await pingNodes(nodes, this.activeContacts)
-        offlineNeighbors.forEach((offlineNeighbor) => {
-            logger.trace('Removing offline node', { node: toNodeId(offlineNeighbor) })
-            this.removeContact(toNodeId(offlineNeighbor))
-        }) 
-    }
-
-    stop(): void {
-        this.stopped = true
-        this.neighbors.toArray().forEach((rpcRemote: DhtNodeRpcRemote) => {
-            rpcRemote.leaveNotice()
-            this.neighbors.remove(rpcRemote.id)
-        })
-        this.neighbors.removeAllListeners()
-        this.ringContacts.getAllContacts().forEach((rpcRemote) => {
-            rpcRemote.leaveNotice()
-            this.ringContacts.removeContact(rpcRemote)
-        })
-        this.nearbyContacts.stop()
-        this.randomContacts.stop()
-    }
-
-    getNearbyContacts(): ReadonlySortedContactList<DhtNodeRpcRemote> {
-        return this.nearbyContacts
-    }
-
-    getClosestRingContactsTo(
-        ringIdRaw: RingIdRaw,
-        limit?: number,
-        excludedIds?: Set<DhtAddress>
-    ): { left: DhtNodeRpcRemote[], right: DhtNodeRpcRemote[] } {
-        const closest = new RingContactList<DhtNodeRpcRemote>(ringIdRaw, excludedIds)
-        this.ringContacts.getAllContacts().map((contact) => closest.addContact(contact))
-        // TODO use options option or named constant?
-        return closest.getClosestContacts(limit ?? 8)
-    }
-    
-    getRandomContacts(): RandomContactList<DhtNodeRpcRemote> {
-        return this.randomContacts
-    }
-    
-    getRingContacts(): RingContactList<DhtNodeRpcRemote> {
-        return this.ringContacts
-    }
-
-    getNearbyContactCount(excludedNodeIds?: Set<DhtAddress>): number {
-        return this.nearbyContacts.getSize(excludedNodeIds)
-    }
-
-    getNeighborCount(): number {
-        return this.neighbors.count()
-    }
-
-    getNeighbors(): ReadonlyArray<DhtNodeRpcRemote> {
-        return this.neighbors.toArray()
-    }
-
-    setContactActive(nodeId: DhtAddress): void {
-        this.activeContacts.add(nodeId)
-    }
-
-    addContact(peerDescriptor: PeerDescriptor): void {
-        if (this.stopped) {
-            return
-        }
-        const nodeId = toNodeId(peerDescriptor)
-        if (nodeId !== this.options.localNodeId) {
-            logger.trace(`Adding new contact ${nodeId}`)
-            const remote = this.options.createDhtNodeRpcRemote(peerDescriptor)
-            const isInNeighbors = (this.neighbors.get(peerDescriptor.nodeId) !== null)
-            const isInNearbyContacts = (this.nearbyContacts.getContact(nodeId) !== undefined)
-            const isInRingContacts = this.ringContacts.getContact(peerDescriptor) !== undefined
-
-            if (isInNeighbors || isInNearbyContacts) {
-                this.randomContacts.addContact(remote)
-            }
-            if (!isInNeighbors) {
-                this.neighbors.add(remote)
-            }
-            if (!isInNearbyContacts) {
-                this.nearbyContacts.addContact(remote)
-            }
-            if (!isInRingContacts) {
-                this.ringContacts.addContact(remote)
-            }
-        }
-    }
-}

package/src/dht/contact/Contact.ts

@@ -1,19 +0,0 @@
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { DhtAddress, toNodeId } from '../../identifiers'
-
-export class Contact {
-
-    private peerDescriptor: PeerDescriptor
-
-    constructor(peerDescriptor: PeerDescriptor) {
-        this.peerDescriptor = peerDescriptor
-    }
-
-    public getPeerDescriptor(): PeerDescriptor {
-        return this.peerDescriptor
-    }
-
-    public getNodeId(): DhtAddress {
-        return toNodeId(this.peerDescriptor)
-    }
-}

package/src/dht/contact/ContactList.ts

@@ -1,43 +0,0 @@
-import EventEmitter from 'eventemitter3'
-import { DhtAddress } from '../../identifiers'
-
-export interface Events<C> {
-    contactRemoved: (removedContact: C) => void
-    contactAdded: (contactAdded: C) => void
-}
-
-export class ContactList<C extends { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {
-
-    protected contactsById: Map<DhtAddress, C> = new Map()
-    // TODO move this to SortedContactList
-    protected contactIds: DhtAddress[] = []
-    protected localNodeId: DhtAddress
-    protected maxSize: number
-
-    constructor(
-        localNodeId: DhtAddress,
-        maxSize: number
-    ) {
-        super()
-        this.localNodeId = localNodeId
-        this.maxSize = maxSize
-    }
-
-    public getContact(id: DhtAddress): C | undefined {
-        return this.contactsById.get(id)
-    }
-
-    public getSize(): number {
-        return this.contactIds.length
-    }
-
-    public clear(): void {
-        this.contactsById.clear()
-        this.contactIds = []
-    }
-
-    public stop(): void {
-        this.removeAllListeners()
-        this.clear()
-    }
-}