@streamr/dht 0.0.1-tatum.0

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

@@ -0,0 +1,108 @@
+// @generated by protobuf-ts 2.8.2 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";
+import { Empty } from "../../../google/protobuf/empty";
+import { Any } from "../../../google/protobuf/any";
+/**
+ * @generated from protobuf message protorpc.RpcMessage
+ */
+export interface RpcMessage {
+    /**
+     * @generated from protobuf field: map<string, string> header = 1;
+     */
+    header: {
+        [key: string]: string;
+    };
+    /**
+     * @generated from protobuf field: google.protobuf.Any body = 2;
+     */
+    body?: Any;
+    /**
+     * @generated from protobuf field: string requestId = 3;
+     */
+    requestId: string;
+    /**
+     * @generated from protobuf field: optional protorpc.RpcErrorType errorType = 4;
+     */
+    errorType?: RpcErrorType;
+    /**
+     * @generated from protobuf field: optional string errorClassName = 5;
+     */
+    errorClassName?: string;
+    /**
+     * @generated from protobuf field: optional string errorCode = 6;
+     */
+    errorCode?: string;
+    /**
+     * @generated from protobuf field: optional string errorMessage = 7;
+     */
+    errorMessage?: string;
+}
+// Dummy message to force the generation of the typescript class "google.prototype.Empty"
+// We need this generated class in RpcCommunicator
+
+/**
+ * @generated from protobuf message protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq
+ */
+export interface Mnfo2uhnf92hvqi2nviouq2hv9puhq {
+    /**
+     * @generated from protobuf field: google.protobuf.Empty empty = 1;
+     */
+    empty?: Empty;
+}
+/**
+ * @generated from protobuf enum protorpc.RpcErrorType
+ */
+export enum RpcErrorType {
+    /**
+     * @generated from protobuf enum value: SERVER_TIMEOUT = 0;
+     */
+    SERVER_TIMEOUT = 0,
+    /**
+     * @generated from protobuf enum value: CLIENT_TIMEOUT = 1;
+     */
+    CLIENT_TIMEOUT = 1,
+    /**
+     * @generated from protobuf enum value: UNKNOWN_RPC_METHOD = 2;
+     */
+    UNKNOWN_RPC_METHOD = 2,
+    /**
+     * @generated from protobuf enum value: CLIENT_ERROR = 3;
+     */
+    CLIENT_ERROR = 3,
+    /**
+     * @generated from protobuf enum value: SERVER_ERROR = 4;
+     */
+    SERVER_ERROR = 4
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class RpcMessage$Type extends MessageType<RpcMessage> {
+    constructor() {
+        super("protorpc.RpcMessage", [
+            { no: 1, name: "header", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } },
+            { no: 2, name: "body", kind: "message", T: () => Any },
+            { no: 3, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "errorType", kind: "enum", opt: true, T: () => ["protorpc.RpcErrorType", RpcErrorType] },
+            { no: 5, name: "errorClassName", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "errorCode", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "errorMessage", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message protorpc.RpcMessage
+ */
+export const RpcMessage = new RpcMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Mnfo2uhnf92hvqi2nviouq2hv9puhq$Type extends MessageType<Mnfo2uhnf92hvqi2nviouq2hv9puhq> {
+    constructor() {
+        super("protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq", [
+            { no: 1, name: "empty", kind: "message", T: () => Empty }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq
+ */
+export const Mnfo2uhnf92hvqi2nviouq2hv9puhq = new Mnfo2uhnf92hvqi2nviouq2hv9puhq$Type();

package/src/proto/tests.ts

@@ -0,0 +1,52 @@
+// @generated by protobuf-ts 2.8.0 with parameter server_generic,generate_dependencies
+// @generated from protobuf file "tests.proto" (package "tests", syntax proto3)
+// tslint:disable
+import { MessageType } from "@protobuf-ts/runtime";
+import { Any } from "./google/protobuf/any";
+/**
+ * @generated from protobuf message tests.TestMessage
+ */
+export interface TestMessage {
+    /**
+     * @generated from protobuf field: string messageId = 1;
+     */
+    messageId: string;
+    /**
+     * @generated from protobuf field: google.protobuf.Any body = 2;
+     */
+    body?: Any;
+}
+/**
+ * @generated from protobuf message tests.SomeMessage
+ */
+export interface SomeMessage {
+    /**
+     * @generated from protobuf field: string juttu = 1;
+     */
+    juttu: string;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class TestMessage$Type extends MessageType<TestMessage> {
+    constructor() {
+        super("tests.TestMessage", [
+            { no: 1, name: "messageId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "body", kind: "message", T: () => Any }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message tests.TestMessage
+ */
+export const TestMessage = new TestMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SomeMessage$Type extends MessageType<SomeMessage> {
+    constructor() {
+        super("tests.SomeMessage", [
+            { no: 1, name: "juttu", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message tests.SomeMessage
+ */
+export const SomeMessage = new SomeMessage$Type();

package/src/rpc-protocol/DhtCallContext.ts

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

package/src/rpc-protocol/DhtRpcOptions.ts

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

package/src/transport/ITransport.ts

@@ -0,0 +1,31 @@
+import { Message, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+
+export type DisconnectionType = 'OUTGOING_GRACEFUL_DISCONNECT' | 'OUTGOING_GRACEFUL_LEAVE' |
+    'INCOMING_GRACEFUL_DISCONNECT' | 'INCOMING_GRACEFUL_LEAVE' | 'OTHER'
+
+export interface TransportEvents {
+    disconnected: (peerDescriptor: PeerDescriptor, disconnectionType: DisconnectionType) => void
+    message: (message: Message) => void
+    connected: (peerDescriptor: PeerDescriptor) => void
+
+}
+
+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, disconnectionType: DisconnectionType) => 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, 
+        disconnectionType: DisconnectionType) => 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, disconnectionType: DisconnectionType) => void): void
+
+    send(msg: Message, doNotConnect?: boolean): Promise<void>
+    getPeerDescriptor(): PeerDescriptor
+    getAllConnectionPeerDescriptors(): PeerDescriptor[]
+    stop(): void | Promise<void>
+}

package/src/transport/ListeningRpcCommunicator.ts

@@ -0,0 +1,14 @@
+import { ITransport } from './ITransport' 
+import { RoutingRpcCommunicator } from './RoutingRpcCommunicator'
+import { RpcCommunicatorConfig } from '@streamr/proto-rpc'
+import { Message } from '../proto/packages/dht/protos/DhtRpc'
+
+export class ListeningRpcCommunicator extends RoutingRpcCommunicator {
+    constructor(ownServiceId: string, transport: ITransport, config?: RpcCommunicatorConfig) {
+        super(ownServiceId, transport.send, config)
+        
+        transport.on('message', (msg: Message) => {
+            this.handleMessageFromPeer(msg)
+        })
+    }
+}

package/src/transport/RoutingRpcCommunicator.ts

@@ -0,0 +1,59 @@
+import { Message, MessageType, 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'
+
+export class RoutingRpcCommunicator extends RpcCommunicator {
+    private ownServiceId: string
+    private sendFn: (msg: Message, doNotConnect?: boolean, doNotMindStopped?: boolean) => Promise<void>
+
+    constructor(
+        ownServiceId: string,
+        sendFn: (msg: Message, doNotConnect?: boolean) => Promise<void>,
+        config?: RpcCommunicatorConfig
+    ) {
+        super(config)
+        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
+                },
+                messageType: MessageType.RPC, 
+                targetDescriptor: 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)
+            }
+
+        })
+    }
+
+    public handleMessageFromPeer(message: Message): void {
+        if (message.serviceId == this.ownServiceId && message.body.oneofKind === 'rpcMessage') {
+            const context = new DhtCallContext()
+            context.incomingSourceDescriptor = message.sourceDescriptor
+            this.handleIncomingMessage(message.body.rpcMessage, context)
+        }
+    }
+}

package/src/types/glogal.d.ts

@@ -0,0 +1 @@
+import 'jest-extended'

package/src/types/textencoding.d.ts

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

package/test/RandomGraphSimulation.ts

@@ -0,0 +1,52 @@
+/* eslint-disable no-console */
+
+import KBucket from 'k-bucket'
+import { range } from 'lodash'
+
+const compareIds = (id1: Uint8Array, id2: Uint8Array) => {
+    const sorted = [id1, id2].sort()
+    return KBucket.distance(sorted[0], sorted[1])
+}
+
+const generateIDs = (count: number): Uint8Array[] => {
+    return range(count).map((i) => new Uint8Array([i, 1, 1]))
+}
+
+const count = 9
+const ids = generateIDs(count)
+
+const distances = ids.map((id1) => ids.map((id2) => {
+    return {
+        distance: compareIds(id1, id2),
+        id: id2.toString()
+    }
+}))
+
+const graph: any[] = []
+for (let i = 0; i < count; i++) {
+    const sorted = distances[i].sort((a, b) => a.distance - b.distance)
+    graph.push([sorted[1], sorted[2], sorted[3], sorted[4]])
+}
+const result = new Map<string, number>()
+ids.forEach((key) => {
+    result.set(key.toString(), 0)
+})
+
+for (let i = 0; i < count; i++) {
+    graph[i].forEach((val: any) => {
+        result.set(val.id, result.get(val.id)! + 1)
+    })
+}
+
+const bidirectional = ids.map((id, i) => {
+    const stringId = id.toString()
+    const allFound = graph[i].some((obj: any) => {
+        const neighborId = obj.id
+        const neighborIndex = parseInt(neighborId.split(',')[0])
+        return graph[neighborIndex].some((obj: any) => obj.id === stringId)
+    })
+    return allFound
+})
+
+console.log(bidirectional)
+console.log(graph)

package/test/benchmark/KademliaCorrectness.test.ts

@@ -0,0 +1,115 @@
+/* eslint-disable no-console */
+import { 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'
+
+describe('Kademlia correctness', () => {
+    let entryPoint: DhtNode
+    let nodes: DhtNode[]
+    let entrypointDescriptor: PeerDescriptor
+    const simulator = new Simulator()
+    const NUM_NODES = 1000
+
+    const nodeIndicesById: Record<string, 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: 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 () => {
+
+        nodes = []
+        const entryPointId = '0'
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), 8)
+        nodes.push(entryPoint)
+        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
+        entrypointDescriptor = {
+            kademliaId: entryPoint.getNodeId().value,
+            type: NodeType.NODEJS
+        }
+
+        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
+            nodes.push(node)
+        }
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            entryPoint.stop(),
+            ...nodes.map(async (node) => await node.stop())
+        ])
+    })
+
+    it('Can find correct neighbors', async () => {
+        await entryPoint.joinDht([entrypointDescriptor])
+
+        await Promise.allSettled(
+            nodes.map((node) => node.joinDht([entrypointDescriptor]))
+        )
+
+        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].getNeighborList().getContactIds()
+
+            let kadString = 'kademliaNeighbors: '
+            kademliaNeighbors.forEach((neighbor) => {
+                kadString += nodeIndicesById[neighbor.toKey()] + ','
+            })
+
+            let correctNeighbors = 0
+            try {
+                for (let j = 0; j < groundTruth[i + ''].length; j++) {
+                    if (groundTruth[i + ''][j].name != (nodeIndicesById[kademliaNeighbors[j].toKey()] + '')) {
+                        break
+                    }
+                    correctNeighbors++
+                }
+            } catch (e) {
+                console.error('Node ' + nodes[i].getNodeName() + ' 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].getBucketSize()
+                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)
+    })
+})

package/test/benchmark/RecursiveFind.test.ts

@@ -0,0 +1,87 @@
+/* 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, peerIdFromPeerDescriptor } from '../../src/exports'
+import { Logger, wait } from '@streamr/utils'
+import { debugVars } from '../../src/helpers/debugHelpers'
+
+const logger = new Logger(module)
+
+describe('Recursive 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')
+    }
+
+    const dhtIds: Array<{ type: string, data: Array<number> }> = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+
+    beforeEach(async () => {
+
+        nodes = []
+        const entryPointId = '0'
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), undefined, entryPointId)
+        nodes.push(entryPoint)
+        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
+        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, Uint8Array.from(dhtIds[i].data), undefined, nodeId)
+            nodeIndicesById[node.getNodeId().toKey()] = i
+            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([entrypointDescriptor])
+
+        await Promise.all(
+            nodes.map((node) => node.joinDht([entrypointDescriptor]))
+        )
+
+        logger.info('waiting 120s')
+        debugVars['waiting'] = true
+
+        await wait(120000)
+        debugVars['waiting'] = false
+        logger.info('waiting over')
+
+        nodes.forEach((node) => logger.info(node.getNodeName() + ': connections:' +
+            node.getNumberOfConnections() + ', kbucket: ' + node.getBucketSize()
+            + ', localLocked: ' + node.getNumberOfLocalLockedConnections()
+            + ', remoteLocked: ' + node.getNumberOfRemoteLockedConnections()
+            + ', weakLocked: ' + node.getNumberOfWeakLockedConnections()))
+
+        logger.info('starting recursive find')
+        const kademliaIdToFind = Uint8Array.from(dhtIds[9].data)
+        const results = await nodes[159].startRecursiveFind(kademliaIdToFind)
+        logger.info('recursive find over')
+        expect(results.closestNodes).toBeGreaterThanOrEqual(5)
+        expect(PeerID.fromValue(kademliaIdToFind).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
+
+    }, 180000)
+})

package/test/benchmark/any.test.ts

@@ -0,0 +1,28 @@
+import { Logger } from '@streamr/utils'
+import { Any } from '../../src/proto/google/protobuf/any'
+import { SomeMessage, TestMessage } from '../../src/proto/tests'
+
+const logger = new Logger(module)
+
+const some: SomeMessage = SomeMessage.create({
+    juttu: 'kivaa'
+})
+logger.info(SomeMessage.typeName)
+
+const message: TestMessage = TestMessage.create({
+    messageId: 'jee',
+    body: Any.pack(some, SomeMessage)
+})
+
+const binary = TestMessage.toBinary(message)
+
+const recovered = TestMessage.fromBinary(binary)
+const jee = Any.unpack(recovered.body!, SomeMessage)
+logger.info(JSON.stringify(jee))
+
+logger.info(TestMessage.toJsonString(recovered, {
+    typeRegistry: [
+        TestMessage,
+        SomeMessage
+    ]
+}))

package/test/benchmark/kademlia-simulation/Contact.ts

@@ -0,0 +1,32 @@
+import { PeerID } from '../../../src/helpers/PeerID'
+import type { SimulationNode } from './SimulationNode'
+import { NodeType, PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
+
+export class Contact {
+    private static counter = 0
+
+    public peerId: PeerID
+    public id: Uint8Array
+    public vectorClock = 0
+    public dhtNode: SimulationNode | undefined
+
+    constructor(ownId: PeerID, dhtNode?: SimulationNode) {
+        this.peerId = ownId
+        this.vectorClock = Contact.counter++
+        this.dhtNode = dhtNode
+        this.id = ownId.value
+    }
+
+    getPeerDescriptor(): PeerDescriptor {
+        const peerDescriptor: PeerDescriptor = {
+            kademliaId: this.peerId.value,
+            type: NodeType.NODEJS
+        }
+        return peerDescriptor
+    }
+
+    getPeerId(): PeerID {
+        return this.peerId
+    }
+
+}