@streamr/dht 101.1.2 → 102.0.0-beta.0

package/src/dht/store/StoreRpcRemote.ts

@@ -1,9 +1,9 @@
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { toNodeId } from '../../identifiers'
 import {
     ReplicateDataRequest,
     StoreDataRequest
-} from '../../proto/packages/dht/protos/DhtRpc'
-import { StoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+} from '../../../generated/packages/dht/protos/DhtRpc'
+import { StoreRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
 import { EXISTING_CONNECTION_TIMEOUT, RpcRemote } from '../contact/RpcRemote'
 
 export class StoreRpcRemote extends RpcRemote<StoreRpcClient> {
@@ -13,15 +13,18 @@ export class StoreRpcRemote extends RpcRemote<StoreRpcClient> {
         try {
             await this.getClient().storeData(request, options)
         } catch (err) {
-            const to = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
-            const from = getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())
+            const to = toNodeId(this.getPeerDescriptor())
+            const from = toNodeId(this.getLocalPeerDescriptor())
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
             throw new Error(`Could not store data to ${to} from ${from} ${err}`)
         }
     }
 
-    async replicateData(request: ReplicateDataRequest): Promise<void> {
+    async replicateData(request: ReplicateDataRequest, connect: boolean): Promise<void> {
         const options = this.formDhtRpcOptions({
-            timeout: EXISTING_CONNECTION_TIMEOUT
+            timeout: EXISTING_CONNECTION_TIMEOUT,
+            notification: true,
+            connect
         })
         return this.getClient().replicateData(request, options)
     }

package/src/exports.ts

@@ -4,7 +4,7 @@ export { RoutingRpcCommunicator } from './transport/RoutingRpcCommunicator'
 export { Simulator, LatencyType } from './connection/simulator/Simulator'
 export { SimulatorTransport } from './connection/simulator/SimulatorTransport'
 export { getRandomRegion, getRegionDelayMatrix } from './connection/simulator/pings'
-export { PeerDescriptor, Message, NodeType, DataEntry } from './proto/packages/dht/protos/DhtRpc'
+export { PeerDescriptor, Message, NodeType, DataEntry } from '../generated/packages/dht/protos/DhtRpc'
 export { ITransport, TransportEvents } from './transport/ITransport'
 export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
 export { ConnectionsView } from './connection/ConnectionsView'
@@ -25,9 +25,9 @@ export { createOutgoingHandshaker } from './connection/Handshaker'
 export { 
     DhtAddress,
     DhtAddressRaw,
-    getDhtAddressFromRaw,
-    getRawFromDhtAddress,
-    createRandomDhtAddress,
+    toDhtAddress,
+    toDhtAddressRaw,
+    randomDhtAddress,
     areEqualPeerDescriptors,
-    getNodeIdFromPeerDescriptor
+    toNodeId
 } from './identifiers'

package/src/helpers/Connectivity.ts

@@ -1,5 +1,5 @@
 import { ConnectionType } from '../connection/IConnection'
-import { ConnectivityMethod, NodeType, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { ConnectivityMethod, NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { isPrivateIPv4 } from './AddressTools'
 
 export const canOpenConnectionFromBrowser = (websocketServer: ConnectivityMethod): boolean => {

package/src/helpers/createPeerDescriptor.ts

@@ -5,12 +5,12 @@ import {
 import crypto from 'crypto'
 import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
 import { createPeerDescriptorSignaturePayload } from '../helpers/createPeerDescriptorSignaturePayload'
-import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../identifiers'
+import { DhtAddress, DhtAddressRaw, toDhtAddressRaw } from '../identifiers'
 import {
     ConnectivityResponse,
     NodeType,
     PeerDescriptor
-} from '../proto/packages/dht/protos/DhtRpc'
+} from '../../generated/packages/dht/protos/DhtRpc'
 
 const calculateNodeIdRaw = (ipAddress: number, privateKey: Uint8Array): DhtAddressRaw => {
     // nodeId is calculated as 
@@ -34,7 +34,7 @@ export const createPeerDescriptor = (connectivityResponse: ConnectivityResponse,
     const publicKey = crypto.randomBytes(20)  // TODO calculate publicKey from privateKey
     let nodeIdRaw: DhtAddressRaw
     if (nodeId !== undefined) {
-        nodeIdRaw = getRawFromDhtAddress(nodeId)
+        nodeIdRaw = toDhtAddressRaw(nodeId)
     } else {
         nodeIdRaw = calculateNodeIdRaw(connectivityResponse.ipAddress, privateKey)
     }

package/src/helpers/createPeerDescriptorSignaturePayload.ts

@@ -1,4 +1,4 @@
-import { ConnectivityMethod, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { ConnectivityMethod, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 
 function convertUnsignedIntegerToBuffer(number: number): Buffer {
     const buffer = Buffer.alloc(4)

package/src/helpers/protoClasses.ts

@@ -26,7 +26,7 @@ import {
     UnlockRequest,
     LockResponse
 
-} from '../proto/packages/dht/protos/DhtRpc'
+} from '../../generated/packages/dht/protos/DhtRpc'
 
 export const protoClasses: Array<IMessageType<any>> = [
     ClosestPeersRequest,

package/src/identifiers.ts

@@ -1,6 +1,6 @@
 import { BrandedString, areEqualBinaries, binaryToHex, hexToBinary } from '@streamr/utils'
 import crypto from 'crypto'
-import { PeerDescriptor } from './proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../generated/packages/dht/protos/DhtRpc'
 
 // https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
 export const KADEMLIA_ID_LENGTH_IN_BYTES = 20
@@ -8,22 +8,22 @@ export const KADEMLIA_ID_LENGTH_IN_BYTES = 20
 export type DhtAddress = BrandedString<'DhtAddress'>
 export type DhtAddressRaw = Uint8Array
 
-export const getDhtAddressFromRaw = (raw: DhtAddressRaw): DhtAddress => {
+export const toDhtAddress = (raw: DhtAddressRaw): DhtAddress => {
     return binaryToHex(raw) as unknown as DhtAddress
 }
 
-export const getRawFromDhtAddress = (address: DhtAddress): DhtAddressRaw => {
+export const toDhtAddressRaw = (address: DhtAddress): DhtAddressRaw => {
     return hexToBinary(address) as unknown as DhtAddressRaw
 }
 
-export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): DhtAddress => {
-    return getDhtAddressFromRaw(peerDescriptor.nodeId)
+export const toNodeId = (peerDescriptor: PeerDescriptor): DhtAddress => {
+    return toDhtAddress(peerDescriptor.nodeId)
 }
 
 export const areEqualPeerDescriptors = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
     return areEqualBinaries(peerDescriptor1.nodeId, peerDescriptor2.nodeId)
 }
 
-export const createRandomDhtAddress = (): DhtAddress => {
-    return getDhtAddressFromRaw(crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES))
+export const randomDhtAddress = (): DhtAddress => {
+    return toDhtAddress(crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES))
 }

package/src/rpc-protocol/DhtCallContext.ts

@@ -1,5 +1,5 @@
 import { ProtoCallContext } from '@streamr/proto-rpc'
-import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { DhtRpcOptions } from './DhtRpcOptions'
 
 export class DhtCallContext extends ProtoCallContext implements DhtRpcOptions {

package/src/rpc-protocol/DhtRpcOptions.ts

@@ -1,5 +1,5 @@
 import { ProtoRpcOptions } from '@streamr/proto-rpc'
-import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 
 export interface DhtRpcOptions extends ProtoRpcOptions {
     targetDescriptor?: PeerDescriptor

package/src/transport/ITransport.ts

@@ -1,4 +1,4 @@
-import { Message, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { Message, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 
 export interface TransportEvents {
     disconnected: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => void
@@ -33,4 +33,5 @@ export interface ITransport {
     send(msg: Message, opts?: SendOptions): Promise<void>
     getLocalPeerDescriptor(): PeerDescriptor
     stop(): void | Promise<void>
+    getDiagnosticInfo(): Record<string, unknown>
 }

package/src/transport/ListeningRpcCommunicator.ts

@@ -1,24 +1,32 @@
 import { ITransport } from './ITransport' 
 import { RoutingRpcCommunicator } from './RoutingRpcCommunicator'
-import { RpcCommunicatorOptions } from '@streamr/proto-rpc'
-import { Message } from '../proto/packages/dht/protos/DhtRpc'
+import { RpcCommunicatorOptions, RpcError } from '@streamr/proto-rpc'
+import { Message, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { ServiceID } from '../types/ServiceID'
+import { areEqualPeerDescriptors } from '../identifiers'
 
 export class ListeningRpcCommunicator extends RoutingRpcCommunicator {
     private readonly transport: ITransport
-    private readonly listener: (msg: Message) => void
+    private readonly messageListener: (msg: Message) => void
+    private readonly disconnectedListener: (peerDescriptor: PeerDescriptor) => void
 
     constructor(ownServiceId: ServiceID, transport: ITransport, options?: RpcCommunicatorOptions) {
         super(ownServiceId, (msg, opts) => transport.send(msg, opts), options)
-        this.listener = (msg: Message) => {
+        this.messageListener = (msg: Message) => {
             this.handleMessageFromPeer(msg)
         }
+        this.disconnectedListener = (peerDescriptor: PeerDescriptor) => {
+            const requests = this.getRequestIds((request) => areEqualPeerDescriptors(peerDescriptor, request.getCallContext().targetDescriptor!))
+            requests.forEach((id) => this.handleClientError(id, new RpcError.Disconnected('Peer disconnected')))
+        }
         this.transport = transport
-        transport.on('message', this.listener) 
+        transport.on('message', this.messageListener) 
+        transport.on('disconnected', this.disconnectedListener)
     }
 
     destroy(): void {
-        this.transport.off('message', this.listener)
+        this.transport.off('message', this.messageListener)
+        this.transport.off('disconnected', this.disconnectedListener)
         this.stop()
     }
 }

package/src/transport/RoutingRpcCommunicator.ts

@@ -1,8 +1,8 @@
-import { Message, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { Message, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { v4 } from 'uuid'
 import { RpcCommunicator, RpcCommunicatorOptions } from '@streamr/proto-rpc'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
-import { RpcMessage } from '../proto/packages/proto-rpc/protos/ProtoRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { ServiceID } from '../types/ServiceID'
 import { DEFAULT_SEND_OPTIONS, SendOptions } from './ITransport'
 

package/test/benchmark/Find.test.ts

@@ -6,7 +6,7 @@ import { execSync } from 'child_process'
 import fs from 'fs'
 import { Logger, wait } from '@streamr/utils'
 import { debugVars } from '../../src/helpers/debugHelpers'
-import { getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { toDhtAddress, toNodeId } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
@@ -26,10 +26,10 @@ describe('Find correctness', () => {
     beforeEach(async () => {
 
         nodes = []
-        entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[0].data)), undefined)
+        entryPoint = await createMockConnectionDhtNode(simulator, toDhtAddress(Uint8Array.from(dhtIds[0].data)), undefined)
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)), undefined)
+            const node = await createMockConnectionDhtNode(simulator, toDhtAddress(Uint8Array.from(dhtIds[i].data)), undefined)
             nodes.push(node)
         }
     })
@@ -55,7 +55,7 @@ describe('Find correctness', () => {
         debugVars['waiting'] = false
         logger.info('waiting over')
 
-        nodes.forEach((node) => logger.info(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ': connections:' +
+        nodes.forEach((node) => logger.info(toNodeId(node.getLocalPeerDescriptor()) + ': connections:' +
             node.getConnectionsView().getConnectionCount() + ', kbucket: ' + node.getNeighborCount()
             + ', localLocked: ' + node.getLocalLockedConnectionCount()
             + ', remoteLocked: ' + node.getRemoteLockedConnectionCount()
@@ -63,10 +63,10 @@ describe('Find correctness', () => {
 
         logger.info('starting find')
         const targetId = Uint8Array.from(dhtIds[9].data)
-        const closestNodes = await nodes[159].findClosestNodesFromDht(getDhtAddressFromRaw(targetId))
+        const closestNodes = await nodes[159].findClosestNodesFromDht(toDhtAddress(targetId))
         logger.info('find over')
         expect(closestNodes).toBeGreaterThanOrEqual(5)
-        expect(getDhtAddressFromRaw(targetId)).toEqual(getNodeIdFromPeerDescriptor(closestNodes[0]))
+        expect(toDhtAddress(targetId)).toEqual(toNodeId(closestNodes[0]))
 
     }, 180000)
 })

package/test/benchmark/KademliaCorrectness.test.ts

@@ -4,7 +4,7 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { DhtAddress, toDhtAddress, toNodeId } from '../../src/identifiers'
 import { Logger } from '@streamr/utils'
 
 const logger = new Logger(module)
@@ -28,12 +28,12 @@ describe('Kademlia correctness', () => {
 
     beforeEach(async () => {
         nodes = []
-        entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[0].data)), 8)
+        entryPoint = await createMockConnectionDhtNode(simulator, toDhtAddress(Uint8Array.from(dhtIds[0].data)), 8)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId()] = 0
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)))
+            const node = await createMockConnectionDhtNode(simulator, toDhtAddress(Uint8Array.from(dhtIds[i].data)))
             nodeIndicesById[node.getNodeId()] = i
             nodes.push(node)
         }
@@ -68,7 +68,7 @@ describe('Kademlia correctness', () => {
                 groundTruthString += groundTruth[i + ''][j].name + ','
             }
 
-            const kademliaNeighbors = nodes[i].getClosestContacts(8).map((p) => getNodeIdFromPeerDescriptor(p))
+            const kademliaNeighbors = nodes[i].getClosestContacts(8).map((p) => toNodeId(p))
 
             let kadString = 'kademliaNeighbors: '
             kademliaNeighbors.forEach((neighbor) => {
@@ -84,7 +84,7 @@ describe('Kademlia correctness', () => {
                     correctNeighbors++
                 }
             } catch {
-                console.error('Node ' + getNodeIdFromPeerDescriptor(nodes[i].getLocalPeerDescriptor()) + ' had only ' 
+                console.error('Node ' + toNodeId(nodes[i].getLocalPeerDescriptor()) + ' had only ' 
                     + kademliaNeighbors.length + ' kademlia neighbors')
             }
             if (correctNeighbors === 0) {

package/test/benchmark/RingCorrectness.test.ts

@@ -4,7 +4,7 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockRingNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { DhtAddress, toDhtAddress, toNodeId } from '../../src/identifiers'
 import { Logger } from '@streamr/utils'
 import { getRingIdRawFromPeerDescriptor } from '../../src/dht/contact/ringIdentifiers'
 
@@ -43,12 +43,12 @@ describe('Ring correctness', () => {
     beforeEach(async () => {
         jest.setTimeout(60000)
         nodes = []
-        entryPoint = await createMockRingNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[0].data)), regions[0])
+        entryPoint = await createMockRingNode(simulator, toDhtAddress(Uint8Array.from(dhtIds[0].data)), regions[0])
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId()] = 0
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockRingNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)), regions[i + 1])
+            const node = await createMockRingNode(simulator, toDhtAddress(Uint8Array.from(dhtIds[i].data)), regions[i + 1])
             nodeIndicesById[node.getNodeId()] = i
             nodes.push(node)
         }
@@ -111,7 +111,7 @@ describe('Ring correctness', () => {
                 groundTruthString += groundTruth[i + ''][j].name + ','
             }
 
-            const kademliaNeighbors = nodes[i].getClosestContacts(8).map((p) => getNodeIdFromPeerDescriptor(p))
+            const kademliaNeighbors = nodes[i].getClosestContacts(8).map((p) => toNodeId(p))
 
             let kadString = 'kademliaNeighbors: '
             kademliaNeighbors.forEach((neighbor) => {
@@ -127,7 +127,7 @@ describe('Ring correctness', () => {
                     correctNeighbors++
                 }
             } catch {
-                console.error('Node ' + getNodeIdFromPeerDescriptor(nodes[i].getLocalPeerDescriptor()) + ' had only '
+                console.error('Node ' + toNodeId(nodes[i].getLocalPeerDescriptor()) + ' had only '
                     + kademliaNeighbors.length + ' kademlia neighbors')
             }
             if (correctNeighbors === 0) {

package/test/benchmark/SortedContactListBenchmark.test.ts

@@ -2,7 +2,7 @@
 
 import KBucket from 'k-bucket'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import { DhtAddress, DhtAddressRaw, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+import { DhtAddress, DhtAddressRaw, randomDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
 
 const NUM_ADDS = 1000
 
@@ -13,8 +13,8 @@ interface Item {
 }
 
 const createRandomItem = (index: number): Item => {
-    const nodeId = createRandomDhtAddress()
-    const nodeIdRaw = getRawFromDhtAddress(nodeId)
+    const nodeId = randomDhtAddress()
+    const nodeIdRaw = toDhtAddressRaw(nodeId)
     return {
         getNodeId: () => nodeId,
         id: nodeIdRaw,
@@ -38,7 +38,7 @@ describe('SortedContactListBenchmark', () => {
             randomIds.push(createRandomItem(i))
         }
         const list = new SortedContactList({
-            referenceId: createRandomDhtAddress(),
+            referenceId: randomDhtAddress(),
             allowToContainReferenceId: true
         })
 
@@ -48,7 +48,7 @@ describe('SortedContactListBenchmark', () => {
         }
         console.timeEnd('SortedContactList.addContact()')
 
-        const kBucket = new KBucket<Item>({ localNodeId: getRawFromDhtAddress(createRandomDhtAddress()) })
+        const kBucket = new KBucket<Item>({ localNodeId: toDhtAddressRaw(randomDhtAddress()) })
         console.time('KBucket.add()')
         for (let i = 0; i < NUM_ADDS; i++) {
             kBucket.add(randomIds[i])
@@ -64,14 +64,14 @@ describe('SortedContactListBenchmark', () => {
 
         console.time('kBucket closest()')
         for (let i = 0; i < NUM_ADDS; i++) {
-            kBucket.closest(getRawFromDhtAddress(createRandomDhtAddress()), 20)
+            kBucket.closest(toDhtAddressRaw(randomDhtAddress()), 20)
         }
         console.timeEnd('kBucket closest()')
 
         console.time('SortedContactList.getClosestContacts()')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: createRandomDhtAddress(),
+                referenceId: randomDhtAddress(),
                 allowToContainReferenceId: true
             })
 
@@ -84,7 +84,7 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() and addContacts()')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: createRandomDhtAddress(),
+                referenceId: randomDhtAddress(),
                 allowToContainReferenceId: true
             })
 
@@ -97,10 +97,10 @@ describe('SortedContactListBenchmark', () => {
         const shuffled = shuffleArray(kBucket.toArray())
         console.time('kbucket add and closest')
         for (let i = 0; i < NUM_ADDS; i++) {
-            const bucket2 = new KBucket<Item>({ localNodeId: getRawFromDhtAddress(createRandomDhtAddress()) })
+            const bucket2 = new KBucket<Item>({ localNodeId: toDhtAddressRaw(randomDhtAddress()) })
 
             shuffled.forEach((contact) => bucket2.add(contact))
-            bucket2.closest(getRawFromDhtAddress(createRandomDhtAddress()), 20)
+            bucket2.closest(toDhtAddressRaw(randomDhtAddress()), 20)
         }
         console.timeEnd('kbucket add and closest')
 

package/test/benchmark/hybrid-network-simulation/RingContactList.test.ts

@@ -1,4 +1,4 @@
-import { ConnectivityResponse, PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
+import { ConnectivityResponse, PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
 import { createPeerDescriptor } from '../../../src/helpers/createPeerDescriptor'
 import { NatType } from '../../../src/connection/ConnectionManager'
 import { ipv4ToNumber, Logger } from '@streamr/utils'

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

@@ -1,5 +1,5 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { randomDhtAddress, toNodeId } from '../../src/identifiers'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('Layer 1 on Layer 0 with mocked connections', () => {
@@ -26,25 +26,25 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
         layer0EntryPoint = new DhtNode({ peerDescriptor: entrypointDescriptor, websocketServerEnableTls: false })
 
-        const layer0Node1Id = createRandomDhtAddress()
+        const layer0Node1Id = randomDhtAddress()
         layer0Node1 = new DhtNode({
             nodeId: layer0Node1Id,
             entryPoints: [entrypointDescriptor]
         })
 
-        const layer0Node2Id = createRandomDhtAddress()
+        const layer0Node2Id = randomDhtAddress()
         layer0Node2 = new DhtNode({
             nodeId: layer0Node2Id,
             entryPoints: [entrypointDescriptor]
         })
 
-        const layer0Node3Id = createRandomDhtAddress()
+        const layer0Node3Id = randomDhtAddress()
         layer0Node3 = new DhtNode({
             nodeId: layer0Node3Id,
             entryPoints: [entrypointDescriptor]
         })
 
-        const layer0Node4Id = createRandomDhtAddress()
+        const layer0Node4Id = randomDhtAddress()
         layer0Node4 = new DhtNode({
             nodeId: layer0Node4Id,
             entryPoints: [entrypointDescriptor]
@@ -57,7 +57,7 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         await layer0Node4.start()
 
         layer1EntryPoint = new DhtNode({
-            nodeId: getNodeIdFromPeerDescriptor(entrypointDescriptor),
+            nodeId: toNodeId(entrypointDescriptor),
             transport: layer0EntryPoint,
             connectionsView: layer0EntryPoint.getConnectionsView(),
             serviceId: 'layer1'

package/test/end-to-end/Layer0Webrtc.test.ts

@@ -1,9 +1,9 @@
 import { areEqualBinaries, waitForEvent3 } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/exports'
+import { toNodeId } from '../../src/exports'
 
 describe('Layer0 with WebRTC connections', () => {
 
@@ -64,8 +64,8 @@ describe('Layer0 with WebRTC connections', () => {
             node2.joinDht([epPeerDescriptor]),
             node1.joinDht([epPeerDescriptor])
         ])
-        const nodeId1 = getNodeIdFromPeerDescriptor(node1.getLocalPeerDescriptor())
-        const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
+        const nodeId1 = toNodeId(node1.getLocalPeerDescriptor())
+        const nodeId2 = toNodeId(node2.getLocalPeerDescriptor())
         expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
         expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
     }, 60000)
@@ -77,8 +77,8 @@ describe('Layer0 with WebRTC connections', () => {
             node3.joinDht([epPeerDescriptor]),
             node4.joinDht([epPeerDescriptor])
         ])
-        const nodeId1 = getNodeIdFromPeerDescriptor(node1.getLocalPeerDescriptor())
-        const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
+        const nodeId1 = toNodeId(node1.getLocalPeerDescriptor())
+        const nodeId2 = toNodeId(node2.getLocalPeerDescriptor())
         expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
         expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
     })

package/test/end-to-end/RecoveryFromFailedAutoCertification.test.ts

@@ -1,5 +1,5 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import os from 'os'
 
 describe('Failed autocertification', () => {

package/test/end-to-end/WebsocketConnectionRequest.test.ts

@@ -1,4 +1,4 @@
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { waitForCondition } from '@streamr/utils'

package/test/end-to-end/memory-leak.test.ts

@@ -1,10 +1,10 @@
 import LeakDetector from 'jest-leak-detector'
 import { waitForCondition } from '@streamr/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { Message } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Message } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { toNodeId } from '../../src/identifiers'
 
 const MESSAGE_ID = 'mock-message-id'
 
@@ -19,7 +19,7 @@ describe('memory leak', () => {
             }
         })
         let entryPoint: DhtNode | undefined = new DhtNode({
-            nodeId: getNodeIdFromPeerDescriptor(entryPointDescriptor),
+            nodeId: toNodeId(entryPointDescriptor),
             websocketHost: entryPointDescriptor.websocket!.host,
             websocketPortRange: {
                 min: entryPointDescriptor.websocket!.port,