@streamr/dht 0.0.1-tatum.5 → 0.0.1-tatum.6

package/src/dht/find/RecursiveFinder.ts

@@ -237,7 +237,7 @@ export class RecursiveFinder implements IRecursiveFinder {
 
     private getClosestConnections(kademliaId: Uint8Array, limit: number): PeerDescriptor[] {
         const connectedPeers = Array.from(this.connections.values())
-        const closestPeers = new SortedContactList(
+        const closestPeers = new SortedContactList<DhtPeer>(
             PeerID.fromValue(kademliaId),
             limit,
             undefined,

package/src/dht/routing/RemoteRouter.ts

@@ -40,7 +40,7 @@ export class RemoteRouter extends Remote<IRoutingServiceClient> {
         } catch (err) {
             const fromNode = params.previousPeer ?
                 peerIdFromPeerDescriptor(params.previousPeer) : keyFromPeerDescriptor(params.sourcePeer!)
-            logger.trace(`Failed to send routeMessage from ${fromNode} to ${this.getPeerId().toKey()} with: ${err}`)
+            logger.trace(`Failed to send routeMessage from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
             return false
         }
         return true
@@ -69,7 +69,7 @@ export class RemoteRouter extends Remote<IRoutingServiceClient> {
                 keyFromPeerDescriptor(params.previousPeer) : keyFromPeerDescriptor(params.sourcePeer!)
 
             logger.trace(
-                `Failed to send forwardMessage from ${fromNode} to ${this.getPeerId().toKey()} with: ${err}`
+                `Failed to send forwardMessage from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`
             )
             return false
         }
@@ -97,7 +97,7 @@ export class RemoteRouter extends Remote<IRoutingServiceClient> {
             }
         } catch (err) {
             const fromNode = params.previousPeer ? keyFromPeerDescriptor(params.previousPeer) : keyFromPeerDescriptor(params.sourcePeer!)
-            logger.debug(`Failed to send recursiveFind message from ${fromNode} to ${this.getPeerId().toKey()} with: ${err}`)
+            logger.debug(`Failed to send recursiveFind message from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
             return false
         }
         return true

package/src/dht/routing/RoutingSession.ts

@@ -10,11 +10,31 @@ import { RemoteRouter } from './RemoteRouter'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { RoutingServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { Contact } from '../contact/Contact'
 
 const logger = new Logger(module)
 
 const MAX_FAILED_HOPS = 2
 
+class RemoteContact extends Contact {
+
+    private router: RemoteRouter
+
+    constructor(peer: DhtPeer, ownPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
+        super(peer.getPeerDescriptor())
+        this.router = new RemoteRouter(
+            ownPeerDescriptor,
+            peer.getPeerDescriptor(),
+            peer.getServiceId(),
+            toProtoRpcClient(new RoutingServiceClient(rpcCommunicator.getRpcClientTransport()))
+        )
+    }
+
+    getRouter(): RemoteRouter {
+        return this.router
+    }
+}
+
 export interface RoutingSessionEvents {
     // This event is emitted when a peer responds with a success ack
     // to routeMessage call
@@ -35,7 +55,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
     public readonly sessionId = v4()
     private readonly rpcCommunicator: RoutingRpcCommunicator
     private ongoingRequests: Set<PeerIDKey> = new Set()
-    private contactList: SortedContactList<RemoteRouter>
+    private contactList: SortedContactList<RemoteContact>
     private readonly ownPeerDescriptor: PeerDescriptor
     private readonly messageToRoute: RouteMessageWrapper
     private connections: Map<PeerIDKey, DhtPeer>
@@ -117,51 +137,40 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
     }
 
-    private sendRouteMessageRequest = async (contact: RemoteRouter): Promise<boolean> => {
+    private sendRouteMessageRequest = async (contact: RemoteContact): Promise<boolean> => {
         if (this.stopped) {
             return false
         }
+        const router = contact.getRouter()
         if (this.mode === RoutingMode.FORWARD) {
-            return contact.forwardMessage({
+            return router.forwardMessage({
                 ...this.messageToRoute,
                 previousPeer: this.ownPeerDescriptor
             })
         } else if (this.mode === RoutingMode.RECURSIVE_FIND) {
-            return contact.findRecursively({
+            return router.findRecursively({
                 ...this.messageToRoute,
                 previousPeer: this.ownPeerDescriptor
             })
         } else {
-            return contact.routeMessage({
+            return router.routeMessage({
                 ...this.messageToRoute,
                 previousPeer: this.ownPeerDescriptor
             })
         }
     }
 
-    private findMoreContacts = (): RemoteRouter[] => {
+    private findMoreContacts = (): RemoteContact[] => {
         logger.trace('findMoreContacts() sessionId: ' + this.sessionId)
         // the contents of the connections might have changed between the rounds
         // addContacts() will only add new contacts that were not there yet
         const contacts = Array.from(this.connections.values())
-            .map((contact) => {
-                return new RemoteRouter(
-                    this.ownPeerDescriptor,
-                    contact.getPeerDescriptor(),
-                    contact.getServiceId(),
-                    toProtoRpcClient(new RoutingServiceClient(this.rpcCommunicator.getRpcClientTransport()))
-                )  
-            })
+            .map((peer) => new RemoteContact(peer, this.ownPeerDescriptor, this.rpcCommunicator))
         this.contactList.addContacts(contacts)
         return this.contactList.getUncontactedContacts(this.parallelism)
     }
 
-    public getClosestContacts = (limit: number): PeerDescriptor[] => {
-        const contacts = this.contactList.getClosestContacts(limit)
-        return contacts.map((contact) => contact.getPeerDescriptor())
-    }
-
-    private sendMoreRequests = (uncontacted: RemoteRouter[]) => {
+    private sendMoreRequests = (uncontacted: RemoteContact[]) => {
         logger.trace('sendMoreRequests() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return

package/src/exports.ts

@@ -7,7 +7,6 @@ export { PeerDescriptor, Message, NodeType, DataEntry } from './proto/packages/d
 export { ITransport } from './transport/ITransport'
 export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
 export { PeerID, PeerIDKey } from './helpers/PeerID'
-export { DhtPeer } from './dht/DhtPeer'
 export { UUID } from './helpers/UUID'
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
 export { protoClasses } from './helpers/protoClasses'

package/test/benchmark/KademliaCorrectness.test.ts

@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
 import { Simulator } from '../../src/connection/Simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
+import { PeerID } from '../../src/exports'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
@@ -70,7 +71,7 @@ describe('Kademlia correctness', () => {
                 groundTruthString += groundTruth[i + ''][j].name + ','
             }
 
-            const kademliaNeighbors = nodes[i].getNeighborList().getContactIds()
+            const kademliaNeighbors = nodes[i].getClosestContacts().map((p) => PeerID.fromValue(p.kademliaId))
 
             let kadString = 'kademliaNeighbors: '
             kademliaNeighbors.forEach((neighbor) => {

package/test/end-to-end/Layer0-Layer1.test.ts

@@ -1,6 +1,6 @@
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('Layer0-Layer1', () => {
     const epPeerDescriptor: PeerDescriptor = {
@@ -76,14 +76,14 @@ describe('Layer0-Layer1', () => {
             stream2Node1.joinDht([epPeerDescriptor]),
             stream2Node2.joinDht([epPeerDescriptor])
         ])
-        expect(stream1Node1.getNeighborList().getSize()).toEqual(1)
-        expect(stream1Node2.getNeighborList().getSize()).toEqual(1)
-        expect(stream2Node1.getNeighborList().getSize()).toEqual(1)
-        expect(stream2Node2.getNeighborList().getSize()).toEqual(1)
-
-        expect(stream1Node1.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(node1.getPeerDescriptor()))).toEqual(true)
-        expect(stream1Node2.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(epPeerDescriptor))).toEqual(true)
-        expect(stream2Node1.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(node2.getPeerDescriptor()))).toEqual(true)
-        expect(stream2Node2.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(epPeerDescriptor))).toEqual(true)
+        expect(stream1Node1.getClosestContacts()).toHaveLength(1)
+        expect(stream1Node2.getClosestContacts()).toHaveLength(1)
+        expect(stream2Node1.getClosestContacts()).toHaveLength(1)
+        expect(stream2Node2.getClosestContacts()).toHaveLength(1)
+
+        expect(isSamePeerDescriptor(stream1Node1.getClosestContacts()[0], node1.getPeerDescriptor())).toBe(true)
+        expect(isSamePeerDescriptor(stream1Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
+        expect(isSamePeerDescriptor(stream2Node1.getClosestContacts()[0], node2.getPeerDescriptor())).toBe(true)
+        expect(isSamePeerDescriptor(stream2Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
     })
 })

package/test/integration/DhtWithMockConnectionLatencies.test.ts

@@ -39,7 +39,7 @@ describe('Mock connection Dht joining with latencies', () => {
         await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
         nodes.forEach((node) => {
             expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 2)
-            expect(node.getNeighborList().getSize()).toBeGreaterThanOrEqual(node.getK() - 2)
+            expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(node.getK() - 2)
         })
         expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(entryPoint.getK() - 2)
     }, 60 * 1000)

package/test/integration/DhtWithMockConnections.test.ts

@@ -39,7 +39,7 @@ describe('Mock IConnection DHT Joining', () => {
         await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
         nodes.forEach((node) => {
             expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 2)
-            expect(node.getNeighborList().getSize()).toBeGreaterThanOrEqual(node.getK() - 2)
+            expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(node.getK() - 2)
         })
         expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(entryPoint.getK() - 2)
     }, 60000)

package/test/integration/DhtWithRealConnectionLatencies.test.ts

@@ -40,7 +40,7 @@ describe('Mock connection Dht joining with real latencies', () => {
         await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
         nodes.forEach((node) => {
             expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 3)
-            expect(node.getNeighborList().getSize()).toBeGreaterThanOrEqual(node.getK() - 3)
+            expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(node.getK() - 3)
         })
         expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(entryPoint.getK())
     }, 60 * 1000)

package/test/unit/RandomContactList.test.ts

@@ -1,92 +1,43 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
-import type { ServiceInfo, MethodInfo } from '@protobuf-ts/runtime-rpc'
-import { PeerID } from '../../src/helpers/PeerID'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { IDhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { LeaveNotice, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { FindDataRequest, FindDataResponse, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { PingRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { ClosestPeersResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { ClosestPeersRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { UnaryCall } from '@protobuf-ts/runtime-rpc'
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc'
-import { DhtPeer } from '../../src/dht/DhtPeer'
-import { IMessageType } from '@protobuf-ts/runtime'
-import { Empty } from '../../src/proto/google/protobuf/empty'
+import { PeerID } from '../../src/exports'
 
-class MockRpcClient implements IDhtRpcServiceClient, ServiceInfo {
-    typeName = 'MockRpcClient'
-    methods: MethodInfo<any, any> [] = [
-        { name: 'getClosestPeers', O: {} as IMessageType<ClosestPeersResponse> } as MethodInfo<any, any>,
-        { name: 'ping', O: {} as IMessageType<PingResponse> } as MethodInfo<any, any>,
-        { name: 'findData', O: {} as IMessageType<FindDataRequest> } as MethodInfo<any, any>,
-        { name: 'leaveNotice', O: {} as IMessageType<Empty> } as MethodInfo<any, any>
-    ]
-    options = {}
-
-    // eslint-disable-next-line class-methods-use-this
-    getClosestPeers(_input: ClosestPeersRequest, _options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse> {
-        return {} as UnaryCall<ClosestPeersRequest, ClosestPeersResponse>
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    ping(_input: PingRequest, _options?: RpcOptions): UnaryCall <PingRequest, PingResponse> {
-        return {} as UnaryCall<PingRequest, PingResponse>
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    findData(_input: FindDataRequest, _options?: RpcOptions): UnaryCall<FindDataRequest, FindDataResponse> {
-        return {} as UnaryCall<FindDataRequest, FindDataResponse>
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    leaveNotice(_input: LeaveNotice, _options?: RpcOptions): UnaryCall<LeaveNotice, Empty> {
-        return {} as UnaryCall<LeaveNotice, Empty>
-    }
-}
-
-const getId = (descriptor: PeerDescriptor): PeerID => {
-    return PeerID.fromValue(descriptor.kademliaId)
+const createItem = (kademliaId: Uint8Array): { getPeerId: () => PeerID } => {
+    return { getPeerId: () => PeerID.fromValue(kademliaId) }
 }
 
 describe('RandomContactList', () => {
-    const serviceId = 'random'
-    const descriptor0: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 0]), type: NodeType.NODEJS }
-    const descriptor1: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 1]), type: NodeType.NODEJS }
-    const descriptor2: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 2]), type: NodeType.NODEJS }
-    const descriptor3: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 3]), type: NodeType.NODEJS }
-    const descriptor4: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 4]), type: NodeType.NODEJS }
-    const peer1 = new DhtPeer(descriptor0, descriptor1, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer2 = new DhtPeer(descriptor0, descriptor2, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer3 = new DhtPeer(descriptor0, descriptor3, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer4 = new DhtPeer(descriptor0, descriptor4, toProtoRpcClient(new MockRpcClient()), serviceId)
+    const item0 = createItem(new Uint8Array([0, 0, 0, 0]))
+    const item1 = createItem(new Uint8Array([0, 0, 0, 1]))
+    const item2 = createItem(new Uint8Array([0, 0, 0, 2]))
+    const item3 = createItem(new Uint8Array([0, 0, 0, 3]))
+    const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
 
     it('adds contacts correctly', () => {
-        const list = new RandomContactList(getId(descriptor0), 5, 1)
-        list.addContact(peer1)
-        list.addContact(peer2)
-        list.addContact(peer3)
-        list.addContact(peer3)
-        list.addContact(peer4)
-        list.addContact(peer4)
+        const list = new RandomContactList(item0.getPeerId(), 5, 1)
+        list.addContact(item1)
+        list.addContact(item2)
+        list.addContact(item3)
+        list.addContact(item3)
+        list.addContact(item4)
+        list.addContact(item4)
         expect(list.getSize()).toEqual(4)
         expect(list.getContacts()).toEqual(
-            [peer1, peer2, peer3, peer4]
+            [item1, item2, item3, item4]
         )
     })
 
     it('removes contacts correctly', () => {
-        const list = new RandomContactList(getId(descriptor0), 5, 1)
-        list.addContact(peer1)
-        list.addContact(peer2)
-        list.addContact(peer3)
-        list.addContact(peer4)
-        list.removeContact(getId(descriptor2))
-        expect(list.getContact(getId(descriptor1))).toBeTruthy()
-        expect(list.getContact(getId(descriptor3))).toBeTruthy()
-        expect(list.getContact(getId(descriptor4))).toBeTruthy()
+        const list = new RandomContactList(item0.getPeerId(), 5, 1)
+        list.addContact(item1)
+        list.addContact(item2)
+        list.addContact(item3)
+        list.addContact(item4)
+        list.removeContact(item2.getPeerId())
+        expect(list.getContact(item1.getPeerId())).toBeTruthy()
+        expect(list.getContact(item3.getPeerId())).toBeTruthy()
+        expect(list.getContact(item4.getPeerId())).toBeTruthy()
         expect(list.getContacts()).toEqual(
-            [peer1, peer3, peer4]
+            [item1, item3, item4]
         )
         expect(list.getSize()).toEqual(3)
     })

package/test/unit/SortedContactList.test.ts

@@ -1,153 +1,103 @@
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import type { ServiceInfo, MethodInfo } from '@protobuf-ts/runtime-rpc'
 import { PeerID } from '../../src/helpers/PeerID'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { IDhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { LeaveNotice, NodeType, PeerDescriptor, RouteMessageAck } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { FindDataRequest, FindDataResponse, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { PingRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { ClosestPeersResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
-import type { ClosestPeersRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { UnaryCall } from '@protobuf-ts/runtime-rpc'
-import type { RpcOptions } from '@protobuf-ts/runtime-rpc'
-import { DhtPeer } from '../../src/dht/DhtPeer'
-import { IMessageType } from '@protobuf-ts/runtime'
-import { Empty } from '../../src/proto/google/protobuf/empty'
 
-/* eslint-disable class-methods-use-this */
-class MockRpcClient implements IDhtRpcServiceClient, ServiceInfo {
-    typeName = 'MockRpcClient'
-    methods: MethodInfo<any, any> [] = [
-        { name: 'getClosestPeers', O: {} as IMessageType<ClosestPeersResponse> } as MethodInfo<any, any>,
-        { name: 'ping', O: {} as IMessageType<PingResponse> } as MethodInfo<any, any>,
-        { name: 'findData', O: {} as IMessageType<RouteMessageAck> } as MethodInfo<any, any>,
-        { name: 'leaveNotice', O: {} as IMessageType<Empty> } as MethodInfo<any, any>
-    ]
-    options = {}
-    getClosestPeers(_input: ClosestPeersRequest, _options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse> {
-        return {} as UnaryCall<ClosestPeersRequest, ClosestPeersResponse>
-    }
-    ping(_input: PingRequest, _options?: RpcOptions): UnaryCall <PingRequest, PingResponse> {
-        return {} as UnaryCall<PingRequest, PingResponse>
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    findData(_input: FindDataRequest, _options?: RpcOptions): UnaryCall<FindDataRequest, FindDataResponse> {
-        return {} as UnaryCall<FindDataRequest, FindDataResponse>
-    }
-
-    leaveNotice(_input: LeaveNotice, _options?: RpcOptions): UnaryCall<LeaveNotice, Empty> {
-        return {} as UnaryCall<LeaveNotice, Empty>
-    }
-}
-
-const getId = (descriptor: PeerDescriptor): PeerID => {
-    return PeerID.fromValue(descriptor.kademliaId)
+const createItem = (kademliaId: Uint8Array): { getPeerId: () => PeerID } => {
+    return { getPeerId: () => PeerID.fromValue(kademliaId) }
 }
 
 describe('SortedContactList', () => {
-    const serviceId = 'sorted'
-    const descriptor0: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 0]), type: NodeType.NODEJS }
-    const descriptor1: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 1]), type: NodeType.NODEJS }
-    const descriptor2: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 2]), type: NodeType.NODEJS }
-    const descriptor3: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 3]), type: NodeType.NODEJS }
-    const descriptor4: PeerDescriptor = { kademliaId: new Uint8Array([0, 0, 0, 4]), type: NodeType.NODEJS }
-    const peer1 = new DhtPeer(descriptor0, descriptor1, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer2 = new DhtPeer(descriptor0, descriptor2, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer3 = new DhtPeer(descriptor0, descriptor3, toProtoRpcClient(new MockRpcClient()), serviceId)
-    const peer4 = new DhtPeer(descriptor0, descriptor4, toProtoRpcClient(new MockRpcClient()), serviceId)
+    const item0 = createItem(new Uint8Array([0, 0, 0, 0]))
+    const item1 = createItem(new Uint8Array([0, 0, 0, 1]))
+    const item2 = createItem(new Uint8Array([0, 0, 0, 2]))
+    const item3 = createItem(new Uint8Array([0, 0, 0, 3]))
+    const item4 = createItem(new Uint8Array([0, 0, 0, 4]))
 
     it('compares Ids correctly', async () => {
-        const list = new SortedContactList(getId(descriptor0), 10)
-        expect(list.compareIds(getId(descriptor0), getId(descriptor0))).toBe(0)
-        expect(list.compareIds(getId(descriptor1), getId(descriptor1))).toBe(0)
-        expect(list.compareIds(getId(descriptor0), getId(descriptor1))).toBe(-1)
-        expect(list.compareIds(getId(descriptor0), getId(descriptor2))).toBe(-2)
-        expect(list.compareIds(getId(descriptor1), getId(descriptor0))).toBe(1)
-        expect(list.compareIds(getId(descriptor2), getId(descriptor0))).toBe(2)
-        expect(list.compareIds(getId(descriptor2), getId(descriptor3))).toBe(-1)
-        expect(list.compareIds(getId(descriptor1), getId(descriptor4))).toBe(-3)
+        const list = new SortedContactList(item0.getPeerId(), 10)
+        expect(list.compareIds(item0.getPeerId(), item0.getPeerId())).toBe(0)
+        expect(list.compareIds(item1.getPeerId(), item1.getPeerId())).toBe(0)
+        expect(list.compareIds(item0.getPeerId(), item1.getPeerId())).toBe(-1)
+        expect(list.compareIds(item0.getPeerId(), item2.getPeerId())).toBe(-2)
+        expect(list.compareIds(item1.getPeerId(), item0.getPeerId())).toBe(1)
+        expect(list.compareIds(item2.getPeerId(), item0.getPeerId())).toBe(2)
+        expect(list.compareIds(item2.getPeerId(), item3.getPeerId())).toBe(-1)
+        expect(list.compareIds(item1.getPeerId(), item4.getPeerId())).toBe(-3)
     })
     
     it('orders itself correctly', async () => {
-
-        const list = new SortedContactList(getId(descriptor0), 10)
-
-        list.addContact(peer3)
-        list.addContact(peer2)
-        list.addContact(peer1)
-
+        const list = new SortedContactList(item0.getPeerId(), 10)
+        list.addContact(item3)
+        list.addContact(item2)
+        list.addContact(item1)
         const contacts = list.getUncontactedContacts(3)
         expect(contacts.length).toEqual(3)
-        expect(contacts[0]).toEqual(peer1)
-        expect(contacts[1]).toEqual(peer2)
-        expect(contacts[2]).toEqual(peer3)
+        expect(contacts[0]).toEqual(item1)
+        expect(contacts[1]).toEqual(item2)
+        expect(contacts[2]).toEqual(item3)
     })
     
     it('handles contacted nodes correctly', async () => {
-        const list = new SortedContactList(getId(descriptor0), 10)
-
-        list.addContact(peer3)
-        list.addContact(peer2)
-        list.addContact(peer1)
-
-        list.setContacted(getId(descriptor2))
+        const list = new SortedContactList(item0.getPeerId(), 10)
+        list.addContact(item3)
+        list.addContact(item2)
+        list.addContact(item1)
+        list.setContacted(item2.getPeerId())
         const contacts = list.getUncontactedContacts(3)
         expect(contacts.length).toEqual(2)
-        expect(contacts[0]).toEqual(peer1)
-        expect(contacts[1]).toEqual(peer3)
+        expect(contacts[0]).toEqual(item1)
+        expect(contacts[1]).toEqual(item3)
     })
 
     it('cannot exceed maxSize', async () => {
-        const list = new SortedContactList(getId(descriptor0), 3)
+        const list = new SortedContactList(item0.getPeerId(), 3)
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
-        list.addContact(peer1)
-        list.addContact(peer4)
-        list.addContact(peer3)
-        list.addContact(peer2)
+        list.addContact(item1)
+        list.addContact(item4)
+        list.addContact(item3)
+        list.addContact(item2)
         expect(list.getSize()).toEqual(3)
-        expect(onContactRemoved).toBeCalledWith(descriptor4, [descriptor1, descriptor2, descriptor3])
-        expect(list.getContact(getId(descriptor4))).toBeFalsy()
+        expect(onContactRemoved).toBeCalledWith(item4, [item1, item2, item3])
+        expect(list.getContact(item4.getPeerId())).toBeFalsy()
     })
 
     it('removing contacts', async () => {
-        const list = new SortedContactList(getId(descriptor0), 8)
+        const list = new SortedContactList(item0.getPeerId(), 8)
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
-        list.addContact(peer4)
-        list.addContact(peer3)
-        list.addContact(peer2)
-        list.addContact(peer1)
-        list.removeContact(getId(descriptor2))
+        list.addContact(item4)
+        list.addContact(item3)
+        list.addContact(item2)
+        list.addContact(item1)
+        list.removeContact(item2.getPeerId())
         expect(list.getSize()).toEqual(3)
-        expect(list.getContact(getId(descriptor2))).toBeFalsy()
+        expect(list.getContact(item2.getPeerId())).toBeFalsy()
         expect(list.getContactIds()).toEqual(list.getContactIds().sort(list.compareIds))
-        expect(list.getAllContacts()).toEqual([peer1, peer3, peer4])
-        expect(onContactRemoved).toBeCalledWith(descriptor2, [descriptor1, descriptor3, descriptor4])
+        expect(list.getAllContacts()).toEqual([item1, item3, item4])
+        expect(onContactRemoved).toBeCalledWith(item2, [item1, item3, item4])
         const ret = list.removeContact(PeerID.fromValue(Buffer.from([0, 0, 0, 6])))
         expect(ret).toEqual(false)
     })
 
     it('get closes contacts', () => {
-        const list = new SortedContactList(getId(descriptor0), 8)
-        list.addContact(peer1)
-        list.addContact(peer3)
-        list.addContact(peer4)
-        list.addContact(peer2)
-        expect(list.getClosestContacts(2)).toEqual([peer1, peer2])
-        expect(list.getClosestContacts()).toEqual([peer1, peer2, peer3, peer4])
+        const list = new SortedContactList(item0.getPeerId(), 8)
+        list.addContact(item1)
+        list.addContact(item3)
+        list.addContact(item4)
+        list.addContact(item2)
+        expect(list.getClosestContacts(2)).toEqual([item1, item2])
+        expect(list.getClosestContacts()).toEqual([item1, item2, item3, item4])
     })
 
     it('get active contacts', () => {
-        const list = new SortedContactList(getId(descriptor0), 8)
-        list.addContact(peer1)
-        list.addContact(peer3)
-        list.addContact(peer4)
-        list.addContact(peer2)
-        list.setActive(getId(descriptor2))
-        list.setActive(getId(descriptor3))
-        list.setActive(getId(descriptor4))
-        expect(list.getActiveContacts()).toEqual([peer2, peer3, peer4])
+        const list = new SortedContactList(item0.getPeerId(), 8)
+        list.addContact(item1)
+        list.addContact(item3)
+        list.addContact(item4)
+        list.addContact(item2)
+        list.setActive(item2.getPeerId())
+        list.setActive(item3.getPeerId())
+        list.setActive(item4.getPeerId())
+        expect(list.getActiveContacts()).toEqual([item2, item3, item4])
     })
 })