@streamr/dht 100.0.0-testnet-two.1 → 100.0.0-testnet-two.2

package/src/dht/store/LocalDataStore.ts

@@ -1,9 +1,6 @@
-import { PeerID, PeerIDKey } from '../../helpers/PeerID'
 import { DataEntry } from '../../proto/packages/dht/protos/DhtRpc'
 import { MapWithTtl } from '../../helpers/MapWithTtl'
-import { NodeID, getNodeIdFromBinary } from '../../helpers/nodeId'
-
-type Key = Uint8Array
+import { DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
 
 export class LocalDataStore {
 
@@ -15,31 +12,30 @@ export class LocalDataStore {
 
     // A map into which each node can store one value per data key
     // The first key is the key of the data, the second key is the
-    // NodeID of the creator of the data
-    private store: Map<PeerIDKey, MapWithTtl<NodeID, DataEntry>> = new Map()
+    // DhtAddress of the creator of the data
+    private store: Map<DhtAddress, MapWithTtl<DhtAddress, DataEntry>> = new Map()
 
     public storeEntry(dataEntry: DataEntry): boolean {
-        const dataKey = PeerID.fromValue(dataEntry.key).toKey()
-        const creatorNodeId = getNodeIdFromBinary(dataEntry.creator)
-        if (!this.store.has(dataKey)) {
-            this.store.set(dataKey, new MapWithTtl((e) => Math.min(e.ttl, this.maxTtl)))
+        const key = getDhtAddressFromRaw(dataEntry.key)
+        const creatorNodeId = getDhtAddressFromRaw(dataEntry.creator)
+        if (!this.store.has(key)) {
+            this.store.set(key, new MapWithTtl((e) => Math.min(e.ttl, this.maxTtl)))
         }
-        if (this.store.get(dataKey)!.has(creatorNodeId)) {
+        if (this.store.get(key)!.has(creatorNodeId)) {
             const storedMillis = (dataEntry.createdAt!.seconds * 1000) + (dataEntry.createdAt!.nanos / 1000000)
-            const oldLocalEntry = this.store.get(dataKey)!.get(creatorNodeId)!
+            const oldLocalEntry = this.store.get(key)!.get(creatorNodeId)!
             const oldStoredMillis = (oldLocalEntry.createdAt!.seconds * 1000) + (oldLocalEntry.createdAt!.nanos / 1000000)
             // do nothing if old entry is newer than the one being replicated
             if (oldStoredMillis >= storedMillis) {
                 return false
             }
         }
-        this.store.get(dataKey)!.set(creatorNodeId, dataEntry)
+        this.store.get(key)!.set(creatorNodeId, dataEntry)
         return true
     }
 
-    public markAsDeleted(key: Key, creator: NodeID): boolean {
-        const dataKey = PeerID.fromValue(key).toKey()
-        const item = this.store.get(dataKey)
+    public markAsDeleted(key: DhtAddress, creator: DhtAddress): boolean {
+        const item = this.store.get(key)
         if ((item === undefined) || !item.has(creator)) {
             return false
         }
@@ -54,37 +50,33 @@ export class LocalDataStore {
         }
     }
 
-    public getEntries(key: Key): Map<NodeID, DataEntry> {
-        const dataEntries = new Map<NodeID, DataEntry>
-        const mapKey = PeerID.fromValue(key).toKey()
-        this.store.get(mapKey)?.forEach((value, key) => {
-            dataEntries.set(key, value)
+    public getEntries(key: DhtAddress): Map<DhtAddress, DataEntry> {
+        const dataEntries = new Map<DhtAddress, DataEntry>
+        this.store.get(key)?.forEach((value, creator) => {
+            dataEntries.set(creator, value)
         })
         return dataEntries
     }
 
-    public setStale(key: Key, creator: NodeID, stale: boolean): void {
-        const mapKey = PeerID.fromValue(key).toKey()
-        const storedEntry = this.store.get(mapKey)?.get(creator)
+    public setStale(key: DhtAddress, creator: DhtAddress, stale: boolean): void {
+        const storedEntry = this.store.get(key)?.get(creator)
         if (storedEntry) {
             storedEntry.stale = stale
         }
     }
 
-    public setAllEntriesAsStale(key: Key): void {
-        const mapKey = PeerID.fromValue(key).toKey()
-        this.store.get(mapKey)?.forEach((value) => {
+    public setAllEntriesAsStale(key: DhtAddress): void {
+        this.store.get(key)?.forEach((value) => {
             value.stale = true
         })
     }
 
-    public deleteEntry(key: Key, creator: NodeID): void {
-        const mapKey = PeerID.fromValue(key).toKey()
-        const storedEntry = this.store.get(mapKey)?.get(creator)
+    public deleteEntry(key: DhtAddress, creator: DhtAddress): void {
+        const storedEntry = this.store.get(key)?.get(creator)
         if (storedEntry) {
-            this.store.get(mapKey)?.delete(creator)
-            if (this.store.get(mapKey)?.size() === 0) {
-                this.store.delete(mapKey)
+            this.store.get(key)?.delete(creator)
+            if (this.store.get(key)?.size() === 0) {
+                this.store.delete(key)
             }
         }
     }

package/src/dht/store/StoreManager.ts

@@ -7,7 +7,7 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { RecursiveOperationManager } from '../recursive-operation/RecursiveOperationManager'
 import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { Logger, executeSafePromise, hexToBinary } from '@streamr/utils'
+import { Logger, executeSafePromise } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
 import { StoreRpcRemote } from './StoreRpcRemote'
 import { Timestamp } from '../../proto/google/protobuf/timestamp'
@@ -15,7 +15,7 @@ import { SortedContactList } from '../contact/SortedContactList'
 import { Contact } from '../contact/Contact'
 import { ServiceID } from '../../types/ServiceID'
 import { findIndex } from 'lodash'
-import { NodeID, areEqualNodeIds, getNodeIdFromBinary, getNodeIdFromDataKey } from '../../helpers/nodeId'
+import { DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../identifiers'
 import { StoreRpcLocal } from './StoreRpcLocal'
 import { getDistance } from '../PeerManager'
 
@@ -27,7 +27,7 @@ interface StoreManagerConfig {
     serviceId: ServiceID
     highestTtl: number
     redundancyFactor: number
-    getClosestNeighborsTo: (id: Uint8Array, n?: number) => PeerDescriptor[]
+    getClosestNeighborsTo: (dataKey: DhtAddress, n?: number) => PeerDescriptor[]
     createRpcRemote: (contact: PeerDescriptor) => StoreRpcRemote
 }
 
@@ -46,7 +46,7 @@ export class StoreManager {
         const rpcLocal = new StoreRpcLocal({
             localDataStore: this.config.localDataStore,
             replicateDataToNeighbors: (incomingPeer: PeerDescriptor, dataEntry: DataEntry) => this.replicateDataToNeighbors(incomingPeer, dataEntry),
-            selfIsWithinRedundancyFactor: (key: Uint8Array): boolean => this.selfIsWithinRedundancyFactor(key)
+            selfIsWithinRedundancyFactor: (key: DhtAddress): boolean => this.selfIsWithinRedundancyFactor(key)
         })
         this.config.rpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData',
             (request: StoreDataRequest) => rpcLocal.storeData(request))
@@ -63,28 +63,25 @@ export class StoreManager {
     private replicateAndUpdateStaleState(dataEntry: DataEntry, newNode: PeerDescriptor): void {
         const newNodeId = getNodeIdFromPeerDescriptor(newNode)
         // TODO use config option or named constant?
-        const closestToData = this.config.getClosestNeighborsTo(dataEntry.key, 10)
+        const closestToData = this.config.getClosestNeighborsTo(getDhtAddressFromRaw(dataEntry.key), 10)
         const sortedList = new SortedContactList<Contact>({
-            referenceId: getNodeIdFromDataKey(dataEntry.key), 
+            referenceId: getDhtAddressFromRaw(dataEntry.key), 
             maxSize: 20,  // TODO use config option or named constant?
             allowToContainReferenceId: true,
             emitEvents: false
         })
         sortedList.addContact(new Contact(this.config.localPeerDescriptor))
         closestToData.forEach((neighbor) => {
-            if (!areEqualNodeIds(newNodeId, getNodeIdFromPeerDescriptor(neighbor))) {
+            if (newNodeId !== getNodeIdFromPeerDescriptor(neighbor)) {
                 sortedList.addContact(new Contact(neighbor))
             }
         })
-        const selfIsPrimaryStorer = areEqualNodeIds(
-            sortedList.getClosestContactId(),
-            getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
-        )
+        const selfIsPrimaryStorer = (sortedList.getClosestContactId() === getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor))
         if (selfIsPrimaryStorer) {
             sortedList.addContact(new Contact(newNode))
             const sorted = sortedList.getContactIds()
             // findIndex should never return -1 here because we just added the new node to the list
-            const index = findIndex(sorted, (nodeId) => areEqualNodeIds(nodeId, newNodeId))
+            const index = findIndex(sorted, (nodeId) => (nodeId === newNodeId))
             // if new node is within the storageRedundancyFactor closest nodes to the data
             // do replicate data to it
             if (index < this.config.redundancyFactor) {
@@ -92,8 +89,8 @@ export class StoreManager {
                     await this.replicateDataToContact(dataEntry, newNode)
                 })
             }
-        } else if (!this.selfIsWithinRedundancyFactor(dataEntry.key)) {
-            this.config.localDataStore.setStale(dataEntry.key, getNodeIdFromBinary(dataEntry.creator), true)
+        } else if (!this.selfIsWithinRedundancyFactor(getDhtAddressFromRaw(dataEntry.key))) {
+            this.config.localDataStore.setStale(getDhtAddressFromRaw(dataEntry.key), getDhtAddressFromRaw(dataEntry.creator), true)
         }
     }
 
@@ -106,7 +103,7 @@ export class StoreManager {
         }
     }
 
-    public async storeDataToDht(key: Uint8Array, data: Any, creator: NodeID): Promise<PeerDescriptor[]> {
+    public async storeDataToDht(key: DhtAddress, data: Any, creator: DhtAddress): Promise<PeerDescriptor[]> {
         logger.debug(`Storing data to DHT ${this.config.serviceId}`)
         const result = await this.config.recursiveOperationManager.execute(key, RecursiveOperation.FIND_NODE)
         const closestNodes = result.closestNodes
@@ -116,9 +113,9 @@ export class StoreManager {
         for (let i = 0; i < closestNodes.length && successfulNodes.length < this.config.redundancyFactor; i++) {
             if (areEqualPeerDescriptors(this.config.localPeerDescriptor, closestNodes[i])) {
                 this.config.localDataStore.storeEntry({
-                    key, 
+                    key: getRawFromDhtAddress(key),
                     data,
-                    creator: hexToBinary(creator),
+                    creator: getRawFromDhtAddress(creator),
                     createdAt,
                     storedAt: Timestamp.now(), 
                     ttl, 
@@ -131,9 +128,9 @@ export class StoreManager {
             const rpcRemote = this.config.createRpcRemote(closestNodes[i])
             try {
                 await rpcRemote.storeData({
-                    key,
+                    key: getRawFromDhtAddress(key),
                     data,
-                    creator: hexToBinary(creator),
+                    creator: getRawFromDhtAddress(creator),
                     createdAt,
                     ttl
                 })
@@ -146,22 +143,21 @@ export class StoreManager {
         return successfulNodes
     }
 
-    private selfIsWithinRedundancyFactor(dataKey: Uint8Array): boolean {
+    private selfIsWithinRedundancyFactor(dataKey: DhtAddress): boolean {
         const closestNeighbors = this.config.getClosestNeighborsTo(dataKey, this.config.redundancyFactor)
         if (closestNeighbors.length < this.config.redundancyFactor) {
             return true
         } else {
-            const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
-            const furthestCloseNeighbor = getNodeIdFromPeerDescriptor(closestNeighbors[closestNeighbors.length - 1])
-            const dataId = getNodeIdFromDataKey(dataKey)
-            return getDistance(dataId, localNodeId) < getDistance(dataId, furthestCloseNeighbor)
+            const furthestCloseNeighbor = closestNeighbors[closestNeighbors.length - 1]
+            const dataKeyRaw = getRawFromDhtAddress(dataKey)
+            return getDistance(dataKeyRaw, this.config.localPeerDescriptor.nodeId) < getDistance(dataKeyRaw, furthestCloseNeighbor.nodeId)
         }
     }
 
     private async replicateDataToClosestNodes(): Promise<void> {
         const dataEntries = Array.from(this.config.localDataStore.values())
         await Promise.all(dataEntries.map(async (dataEntry) => {
-            const neighbors = this.config.getClosestNeighborsTo(dataEntry.key, this.config.redundancyFactor)
+            const neighbors = this.config.getClosestNeighborsTo(getDhtAddressFromRaw(dataEntry.key), this.config.redundancyFactor)
             await Promise.all(neighbors.map(async (neighbor) => {
                 const rpcRemote = this.config.createRpcRemote(neighbor)
                 try {
@@ -178,9 +174,9 @@ export class StoreManager {
         const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
         const incomingNodeId = getNodeIdFromPeerDescriptor(incomingPeer)
         // TODO use config option or named constant?
-        const closestToData = this.config.getClosestNeighborsTo(dataEntry.key, 10)
+        const closestToData = this.config.getClosestNeighborsTo(getDhtAddressFromRaw(dataEntry.key), 10)
         const sortedList = new SortedContactList<Contact>({
-            referenceId: getNodeIdFromDataKey(dataEntry.key), 
+            referenceId: getDhtAddressFromRaw(dataEntry.key), 
             maxSize: this.config.redundancyFactor, 
             allowToContainReferenceId: true, 
             emitEvents: false
@@ -189,7 +185,7 @@ export class StoreManager {
         closestToData.forEach((neighbor) => {
             sortedList.addContact(new Contact(neighbor))
         })
-        const selfIsPrimaryStorer = areEqualNodeIds(sortedList.getClosestContactId(), localNodeId)
+        const selfIsPrimaryStorer = (sortedList.getClosestContactId() === localNodeId)
         const targets = selfIsPrimaryStorer
             // if we are the closest to the data, replicate to all storageRedundancyFactor nearest
             ? sortedList.getAllContacts()
@@ -197,7 +193,7 @@ export class StoreManager {
             : [sortedList.getAllContacts()[0]]
         targets.forEach((contact) => {
             const contactNodeId = getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())
-            if (!areEqualNodeIds(incomingNodeId, contactNodeId) && !areEqualNodeIds(localNodeId, contactNodeId)) {
+            if ((incomingNodeId !== contactNodeId) && (localNodeId !== contactNodeId)) {
                 setImmediate(() => {
                     executeSafePromise(async () => {
                         await this.replicateDataToContact(dataEntry, contact.getPeerDescriptor())

package/src/dht/store/StoreRpcLocal.ts

@@ -11,11 +11,12 @@ import {
 import { IStoreRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { LocalDataStore } from './LocalDataStore'
+import { DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
 
 interface StoreRpcLocalConfig {
     localDataStore: LocalDataStore
     replicateDataToNeighbors: (incomingPeer: PeerDescriptor, dataEntry: DataEntry) => void
-    selfIsWithinRedundancyFactor: (key: Uint8Array) => boolean
+    selfIsWithinRedundancyFactor: (key: DhtAddress) => boolean
 }
 
 const logger = new Logger(module)
@@ -30,15 +31,15 @@ export class StoreRpcLocal implements IStoreRpc {
 
     async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
         logger.trace('storeData()')
-        const { key, data, creator, createdAt, ttl } = request
+        const key = getDhtAddressFromRaw(request.key)
         const selfIsOneOfClosestPeers = this.config.selfIsWithinRedundancyFactor(key)
         this.config.localDataStore.storeEntry({ 
-            key, 
-            data,
-            creator, 
-            createdAt,
+            key: request.key,
+            data: request.data,
+            creator: request.creator,
+            createdAt: request.createdAt,
             storedAt: Timestamp.now(),
-            ttl,
+            ttl: request.ttl,
             stale: !selfIsOneOfClosestPeers,
             deleted: false
         })
@@ -55,8 +56,9 @@ export class StoreRpcLocal implements IStoreRpc {
         if (wasStored) {
             this.config.replicateDataToNeighbors((context as DhtCallContext).incomingSourceDescriptor!, request.entry!)
         }
-        if (!this.config.selfIsWithinRedundancyFactor(dataEntry.key)) {
-            this.config.localDataStore.setAllEntriesAsStale(dataEntry.key)
+        const key = getDhtAddressFromRaw(dataEntry.key)
+        if (!this.config.selfIsWithinRedundancyFactor(key)) {
+            this.config.localDataStore.setAllEntriesAsStale(key)
         }
         logger.trace('server-side replicateData() at end')
         return {}

package/src/exports.ts

@@ -19,3 +19,5 @@ export { ManagedConnection } from './connection/ManagedConnection'
 export { ConnectionType } from './connection/IConnection'
 export { PeerID } from './helpers/PeerID'
 export { ServiceID } from './types/ServiceID'
+export { DhtAddress, DhtAddressRaw, getDhtAddressFromRaw, getRawFromDhtAddress } from './identifiers'
+export { getNodeIdFromPeerDescriptor } from './helpers/peerIdFromPeerDescriptor'

package/src/helpers/AddressTools.ts

@@ -1,10 +1,12 @@
 import ipaddr from 'ipaddr.js'
 
 // IPv4 private address ranges as specified by RFC 1918
+// and private loopback addresses
 const IPv4PrivateRanges = [
     '10.0.0.0/8',
     '172.16.0.0/12',
     '192.168.0.0/16',
+    '127.0.0.0/8'
 ].map((a) => ipaddr.parseCIDR(a))
 
 export function isPrivateIPv4(address: string): boolean {

package/src/helpers/PeerID.ts

@@ -2,7 +2,7 @@ import { BrandedString, binaryToHex } from '@streamr/utils'
 import { UUID } from './UUID'
 import { IllegalArguments } from './errors'
 import crypto from 'crypto'
-import { NodeID, getNodeIdFromBinary } from './nodeId'
+import { DhtAddress, getDhtAddressFromRaw } from '../identifiers'
 
 export type PeerIDKey = BrandedString<'PeerIDKey'>
 
@@ -69,15 +69,15 @@ export class PeerID {
     }
 
     toString(): string {
-        return PeerID.textDecoder.decode(this.data) //utf8ArrayToString(this.data)
+        return PeerID.textDecoder.decode(this.data)
     }
 
     toKey(): PeerIDKey {
         return this.key
     }
 
-    toNodeId(): NodeID {
-        return getNodeIdFromBinary(this.data)
+    toNodeId(): DhtAddress {
+        return getDhtAddressFromRaw(this.data)
     }
 
     get value(): Uint8Array {

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -1,7 +1,7 @@
-import { areEqualBinaries, binaryToHex } from '@streamr/utils'
+import { areEqualBinaries } from '@streamr/utils'
 import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { PeerID, PeerIDKey, createPeerIDKey } from './PeerID'
-import { NodeID } from './nodeId'
+import { DhtAddress, getDhtAddressFromRaw } from '../identifiers'
 
 export const peerIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerID => {
     return PeerID.fromValue(peerDescriptor.nodeId)
@@ -9,8 +9,8 @@ export const peerIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerID
 
 // TODO could use this in trackerless-network (instead of copy-pasted same implementation)
 // and move this to nodeId.ts
-export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): NodeID => {
-    return binaryToHex(peerDescriptor.nodeId) as unknown as NodeID
+export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): DhtAddress => {
+    return getDhtAddressFromRaw(peerDescriptor.nodeId)
 }
 
 export const keyFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerIDKey => {

package/src/identifiers.ts

@@ -0,0 +1,20 @@
+import { BrandedString, binaryToHex, hexToBinary } from '@streamr/utils'
+import crypto from 'crypto'
+
+// https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
+const KADEMLIA_ID_LENGTH_IN_BYTES = 20
+
+export type DhtAddress = BrandedString<'DhtAddress'>
+export type DhtAddressRaw = Uint8Array
+
+export const getDhtAddressFromRaw = (raw: DhtAddressRaw): DhtAddress => {
+    return binaryToHex(raw) as unknown as DhtAddress
+}
+
+export const getRawFromDhtAddress = (address: DhtAddress): DhtAddressRaw => {
+    return hexToBinary(address) as unknown as DhtAddressRaw
+}
+
+export const createRandomDhtAddress = (): DhtAddress => {
+    return getDhtAddressFromRaw(crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES))
+}

package/test/RandomGraphSimulation.ts

@@ -2,13 +2,14 @@
 
 import KBucket from 'k-bucket'
 import { range } from 'lodash'
+import { DhtAddressRaw } from '../src/identifiers'
 
-const compareIds = (id1: Uint8Array, id2: Uint8Array) => {
+const compareIds = (id1: DhtAddressRaw, id2: DhtAddressRaw) => {
     const sorted = [id1, id2].sort()
     return KBucket.distance(sorted[0], sorted[1])
 }
 
-const generateIDs = (count: number): Uint8Array[] => {
+const generateIDs = (count: number): DhtAddressRaw[] => {
     return range(count).map((i) => new Uint8Array([i, 1, 1]))
 }
 

package/test/benchmark/Find.test.ts

@@ -9,6 +9,7 @@ import { PeerID } from '../../src/helpers/PeerID'
 import { getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger, wait } from '@streamr/utils'
 import { debugVars } from '../../src/helpers/debugHelpers'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
@@ -28,10 +29,10 @@ describe('Find correctness', () => {
     beforeEach(async () => {
 
         nodes = []
-        entryPoint = await createMockConnectionDhtNode(simulator, Uint8Array.from(dhtIds[0].data), undefined)
+        entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[0].data)), undefined)
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, Uint8Array.from(dhtIds[i].data), undefined)
+            const node = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)), undefined)
             nodes.push(node)
         }
     })
@@ -65,7 +66,7 @@ describe('Find correctness', () => {
 
         logger.info('starting find')
         const targetId = Uint8Array.from(dhtIds[9].data)
-        const results = await nodes[159].executeRecursiveOperation(targetId, RecursiveOperation.FIND_NODE)
+        const results = await nodes[159].executeRecursiveOperation(getDhtAddressFromRaw(targetId), RecursiveOperation.FIND_NODE)
         logger.info('find over')
         expect(results.closestNodes).toBeGreaterThanOrEqual(5)
         expect(PeerID.fromValue(targetId).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))

package/test/benchmark/KademliaCorrectness.test.ts

@@ -5,7 +5,7 @@ import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDes
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { NodeID } from '../../src/helpers/nodeId'
+import { DhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
 
 describe('Kademlia correctness', () => {
     let entryPoint: DhtNode
@@ -13,7 +13,7 @@ describe('Kademlia correctness', () => {
     const simulator = new Simulator()
     const NUM_NODES = 1000
 
-    const nodeIndicesById: Record<NodeID, number> = {}
+    const nodeIndicesById: Record<DhtAddress, number> = {}
 
     if (!fs.existsSync('test/data/nodeids.json')) {
         console.log('gound truth data does not exist yet, generating..')
@@ -27,12 +27,12 @@ describe('Kademlia correctness', () => {
     beforeEach(async () => {
 
         nodes = []
-        entryPoint = await createMockConnectionDhtNode(simulator, Uint8Array.from(dhtIds[0].data), 8)
+        entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(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, Uint8Array.from(dhtIds[i].data))
+            const node = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)))
             nodeIndicesById[node.getNodeId()] = i
             nodes.push(node)
         }

package/test/benchmark/SortedContactListBenchmark.test.ts

@@ -3,19 +3,20 @@
 import KBucket from 'k-bucket'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import crypto from 'crypto'
-import { NodeID, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { DhtAddress, DhtAddressRaw, getDhtAddressFromRaw } from '../../src/identifiers'
 
 const NUM_ADDS = 1000
+
 interface Item {
-    id: Uint8Array
+    id: DhtAddressRaw
     vectorClock: number
-    getNodeId: () => NodeID
+    getNodeId: () => DhtAddress
 }
 
 const createRandomItem = (index: number): Item => {
     const rand = new Uint8Array(crypto.randomBytes(20))
     return {
-        getNodeId: () => getNodeIdFromBinary(rand),
+        getNodeId: () => getDhtAddressFromRaw(rand),
         id: rand,
         vectorClock: index
     }
@@ -37,7 +38,7 @@ describe('SortedContactListBenchmark', () => {
             randomIds.push(createRandomItem(i))
         }
         const list = new SortedContactList({
-            referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+            referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
             allowToContainReferenceId: true,
             emitEvents: true
         })
@@ -49,7 +50,7 @@ describe('SortedContactListBenchmark', () => {
         console.timeEnd('SortedContactList.addContact() with emitEvents=true')
 
         const list2 = new SortedContactList({
-            referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+            referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
             allowToContainReferenceId: true,
             emitEvents: false
         })
@@ -83,13 +84,13 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=true')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: true
             })
 
             const arrayFromBucket = kBucket.toArray()
-            arrayFromBucket.map((contact) => closest.addContact(contact))
+            arrayFromBucket.forEach((contact) => closest.addContact(contact))
             closest.getClosestContacts(20)
         }
         console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=true')
@@ -97,13 +98,13 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=false')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
 
             const arrayFromBucket = kBucket.toArray()
-            arrayFromBucket.map((contact) => closest.addContact(contact))
+            arrayFromBucket.forEach((contact) => closest.addContact(contact))
             closest.getClosestContacts(20)
         }
         console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false')
@@ -111,13 +112,13 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
 
             const arrayFromBucket = kBucket.toArray()
-            arrayFromBucket.map((contact) => closest.addContact(contact))
+            arrayFromBucket.forEach((contact) => closest.addContact(contact))
             closest.getClosestContacts(20)
         }
         console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
@@ -125,7 +126,7 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=false and addContacts()')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
@@ -141,7 +142,7 @@ describe('SortedContactListBenchmark', () => {
         for (let i = 0; i < NUM_ADDS; i++) {
             const bucket2 = new KBucket<Item>({ localNodeId: crypto.randomBytes(20) })
 
-            shuffled.map((contact) => bucket2.add(contact))
+            shuffled.forEach((contact) => bucket2.add(contact))
             bucket2.closest(crypto.randomBytes(20), 20)
         }
         console.timeEnd('kbucket add and closest')

package/test/benchmark/kademlia-simulation/Contact.ts

@@ -1,32 +1,31 @@
 import type { SimulationNode } from './SimulationNode'
 import { NodeType, PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
-import { NodeID } from '../../../src/helpers/nodeId'
-import { hexToBinary } from '@streamr/utils'
+import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../../../src/identifiers'
 
 export class Contact {
     private static counter = 0
 
-    public ownId: NodeID
-    public id: Uint8Array
+    public ownId: DhtAddress
+    public id: DhtAddressRaw
     public vectorClock = 0
     public dhtNode: SimulationNode | undefined
 
-    constructor(ownId: NodeID, dhtNode?: SimulationNode) {
+    constructor(ownId: DhtAddress, dhtNode?: SimulationNode) {
         this.ownId = ownId
         this.vectorClock = Contact.counter++
         this.dhtNode = dhtNode
-        this.id = hexToBinary(ownId)
+        this.id = getRawFromDhtAddress(ownId)
     }
 
     getPeerDescriptor(): PeerDescriptor {
         const peerDescriptor: PeerDescriptor = {
-            nodeId: hexToBinary(this.ownId),
+            nodeId: getRawFromDhtAddress(this.ownId),
             type: NodeType.NODEJS
         }
         return peerDescriptor
     }
 
-    getNodeId(): NodeID {
+    getNodeId(): DhtAddress {
         return this.ownId
     }