@streamr/dht 101.1.2 → 102.0.0-beta.1

package/src/dht/store/StoreRpcLocal.ts

@@ -1,23 +1,23 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { Logger, executeSafePromise } from '@streamr/utils'
-import { Empty } from '../../proto/google/protobuf/empty'
-import { Timestamp } from '../../proto/google/protobuf/timestamp'
+import { Empty } from '../../../generated/google/protobuf/empty'
+import { Timestamp } from '../../../generated/google/protobuf/timestamp'
 import {
     DataEntry,
     PeerDescriptor,
     ReplicateDataRequest,
     StoreDataRequest, StoreDataResponse
-} from '../../proto/packages/dht/protos/DhtRpc'
-import { IStoreRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+} from '../../../generated/packages/dht/protos/DhtRpc'
+import { IStoreRpc } from '../../../generated/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { LocalDataStore } from './LocalDataStore'
-import { areEqualPeerDescriptors, DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
+import { areEqualPeerDescriptors, DhtAddress, toDhtAddress } from '../../identifiers'
 
 interface StoreRpcLocalOptions {
     localDataStore: LocalDataStore
     localPeerDescriptor: PeerDescriptor
     replicateDataToContact: (dataEntry: DataEntry, contact: PeerDescriptor) => Promise<void>
-    getStorers: (key: DhtAddress) => ReadonlyArray<PeerDescriptor>
+    getStorers: (key: DhtAddress) => readonly PeerDescriptor[]
 }
 
 const logger = new Logger(module)
@@ -32,7 +32,7 @@ export class StoreRpcLocal implements IStoreRpc {
 
     async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
         logger.trace('storeData()')
-        const key = getDhtAddressFromRaw(request.key)
+        const key = toDhtAddress(request.key)
         const isLocalNodeStorer = this.isLocalNodeStorer(key)
         this.options.localDataStore.storeEntry({ 
             key: request.key,
@@ -57,7 +57,7 @@ export class StoreRpcLocal implements IStoreRpc {
         if (wasStored) {
             this.replicateDataToNeighbors((context as DhtCallContext).incomingSourceDescriptor!, request.entry!)
         }
-        const key = getDhtAddressFromRaw(dataEntry.key)
+        const key = toDhtAddress(dataEntry.key)
         if (!this.isLocalNodeStorer(key)) {
             this.options.localDataStore.setAllEntriesAsStale(key)
         }
@@ -70,7 +70,7 @@ export class StoreRpcLocal implements IStoreRpc {
     }
 
     private replicateDataToNeighbors(requestor: PeerDescriptor, dataEntry: DataEntry): void {
-        const dataKey = getDhtAddressFromRaw(dataEntry.key)
+        const dataKey = toDhtAddress(dataEntry.key)
         const storers = this.options.getStorers(dataKey)
         const isLocalNodePrimaryStorer = areEqualPeerDescriptors(storers[0], this.options.localPeerDescriptor)
         // If we are the closest to the data, get storageRedundancyFactor - 1 nearest node to the data, and

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

package/src/helpers/version.ts

@@ -6,9 +6,9 @@ export const LOCAL_PROTOCOL_VERSION = '1.1'
  * 
  * The older version assumes optimistically that it may be supported by the newer
  * version. It can't know for sure, but the other node will tell if it is not
- * supported (e.g. rejecting the handshake with UNSUPPORTED_VERSION error).
+ * supported (e.g. rejecting the handshake with UNSUPPORTED_PROTOCOL_VERSION error).
  */
-export const isMaybeSupportedVersion = (remoteVersion: string): boolean => {
+export const isMaybeSupportedProtocolVersion = (remoteVersion: string): boolean => {
     const localMajor = parseVersion(LOCAL_PROTOCOL_VERSION)!.major
     const remoteMajor = parseVersion(remoteVersion)?.major
     if ((remoteMajor === undefined) || (remoteMajor < localMajor)) {

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)
 
@@ -21,15 +21,15 @@ describe('Find correctness', () => {
         execSync('npm run prepare-kademlia-simulation')
     }
 
-    const dhtIds: Array<{ type: string, data: Array<number> }> = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+    const dhtIds: { type: string, data: number[] }[] = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
 
     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)
         }
     })
@@ -49,13 +49,13 @@ describe('Find correctness', () => {
         )
 
         logger.info('waiting 120s')
-        debugVars['waiting'] = true
+        debugVars.waiting = true
 
         await wait(120000)
-        debugVars['waiting'] = false
+        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)
@@ -22,18 +22,18 @@ describe('Kademlia correctness', () => {
         execSync('npm run prepare-kademlia-simulation')
     }
 
-    const dhtIds: Array<{ type: string, data: Array<number> }> = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
-    const groundTruth: Record<string, Array<{ name: string, distance: number, id: { type: string, data: Array<number> } }>>
+    const dhtIds: { type: string, data: number[] }[] = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+    const groundTruth: Record<string, { name: string, distance: number, id: { type: string, data: number[] } }[]>
         = JSON.parse(fs.readFileSync('test/data/orderedneighbors.json').toString())
 
     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'
 
@@ -18,7 +18,7 @@ describe('Ring correctness', () => {
     const NUM_NODES = 900
     const nodeIndicesById: Record<DhtAddress, number> = {}
 
-    const regions: Array<number> = []
+    const regions: number[] = []
     for (let i = 0; i < (NUM_NODES + 1); i++) {
         regions.push(i)
     }
@@ -36,19 +36,19 @@ describe('Ring correctness', () => {
         execSync('npm run prepare-kademlia-simulation')
     }
 
-    const dhtIds: Array<{ type: string, data: Array<number> }> = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
-    const groundTruth: Record<string, Array<{ name: string, distance: number, id: { type: string, data: Array<number> } }>>
+    const dhtIds: { type: string, data: number[] }[] = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+    const groundTruth: Record<string, { name: string, distance: number, id: { type: string, data: number[] } }[]>
         = JSON.parse(fs.readFileSync('test/data/orderedneighbors.json').toString())
 
     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'
@@ -26,7 +26,7 @@ class MockNode {
             host: 'localhost',
             natType: NatType.UNKNOWN,
             ipAddress: ipv4ToNumber(ipAddress),
-            version: '0.0.0'
+            protocolVersion: '0.0.0'
 
         }
         this.peerDescriptor = createPeerDescriptor(connectivityResponse, getRandomRegion())
@@ -39,7 +39,7 @@ class MockNode {
 }
 
 // populate with mock ip addresses
-const mockData: Array< [number, string] > = [
+const mockData: [number, string][] = [
     [0, '5.2.4.2'],
     [0, '6.23.2.4'],
     [0, '7.2.4.2'],

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'