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

package/src/connection/ConnectorFacade.ts

@@ -1,217 +0,0 @@
-import { Logger } from '@streamr/utils'
-import {
-    ConnectivityResponse,
-    PeerDescriptor
-} from '../../generated/packages/dht/protos/DhtRpc'
-import { ITransport } from '../transport/ITransport'
-import { PortRange, TlsCertificate } from './ConnectionManager'
-import { Simulator } from './simulator/Simulator'
-import { SimulatorConnector } from './simulator/SimulatorConnector'
-import { IceServer, WebrtcConnector } from './webrtc/WebrtcConnector'
-import { WebsocketClientConnector } from './websocket/WebsocketClientConnector'
-import { DhtAddress } from '../identifiers'
-import { WebsocketServerConnector, WebsocketServerConnectorOptions } from './websocket/WebsocketServerConnector'
-import { PendingConnection } from './PendingConnection'
-import { ListeningRpcCommunicator } from '../transport/ListeningRpcCommunicator'
-
-export interface ConnectorFacade {
-    createConnection: (peerDescriptor: PeerDescriptor) => PendingConnection
-    getLocalPeerDescriptor: () => PeerDescriptor | undefined
-    start: (
-        onNewConnection: (connection: PendingConnection) => boolean,
-        hasConnection: (nodeId: DhtAddress) => boolean,
-        autoCertifierTransport: ITransport
-    ) => Promise<void>
-    stop: () => Promise<void>
-}
-
-const logger = new Logger(module)
-
-// TODO: Wrap component specific configs to their own objects.
-export interface DefaultConnectorFacadeOptions {
-    transport: ITransport
-    websocketHost?: string
-    websocketPortRange?: PortRange
-    entryPoints?: PeerDescriptor[]
-    iceServers?: IceServer[]
-    webrtcAllowPrivateAddresses?: boolean
-    webrtcDatachannelBufferThresholdLow?: number
-    webrtcDatachannelBufferThresholdHigh?: number
-    externalIp?: string
-    webrtcPortRange?: PortRange
-    maxMessageSize?: number
-    tlsCertificate?: TlsCertificate
-    // TODO explicit default value for "websocketServerEnableTls" or make it required
-    websocketServerEnableTls?: boolean
-    autoCertifierUrl?: string
-    autoCertifierConfigFile?: string
-    geoIpDatabaseFolder?: string
-    createLocalPeerDescriptor: (connectivityResponse: ConnectivityResponse) => Promise<PeerDescriptor>
-}
-
-export class DefaultConnectorFacade implements ConnectorFacade {
-
-    private readonly options: DefaultConnectorFacadeOptions
-    private localPeerDescriptor?: PeerDescriptor
-    private websocketConnectorRpcCommunicator?: ListeningRpcCommunicator
-    private websocketClientConnector?: WebsocketClientConnector
-    private websocketServerConnector?: WebsocketServerConnector
-    private webrtcConnector?: WebrtcConnector
-    constructor(options: DefaultConnectorFacadeOptions) {
-        this.options = options
-    }
-
-    async start(
-        onNewConnection: (connection: PendingConnection) => boolean,
-        hasConnection: (nodeId: DhtAddress) => boolean,
-        autoCertifierTransport: ITransport
-    ): Promise<void> {
-        logger.trace(`Creating WebsocketConnectorRpcLocal`)
-        this.websocketConnectorRpcCommunicator = new ListeningRpcCommunicator(
-            WebsocketClientConnector.WEBSOCKET_CONNECTOR_SERVICE_ID, 
-            this.options.transport, 
-            { rpcRequestTimeout: 15000 }  // TODO use options option or named constant?
-        
-        )
-        const webSocketClientConnectorOptions = {
-            // TODO should we use canConnect also for WebrtcConnector? (NET-1142)
-            onNewConnection,
-            hasConnection,
-            rpcCommunicator: this.websocketConnectorRpcCommunicator
-        }
-        this.websocketClientConnector = new WebsocketClientConnector(webSocketClientConnectorOptions)
-
-        const webSocketServerConnectorOptions = {
-            rpcCommunicator: this.websocketConnectorRpcCommunicator,
-            // TODO should we use canConnect also for WebrtcConnector? (NET-1142)
-            onNewConnection,
-            hasConnection,
-            portRange: this.options.websocketPortRange,
-            host: this.options.websocketHost,
-            entrypoints: this.options.entryPoints,
-            tlsCertificate: this.options.tlsCertificate,
-            serverEnableTls: this.options.websocketServerEnableTls!,
-            autoCertifierUrl: this.options.autoCertifierUrl!,
-            autoCertifierConfigFile: this.options.autoCertifierConfigFile!,
-            autoCertifierTransport,
-            maxMessageSize: this.options.maxMessageSize,
-            geoIpDatabaseFolder: this.options.geoIpDatabaseFolder
-        }
-        this.websocketServerConnector = new WebsocketServerConnector(webSocketServerConnectorOptions)
-        this.webrtcConnector = new WebrtcConnector({
-            onNewConnection,
-            transport: this.options.transport,
-            iceServers: this.options.iceServers,
-            allowPrivateAddresses: this.options.webrtcAllowPrivateAddresses,
-            bufferThresholdLow: this.options.webrtcDatachannelBufferThresholdLow,
-            bufferThresholdHigh: this.options.webrtcDatachannelBufferThresholdHigh,
-            externalIp: this.options.externalIp,
-            portRange: this.options.webrtcPortRange,
-            maxMessageSize: this.options.maxMessageSize
-        })
-        await this.websocketServerConnector.start()
-        // TODO: generate a PeerDescriptor in a single function. Requires changes to the createOwnPeerDescriptor
-        // function in the options. Currently it's given by the DhtNode and it sets the PeerDescriptor for the
-        // DhtNode in each call. 
-        // LocalPeerDescriptor could be stored in one place and passed from there to the connectors
-        const temporarilySelfSigned = (!this.options.tlsCertificate && this.options.websocketServerEnableTls === true)
-        const connectivityResponse = await this.websocketServerConnector.checkConnectivity(temporarilySelfSigned)
-        const localPeerDescriptor = await this.options.createLocalPeerDescriptor(connectivityResponse)
-        this.setLocalPeerDescriptor(localPeerDescriptor)
-        if (localPeerDescriptor.websocket && !this.options.tlsCertificate && this.options.websocketServerEnableTls) {
-            try {
-                await this.websocketServerConnector.autoCertify()
-                const connectivityResponse = await this.websocketServerConnector.checkConnectivity(false)
-                const autocertifiedLocalPeerDescriptor = await this.options.createLocalPeerDescriptor(connectivityResponse)
-                if (autocertifiedLocalPeerDescriptor.websocket !== undefined) {
-                    this.setLocalPeerDescriptor(autocertifiedLocalPeerDescriptor)
-                } else {
-                    logger.warn('Connectivity check failed after auto-certification, disabling WebSocket server TLS')
-                    await this.restartWebsocketServerConnector({
-                        ...webSocketServerConnectorOptions,
-                        serverEnableTls: false
-                    })
-                }
-            } catch (err) {
-                logger.warn('Failed to auto-certify, disabling WebSocket server TLS', { err })
-                await this.restartWebsocketServerConnector({
-                    ...webSocketServerConnectorOptions,
-                    serverEnableTls: false
-                })
-            }
-        }
-    }
-
-    private setLocalPeerDescriptor(peerDescriptor: PeerDescriptor) {
-        this.localPeerDescriptor = peerDescriptor
-        this.websocketServerConnector!.setLocalPeerDescriptor(peerDescriptor)
-        this.websocketClientConnector!.setLocalPeerDescriptor(peerDescriptor)
-        this.webrtcConnector!.setLocalPeerDescriptor(peerDescriptor)
-    }
-    
-    async restartWebsocketServerConnector(options: WebsocketServerConnectorOptions): Promise<void> {
-        await this.websocketServerConnector!.destroy()
-        this.websocketServerConnector = new WebsocketServerConnector(options)
-        await this.websocketServerConnector.start()
-        const connectivityResponse = await this.websocketServerConnector.checkConnectivity(false)
-        const localPeerDescriptor = await this.options.createLocalPeerDescriptor(connectivityResponse)
-        this.setLocalPeerDescriptor(localPeerDescriptor)
-    }
-
-    createConnection(peerDescriptor: PeerDescriptor): PendingConnection {
-        if (this.websocketClientConnector!.isPossibleToFormConnection(peerDescriptor)) {
-            return this.websocketClientConnector!.connect(peerDescriptor)
-        } else if (this.websocketServerConnector!.isPossibleToFormConnection(peerDescriptor)) {
-            return this.websocketServerConnector!.connect(peerDescriptor)
-        } else {
-            return this.webrtcConnector!.connect(peerDescriptor, false)
-        }
-    }
-
-    getLocalPeerDescriptor(): PeerDescriptor | undefined {
-        return this.localPeerDescriptor
-    }
-
-    async stop(): Promise<void> {
-        this.websocketConnectorRpcCommunicator!.destroy()
-        await this.websocketServerConnector!.destroy()
-        await this.websocketClientConnector!.destroy()
-        await this.webrtcConnector!.stop()
-    }
-}
-
-export class SimulatorConnectorFacade implements ConnectorFacade {
-
-    private readonly localPeerDescriptor: PeerDescriptor
-    private simulatorConnector?: SimulatorConnector
-    private simulator: Simulator
-
-    constructor(localPeerDescriptor: PeerDescriptor, simulator: Simulator) {
-        this.localPeerDescriptor = localPeerDescriptor
-        this.simulator = simulator
-    }
-
-    async start(
-        onNewConnection: (connection: PendingConnection) => boolean,
-    ): Promise<void> {
-        logger.trace(`Creating SimulatorConnector`)
-        this.simulatorConnector = new SimulatorConnector(
-            this.localPeerDescriptor,
-            this.simulator,
-            onNewConnection
-        )
-        this.simulator.addConnector(this.simulatorConnector)
-    }
-
-    createConnection(peerDescriptor: PeerDescriptor): PendingConnection {
-        return this.simulatorConnector!.connect(peerDescriptor)
-    }
-
-    getLocalPeerDescriptor(): PeerDescriptor {
-        return this.localPeerDescriptor
-    }
-
-    async stop(): Promise<void> {
-        await this.simulatorConnector!.stop()
-    }
-}

package/src/connection/Handshaker.ts

@@ -1,209 +0,0 @@
-import { Logger } from '@streamr/utils'
-import { EventEmitter } from 'eventemitter3'
-import { v4 } from 'uuid'
-import { Message, HandshakeRequest, HandshakeResponse, PeerDescriptor, HandshakeError } from '../../generated/packages/dht/protos/DhtRpc'
-import { IConnection } from './IConnection'
-import { LOCAL_PROTOCOL_VERSION, isMaybeSupportedProtocolVersion } from '../helpers/version'
-import { toNodeId } from '../identifiers'
-import { PendingConnection } from './PendingConnection'
-import { version as applicationVersion } from '../../package.json'
-
-const logger = new Logger(module)
-
-interface HandshakerEvents {
-    handshakeRequest: (source: PeerDescriptor, protocolVersion: string, target?: PeerDescriptor) => void
-    handshakeCompleted: (remote: PeerDescriptor) => void
-    handshakeFailed: (error?: HandshakeError) => void
-}
-
-// Optimally the Outgoing and Incoming Handshakers could be their own separate classes
-// However, in cases where the PeerDescriptor of the other end of the connection can be known
-// only after a HandshakeRequest a base Handshaker class is needed as the IncomingHandshaker currently
-// requires knowledge of the other ends PeerDescriptor. (Note PendingConnection requires the remote PeerDescriptor)
-export const createOutgoingHandshaker = (
-    localPeerDescriptor: PeerDescriptor,
-    pendingConnection: PendingConnection,
-    connection: IConnection,
-    targetPeerDescriptor?: PeerDescriptor
-): Handshaker => {
-    const handshaker = new Handshaker(localPeerDescriptor, connection)
-    const stopHandshaker = () => {
-        handshaker.stop()
-        connection.off('disconnected', disconnectedListener)
-        connection.off('connected', connectedListener)
-        handshaker.off('handshakeCompleted', handshakeCompletedListener)
-        handshaker.off('handshakeFailed', handshakeFailedListener)
-        pendingConnection.off('disconnected', managedConnectionDisconnectedListener)
-    }
-    const handshakeFailedListener = (error?: HandshakeError) => {
-        if (error === HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR || error === HandshakeError.UNSUPPORTED_PROTOCOL_VERSION) {
-            pendingConnection.close(false)
-            stopHandshaker()
-        } else {
-            // Wait for the other end to close the connection
-        }
-    }
-    const handshakeCompletedListener = (peerDescriptor: PeerDescriptor) => {
-        logger.trace('handshake completed for outgoing connection, ' + toNodeId(peerDescriptor))
-        pendingConnection.onHandshakeCompleted(connection)
-        stopHandshaker()
-    }
-    const connectedListener = () => handshaker.sendHandshakeRequest(targetPeerDescriptor)
-    const disconnectedListener = (graceful: boolean) => {
-        pendingConnection.close(graceful)
-        stopHandshaker()
-    }
-    const managedConnectionDisconnectedListener = () => {
-        connection.close(false)
-        stopHandshaker()
-    }
-    handshaker.once('handshakeFailed', handshakeFailedListener)
-    handshaker.once('handshakeCompleted', handshakeCompletedListener)
-    connection.once('connected', connectedListener)
-    connection.once('disconnected', disconnectedListener)
-    pendingConnection.once('disconnected', managedConnectionDisconnectedListener)
-    return handshaker
-}
-
-export const createIncomingHandshaker = (
-    localPeerDescriptor: PeerDescriptor,
-    pendingConnection: PendingConnection,
-    connection: IConnection
-): Handshaker => {
-    const handshaker = new Handshaker(localPeerDescriptor, connection)
-    const stopHandshaker = () => {
-        handshaker.stop()
-        pendingConnection.off('disconnected', connectionDisconnected)
-        connection.off('disconnected', connectionDisconnected)
-    }
-    const onHandshakeRequest = (): void => {
-        stopHandshaker()
-    }
-    const connectionDisconnected = (graceful: boolean) => {
-        pendingConnection.close(graceful)
-        stopHandshaker()
-    }
-    const managedConnectionDisconnected = () => {
-        connection.close(false)
-        stopHandshaker()
-    }
-    handshaker.on('handshakeRequest', onHandshakeRequest)
-    connection.once('disconnected', connectionDisconnected)
-    pendingConnection.once('disconnected', managedConnectionDisconnected)
-    return handshaker
-}
-
-export const rejectHandshake = (
-    pendingConnection: PendingConnection,
-    connection: IConnection,
-    handshaker: Handshaker,
-    error: HandshakeError
-): void => {
-    handshaker.sendHandshakeResponse(error)
-    connection.destroy()
-    pendingConnection.destroy()
-}
-
-export const acceptHandshake = (handshaker: Handshaker, pendingConnection: PendingConnection, connection: IConnection): void => {
-    handshaker.sendHandshakeResponse()
-    pendingConnection.onHandshakeCompleted(connection)
-}
-
-export const createHandshakeRequest = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): Message => {
-    const outgoingHandshake: HandshakeRequest = {
-        sourcePeerDescriptor: localPeerDescriptor,
-        targetPeerDescriptor: remotePeerDescriptor,
-        protocolVersion: LOCAL_PROTOCOL_VERSION,
-        applicationVersion
-    }
-    return {
-        serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
-        messageId: v4(),
-        body: {
-            oneofKind: 'handshakeRequest',
-            handshakeRequest: outgoingHandshake
-        }
-    }
-}
-
-export const createHandshakeResponse = (localPeerDescriptor: PeerDescriptor, error?: HandshakeError): Message => {
-    const outgoingHandshakeResponse: HandshakeResponse = {
-        sourcePeerDescriptor: localPeerDescriptor,
-        error,
-        protocolVersion: LOCAL_PROTOCOL_VERSION,
-        applicationVersion
-    }
-    return {
-        serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
-        messageId: v4(),
-        body: {
-            oneofKind: 'handshakeResponse',
-            handshakeResponse: outgoingHandshakeResponse
-        }
-    }
-}
-
-export class Handshaker extends EventEmitter<HandshakerEvents> {
-
-    public static readonly HANDSHAKER_SERVICE_ID = 'system/handshaker'
-    private localPeerDescriptor: PeerDescriptor
-    private connection: IConnection
-    private readonly onDataListener: (data: Uint8Array) => void
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        connection: IConnection
-    ) {
-        super()
-        this.localPeerDescriptor = localPeerDescriptor
-        this.connection = connection
-        this.onDataListener = (data: Uint8Array) => this.onData(data)
-        this.connection.on('data', this.onDataListener)
-    }
-
-    private onData(data: Uint8Array) {
-        try {
-            const message = Message.fromBinary(data)
-            if (message.body.oneofKind === 'handshakeRequest') {
-                logger.trace('handshake request received')
-                const handshake = message.body.handshakeRequest
-                this.emit(
-                    'handshakeRequest',
-                    handshake.sourcePeerDescriptor!,
-                    handshake.protocolVersion,
-                    handshake.targetPeerDescriptor
-                )
-            }
-            if (message.body.oneofKind === 'handshakeResponse') {
-                logger.trace('handshake response received')
-                const handshake = message.body.handshakeResponse
-                const error = !isMaybeSupportedProtocolVersion(handshake.protocolVersion) 
-                    ? HandshakeError.UNSUPPORTED_PROTOCOL_VERSION : handshake.error
-                if (error !== undefined) {
-                    this.emit('handshakeFailed', error)
-                } else {
-                    this.emit('handshakeCompleted', handshake.sourcePeerDescriptor!)
-                }
-            }
-        } catch (err) {
-            logger.debug('error while parsing handshake message', err)
-        }
-
-    }
-
-    public sendHandshakeRequest(remotePeerDescriptor?: PeerDescriptor): void {
-        const msg = createHandshakeRequest(this.localPeerDescriptor, remotePeerDescriptor!)
-        this.connection.send(Message.toBinary(msg))
-        logger.trace('handshake request sent')
-    }
-
-    public sendHandshakeResponse(error?: HandshakeError): void {
-        const msg = createHandshakeResponse(this.localPeerDescriptor, error)
-        this.connection.send(Message.toBinary(msg))
-        logger.trace('handshake response sent')
-    }
-
-    public stop(): void {
-        this.connection.off('data', this.onDataListener)
-        this.removeAllListeners()
-    }
-}

package/src/connection/IConnection.ts

@@ -1,40 +0,0 @@
-import { BrandedString } from '@streamr/utils'
-
-export interface ConnectionEvents {
-    data: (bytes: Uint8Array) => void
-    connected: () => void
-    disconnected: (gracefulLeave: boolean, code?: number, reason?: string) => void 
-    error: (name: string) => void
-}
-
-export enum ConnectionType {
-    WEBSOCKET_SERVER = 'websocket-server',
-    WEBSOCKET_CLIENT = 'websocket-client',
-    WEBRTC = 'webrtc',
-    SIMULATOR_SERVER = 'simulator-server',
-    SIMULATOR_CLIENT = 'simulator-client',
-}
-
-export type ConnectionID = BrandedString<'ConnectionID'>
-
-export interface IConnection {
-    
-    on(event: 'data', listener: (bytes: Uint8Array) => void): this
-    on(event: 'error', listener: (name: string) => void): this
-    on(event: 'connected', listener: () => void): this
-    on(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): this
-    
-    once(event: 'data', listener: (bytes: Uint8Array) => void): this
-    once(event: 'error', listener: (name: string) => void): this
-    once(event: 'connected', listener: () => void): this
-    once(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): this
-
-    off(event: 'data', listener: (bytes: Uint8Array) => void): void
-    off(event: 'error', listener: (name: string) => void): void
-    off(event: 'connected', listener: () => void): void
-    off(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): void
-    
-    send(data: Uint8Array): void
-    close(gracefulLeave: boolean): Promise<void>
-    destroy(): void
-}

package/src/connection/ManagedConnection.ts

@@ -1,113 +0,0 @@
-import { ConnectionID, IConnection } from './IConnection'
-import * as Err from '../helpers/errors'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { Logger } from '@streamr/utils'
-import EventEmitter from 'eventemitter3'
-import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
-import { DhtAddress, toNodeId } from '../identifiers'
-import { createRandomConnectionId } from './Connection'
-
-export interface ManagedConnectionEvents {
-    managedData: (bytes: Uint8Array, remotePeerDescriptor: PeerDescriptor) => void
-    disconnected: (gracefulLeave: boolean) => void
-}
-
-const logger = new Logger(module)
-
-export type Events = ManagedConnectionEvents
-
-// ManagedConnection is a component used as a wrapper for IConnection after they have been successfully handshaked.
-// Should only be used in the ConnectionManager.
-export class ManagedConnection extends EventEmitter<ManagedConnectionEvents> {
-
-    private connection: IConnection
-    public connectionId: ConnectionID
-    private remotePeerDescriptor: PeerDescriptor
-    private lastUsedTimestamp: number = Date.now()
-    private replacedAsDuplicate = false
-    private stopped = false
-    private openedAt = Date.now()
-    private bytesSent = 0
-    private bytesReceived = 0
-    private messagesSent = 0
-    private messagesReceived = 0
-
-    constructor(peerDescriptor: PeerDescriptor, connection: IConnection) {
-        super()
-        this.connectionId = createRandomConnectionId()
-        this.connection = connection
-
-        connection.on('data', (bytes: Uint8Array) => {
-            this.lastUsedTimestamp = Date.now()
-            this.messagesReceived += 1
-            this.bytesReceived += bytes.length
-            this.emit('managedData', bytes, this.getPeerDescriptor()!)
-        })
-        connection.on('disconnected', (gracefulLeave) => this.onDisconnected(gracefulLeave))
-
-        this.lastUsedTimestamp = Date.now()
-        this.remotePeerDescriptor = peerDescriptor
-    }
-
-    private onDisconnected(gracefulLeave: boolean): void {
-        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' onDisconnected() ' + gracefulLeave)
-        if (!this.replacedAsDuplicate) {
-            this.emit('disconnected', gracefulLeave)
-        }
-        this.removeAllListeners()
-    }
-
-    // TODO: Can this be removed if ManagedConnections can never be duplicates?
-    // Handle duplicates in the ConncetorFacade and no longer have PendingConnections in ConnectionManager
-    replaceAsDuplicate(): void {
-        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate')
-        this.replacedAsDuplicate = true
-    }
-
-    send(data: Uint8Array): void {
-        if (this.stopped) {
-            throw new Err.SendFailed('ManagedConnection is stopped')
-        }
-        this.lastUsedTimestamp = Date.now()
-        this.messagesSent += 1
-        this.bytesSent += data.length
-        this.connection.send(data)
-    }
-
-    async close(gracefulLeave: boolean): Promise<void> {
-        if (this.stopped) {
-            return
-        }
-        await this.connection.close(gracefulLeave)       
-        this.removeAllListeners()
-    }
-
-    getNodeId(): DhtAddress {
-        return toNodeId(this.remotePeerDescriptor)
-    }
-
-    getLastUsedTimestamp(): number {
-        return this.lastUsedTimestamp
-    }
-
-    getPeerDescriptor(): PeerDescriptor | undefined {
-        return this.remotePeerDescriptor
-    }
-
-    getDiagnosticInfo(): Record<string, unknown> {
-        return {
-            remotePeerDescriptor: this.remotePeerDescriptor,
-            lastUsedTimestamp: this.lastUsedTimestamp,
-            replacedAsDuplicate: this.replacedAsDuplicate,
-            stopped: this.stopped,
-            openedAt: this.openedAt,
-            bytesSent: this.bytesSent,
-            bytesReceived: this.bytesReceived,
-            messagesSent: this.messagesSent,
-            messagesReceived: this.messagesReceived
-            // Add connection type?
-        }
-
-    }
-
-}

package/src/connection/OutputBuffer.ts

@@ -1,28 +0,0 @@
-import { Defer } from '@streamr/utils'
-import { SendFailed } from '../helpers/errors'
-
-export class OutputBuffer {
-
-    private readonly buffer: Uint8Array[] = []
-    private readonly deferredPromise: Defer<void> = new Defer<void>()
-
-    push(message: Uint8Array): Defer<void> {
-        this.buffer.push(message)
-        return this.deferredPromise
-    }
-
-    getBuffer(): Uint8Array[] {
-        return this.buffer
-    }
-
-    resolve(): void {
-        this.buffer.length = 0
-        this.deferredPromise.resolve()
-    }
-
-    reject(): void {
-        this.buffer.length = 0
-        this.deferredPromise.reject(new SendFailed('Could not send buffered messages'))
-    }
-
-}

package/src/connection/PendingConnection.ts

@@ -1,68 +0,0 @@
-import EventEmitter from 'eventemitter3'
-import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { Logger, setAbortableTimeout } from '@streamr/utils'
-import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
-import { IConnection } from './IConnection'
-
-export interface PendingConnectionEvents {
-    connected: (peerDescriptor: PeerDescriptor, connection: IConnection) => void
-    disconnected: (gracefulLeave: boolean) => void
-}
-
-const logger = new Logger(module)
-
-// PendingConnection is used as a reference to a connection that should be opened and handshaked to a given PeerDescriptor
-// It does not hold a connection internally. The public method onHandshakedCompleted should be called once a connection for the 
-// remotePeerDescriptor is opened and handshaked successfully.
-// PendingConnections are created by the Connectors.
-export class PendingConnection extends EventEmitter<PendingConnectionEvents> {
-
-    private readonly connectingAbortController: AbortController = new AbortController()
-    private remotePeerDescriptor: PeerDescriptor
-    private replacedAsDuplicate: boolean = false
-    private stopped: boolean = false
-
-    constructor(remotePeerDescriptor: PeerDescriptor, timeout = 15 * 1000) {
-        super()
-        this.remotePeerDescriptor = remotePeerDescriptor
-        setAbortableTimeout(() => {
-            this.close(false)
-        }, timeout, this.connectingAbortController.signal)
-    }
-
-    replaceAsDuplicate(): void {
-        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate')
-        this.replacedAsDuplicate = true
-    }
-
-    onHandshakeCompleted(connection: IConnection): void {
-        if (!this.replacedAsDuplicate) {
-            this.emit('connected', this.remotePeerDescriptor, connection)
-        }
-    }
-
-    close(graceful: boolean): void {
-        if (this.stopped) {
-            return
-        }
-        this.stopped = true
-        this.connectingAbortController.abort()
-        if (!this.replacedAsDuplicate) {
-            this.emit('disconnected', graceful)
-        }
-    }
-
-    destroy(): void {
-        if (this.stopped) {
-            return
-        }
-        this.stopped = true
-        this.connectingAbortController.abort()
-        this.removeAllListeners()
-    }
-
-    getPeerDescriptor(): PeerDescriptor {
-        return this.remotePeerDescriptor
-    }
-
-}