@streamr/dht 100.0.0-testnet-one.4 → 100.0.0-testnet-two.1

package/src/dht/store/StoreRpcLocal.ts

@@ -1,340 +1,64 @@
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { Logger } from '@streamr/utils'
+import { Empty } from '../../proto/google/protobuf/empty'
+import { Timestamp } from '../../proto/google/protobuf/timestamp'
 import {
-    DataEntry, ReplicateDataRequest, PeerDescriptor,
+    DataEntry,
+    PeerDescriptor,
+    ReplicateDataRequest,
     StoreDataRequest, StoreDataResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../helpers/PeerID'
-import { Any } from '../../proto/google/protobuf/any'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { IStoreRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { StoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { IFinder } from '../find/Finder'
-import { areEqualPeerDescriptors } from '../../helpers/peerIdFromPeerDescriptor'
-import { Logger } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
-import { IStoreRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
-import { StoreRpcRemote } from './StoreRpcRemote'
-import { Timestamp } from '../../proto/google/protobuf/timestamp'
-import EventEmitter from 'eventemitter3'
-import { Events } from '../DhtNode'
-import { SortedContactList } from '../contact/SortedContactList'
-import { Contact } from '../contact/Contact'
-import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { ServiceID } from '../../types/ServiceID'
-import { Empty } from '../../proto/google/protobuf/empty'
 
-interface DataStoreConfig {
-    rpcCommunicator: RoutingRpcCommunicator
-    finder: IFinder
-    localPeerDescriptor: PeerDescriptor
+interface StoreRpcLocalConfig {
     localDataStore: LocalDataStore
-    serviceId: ServiceID
-    maxTtl: number
-    highestTtl: number
-    redundancyFactor: number
-    dhtNodeEmitter: EventEmitter<Events>
-    getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtNodeRpcRemote[]
-    rpcRequestTimeout?: number
+    replicateDataToNeighbors: (incomingPeer: PeerDescriptor, dataEntry: DataEntry) => void
+    selfIsWithinRedundancyFactor: (key: Uint8Array) => boolean
 }
 
 const logger = new Logger(module)
 
 export class StoreRpcLocal implements IStoreRpc {
 
-    private readonly rpcCommunicator: RoutingRpcCommunicator
-    private readonly finder: IFinder
-    private readonly localPeerDescriptor: PeerDescriptor
-    private readonly localDataStore: LocalDataStore
-    private readonly serviceId: ServiceID
-    private readonly maxTtl: number
-    private readonly highestTtl: number
-    private readonly redundancyFactor: number
-    private readonly dhtNodeEmitter: EventEmitter<Events>
-    private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtNodeRpcRemote[]
-    private readonly rpcRequestTimeout?: number
-
-    constructor(config: DataStoreConfig) {
-        this.rpcCommunicator = config.rpcCommunicator
-        this.finder = config.finder
-        this.localPeerDescriptor = config.localPeerDescriptor
-        this.localDataStore = config.localDataStore
-        this.serviceId = config.serviceId
-        this.maxTtl = config.maxTtl
-        this.highestTtl = config.highestTtl
-        this.redundancyFactor = config.redundancyFactor
-        this.dhtNodeEmitter = config.dhtNodeEmitter
-        this.rpcRequestTimeout = config.rpcRequestTimeout
-        this.getNodesClosestToIdFromBucket = config.getNodesClosestToIdFromBucket
-        this.rpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData',
-            (request: StoreDataRequest) => this.storeData(request))
-        this.rpcCommunicator.registerRpcNotification(ReplicateDataRequest, 'replicateData',
-            (request: ReplicateDataRequest, context: ServerCallContext) => this.replicateData(request, context))
-
-        this.dhtNodeEmitter.on('newContact', (peerDescriptor: PeerDescriptor) => {
-            this.localDataStore.getStore().forEach((dataMap, _dataKey) => {
-                dataMap.forEach(async (dataEntry) => {
-                    if (this.shouldReplicateDataToNewNode(dataEntry.dataEntry, peerDescriptor)) {
-                        try {
-                            await this.replicateDataToContact(dataEntry.dataEntry, peerDescriptor)
-                        } catch (e) {
-                            logger.trace('replicateDataToContact() failed', { error: e })
-                        }
-                    }
-                })
-            })
-        })
-    }
-
-    private shouldReplicateDataToNewNode(dataEntry: DataEntry, newNode: PeerDescriptor): boolean {
+    private readonly config: StoreRpcLocalConfig
 
-        const dataId = PeerID.fromValue(dataEntry.key)
-        const newNodeId = PeerID.fromValue(newNode.nodeId)
-        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.nodeId)
-
-        const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.key, 10)
-        const sortedList = new SortedContactList<Contact>({
-            referenceId: PeerID.fromValue(dataEntry.key), 
-            maxSize: 20,  // TODO use config option or named constant?
-            allowToContainReferenceId: true,
-            emitEvents: false
-        })
-        sortedList.addContact(new Contact(this.localPeerDescriptor))
-
-        closestToData.forEach((con) => {
-            if (!newNodeId.equals(PeerID.fromValue(con.getPeerDescriptor().nodeId))) {
-                sortedList.addContact(new Contact(con.getPeerDescriptor()))
-            }
-        })
-
-        if (!sortedList.getAllContacts()[0].getPeerId().equals(localPeerId)) {
-            // If we are not the closes node to the data, do not replicate
-            return false
-        }
-
-        this.localDataStore.setStale(dataId, dataEntry.creator!, false)
-        const newPeerId = PeerID.fromValue(newNode.nodeId)
-        sortedList.addContact(new Contact(newNode))
-
-        const sorted = sortedList.getAllContacts()
-
-        let index = 0
-
-        for (index = 0; index < sorted.length; index++) {
-            if (sorted[index].getPeerId().equals(newPeerId)) {
-                break
-            }
-        }
-
-        // if new node is within the storageRedundancyFactor closest nodes to the data
-        // do replicate data to it
-
-        if (index < this.redundancyFactor) {
-            return true
-        } else {
-            return false
-        }
+    constructor(config: StoreRpcLocalConfig) {
+        this.config = config
     }
 
-    private async replicateDataToContact(dataEntry: DataEntry, contact: PeerDescriptor, doNotConnect: boolean = false): Promise<void> {
-        const rpcRemote = new StoreRpcRemote(
-            this.localPeerDescriptor,
-            contact,
-            this.serviceId,
-            toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport())),
-            this.rpcRequestTimeout
-        )
-        try {
-            await rpcRemote.replicateData({ entry: dataEntry }, doNotConnect)
-        } catch (e) {
-            logger.trace('replicateData() threw an exception ' + e)
-        }
-    }
-
-    public async storeDataToDht(key: Uint8Array, data: Any, creator: PeerDescriptor): Promise<PeerDescriptor[]> {
-        logger.debug(`Storing data to DHT ${this.serviceId}`)
-        const result = await this.finder.startFind(key)
-        const closestNodes = result.closestNodes
-        const successfulNodes: PeerDescriptor[] = []
-        const ttl = this.highestTtl // ToDo: make TTL decrease according to some nice curve
-        const createdAt = Timestamp.now()
-        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.redundancyFactor; i++) {
-            if (areEqualPeerDescriptors(this.localPeerDescriptor, closestNodes[i])) {
-                this.localDataStore.storeEntry({
-                    key, 
-                    data,
-                    creator,
-                    createdAt,
-                    storedAt: Timestamp.now(), 
-                    ttl, 
-                    stale: false,
-                    deleted: false,
-                })
-                successfulNodes.push(closestNodes[i])
-                continue
-            }
-            const rpcRemote = new StoreRpcRemote(
-                this.localPeerDescriptor,
-                closestNodes[i],
-                this.serviceId,
-                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport())),
-                this.rpcRequestTimeout
-            )
-            try {
-                const response = await rpcRemote.storeData({
-                    key,
-                    data,
-                    creator,
-                    createdAt,
-                    ttl
-                })
-                if (!response.error) {
-                    successfulNodes.push(closestNodes[i])
-                    logger.trace('remote.storeData() returned success')
-                } else {
-                    logger.trace('remote.storeData() returned error: ' + response.error)
-                }
-            } catch (e) {
-                logger.trace('remote.storeData() threw an exception ' + e)
-            }
-        }
-        return successfulNodes
-    }
-
-    private selfIsOneOfClosestPeers(dataId: Uint8Array): boolean {
-        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.nodeId)
-        const closestPeers = this.getNodesClosestToIdFromBucket(dataId, this.redundancyFactor)
-        const sortedList = new SortedContactList<Contact>({
-            referenceId: localPeerId, 
-            maxSize: this.redundancyFactor, 
-            allowToContainReferenceId: true, 
-            emitEvents: false
-        })
-        sortedList.addContact(new Contact(this.localPeerDescriptor))
-        closestPeers.forEach((con) => sortedList.addContact(new Contact(con.getPeerDescriptor())))
-        return sortedList.getClosestContacts().some((node) => node.getPeerId().equals(localPeerId))
-    }
-
-    // RPC service implementation
     async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
-        const ttl = Math.min(request.ttl, this.maxTtl)
-        const { key, data, createdAt, creator } = request
-        this.localDataStore.storeEntry({ 
+        logger.trace('storeData()')
+        const { key, data, creator, createdAt, ttl } = request
+        const selfIsOneOfClosestPeers = this.config.selfIsWithinRedundancyFactor(key)
+        this.config.localDataStore.storeEntry({ 
             key, 
             data,
             creator, 
             createdAt,
             storedAt: Timestamp.now(),
             ttl,
-            stale: !this.selfIsOneOfClosestPeers(key),
+            stale: !selfIsOneOfClosestPeers,
             deleted: false
         })
-        
-        if (!this.selfIsOneOfClosestPeers(key)) {
-            this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(key))
+        if (!selfIsOneOfClosestPeers) {
+            this.config.localDataStore.setAllEntriesAsStale(key)
         }
-
-        logger.trace('storeData()')
-        return StoreDataResponse.create()
-    }
-
-    async destroy(): Promise<void> {
-        await this.replicateDataToClosestNodes()
-    }
-
-    private async replicateDataToClosestNodes(): Promise<void> {
-        const dataEntries = Array.from(this.localDataStore.getStore().values())
-            .flatMap((dataMap) => Array.from(dataMap.values()))
-            .map((localData) => localData.dataEntry)
-
-        await Promise.all(dataEntries.map(async (dataEntry) => {
-            const dhtNodeRemotes = this.getNodesClosestToIdFromBucket(dataEntry.key, this.redundancyFactor)
-            await Promise.all(dhtNodeRemotes.map(async (remoteDhtNode) => {
-                const rpcRemote = new StoreRpcRemote(
-                    this.localPeerDescriptor,
-                    remoteDhtNode.getPeerDescriptor(),
-                    this.serviceId,
-                    toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport())),
-                    this.rpcRequestTimeout
-                )
-                try {
-                    await rpcRemote.replicateData({ entry: dataEntry })
-                } catch (err) {
-                    logger.trace('Failed to replicate data in replicateDataToClosestNodes', { error: err })
-                }
-            }))
-        }))
+        return {}
     }
 
-    // RPC service implementation
     public async replicateData(request: ReplicateDataRequest, context: ServerCallContext): Promise<Empty> {
         logger.trace('server-side replicateData()')
         const dataEntry = request.entry!
-
-        const wasStored = this.localDataStore.storeEntry(dataEntry)
-        
+        const wasStored = this.config.localDataStore.storeEntry(dataEntry)
         if (wasStored) {
-            this.replicateDataToNeighborsIfNeeded((context as DhtCallContext).incomingSourceDescriptor!, request.entry!)
+            this.config.replicateDataToNeighbors((context as DhtCallContext).incomingSourceDescriptor!, request.entry!)
         }
-        if (!this.selfIsOneOfClosestPeers(dataEntry.key)) {
-            this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(dataEntry.key))
+        if (!this.config.selfIsWithinRedundancyFactor(dataEntry.key)) {
+            this.config.localDataStore.setAllEntriesAsStale(dataEntry.key)
         }
         logger.trace('server-side replicateData() at end')
         return {}
     }
-
-    private replicateDataToNeighborsIfNeeded(incomingPeer: PeerDescriptor, dataEntry: DataEntry): void {
-
-        // sort own contact list according to data id
-        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.nodeId)
-        const dataId = PeerID.fromValue(dataEntry.key)
-        const incomingPeerId = PeerID.fromValue(incomingPeer.nodeId)
-        const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.key, 10)
-        const sortedList = new SortedContactList<Contact>({
-            referenceId: dataId, 
-            maxSize: this.redundancyFactor, 
-            allowToContainReferenceId: true, 
-            emitEvents: false
-        })
-        sortedList.addContact(new Contact(this.localPeerDescriptor))
-
-        closestToData.forEach((con) => {
-            sortedList.addContact(new Contact(con.getPeerDescriptor()))
-        })
-
-        if (!sortedList.getAllContacts()[0].getPeerId().equals(localPeerId)) {
-            // If we are not the closest node to the data, replicate only to the 
-            // closest one to the data
-
-            const contact = sortedList.getAllContacts()[0]
-            const contactPeerId = PeerID.fromValue(contact.getPeerDescriptor().nodeId)
-            if (!incomingPeerId.equals(contactPeerId) && !localPeerId.equals(contactPeerId)) {
-                setImmediate(async () => {
-                    try {
-                        await this.replicateDataToContact(dataEntry, contact.getPeerDescriptor())
-                        logger.trace('replicateDataToContact() returned when migrating to only the closest contact')
-                    } catch (e) {
-                        logger.error('replicating data to only the closest contact failed ' + e)
-                    }
-                })
-            }
-        } else {
-            // if we are the closest to the data, replicate to all storageRedundancyFactor nearest
-            sortedList.getAllContacts().forEach((contact) => {
-                const contactPeerId = PeerID.fromValue(contact.getPeerDescriptor().nodeId)
-                if (!incomingPeerId.equals(contactPeerId) && !localPeerId.equals(contactPeerId)) {
-                    if (!incomingPeerId.equals(contactPeerId) && !localPeerId.equals(contactPeerId)) {
-                        setImmediate(async () => {
-                            try {
-                                await this.replicateDataToContact(dataEntry, contact.getPeerDescriptor())
-                                logger.trace('replicateDataToContact() returned')
-                            } catch (e) {
-                                logger.error('replicating data to one of the closest contacts failed ' + e)
-                            }
-                        })
-                    }
-                }
-            })
-        }
-    }
 }

package/src/dht/store/StoreRpcRemote.ts

@@ -1,18 +1,17 @@
-import { EXISTING_CONNECTION_TIMEOUT, RpcRemote } from '../contact/RpcRemote'
-import { IStoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import {
     ReplicateDataRequest,
-    StoreDataRequest,
-    StoreDataResponse
+    StoreDataRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { StoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { EXISTING_CONNECTION_TIMEOUT, RpcRemote } from '../contact/RpcRemote'
 
-export class StoreRpcRemote extends RpcRemote<IStoreRpcClient> {
+export class StoreRpcRemote extends RpcRemote<StoreRpcClient> {
 
-    async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
+    async storeData(request: StoreDataRequest): Promise<void> {
         const options = this.formDhtRpcOptions()
         try {
-            return await this.getClient().storeData(request, options)
+            await this.getClient().storeData(request, options)
         } catch (err) {
             const to = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
             const from = getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())
@@ -20,10 +19,9 @@ export class StoreRpcRemote extends RpcRemote<IStoreRpcClient> {
         }
     }
 
-    async replicateData(request: ReplicateDataRequest, doNotConnect: boolean = false): Promise<void> {
+    async replicateData(request: ReplicateDataRequest): Promise<void> {
         const options = this.formDhtRpcOptions({
-            timeout: EXISTING_CONNECTION_TIMEOUT,
-            doNotConnect
+            timeout: EXISTING_CONNECTION_TIMEOUT
         })
         return this.getClient().replicateData(request, options)
     }

package/src/exports.ts

@@ -7,6 +7,7 @@ export { getRandomRegion, getRegionDelayMatrix } from './connection/simulator/pi
 export { PeerDescriptor, Message, NodeType, DataEntry } from './proto/packages/dht/protos/DhtRpc'
 export { ITransport } from './transport/ITransport'
 export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
+export { LockID } from './connection/ConnectionLockHandler'
 export { DefaultConnectorFacade } from './connection/ConnectorFacade'
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
 export { RpcRemote, EXISTING_CONNECTION_TIMEOUT } from './dht/contact/RpcRemote'
@@ -17,3 +18,4 @@ export { ClientWebsocket } from './connection/websocket/ClientWebsocket'
 export { ManagedConnection } from './connection/ManagedConnection'
 export { ConnectionType } from './connection/IConnection'
 export { PeerID } from './helpers/PeerID'
+export { ServiceID } from './types/ServiceID'

package/src/helpers/MapWithTtl.ts

@@ -0,0 +1,71 @@
+interface ValueWrapper<V> {
+    value: V
+    timeout: NodeJS.Timeout
+}
+
+export class MapWithTtl<K, V> {
+
+    private readonly delegate: Map<K, ValueWrapper<V>> = new Map()
+    private readonly getTtl: (value: V) => number
+
+    constructor(getTtl: (value: V) => number) {
+        this.getTtl = getTtl
+    }
+
+    set(key: K, value: V): void {
+        const existing = this.delegate.get(key)
+        if (existing !== undefined) {
+            clearTimeout(existing.timeout)
+        }
+        this.delegate.set(key, {
+            value,
+            timeout: this.createTimeout(key, value)
+        })
+    }
+
+    get(key: K): V | undefined {
+        const wrapper = this.delegate.get(key)
+        return wrapper?.value
+    }
+
+    has(key: K): boolean {
+        return this.delegate.has(key)
+    }
+
+    delete(key: K): void {
+        const existing = this.delegate.get(key)
+        if (existing !== undefined) {
+            clearTimeout(existing.timeout)
+            this.delegate.delete(key)
+        }
+    }
+
+    clear(): void {
+        this.delegate.forEach((value) => {
+            clearTimeout(value.timeout)
+        })
+        this.delegate.clear()
+    }
+
+    size(): number {
+        return this.delegate.size
+    }
+
+    *values(): IterableIterator<V> {
+        for (const v of this.delegate.values()) {
+            yield v.value
+        }
+    }
+
+    forEach(cb: (value: V, key: K) => void): void {
+        this.delegate.forEach((valueWrapper: ValueWrapper<V>, key: K) => {
+            cb(valueWrapper.value, key)
+        })
+    }
+
+    private createTimeout(key: K, value: V): NodeJS.Timeout {
+        return setTimeout(() => {
+            this.delete(key)
+        }, this.getTtl(value))
+    }
+}

package/src/helpers/PeerID.ts

@@ -2,6 +2,7 @@ import { BrandedString, binaryToHex } from '@streamr/utils'
 import { UUID } from './UUID'
 import { IllegalArguments } from './errors'
 import crypto from 'crypto'
+import { NodeID, getNodeIdFromBinary } from './nodeId'
 
 export type PeerIDKey = BrandedString<'PeerIDKey'>
 
@@ -75,6 +76,10 @@ export class PeerID {
         return this.key
     }
 
+    toNodeId(): NodeID {
+        return getNodeIdFromBinary(this.data)
+    }
+
     get value(): Uint8Array {
         return this.data
     }

package/src/helpers/nodeId.ts

@@ -1,8 +1,28 @@
+import { BrandedString, binaryToHex } from '@streamr/utils'
 import crypto from 'crypto'
 
 // https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
 const KADEMLIA_ID_LENGTH_IN_BYTES = 20
 
+// TODO this should return NodeID
 export const createRandomNodeId = (): Uint8Array => {
     return crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES)
 }
+
+// TODO rename the file to be "NodeID.ts" instead of "nodeId.ts"
+export type NodeID = BrandedString<'NodeID'>
+
+// TODO remove this or add support for UInt8Array parameters
+export const areEqualNodeIds = (nodeId1: NodeID, nodeId2: NodeID): boolean => {
+    return nodeId1 === nodeId2
+}
+
+// TODO maybe this is not needed and we can use just getNodeIdFromBinary?
+export const getNodeIdFromDataKey = (key: Uint8Array): NodeID => {
+    return getNodeIdFromBinary(key)
+}
+
+// TODO should we have similar method to convert nodeId to bucketId (which is just hexToBinary)
+export const getNodeIdFromBinary = (id: Uint8Array): NodeID => {
+    return binaryToHex(id) as unknown as NodeID
+}

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -1,14 +1,16 @@
 import { areEqualBinaries, binaryToHex } from '@streamr/utils'
 import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { PeerID, PeerIDKey, createPeerIDKey } from './PeerID'
+import { NodeID } from './nodeId'
 
 export const peerIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerID => {
     return PeerID.fromValue(peerDescriptor.nodeId)
 }
 
-// TODO could move getNodeIdFromPeerDescriptor (and NodeID) from trackerless-network
-export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): string => {
-    return binaryToHex(peerDescriptor.nodeId)
+// TODO could use this in trackerless-network (instead of copy-pasted same implementation)
+// and move this to nodeId.ts
+export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): NodeID => {
+    return binaryToHex(peerDescriptor.nodeId) as unknown as NodeID
 }
 
 export const keyFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerIDKey => {

package/src/helpers/protoClasses.ts

@@ -13,12 +13,11 @@ import {
     PeerDescriptor, 
     PingRequest, 
     PingResponse, 
-    FindResponse, 
-    FindRequest, 
+    RecursiveOperationResponse, 
+    RecursiveOperationRequest, 
     RouteMessageAck, 
     RouteMessageWrapper,
     WebsocketConnectionRequest,
-    WebsocketConnectionResponse,
     WebrtcConnectionRequest,
     RtcOffer,
     RtcAnswer,
@@ -32,8 +31,8 @@ import {
 export const protoClasses: Array<IMessageType<any>> = [
     ClosestPeersRequest,
     ClosestPeersResponse,
-    FindRequest,
-    FindResponse,
+    RecursiveOperationRequest,
+    RecursiveOperationResponse,
     PingRequest,
     PingResponse,
     LeaveNotice,
@@ -48,7 +47,6 @@ export const protoClasses: Array<IMessageType<any>> = [
     HandshakeResponse,
     Message,
     WebsocketConnectionRequest,
-    WebsocketConnectionResponse,
     WebrtcConnectionRequest,
     RtcOffer,
     RtcAnswer,

package/src/helpers/versionCompatibility.ts

@@ -0,0 +1,13 @@
+// Is able to compare versions such as 1.2.3 and 1.2.4
+// can also compare versions such as 100.0.0-pretestnet.0 and 100.0.0-pretestnet.40
+export const isCompatibleVersion = (version1: string, version2: string): boolean => {
+    const minorVersion1 = excludePatchVersion(version1)
+    const minorVersion2 = excludePatchVersion(version2)
+    return minorVersion1 === minorVersion2
+}
+
+export const excludePatchVersion = (version: string): string => {
+    const versionParts = version.split('.')
+    versionParts.pop()
+    return versionParts.join('.')
+}