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

package/src/connection/websocket/WebsocketServerConnector.ts

@@ -12,7 +12,7 @@ import { attachConnectivityRequestHandler, DISABLE_CONNECTIVITY_PROBE } from '..
 import { WebsocketServerConnection } from './WebsocketServerConnection'
 import { ConnectionType, IConnection } from '../IConnection'
 import queryString from 'querystring'
-import { isMaybeSupportedVersion, LOCAL_PROTOCOL_VERSION } from '../../helpers/version'
+import { isMaybeSupportedProtocolVersion, LOCAL_PROTOCOL_VERSION } from '../../helpers/version'
 import { shuffle } from 'lodash'
 import { sendConnectivityRequest } from '../connectivityChecker'
 import { acceptHandshake, Handshaker, rejectHandshake } from '../Handshaker'
@@ -114,23 +114,27 @@ export class WebsocketServerConnector {
     private attachHandshaker(connection: IConnection) {
         // TODO: use createIncomingHandshaker here?
         const handshaker = new Handshaker(this.localPeerDescriptor!, connection)
-        handshaker.once('handshakeRequest', (localPeerDescriptor: PeerDescriptor, sourceVersion: string, remotePeerDescriptor?: PeerDescriptor) => {
-            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, handshaker, sourceVersion, remotePeerDescriptor)
+        handshaker.once('handshakeRequest', (
+            localPeerDescriptor: PeerDescriptor,
+            remoteProtocolVersion: string,
+            remotePeerDescriptor?: PeerDescriptor
+        ) => {
+            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, handshaker, remoteProtocolVersion, remotePeerDescriptor)
         })
     }
 
     private onServerSocketHandshakeRequest(
-        sourcePeerDescriptor: PeerDescriptor,
+        remotePeerDescriptor: PeerDescriptor,
         websocketServerConnection: IConnection,
         handshaker: Handshaker,
-        remoteVersion: string,
+        remoteProtocolVersion: string,
         targetPeerDescriptor?: PeerDescriptor
     ) {
-        const nodeId = toNodeId(sourcePeerDescriptor)
+        const nodeId = toNodeId(remotePeerDescriptor)
         if (this.ongoingConnectRequests.has(nodeId)) {
             const { pendingConnection, delFunc } = this.ongoingConnectRequests.get(nodeId)!
-            if (!isMaybeSupportedVersion(remoteVersion)) {
-                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_VERSION)
+            if (!isMaybeSupportedProtocolVersion(remoteProtocolVersion)) {
+                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_PROTOCOL_VERSION)
                 delFunc()
             } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
                 rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
@@ -139,10 +143,10 @@ export class WebsocketServerConnector {
                 acceptHandshake(handshaker, pendingConnection, websocketServerConnection)
             }
         } else {
-            const pendingConnection = new PendingConnection(sourcePeerDescriptor)
+            const pendingConnection = new PendingConnection(remotePeerDescriptor)
             
-            if (!isMaybeSupportedVersion(remoteVersion)) {
-                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_VERSION)  
+            if (!isMaybeSupportedProtocolVersion(remoteProtocolVersion)) {
+                rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.UNSUPPORTED_PROTOCOL_VERSION)  
             } else if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
                 rejectHandshake(pendingConnection, websocketServerConnection, handshaker, HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)  
             } else if (this.options.onNewConnection(pendingConnection)) {
@@ -160,7 +164,7 @@ export class WebsocketServerConnector {
                 host: '127.0.0.1',
                 natType: NatType.UNKNOWN,
                 ipAddress: ipv4ToNumber('127.0.0.1'),
-                version: LOCAL_PROTOCOL_VERSION
+                protocolVersion: LOCAL_PROTOCOL_VERSION
             }
         }
         if (!this.options.entrypoints || this.options.entrypoints.length === 0) {
@@ -175,7 +179,7 @@ export class WebsocketServerConnector {
                 },
                 // TODO: Resolve the given host name or or use as is if IP was given. 
                 ipAddress: ipv4ToNumber('127.0.0.1'),
-                version: LOCAL_PROTOCOL_VERSION
+                protocolVersion: LOCAL_PROTOCOL_VERSION
             }
         }
         const shuffledEntrypoints = shuffle(this.options.entrypoints)

package/src/dht/DhtNode.ts

@@ -4,7 +4,7 @@ import {
     MetricsContext,
     merge,
     scheduleAtInterval,
-    waitForCondition
+    until
 } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sample } from 'lodash'
@@ -79,6 +79,10 @@ export interface DhtNodeOptions {
     storageRedundancyFactor?: number
     periodicallyPingNeighbors?: boolean
     periodicallyPingRingContacts?: boolean
+    // Limit for how many new neighbors to ping. If number of neighbors is higher than the limit new neighbors 
+    // are not pinged when they are added. This is to prevent flooding the network with pings when joining.
+    // Enable periodicallyPingNeighbors to eventually ping all neighbors.
+    neighborPingLimit?: number
 
     transport?: ITransport
     connectionsView?: ConnectionsView
@@ -340,7 +344,8 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             connectionLocker: this.connectionLocker,
             lockId: this.options.serviceId,
             createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => this.createDhtNodeRpcRemote(peerDescriptor),
-            hasConnection: (nodeId: DhtAddress) => this.connectionsView!.hasConnection(nodeId)
+            hasConnection: (nodeId: DhtAddress) => this.connectionsView!.hasConnection(nodeId),
+            neighborPingLimit: this.options.neighborPingLimit
         })
         this.peerManager.on('nearbyContactRemoved', (peerDescriptor: PeerDescriptor) => {
             this.emit('nearbyContactRemoved', peerDescriptor)
@@ -621,7 +626,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
  
     public async waitForNetworkConnectivity(): Promise<void> {
-        await waitForCondition(
+        await until(
             () => this.connectionsView!.getConnectionCount() > 0,
             this.options.networkConnectivityTimeout,
             100,

package/src/dht/DhtNodeRpcLocal.ts

@@ -19,7 +19,7 @@ import { RingIdRaw } from './contact/ringIdentifiers'
 
 interface DhtNodeRpcLocalOptions {
     peerDiscoveryQueryBatchSize: number
-    getNeighbors: () => ReadonlyArray<PeerDescriptor>
+    getNeighbors: () => readonly PeerDescriptor[]
     getClosestRingContactsTo: (id: RingIdRaw, limit: number) => RingContacts
     addContact: (contact: PeerDescriptor) => void
     removeContact: (nodeId: DhtAddress) => void

package/src/dht/PeerManager.ts

@@ -23,6 +23,7 @@ interface PeerManagerOptions {
     localNodeId: DhtAddress
     localPeerDescriptor: PeerDescriptor
     connectionLocker?: ConnectionLocker
+    neighborPingLimit?: number
     lockId: LockID
     createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
     hasConnection: (nodeId: DhtAddress) => boolean
@@ -154,7 +155,8 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             const nodeId = toNodeId(peerDescriptor)
             // Important to lock here, before the ping result is known
             this.options.connectionLocker?.weakLockConnection(nodeId, this.options.lockId)
-            if (this.options.hasConnection(contact.getNodeId())) {
+            if (this.options.hasConnection(contact.getNodeId()) 
+                || (this.options.neighborPingLimit !== undefined && this.neighbors.count() > this.options.neighborPingLimit)) {
                 logger.trace(`Added new contact ${nodeId}`)
             } else {    // open connection by pinging
                 logger.trace('starting ping ' + nodeId)
@@ -266,7 +268,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return this.neighbors.count()
     }
 
-    getNeighbors(): ReadonlyArray<DhtNodeRpcRemote> {
+    getNeighbors(): readonly DhtNodeRpcRemote[] {
         return this.neighbors.toArray()
     }
 

package/src/dht/contact/SortedContactList.ts

@@ -42,7 +42,7 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
 
     public addContact(contact: C): void {
         const contactId = contact.getNodeId()
-        if (this.options.excludedNodeIds !== undefined && this.options.excludedNodeIds.has(contactId)) {
+        if (this.options.excludedNodeIds?.has(contactId)) {
             return
         }
         if ((!this.options.allowToContainReferenceId && (this.options.referenceId === contactId)) ||

package/src/dht/recursive-operation/RecursiveOperationManager.ts

@@ -39,7 +39,7 @@ interface RecursiveOperationManagerOptions {
     createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
 }
 
-export interface RecursiveOperationResult { closestNodes: Array<PeerDescriptor>, dataEntries?: Array<DataEntry> }
+export interface RecursiveOperationResult { closestNodes: PeerDescriptor[], dataEntries?: DataEntry[] }
 
 const logger = new Logger(module)
 

package/src/dht/routing/DuplicateDetector.ts

@@ -1,7 +1,7 @@
 export class DuplicateDetector {
 
     private values: Set<string> = new Set()
-    private queue: Array<string> = []
+    private queue: string[] = []
     private maxItemCount: number
 
     constructor(

package/src/dht/routing/RoutingSession.ts

@@ -16,7 +16,7 @@ import { RoutingTable, RoutingTablesCache } from './RoutingTablesCache'
 const logger = new Logger(module)
 
 const MAX_FAILED_HOPS = 2
-const ROUTING_TABLE_MAX_SIZE = 20
+const ROUTING_TABLE_MAX_SIZE = 5
 
 export class RoutingRemoteContact extends Contact {
 
@@ -163,7 +163,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         const previousId = previousPeer ? toNodeId(previousPeer) : undefined
         const targetId = toDhtAddress(this.options.routedMessage.target)
         let routingTable: RoutingTable
-        if (this.options.routingTablesCache.has(targetId, previousId)) {
+        if (this.options.routingTablesCache.has(targetId, previousId) && this.options.routingTablesCache.get(targetId, previousId)!.getSize() > 0) {
             routingTable = this.options.routingTablesCache.get(targetId, previousId)!
         } else {
             routingTable = new SortedContactList<RoutingRemoteContact>({

package/src/dht/routing/RoutingTablesCache.ts

@@ -6,7 +6,7 @@ import { LRUCache } from 'lru-cache'
 type RoutingTableID = string
 export type RoutingTable = Pick<
     SortedContactList<RoutingRemoteContact>,
-    'getClosestContacts' | 'addContacts' | 'addContact' | 'removeContact' | 'stop'>
+    'getClosestContacts' | 'addContacts' | 'addContact' | 'removeContact' | 'stop' | 'getSize'>
 
 const createRoutingTableId = (targetId: DhtAddress, previousId?: DhtAddress): RoutingTableID => {
     return targetId + (previousId ? previousId : '')

package/src/dht/store/LocalDataStore.ts

@@ -36,7 +36,7 @@ export class LocalDataStore {
 
     public markAsDeleted(key: DhtAddress, creator: DhtAddress): boolean {
         const item = this.store.get(key)
-        if ((item === undefined) || !item.has(creator)) {
+        if (!item?.has(creator)) {
             return false
         }
         const storedEntry = item.get(creator)

package/src/dht/store/StoreManager.ts

@@ -32,7 +32,7 @@ interface StoreManagerOptions {
     serviceId: ServiceID
     highestTtl: number
     redundancyFactor: number
-    getNeighbors: () => ReadonlyArray<PeerDescriptor>
+    getNeighbors: () => readonly PeerDescriptor[]
     createRpcRemote: (contact: PeerDescriptor) => StoreRpcRemote
 }
 

package/src/dht/store/StoreRpcLocal.ts

@@ -17,7 +17,7 @@ interface StoreRpcLocalOptions {
     localDataStore: LocalDataStore
     localPeerDescriptor: PeerDescriptor
     replicateDataToContact: (dataEntry: DataEntry, contact: PeerDescriptor) => Promise<void>
-    getStorers: (key: DhtAddress) => ReadonlyArray<PeerDescriptor>
+    getStorers: (key: DhtAddress) => readonly PeerDescriptor[]
 }
 
 const logger = new Logger(module)

package/src/helpers/protoClasses.ts

@@ -28,7 +28,7 @@ import {
 
 } from '../../generated/packages/dht/protos/DhtRpc'
 
-export const protoClasses: Array<IMessageType<any>> = [
+export const protoClasses: IMessageType<any>[] = [
     ClosestPeersRequest,
     ClosestPeersResponse,
     RecursiveOperationRequest,

package/src/helpers/version.ts

@@ -6,9 +6,9 @@ export const LOCAL_PROTOCOL_VERSION = '1.1'
  * 
  * The older version assumes optimistically that it may be supported by the newer
  * version. It can't know for sure, but the other node will tell if it is not
- * supported (e.g. rejecting the handshake with UNSUPPORTED_VERSION error).
+ * supported (e.g. rejecting the handshake with UNSUPPORTED_PROTOCOL_VERSION error).
  */
-export const isMaybeSupportedVersion = (remoteVersion: string): boolean => {
+export const isMaybeSupportedProtocolVersion = (remoteVersion: string): boolean => {
     const localMajor = parseVersion(LOCAL_PROTOCOL_VERSION)!.major
     const remoteMajor = parseVersion(remoteVersion)?.major
     if ((remoteMajor === undefined) || (remoteMajor < localMajor)) {

package/test/benchmark/Find.test.ts

@@ -21,7 +21,7 @@ describe('Find correctness', () => {
         execSync('npm run prepare-kademlia-simulation')
     }
 
-    const dhtIds: Array<{ type: string, data: Array<number> }> = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+    const dhtIds: { type: string, data: number[] }[] = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
 
     beforeEach(async () => {
 
@@ -49,10 +49,10 @@ describe('Find correctness', () => {
         )
 
         logger.info('waiting 120s')
-        debugVars['waiting'] = true
+        debugVars.waiting = true
 
         await wait(120000)
-        debugVars['waiting'] = false
+        debugVars.waiting = false
         logger.info('waiting over')
 
         nodes.forEach((node) => logger.info(toNodeId(node.getLocalPeerDescriptor()) + ': connections:' +

package/test/benchmark/KademliaCorrectness.test.ts

@@ -22,8 +22,8 @@ describe('Kademlia correctness', () => {
         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> } }>>
+    const dhtIds: { type: string, data: number[] }[] = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+    const groundTruth: Record<string, { name: string, distance: number, id: { type: string, data: number[] } }[]>
         = JSON.parse(fs.readFileSync('test/data/orderedneighbors.json').toString())
 
     beforeEach(async () => {

package/test/benchmark/RingCorrectness.test.ts

@@ -18,7 +18,7 @@ describe('Ring correctness', () => {
     const NUM_NODES = 900
     const nodeIndicesById: Record<DhtAddress, number> = {}
 
-    const regions: Array<number> = []
+    const regions: number[] = []
     for (let i = 0; i < (NUM_NODES + 1); i++) {
         regions.push(i)
     }
@@ -36,8 +36,8 @@ describe('Ring correctness', () => {
         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> } }>>
+    const dhtIds: { type: string, data: number[] }[] = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
+    const groundTruth: Record<string, { name: string, distance: number, id: { type: string, data: number[] } }[]>
         = JSON.parse(fs.readFileSync('test/data/orderedneighbors.json').toString())
 
     beforeEach(async () => {

package/test/benchmark/hybrid-network-simulation/RingContactList.test.ts

@@ -26,7 +26,7 @@ class MockNode {
             host: 'localhost',
             natType: NatType.UNKNOWN,
             ipAddress: ipv4ToNumber(ipAddress),
-            version: '0.0.0'
+            protocolVersion: '0.0.0'
 
         }
         this.peerDescriptor = createPeerDescriptor(connectivityResponse, getRandomRegion())
@@ -39,7 +39,7 @@ class MockNode {
 }
 
 // populate with mock ip addresses
-const mockData: Array< [number, string] > = [
+const mockData: [number, string][] = [
     [0, '5.2.4.2'],
     [0, '6.23.2.4'],
     [0, '7.2.4.2'],

package/test/end-to-end/WebsocketConnectionRequest.test.ts

@@ -1,7 +1,7 @@
 import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { areEqualPeerDescriptors } from '../../src/identifiers'
 
@@ -60,7 +60,7 @@ describe('Websocket IConnection Requests', () => {
         await node2.joinDht([epPeerDescriptor])
         await node1.joinDht([epPeerDescriptor])
 
-        await waitForCondition(() => { return (connected1 && connected2) })
+        await until(() => { return (connected1 && connected2) })
 
         expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getNodeId())).toEqual(true)
         expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getNodeId())).toEqual(true)

package/test/end-to-end/memory-leak.test.ts

@@ -1,5 +1,5 @@
 import LeakDetector from 'jest-leak-detector'
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { Message } from '../../generated/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
@@ -55,7 +55,7 @@ describe('memory leak', () => {
             }
         }
         await sender.send(msg)
-        await waitForCondition(() => receivedMessage !== undefined)
+        await until(() => receivedMessage !== undefined)
         expect(receivedMessage!.messageId).toEqual(MESSAGE_ID)
 
         await Promise.all([

package/test/integration/ConnectionLocking.test.ts

@@ -1,4 +1,4 @@
-import { MetricsContext, waitForCondition } from '@streamr/utils'
+import { MetricsContext, until } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
@@ -60,7 +60,8 @@ describe('Connection Locking', () => {
         const nodeId1 = toNodeId(mockPeerDescriptor1)
         const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
         ])
         expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
@@ -72,11 +73,13 @@ describe('Connection Locking', () => {
         const nodeId1 = toNodeId(mockPeerDescriptor1)
         const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
         expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
@@ -88,16 +91,17 @@ describe('Connection Locking', () => {
         const nodeId1 = toNodeId(mockPeerDescriptor1)
         const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
         ])
-        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
         expect(connectionManager2.hasLocalLockedConnection(nodeId2)).toEqual(false)
         expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock')
         expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(false)
-        await waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1) === false)
+        await until(() => connectionManager2.hasRemoteLockedConnection(nodeId1) === false)
         expect(connectionManager1.hasConnection(nodeId1)).toEqual(false)
     })
 
@@ -105,15 +109,17 @@ describe('Connection Locking', () => {
         const nodeId1 = toNodeId(mockPeerDescriptor1)
         const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
 
-        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
         expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(false)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
@@ -128,17 +134,19 @@ describe('Connection Locking', () => {
         const nodeId1 = toNodeId(mockPeerDescriptor1)
         const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
         ])
 
-        expect(connectionManager1.hasLocalLockedConnection(nodeId2))
-        expect(connectionManager2.hasLocalLockedConnection(nodeId1))
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
+        expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(true)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
-        await waitForCondition(() =>
+        await until(() =>
             connectionManager1.hasRemoteLockedConnection(nodeId2)
             && !connectionManager1.hasLocalLockedConnection(nodeId2)
             && !connectionManager2.hasRemoteLockedConnection(nodeId1)
@@ -153,28 +161,30 @@ describe('Connection Locking', () => {
         const nodeId1 = toNodeId(mockPeerDescriptor1)
         const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
         ])
-        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
         expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(true)
         expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
 
         //@ts-expect-error private field
         await connectionManager1.gracefullyDisconnectAsync(mockPeerDescriptor2)
         
-        await waitForCondition(() =>
+        await until(() =>
             !connectionManager1.hasRemoteLockedConnection(nodeId2)
             && !connectionManager1.hasLocalLockedConnection(nodeId2)
         )
-        await waitForCondition(() =>
+        await until(() =>
             !connectionManager2.hasRemoteLockedConnection(nodeId1)
             && !connectionManager2.hasLocalLockedConnection(nodeId1)
         )
-        await waitForCondition(() => !connectionManager2.hasConnection(nodeId1))
-        await waitForCondition(() => !connectionManager1.hasConnection(nodeId2))
+        await until(() => !connectionManager2.hasConnection(nodeId1))
+        await until(() => !connectionManager1.hasConnection(nodeId2))
 
         expect(connectionManager1.hasConnection(nodeId2)).toEqual(false)
         expect(connectionManager2.hasConnection(nodeId1)).toEqual(false)

package/test/integration/ConnectionManager.test.ts

@@ -1,4 +1,4 @@
-import { Logger, MetricsContext, waitForCondition, waitForEvent3 } from '@streamr/utils'
+import { Logger, MetricsContext, until, waitForEvent3 } from '@streamr/utils'
 import { MarkOptional } from 'ts-essentials'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
@@ -513,11 +513,11 @@ describe('ConnectionManager', () => {
         await Promise.all([connectedPromise1, connectedPromise2, connectionManager2.send(msg)])
 
         await connectionManager1.enablePrivateClientMode()
-        await waitForCondition(() => connectionManager2.getConnections().length === 0)
+        await until(() => connectionManager2.getConnections().length === 0)
         expect(connectionManager1.getConnections().length).toEqual(1)
 
         await connectionManager1.disablePrivateClientMode()
-        await waitForCondition(() => connectionManager2.getConnections().length === 1)
+        await until(() => connectionManager2.getConnections().length === 1)
         expect(connectionManager1.getConnections().length).toEqual(1)
 
         await connectionManager1.stop()

package/test/integration/ConnectivityChecking.test.ts

@@ -48,6 +48,6 @@ describe('ConnectivityChecking', () => {
             allowSelfSignedCertificate: false
         }
         const response = await sendConnectivityRequest(request, server.getLocalPeerDescriptor())
-        expect(response.version).toEqual(LOCAL_PROTOCOL_VERSION)
+        expect(response.protocolVersion).toEqual(LOCAL_PROTOCOL_VERSION)
     })
 })

package/test/integration/DhtNode.test.ts

@@ -1,4 +1,4 @@
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { range, without } from 'lodash'
 import { DhtNodeRpcLocal } from '../../src/dht/DhtNodeRpcLocal'
 import { DhtNode, ListeningRpcCommunicator, toNodeId } from '../../src/exports'
@@ -58,7 +58,7 @@ describe('DhtNode', () => {
         await localNode.joinDht([entryPointPeerDescriptor])
         await localNode.waitForNetworkConnectivity()
 
-        await waitForCondition(() => localNode.getNeighborCount() === otherPeerDescriptors.length + 1)
+        await until(() => localNode.getNeighborCount() === otherPeerDescriptors.length + 1)
         const expectedNodeIds = without(getAllPeerDescriptors(), localPeerDescriptor).map((n) => toNodeId(n))
         const actualNodeIds = localNode.getClosestContacts().map((n) => toNodeId(n))
         expect(actualNodeIds).toIncludeSameMembers(expectedNodeIds)

package/test/integration/GeoIpConnectivityChecking.test.ts

@@ -8,12 +8,12 @@ import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
 import { WebsocketServerConnection } from '../../src/connection/websocket/WebsocketServerConnection'
 import fs from 'fs'
 
-// www.gov.za
-const testIp = '164.151.129.20'
+// helsinki.fi
+const testIp = '128.214.222.50'
 
-// Pretoria, South Africa
-const testLatitude = -25.7599
-const testLongitude = 28.2604
+// Helsinki, Finland
+const testLatitude = 60.1719
+const testLongitude = 24.9347
 
 const dbPath = '/tmp/geoipdatabasesintegration'
 
@@ -65,7 +65,7 @@ describe('ConnectivityChecking', () => {
             allowSelfSignedCertificate: false
         }
         const response = await sendConnectivityRequest(request, server.getLocalPeerDescriptor())
-        expect(response.version).toEqual(LOCAL_PROTOCOL_VERSION)
+        expect(response.protocolVersion).toEqual(LOCAL_PROTOCOL_VERSION)
         expect(response.latitude).toEqual(testLatitude)
         expect(response.longitude).toEqual(testLongitude)
     })

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

@@ -178,7 +178,7 @@ describe('Layer1', () => {
     //         })
     //     })
     //
-    //     await waitForCondition(() => {
+    //     await until(() => {
     //         return [...receivedMessages.values()].every((set) => {
     //             return set.size === receivedMessages.size - 1
     //         })

package/test/integration/RouteMessage.test.ts

@@ -1,7 +1,7 @@
 import { DhtNode, Events as DhtNodeEvents } from '../../src/dht/DhtNode'
 import { Message, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../generated/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
-import { Logger, runAndWaitForEvents3, waitForCondition } from '@streamr/utils'
+import { Logger, runAndWaitForEvents3, until } from '@streamr/utils'
 import { createMockConnectionDhtNode, createWrappedClosestPeersRequest } from '../utils/utils'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { v4 } from 'uuid'
@@ -116,7 +116,7 @@ describe('Route Message With Mock Connections', () => {
                 parallelRootNodeIds: []
             })
         }
-        await waitForCondition(() => receivedMessages === messageCount)
+        await until(() => receivedMessages === messageCount)
     })
 
     it('From all to all', async () => {
@@ -157,10 +157,10 @@ describe('Route Message With Mock Connections', () => {
                 }))
             )
         )
-        await waitForCondition(() => receivedMessageCounts[routerNodes[0].getNodeId()] >= routerNodes.length - 1, 30000)
+        await until(() => receivedMessageCounts[routerNodes[0].getNodeId()] >= routerNodes.length - 1, 30000)
         await Promise.all(
             Object.keys(receivedMessageCounts).map(async (key) =>
-                waitForCondition(() => receivedMessageCounts[key as DhtAddress] >= routerNodes.length - 1, 30000)
+                until(() => receivedMessageCounts[key as DhtAddress] >= routerNodes.length - 1, 30000)
             )
         )