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

package/src/dht/store/StoreManager.ts

@@ -1,170 +0,0 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { Logger } from '@streamr/utils'
-import {
-    DhtAddress,
-    areEqualPeerDescriptors,
-    toDhtAddress,
-    toNodeId,
-    toDhtAddressRaw
-} from '../../identifiers'
-import { Any } from '../../../generated/google/protobuf/any'
-import { Timestamp } from '../../../generated/google/protobuf/timestamp'
-import {
-    DataEntry,
-    PeerDescriptor,
-    RecursiveOperation,
-    ReplicateDataRequest,
-    StoreDataRequest, StoreDataResponse
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { ServiceID } from '../../types/ServiceID'
-import { getClosestNodes } from '../contact/getClosestNodes'
-import { RecursiveOperationManager } from '../recursive-operation/RecursiveOperationManager'
-import { LocalDataStore } from './LocalDataStore'
-import { StoreRpcLocal } from './StoreRpcLocal'
-import { StoreRpcRemote } from './StoreRpcRemote'
-
-interface StoreManagerOptions {
-    rpcCommunicator: RoutingRpcCommunicator
-    recursiveOperationManager: RecursiveOperationManager
-    localPeerDescriptor: PeerDescriptor
-    localDataStore: LocalDataStore
-    serviceId: ServiceID
-    highestTtl: number
-    redundancyFactor: number
-    getNeighbors: () => readonly PeerDescriptor[]
-    createRpcRemote: (contact: PeerDescriptor) => StoreRpcRemote
-}
-
-const logger = new Logger(module)
-
-export class StoreManager {
-
-    private readonly options: StoreManagerOptions
-
-    constructor(options: StoreManagerOptions) {
-        this.options = options
-        this.registerLocalRpcMethods()
-    }
-
-    private registerLocalRpcMethods() {
-        const rpcLocal = new StoreRpcLocal({
-            localPeerDescriptor: this.options.localPeerDescriptor,
-            localDataStore: this.options.localDataStore,
-            replicateDataToContact: (dataEntry: DataEntry, contact: PeerDescriptor) => this.replicateDataToContact(dataEntry, contact),
-            getStorers: (dataKey: DhtAddress) => this.getStorers(dataKey)
-        })
-        this.options.rpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData',
-            (request: StoreDataRequest) => rpcLocal.storeData(request))
-        this.options.rpcCommunicator.registerRpcNotification(ReplicateDataRequest, 'replicateData',
-            (request: ReplicateDataRequest, context: ServerCallContext) => rpcLocal.replicateData(request, context))
-    }
-
-    onContactAdded(peerDescriptor: PeerDescriptor): void {
-        for (const key of this.options.localDataStore.keys()) {
-            this.replicateAndUpdateStaleState(key, peerDescriptor)
-        }
-    }
-
-    private replicateAndUpdateStaleState(dataKey: DhtAddress, newNode: PeerDescriptor): void {
-        const storers = this.getStorers(dataKey)
-        const storersBeforeContactAdded = storers.filter((p) => !areEqualPeerDescriptors(p, newNode))
-        const selfWasPrimaryStorer = areEqualPeerDescriptors(storersBeforeContactAdded[0], this.options.localPeerDescriptor)
-        if (selfWasPrimaryStorer) {
-            if (storers.some((p) => areEqualPeerDescriptors(p, newNode))) {
-                setImmediate(async () => {
-                    const dataEntries = Array.from(this.options.localDataStore.values(dataKey))
-                    await Promise.all(dataEntries.map(async (dataEntry) => this.replicateDataToContact(dataEntry, newNode)))
-                })
-            }
-        } else if (!storers.some((p) => areEqualPeerDescriptors(p, this.options.localPeerDescriptor))) {
-            this.options.localDataStore.setAllEntriesAsStale(dataKey)
-        }
-    }
-
-    private async replicateDataToContact(dataEntry: DataEntry, contact: PeerDescriptor): Promise<void> {
-        const rpcRemote = this.options.createRpcRemote(contact)
-        try {
-            await rpcRemote.replicateData({ entry: dataEntry }, true)
-        } catch (e) {
-            logger.trace('replicateData() threw an exception ' + e)
-        }
-    }
-
-    public async storeDataToDht(key: DhtAddress, data: Any, creator: DhtAddress): Promise<PeerDescriptor[]> {
-        logger.debug(`Storing data to DHT ${this.options.serviceId}`)
-        const result = await this.options.recursiveOperationManager.execute(key, RecursiveOperation.FIND_CLOSEST_NODES)
-        const closestNodes = result.closestNodes
-        const successfulNodes: PeerDescriptor[] = []
-        const ttl = this.options.highestTtl // ToDo: make TTL decrease according to some nice curve
-        const createdAt = Timestamp.now()
-        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.options.redundancyFactor; i++) {
-            const keyRaw = toDhtAddressRaw(key)
-            const creatorRaw = toDhtAddressRaw(creator)
-            if (areEqualPeerDescriptors(this.options.localPeerDescriptor, closestNodes[i])) {
-                this.options.localDataStore.storeEntry({
-                    key: keyRaw,
-                    data,
-                    creator: creatorRaw,
-                    createdAt,
-                    storedAt: Timestamp.now(), 
-                    ttl, 
-                    stale: false,
-                    deleted: false,
-                })
-                successfulNodes.push(closestNodes[i])
-                continue
-            }
-            const rpcRemote = this.options.createRpcRemote(closestNodes[i])
-            try {
-                await rpcRemote.storeData({
-                    key: keyRaw,
-                    data,
-                    creator: creatorRaw,
-                    createdAt,
-                    ttl
-                })
-                successfulNodes.push(closestNodes[i])
-                logger.trace('remote.storeData() success')
-            } catch (e) {
-                logger.trace('remote.storeData() threw an exception ' + e)
-            }
-        }
-        return successfulNodes
-    }
-
-    private async replicateDataToClosestNodes(): Promise<void> {
-        const dataEntries = Array.from(this.options.localDataStore.values())
-        await Promise.all(dataEntries.map(async (dataEntry) => {
-            const dataKey = toDhtAddress(dataEntry.key)
-            const neighbors = getClosestNodes(
-                dataKey,
-                this.options.getNeighbors(),
-                { maxCount: this.options.redundancyFactor }
-            )
-            await Promise.all(neighbors.map(async (neighbor) => {
-                const rpcRemote = this.options.createRpcRemote(neighbor)
-                try {
-                    await rpcRemote.replicateData({ entry: dataEntry }, false)
-                } catch (err) {
-                    logger.trace('Failed to replicate data in replicateDataToClosestNodes', { err })
-                }
-            }))
-        }))
-    }
-
-    private getStorers(dataKey: DhtAddress, excludedNode?: PeerDescriptor): PeerDescriptor[] {
-        return getClosestNodes(
-            dataKey,
-            [...this.options.getNeighbors(), this.options.localPeerDescriptor],
-            { 
-                maxCount: this.options.redundancyFactor,
-                excludedNodeIds: excludedNode !== undefined ? new Set([toNodeId(excludedNode)]) : undefined
-            }
-        )
-    }
-
-    async destroy(): Promise<void> {
-        await this.replicateDataToClosestNodes()
-    }
-}

package/src/dht/store/StoreRpcLocal.ts

@@ -1,89 +0,0 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { Logger, executeSafePromise } from '@streamr/utils'
-import { Empty } from '../../../generated/google/protobuf/empty'
-import { Timestamp } from '../../../generated/google/protobuf/timestamp'
-import {
-    DataEntry,
-    PeerDescriptor,
-    ReplicateDataRequest,
-    StoreDataRequest, StoreDataResponse
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { IStoreRpc } from '../../../generated/packages/dht/protos/DhtRpc.server'
-import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
-import { LocalDataStore } from './LocalDataStore'
-import { areEqualPeerDescriptors, DhtAddress, toDhtAddress } from '../../identifiers'
-
-interface StoreRpcLocalOptions {
-    localDataStore: LocalDataStore
-    localPeerDescriptor: PeerDescriptor
-    replicateDataToContact: (dataEntry: DataEntry, contact: PeerDescriptor) => Promise<void>
-    getStorers: (key: DhtAddress) => readonly PeerDescriptor[]
-}
-
-const logger = new Logger(module)
-
-export class StoreRpcLocal implements IStoreRpc {
-
-    private readonly options: StoreRpcLocalOptions
-
-    constructor(options: StoreRpcLocalOptions) {
-        this.options = options
-    }
-
-    async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
-        logger.trace('storeData()')
-        const key = toDhtAddress(request.key)
-        const isLocalNodeStorer = this.isLocalNodeStorer(key)
-        this.options.localDataStore.storeEntry({ 
-            key: request.key,
-            data: request.data,
-            creator: request.creator,
-            createdAt: request.createdAt,
-            storedAt: Timestamp.now(),
-            ttl: request.ttl,
-            stale: !isLocalNodeStorer,
-            deleted: false
-        })
-        if (!isLocalNodeStorer) {
-            this.options.localDataStore.setAllEntriesAsStale(key)
-        }
-        return {}
-    }
-
-    public async replicateData(request: ReplicateDataRequest, context: ServerCallContext): Promise<Empty> {
-        logger.trace('server-side replicateData()')
-        const dataEntry = request.entry!
-        const wasStored = this.options.localDataStore.storeEntry(dataEntry)
-        if (wasStored) {
-            this.replicateDataToNeighbors((context as DhtCallContext).incomingSourceDescriptor!, request.entry!)
-        }
-        const key = toDhtAddress(dataEntry.key)
-        if (!this.isLocalNodeStorer(key)) {
-            this.options.localDataStore.setAllEntriesAsStale(key)
-        }
-        logger.trace('server-side replicateData() at end')
-        return {}
-    }
-
-    private isLocalNodeStorer(dataKey: DhtAddress): boolean {
-        return this.options.getStorers(dataKey).some((p) => areEqualPeerDescriptors(p, this.options.localPeerDescriptor))    
-    }
-
-    private replicateDataToNeighbors(requestor: PeerDescriptor, dataEntry: DataEntry): void {
-        const dataKey = toDhtAddress(dataEntry.key)
-        const storers = this.options.getStorers(dataKey)
-        const isLocalNodePrimaryStorer = areEqualPeerDescriptors(storers[0], this.options.localPeerDescriptor)
-        // If we are the closest to the data, get storageRedundancyFactor - 1 nearest node to the data, and
-        // replicate to all those node. Otherwise replicate only to the one closest one. And never replicate 
-        // to the requestor nor to itself.
-        const targets = (isLocalNodePrimaryStorer ? storers : [storers[0]]).filter(
-            (p) => !areEqualPeerDescriptors(p, requestor) && !areEqualPeerDescriptors(p, this.options.localPeerDescriptor)
-        )
-        targets.forEach((target) => {
-            setImmediate(() => {
-                executeSafePromise(() => this.options.replicateDataToContact(dataEntry, target))
-            })
-        })
-    }
-
-}

package/src/dht/store/StoreRpcRemote.ts

@@ -1,32 +0,0 @@
-import { toNodeId } from '../../identifiers'
-import {
-    ReplicateDataRequest,
-    StoreDataRequest
-} from '../../../generated/packages/dht/protos/DhtRpc'
-import { StoreRpcClient } from '../../../generated/packages/dht/protos/DhtRpc.client'
-import { EXISTING_CONNECTION_TIMEOUT, RpcRemote } from '../contact/RpcRemote'
-
-export class StoreRpcRemote extends RpcRemote<StoreRpcClient> {
-
-    async storeData(request: StoreDataRequest): Promise<void> {
-        const options = this.formDhtRpcOptions()
-        try {
-            await this.getClient().storeData(request, options)
-        } catch (err) {
-            const to = toNodeId(this.getPeerDescriptor())
-            const from = toNodeId(this.getLocalPeerDescriptor())
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            throw new Error(`Could not store data to ${to} from ${from} ${err}`)
-        }
-    }
-
-    async replicateData(request: ReplicateDataRequest, connect: boolean): Promise<void> {
-        const options = this.formDhtRpcOptions({
-            timeout: EXISTING_CONNECTION_TIMEOUT,
-            notification: true,
-            connect
-        })
-        return this.getClient().replicateData(request, options)
-    }
-
-}

package/src/exports.ts

@@ -1,33 +0,0 @@
-export { DhtNode, DhtNodeEvents, DhtNodeOptions } from './dht/DhtNode'
-export { ListeningRpcCommunicator } from './transport/ListeningRpcCommunicator'
-export { RoutingRpcCommunicator } from './transport/RoutingRpcCommunicator'
-export { Simulator, LatencyType } from './connection/simulator/Simulator'
-export { SimulatorTransport } from './connection/simulator/SimulatorTransport'
-export { getRandomRegion, getRegionDelayMatrix } from './connection/simulator/pings'
-export { PeerDescriptor, Message, NodeType, DataEntry } from '../generated/packages/dht/protos/DhtRpc'
-export { ITransport, TransportEvents } from './transport/ITransport'
-export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
-export { ConnectionsView } from './connection/ConnectionsView'
-export { LockID } from './connection/ConnectionLockStates'
-export { DefaultConnectorFacade } from './connection/ConnectorFacade'
-export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
-export { RpcRemote, EXISTING_CONNECTION_TIMEOUT } from './dht/contact/RpcRemote'
-export { IceServer } from './connection/webrtc/WebrtcConnector'
-export { DhtCallContext } from './rpc-protocol/DhtCallContext'
-export { WebsocketClientConnection } from './connection/websocket/NodeWebsocketClientConnection'
-export { ManagedConnection } from './connection/ManagedConnection'
-export { PendingConnection } from './connection/PendingConnection'
-export { IConnection } from './connection/IConnection'
-export { ConnectionType } from './connection/IConnection'
-export { ServiceID } from './types/ServiceID'
-export { RingContacts } from './dht/contact/RingContactList'
-export { createOutgoingHandshaker } from './connection/Handshaker'
-export { 
-    DhtAddress,
-    DhtAddressRaw,
-    toDhtAddress,
-    toDhtAddressRaw,
-    randomDhtAddress,
-    areEqualPeerDescriptors,
-    toNodeId
-} from './identifiers'

package/src/helpers/AddressTools.ts

@@ -1,28 +0,0 @@
-import ipaddr from 'ipaddr.js'
-
-// IPv4 private address ranges as specified by RFC 1918
-// and private loopback addresses
-const IPv4PrivateRanges = [
-    '10.0.0.0/8',
-    '172.16.0.0/12',
-    '192.168.0.0/16',
-    '127.0.0.0/8'
-].map((a) => ipaddr.parseCIDR(a))
-
-export function isPrivateIPv4(address: string): boolean {
-    if (ipaddr.IPv4.isValid(address)) {
-        const ip = ipaddr.IPv4.parse(address)
-        for (const range of IPv4PrivateRanges) {
-            if (ip.match(range)) {
-                return true
-            }
-        }
-    }
-
-    return false
-}
-
-export function getAddressFromIceCandidate(candidate: string): string | undefined {
-    const fields = candidate.split(' ').filter((field) => field.length > 0)
-    return fields.length >= 5 && ipaddr.isValid(fields[4]) ? fields[4] : undefined
-}

package/src/helpers/Connectivity.ts

@@ -1,19 +0,0 @@
-import { ConnectionType } from '../connection/IConnection'
-import { ConnectivityMethod, NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-import { isPrivateIPv4 } from './AddressTools'
-
-export const canOpenConnectionFromBrowser = (websocketServer: ConnectivityMethod): boolean => {
-    const hasPrivateAddress = ((websocketServer.host === 'localhost') || isPrivateIPv4(websocketServer.host))
-    return websocketServer.tls || hasPrivateAddress
-}
-
-export const expectedConnectionType = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): ConnectionType => {
-    if (remotePeerDescriptor.websocket 
-        && (localPeerDescriptor.type !== NodeType.BROWSER || canOpenConnectionFromBrowser(remotePeerDescriptor.websocket))) {
-        return ConnectionType.WEBSOCKET_CLIENT
-    } else if (localPeerDescriptor.websocket 
-        && (remotePeerDescriptor.type !== NodeType.BROWSER || canOpenConnectionFromBrowser(localPeerDescriptor.websocket))) {
-        return ConnectionType.WEBSOCKET_SERVER
-    }
-    return ConnectionType.WEBRTC
-}

package/src/helpers/browser/isBrowserEnvironment.ts

@@ -1 +0,0 @@
-export const isBrowserEnvironment = (): boolean => false

package/src/helpers/browser/isBrowserEnvironment_override.ts

@@ -1,3 +0,0 @@
-// webpack overwrites the isBrowserEnvironment.ts with this file when it creates the browser bundle
-
-export const isBrowserEnvironment = (): boolean => true

package/src/helpers/createPeerDescriptor.ts

@@ -1,57 +0,0 @@
-import {
-    createSignature,
-    hash
-} from '@streamr/utils'
-import crypto from 'crypto'
-import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
-import { createPeerDescriptorSignaturePayload } from '../helpers/createPeerDescriptorSignaturePayload'
-import { DhtAddress, DhtAddressRaw, toDhtAddressRaw } from '../identifiers'
-import {
-    ConnectivityResponse,
-    NodeType,
-    PeerDescriptor
-} from '../../generated/packages/dht/protos/DhtRpc'
-
-const calculateNodeIdRaw = (ipAddress: number, privateKey: Uint8Array): DhtAddressRaw => {
-    // nodeId is calculated as 
-    // concatenate(
-    //   get104leastSignificatBits(hash(ipAddress)), 
-    //   get56leastSignificatBits(sign(ipAddress))
-    // )
-    const ipAsBuffer = Buffer.alloc(4)
-    ipAsBuffer.writeUInt32BE(ipAddress)
-    const ipHash = hash(ipAsBuffer)
-    const signature = createSignature(ipAsBuffer, privateKey)
-    const nodeIdRaw = Buffer.concat([
-        ipHash.subarray(ipHash.length - 13, ipHash.length),
-        signature.subarray(signature.length - 7, signature.length)
-    ])
-    return nodeIdRaw
-}
-
-export const createPeerDescriptor = (connectivityResponse: ConnectivityResponse, region: number, nodeId?: DhtAddress): PeerDescriptor => {
-    const privateKey = crypto.randomBytes(32)
-    const publicKey = crypto.randomBytes(20)  // TODO calculate publicKey from privateKey
-    let nodeIdRaw: DhtAddressRaw
-    if (nodeId !== undefined) {
-        nodeIdRaw = toDhtAddressRaw(nodeId)
-    } else {
-        nodeIdRaw = calculateNodeIdRaw(connectivityResponse.ipAddress, privateKey)
-    }
-    const ret: PeerDescriptor = {
-        nodeId: nodeIdRaw,
-        type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
-        ipAddress: connectivityResponse.ipAddress,
-        region,
-        publicKey 
-    }
-    if (connectivityResponse.websocket) {
-        ret.websocket = {
-            host: connectivityResponse.websocket.host,
-            port: connectivityResponse.websocket.port,
-            tls: connectivityResponse.websocket.tls
-        }
-    }
-    ret.signature = createSignature(createPeerDescriptorSignaturePayload(ret), privateKey)
-    return ret
-}

package/src/helpers/createPeerDescriptorSignaturePayload.ts

@@ -1,28 +0,0 @@
-import { ConnectivityMethod, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
-
-function convertUnsignedIntegerToBuffer(number: number): Buffer {
-    const buffer = Buffer.alloc(4)
-    buffer.writeUInt32BE(number)
-    return buffer
-}
-
-export const createPeerDescriptorSignaturePayload = (peerDescriptor: PeerDescriptor): Uint8Array => {
-    const separator = Buffer.from(',')
-    const buffers = [
-        peerDescriptor.type !== undefined ? convertUnsignedIntegerToBuffer(peerDescriptor.type) : new Uint8Array(0),
-        separator,
-        peerDescriptor.udp !== undefined ? ConnectivityMethod.toBinary(peerDescriptor.udp) : new Uint8Array(0),
-        separator,
-        peerDescriptor.tcp !== undefined ? ConnectivityMethod.toBinary(peerDescriptor.tcp) : new Uint8Array(0),
-        separator,
-        peerDescriptor.websocket !== undefined ? ConnectivityMethod.toBinary(peerDescriptor.websocket) : new Uint8Array(0),
-        separator,
-        peerDescriptor.region !== undefined ? convertUnsignedIntegerToBuffer(peerDescriptor.region) : new Uint8Array(0),
-        separator,
-        peerDescriptor.ipAddress !== undefined ? convertUnsignedIntegerToBuffer(peerDescriptor.ipAddress) : new Uint8Array(0),
-        separator,
-        peerDescriptor.publicKey !== undefined ? Buffer.from(peerDescriptor.publicKey) : new Uint8Array(0)
-    ]
-    return Buffer.concat(buffers)
-}
-

package/src/helpers/debugHelpers.ts

@@ -1,9 +0,0 @@
-import { Logger } from '@streamr/utils'
-
-export const debugVars: Record<string, any> = []
-
-export function logInfoIf(logger: Logger, condition: boolean, msg: string): void {
-    if (condition) {
-        logger.info(msg)
-    }
-}

package/src/helpers/errors.ts

@@ -1,49 +0,0 @@
-/* eslint-disable max-len */
-
-export enum ErrorCode {
-    CONNECTION_FAILED = 'CONNECTION_FAILED',
-    COULD_NOT_ROUTE = 'COULD_NOT_ROUTE',
-    STARTING_WEBSOCKET_SERVER_FAILED = 'STARTING_WEBSOCKET_SERVER_FAILED',
-    WEBSOCKET_CONNECTION_REQUEST_REJECTED = 'WEBSOCKET_CONNECTION_REQUEST_REJECTED',
-    COULD_NOT_START = 'COULD_NOT_START',
-    COULD_NOT_STOP = 'COULD_NOT_STOP',
-    CANNOT_CONNECT_TO_SELF = 'CANNOT_CONNECT_TO_SELF',
-    NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
-    ILLEGAL_RTC_PEER_CONNECTION_STATE = 'ILLEGAL_RTC_PEER_CONNECTION_STATE',
-    ILLEGAL_ARGUMENTS = 'ILLEGAL_ARGUMENTS',
-    CONNECTIVITY_RESPONSE_NOT_RECEIVED_BEFORE_TIMEOUT = 'CONNECTIVITY_RESPONSE_NOT_RECEIVED_BEFORE_TIMEOUT',
-    CONNECTION_LOCKER = 'CONNECTION_LOCKER',
-    DHT_JOIN_TIMEOUT = 'DHT_JOIN_TIMEOUT',
-    SEND_FAILED = 'SEND_FAILED',
-    GETTING_DATA_FAILED = 'GETTING_DATA_FAILED',
-    CONNECTION_NOT_OPEN = 'CONNECTION_NOT_OPEN'
-}
-
-class Err extends Error {
-    
-    public code: ErrorCode
-    public originalError?: Error | string
-
-    constructor(code: ErrorCode, message?: string, originalError?: Error | string) {
-        super(message)
-        this.code = code
-        this.originalError = originalError
-    }
-}
-
-export class ConnectionFailed extends Err { constructor( message?: string, originalError?: Error | string) { super(ErrorCode.CONNECTION_FAILED, message, originalError) } }
-export class CouldNotRoute extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.COULD_NOT_ROUTE, message, originalError) } }
-export class WebsocketServerStartError extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.STARTING_WEBSOCKET_SERVER_FAILED, message, originalError) } }
-export class WebsocketConnectionRequestRejected extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.WEBSOCKET_CONNECTION_REQUEST_REJECTED, message, originalError) } }
-export class CouldNotStart extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.COULD_NOT_START, message, originalError) } }
-export class CouldNotStop extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.COULD_NOT_STOP, message, originalError) } }
-export class CannotConnectToSelf extends Err { constructor(message?: string, originalError?: Error | string) {super(ErrorCode.CANNOT_CONNECT_TO_SELF, message, originalError) } }
-export class NotImplemented extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.NOT_IMPLEMENTED, message, originalError) } }
-export class IllegalRtcPeerConnectionState extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.ILLEGAL_RTC_PEER_CONNECTION_STATE, message, originalError) } }
-export class IllegalArguments extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.ILLEGAL_ARGUMENTS, message, originalError) } }
-export class ConnectivityResponseTimeout extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.CONNECTIVITY_RESPONSE_NOT_RECEIVED_BEFORE_TIMEOUT, message, originalError) } }
-export class ConnectionLocker extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.CONNECTION_LOCKER, message, originalError) } }
-export class DhtJoinTimeout extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.DHT_JOIN_TIMEOUT, message, originalError) } }
-export class SendFailed extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.SEND_FAILED, message, originalError) } }
-export class GettingDataFailed extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.GETTING_DATA_FAILED, message, originalError) } }
-export class ConnectionNotOpen extends Err { constructor( message?: string, originalError?: Error | string) { super(ErrorCode.CONNECTION_NOT_OPEN, message, originalError) } }

package/src/helpers/offering.ts

@@ -1,15 +0,0 @@
-import crypto from 'crypto'
-import { DhtAddress } from '../identifiers'
-
-type Offerer = 'local' | 'remote'
-
-export const getOfferer = (localNodeId: DhtAddress, remoteNodeId: DhtAddress): Offerer => {
-    return getOfferingHash(localNodeId + ',' + remoteNodeId) < getOfferingHash(remoteNodeId + ',' + localNodeId)
-        ? 'local'
-        : 'remote'
-}
-
-const getOfferingHash = (idPair: string): number => {
-    const buffer = crypto.createHash('md5').update(idPair).digest()
-    return buffer.readInt32LE(0)
-}

package/src/helpers/protoClasses.ts

@@ -1,57 +0,0 @@
-import { IMessageType } from '@protobuf-ts/runtime'
-import {
-    ClosestPeersRequest,
-    ClosestPeersResponse, 
-    ConnectivityMethod,  
-    ConnectivityRequest, 
-    ConnectivityResponse, 
-    DisconnectNotice,
-    HandshakeRequest, 
-    HandshakeResponse, 
-    LeaveNotice, 
-    Message, 
-    PeerDescriptor, 
-    PingRequest, 
-    PingResponse, 
-    RecursiveOperationResponse, 
-    RecursiveOperationRequest, 
-    RouteMessageAck, 
-    RouteMessageWrapper,
-    WebsocketConnectionRequest,
-    WebrtcConnectionRequest,
-    RtcOffer,
-    RtcAnswer,
-    IceCandidate,
-    LockRequest,
-    UnlockRequest,
-    LockResponse
-
-} from '../../generated/packages/dht/protos/DhtRpc'
-
-export const protoClasses: IMessageType<any>[] = [
-    ClosestPeersRequest,
-    ClosestPeersResponse,
-    RecursiveOperationRequest,
-    RecursiveOperationResponse,
-    PingRequest,
-    PingResponse,
-    LeaveNotice,
-    PeerDescriptor,
-    ConnectivityMethod,
-    DisconnectNotice,
-    RouteMessageWrapper,
-    RouteMessageAck,
-    ConnectivityRequest,
-    ConnectivityResponse,
-    HandshakeRequest,
-    HandshakeResponse,
-    Message,
-    WebsocketConnectionRequest,
-    WebrtcConnectionRequest,
-    RtcOffer,
-    RtcAnswer,
-    IceCandidate,
-    LockRequest,
-    UnlockRequest,
-    LockResponse
-]

package/src/helpers/protoToString.ts

@@ -1,21 +0,0 @@
-import { IMessageType } from '@protobuf-ts/runtime'
-
-import { protoClasses } from './protoClasses'
-import { protoClasses as rpcProtoClasses } from '@streamr/proto-rpc'
-
-const typeRegistry = protoClasses.concat(rpcProtoClasses)
-
-export function protoToString<T extends object, ClassType extends IMessageType<T>>(protoObj: T,
-    objectType: ClassType): string {
-
-    let ret = ''
-    try {
-        ret = objectType.toJsonString(protoObj, {
-            typeRegistry
-        })
-    } catch (_e) {
-        ret = '[type not in type registry]'
-    }
-
-    return ret
-}

package/src/helpers/version.ts

@@ -1,32 +0,0 @@
-export const LOCAL_PROTOCOL_VERSION = '1.1'
-
-/*
- * When two nodes negotiate whether they are compatible or not, it is up to the
- * newer version to decide if it supports the old version or not.
- * 
- * 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_PROTOCOL_VERSION error).
- */
-export const isMaybeSupportedProtocolVersion = (remoteVersion: string): boolean => {
-    const localMajor = parseVersion(LOCAL_PROTOCOL_VERSION)!.major
-    const remoteMajor = parseVersion(remoteVersion)?.major
-    if ((remoteMajor === undefined) || (remoteMajor < localMajor)) {
-        return false
-    } else {
-        // TODO implement proper checking when there are new protocol versions
-        return true
-    }
-}
-
-export const parseVersion = (version: string): { major: number, minor: number } | undefined => {
-    const parts = version.split('.')
-    if (parts.length === 2) {
-        const values = parts.map((p) => Number(p))
-        if (!values.some((v) => isNaN(v))) {
-            return { major: values[0], minor: values[1] }
-        }
-    } else {
-        return undefined
-    }
-}