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

package/src/dht/routing/RoutingSession.ts

@@ -12,7 +12,7 @@ import { Contact } from '../contact/Contact'
 import { RecursiveOperationRpcRemote } from '../recursive-operation/RecursiveOperationRpcRemote'
 import { EXISTING_CONNECTION_TIMEOUT } from '../contact/RpcRemote'
 import { getPreviousPeer } from './getPreviousPeer'
-import { NodeID, getNodeIdFromBinary } from '../../helpers/nodeId'
+import { DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -28,7 +28,6 @@ class RemoteContact extends Contact {
         this.routerRpcRemote = new RouterRpcRemote(
             localPeerDescriptor,
             peer.getPeerDescriptor(),
-            peer.getServiceId(),
             rpcCommunicator,
             RouterRpcClient,
             EXISTING_CONNECTION_TIMEOUT
@@ -36,7 +35,6 @@ class RemoteContact extends Contact {
         this.recursiveOperationRpcRemote = new RecursiveOperationRpcRemote(
             localPeerDescriptor,
             peer.getPeerDescriptor(),
-            peer.getServiceId(),
             rpcCommunicator,
             RecursiveOperationRpcClient,
             EXISTING_CONNECTION_TIMEOUT
@@ -69,16 +67,16 @@ interface RoutingSessionConfig {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
     routedMessage: RouteMessageWrapper
-    connections: Map<NodeID, DhtNodeRpcRemote>
+    connections: Map<DhtAddress, DhtNodeRpcRemote>
     parallelism: number
     mode: RoutingMode
-    excludedNodeIds?: Set<NodeID>
+    excludedNodeIds?: Set<DhtAddress>
 }
 
 export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     public readonly sessionId = v4()
-    private ongoingRequests: Set<NodeID> = new Set()
+    private ongoingRequests: Set<DhtAddress> = new Set()
     private contactList: SortedContactList<RemoteContact>
     private failedHopCounter = 0
     private successfulHopCounter = 0
@@ -91,7 +89,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         const previousPeer = getPreviousPeer(config.routedMessage)
         const previousId = previousPeer ? getNodeIdFromPeerDescriptor(previousPeer) : undefined
         this.contactList = new SortedContactList({
-            referenceId: getNodeIdFromBinary(config.routedMessage.target),
+            referenceId: getDhtAddressFromRaw(config.routedMessage.target),
             maxSize: 10000,  // TODO use config option or named constant?
             allowToContainReferenceId: true,
             nodeIdDistanceLimit: previousId,
@@ -100,7 +98,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         })
     }
 
-    private onRequestFailed(nodeId: NodeID) {
+    private onRequestFailed(nodeId: DhtAddress) {
         logger.trace('onRequestFailed() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return

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
         }
@@ -48,43 +44,38 @@ export class LocalDataStore {
         return true
     }
 
-    public* values(): IterableIterator<DataEntry> {
-        for (const v of this.store.values()) {
-            yield* v.values()
+    public* values(key?: DhtAddress): IterableIterator<DataEntry> {
+        if (key !== undefined) {
+            const map = this.store.get(key)
+            if (map !== undefined) {
+                yield* map.values()
+            }
+        } else {
+            for (const v of this.store.values()) {
+                yield* v.values()
+            }
         }
     }
 
-    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)
-        })
-        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))
@@ -62,29 +62,27 @@ export class StoreManager {
 
     private replicateAndUpdateStaleState(dataEntry: DataEntry, newNode: PeerDescriptor): void {
         const newNodeId = getNodeIdFromPeerDescriptor(newNode)
+        const key = getDhtAddressFromRaw(dataEntry.key)
         // TODO use config option or named constant?
-        const closestToData = this.config.getClosestNeighborsTo(dataEntry.key, 10)
+        const closestToData = this.config.getClosestNeighborsTo(key, 10)
         const sortedList = new SortedContactList<Contact>({
-            referenceId: getNodeIdFromDataKey(dataEntry.key), 
+            referenceId: 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 +90,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(key)) {
+            this.config.localDataStore.setStale(key, getDhtAddressFromRaw(dataEntry.creator), true)
         }
     }
 
@@ -106,7 +104,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
@@ -114,11 +112,13 @@ export class StoreManager {
         const ttl = this.config.highestTtl // ToDo: make TTL decrease according to some nice curve
         const createdAt = Timestamp.now()
         for (let i = 0; i < closestNodes.length && successfulNodes.length < this.config.redundancyFactor; i++) {
+            const keyRaw = getRawFromDhtAddress(key)
+            const creatorRaw = getRawFromDhtAddress(creator)
             if (areEqualPeerDescriptors(this.config.localPeerDescriptor, closestNodes[i])) {
                 this.config.localDataStore.storeEntry({
-                    key, 
+                    key: keyRaw,
                     data,
-                    creator: hexToBinary(creator),
+                    creator: creatorRaw,
                     createdAt,
                     storedAt: Timestamp.now(), 
                     ttl, 
@@ -131,9 +131,9 @@ export class StoreManager {
             const rpcRemote = this.config.createRpcRemote(closestNodes[i])
             try {
                 await rpcRemote.storeData({
-                    key,
+                    key: keyRaw,
                     data,
-                    creator: hexToBinary(creator),
+                    creator: creatorRaw,
                     createdAt,
                     ttl
                 })
@@ -146,22 +146,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 {
@@ -177,10 +176,11 @@ export class StoreManager {
         // sort own contact list according to data id
         const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
         const incomingNodeId = getNodeIdFromPeerDescriptor(incomingPeer)
+        const key = getDhtAddressFromRaw(dataEntry.key)
         // TODO use config option or named constant?
-        const closestToData = this.config.getClosestNeighborsTo(dataEntry.key, 10)
+        const closestToData = this.config.getClosestNeighborsTo(key, 10)
         const sortedList = new SortedContactList<Contact>({
-            referenceId: getNodeIdFromDataKey(dataEntry.key), 
+            referenceId: key, 
             maxSize: this.config.redundancyFactor, 
             allowToContainReferenceId: true, 
             emitEvents: false
@@ -189,20 +189,20 @@ 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()
             // if we are not the closest node to the data, replicate only to the closest one to the data
             : [sortedList.getAllContacts()[0]]
         targets.forEach((contact) => {
-            const contactNodeId = getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())
-            if (!areEqualNodeIds(incomingNodeId, contactNodeId) && !areEqualNodeIds(localNodeId, contactNodeId)) {
+            const contactNodeId = contact.getNodeId()
+            if ((incomingNodeId !== contactNodeId) && (localNodeId !== contactNodeId)) {
                 setImmediate(() => {
                     executeSafePromise(async () => {
                         await this.replicateDataToContact(dataEntry, contact.getPeerDescriptor())
                         logger.trace('replicateDataToContact() returned', { 
-                            node: getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()),
+                            node: contactNodeId,
                             replicateOnlyToClosest: !selfIsPrimaryStorer
                         })
                     })

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,16 +1,14 @@
-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)
 }
 
-// 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)
         }