@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.7

package/src/dht/routing/DuplicateDetector.ts

@@ -1,6 +1,4 @@
-import { Message } from '../../proto/packages/dht/protos/DhtRpc'
-
-type QueueEntry = [timeStamp: number, value: string, senderId: string, message?: Message]
+type QueueEntry = [timestamp: number, value: string]
 
 export class DuplicateDetector {
 
@@ -17,13 +15,9 @@ export class DuplicateDetector {
         this.maxAge = maxAgeInSeconds * 1000
     }
 
-    public add(value: string, senderId: string, message?: Message): void {
+    public add(value: string): void {
         this.values.add(value)
-        if (message) {
-            this.queue.push([Date.now(), value, senderId, message])
-        } else {
-            this.queue.push([Date.now(), value, senderId])
-        }
+        this.queue.push([Date.now(), value])
         this.cleanUp()
     }
 
@@ -49,5 +43,4 @@ export class DuplicateDetector {
         this.values.clear()
         this.queue = []
     }
-
 }

package/src/dht/routing/RemoteRouter.ts

@@ -1,7 +1,7 @@
 import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { v4 } from 'uuid'
 import {
-    isSamePeerDescriptor,
+    areEqualPeerDescriptors,
     keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
@@ -30,7 +30,7 @@ export class RemoteRouter extends Remote<IRoutingServiceClient> {
             const ack = await this.getClient().routeMessage(message, options)
             // Success signal if sent to destination and error includes duplicate
             if (
-                isSamePeerDescriptor(params.destinationPeer!, this.getPeerDescriptor())
+                areEqualPeerDescriptors(params.destinationPeer!, this.getPeerDescriptor())
                 && ack.error.includes('duplicate')
             ) {
                 return true

package/src/dht/routing/Router.ts

@@ -1,13 +1,12 @@
 import { Message, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { RoutingMode, RoutingSession, RoutingSessionEvents } from './RoutingSession'
 import { Logger, executeSafePromise, raceEvents3, withTimeout } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { PeerIDKey } from '../../helpers/PeerID'
 import { DuplicateDetector } from './DuplicateDetector'
 import { ConnectionManager } from '../../connection/ConnectionManager'
-import { DhtPeer } from '../DhtPeer'
+import { RemoteDhtNode } from '../RemoteDhtNode'
 import { v4 } from 'uuid'
 import { IRoutingService } from '../../proto/packages/dht/protos/DhtRpc.server'
 
@@ -29,8 +28,7 @@ export enum RoutingErrors {
 export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
     ownPeerDescriptor: PeerDescriptor
-    ownPeerId: PeerID
-    connections: Map<PeerIDKey, DhtPeer>
+    connections: Map<PeerIDKey, RemoteDhtNode>
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     serviceId: string
     connectionManager?: ConnectionManager
@@ -44,8 +42,8 @@ interface ForwardingTableEntry {
 interface IRouterFunc {
     doRouteMessage(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedPeer?: PeerDescriptor): RouteMessageAck
     send(msg: Message, reachableThrough: PeerDescriptor[]): Promise<void>
-    checkDuplicate(messageId: string): boolean
-    addToDuplicateDetector(messageId: string, senderId: string, message?: Message): void
+    isMostLikelyDuplicate(requestId: string): boolean
+    addToDuplicateDetector(requestId: string): void
     addRoutingSession(session: RoutingSession): void
     removeRoutingSession(sessionId: string): void
     stop(): void
@@ -58,28 +56,26 @@ const logger = new Logger(module)
 export class Router implements IRouter {
     private readonly rpcCommunicator: RoutingRpcCommunicator
     private readonly ownPeerDescriptor: PeerDescriptor
-    private readonly ownPeerId: PeerID
-    private readonly connections: Map<PeerIDKey, DhtPeer>
+    private readonly connections: Map<PeerIDKey, RemoteDhtNode>
     private readonly addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     private readonly serviceId: string
     private readonly connectionManager?: ConnectionManager
     private readonly forwardingTable: Map<string, ForwardingTableEntry> = new Map()
     private ongoingRoutingSessions: Map<string, RoutingSession> = new Map()
-    private readonly routerDuplicateDetector: DuplicateDetector = new DuplicateDetector(100000, 100)
+    private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(100000, 100)
     private stopped = false
 
     constructor(config: RouterConfig) {
         this.rpcCommunicator = config.rpcCommunicator
         this.ownPeerDescriptor = config.ownPeerDescriptor
-        this.ownPeerId = config.ownPeerId
         this.connections = config.connections
         this.addContact = config.addContact
         this.serviceId = config.serviceId
         this.connectionManager = config.connectionManager
         this.rpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'forwardMessage',
-            (forwardMessage: RouteMessageWrapper, context) => this.forwardMessage(forwardMessage, context))
+            (forwardMessage: RouteMessageWrapper) => this.forwardMessage(forwardMessage))
         this.rpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'routeMessage',
-            (routedMessage: RouteMessageWrapper, context) => this.routeMessage(routedMessage, context))
+            (routedMessage: RouteMessageWrapper) => this.routeMessage(routedMessage))
     }
 
     public async send(msg: Message, reachableThrough: PeerDescriptor[]): Promise<void> {
@@ -114,8 +110,8 @@ export class Router implements IRouter {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, RoutingErrors.STOPPED)
         }
-        logger.trace(`Peer ${this.ownPeerId.value} routing message ${routedMessage.requestId} 
-            from ${routedMessage.sourcePeer?.kademliaId} to ${routedMessage.destinationPeer?.kademliaId}`)
+        logger.trace(`Routing message ${routedMessage.requestId} from ${keyFromPeerDescriptor(routedMessage.sourcePeer!)} `
+            + `to ${keyFromPeerDescriptor(routedMessage.destinationPeer!)}`)
         routedMessage.routingPath.push(this.ownPeerDescriptor)
         const session = this.createRoutingSession(routedMessage, mode, excludedPeer)
         this.addRoutingSession(session)
@@ -141,7 +137,7 @@ export class Router implements IRouter {
             })
             session.start()
         } catch (e) {
-            if (peerIdFromPeerDescriptor(routedMessage.sourcePeer!).equals(this.ownPeerId)) {
+            if (areEqualPeerDescriptors(routedMessage.sourcePeer!, this.ownPeerDescriptor)) {
                 logger.warn(
                     `Failed to send (routeMessage: ${this.serviceId}) to ${keyFromPeerDescriptor(routedMessage.destinationPeer!)}: ${e}`
                 )
@@ -162,19 +158,19 @@ export class Router implements IRouter {
             this.ownPeerDescriptor,
             routedMessage,
             this.connections,
-            this.ownPeerId.equals(peerIdFromPeerDescriptor(routedMessage.sourcePeer!)) ? 2 : 1,
+            areEqualPeerDescriptors(this.ownPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
             mode,
             undefined,
             excludedPeers
         )
     }
 
-    public checkDuplicate(messageId: string): boolean {
-        return this.routerDuplicateDetector.isMostLikelyDuplicate(messageId)
+    public isMostLikelyDuplicate(requestId: string): boolean {
+        return this.duplicateRequestDetector.isMostLikelyDuplicate(requestId)
     }
 
-    public addToDuplicateDetector(messageId: string, senderId: string, message?: Message): void {
-        this.routerDuplicateDetector.add(messageId, senderId, message)
+    public addToDuplicateDetector(requestId: string): void {
+        this.duplicateRequestDetector.add(requestId)
     }
 
     public addRoutingSession(session: RoutingSession): void {
@@ -195,23 +191,23 @@ export class Router implements IRouter {
             clearTimeout(entry.timeout)
         })
         this.forwardingTable.clear()
-        this.routerDuplicateDetector.clear()
+        this.duplicateRequestDetector.clear()
     }
     
     // IRoutingService method
-    async routeMessage(routedMessage: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+    async routeMessage(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, 'routeMessage() service is not running')
-        } else if (this.routerDuplicateDetector.isMostLikelyDuplicate(routedMessage.requestId)) {
-            logger.trace(`Peer ${this.ownPeerId?.value} routing message ${routedMessage.requestId} 
-                from ${routedMessage.sourcePeer!.kademliaId} to ${routedMessage.destinationPeer!.kademliaId} is likely a duplicate`)
+        } else if (this.duplicateRequestDetector.isMostLikelyDuplicate(routedMessage.requestId)) {
+            logger.trace(`Routing message ${routedMessage.requestId} from ${keyFromPeerDescriptor(routedMessage.sourcePeer!)} `
+                + `to ${keyFromPeerDescriptor(routedMessage.destinationPeer!)} is likely a duplicate`)
             return createRouteMessageAck(routedMessage, 'message given to routeMessage() service is likely a duplicate')
         }
         logger.trace(`Processing received routeMessage ${routedMessage.requestId}`)
         this.addContact(routedMessage.sourcePeer!, true)
-        this.addToDuplicateDetector(routedMessage.requestId, keyFromPeerDescriptor(routedMessage.sourcePeer!))
-        if (this.ownPeerId.equals(peerIdFromPeerDescriptor(routedMessage.destinationPeer!))) {
-            logger.trace(`${this.ownPeerDescriptor.nodeName} routing message targeted to self ${routedMessage.requestId}`)
+        this.addToDuplicateDetector(routedMessage.requestId)
+        if (areEqualPeerDescriptors(this.ownPeerDescriptor, routedMessage.destinationPeer!)) {
+            logger.trace(`routing message targeted to self ${routedMessage.requestId}`)
             this.setForwardingEntries(routedMessage)
             this.connectionManager?.handleMessage(routedMessage.message!)
             return createRouteMessageAck(routedMessage)
@@ -222,7 +218,7 @@ export class Router implements IRouter {
 
     private setForwardingEntries(routedMessage: RouteMessageWrapper): void {
         const reachableThroughWithoutSelf = routedMessage.reachableThrough.filter((peer) => {
-            return !peerIdFromPeerDescriptor(peer).equals(this.ownPeerId)
+            return !areEqualPeerDescriptors(peer, this.ownPeerDescriptor)
         })
         
         if (reachableThroughWithoutSelf.length > 0) {
@@ -243,18 +239,18 @@ export class Router implements IRouter {
     }
 
     // IRoutingService method
-    async forwardMessage(forwardMessage: RouteMessageWrapper, _context: ServerCallContext): Promise<RouteMessageAck> {
+    async forwardMessage(forwardMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.stopped) {
             return createRouteMessageAck(forwardMessage, 'forwardMessage() service is not running')
-        } else if (this.routerDuplicateDetector.isMostLikelyDuplicate(forwardMessage.requestId)) {
-            logger.trace(`Peer ${this.ownPeerId.value} forwarding message ${forwardMessage.requestId} 
-        from ${forwardMessage.sourcePeer?.kademliaId} to ${forwardMessage.destinationPeer?.kademliaId} is likely a duplicate`)
+        } else if (this.duplicateRequestDetector.isMostLikelyDuplicate(forwardMessage.requestId)) {
+            logger.trace(`Forwarding message ${forwardMessage.requestId} from ${keyFromPeerDescriptor(forwardMessage.sourcePeer!)} `
+                + `to ${keyFromPeerDescriptor(forwardMessage.destinationPeer!)} is likely a duplicate`)
             return createRouteMessageAck(forwardMessage, 'message given to forwardMessage() service is likely a duplicate')
         }
         logger.trace(`Processing received forward routeMessage ${forwardMessage.requestId}`)
         this.addContact(forwardMessage.sourcePeer!, true)
-        this.addToDuplicateDetector(forwardMessage.requestId, keyFromPeerDescriptor(forwardMessage.sourcePeer!))
-        if (this.ownPeerId.equals(peerIdFromPeerDescriptor(forwardMessage.destinationPeer!))) {
+        this.addToDuplicateDetector(forwardMessage.requestId)
+        if (areEqualPeerDescriptors(this.ownPeerDescriptor, forwardMessage.destinationPeer!)) {
             return this.forwardToDestination(forwardMessage)
         } else {
             return this.doRouteMessage(forwardMessage, RoutingMode.FORWARD)
@@ -262,9 +258,9 @@ export class Router implements IRouter {
     }
 
     private forwardToDestination(routedMessage: RouteMessageWrapper): RouteMessageAck {
-        logger.trace(`Peer ${this.ownPeerId.value} forwarding found message targeted to self ${routedMessage.requestId}`)
+        logger.trace(`Forwarding found message targeted to self ${routedMessage.requestId}`)
         const forwardedMessage = routedMessage.message!
-        if (this.ownPeerId.equals(peerIdFromPeerDescriptor(forwardedMessage.targetDescriptor!))) {
+        if (areEqualPeerDescriptors(this.ownPeerDescriptor, forwardedMessage.targetDescriptor!)) {
             this.connectionManager?.handleMessage(forwardedMessage)
             return createRouteMessageAck(routedMessage)
         }

package/src/dht/routing/RoutingSession.ts

@@ -1,11 +1,11 @@
-import { PeerDescriptor } from '../../exports'
-import { DhtPeer } from '../DhtPeer'
+import { RemoteDhtNode } from '../RemoteDhtNode'
 import { SortedContactList } from '../contact/SortedContactList'
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
-import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { RemoteRouter } from './RemoteRouter'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { RoutingServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
@@ -20,7 +20,7 @@ class RemoteContact extends Contact {
 
     private router: RemoteRouter
 
-    constructor(peer: DhtPeer, ownPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
+    constructor(peer: RemoteDhtNode, ownPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
         super(peer.getPeerDescriptor())
         this.router = new RemoteRouter(
             ownPeerDescriptor,
@@ -58,7 +58,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
     private contactList: SortedContactList<RemoteContact>
     private readonly ownPeerDescriptor: PeerDescriptor
     private readonly messageToRoute: RouteMessageWrapper
-    private connections: Map<PeerIDKey, DhtPeer>
+    private connections: Map<PeerIDKey, RemoteDhtNode>
     private readonly parallelism: number
     private failedHopCounter = 0
     private successfulHopCounter = 0
@@ -69,7 +69,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         rpcCommunicator: RoutingRpcCommunicator,
         ownPeerDescriptor: PeerDescriptor,
         messageToRoute: RouteMessageWrapper,
-        connections: Map<PeerIDKey, DhtPeer>,
+        connections: Map<PeerIDKey, RemoteDhtNode>,
         parallelism: number,
         mode: RoutingMode = RoutingMode.ROUTE,
         destinationId?: Uint8Array,
@@ -122,7 +122,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
     }
 
-    private onRequestSucceeded = (_peerId: PeerID) => {
+    private onRequestSucceeded = () => {
         logger.trace('onRequestSucceeded() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return
@@ -187,14 +187,14 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         while ((this.ongoingRequests.size) < this.parallelism && (uncontacted.length > 0) && !this.stopped) {
             const nextPeer = uncontacted.shift()
             // eslint-disable-next-line max-len
-            logger.trace(`Sending routeMessage request from ${this.ownPeerDescriptor.kademliaId} to contact: ${nextPeer!.getPeerId()} (sessionId=${this.sessionId})`)
+            logger.trace(`Sending routeMessage request to contact: ${keyFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
             this.contactList.setContacted(nextPeer!.getPeerId())
             this.ongoingRequests.add(nextPeer!.getPeerId().toKey())
             setImmediate(async () => {
                 try {
                     const succeeded = await this.sendRouteMessageRequest(nextPeer!)
                     if (succeeded) {
-                        this.onRequestSucceeded(nextPeer!.getPeerId())
+                        this.onRequestSucceeded()
                     } else {
                         this.onRequestFailed(nextPeer!.getPeerId())
                     }

package/src/dht/store/DataStore.ts

@@ -10,7 +10,7 @@ import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { StoreServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { IRecursiveFinder } from '../find/RecursiveFinder'
-import { isSamePeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
 import { IStoreService } from '../../proto/packages/dht/protos/DhtRpc.server'
@@ -20,7 +20,7 @@ import EventEmitter from 'eventemitter3'
 import { Events } from '../DhtNode'
 import { SortedContactList } from '../contact/SortedContactList'
 import { Contact } from '../contact/Contact'
-import { DhtPeer } from '../DhtPeer'
+import { RemoteDhtNode } from '../RemoteDhtNode'
 
 interface DataStoreConfig {
     rpcCommunicator: RoutingRpcCommunicator
@@ -32,7 +32,7 @@ interface DataStoreConfig {
     highestTtl: number
     numberOfCopies: number
     dhtNodeEmitter: EventEmitter<Events>
-    getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtPeer[]
+    getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
 }
 
 const logger = new Logger(module)
@@ -48,7 +48,7 @@ export class DataStore implements IStoreService {
     private readonly highestTtl: number
     private readonly numberOfCopies: number
     private readonly dhtNodeEmitter: EventEmitter<Events>
-    private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtPeer[]
+    private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
 
     constructor(config: DataStoreConfig) {
         this.rpcCommunicator = config.rpcCommunicator
@@ -68,7 +68,7 @@ export class DataStore implements IStoreService {
         this.rpcCommunicator.registerRpcMethod(DeleteDataRequest, DeleteDataResponse, 'deleteData',
             (request: DeleteDataRequest, context: ServerCallContext) => this.deleteData(request, context))
 
-        this.dhtNodeEmitter.on('newContact', (peerDescriptor: PeerDescriptor, _closestPeers: PeerDescriptor[]) => {
+        this.dhtNodeEmitter.on('newContact', (peerDescriptor: PeerDescriptor) => {
             this.localDataStore.getStore().forEach((dataMap, _dataKey) => {
                 dataMap.forEach((dataEntry) => {
                     if (this.shouldMigrateDataToNewNode(dataEntry.dataEntry, peerDescriptor)) {
@@ -151,7 +151,7 @@ export class DataStore implements IStoreService {
         const ttl = this.highestTtl // ToDo: make TTL decrease according to some nice curve
         const storerTime = Timestamp.now()
         for (let i = 0; i < closestNodes.length && successfulNodes.length < this.numberOfCopies; i++) {
-            if (isSamePeerDescriptor(this.ownPeerDescriptor, closestNodes[i])) {
+            if (areEqualPeerDescriptors(this.ownPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.storeEntry({
                     kademliaId: key, 
                     storer: this.ownPeerDescriptor,
@@ -201,7 +201,7 @@ export class DataStore implements IStoreService {
         const closestNodes = result.closestNodes
         const successfulNodes: PeerDescriptor[] = []
         for (let i = 0; i < closestNodes.length && successfulNodes.length < this.numberOfCopies; i++) {
-            if (isSamePeerDescriptor(this.ownPeerDescriptor, closestNodes[i])) {
+            if (areEqualPeerDescriptors(this.ownPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.markAsDeleted(key, peerIdFromPeerDescriptor(this.ownPeerDescriptor))
                 successfulNodes.push(closestNodes[i])
                 continue
@@ -217,7 +217,7 @@ export class DataStore implements IStoreService {
                 if (response.deleted) {
                     logger.trace('remoteStore.deleteData() returned success')
                 } else {
-                    logger.trace('could not delete data from ' + PeerID.fromValue(closestNodes[i].kademliaId))
+                    logger.trace('could not delete data from ' + keyFromPeerDescriptor(closestNodes[i]))
                 }
                 successfulNodes.push(closestNodes[i])
             } catch (e) {
@@ -246,7 +246,7 @@ export class DataStore implements IStoreService {
             this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(kademliaId))
         }
 
-        logger.trace(this.ownPeerDescriptor.nodeName + ' storeData()')
+        logger.trace('storeData()')
         return StoreDataResponse.create()
     }
 
@@ -260,7 +260,7 @@ export class DataStore implements IStoreService {
 
     // RPC service implementation
     public async migrateData(request: MigrateDataRequest, context: ServerCallContext): Promise<MigrateDataResponse> {
-        logger.trace(this.ownPeerDescriptor.nodeName + ' server-side migrateData()')
+        logger.trace('server-side migrateData()')
         const dataEntry = request.dataEntry!
 
         const wasStored = this.localDataStore.storeEntry(dataEntry)
@@ -271,7 +271,7 @@ export class DataStore implements IStoreService {
         if (!this.selfIsOneOfClosestPeers(dataEntry.kademliaId)) {
             this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(dataEntry.kademliaId))
         }
-        logger.trace(this.ownPeerDescriptor.nodeName + ' server-side migrateData() at end')
+        logger.trace('server-side migrateData() at end')
         return MigrateDataResponse.create()
     }
 

package/src/exports.ts

@@ -6,14 +6,8 @@ export { getRandomRegion, getRegionDelayMatrix } from './connection/Simulator/pi
 export { PeerDescriptor, Message, NodeType, DataEntry } from './proto/packages/dht/protos/DhtRpc'
 export { ITransport } from './transport/ITransport'
 export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
-export { PeerID, PeerIDKey } from './helpers/PeerID'
-export { UUID } from './helpers/UUID'
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
-export { protoClasses } from './helpers/protoClasses'
-export { SortedContactList } from './dht/contact/SortedContactList'
-export { Contact } from './dht/contact/Contact'
 export { Remote } from './dht/contact/Remote'
-export { RecursiveFindResult } from './dht/find/RecursiveFinder'
-export { peerIdFromPeerDescriptor, keyFromPeerDescriptor, isSamePeerDescriptor } from './helpers/peerIdFromPeerDescriptor'
+export { areEqualPeerDescriptors } from './helpers/peerIdFromPeerDescriptor'
 export { IceServer } from './connection/WebRTC/WebRtcConnector'
 export { DhtCallContext } from './rpc-protocol/DhtCallContext'

package/src/helpers/PeerID.ts

@@ -49,13 +49,6 @@ export class PeerID {
         return new PeerID({ stringValue })
     }
 
-    static generateRandom(): PeerID {
-        // generate 160 bit random Uint8array
-        const value = new Uint8Array(20)
-        crypto.randomFillSync(value)
-        return new PeerID({ value })
-    }
-
     // TODO convert to static method?
     // eslint-disable-next-line class-methods-use-this
     private ip2Int(ip: string): number {

package/src/helpers/browser/isBrowserEnvironment.ts

@@ -0,0 +1 @@
+export const isBrowserEnvironment = (): boolean => false

package/src/helpers/browser/isBrowserEnvironment_override.ts

@@ -0,0 +1,3 @@
+// webpack overwrites the isBrowserEnvironment.ts with this file when it creates the browser bundle
+
+export const isBrowserEnvironment = (): boolean => true

package/src/helpers/kademliaId.ts

@@ -0,0 +1,8 @@
+import crypto from 'crypto'
+
+// https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
+const KADEMLIA_ID_LENGTH_IN_BYTES = 20
+
+export const createRandomKademliaId = (): Uint8Array => {
+    return crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES)
+}

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -9,6 +9,6 @@ export const keyFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerIDKey
     return PeerID.fromValue(peerDescriptor.kademliaId).toKey()
 }
 
-export const isSamePeerDescriptor = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
+export const areEqualPeerDescriptors = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
     return peerIdFromPeerDescriptor(peerDescriptor1).equals(peerIdFromPeerDescriptor(peerDescriptor2))
 }

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

@@ -253,10 +253,6 @@ export interface PeerDescriptor {
      * @generated from protobuf field: optional uint32 region = 7;
      */
     region?: number;
-    /**
-     * @generated from protobuf field: optional string nodeName = 8;
-     */
-    nodeName?: string;
 }
 /**
  * @generated from protobuf message dht.ConnectivityMethod
@@ -1019,8 +1015,7 @@ class PeerDescriptor$Type extends MessageType$<PeerDescriptor> {
             { no: 4, name: "tcp", kind: "message", T: () => ConnectivityMethod },
             { no: 5, name: "websocket", kind: "message", T: () => ConnectivityMethod },
             { no: 6, name: "openInternet", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
-            { no: 7, name: "region", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
-            { no: 8, name: "nodeName", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+            { no: 7, name: "region", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
 }

package/test/benchmark/KademliaCorrectness.test.ts

@@ -1,7 +1,8 @@
 /* eslint-disable no-console */
 import { Simulator } from '../../src/connection/Simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerID } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
+import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
@@ -87,7 +88,8 @@ describe('Kademlia correctness', () => {
                     correctNeighbors++
                 }
             } catch (e) {
-                console.error('Node ' + nodes[i].getPeerDescriptor().nodeName + ' had only ' + kademliaNeighbors.length + ' kademlia neighbors')
+                console.error('Node ' + keyFromPeerDescriptor(nodes[i].getPeerDescriptor()) + ' had only ' 
+                    + kademliaNeighbors.length + ' kademlia neighbors')
             }
             if (correctNeighbors === 0) {
                 console.log('No correct neighbors found for node ' + i)

package/test/benchmark/RecursiveFind.test.ts

@@ -5,7 +5,8 @@ import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dh
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { PeerID, peerIdFromPeerDescriptor } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
+import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger, wait } from '@streamr/utils'
 import { debugVars } from '../../src/helpers/debugHelpers'
 
@@ -31,19 +32,18 @@ describe('Recursive find correctness', () => {
 
         nodes = []
         const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), undefined, entryPointId)
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), undefined)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
         entrypointDescriptor = {
             kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: entryPointId
+            type: NodeType.NODEJS
         }
 
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`
 
-            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data), undefined, nodeId)
+            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data), undefined)
             nodeIndicesById[node.getNodeId().toKey()] = i
             nodes.push(node)
         }
@@ -70,7 +70,7 @@ describe('Recursive find correctness', () => {
         debugVars['waiting'] = false
         logger.info('waiting over')
 
-        nodes.forEach((node) => logger.info(node.getPeerDescriptor().nodeName + ': connections:' +
+        nodes.forEach((node) => logger.info(keyFromPeerDescriptor(node.getPeerDescriptor()) + ': connections:' +
             node.getNumberOfConnections() + ', kbucket: ' + node.getBucketSize()
             + ', localLocked: ' + node.getNumberOfLocalLockedConnections()
             + ', remoteLocked: ' + node.getNumberOfRemoteLockedConnections()

package/test/end-to-end/Layer0-Layer1.test.ts

@@ -1,6 +1,6 @@
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('Layer0-Layer1', () => {
     const epPeerDescriptor: PeerDescriptor = {
@@ -35,11 +35,11 @@ describe('Layer0-Layer1', () => {
         await node1.start()
         await node2.start()
 
-        stream1Node1 = new DhtNode({ transportLayer: epDhtNode, serviceId: STREAM_ID1 })
-        stream1Node2 = new DhtNode({ transportLayer: node1, serviceId: STREAM_ID1 })
+        stream1Node1 = new DhtNode({ transport: epDhtNode, serviceId: STREAM_ID1 })
+        stream1Node2 = new DhtNode({ transport: node1, serviceId: STREAM_ID1 })
 
-        stream2Node1 = new DhtNode({ transportLayer: epDhtNode, serviceId: STREAM_ID2 })
-        stream2Node2 = new DhtNode({ transportLayer: node2, serviceId: STREAM_ID2 })
+        stream2Node1 = new DhtNode({ transport: epDhtNode, serviceId: STREAM_ID2 })
+        stream2Node2 = new DhtNode({ transport: node2, serviceId: STREAM_ID2 })
 
         await Promise.all([
             stream1Node1.start(),
@@ -81,9 +81,9 @@ describe('Layer0-Layer1', () => {
         expect(stream2Node1.getClosestContacts()).toHaveLength(1)
         expect(stream2Node2.getClosestContacts()).toHaveLength(1)
 
-        expect(isSamePeerDescriptor(stream1Node1.getClosestContacts()[0], node1.getPeerDescriptor())).toBe(true)
-        expect(isSamePeerDescriptor(stream1Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
-        expect(isSamePeerDescriptor(stream2Node1.getClosestContacts()[0], node2.getPeerDescriptor())).toBe(true)
-        expect(isSamePeerDescriptor(stream2Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
+        expect(areEqualPeerDescriptors(stream1Node1.getClosestContacts()[0], node1.getPeerDescriptor())).toBe(true)
+        expect(areEqualPeerDescriptors(stream1Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
+        expect(areEqualPeerDescriptors(stream2Node1.getClosestContacts()[0], node2.getPeerDescriptor())).toBe(true)
+        expect(areEqualPeerDescriptors(stream2Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
     })
 })

package/test/end-to-end/Layer0WebRTC-Layer1.test.ts

@@ -54,31 +54,31 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
         layer1EntryPoint = new DhtNode({
             peerId: binaryToHex(entrypointDescriptor.kademliaId),
-            transportLayer: layer0EntryPoint,
+            transport: layer0EntryPoint,
             serviceId: 'layer1'
         })
 
         layer1Node1 = new DhtNode({
             peerId: layer0Node1Id,
-            transportLayer: layer0Node1,
+            transport: layer0Node1,
             serviceId: 'layer1'
         })
 
         layer1Node2 = new DhtNode({
             peerId: layer0Node2Id,
-            transportLayer: layer0Node2,
+            transport: layer0Node2,
             serviceId: 'layer1'
         })
 
         layer1Node3 = new DhtNode({
             peerId: layer0Node3Id,
-            transportLayer: layer0Node3,
+            transport: layer0Node3,
             serviceId: 'layer1'
         })
 
         layer1Node4 = new DhtNode({
             peerId: layer0Node4Id,
-            transportLayer: layer0Node4,
+            transport: layer0Node4,
             serviceId: 'layer1'
         })