@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/src/proto/packages/proto-rpc/protos/ProtoRpc.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/proto-rpc/protos/ProtoRpc.proto" (package "protorpc", syntax proto3)
 // tslint:disable
 import { MessageType } from "@protobuf-ts/runtime";

package/src/rpc-protocol/DhtCallContext.ts

@@ -6,9 +6,9 @@ export class DhtCallContext extends ProtoCallContext implements DhtRpcOptions {
     // used by client
     targetDescriptor?: PeerDescriptor
     sourceDescriptor?: PeerDescriptor
-    notification?: boolean
     clientId?: number
-    doNotConnect?: boolean 
+    connect?: boolean
+    sendIfStopped?: boolean
     //used in incoming calls
     incomingSourceDescriptor?: PeerDescriptor
 }

package/src/rpc-protocol/DhtRpcOptions.ts

@@ -5,5 +5,6 @@ export interface DhtRpcOptions extends ProtoRpcOptions {
     targetDescriptor?: PeerDescriptor
     sourceDescriptor?: PeerDescriptor
     clientId?: number
-    doNotConnect?: boolean
+    connect?: boolean
+    sendIfStopped?: boolean
 }

package/src/transport/ITransport.ts

@@ -4,7 +4,16 @@ export interface TransportEvents {
     disconnected: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => void
     message: (message: Message) => void
     connected: (peerDescriptor: PeerDescriptor) => void
+}
+
+export interface SendOptions {
+    connect: boolean
+    sendIfStopped: boolean
+}
 
+export const DEFAULT_SEND_OPTIONS = {
+    connect: true,
+    sendIfStopped: false
 }
 
 export interface ITransport {
@@ -21,8 +30,8 @@ export interface ITransport {
     off<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
     off<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => void): void
 
-    send(msg: Message, doNotConnect?: boolean): Promise<void>
+    send(msg: Message, opts?: SendOptions): Promise<void>
     getLocalPeerDescriptor(): PeerDescriptor
-    getAllConnectionPeerDescriptors(): PeerDescriptor[]
+    getConnections(): PeerDescriptor[]
     stop(): void | Promise<void>
 }

package/src/transport/ListeningRpcCommunicator.ts

@@ -9,7 +9,7 @@ export class ListeningRpcCommunicator extends RoutingRpcCommunicator {
     private readonly listener: (msg: Message) => void
 
     constructor(ownServiceId: ServiceID, transport: ITransport, config?: RpcCommunicatorConfig) {
-        super(ownServiceId, transport.send, config)
+        super(ownServiceId, (msg, opts) => transport.send(msg, opts), config)
         this.listener = (msg: Message) => {
             this.handleMessageFromPeer(msg)
         }

package/src/transport/RoutingRpcCommunicator.ts

@@ -1,17 +1,18 @@
-import { Message, MessageType, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { Message, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { v4 } from 'uuid'
 import { RpcCommunicator, RpcCommunicatorConfig } from '@streamr/proto-rpc'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 import { RpcMessage } from '../proto/packages/proto-rpc/protos/ProtoRpc'
 import { ServiceID } from '../types/ServiceID'
+import { DEFAULT_SEND_OPTIONS, SendOptions } from './ITransport'
 
-export class RoutingRpcCommunicator extends RpcCommunicator {
+export class RoutingRpcCommunicator extends RpcCommunicator<DhtCallContext> {
     private ownServiceId: ServiceID
-    private sendFn: (msg: Message, doNotConnect?: boolean, doNotMindStopped?: boolean) => Promise<void>
+    private sendFn: (msg: Message, opts: SendOptions) => Promise<void>
 
     constructor(
         ownServiceId: ServiceID,
-        sendFn: (msg: Message, doNotConnect?: boolean) => Promise<void>,
+        sendFn: (msg: Message, opts: SendOptions) => Promise<void>,
         config?: RpcCommunicatorConfig
     ) {
         super(config)
@@ -34,25 +35,31 @@ export class RoutingRpcCommunicator extends RpcCommunicator {
                     oneofKind: 'rpcMessage',
                     rpcMessage: msg
                 },
-                messageType: MessageType.RPC, 
                 targetDescriptor
             }
 
-            if (msg.header.response || callContext && callContext.doNotConnect && callContext.doNotMindStopped ) {
-                return this.sendFn(message, true, true)
-            } else if (msg.header.response || callContext && callContext.doNotConnect) {
-                return this.sendFn(message, true)
-            } else {
-                return this.sendFn(message)
-            }
-
+            // TODO maybe sendOptions could be a separate block inside callContext
+            const sendOpts = (msg.header.response !== undefined)
+                ? {
+                    // typically we already have a connection, but if it has disconnected for some reason
+                    // the receiver could have gone offline (or it is no longer a neighbor) and therefore there
+                    // is no point in trying form a new connection
+                    connect: false,
+                    // TODO maybe this options could be removed?
+                    sendIfStopped: true
+                } : {
+                    connect: callContext?.connect ?? DEFAULT_SEND_OPTIONS.connect,
+                    sendIfStopped: callContext?.sendIfStopped ?? DEFAULT_SEND_OPTIONS.sendIfStopped
+                }
+            return this.sendFn(message, sendOpts)
         })
     }
 
     public handleMessageFromPeer(message: Message): void {
-        if (message.serviceId == this.ownServiceId && message.body.oneofKind === 'rpcMessage') {
+        if (message.serviceId === this.ownServiceId && message.body.oneofKind === 'rpcMessage') {
             const context = new DhtCallContext()
             context.incomingSourceDescriptor = message.sourceDescriptor
+            // TODO should we have some handling for this floating promise?
             this.handleIncomingMessage(message.body.rpcMessage, context)
         }
     }

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

@@ -1,26 +1,21 @@
 /* eslint-disable no-console */
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-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, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
 describe('Find correctness', () => {
     let entryPoint: DhtNode
     let nodes: DhtNode[]
-    let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.NONE)
     const NUM_NODES = 1000
 
-    const nodeIndicesById: Record<string, number> = {}
-
     if (!fs.existsSync('test/data/nodeids.json')) {
         console.log('ground truth data does not exist yet, generating..')
         execSync('npm run prepare-kademlia-simulation')
@@ -31,20 +26,10 @@ describe('Find correctness', () => {
     beforeEach(async () => {
 
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), undefined)
-        nodes.push(entryPoint)
-        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[0].data)), undefined)
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-
-            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data), undefined)
-            nodeIndicesById[node.getNodeId().toKey()] = i
+            const node = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)), undefined)
             nodes.push(node)
         }
     })
@@ -57,10 +42,10 @@ describe('Find correctness', () => {
     })
 
     it('Entrypoint can find a node from the network (exact match)', async () => {
-        await entryPoint.joinDht([entrypointDescriptor])
+        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
 
         await Promise.all(
-            nodes.map((node) => node.joinDht([entrypointDescriptor]))
+            nodes.map((node) => node.joinDht([entryPoint.getLocalPeerDescriptor()]))
         )
 
         logger.info('waiting 120s')
@@ -71,17 +56,17 @@ describe('Find correctness', () => {
         logger.info('waiting over')
 
         nodes.forEach((node) => logger.info(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ': connections:' +
-            node.getNumberOfConnections() + ', kbucket: ' + node.getBucketSize()
-            + ', localLocked: ' + node.getNumberOfLocalLockedConnections()
-            + ', remoteLocked: ' + node.getNumberOfRemoteLockedConnections()
-            + ', weakLocked: ' + node.getNumberOfWeakLockedConnections()))
+            node.getConnectionCount() + ', kbucket: ' + node.getNeighborCount()
+            + ', localLocked: ' + node.getLocalLockedConnectionCount()
+            + ', remoteLocked: ' + node.getRemoteLockedConnectionCount()
+            + ', weakLocked: ' + node.getWeakLockedConnectionCount()))
 
         logger.info('starting find')
-        const kademliaIdToFind = Uint8Array.from(dhtIds[9].data)
-        const results = await nodes[159].startFind(kademliaIdToFind)
+        const targetId = Uint8Array.from(dhtIds[9].data)
+        const closestNodes = await nodes[159].findClosestNodesFromDht(getDhtAddressFromRaw(targetId))
         logger.info('find over')
-        expect(results.closestNodes).toBeGreaterThanOrEqual(5)
-        expect(PeerID.fromValue(kademliaIdToFind).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
+        expect(closestNodes).toBeGreaterThanOrEqual(5)
+        expect(getDhtAddressFromRaw(targetId)).toEqual(getNodeIdFromPeerDescriptor(closestNodes[0]))
 
     }, 180000)
 })

package/test/benchmark/KademliaCorrectness.test.ts

@@ -1,21 +1,21 @@
 /* eslint-disable no-console */
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerID } from '../../src/helpers/PeerID'
-import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
+import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { Logger } from '@streamr/utils'
+
+const logger = new Logger(module)
 
 describe('Kademlia correctness', () => {
     let entryPoint: DhtNode
     let nodes: DhtNode[]
-    let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator()
-    const NUM_NODES = 1000
+    const NUM_NODES = 200
 
-    const nodeIndicesById: Record<string, number> = {}
+    const nodeIndicesById: Record<DhtAddress, number> = {}
 
     if (!fs.existsSync('test/data/nodeids.json')) {
         console.log('gound truth data does not exist yet, generating..')
@@ -27,22 +27,14 @@ describe('Kademlia correctness', () => {
         = JSON.parse(fs.readFileSync('test/data/orderedneighbors.json').toString())
 
     beforeEach(async () => {
-
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), 8)
+        entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[0].data)), 8)
         nodes.push(entryPoint)
-        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        nodeIndicesById[entryPoint.getNodeId()] = 0
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-
-            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data))
-            nodeIndicesById[node.getNodeId().toKey()] = i
+            const node = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)))
+            nodeIndicesById[node.getNodeId()] = i
             nodes.push(node)
         }
     })
@@ -50,16 +42,20 @@ describe('Kademlia correctness', () => {
     afterEach(async () => {
         await Promise.all([
             entryPoint.stop(),
-            ...nodes.map(async (node) => await node.stop())
+            ...nodes.map((node) => node.stop())
         ])
     })
 
     it('Can find correct neighbors', async () => {
-        await entryPoint.joinDht([entrypointDescriptor])
+        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
 
-        await Promise.allSettled(
-            nodes.map((node) => node.joinDht([entrypointDescriptor]))
-        )
+        for (let i = 1; i < NUM_NODES; i++) {
+            // time to join the network
+            const startTimestamp = Date.now()
+            await nodes[i].joinDht([entryPoint.getLocalPeerDescriptor()])
+            const endTimestamp = Date.now()
+            logger.info('Node ' + i + ' joined in ' + (endTimestamp - startTimestamp) + ' ms')  
+        }
 
         let minimumCorrectNeighbors = Number.MAX_SAFE_INTEGER
         let sumCorrectNeighbors = 0
@@ -72,17 +68,17 @@ describe('Kademlia correctness', () => {
                 groundTruthString += groundTruth[i + ''][j].name + ','
             }
 
-            const kademliaNeighbors = nodes[i].getClosestContacts().map((p) => PeerID.fromValue(p.kademliaId))
+            const kademliaNeighbors = nodes[i].getClosestContacts(8).map((p) => getNodeIdFromPeerDescriptor(p))
 
             let kadString = 'kademliaNeighbors: '
             kademliaNeighbors.forEach((neighbor) => {
-                kadString += nodeIndicesById[neighbor.toKey()] + ','
+                kadString += nodeIndicesById[neighbor] + ','
             })
 
             let correctNeighbors = 0
             try {
                 for (let j = 0; j < groundTruth[i + ''].length; j++) {
-                    if (groundTruth[i + ''][j].name != (nodeIndicesById[kademliaNeighbors[j].toKey()] + '')) {
+                    if (groundTruth[i + ''][j].name != (nodeIndicesById[kademliaNeighbors[j]] + '')) {
                         break
                     }
                     correctNeighbors++
@@ -102,7 +98,7 @@ describe('Kademlia correctness', () => {
             }
 
             if (i > 0) {
-                sumKbucketSize += nodes[i].getBucketSize()
+                sumKbucketSize += nodes[i].getNeighborCount()
                 sumCorrectNeighbors += correctNeighbors
             }
         }
@@ -114,5 +110,5 @@ describe('Kademlia correctness', () => {
         console.log('Minimum correct neighbors: ' + minimumCorrectNeighbors)
         console.log('Average correct neighbors: ' + avgCorrectNeighbors)
         console.log('Average Kbucket size: ' + avgKbucketSize)
-    })
+    }, 120000)
 })

package/test/benchmark/RingCorrectness.test.ts

@@ -0,0 +1,157 @@
+/* eslint-disable no-console */
+import { Simulator } from '../../src/connection/simulator/Simulator'
+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 { Logger } from '@streamr/utils'
+import { getRingIdRawFromPeerDescriptor } from '../../src/dht/contact/ringIdentifiers'
+
+const logger = new Logger(module)
+
+describe('Ring correctness', () => {
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    const simulator = new Simulator()
+
+    const NUM_NODES = 900
+    const nodeIndicesById: Record<DhtAddress, number> = {}
+
+    const regions: Array<number> = []
+    for (let i = 0; i < (NUM_NODES + 1); i++) {
+        regions.push(i)
+    }
+
+    // Shuffle the regions
+    for (let i = regions.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1))
+        const temp = regions[i]
+        regions[i] = regions[j]
+        regions[j] = temp
+    }
+
+    if (!fs.existsSync('test/data/nodeids.json')) {
+        console.log('gound truth data does not exist yet, generating..')
+        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> } }>>
+        = 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])
+        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])
+            nodeIndicesById[node.getNodeId()] = i
+            nodes.push(node)
+        }
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            entryPoint.stop(),
+            ...nodes.map((node) => node.stop())
+        ])
+    })
+
+    it('Can find correct neighbors', async () => {
+        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
+
+        //await Promise.all(
+        //    nodes.map((node) => node.joinDht([entryPoint.getLocalPeerDescriptor()]))
+        //)
+
+        for (let i = 1; i < NUM_NODES; i++) {
+            // time to join the network
+            const startTimestamp = Date.now()
+            await nodes[i].joinDht([entryPoint.getLocalPeerDescriptor()])
+            const endTimestamp = Date.now()
+            logger.info('Node ' + i + ' joined in ' + (endTimestamp - startTimestamp) + ' ms')
+            const ringStartTimestamp = Date.now()
+            await nodes[i].joinRing()
+            const ringEndTimestamp = Date.now()
+            logger.info('Node ' + i + ' joined ring in ' + (ringEndTimestamp - ringStartTimestamp) + ' ms')
+
+        }
+
+        /*
+        for (let i = 1; i < NUM_NODES; i++) {
+            // time to join the network
+            const ringStartTimestamp = Date.now()
+            await nodes[i].joinRing()
+            const ringEndTimestamp = Date.now()
+            logger.info('Node ' + i + ' joined ring in ' + (ringEndTimestamp - ringStartTimestamp) + ' ms')  
+        }*/
+
+        for (let i = 1; i < NUM_NODES; i++) {
+            logger.info('Node ' + i + ', own region: ' + nodes[i].getLocalPeerDescriptor().region
+                + '. Regions of closest ring peers, left: '
+                + nodes[i].getClosestRingContactsTo(
+                    getRingIdRawFromPeerDescriptor(nodes[i].getLocalPeerDescriptor()), 10).left.map((p) => p.region)
+                + ', right: ' + nodes[i].getClosestRingContactsTo(getRingIdRawFromPeerDescriptor(
+                nodes[i].getLocalPeerDescriptor()), 10).right.map((p) => p.region)
+            )
+        }
+
+        let minimumCorrectNeighbors = Number.MAX_SAFE_INTEGER
+        let sumCorrectNeighbors = 0
+        let sumKbucketSize = 1
+
+        for (let i = nodes.length - 1; i >= 0; i--) {
+            let groundTruthString = 'groundTruthNeighb: '
+            // eslint-disable-next-line @typescript-eslint/prefer-for-of
+            for (let j = 0; j < groundTruth[i + ''].length; j++) {
+                groundTruthString += groundTruth[i + ''][j].name + ','
+            }
+
+            const kademliaNeighbors = nodes[i].getClosestContacts(8).map((p) => getNodeIdFromPeerDescriptor(p))
+
+            let kadString = 'kademliaNeighbors: '
+            kademliaNeighbors.forEach((neighbor) => {
+                kadString += nodeIndicesById[neighbor] + ','
+            })
+
+            let correctNeighbors = 0
+            try {
+                for (let j = 0; j < groundTruth[i + ''].length; j++) {
+                    if (groundTruth[i + ''][j].name != (nodeIndicesById[kademliaNeighbors[j]] + '')) {
+                        break
+                    }
+                    correctNeighbors++
+                }
+            } catch (e) {
+                console.error('Node ' + getNodeIdFromPeerDescriptor(nodes[i].getLocalPeerDescriptor()) + ' had only '
+                    + kademliaNeighbors.length + ' kademlia neighbors')
+            }
+            if (correctNeighbors === 0) {
+                console.log('No correct neighbors found for node ' + i)
+                console.log(groundTruthString)
+                console.log(kadString)
+            }
+            if (correctNeighbors < minimumCorrectNeighbors) {
+                console.log('NEW MIN', i, correctNeighbors)
+                minimumCorrectNeighbors = correctNeighbors
+            }
+
+            if (i > 0) {
+                sumKbucketSize += nodes[i].getNeighborCount()
+                sumCorrectNeighbors += correctNeighbors
+            }
+        }
+
+        const avgKbucketSize = sumKbucketSize / (NUM_NODES - 1)
+        const avgCorrectNeighbors = sumCorrectNeighbors / (NUM_NODES - 1)
+
+        console.log('----------- Simulation results ------------------')
+        console.log('Minimum correct neighbors: ' + minimumCorrectNeighbors)
+        console.log('Average correct neighbors: ' + avgCorrectNeighbors)
+        console.log('Average Kbucket size: ' + avgKbucketSize)
+    }, 240000)
+})

package/test/benchmark/SortedContactListBenchmark.test.ts

@@ -0,0 +1,151 @@
+/* eslint-disable no-console */
+
+import KBucket from 'k-bucket'
+import { SortedContactList } from '../../src/dht/contact/SortedContactList'
+import { DhtAddress, DhtAddressRaw, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+
+const NUM_ADDS = 1000
+
+interface Item {
+    id: DhtAddressRaw
+    vectorClock: number
+    getNodeId: () => DhtAddress
+}
+
+const createRandomItem = (index: number): Item => {
+    const nodeId = createRandomDhtAddress()
+    const nodeIdRaw = getRawFromDhtAddress(nodeId)
+    return {
+        getNodeId: () => nodeId,
+        id: nodeIdRaw,
+        vectorClock: index
+    }
+}
+
+function shuffleArray<T>(array: T[]): T[] {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]]
+    }
+    return array
+}
+
+describe('SortedContactListBenchmark', () => {
+
+    it('adds ' + NUM_ADDS + ' random nodeIds', async () => {
+        const randomIds = []
+        for (let i = 0; i < NUM_ADDS; i++) {
+            randomIds.push(createRandomItem(i))
+        }
+        const list = new SortedContactList({
+            referenceId: createRandomDhtAddress(),
+            allowToContainReferenceId: true,
+            emitEvents: true
+        })
+
+        console.time('SortedContactList.addContact() with emitEvents=true')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            list.addContact(randomIds[i])
+        }
+        console.timeEnd('SortedContactList.addContact() with emitEvents=true')
+
+        const list2 = new SortedContactList({
+            referenceId: createRandomDhtAddress(),
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
+
+        console.time('SortedContactList.addContact() with emitEvents=false')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            list2.addContact(randomIds[i])
+        }
+        console.timeEnd('SortedContactList.addContact() with emitEvents=false')
+
+        const kBucket = new KBucket<Item>({ localNodeId: getRawFromDhtAddress(createRandomDhtAddress()) })
+        console.time('KBucket.add()')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            kBucket.add(randomIds[i])
+        }
+        console.timeEnd('KBucket.add()')
+
+        console.time('kBucket toArray()')
+
+        for (let i = 0; i < NUM_ADDS; i++) {
+            kBucket.toArray()
+        }
+        console.timeEnd('kBucket toArray()')
+
+        console.time('kBucket closest()')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            kBucket.closest(getRawFromDhtAddress(createRandomDhtAddress()), 20)
+        }
+        console.timeEnd('kBucket closest()')
+
+        console.time('SortedContactList.getClosestContacts() with emitEvents=true')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            const closest = new SortedContactList<Item>({
+                referenceId: createRandomDhtAddress(),
+                allowToContainReferenceId: true,
+                emitEvents: true
+            })
+
+            const arrayFromBucket = kBucket.toArray()
+            arrayFromBucket.forEach((contact) => closest.addContact(contact))
+            closest.getClosestContacts(20)
+        }
+        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=true')
+
+        console.time('SortedContactList.getClosestContacts() with emitEvents=false')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            const closest = new SortedContactList<Item>({
+                referenceId: createRandomDhtAddress(),
+                allowToContainReferenceId: true,
+                emitEvents: false
+            })
+
+            const arrayFromBucket = kBucket.toArray()
+            arrayFromBucket.forEach((contact) => closest.addContact(contact))
+            closest.getClosestContacts(20)
+        }
+        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false')
+
+        console.time('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            const closest = new SortedContactList<Item>({
+                referenceId: createRandomDhtAddress(),
+                allowToContainReferenceId: true,
+                emitEvents: false
+            })
+
+            const arrayFromBucket = kBucket.toArray()
+            arrayFromBucket.forEach((contact) => closest.addContact(contact))
+            closest.getClosestContacts(20)
+        }
+        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
+
+        console.time('SortedContactList.getClosestContacts() with emitEvents=false and addContacts()')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            const closest = new SortedContactList<Item>({
+                referenceId: createRandomDhtAddress(),
+                allowToContainReferenceId: true,
+                emitEvents: false
+            })
+
+            const arrayFromBucket = kBucket.toArray()
+            closest.addContacts(arrayFromBucket)
+            closest.getClosestContacts(20)
+        }
+        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false and addContacts()')
+
+        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()) })
+
+            shuffled.forEach((contact) => bucket2.add(contact))
+            bucket2.closest(getRawFromDhtAddress(createRandomDhtAddress()), 20)
+        }
+        console.timeEnd('kbucket add and closest')
+
+    })
+})