@streamr/dht 102.0.0-beta.1 → 102.0.0-beta.2

package/src/identifiers.ts

@@ -1,29 +0,0 @@
-import { BrandedString, areEqualBinaries, binaryToHex, hexToBinary } from '@streamr/utils'
-import crypto from 'crypto'
-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
-
-export type DhtAddress = BrandedString<'DhtAddress'>
-export type DhtAddressRaw = Uint8Array
-
-export const toDhtAddress = (raw: DhtAddressRaw): DhtAddress => {
-    return binaryToHex(raw) as unknown as DhtAddress
-}
-
-export const toDhtAddressRaw = (address: DhtAddress): DhtAddressRaw => {
-    return hexToBinary(address) as unknown as DhtAddressRaw
-}
-
-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 randomDhtAddress = (): DhtAddress => {
-    return toDhtAddress(crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES))
-}

package/src/rpc-protocol/DhtCallContext.ts

@@ -1,14 +0,0 @@
-import { ProtoCallContext } from '@streamr/proto-rpc'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { DhtRpcOptions } from './DhtRpcOptions'
-
-export class DhtCallContext extends ProtoCallContext implements DhtRpcOptions {
-    // used by client
-    targetDescriptor?: PeerDescriptor
-    sourceDescriptor?: PeerDescriptor
-    clientId?: number
-    connect?: boolean
-    sendIfStopped?: boolean
-    //used in incoming calls
-    incomingSourceDescriptor?: PeerDescriptor
-}

package/src/rpc-protocol/DhtRpcOptions.ts

@@ -1,10 +0,0 @@
-import { ProtoRpcOptions } from '@streamr/proto-rpc'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-
-export interface DhtRpcOptions extends ProtoRpcOptions {
-    targetDescriptor?: PeerDescriptor
-    sourceDescriptor?: PeerDescriptor
-    clientId?: number
-    connect?: boolean
-    sendIfStopped?: boolean
-}

package/src/transport/ITransport.ts

@@ -1,37 +0,0 @@
-import { Message, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-
-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 {
-    on<T extends keyof TransportEvents>(eventName: T, listener: (message: Message) => void): void
-    on<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
-    on<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => void): void
-
-    once<T extends keyof TransportEvents>(eventName: T, listener: (message: Message) => void): void
-    once<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void
-    once<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, 
-        gracefulLeave: boolean) => void): void
-
-    off<T extends keyof TransportEvents>(eventName: T, listener: (message: Message) => void): void
-    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, opts?: SendOptions): Promise<void>
-    getLocalPeerDescriptor(): PeerDescriptor
-    stop(): void | Promise<void>
-    getDiagnosticInfo(): Record<string, unknown>
-}

package/src/transport/ListeningRpcCommunicator.ts

@@ -1,32 +0,0 @@
-import { ITransport } from './ITransport' 
-import { RoutingRpcCommunicator } from './RoutingRpcCommunicator'
-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 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.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.messageListener) 
-        transport.on('disconnected', this.disconnectedListener)
-    }
-
-    destroy(): void {
-        this.transport.off('message', this.messageListener)
-        this.transport.off('disconnected', this.disconnectedListener)
-        this.stop()
-    }
-}

package/src/transport/RoutingRpcCommunicator.ts

@@ -1,66 +0,0 @@
-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 '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { ServiceID } from '../types/ServiceID'
-import { DEFAULT_SEND_OPTIONS, SendOptions } from './ITransport'
-
-export class RoutingRpcCommunicator extends RpcCommunicator<DhtCallContext> {
-    private ownServiceId: ServiceID
-    private sendFn: (msg: Message, opts: SendOptions) => Promise<void>
-
-    constructor(
-        ownServiceId: ServiceID,
-        sendFn: (msg: Message, opts: SendOptions) => Promise<void>,
-        options?: RpcCommunicatorOptions
-    ) {
-        super(options)
-        this.ownServiceId = ownServiceId
-        this.sendFn = sendFn
-
-        this.setOutgoingMessageListener((msg: RpcMessage, _requestId: string, callContext?: DhtCallContext) => {
-            let targetDescriptor: PeerDescriptor
-            // rpc call message
-            if (callContext!.targetDescriptor) {
-                targetDescriptor = callContext!.targetDescriptor!
-            } else { // rpc reply message
-                targetDescriptor = callContext!.incomingSourceDescriptor!
-            }
-
-            const message: Message = {
-                messageId: v4(), 
-                serviceId: this.ownServiceId, 
-                body: {
-                    oneofKind: 'rpcMessage',
-                    rpcMessage: msg
-                },
-                targetDescriptor
-            }
-
-            // 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') {
-            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/src/types/ServiceID.ts

@@ -1 +0,0 @@
-export type ServiceID = string

package/src/types/textencoding.d.ts

@@ -1,6 +0,0 @@
-import { TextEncoder as _TextEncoder, TextDecoder as _TextDecoder } from 'node:util'
-
-declare global {
-    const TextEncoder: typeof _TextEncoder
-    const TextDecoder: typeof _TextDecoder
-}

package/test/benchmark/Find.test.ts

@@ -1,72 +0,0 @@
-/* eslint-disable no-console */
-import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { createMockConnectionDhtNode } from '../utils/utils'
-import { execSync } from 'child_process'
-import fs from 'fs'
-import { Logger, wait } from '@streamr/utils'
-import { debugVars } from '../../src/helpers/debugHelpers'
-import { toDhtAddress, toNodeId } from '../../src/identifiers'
-
-const logger = new Logger(module)
-
-describe('Find correctness', () => {
-    let entryPoint: DhtNode
-    let nodes: DhtNode[]
-    const simulator = new Simulator(LatencyType.NONE)
-    const NUM_NODES = 1000
-
-    if (!fs.existsSync('test/data/nodeids.json')) {
-        console.log('ground truth data does not exist yet, generating..')
-        execSync('npm run prepare-kademlia-simulation')
-    }
-
-    const dhtIds: { type: string, data: number[] }[] = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
-
-    beforeEach(async () => {
-
-        nodes = []
-        entryPoint = await createMockConnectionDhtNode(simulator, toDhtAddress(Uint8Array.from(dhtIds[0].data)), undefined)
-
-        for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, toDhtAddress(Uint8Array.from(dhtIds[i].data)), undefined)
-            nodes.push(node)
-        }
-    })
-
-    afterEach(async () => {
-        await Promise.all([
-            entryPoint.stop(),
-            ...nodes.map(async (node) => await node.stop())
-        ])
-    })
-
-    it('Entrypoint can find a node from the network (exact match)', async () => {
-        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
-
-        await Promise.all(
-            nodes.map((node) => node.joinDht([entryPoint.getLocalPeerDescriptor()]))
-        )
-
-        logger.info('waiting 120s')
-        debugVars.waiting = true
-
-        await wait(120000)
-        debugVars.waiting = false
-        logger.info('waiting over')
-
-        nodes.forEach((node) => logger.info(toNodeId(node.getLocalPeerDescriptor()) + ': connections:' +
-            node.getConnectionsView().getConnectionCount() + ', kbucket: ' + node.getNeighborCount()
-            + ', localLocked: ' + node.getLocalLockedConnectionCount()
-            + ', remoteLocked: ' + node.getRemoteLockedConnectionCount()
-            + ', weakLocked: ' + node.getWeakLockedConnectionCount()))
-
-        logger.info('starting find')
-        const targetId = Uint8Array.from(dhtIds[9].data)
-        const closestNodes = await nodes[159].findClosestNodesFromDht(toDhtAddress(targetId))
-        logger.info('find over')
-        expect(closestNodes).toBeGreaterThanOrEqual(5)
-        expect(toDhtAddress(targetId)).toEqual(toNodeId(closestNodes[0]))
-
-    }, 180000)
-})

package/test/benchmark/KademliaCorrectness.test.ts

@@ -1,114 +0,0 @@
-/* eslint-disable no-console */
-import { Simulator } from '../../src/connection/simulator/Simulator'
-import { DhtNode } from '../../src/dht/DhtNode'
-import { createMockConnectionDhtNode } from '../utils/utils'
-import { execSync } from 'child_process'
-import fs from 'fs'
-import { DhtAddress, toDhtAddress, toNodeId } from '../../src/identifiers'
-import { Logger } from '@streamr/utils'
-
-const logger = new Logger(module)
-
-describe('Kademlia correctness', () => {
-    let entryPoint: DhtNode
-    let nodes: DhtNode[]
-    const simulator = new Simulator()
-    const NUM_NODES = 200
-
-    const nodeIndicesById: Record<DhtAddress, number> = {}
-
-    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: { 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, 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, toDhtAddress(Uint8Array.from(dhtIds[i].data)))
-            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()])
-
-        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
-        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) => toNodeId(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 {
-                console.error('Node ' + toNodeId(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)
-    }, 120000)
-})

package/test/benchmark/RingCorrectness.test.ts

@@ -1,157 +0,0 @@
-/* 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, toDhtAddress, toNodeId } 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: 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: { 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, 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, toDhtAddress(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) => toNodeId(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 {
-                console.error('Node ' + toNodeId(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

@@ -1,108 +0,0 @@
-/* eslint-disable no-console */
-
-import KBucket from 'k-bucket'
-import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import { DhtAddress, DhtAddressRaw, randomDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
-
-const NUM_ADDS = 1000
-
-interface Item {
-    id: DhtAddressRaw
-    vectorClock: number
-    getNodeId: () => DhtAddress
-}
-
-const createRandomItem = (index: number): Item => {
-    const nodeId = randomDhtAddress()
-    const nodeIdRaw = toDhtAddressRaw(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: randomDhtAddress(),
-            allowToContainReferenceId: true
-        })
-
-        console.time('SortedContactList.addContact()')
-        for (let i = 0; i < NUM_ADDS; i++) {
-            list.addContact(randomIds[i])
-        }
-        console.timeEnd('SortedContactList.addContact()')
-
-        const kBucket = new KBucket<Item>({ localNodeId: toDhtAddressRaw(randomDhtAddress()) })
-        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(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: randomDhtAddress(),
-                allowToContainReferenceId: true
-            })
-
-            const arrayFromBucket = kBucket.toArray()
-            arrayFromBucket.forEach((contact) => closest.addContact(contact))
-            closest.getClosestContacts(20)
-        }
-        console.timeEnd('SortedContactList.getClosestContacts()')
-
-        console.time('SortedContactList.getClosestContacts() and addContacts()')
-        for (let i = 0; i < NUM_ADDS; i++) {
-            const closest = new SortedContactList<Item>({
-                referenceId: randomDhtAddress(),
-                allowToContainReferenceId: true
-            })
-
-            const arrayFromBucket = kBucket.toArray()
-            closest.addContacts(arrayFromBucket)
-            closest.getClosestContacts(20)
-        }
-        console.timeEnd('SortedContactList.getClosestContacts() 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: toDhtAddressRaw(randomDhtAddress()) })
-
-            shuffled.forEach((contact) => bucket2.add(contact))
-            bucket2.closest(toDhtAddressRaw(randomDhtAddress()), 20)
-        }
-        console.timeEnd('kbucket add and closest')
-
-    })
-})