@streamr/dht 0.0.1-tatum.0

package/test/integration/Layer1-scale.test.ts

@@ -0,0 +1,200 @@
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { PeerID } from '../../src/helpers/PeerID'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
+import { UUID } from '../../src/helpers/UUID'
+
+describe('Layer1', () => {
+
+    let simulator: Simulator
+    const layer0EntryPointId = new UUID().toString()
+
+    const entryPoint0Descriptor = {
+        kademliaId: PeerID.fromString(layer0EntryPointId).value,
+        type: 0,
+        nodeName: layer0EntryPointId
+    }
+
+    let layer0EntryPoint: DhtNode
+
+    const NODE_COUNT = 48
+    let nodes: DhtNode[]
+
+    let layer1CleanUp: DhtNode[]
+
+    beforeEach(async () => {
+        simulator = new Simulator()
+        layer0EntryPoint = await createMockConnectionDhtNode(layer0EntryPointId, simulator)
+        await layer0EntryPoint.joinDht([entryPoint0Descriptor])
+
+        nodes = []
+        layer1CleanUp = []
+
+        for (let i = 0; i < NODE_COUNT; i++) {
+            const node = await createMockConnectionDhtNode(
+                new UUID().toString(),
+                simulator,
+                undefined,
+                undefined,
+                undefined,
+                undefined,
+                60000
+            )
+            nodes.push(node)
+        }
+
+        await Promise.all(nodes.map((node) => node.joinDht([entryPoint0Descriptor])))
+
+    }, 30000)
+
+    afterEach(async () => {
+        await Promise.all(nodes.map((node) => node.stop()))
+        await Promise.all(layer1CleanUp.map((node) => node.stop()))
+        await layer0EntryPoint.stop()
+        simulator.stop()
+    })
+
+    it('single layer1 dht', async () => {
+        const layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint)
+        await layer1EntryPoint.joinDht([entryPoint0Descriptor])
+        layer1CleanUp.push(layer1EntryPoint)
+
+        const layer1Nodes: DhtNode[] = []
+        for (let i = 0; i < NODE_COUNT; i++) {
+            const layer0 = nodes[i]
+            const layer1 = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0)
+            layer1Nodes.push(layer1)
+            layer1CleanUp.push(layer1)
+        }
+
+        await Promise.all(layer1Nodes.map((node) => node.joinDht([entryPoint0Descriptor])))
+
+        for (let i = 0; i < NODE_COUNT; i++) {
+            const layer0Node = nodes[i]
+            const layer1Node = layer1Nodes[i]
+            expect(layer1Node.getNodeId().equals(layer0Node.getNodeId())).toEqual(true)
+            expect(layer1Node.getNumberOfConnections()).toEqual(layer0Node.getNumberOfConnections())
+            expect(layer1Node.getBucketSize()).toBeGreaterThanOrEqual(layer1Node.getK() / 2)
+            expect(layer1Node.getAllConnectionPeerDescriptors()).toEqual(layer0Node.getAllConnectionPeerDescriptors())
+        }
+    }, 120000)
+
+    it('multiple layer1 dht', async () => {
+        const stream1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'one')
+        await stream1EntryPoint.joinDht([entryPoint0Descriptor])
+
+        const stream2EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'two')
+        await stream2EntryPoint.joinDht([entryPoint0Descriptor])
+
+        const stream3EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'three')
+        await stream3EntryPoint.joinDht([entryPoint0Descriptor])
+
+        const stream4EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'four')
+        await stream4EntryPoint.joinDht([entryPoint0Descriptor])
+
+        layer1CleanUp.push(stream1EntryPoint)
+        layer1CleanUp.push(stream2EntryPoint)
+        layer1CleanUp.push(stream3EntryPoint)
+        layer1CleanUp.push(stream4EntryPoint)
+
+        const stream1: DhtNode[] = []
+        const stream2: DhtNode[] = []
+        const stream3: DhtNode[] = []
+        const stream4: DhtNode[] = []
+
+        for (let i = 0; i < NODE_COUNT; i++) {
+            const layer0 = nodes[i]
+            const one = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'one')
+            const two = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'two')
+            const three = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'three')
+            const four = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'four')
+
+            stream1.push(one)
+            stream2.push(two)
+            stream3.push(three)
+            stream4.push(four)
+
+            layer1CleanUp.push(one)
+            layer1CleanUp.push(two)
+            layer1CleanUp.push(three)
+            layer1CleanUp.push(four)
+        }
+
+        await Promise.all(layer1CleanUp.map((node) => node.joinDht([entryPoint0Descriptor])))
+
+        for (let i = 0; i < NODE_COUNT; i++) {
+            const layer0Node = nodes[i]
+            const stream1Node = stream1[i]
+            const stream2Node = stream2[i]
+            const stream3Node = stream3[i]
+            const stream4Node = stream4[i]
+
+            expect(layer0Node.getNumberOfConnections()).toEqual(stream1Node.getNumberOfConnections())
+            expect(layer0Node.getNumberOfConnections()).toEqual(stream2Node.getNumberOfConnections())
+            expect(layer0Node.getNumberOfConnections()).toEqual(stream3Node.getNumberOfConnections())
+            expect(layer0Node.getNumberOfConnections()).toEqual(stream4Node.getNumberOfConnections())
+
+        }
+    }, 120000)
+
+    // TODO: Make this work
+    // it('layer1 routing', async () => {
+    //     const layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint)
+    //     await layer1EntryPoint.joinDht(entryPoint0Descriptor)
+    //     layer1CleanUp.push(layer1EntryPoint)
+    //
+    //     const receivedMessages: Map<string, Set<string>> = new Map()
+    //
+    //     const layer1Nodes: DhtNode[] = []
+    //     for (let i = 0; i < NODE_COUNT; i++) {
+    //         const layer0 = nodes[i]
+    //         if (i > NODE_COUNT - 5) {
+    //             const layer1 = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0)
+    //             layer1Nodes.push(layer1)
+    //             layer1CleanUp.push(layer1)
+    //             receivedMessages.set(layer0.getNodeId().toKey(), new Set())
+    //             layer1.on('message', (msg: Message) => {
+    //                 const peerId = PeerID.fromValue(msg.sourceDescriptor!.kademliaId)
+    //                 receivedMessages.get(layer0.getNodeId().toKey())!.add(peerId.toKey())
+    //             })
+    //         }
+    //     }
+    //
+    //     await Promise.all(layer1Nodes.map((node) => node.joinDht(entryPoint0Descriptor)))
+    //
+    //     layer1Nodes.map((sender) => {
+    //         layer1Nodes.map(async (receiver) => {
+    //             if (!sender.getNodeId().equals(receiver.getNodeId())) {
+    //                 const rpcWrapper = createWrappedClosestPeersRequest(sender.getPeerDescriptor(), receiver.getPeerDescriptor())
+    //                 const message: Message = {
+    //                     serviceId: 'service',
+    //                     messageId: v4(),
+    //                     messageType: MessageType.RPC,
+    //                     body: {
+    //                         oneofKind: 'rpcMessage',
+    //                         rpcMessage: rpcWrapper
+    //                     },
+    //                     sourceDescriptor: sender.getPeerDescriptor(),
+    //                     targetDescriptor: receiver.getPeerDescriptor()
+    //                 }
+    //                 await sender.doRouteMessage({
+    //                     message,
+    //                     destinationPeer: receiver.getPeerDescriptor(),
+    //                     sourcePeer: sender.getPeerDescriptor(),
+    //                     requestId: v4(),
+    //                     reachableThrough: [],
+    //                     routingPath: []
+    //                 })
+    //             }
+    //         })
+    //     })
+    //
+    //     await waitForCondition(() => {
+    //         return [...receivedMessages.values()].every((set) => {
+    //             return set.size === receivedMessages.size - 1
+    //         })
+    //     }, 15000)
+    //
+    // }, 120000)
+
+})

package/test/integration/MigrateData.test.ts

@@ -0,0 +1,203 @@
+/* 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, waitNodesReadyForTesting } from '../utils/utils'
+import { execSync } from 'child_process'
+import fs from 'fs'
+import { Logger } from '@streamr/utils'
+import { PeerID } from '../../src/exports'
+import { Any } from '../../src/proto/google/protobuf/any'
+import { SortedContactList } from '../../src/dht/contact/SortedContactList'
+import { Contact } from '../../src/dht/contact/Contact'
+
+const logger = new Logger(module)
+
+jest.setTimeout(60000)
+
+describe('Migrating data from node to node in DHT', () => {
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    let entrypointDescriptor: PeerDescriptor
+    const simulator = new Simulator(LatencyType.FIXED, 20)
+    const NUM_NODES = 100
+    const MAX_CONNECTIONS = 80
+    const K = 8
+
+    const nodesById: Map<string, DhtNode> = new Map()
+
+    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: Array<{ type: string, data: Array<number> }> = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+    /*
+    const getRandomNode = () => {
+        return nodes[Math.floor(Math.random() * nodes.length)]
+    }
+    */
+    beforeEach(async () => {
+        nodes = []
+        const entryPointId = '0'
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
+            Uint8Array.from(dhtIds[0].data), K, entryPointId, MAX_CONNECTIONS)
+        nodes.push(entryPoint)
+        nodesById.set(entryPoint.getNodeId().toKey(), entryPoint)
+
+        entrypointDescriptor = {
+            kademliaId: entryPoint.getNodeId().value,
+            type: NodeType.NODEJS,
+            nodeName: entryPointId
+        }
+
+        nodes.push(entryPoint)
+
+        for (let i = 1; i < NUM_NODES; i++) {
+            const nodeId = `${i}`
+
+            const node = await createMockConnectionDhtNode(nodeId, simulator,
+                Uint8Array.from(dhtIds[i].data), K, nodeId, MAX_CONNECTIONS)
+            nodesById.set(node.getNodeId().toKey(), node)
+            nodes.push(node)
+        }
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            ...nodes.map(async (node) => await node.stop())
+        ])
+        logger.info('nodes stopped')
+    })
+
+    afterAll(async () => {
+        simulator.stop()
+    })
+
+    it('Data migrates to the closest node no matter where it is stored', async () => {
+        const dataKey = PeerID.fromString('3232323e12r31r3')
+        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
+
+        // calculate offline which node is closest to the data
+
+        const sortedList = new SortedContactList<Contact>(dataKey, 10000)
+
+        nodes.forEach((node) => {
+            sortedList.addContact(new Contact(node.getPeerDescriptor())
+            )
+        })
+
+        const closest = sortedList.getAllContacts()
+
+        logger.info('Nodes sorted according to distance to data are: ')
+        closest.forEach((contact) => {
+            logger.info('' + contact.getPeerDescriptor().nodeName)
+        })
+
+        logger.info('node 0 joining to the DHT')
+
+        await nodes[0].joinDht([entrypointDescriptor])
+
+        logger.info('storing data to node 0')
+        const successfulStorers = await nodes[0].storeDataToDht(dataKey.value, data)
+        expect(successfulStorers.length).toBe(1)
+        logger.info('data successfully stored to node 0')
+
+        logger.info('Nodes sorted according to distance to data with storing nodes marked are: ')
+
+        closest.forEach((contact) => {
+            const node = nodesById.get(PeerID.fromValue(contact.getPeerDescriptor().kademliaId).toKey())!
+            let hasDataMarker = ''
+            
+            // @ts-expect-error private field
+            if (node.localDataStore.getEntry(dataKey)) {
+                hasDataMarker = '<-'
+            }
+
+            logger.info(contact.getPeerDescriptor().nodeName + ' ' + node.getNodeName() + hasDataMarker)
+        })
+
+        logger.info(NUM_NODES + ' nodes joining layer0 DHT')
+        await Promise.all(
+            nodes.map((node) => {
+                if (node.getNodeName() != '0') {
+                    node.joinDht([entrypointDescriptor])
+                }
+            })
+        )
+
+        logger.info('completed ' + NUM_NODES + ' nodes joining layer0 DHT')
+
+        await waitNodesReadyForTesting(nodes)
+
+        logger.info('After join of 99 nodes: nodes sorted according to distance to data with storing nodes marked are: ')
+
+        closest.forEach((contact) => {
+            const node = nodesById.get(PeerID.fromValue(contact.getPeerDescriptor().kademliaId).toKey())!
+            let hasDataMarker = ''
+
+            // @ts-expect-error private field
+
+            if (node.localDataStore.getEntry(dataKey)) {
+                hasDataMarker = '<-'
+            }
+
+            logger.info('' + node.getNodeName() + hasDataMarker)
+        })
+
+        const closestNode = nodesById.get(PeerID.fromValue(closest[0].getPeerDescriptor().kademliaId).toKey())!
+
+        // @ts-expect-error private field
+        expect(closestNode.localDataStore.getEntry(dataKey)).toBeTruthy()
+    }, 180000)
+
+    it('Data migrates to the last remaining node if all other nodes leave gracefully', async () => {
+        const dataKey = PeerID.fromString('3232323e12r31r3')
+        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
+
+        logger.info(NUM_NODES + ' nodes joining layer0 DHT')
+        await Promise.all(
+            nodes.map((node) => {
+                node.joinDht([entrypointDescriptor])
+            })
+        )
+
+        logger.info('completed ' + NUM_NODES + ' nodes joining layer0 DHT')
+
+        await waitNodesReadyForTesting(nodes)
+
+        const randomIndex = Math.floor(Math.random() * nodes.length)
+        logger.info('storing data to a random node: ' + randomIndex)
+
+        const successfulStorers = await nodes[randomIndex].storeDataToDht(dataKey.value, data)
+
+        logger.info('data successfully stored to ' + successfulStorers + ' nodes')
+
+        const randomIndices = []
+        for (let i = 0; i < nodes.length; i++) {
+            randomIndices.push(i)
+        }
+
+        console.error(randomIndices)
+        while (randomIndices.length > 1) {
+            const index = Math.floor(Math.random() * randomIndices.length)
+            const nodeIndex = randomIndices[index]
+            randomIndices.splice(index, 1)
+
+            logger.info('Stopping node ' + nodeIndex + ' ' +
+                // @ts-expect-error private field
+                (nodes[nodeIndex].localDataStore.getEntry(dataKey) ? ', has data' : ' does not have data'))
+
+            await nodes[nodeIndex].stop()
+        }
+
+        logger.info('after random graceful leaving, node ' + randomIndices[0] + ' is left')
+
+        // @ts-expect-error private field
+        logger.info('data of ' + randomIndices[0] + ' was ' + nodes[randomIndices[0]].localDataStore.getEntry(dataKey))
+
+        // @ts-expect-error private field
+        expect(nodes[randomIndices[0]].localDataStore.getEntry(dataKey)).toBeTruthy()
+
+    }, 180000)
+})

package/test/integration/Mock-Layer1-Layer0.test.ts

@@ -0,0 +1,106 @@
+import { Logger } from '@streamr/utils'
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
+
+const logger = new Logger(module)
+
+describe('Layer 1 on Layer 0 with mocked connections', () => {
+    const simulator = new Simulator()
+    const layer0EntryPointId = 'layer0entrypoint'
+
+    let layer0EntryPoint: DhtNode
+    let layer1Node1: DhtNode
+
+    let layer0Node1: DhtNode
+    let layer1EntryPoint: DhtNode
+
+    let layer0Node2: DhtNode
+    let layer1Node2: DhtNode
+
+    let layer0Node3: DhtNode
+    let layer1Node3: DhtNode
+
+    let layer0Node4: DhtNode
+    let layer1Node4: DhtNode
+
+    let entryPointDescriptor: PeerDescriptor
+
+    beforeEach(async () => {
+
+        layer0EntryPoint = await createMockConnectionDhtNode(layer0EntryPointId, simulator)
+
+        const layer0Node1Id = 'node1'
+        layer0Node1 = await createMockConnectionDhtNode(layer0Node1Id, simulator)
+
+        const layer0Node2Id = 'node2'
+        layer0Node2 = await createMockConnectionDhtNode(layer0Node2Id, simulator)
+
+        const layer0Node3Id = 'node3'
+        layer0Node3 = await createMockConnectionDhtNode(layer0Node3Id, simulator)
+
+        const layer0Node4Id = 'node4'
+        layer0Node4 = await createMockConnectionDhtNode(layer0Node4Id, simulator)
+
+        layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPointId, layer0EntryPoint)
+
+        layer1Node1 = await createMockConnectionLayer1Node(layer0Node1Id, layer0Node1)
+        layer1Node2 = await createMockConnectionLayer1Node(layer0Node2Id, layer0Node2)
+        layer1Node3 = await createMockConnectionLayer1Node(layer0Node3Id, layer0Node3)
+        layer1Node4 = await createMockConnectionLayer1Node(layer0Node4Id, layer0Node4)
+
+        entryPointDescriptor = {
+            kademliaId: layer0EntryPoint.getNodeId().value,
+            type: 0,
+            nodeName: layer0EntryPointId
+        }
+
+        await layer0EntryPoint.joinDht([entryPointDescriptor])
+        await layer1EntryPoint.joinDht([entryPointDescriptor])
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            layer0EntryPoint.stop(),
+            layer0Node1.stop(),
+            layer0Node2.stop(),
+            layer0Node3.stop(),
+            layer0Node4.stop(),
+            layer1EntryPoint.stop(),
+            layer1Node1.stop(),
+            layer1Node2.stop(),
+            layer1Node3.stop(),
+            layer1Node4.stop()
+        ])
+    })
+
+    it('Happy Path', async () => {
+        await layer0Node1.joinDht([entryPointDescriptor])
+        await layer0Node2.joinDht([entryPointDescriptor])
+        await layer0Node3.joinDht([entryPointDescriptor])
+        await layer0Node4.joinDht([entryPointDescriptor])
+
+        await layer1Node1.joinDht([entryPointDescriptor])
+        await layer1Node2.joinDht([entryPointDescriptor])
+        await layer1Node3.joinDht([entryPointDescriptor])
+        await layer1Node4.joinDht([entryPointDescriptor])
+
+        logger.info('layer1EntryPoint.getBucketSize() ' + layer1EntryPoint.getBucketSize())
+        logger.info('layer1Node1.getBucketSize()' + layer1Node1.getBucketSize())
+        logger.info('layer1Node2.getBucketSize()' + layer1Node2.getBucketSize())
+        logger.info('layer1Node3.getBucketSize()' + layer1Node3.getBucketSize())
+        logger.info('layer1Node4.getBucketSize()' + layer1Node4.getBucketSize())
+
+        expect(layer1Node1.getBucketSize()).toEqual(layer0Node1.getBucketSize())
+        expect(layer1Node2.getBucketSize()).toEqual(layer0Node2.getBucketSize())
+        expect(layer1Node3.getBucketSize()).toEqual(layer0Node3.getBucketSize())
+        expect(layer1Node4.getBucketSize()).toEqual(layer0Node4.getBucketSize())
+
+        expect(layer1Node1.getKBucketPeers()).toContainValues(layer0Node1.getKBucketPeers())
+        expect(layer1Node2.getKBucketPeers()).toContainValues(layer0Node2.getKBucketPeers())
+        expect(layer1Node3.getKBucketPeers()).toContainValues(layer0Node3.getKBucketPeers())
+        expect(layer1Node4.getKBucketPeers()).toContainValues(layer0Node4.getKBucketPeers())
+
+    }, 60000)
+})

package/test/integration/MultipleEntryPointJoining.test.ts

@@ -0,0 +1,105 @@
+import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockConnectionDhtNode } from '../utils/utils'
+
+describe('multiple entry point joining', () => {
+
+    describe('all nodes are entry points', () => {
+
+        let simulator: Simulator
+        let node1: DhtNode
+        let node2: DhtNode
+        let node3: DhtNode
+        let entryPoints: PeerDescriptor[]
+        
+        beforeEach(async () => {
+            simulator = new Simulator(LatencyType.RANDOM)
+
+            node1 = await createMockConnectionDhtNode('node1', simulator)
+            node2 = await createMockConnectionDhtNode('node2', simulator)
+            node3 = await createMockConnectionDhtNode('node3', simulator)
+
+            entryPoints = [
+                node1.getPeerDescriptor(),
+                node2.getPeerDescriptor(),
+                node3.getPeerDescriptor()
+            ]
+        })
+
+        afterEach(async () => {
+            await Promise.all([
+                node1.stop(),
+                node2.stop(),
+                node3.stop()
+            ])
+            simulator.stop()
+        })
+
+        it('can join simultaneously', async () => {
+            await Promise.all([
+                node1.joinDht(entryPoints),
+                node2.joinDht(entryPoints),
+                node3.joinDht(entryPoints)
+            ])
+            expect(node1.getBucketSize()).toEqual(2)
+            expect(node2.getBucketSize()).toEqual(2)
+            expect(node3.getBucketSize()).toEqual(2)
+        })
+
+        it('can join even if a node is offline', async () => {
+            await node3.stop()
+            await Promise.all([
+                node1.joinDht(entryPoints),
+                node2.joinDht(entryPoints)
+            ])
+            expect(node1.getBucketSize()).toEqual(1)
+            expect(node2.getBucketSize()).toEqual(1)
+        }, 10000)
+    })
+
+    describe('non entry point nodes can join via multiple entry points', () => {
+        let simulator: Simulator
+        let entryPoint1: DhtNode
+        let entryPoint2: DhtNode
+        let node1: DhtNode
+        let node2: DhtNode
+        let entryPoints: PeerDescriptor[]
+        
+        beforeEach(async () => {
+            simulator = new Simulator(LatencyType.RANDOM)
+            
+            entryPoint1 = await createMockConnectionDhtNode('entryPoint1', simulator)
+            entryPoint2 = await createMockConnectionDhtNode('entryPoint2', simulator)
+            
+            node1 = await createMockConnectionDhtNode('node1', simulator)
+            node2 = await createMockConnectionDhtNode('node2', simulator)
+
+            entryPoints = [
+                entryPoint1.getPeerDescriptor(),
+                entryPoint2.getPeerDescriptor(),
+            ]
+
+            await entryPoint1.joinDht(entryPoints)
+            await entryPoint2.joinDht(entryPoints)
+        })
+
+        afterEach(async () => {
+            await Promise.all([
+                entryPoint1.stop(),
+                entryPoint2.stop(),
+                node1.stop(),
+                node2.stop()
+            ])
+            simulator.stop()
+        })
+
+        it('non-entry point nodes can join', async () => {
+            await node1.joinDht(entryPoints)
+            expect(node1.getBucketSize()).toEqual(2)
+            await node2.joinDht(entryPoints)
+            expect(node2.getBucketSize()).toEqual(3)
+        })
+
+    })
+})

package/test/integration/RecursiveFind.test.ts

@@ -0,0 +1,50 @@
+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, waitConnectionManagersReadyForTesting } from '../utils/utils'
+import { PeerID, peerIdFromPeerDescriptor } from '../../src/exports'
+
+describe('Recursive find correctness', () => {
+
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    let entrypointDescriptor: PeerDescriptor
+    const simulator = new Simulator(LatencyType.RANDOM)
+    const NUM_NODES = 100
+    const K = 2
+
+    beforeEach(async () => {
+        nodes = []
+        const entryPointId = '0'
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, K, entryPointId)
+        nodes.push(entryPoint)
+        entrypointDescriptor = {
+            kademliaId: entryPoint.getNodeId().value,
+            type: NodeType.NODEJS,
+            nodeName: entryPointId
+        }
+        for (let i = 1; i < NUM_NODES; i++) {
+            const nodeId = `${i}`
+            const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, nodeId, 20, 60000)
+            nodes.push(node)
+        }
+        await entryPoint.joinDht([entrypointDescriptor])
+        await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
+        await waitConnectionManagersReadyForTesting(nodes.map((node) => node.connectionManager!), 20)
+    }, 90000)
+
+    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 () => {
+        const kademliaIdToFind = nodes[45].getNodeId().value
+        const results = await entryPoint.startRecursiveFind(kademliaIdToFind)
+        expect(results.closestNodes.length).toBeGreaterThanOrEqual(5)
+        expect(PeerID.fromValue(kademliaIdToFind).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
+    }, 30000)
+
+})