@streamr/trackerless-network 102.0.0-beta.0 → 102.0.0-beta.2

package/src/logic/DuplicateMessageDetector.ts

@@ -1,167 +0,0 @@
-/**
- * Represent a pair of numbers (a,b). Ordering between two pairs is defined as
- * follows. First compare first numbers. Compare second numbers if first are
- * equal.
- */
-export class NumberPair {
-    private readonly a
-    private readonly b
-
-    constructor(a: number, b: number) {
-        this.a = a
-        this.b = b
-    }
-
-    greaterThanOrEqual(otherPair: NumberPair): boolean {
-        return this.greaterThan(otherPair) || this.equalTo(otherPair)
-    }
-
-    greaterThan(otherPair: NumberPair): boolean {
-        return this.compareTo(otherPair) === 1
-    }
-
-    equalTo(otherPair: NumberPair): boolean {
-        return this.compareTo(otherPair) === 0
-    }
-
-    private compareTo(otherPair: NumberPair): number {
-        if (this.a > otherPair.a) {
-            return 1
-        }
-        if (this.a < otherPair.a) {
-            return -1
-        }
-        if (this.b > otherPair.b) {
-            return 1
-        }
-        if (this.b < otherPair.b) {
-            return -1
-        }
-        return 0
-    }
-
-    toString(): string {
-        return `${this.a}|${this.b}`
-    }
-}
-
-export class InvalidNumberingError extends Error {
-    constructor() {
-        super('pre-condition: previousNumber < number')
-    }
-}
-
-export class GapMisMatchError extends Error {
-    constructor(state: string, previousNumber: NumberPair, number: NumberPair) {
-        super('pre-condition: gap overlap in given numbers:'
-            + ` previousNumber=${previousNumber.toString()}, number=${number.toString()}, state=${state}`)
-    }
-}
-
-/**
- *
- * Keeps track of a stream's message numbers and reports already seen numbers
- * as duplicates.
- *
- * Leverages the fact that message are assigned numbers from a strictly
- * increasing integer sequence for lowered space complexity. For example,
- * if we know that all messages up to number N have been seen, we can only
- * store the number N to provide message identity check. This is because
- * anything less than N can be deemed a duplicate.
- *
- * Messages arriving out-of-order makes this a bit harder since gaps form.
- * Most of the code in this class is built to deal with this complexity.
- * Basically, we need to keep track of which intervals [N,M] could still
- * contain unseen messages. We should also remove intervals after we are sure
- * that they contain no unseen messages.
- *
- * In addition to the above, there needs to be a limit to the number of
- * intervals we store, as it could well be that some messages never
- * arrive. The strategy is to start removing the lowest numbered
- * intervals when storage limits are hit.
- *
- */
-export class DuplicateMessageDetector {
-    private readonly maxGapCount: number
-    private readonly gaps: Array<[NumberPair, NumberPair]>
-
-    constructor(maxGapCount = 10000) {
-        this.maxGapCount = maxGapCount
-        this.gaps = [] // ascending order of half-closed intervals (x,y] representing gaps that contain unseen message(s)
-    }
-
-    /**
-     * returns true if number has not yet been seen (i.e. is not a duplicate)
-     */
-    markAndCheck(previousNumber: NumberPair | null, number: NumberPair): boolean | never {
-        if (previousNumber && previousNumber.greaterThanOrEqual(number)) {
-            throw new InvalidNumberingError()
-        }
-
-        if (this.gaps.length === 0) {
-            this.gaps.push([number, new NumberPair(Infinity, Infinity)])
-            return true
-        }
-
-        // Handle special case where previousNumber is not provided. Only
-        // minimal duplicate detection is provided (comparing against latest
-        // known message number).
-        if (previousNumber === null) {
-            if (number.greaterThan(this.gaps[this.gaps.length - 1][0])) {
-                this.gaps[this.gaps.length - 1][0] = number
-                return true
-            }
-            return false
-        }
-
-        for (let i = this.gaps.length - 1; i >= 0; --i) {
-            const [lowerBound, upperBound] = this.gaps[i] // invariant: upperBound > lowerBound
-
-            // implies number > upperBound (would've been handled in previous iteration if gap exists)
-            if (previousNumber.greaterThanOrEqual(upperBound)) {
-                return false
-            }
-            if (previousNumber.greaterThanOrEqual(lowerBound)) {
-                if (number.greaterThan(upperBound)) {
-                    throw new GapMisMatchError(this.toString(), previousNumber, number)
-                }
-                if (previousNumber.equalTo(lowerBound)) {
-                    if (number.equalTo(upperBound)) {
-                        this.gaps.splice(i, 1)
-                    } else {
-                        this.gaps[i] = [number, upperBound]
-                    }
-                } else if (number.equalTo(upperBound)) {
-                    this.gaps[i] = [lowerBound, previousNumber]
-                } else {
-                    this.gaps.splice(i, 1, [lowerBound, previousNumber], [number, upperBound])
-                }
-
-                // invariants after:
-                //   - gaps are in ascending order
-                //   - the intersection between any two gaps is empty
-                //   - there are no gaps that define the empty set
-                //   - last gap is [n, Infinity]
-                //   - anything not covered by a gap is considered seen
-
-                this.dropLowestGapIfOverMaxGapCount()
-                return true
-            }
-            if (number.greaterThan(lowerBound)) {
-                throw new GapMisMatchError(this.toString(), previousNumber, number)
-            }
-        }
-        return false
-    }
-
-    private dropLowestGapIfOverMaxGapCount(): void {
-        // invariant: this.gaps.length <= this.maxGapCount + 1
-        if (this.gaps.length > this.maxGapCount) {
-            this.gaps.shift()
-        }
-    }
-
-    toString(): string {
-        return this.gaps.map(([lower, upper]) => `(${lower.toString()}, ${upper.toString()}]`).join(', ')
-    }
-}

package/src/logic/ExternalNetworkRpc.ts

@@ -1,42 +0,0 @@
-import { IMessageType } from '@protobuf-ts/runtime'
-import { ServerCallContext, ServiceInfo } from '@protobuf-ts/runtime-rpc'
-import { ITransport, ListeningRpcCommunicator } from '@streamr/dht'
-import { ClassType, ClientTransport, ProtoRpcClient, toProtoRpcClient } from '@streamr/proto-rpc'
-
-export const SERVICE_ID = 'external-network-service'
-
-export type ExternalRpcClient = ServiceInfo & ClassType
-// eslint-disable-next-line @typescript-eslint/prefer-function-type, @typescript-eslint/consistent-type-definitions
-export type ExternalRpcClientClass<T extends ExternalRpcClient> = { new (clientTransport: ClientTransport): T }
-
-export class ExternalNetworkRpc {
-
-    private readonly rpcCommunicator: ListeningRpcCommunicator
-
-    constructor(transport: ITransport) {
-        this.rpcCommunicator = new ListeningRpcCommunicator(SERVICE_ID, transport)
-    }
-
-    registerRpcMethod<
-        RequestClass extends IMessageType<RequestType>,
-        ResponseClass extends IMessageType<ResponseType>,
-        RequestType extends object,
-        ResponseType extends object
-    >(
-        request: RequestClass,
-        response: ResponseClass,
-        name: string, 
-        fn: (req: RequestType, context: ServerCallContext) => Promise<ResponseType>
-    ): void {
-        this.rpcCommunicator.registerRpcMethod(request, response, name, fn)
-    }
-
-    createRpcClient<T extends ExternalRpcClient>(clientClass: ExternalRpcClientClass<T>): ProtoRpcClient<T> {
-        return toProtoRpcClient(new clientClass(this.rpcCommunicator.getRpcClientTransport()))
-    }
-
-    destroy(): void {
-        this.rpcCommunicator.destroy()
-    }
-
-}

package/src/logic/NodeList.ts

@@ -1,114 +0,0 @@
-import { DhtAddress, toNodeId } from '@streamr/dht'
-import { sample } from 'lodash'
-import { ContentDeliveryRpcRemote } from './ContentDeliveryRpcRemote'
-import { EventEmitter } from 'eventemitter3'
-
-export interface Events {
-    nodeAdded: (id: DhtAddress, remote: ContentDeliveryRpcRemote) => void
-    nodeRemoved: (id: DhtAddress, remote: ContentDeliveryRpcRemote) => void
-}
-
-const getValuesOfIncludedKeys = (
-    nodes: Map<DhtAddress, ContentDeliveryRpcRemote>,
-    exclude: DhtAddress[],
-    wsOnly = false
-): ContentDeliveryRpcRemote[] => {
-    const values = wsOnly 
-        ? Array.from(nodes.entries()).filter(([_, node]) => node.getPeerDescriptor().websocket !== undefined)
-        : Array.from(nodes.entries())
-    return values
-        .filter(([id]) => !exclude.includes(id))
-        .map(([_id, node]) => node)
-}
-
-// The items in the list are in the insertion order
-
-export class NodeList extends EventEmitter<Events> {
-    private readonly nodes: Map<DhtAddress, ContentDeliveryRpcRemote>
-    private readonly limit: number
-    private ownId: DhtAddress
-
-    constructor(ownId: DhtAddress, limit: number) {
-        super()
-        this.nodes = new Map()
-        this.limit = limit
-        this.ownId = ownId
-    }
-
-    add(remote: ContentDeliveryRpcRemote): void {
-        const nodeId = toNodeId(remote.getPeerDescriptor())
-        if ((this.ownId !== nodeId) && (this.nodes.size < this.limit)) {
-            const isExistingNode = this.nodes.has(nodeId)
-            this.nodes.set(nodeId, remote)
-            
-            if (!isExistingNode) {
-                this.emit('nodeAdded', nodeId, remote)
-            }
-        }
-    }
-
-    remove(nodeId: DhtAddress): void {
-        if (this.nodes.has(nodeId)) {
-            const remote = this.nodes.get(nodeId)!
-            this.nodes.delete(nodeId)
-            this.emit('nodeRemoved', nodeId, remote)
-        }   
-    }
-
-    has(nodeId: DhtAddress): boolean {
-        return this.nodes.has(nodeId)
-    }
-
-    // Replace nodes does not emit nodeRemoved events, use with caution
-    replaceAll(neighbors: ContentDeliveryRpcRemote[]): void {
-        this.nodes.clear()
-        const limited = neighbors.splice(0, this.limit)
-        limited.forEach((remote) => {
-            this.add(remote)
-        })
-    }
-
-    getIds(): DhtAddress[] {
-        return Array.from(this.nodes.keys())
-    }
-
-    get(id: DhtAddress): ContentDeliveryRpcRemote | undefined {
-        return this.nodes.get(id)
-    }
-
-    size(exclude: DhtAddress[] = []): number {
-        return Array.from(this.nodes.keys()).filter((node) => !exclude.includes(node)).length
-    }
-
-    getRandom(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined {
-        return sample(getValuesOfIncludedKeys(this.nodes, exclude))
-    }
-
-    getFirst(exclude: DhtAddress[], wsOnly = false): ContentDeliveryRpcRemote | undefined {
-        const included = getValuesOfIncludedKeys(this.nodes, exclude, wsOnly)
-        return included[0]
-    }
-
-    getFirstAndLast(exclude: DhtAddress[]): ContentDeliveryRpcRemote[] {
-        const included = getValuesOfIncludedKeys(this.nodes, exclude)
-        if (included.length === 0) {
-            return []
-        }
-        return included.length > 1 ? [this.getFirst(exclude)!, this.getLast(exclude)!] : [this.getFirst(exclude)!]
-    }
-
-    getLast(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined {
-        const included = getValuesOfIncludedKeys(this.nodes, exclude)
-        return included[included.length - 1]
-    }
-
-    getAll(): ContentDeliveryRpcRemote[] {
-        return Array.from(this.nodes.values())
-    }
-
-    stop(): void {
-        this.nodes.forEach((node) => this.remove(toNodeId(node.getPeerDescriptor())))
-        this.removeAllListeners()
-    }
-
-}

package/src/logic/PeerDescriptorStoreManager.ts

@@ -1,96 +0,0 @@
-import {
-    DataEntry,
-    DhtAddress,
-    PeerDescriptor,
-    areEqualPeerDescriptors
-} from '@streamr/dht'
-import { Logger, scheduleAtInterval } from '@streamr/utils'
-import { Any } from '../proto/google/protobuf/any'
-
-const parsePeerDescriptor = (dataEntries: DataEntry[]): PeerDescriptor[] => {
-    return dataEntries.filter((entry) => !entry.deleted).map((entry) => Any.unpack(entry.data!, PeerDescriptor))
-}
-
-const logger = new Logger(module)
-
-export const MAX_NODE_COUNT = 8
-
-interface PeerDescriptorStoreManagerOptions {
-    key: DhtAddress
-    localPeerDescriptor: PeerDescriptor
-    storeInterval?: number
-    fetchDataFromDht: (key: DhtAddress) => Promise<DataEntry[]>
-    storeDataToDht: (key: DhtAddress, data: Any) => Promise<PeerDescriptor[]>
-    deleteDataFromDht: (key: DhtAddress, waitForCompletion: boolean) => Promise<void>
-}
-
-/**
- * For each key there is usually 0-MAX_NODE_COUNT PeerDescriptors stored in the DHT. If there are fewer node,
- * the peer descriptor of the local node is stored to the DHT.
- */
-export class PeerDescriptorStoreManager {
-
-    private readonly abortController: AbortController
-    private readonly options: PeerDescriptorStoreManagerOptions
-    private isLocalNodeStored_ = false
-
-    constructor(options: PeerDescriptorStoreManagerOptions) {
-        this.options = options
-        this.abortController = new AbortController()
-    }
-
-    async fetchNodes(): Promise<PeerDescriptor[]> {
-        logger.trace('Fetch data', { key: this.options.key })
-        try {
-            const result = await this.options.fetchDataFromDht(this.options.key)
-            return parsePeerDescriptor(result)
-        } catch {
-            return []
-        }
-    }
-
-    async storeAndKeepLocalNode(): Promise<void> {
-        if (this.abortController.signal.aborted) {
-            return
-        }
-        // eslint-disable-next-line no-underscore-dangle
-        this.isLocalNodeStored_ = true
-        await this.storeLocalNode()
-        await this.keepLocalNode()
-    }
-
-    private async storeLocalNode(): Promise<void> {
-        const localPeerDescriptor = this.options.localPeerDescriptor
-        const dataToStore = Any.pack(localPeerDescriptor, PeerDescriptor)
-        try {
-            await this.options.storeDataToDht(this.options.key, dataToStore)
-        } catch {
-            logger.warn('Failed to store local node', { key: this.options.key })
-        }
-    }
-
-    private async keepLocalNode(): Promise<void> {
-        await scheduleAtInterval(async () => {
-            logger.trace('Attempting to keep local node', { key: this.options.key })
-            try {
-                const discovered = await this.fetchNodes()
-                if (discovered.length < MAX_NODE_COUNT
-                    || discovered.some((peerDescriptor) => areEqualPeerDescriptors(peerDescriptor, this.options.localPeerDescriptor))) {
-                    await this.storeLocalNode()
-                }
-            } catch {
-                logger.debug('Failed to keep local node', { key: this.options.key })
-            }
-        }, this.options.storeInterval ?? 60000, false, this.abortController.signal)
-    }
-
-    public isLocalNodeStored(): boolean {
-        // eslint-disable-next-line no-underscore-dangle
-        return this.isLocalNodeStored_
-    }
-
-    async destroy(): Promise<void> {
-        this.abortController.abort()
-        await this.options.deleteDataFromDht(this.options.key, false)
-    }
-}

package/src/logic/StreamPartNetworkSplitAvoidance.ts

@@ -1,90 +0,0 @@
-import { areEqualPeerDescriptors, DhtAddress, toNodeId, PeerDescriptor } from '@streamr/dht'
-import { Logger, wait } from '@streamr/utils'
-import { DiscoveryLayerNode } from './DiscoveryLayerNode'
-
-/*
- * Tries to find new neighbors if we currently have less than MIN_NEIGHBOR_COUNT neigbors. It does so by
- * rejoining the stream's control layer network.
- * 
- * This way we can avoid some network split scenarios. The functionality is most relevant for small stream
- * networks.
- */
-
-const logger = new Logger(module)
-
-const exponentialRunOff = async (
-    task: () => Promise<void>,
-    description: string,
-    abortSignal: AbortSignal,
-    baseDelay = 500,
-    maxAttempts = 6
-): Promise<void> => {
-    for (let i = 1; i <= maxAttempts; i++) {
-        if (abortSignal.aborted) {
-            return
-        }
-        const factor = 2 ** i
-        const delay = baseDelay * factor
-        try {
-            await task()
-        } catch {
-            logger.trace(`${description} failed, retrying in ${delay} ms`)
-        }
-        try { // Abort controller throws unexpected errors in destroy?
-            await wait(delay, abortSignal)
-        } catch (err) {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-            logger.trace(`${err}`)  // TODO Do we need logging?
-        }
-    }
-}
-
-export const MIN_NEIGHBOR_COUNT = 4
-
-export interface StreamPartNetworkSplitAvoidanceOptions {
-    discoveryLayerNode: DiscoveryLayerNode
-    discoverEntryPoints: (excludedNodes?: Set<DhtAddress>) => Promise<PeerDescriptor[]>
-    exponentialRunOfBaseDelay?: number
-}
-
-export class StreamPartNetworkSplitAvoidance {
-
-    private readonly abortController: AbortController
-    private readonly options: StreamPartNetworkSplitAvoidanceOptions
-    private readonly excludedNodes: Set<DhtAddress> = new Set()
-    private running = false
-
-    constructor(options: StreamPartNetworkSplitAvoidanceOptions) {
-        this.options = options
-        this.abortController = new AbortController()
-    }
-
-    public async avoidNetworkSplit(): Promise<void> {
-        this.running = true
-        await exponentialRunOff(async () => {
-            const discoveredEntrypoints = await this.options.discoverEntryPoints()
-            const filteredEntryPoints = discoveredEntrypoints.filter((peer) => !this.excludedNodes.has(toNodeId(peer)))
-            await this.options.discoveryLayerNode.joinDht(filteredEntryPoints, false, false)
-            if (this.options.discoveryLayerNode.getNeighborCount() < MIN_NEIGHBOR_COUNT) {
-                // Filter out nodes that are not neighbors as those nodes are assumed to be offline
-                const newExcludes = filteredEntryPoints
-                    .filter((peer) => !this.options.discoveryLayerNode.getNeighbors()
-                        .some((neighbor) => areEqualPeerDescriptors(neighbor, peer)))
-                    .map((peer) => toNodeId(peer))
-                newExcludes.forEach((node) => this.excludedNodes.add(node))
-                throw new Error(`Network split is still possible`)
-            }
-        }, 'avoid network split', this.abortController.signal, this.options.exponentialRunOfBaseDelay)
-        this.running = false
-        this.excludedNodes.clear()
-        logger.trace(`Network split avoided`)
-    }
-
-    public isRunning(): boolean {
-        return this.running
-    }
-
-    destroy(): void {
-        this.abortController.abort()
-    }
-}

package/src/logic/StreamPartReconnect.ts

@@ -1,38 +0,0 @@
-import { scheduleAtInterval } from '@streamr/utils'
-import { MAX_NODE_COUNT, PeerDescriptorStoreManager } from './PeerDescriptorStoreManager'
-import { DiscoveryLayerNode } from './DiscoveryLayerNode'
-
-const DEFAULT_RECONNECT_INTERVAL = 30 * 1000
-export class StreamPartReconnect {
-    private abortController?: AbortController
-    private readonly discoveryLayerNode: DiscoveryLayerNode
-    private readonly peerDescriptorStoreManager: PeerDescriptorStoreManager
-
-    constructor(discoveryLayerNode: DiscoveryLayerNode, peerDescriptorStoreManager: PeerDescriptorStoreManager) {
-        this.discoveryLayerNode = discoveryLayerNode
-        this.peerDescriptorStoreManager = peerDescriptorStoreManager
-    }
-
-    async reconnect(timeout = DEFAULT_RECONNECT_INTERVAL): Promise<void> {
-        this.abortController = new AbortController()
-        await scheduleAtInterval(async () => {
-            const entryPoints = await this.peerDescriptorStoreManager.fetchNodes()
-            await this.discoveryLayerNode.joinDht(entryPoints)
-            // Is is necessary to store the node as an entry point here?
-            if (!this.peerDescriptorStoreManager.isLocalNodeStored() && entryPoints.length < MAX_NODE_COUNT) {
-                await this.peerDescriptorStoreManager.storeAndKeepLocalNode()
-            }
-            if (this.discoveryLayerNode.getNeighborCount() > 0) {
-                this.abortController!.abort()
-            }
-        }, timeout, true, this.abortController.signal)
-    }
-
-    isRunning(): boolean {
-        return this.abortController ? !this.abortController.signal.aborted : false
-    }
-
-    destroy(): void {
-        this.abortController?.abort()
-    }
-}

package/src/logic/createContentDeliveryLayerNode.ts

@@ -1,130 +0,0 @@
-import { DhtAddress, ListeningRpcCommunicator, toNodeId } from '@streamr/dht'
-import { Handshaker } from './neighbor-discovery/Handshaker'
-import { NeighborFinder } from './neighbor-discovery/NeighborFinder'
-import { NeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
-import { StrictContentDeliveryLayerNodeOptions, ContentDeliveryLayerNode } from './ContentDeliveryLayerNode'
-import { NodeList } from './NodeList'
-import { Propagation } from './propagation/Propagation'
-import { StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import type { MarkOptional } from 'ts-essentials'
-import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
-import { Inspector } from './inspect/Inspector'
-import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
-import { formStreamPartContentDeliveryServiceId } from './formStreamPartDeliveryServiceId'
-
-type ContentDeliveryLayerNodeOptions = MarkOptional<StrictContentDeliveryLayerNodeOptions,
-    'nearbyNodeView' | 'randomNodeView' | 'neighbors' | 'leftNodeView' | 'rightNodeView' | 'propagation'
-    | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'neighborTargetCount'
-    | 'rpcCommunicator' | 'nodeViewSize'
-    | 'inspector' | 'temporaryConnectionRpcLocal'> & {
-        maxContactCount?: number
-        minPropagationTargets?: number
-        acceptProxyConnections?: boolean
-        neighborUpdateInterval?: number
-    }
-
-const createConfigWithDefaults = (options: ContentDeliveryLayerNodeOptions): StrictContentDeliveryLayerNodeOptions => {
-    const ownNodeId = toNodeId(options.localPeerDescriptor)
-    const rpcCommunicator = options.rpcCommunicator ?? new ListeningRpcCommunicator(
-        formStreamPartContentDeliveryServiceId(options.streamPartId),
-        options.transport
-    )
-    const neighborTargetCount = options.neighborTargetCount ?? 4
-    const maxContactCount = options.maxContactCount ?? 20
-    const minPropagationTargets = options.minPropagationTargets ?? 2
-    const acceptProxyConnections = options.acceptProxyConnections ?? false
-    const neighborUpdateInterval = options.neighborUpdateInterval ?? 10000
-    const neighbors = options.neighbors ?? new NodeList(ownNodeId, maxContactCount)
-    const leftNodeView = options.leftNodeView ?? new NodeList(ownNodeId, maxContactCount)
-    const rightNodeView = options.rightNodeView ?? new NodeList(ownNodeId, maxContactCount)
-    const nearbyNodeView = options.nearbyNodeView ?? new NodeList(ownNodeId, maxContactCount)
-    const randomNodeView = options.randomNodeView ?? new NodeList(ownNodeId, maxContactCount)
-    const ongoingHandshakes = new Set<DhtAddress>()
-
-    const temporaryConnectionRpcLocal = new TemporaryConnectionRpcLocal({
-        rpcCommunicator,
-        localPeerDescriptor: options.localPeerDescriptor,
-        streamPartId: options.streamPartId,
-        connectionLocker: options.connectionLocker
-    })
-    const proxyConnectionRpcLocal = acceptProxyConnections ? new ProxyConnectionRpcLocal({
-        localPeerDescriptor: options.localPeerDescriptor,
-        streamPartId: options.streamPartId,
-        rpcCommunicator
-    }) : undefined
-    const propagation = options.propagation ?? new Propagation({
-        minPropagationTargets,
-        sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
-            const remote = neighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId)
-            const proxyConnection = proxyConnectionRpcLocal?.getConnection(neighborId)
-            if (remote) {
-                await remote.sendStreamMessage(msg)
-            } else if (proxyConnection) {
-                await proxyConnection.remote.sendStreamMessage(msg)
-            } else {
-                throw new Error('Propagation target not found')
-            }
-        }
-    })
-    const handshaker = options.handshaker ?? new Handshaker({
-        localPeerDescriptor: options.localPeerDescriptor,
-        streamPartId: options.streamPartId,
-        rpcCommunicator,
-        neighbors,
-        leftNodeView,
-        rightNodeView,
-        nearbyNodeView,
-        randomNodeView,
-        maxNeighborCount: neighborTargetCount,
-        rpcRequestTimeout: options.rpcRequestTimeout,
-        ongoingHandshakes
-    })
-    const neighborFinder = options.neighborFinder ?? new NeighborFinder({
-        neighbors,
-        leftNodeView,
-        rightNodeView,
-        nearbyNodeView,
-        randomNodeView,
-        doFindNeighbors: (excludedIds) => handshaker.attemptHandshakesOnContacts(excludedIds),
-        minCount: neighborTargetCount
-    })
-    const neighborUpdateManager = options.neighborUpdateManager ?? new NeighborUpdateManager({
-        neighbors,
-        nearbyNodeView,
-        localPeerDescriptor: options.localPeerDescriptor,
-        neighborFinder,
-        streamPartId: options.streamPartId,
-        rpcCommunicator,
-        neighborUpdateInterval,
-        neighborTargetCount,
-        ongoingHandshakes
-    })
-    const inspector = options.inspector ?? new Inspector({
-        localPeerDescriptor: options.localPeerDescriptor,
-        rpcCommunicator,
-        streamPartId: options.streamPartId,
-        connectionLocker: options.connectionLocker
-    })
-    return {
-        ...options,
-        neighbors,
-        leftNodeView,
-        rightNodeView,
-        nearbyNodeView,
-        randomNodeView,
-        rpcCommunicator,
-        handshaker,
-        neighborFinder,
-        neighborUpdateManager,
-        propagation,
-        neighborTargetCount,
-        nodeViewSize: maxContactCount,
-        proxyConnectionRpcLocal,
-        inspector,
-        temporaryConnectionRpcLocal
-    }
-}
-
-export const createContentDeliveryLayerNode = (options: ContentDeliveryLayerNodeOptions): ContentDeliveryLayerNode => {
-    return new ContentDeliveryLayerNode(createConfigWithDefaults(options))
-}

package/src/logic/formStreamPartDeliveryServiceId.ts

@@ -1,7 +0,0 @@
-import { ServiceID } from '@streamr/dht'
-import { StreamPartID } from '@streamr/utils'
-
-export const formStreamPartContentDeliveryServiceId = (streamPartId: StreamPartID): ServiceID => {
-    // could be "content-delivery" instead of "delivery", but that is a breaking change
-    return `stream-part-delivery-${streamPartId}`
-}