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

package/src/connection/simulator/Simulator.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/parameter-properties */
 import EventEmitter from 'eventemitter3'
-import { PeerIDKey } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { ConnectionSourceEvents } from '../IConnectionSource'
 import { SimulatorConnector } from './SimulatorConnector'
@@ -8,19 +7,10 @@ import { SimulatorConnection } from './SimulatorConnection'
 import { ConnectionID } from '../IConnection'
 import { Logger } from '@streamr/utils'
 import { getRegionDelayMatrix } from './pings'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import Heap from 'heap'
 import { debugVars } from '../../helpers/debugHelpers'
-import * as sinon from 'sinon'
-
-// TODO take this from @streamr/test-utils (we can't access devDependencies as Simulator
-// is currently in "src" directory instead of "test" directory)
-// eslint-disable-next-line no-underscore-dangle
-declare let _streamr_electron_test: any
-export function isRunningInElectron(): boolean {
-    // eslint-disable-next-line no-underscore-dangle
-    return typeof _streamr_electron_test !== 'undefined'
-}
+import { NodeID } from '../../helpers/nodeId'
 
 const logger = new Logger(module)
 
@@ -102,7 +92,7 @@ class CloseOperation extends SimulatorOperation {
 
 export class Simulator extends EventEmitter<ConnectionSourceEvents> {
     private stopped = false
-    private connectors: Map<PeerIDKey, SimulatorConnector> = new Map()
+    private connectors: Map<NodeID, SimulatorConnector> = new Map()
     private latencyTable?: Array<Array<number>>
     private associations: Map<ConnectionID, Association> = new Map()
 
@@ -121,22 +111,6 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
     })
 
     private simulatorTimeout?: NodeJS.Timeout
-    private static clock: sinon.SinonFakeTimers | undefined
-
-    static useFakeTimers(on = true): void {
-        if (!isRunningInElectron()) {  // never use fake timers in browser environment
-            if (on) {
-                if (!Simulator.clock) {
-                    Simulator.clock = sinon.useFakeTimers()
-                }
-            } else {
-                if (Simulator.clock) {
-                    Simulator.clock.restore()
-                    Simulator.clock = undefined
-                }
-            }
-        }
-    }
 
     constructor(latencyType: LatencyType = LatencyType.NONE, fixedLatency?: number) {
         super()
@@ -214,11 +188,11 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
     }
 
     public addConnector(connector: SimulatorConnector): void {
-        this.connectors.set(keyFromPeerDescriptor(connector.getPeerDescriptor()), connector)
+        this.connectors.set(getNodeIdFromPeerDescriptor(connector.getPeerDescriptor()), connector)
     }
 
     private executeConnectOperation(operation: ConnectOperation): void {
-        const target = this.connectors.get(keyFromPeerDescriptor(operation.targetDescriptor))
+        const target = this.connectors.get(getNodeIdFromPeerDescriptor(operation.targetDescriptor))
 
         if (!target) {
             logger.error('Target connector not found when executing connect operation')
@@ -311,11 +285,6 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
         const timeDifference = firstOperationTime - currentTime
 
         this.simulatorTimeout = setTimeout(this.executeQueuedOperations, timeDifference)
-       
-        if (Simulator.clock) {
-            // TODO should we have some handling for this floating promise?
-            Simulator.clock.runAllAsync()
-        }
     }
 
     private scheduleOperation(operation: SimulatorOperation) {

package/src/connection/simulator/SimulatorConnector.ts

@@ -6,16 +6,16 @@ import {
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
 import { ManagedConnection } from '../ManagedConnection'
-import { PeerIDKey } from '../../helpers/PeerID'
 import { Simulator } from './Simulator'
 import { SimulatorConnection } from './SimulatorConnection'
-import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { NodeID } from '../../helpers/nodeId'
 
 const logger = new Logger(module)
 
 export class SimulatorConnector {
 
-    private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
+    private connectingConnections: Map<NodeID, ManagedConnection> = new Map()
     private stopped = false
     private localPeerDescriptor: PeerDescriptor
     private simulator: Simulator
@@ -33,8 +33,8 @@ export class SimulatorConnector {
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
         logger.trace('connect() ' + getNodeIdFromPeerDescriptor(targetPeerDescriptor))
-        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
-        const existingConnection = this.connectingConnections.get(peerKey)
+        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.connectingConnections.get(nodeId)
         if (existingConnection) {
             return existingConnection
         }
@@ -44,12 +44,12 @@ export class SimulatorConnector {
         const managedConnection = new ManagedConnection(this.localPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, connection, undefined)
         managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
-        this.connectingConnections.set(peerKey, managedConnection)
+        this.connectingConnections.set(nodeId, managedConnection)
         connection.once('disconnected', () => {
-            this.connectingConnections.delete(peerKey)
+            this.connectingConnections.delete(nodeId)
         })
         connection.once('connected', () => {
-            this.connectingConnections.delete(peerKey)
+            this.connectingConnections.delete(nodeId)
         })
 
         connection.connect()

package/src/connection/webrtc/BrowserWebrtcConnection.ts

@@ -22,12 +22,9 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
 
     public connectionId: ConnectionID
     public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
-
     // We need to keep track of connection state ourselves because
     // RTCPeerConnection.connectionState is not supported on Firefox
-
     private lastState: RTCPeerConnectionState = 'connecting'
-
     private readonly iceServers: IceServer[]
     private peerConnection?: RTCPeerConnection
     private dataChannel?: RTCDataChannel

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -5,7 +5,7 @@ import EventEmitter from 'eventemitter3'
 import nodeDatachannel, { DataChannel, DescriptionType, PeerConnection } from 'node-datachannel'
 import { Logger } from '@streamr/utils'
 import { IllegalRtcPeerConnectionState } from '../../helpers/errors'
-import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { iceServerAsString } from './iceServerAsString'
 import { IceServer } from './WebrtcConnector'
 import { PortRange } from '../ConnectionManager'
@@ -55,7 +55,6 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     private lastState: RtcPeerConnectionState = 'connecting'
     private remoteDescriptionSet = false
     private connectingTimeoutRef?: NodeJS.Timeout
-
     public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
     private readonly iceServers: IceServer[]
     private readonly _bufferThresholdHigh: number // TODO: buffer handling must be implemented before production use (NET-938)
@@ -80,9 +79,9 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     }
 
     public start(isOffering: boolean): void {
-        const peerIdKey = keyFromPeerDescriptor(this.remotePeerDescriptor)
+        const nodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
         logger.trace(`Starting new connection for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`, { isOffering })
-        this.connection = new PeerConnection(peerIdKey, {
+        this.connection = new PeerConnection(nodeId, {
             iceServers: this.iceServers.map(iceServerAsString),
             maxMessageSize: this.maxMessageSize,
             portRangeBegin: this.portRange?.min,

package/src/connection/webrtc/WebrtcConnector.ts

@@ -9,21 +9,19 @@ import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicat
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
 import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { PeerIDKey } from '../../helpers/PeerID'
 import { ManagedWebrtcConnection } from '../ManagedWebrtcConnection'
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
 import { ManagedConnection } from '../ManagedConnection'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     areEqualPeerDescriptors,
     getNodeIdFromPeerDescriptor,
-    keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
 import { PortRange } from '../ConnectionManager'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { WebrtcConnectorRpcLocal } from './WebrtcConnectorRpcLocal'
+import { NodeID } from '../../helpers/nodeId'
 
 const logger = new Logger(module)
 
@@ -60,10 +58,9 @@ export class WebrtcConnector {
 
     private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly ongoingConnectAttempts: Map<PeerIDKey, ManagedWebrtcConnection> = new Map()
+    private readonly ongoingConnectAttempts: Map<NodeID, ManagedWebrtcConnection> = new Map()
     private localPeerDescriptor?: PeerDescriptor
     private stopped = false
-    private iceServers: IceServer[]
     private config: WebrtcConnectorConfig
 
     constructor(
@@ -71,9 +68,8 @@ export class WebrtcConnector {
         onNewConnection: (connection: ManagedConnection) => boolean
     ) {
         this.config = config
-        this.iceServers = config.iceServers ?? []
         this.rpcCommunicator = new ListeningRpcCommunicator(WebrtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
-            rpcRequestTimeout: 15000
+            rpcRequestTimeout: 15000  // TODO use config option or named constant?
         })
         this.registerLocalRpcMethods(config, onNewConnection)
     }
@@ -135,15 +131,15 @@ export class WebrtcConnector {
 
         logger.trace(`Opening WebRTC connection to ${getNodeIdFromPeerDescriptor(targetPeerDescriptor)}`)
 
-        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
-        const existingConnection = this.ongoingConnectAttempts.get(peerKey)
+        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.ongoingConnectAttempts.get(nodeId)
         if (existingConnection) {
             return existingConnection
         }
 
         const connection = new NodeWebrtcConnection({
             remotePeerDescriptor: targetPeerDescriptor,
-            iceServers: this.iceServers,
+            iceServers: this.config.iceServers,
             bufferThresholdLow: this.config.bufferThresholdLow,
             bufferThresholdHigh: this.config.bufferThresholdHigh,
             connectingTimeout: this.config.connectionTimeout,
@@ -161,10 +157,10 @@ export class WebrtcConnector {
 
         managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
-        this.ongoingConnectAttempts.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
+        this.ongoingConnectAttempts.set(getNodeIdFromPeerDescriptor(targetPeerDescriptor), managedConnection)
 
         const delFunc = () => {
-            this.ongoingConnectAttempts.delete(peerKey)
+            this.ongoingConnectAttempts.delete(nodeId)
             connection.off('disconnected', delFunc)
             managedConnection.off('handshakeCompleted', delFunc)
         }
@@ -174,7 +170,9 @@ export class WebrtcConnector {
         const remoteConnector = new WebrtcConnectorRpcRemote(
             this.localPeerDescriptor!,
             targetPeerDescriptor,
-            toProtoRpcClient(new WebrtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+            'DUMMY',
+            this.rpcCommunicator,
+            WebrtcConnectorRpcClient
         )
 
         connection.on('localCandidate', (candidate: string, mid: string) => {

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -1,11 +1,10 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Logger } from '@streamr/utils'
 import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
-import { PeerIDKey } from '../../helpers/PeerID'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Empty } from '../../proto/google/protobuf/empty'
 import {
+    HandshakeError,
     IceCandidate,
     PeerDescriptor,
     RtcAnswer,
@@ -19,6 +18,9 @@ import { ManagedConnection } from '../ManagedConnection'
 import { ManagedWebrtcConnection } from '../ManagedWebrtcConnection'
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
+import { NodeID } from '../../helpers/nodeId'
+import { version } from '../../../package.json'
+import { isCompatibleVersion } from '../../helpers/versionCompatibility'
 
 const logger = new Logger(module)
 
@@ -26,7 +28,7 @@ interface WebrtcConnectorRpcLocalConfig {
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection 
     onNewConnection: (connection: ManagedConnection) => boolean
     // TODO pass accessor methods instead of passing a mutable entity
-    ongoingConnectAttempts: Map<PeerIDKey, ManagedWebrtcConnection>
+    ongoingConnectAttempts: Map<NodeID, ManagedWebrtcConnection>
     rpcCommunicator: ListeningRpcCommunicator
     getLocalPeerDescriptor: () => PeerDescriptor
     allowPrivateAddresses: boolean
@@ -42,7 +44,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async requestConnection(context: ServerCallContext): Promise<Empty> {
         const targetPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (this.config.ongoingConnectAttempts.has(keyFromPeerDescriptor(targetPeerDescriptor))) {
+        if (this.config.ongoingConnectAttempts.has(getNodeIdFromPeerDescriptor(targetPeerDescriptor))) {
             return {}
         }
         const managedConnection = this.config.connect(targetPeerDescriptor)
@@ -53,20 +55,22 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async rtcOffer(request: RtcOffer, context: ServerCallContext): Promise<Empty> {
         const remotePeer = (context as DhtCallContext).incomingSourceDescriptor!
-        const peerKey = keyFromPeerDescriptor(remotePeer)
-        let managedConnection = this.config.ongoingConnectAttempts.get(peerKey)
+        const nodeId = getNodeIdFromPeerDescriptor(remotePeer)
+        let managedConnection = this.config.ongoingConnectAttempts.get(nodeId)
         let connection = managedConnection?.getWebrtcConnection()
 
         if (!managedConnection) {
             connection = new NodeWebrtcConnection({ remotePeerDescriptor: remotePeer })
             managedConnection = new ManagedWebrtcConnection(this.config.getLocalPeerDescriptor(), undefined, connection)
             managedConnection.setRemotePeerDescriptor(remotePeer)
-            this.config.ongoingConnectAttempts.set(peerKey, managedConnection)
+            this.config.ongoingConnectAttempts.set(nodeId, managedConnection)
             this.config.onNewConnection(managedConnection)
             const remoteConnector = new WebrtcConnectorRpcRemote(
                 this.config.getLocalPeerDescriptor(),
                 remotePeer,
-                toProtoRpcClient(new WebrtcConnectorRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                'DUMMY', 
+                this.config.rpcCommunicator,
+                WebrtcConnectorRpcClient
             )
             connection.on('localCandidate', (candidate: string, mid: string) => {
                 remoteConnector.sendIceCandidate(candidate, mid, connection!.connectionId.toString())
@@ -81,19 +85,23 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
         connection!.setConnectionId(request.connectionId)
         connection!.setRemoteDescription(request.description, 'offer')
 
-        managedConnection.on('handshakeRequest', () => {
-            if (this.config.ongoingConnectAttempts.has(peerKey)) {
-                this.config.ongoingConnectAttempts.delete(peerKey)
+        managedConnection.on('handshakeRequest', (_sourceDescriptor: PeerDescriptor, sourceVersion: string) => {
+            if (this.config.ongoingConnectAttempts.has(nodeId)) {
+                this.config.ongoingConnectAttempts.delete(nodeId)
+            }
+            if (!isCompatibleVersion(sourceVersion, version)) {
+                managedConnection!.rejectHandshake(HandshakeError.UNSUPPORTED_VERSION)
+            } else {
+                managedConnection!.acceptHandshake()
             }
-            managedConnection!.acceptHandshake()
         })
         return {}
     }
 
     async rtcAnswer(request: RtcAnswer, context: ServerCallContext): Promise<Empty> {
         const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
-        const connection = this.config.ongoingConnectAttempts.get(peerKey)?.getWebrtcConnection()
+        const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
+        const connection = this.config.ongoingConnectAttempts.get(nodeId)?.getWebrtcConnection()
         if (!connection) {
             return {}
         } else if (connection.connectionId.toString() !== request.connectionId) {
@@ -106,9 +114,8 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async iceCandidate(request: IceCandidate, context: ServerCallContext): Promise<Empty> {
         const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
-        const connection = this.config.ongoingConnectAttempts.get(peerKey)?.getWebrtcConnection()
-
+        const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
+        const connection = this.config.ongoingConnectAttempts.get(nodeId)?.getWebrtcConnection()
         if (!connection) {
             return {}
         } else if (connection.connectionId.toString() !== request.connectionId) {

package/src/connection/webrtc/WebrtcConnectorRpcRemote.ts

@@ -1,26 +1,16 @@
+import { Logger } from '@streamr/utils'
 import { RpcRemote } from '../../dht/contact/RpcRemote'
 import {
     IceCandidate,
-    PeerDescriptor,
     RtcAnswer,
     RtcOffer,
     WebrtcConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { Logger } from '@streamr/utils'
+import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 
 const logger = new Logger(module)
 
-export class WebrtcConnectorRpcRemote extends RpcRemote<IWebrtcConnectorRpcClient> {
-
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        remotePeerDescriptor: PeerDescriptor,
-        client: ProtoRpcClient<IWebrtcConnectorRpcClient>
-    ) {
-        super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
-    }
+export class WebrtcConnectorRpcRemote extends RpcRemote<WebrtcConnectorRpcClient> {
 
     requestConnection(): void {
         const request: WebrtcConnectionRequest = {

package/src/connection/websocket/AutoCertifierClientFacade.ts

@@ -55,12 +55,10 @@ export class AutoCertifierClientFacade {
 
     private autoCertifierClient: IAutoCertifierClient
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly setHost: (host: string) => void
-    private readonly updateCertificate: (certificate: string, privateKey: string) => void
+    private readonly config: AutoCertifierClientFacadeConfig
 
     constructor(config: AutoCertifierClientFacadeConfig) {
-        this.setHost = config.setHost
-        this.updateCertificate = config.updateCertificate
+        this.config = config
         this.rpcCommunicator = new ListeningRpcCommunicator(AUTO_CERTIFIER_SERVICE_ID, config.transport)
         this.autoCertifierClient = config.createClientFactory ? config.createClientFactory() 
             : defaultAutoCertifierClientFactory(
@@ -73,8 +71,8 @@ export class AutoCertifierClientFacade {
 
     async start(): Promise<void> {
         this.autoCertifierClient.on('updatedCertificate', (subdomain: CertifiedSubdomain) => {
-            this.setHost(subdomain.fqdn)
-            this.updateCertificate(subdomain.certificate, subdomain.privateKey)
+            this.config.setHost(subdomain.fqdn)
+            this.config.updateCertificate(subdomain.certificate, subdomain.privateKey)
             logger.trace(`Updated certificate`)
         })
         await Promise.all([

package/src/connection/websocket/ClientWebsocket.ts

@@ -15,6 +15,7 @@ export const CUSTOM_GOING_AWAY = 3001
 const BINARY_TYPE = 'arraybuffer'
 
 export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements IConnection {
+
     public readonly connectionId: ConnectionID
     private socket?: Websocket
     public connectionType = ConnectionType.WEBSOCKET_CLIENT