@streamr/trackerless-network 103.1.2 → 103.2.0-experiment.0

package/dist/exports.js

@@ -0,0 +1,4477 @@
+import { ListeningRpcCommunicator, PeerDescriptor as PeerDescriptor$1, areEqualPeerDescriptors, toNodeId, RpcRemote, toDhtAddress, toDhtAddressRaw, EXISTING_CONNECTION_TIMEOUT, DhtNode } from '@streamr/dht';
+import { toProtoRpcClient } from '@streamr/proto-rpc';
+import { Logger, scheduleAtInterval, wait, setAbortableTimeout, toUserId, addManagedEventListener, waitForEvent, toUserIdRaw, computeSha1, MetricsContext, RateMetric, toStreamPartID, StreamPartIDUtils, until } from '@streamr/utils';
+import pull from 'lodash/pull';
+import { EventEmitter } from 'eventemitter3';
+import sampleSize from 'lodash/sampleSize';
+import { MessageType, jsonWriteOptions, isJsonObject, typeofJsonValue, reflectionMergePartial, UnknownFieldHandler, WireType, PbLong } from '@protobuf-ts/runtime';
+import { ServiceType, stackIntercept } from '@protobuf-ts/runtime-rpc';
+import { v4 } from 'uuid';
+import sample from 'lodash/sample';
+import { Yallist, Node } from 'yallist';
+
+const SERVICE_ID$1 = 'external-network-service';
+class ExternalNetworkRpc {
+    rpcCommunicator;
+    constructor(transport) {
+        this.rpcCommunicator = new ListeningRpcCommunicator(SERVICE_ID$1, transport);
+    }
+    registerRpcMethod(request, response, name, fn) {
+        this.rpcCommunicator.registerRpcMethod(request, response, name, fn);
+    }
+    createRpcClient(clientClass) {
+        return toProtoRpcClient(new clientClass(this.rpcCommunicator.getRpcClientTransport()));
+    }
+    destroy() {
+        this.rpcCommunicator.destroy();
+    }
+}
+
+var version = "103.2.0-experiment.0";
+
+// @generated message type with reflection information, may provide speed optimized methods
+class Any$Type extends MessageType {
+    constructor() {
+        super("google.protobuf.Any", [
+            { no: 1, name: "type_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "value", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    /**
+     * Pack the message into a new `Any`.
+     *
+     * Uses 'type.googleapis.com/full.type.name' as the type URL.
+     */
+    pack(message, type) {
+        return {
+            typeUrl: this.typeNameToUrl(type.typeName), value: type.toBinary(message),
+        };
+    }
+    /**
+     * Unpack the message from the `Any`.
+     */
+    unpack(any, type, options) {
+        if (!this.contains(any, type))
+            throw new Error("Cannot unpack google.protobuf.Any with typeUrl '" + any.typeUrl + "' as " + type.typeName + ".");
+        return type.fromBinary(any.value, options);
+    }
+    /**
+     * Does the given `Any` contain a packed message of the given type?
+     */
+    contains(any, type) {
+        if (!any.typeUrl.length)
+            return false;
+        let wants = typeof type == "string" ? type : type.typeName;
+        let has = this.typeUrlToName(any.typeUrl);
+        return wants === has;
+    }
+    /**
+     * Convert the message to canonical JSON value.
+     *
+     * You have to provide the `typeRegistry` option so that the
+     * packed message can be converted to JSON.
+     *
+     * The `typeRegistry` option is also required to read
+     * `google.protobuf.Any` from JSON format.
+     */
+    internalJsonWrite(any, options) {
+        if (any.typeUrl === "")
+            return {};
+        let typeName = this.typeUrlToName(any.typeUrl);
+        let opt = jsonWriteOptions(options);
+        let type = opt.typeRegistry?.find(t => t.typeName === typeName);
+        if (!type)
+            throw new globalThis.Error("Unable to convert google.protobuf.Any with typeUrl '" + any.typeUrl + "' to JSON. The specified type " + typeName + " is not available in the type registry.");
+        let value = type.fromBinary(any.value, { readUnknownField: false });
+        let json = type.internalJsonWrite(value, opt);
+        if (typeName.startsWith("google.protobuf.") || !isJsonObject(json))
+            json = { value: json };
+        json["@type"] = any.typeUrl;
+        return json;
+    }
+    internalJsonRead(json, options, target) {
+        if (!isJsonObject(json))
+            throw new globalThis.Error("Unable to parse google.protobuf.Any from JSON " + typeofJsonValue(json) + ".");
+        if (typeof json["@type"] != "string" || json["@type"] == "")
+            return this.create();
+        let typeName = this.typeUrlToName(json["@type"]);
+        let type = options?.typeRegistry?.find(t => t.typeName == typeName);
+        if (!type)
+            throw new globalThis.Error("Unable to parse google.protobuf.Any from JSON. The specified type " + typeName + " is not available in the type registry.");
+        let value;
+        if (typeName.startsWith("google.protobuf.") && json.hasOwnProperty("value"))
+            value = type.fromJson(json["value"], options);
+        else {
+            let copy = Object.assign({}, json);
+            delete copy["@type"];
+            value = type.fromJson(copy, options);
+        }
+        if (target === undefined)
+            target = this.create();
+        target.typeUrl = json["@type"];
+        target.value = type.toBinary(value);
+        return target;
+    }
+    typeNameToUrl(name) {
+        if (!name.length)
+            throw new Error("invalid type name: " + name);
+        return "type.googleapis.com/" + name;
+    }
+    typeUrlToName(url) {
+        if (!url.length)
+            throw new Error("invalid type url: " + url);
+        let slash = url.lastIndexOf("/");
+        let name = slash > 0 ? url.substring(slash + 1) : url;
+        if (!name.length)
+            throw new Error("invalid type url: " + url);
+        return name;
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.typeUrl = "";
+        message.value = new Uint8Array(0);
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string type_url */ 1:
+                    message.typeUrl = reader.string();
+                    break;
+                case /* bytes value */ 2:
+                    message.value = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string type_url = 1; */
+        if (message.typeUrl !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.typeUrl);
+        /* bytes value = 2; */
+        if (message.value.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.value);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Any
+ */
+const Any = new Any$Type();
+
+const parsePeerDescriptor = (dataEntries) => {
+    return dataEntries.filter((entry) => !entry.deleted).map((entry) => Any.unpack(entry.data, PeerDescriptor$1));
+};
+const logger$h = new Logger('PeerDescriptorStoreManager');
+const MAX_NODE_COUNT = 8;
+/**
+ * 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.
+ */
+class PeerDescriptorStoreManager {
+    abortController;
+    options;
+    isLocalNodeStored_ = false;
+    constructor(options) {
+        this.options = options;
+        this.abortController = new AbortController();
+    }
+    async fetchNodes() {
+        logger$h.trace('Fetch data', { key: this.options.key });
+        try {
+            const result = await this.options.fetchDataFromDht(this.options.key);
+            return parsePeerDescriptor(result);
+        }
+        catch {
+            return [];
+        }
+    }
+    async storeAndKeepLocalNode() {
+        if (this.abortController.signal.aborted) {
+            return;
+        }
+        // eslint-disable-next-line no-underscore-dangle
+        this.isLocalNodeStored_ = true;
+        await this.storeLocalNode();
+        await this.keepLocalNode();
+    }
+    async storeLocalNode() {
+        const localPeerDescriptor = this.options.localPeerDescriptor;
+        const dataToStore = Any.pack(localPeerDescriptor, PeerDescriptor$1);
+        try {
+            await this.options.storeDataToDht(this.options.key, dataToStore);
+        }
+        catch {
+            logger$h.warn('Failed to store local node', { key: this.options.key });
+        }
+    }
+    async keepLocalNode() {
+        await scheduleAtInterval(async () => {
+            logger$h.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$h.debug('Failed to keep local node', { key: this.options.key });
+            }
+        }, this.options.storeInterval ?? 60000, false, this.abortController.signal);
+    }
+    isLocalNodeStored() {
+        // eslint-disable-next-line no-underscore-dangle
+        return this.isLocalNodeStored_;
+    }
+    async destroy() {
+        this.abortController.abort();
+        await this.options.deleteDataFromDht(this.options.key, false);
+    }
+}
+
+/*
+ * 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$g = new Logger('StreamPartNetworkSplitAvoidance');
+const exponentialRunOff = async (task, description, abortSignal, baseDelay = 500, maxAttempts = 6) => {
+    for (let i = 1; i <= maxAttempts; i++) {
+        if (abortSignal.aborted) {
+            return;
+        }
+        const factor = 2 ** i;
+        const delay = baseDelay * factor;
+        try {
+            await task();
+        }
+        catch {
+            logger$g.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$g.trace(`${err}`); // TODO Do we need logging?
+        }
+    }
+};
+const MIN_NEIGHBOR_COUNT = 4;
+class StreamPartNetworkSplitAvoidance {
+    abortController;
+    options;
+    excludedNodes = new Set();
+    running = false;
+    constructor(options) {
+        this.options = options;
+        this.abortController = new AbortController();
+    }
+    async avoidNetworkSplit() {
+        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$g.trace(`Network split avoided`);
+    }
+    isRunning() {
+        return this.running;
+    }
+    destroy() {
+        this.abortController.abort();
+    }
+}
+
+const DEFAULT_RECONNECT_INTERVAL = 30 * 1000;
+class StreamPartReconnect {
+    abortController;
+    discoveryLayerNode;
+    peerDescriptorStoreManager;
+    constructor(discoveryLayerNode, peerDescriptorStoreManager) {
+        this.discoveryLayerNode = discoveryLayerNode;
+        this.peerDescriptorStoreManager = peerDescriptorStoreManager;
+    }
+    async reconnect(timeout = DEFAULT_RECONNECT_INTERVAL) {
+        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() {
+        return this.abortController ? !this.abortController.signal.aborted : false;
+    }
+    destroy() {
+        this.abortController?.abort();
+    }
+}
+
+// @generated message type with reflection information, may provide speed optimized methods
+class Empty$Type extends MessageType {
+    constructor() {
+        super("google.protobuf.Empty", []);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Empty
+ */
+const Empty = new Empty$Type();
+
+// @generated by protobuf-ts 2.11.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated from protobuf file "packages/proto-rpc/protos/ProtoRpc.proto" (package "protorpc", syntax proto3)
+// tslint:disable
+/**
+ * @generated from protobuf enum protorpc.RpcErrorType
+ */
+var RpcErrorType;
+(function (RpcErrorType) {
+    /**
+     * @generated from protobuf enum value: SERVER_TIMEOUT = 0;
+     */
+    RpcErrorType[RpcErrorType["SERVER_TIMEOUT"] = 0] = "SERVER_TIMEOUT";
+    /**
+     * @generated from protobuf enum value: CLIENT_TIMEOUT = 1;
+     */
+    RpcErrorType[RpcErrorType["CLIENT_TIMEOUT"] = 1] = "CLIENT_TIMEOUT";
+    /**
+     * @generated from protobuf enum value: UNKNOWN_RPC_METHOD = 2;
+     */
+    RpcErrorType[RpcErrorType["UNKNOWN_RPC_METHOD"] = 2] = "UNKNOWN_RPC_METHOD";
+    /**
+     * @generated from protobuf enum value: CLIENT_ERROR = 3;
+     */
+    RpcErrorType[RpcErrorType["CLIENT_ERROR"] = 3] = "CLIENT_ERROR";
+    /**
+     * @generated from protobuf enum value: SERVER_ERROR = 4;
+     */
+    RpcErrorType[RpcErrorType["SERVER_ERROR"] = 4] = "SERVER_ERROR";
+})(RpcErrorType || (RpcErrorType = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class RpcMessage$Type extends MessageType {
+    constructor() {
+        super("protorpc.RpcMessage", [
+            { no: 1, name: "header", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } },
+            { no: 2, name: "body", kind: "message", T: () => Any },
+            { no: 3, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "errorType", kind: "enum", opt: true, T: () => ["protorpc.RpcErrorType", RpcErrorType] },
+            { no: 5, name: "errorClassName", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "errorCode", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "errorMessage", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message protorpc.RpcMessage
+ */
+const RpcMessage = new RpcMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Mnfo2uhnf92hvqi2nviouq2hv9puhq$Type extends MessageType {
+    constructor() {
+        super("protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq", [
+            { no: 1, name: "empty", kind: "message", T: () => Empty }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq
+ */
+new Mnfo2uhnf92hvqi2nviouq2hv9puhq$Type();
+
+// @generated message type with reflection information, may provide speed optimized methods
+class Timestamp$Type extends MessageType {
+    constructor() {
+        super("google.protobuf.Timestamp", [
+            { no: 1, name: "seconds", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "nanos", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+    /**
+     * Creates a new `Timestamp` for the current time.
+     */
+    now() {
+        const msg = this.create();
+        const ms = Date.now();
+        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toNumber();
+        msg.nanos = (ms % 1000) * 1000000;
+        return msg;
+    }
+    /**
+     * Converts a `Timestamp` to a JavaScript Date.
+     */
+    toDate(message) {
+        return new Date(PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1000000));
+    }
+    /**
+     * Converts a JavaScript Date to a `Timestamp`.
+     */
+    fromDate(date) {
+        const msg = this.create();
+        const ms = date.getTime();
+        msg.seconds = PbLong.from(Math.floor(ms / 1000)).toNumber();
+        msg.nanos = ((ms % 1000) + (ms < 0 && ms % 1000 !== 0 ? 1000 : 0)) * 1000000;
+        return msg;
+    }
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonWrite(message, options) {
+        let ms = PbLong.from(message.seconds).toNumber() * 1000;
+        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
+            throw new Error("Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
+        if (message.nanos < 0)
+            throw new Error("Unable to encode invalid Timestamp to JSON. Nanos must not be negative.");
+        let z = "Z";
+        if (message.nanos > 0) {
+            let nanosStr = (message.nanos + 1000000000).toString().substring(1);
+            if (nanosStr.substring(3) === "000000")
+                z = "." + nanosStr.substring(0, 3) + "Z";
+            else if (nanosStr.substring(6) === "000")
+                z = "." + nanosStr.substring(0, 6) + "Z";
+            else
+                z = "." + nanosStr + "Z";
+        }
+        return new Date(ms).toISOString().replace(".000Z", z);
+    }
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonRead(json, options, target) {
+        if (typeof json !== "string")
+            throw new Error("Unable to parse Timestamp from JSON " + typeofJsonValue(json) + ".");
+        let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+        if (!matches)
+            throw new Error("Unable to parse Timestamp from JSON. Invalid format.");
+        let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
+        if (Number.isNaN(ms))
+            throw new Error("Unable to parse Timestamp from JSON. Invalid value.");
+        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z"))
+            throw new globalThis.Error("Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.");
+        if (!target)
+            target = this.create();
+        target.seconds = PbLong.from(ms / 1000).toNumber();
+        target.nanos = 0;
+        if (matches[7])
+            target.nanos = (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000);
+        return target;
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.seconds = 0;
+        message.nanos = 0;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 seconds */ 1:
+                    message.seconds = reader.int64().toNumber();
+                    break;
+                case /* int32 nanos */ 2:
+                    message.nanos = reader.int32();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* int64 seconds = 1; */
+        if (message.seconds !== 0)
+            writer.tag(1, WireType.Varint).int64(message.seconds);
+        /* int32 nanos = 2; */
+        if (message.nanos !== 0)
+            writer.tag(2, WireType.Varint).int32(message.nanos);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Timestamp
+ */
+const Timestamp = new Timestamp$Type();
+
+// @generated by protobuf-ts 2.11.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated from protobuf file "packages/dht/protos/DhtRpc.proto" (package "dht", syntax proto3)
+// tslint:disable
+/**
+ * @generated from protobuf enum dht.RecursiveOperation
+ */
+var RecursiveOperation;
+(function (RecursiveOperation) {
+    /**
+     * @generated from protobuf enum value: FIND_CLOSEST_NODES = 0;
+     */
+    RecursiveOperation[RecursiveOperation["FIND_CLOSEST_NODES"] = 0] = "FIND_CLOSEST_NODES";
+    /**
+     * @generated from protobuf enum value: FETCH_DATA = 1;
+     */
+    RecursiveOperation[RecursiveOperation["FETCH_DATA"] = 1] = "FETCH_DATA";
+    /**
+     * @generated from protobuf enum value: DELETE_DATA = 2;
+     */
+    RecursiveOperation[RecursiveOperation["DELETE_DATA"] = 2] = "DELETE_DATA";
+})(RecursiveOperation || (RecursiveOperation = {}));
+/**
+ * @generated from protobuf enum dht.NodeType
+ */
+var NodeType;
+(function (NodeType) {
+    /**
+     * @generated from protobuf enum value: NODEJS = 0;
+     */
+    NodeType[NodeType["NODEJS"] = 0] = "NODEJS";
+    /**
+     * @generated from protobuf enum value: BROWSER = 1;
+     */
+    NodeType[NodeType["BROWSER"] = 1] = "BROWSER";
+})(NodeType || (NodeType = {}));
+/**
+ * @generated from protobuf enum dht.RpcResponseError
+ */
+var RpcResponseError;
+(function (RpcResponseError) {
+    /**
+     * @generated from protobuf enum value: SERVER_TIMOUT = 0;
+     */
+    RpcResponseError[RpcResponseError["SERVER_TIMOUT"] = 0] = "SERVER_TIMOUT";
+    /**
+     * @generated from protobuf enum value: CLIENT_TIMEOUT = 1;
+     */
+    RpcResponseError[RpcResponseError["CLIENT_TIMEOUT"] = 1] = "CLIENT_TIMEOUT";
+    /**
+     * @generated from protobuf enum value: SERVER_ERROR = 2;
+     */
+    RpcResponseError[RpcResponseError["SERVER_ERROR"] = 2] = "SERVER_ERROR";
+    /**
+     * @generated from protobuf enum value: UNKNOWN_RPC_METHOD = 3;
+     */
+    RpcResponseError[RpcResponseError["UNKNOWN_RPC_METHOD"] = 3] = "UNKNOWN_RPC_METHOD";
+})(RpcResponseError || (RpcResponseError = {}));
+/**
+ * @generated from protobuf enum dht.RouteMessageError
+ */
+var RouteMessageError;
+(function (RouteMessageError) {
+    /**
+     * @generated from protobuf enum value: NO_TARGETS = 0;
+     */
+    RouteMessageError[RouteMessageError["NO_TARGETS"] = 0] = "NO_TARGETS";
+    /**
+     * @generated from protobuf enum value: DUPLICATE = 1;
+     */
+    RouteMessageError[RouteMessageError["DUPLICATE"] = 1] = "DUPLICATE";
+    /**
+     * TODO: can this be removed? If DhtNode is already stopped the server side requests
+     * should not be processed
+     *
+     * @generated from protobuf enum value: STOPPED = 2;
+     */
+    RouteMessageError[RouteMessageError["STOPPED"] = 2] = "STOPPED";
+})(RouteMessageError || (RouteMessageError = {}));
+/**
+ * @generated from protobuf enum dht.HandshakeError
+ */
+var HandshakeError;
+(function (HandshakeError) {
+    /**
+     * @generated from protobuf enum value: DUPLICATE_CONNECTION = 0;
+     */
+    HandshakeError[HandshakeError["DUPLICATE_CONNECTION"] = 0] = "DUPLICATE_CONNECTION";
+    /**
+     * @generated from protobuf enum value: INVALID_TARGET_PEER_DESCRIPTOR = 1;
+     */
+    HandshakeError[HandshakeError["INVALID_TARGET_PEER_DESCRIPTOR"] = 1] = "INVALID_TARGET_PEER_DESCRIPTOR";
+    /**
+     * @generated from protobuf enum value: UNSUPPORTED_PROTOCOL_VERSION = 2;
+     */
+    HandshakeError[HandshakeError["UNSUPPORTED_PROTOCOL_VERSION"] = 2] = "UNSUPPORTED_PROTOCOL_VERSION";
+})(HandshakeError || (HandshakeError = {}));
+/**
+ * @generated from protobuf enum dht.DisconnectMode
+ */
+var DisconnectMode;
+(function (DisconnectMode) {
+    /**
+     * @generated from protobuf enum value: NORMAL = 0;
+     */
+    DisconnectMode[DisconnectMode["NORMAL"] = 0] = "NORMAL";
+    /**
+     * @generated from protobuf enum value: LEAVING = 1;
+     */
+    DisconnectMode[DisconnectMode["LEAVING"] = 1] = "LEAVING";
+})(DisconnectMode || (DisconnectMode = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class StoreDataRequest$Type extends MessageType {
+    constructor() {
+        super("dht.StoreDataRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "data", kind: "message", T: () => Any },
+            { no: 3, name: "creator", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 4, name: "createdAt", kind: "message", T: () => Timestamp },
+            { no: 5, name: "ttl", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.StoreDataRequest
+ */
+const StoreDataRequest = new StoreDataRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StoreDataResponse$Type extends MessageType {
+    constructor() {
+        super("dht.StoreDataResponse", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.StoreDataResponse
+ */
+const StoreDataResponse = new StoreDataResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExternalStoreDataRequest$Type extends MessageType {
+    constructor() {
+        super("dht.ExternalStoreDataRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "data", kind: "message", T: () => Any }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ExternalStoreDataRequest
+ */
+const ExternalStoreDataRequest = new ExternalStoreDataRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExternalStoreDataResponse$Type extends MessageType {
+    constructor() {
+        super("dht.ExternalStoreDataResponse", [
+            { no: 1, name: "storers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ExternalStoreDataResponse
+ */
+const ExternalStoreDataResponse = new ExternalStoreDataResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplicateDataRequest$Type extends MessageType {
+    constructor() {
+        super("dht.ReplicateDataRequest", [
+            { no: 1, name: "entry", kind: "message", T: () => DataEntry }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ReplicateDataRequest
+ */
+const ReplicateDataRequest = new ReplicateDataRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DataEntry$Type extends MessageType {
+    constructor() {
+        super("dht.DataEntry", [
+            { no: 1, name: "key", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "data", kind: "message", T: () => Any },
+            { no: 3, name: "creator", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 4, name: "createdAt", kind: "message", T: () => Timestamp },
+            { no: 5, name: "storedAt", kind: "message", T: () => Timestamp },
+            { no: 6, name: "ttl", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 7, name: "stale", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 8, name: "deleted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.DataEntry
+ */
+const DataEntry = new DataEntry$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ClosestPeersRequest$Type extends MessageType {
+    constructor() {
+        super("dht.ClosestPeersRequest", [
+            { no: 1, name: "nodeId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ClosestPeersRequest
+ */
+const ClosestPeersRequest = new ClosestPeersRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ClosestPeersResponse$Type extends MessageType {
+    constructor() {
+        super("dht.ClosestPeersResponse", [
+            { no: 1, name: "peers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor },
+            { no: 2, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ClosestPeersResponse
+ */
+const ClosestPeersResponse = new ClosestPeersResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ClosestRingPeersRequest$Type extends MessageType {
+    constructor() {
+        super("dht.ClosestRingPeersRequest", [
+            { no: 1, name: "ringId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ClosestRingPeersRequest
+ */
+const ClosestRingPeersRequest = new ClosestRingPeersRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ClosestRingPeersResponse$Type extends MessageType {
+    constructor() {
+        super("dht.ClosestRingPeersResponse", [
+            { no: 1, name: "leftPeers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor },
+            { no: 2, name: "rightPeers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor },
+            { no: 3, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ClosestRingPeersResponse
+ */
+const ClosestRingPeersResponse = new ClosestRingPeersResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RecursiveOperationRequest$Type extends MessageType {
+    constructor() {
+        super("dht.RecursiveOperationRequest", [
+            { no: 1, name: "sessionId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "operation", kind: "enum", T: () => ["dht.RecursiveOperation", RecursiveOperation] }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.RecursiveOperationRequest
+ */
+const RecursiveOperationRequest = new RecursiveOperationRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RecursiveOperationResponse$Type extends MessageType {
+    constructor() {
+        super("dht.RecursiveOperationResponse", [
+            { no: 1, name: "closestConnectedNodes", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor },
+            { no: 2, name: "dataEntries", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DataEntry },
+            { no: 3, name: "noCloserNodesFound", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 4, name: "routingPath", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.RecursiveOperationResponse
+ */
+const RecursiveOperationResponse = new RecursiveOperationResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PingRequest$Type extends MessageType {
+    constructor() {
+        super("dht.PingRequest", [
+            { no: 1, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.PingRequest
+ */
+const PingRequest = new PingRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PingResponse$Type extends MessageType {
+    constructor() {
+        super("dht.PingResponse", [
+            { no: 1, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.PingResponse
+ */
+const PingResponse = new PingResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LeaveNotice$Type extends MessageType {
+    constructor() {
+        super("dht.LeaveNotice", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.LeaveNotice
+ */
+const LeaveNotice = new LeaveNotice$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PeerDescriptor$Type extends MessageType {
+    constructor() {
+        super("dht.PeerDescriptor", [
+            { no: 1, name: "nodeId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "type", kind: "enum", T: () => ["dht.NodeType", NodeType] },
+            { no: 3, name: "udp", kind: "message", T: () => ConnectivityMethod },
+            { no: 4, name: "tcp", kind: "message", T: () => ConnectivityMethod },
+            { no: 5, name: "websocket", kind: "message", T: () => ConnectivityMethod },
+            { no: 6, name: "region", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
+            { no: 7, name: "ipAddress", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
+            { no: 8, name: "publicKey", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
+            { no: 9, name: "signature", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.PeerDescriptor
+ */
+const PeerDescriptor = new PeerDescriptor$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ConnectivityMethod$Type extends MessageType {
+    constructor() {
+        super("dht.ConnectivityMethod", [
+            { no: 1, name: "port", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: "host", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "tls", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ConnectivityMethod
+ */
+const ConnectivityMethod = new ConnectivityMethod$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RouteMessageWrapper$Type extends MessageType {
+    constructor() {
+        super("dht.RouteMessageWrapper", [
+            { no: 1, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "sourcePeer", kind: "message", T: () => PeerDescriptor },
+            { no: 3, name: "target", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 4, name: "message", kind: "message", T: () => Message },
+            { no: 5, name: "reachableThrough", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor },
+            { no: 6, name: "routingPath", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor },
+            { no: 7, name: "parallelRootNodeIds", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.RouteMessageWrapper
+ */
+const RouteMessageWrapper = new RouteMessageWrapper$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RouteMessageAck$Type extends MessageType {
+    constructor() {
+        super("dht.RouteMessageAck", [
+            { no: 1, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "error", kind: "enum", opt: true, T: () => ["dht.RouteMessageError", RouteMessageError] }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.RouteMessageAck
+ */
+const RouteMessageAck = new RouteMessageAck$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ConnectivityRequest$Type extends MessageType {
+    constructor() {
+        super("dht.ConnectivityRequest", [
+            { no: 1, name: "port", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: "tls", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "host", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "allowSelfSignedCertificate", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ConnectivityRequest
+ */
+const ConnectivityRequest = new ConnectivityRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ConnectivityResponse$Type extends MessageType {
+    constructor() {
+        super("dht.ConnectivityResponse", [
+            { no: 1, name: "host", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "natType", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "websocket", kind: "message", T: () => ConnectivityMethod },
+            { no: 4, name: "ipAddress", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 5, name: "protocolVersion", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "latitude", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ },
+            { no: 7, name: "longitude", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ConnectivityResponse
+ */
+const ConnectivityResponse = new ConnectivityResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HandshakeRequest$Type extends MessageType {
+    constructor() {
+        super("dht.HandshakeRequest", [
+            { no: 1, name: "sourcePeerDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 2, name: "targetPeerDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 3, name: "protocolVersion", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "applicationVersion", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.HandshakeRequest
+ */
+const HandshakeRequest = new HandshakeRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class HandshakeResponse$Type extends MessageType {
+    constructor() {
+        super("dht.HandshakeResponse", [
+            { no: 1, name: "sourcePeerDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 2, name: "error", kind: "enum", opt: true, T: () => ["dht.HandshakeError", HandshakeError] },
+            { no: 3, name: "protocolVersion", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "applicationVersion", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.HandshakeResponse
+ */
+const HandshakeResponse = new HandshakeResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Message$Type extends MessageType {
+    constructor() {
+        super("dht.Message", [
+            { no: 1, name: "messageId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "sourceDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 3, name: "targetDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 4, name: "serviceId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "rpcMessage", kind: "message", oneof: "body", T: () => RpcMessage },
+            { no: 6, name: "connectivityRequest", kind: "message", oneof: "body", T: () => ConnectivityRequest },
+            { no: 7, name: "connectivityResponse", kind: "message", oneof: "body", T: () => ConnectivityResponse },
+            { no: 8, name: "handshakeRequest", kind: "message", oneof: "body", T: () => HandshakeRequest },
+            { no: 9, name: "handshakeResponse", kind: "message", oneof: "body", T: () => HandshakeResponse },
+            { no: 10, name: "recursiveOperationRequest", kind: "message", oneof: "body", T: () => RecursiveOperationRequest }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.Message
+ */
+const Message = new Message$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WebsocketConnectionRequest$Type extends MessageType {
+    constructor() {
+        super("dht.WebsocketConnectionRequest", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.WebsocketConnectionRequest
+ */
+const WebsocketConnectionRequest = new WebsocketConnectionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class WebrtcConnectionRequest$Type extends MessageType {
+    constructor() {
+        super("dht.WebrtcConnectionRequest", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.WebrtcConnectionRequest
+ */
+const WebrtcConnectionRequest = new WebrtcConnectionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RtcOffer$Type extends MessageType {
+    constructor() {
+        super("dht.RtcOffer", [
+            { no: 1, name: "description", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "connectionId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.RtcOffer
+ */
+const RtcOffer = new RtcOffer$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RtcAnswer$Type extends MessageType {
+    constructor() {
+        super("dht.RtcAnswer", [
+            { no: 1, name: "description", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "connectionId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.RtcAnswer
+ */
+const RtcAnswer = new RtcAnswer$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class IceCandidate$Type extends MessageType {
+    constructor() {
+        super("dht.IceCandidate", [
+            { no: 1, name: "candidate", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "mid", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "connectionId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.IceCandidate
+ */
+const IceCandidate = new IceCandidate$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LockRequest$Type extends MessageType {
+    constructor() {
+        super("dht.LockRequest", [
+            { no: 1, name: "lockId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.LockRequest
+ */
+const LockRequest = new LockRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UnlockRequest$Type extends MessageType {
+    constructor() {
+        super("dht.UnlockRequest", [
+            { no: 1, name: "lockId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.UnlockRequest
+ */
+const UnlockRequest = new UnlockRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LockResponse$Type extends MessageType {
+    constructor() {
+        super("dht.LockResponse", [
+            { no: 1, name: "accepted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.LockResponse
+ */
+const LockResponse = new LockResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DisconnectNotice$Type extends MessageType {
+    constructor() {
+        super("dht.DisconnectNotice", [
+            { no: 1, name: "disconnectMode", kind: "enum", T: () => ["dht.DisconnectMode", DisconnectMode] }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.DisconnectNotice
+ */
+const DisconnectNotice = new DisconnectNotice$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SetPrivateRequest$Type extends MessageType {
+    constructor() {
+        super("dht.SetPrivateRequest", [
+            { no: 1, name: "isPrivate", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.SetPrivateRequest
+ */
+const SetPrivateRequest = new SetPrivateRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExternalFetchDataRequest$Type extends MessageType {
+    constructor() {
+        super("dht.ExternalFetchDataRequest", [
+            { no: 1, name: "key", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ExternalFetchDataRequest
+ */
+const ExternalFetchDataRequest = new ExternalFetchDataRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExternalFetchDataResponse$Type extends MessageType {
+    constructor() {
+        super("dht.ExternalFetchDataResponse", [
+            { no: 1, name: "entries", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DataEntry }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ExternalFetchDataResponse
+ */
+const ExternalFetchDataResponse = new ExternalFetchDataResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExternalFindClosestNodesRequest$Type extends MessageType {
+    constructor() {
+        super("dht.ExternalFindClosestNodesRequest", [
+            { no: 1, name: "nodeId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ExternalFindClosestNodesRequest
+ */
+const ExternalFindClosestNodesRequest = new ExternalFindClosestNodesRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExternalFindClosestNodesResponse$Type extends MessageType {
+    constructor() {
+        super("dht.ExternalFindClosestNodesResponse", [
+            { no: 1, name: "closestNodes", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ExternalFindClosestNodesResponse
+ */
+const ExternalFindClosestNodesResponse = new ExternalFindClosestNodesResponse$Type();
+/**
+ * @generated ServiceType for protobuf service dht.DhtNodeRpc
+ */
+new ServiceType("dht.DhtNodeRpc", [
+    { name: "getClosestPeers", options: {}, I: ClosestPeersRequest, O: ClosestPeersResponse },
+    { name: "getClosestRingPeers", options: {}, I: ClosestRingPeersRequest, O: ClosestRingPeersResponse },
+    { name: "ping", options: {}, I: PingRequest, O: PingResponse },
+    { name: "leaveNotice", options: {}, I: LeaveNotice, O: Empty }
+]);
+/**
+ * @generated ServiceType for protobuf service dht.RouterRpc
+ */
+new ServiceType("dht.RouterRpc", [
+    { name: "routeMessage", options: {}, I: RouteMessageWrapper, O: RouteMessageAck },
+    { name: "forwardMessage", options: {}, I: RouteMessageWrapper, O: RouteMessageAck }
+]);
+/**
+ * @generated ServiceType for protobuf service dht.RecursiveOperationRpc
+ */
+new ServiceType("dht.RecursiveOperationRpc", [
+    { name: "routeRequest", options: {}, I: RouteMessageWrapper, O: RouteMessageAck }
+]);
+/**
+ * @generated ServiceType for protobuf service dht.StoreRpc
+ */
+new ServiceType("dht.StoreRpc", [
+    { name: "storeData", options: {}, I: StoreDataRequest, O: StoreDataResponse },
+    { name: "replicateData", options: {}, I: ReplicateDataRequest, O: Empty }
+]);
+/**
+ * @generated ServiceType for protobuf service dht.RecursiveOperationSessionRpc
+ */
+new ServiceType("dht.RecursiveOperationSessionRpc", [
+    { name: "sendResponse", options: {}, I: RecursiveOperationResponse, O: Empty }
+]);
+/**
+ * @generated ServiceType for protobuf service dht.WebsocketClientConnectorRpc
+ */
+new ServiceType("dht.WebsocketClientConnectorRpc", [
+    { name: "requestConnection", options: {}, I: WebsocketConnectionRequest, O: Empty }
+]);
+/**
+ * @generated ServiceType for protobuf service dht.WebrtcConnectorRpc
+ */
+new ServiceType("dht.WebrtcConnectorRpc", [
+    { name: "requestConnection", options: {}, I: WebrtcConnectionRequest, O: Empty },
+    { name: "rtcOffer", options: {}, I: RtcOffer, O: Empty },
+    { name: "rtcAnswer", options: {}, I: RtcAnswer, O: Empty },
+    { name: "iceCandidate", options: {}, I: IceCandidate, O: Empty }
+]);
+/**
+ * @generated ServiceType for protobuf service dht.ConnectionLockRpc
+ */
+new ServiceType("dht.ConnectionLockRpc", [
+    { name: "lockRequest", options: {}, I: LockRequest, O: LockResponse },
+    { name: "unlockRequest", options: {}, I: UnlockRequest, O: Empty },
+    { name: "gracefulDisconnect", options: {}, I: DisconnectNotice, O: Empty },
+    { name: "setPrivate", options: {}, I: SetPrivateRequest, O: Empty }
+]);
+/**
+ * @generated ServiceType for protobuf service dht.ExternalApiRpc
+ */
+new ServiceType("dht.ExternalApiRpc", [
+    { name: "externalFetchData", options: {}, I: ExternalFetchDataRequest, O: ExternalFetchDataResponse },
+    { name: "externalStoreData", options: {}, I: ExternalStoreDataRequest, O: ExternalStoreDataResponse },
+    { name: "externalFindClosestNodes", options: {}, I: ExternalFindClosestNodesRequest, O: ExternalFindClosestNodesResponse }
+]);
+
+// @generated by protobuf-ts 2.11.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated from protobuf file "packages/trackerless-network/protos/NetworkRpc.proto" (syntax proto3)
+// tslint:disable
+/**
+ * @generated from protobuf enum ContentType
+ */
+var ContentType;
+(function (ContentType) {
+    /**
+     * @generated from protobuf enum value: JSON = 0;
+     */
+    ContentType[ContentType["JSON"] = 0] = "JSON";
+    /**
+     * @generated from protobuf enum value: BINARY = 1;
+     */
+    ContentType[ContentType["BINARY"] = 1] = "BINARY";
+})(ContentType || (ContentType = {}));
+/**
+ * @generated from protobuf enum EncryptionType
+ */
+var EncryptionType;
+(function (EncryptionType) {
+    /**
+     * @generated from protobuf enum value: NONE = 0;
+     */
+    EncryptionType[EncryptionType["NONE"] = 0] = "NONE";
+    /**
+     * @generated from protobuf enum value: AES = 1;
+     */
+    EncryptionType[EncryptionType["AES"] = 1] = "AES";
+})(EncryptionType || (EncryptionType = {}));
+/**
+ * @generated from protobuf enum AsymmetricEncryptionType
+ */
+var AsymmetricEncryptionType;
+(function (AsymmetricEncryptionType) {
+    /**
+     * default
+     *
+     * @generated from protobuf enum value: RSA = 0;
+     */
+    AsymmetricEncryptionType[AsymmetricEncryptionType["RSA"] = 0] = "RSA";
+    /**
+     * @generated from protobuf enum value: ML_KEM = 1;
+     */
+    AsymmetricEncryptionType[AsymmetricEncryptionType["ML_KEM"] = 1] = "ML_KEM";
+})(AsymmetricEncryptionType || (AsymmetricEncryptionType = {}));
+/**
+ * @generated from protobuf enum SignatureType
+ */
+var SignatureType;
+(function (SignatureType) {
+    /**
+     * @generated from protobuf enum value: ECDSA_SECP256K1_LEGACY = 0;
+     */
+    SignatureType[SignatureType["ECDSA_SECP256K1_LEGACY"] = 0] = "ECDSA_SECP256K1_LEGACY";
+    /**
+     * @generated from protobuf enum value: ECDSA_SECP256K1_EVM = 1;
+     */
+    SignatureType[SignatureType["ECDSA_SECP256K1_EVM"] = 1] = "ECDSA_SECP256K1_EVM";
+    /**
+     * @generated from protobuf enum value: ERC_1271 = 2;
+     */
+    SignatureType[SignatureType["ERC_1271"] = 2] = "ERC_1271";
+    /**
+     * @generated from protobuf enum value: ML_DSA_87 = 3;
+     */
+    SignatureType[SignatureType["ML_DSA_87"] = 3] = "ML_DSA_87";
+    /**
+     * @generated from protobuf enum value: ECDSA_SECP256R1 = 4;
+     */
+    SignatureType[SignatureType["ECDSA_SECP256R1"] = 4] = "ECDSA_SECP256R1";
+})(SignatureType || (SignatureType = {}));
+/**
+ * @generated from protobuf enum ProxyDirection
+ */
+var ProxyDirection;
+(function (ProxyDirection) {
+    /**
+     * @generated from protobuf enum value: PUBLISH = 0;
+     */
+    ProxyDirection[ProxyDirection["PUBLISH"] = 0] = "PUBLISH";
+    /**
+     * @generated from protobuf enum value: SUBSCRIBE = 1;
+     */
+    ProxyDirection[ProxyDirection["SUBSCRIBE"] = 1] = "SUBSCRIBE";
+})(ProxyDirection || (ProxyDirection = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class MessageID$Type extends MessageType {
+    constructor() {
+        super("MessageID", [
+            { no: 1, name: "streamId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "streamPartition", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "timestamp", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 4, name: "sequenceNumber", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 5, name: "publisherId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 6, name: "messageChainId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message MessageID
+ */
+const MessageID = new MessageID$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MessageRef$Type extends MessageType {
+    constructor() {
+        super("MessageRef", [
+            { no: 1, name: "timestamp", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ },
+            { no: 2, name: "sequenceNumber", kind: "scalar", T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message MessageRef
+ */
+const MessageRef = new MessageRef$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamMessage$Type extends MessageType {
+    constructor() {
+        super("StreamMessage", [
+            { no: 1, name: "messageId", kind: "message", T: () => MessageID },
+            { no: 2, name: "previousMessageRef", kind: "message", T: () => MessageRef },
+            { no: 3, name: "signature", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 4, name: "signatureType", kind: "enum", T: () => ["SignatureType", SignatureType] },
+            { no: 5, name: "contentMessage", kind: "message", oneof: "body", T: () => ContentMessage },
+            { no: 6, name: "groupKeyRequest", kind: "message", oneof: "body", T: () => GroupKeyRequest },
+            { no: 7, name: "groupKeyResponse", kind: "message", oneof: "body", T: () => GroupKeyResponse }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message StreamMessage
+ */
+const StreamMessage = new StreamMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ContentMessage$Type extends MessageType {
+    constructor() {
+        super("ContentMessage", [
+            { no: 1, name: "content", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "contentType", kind: "enum", T: () => ["ContentType", ContentType] },
+            { no: 3, name: "encryptionType", kind: "enum", T: () => ["EncryptionType", EncryptionType] },
+            { no: 4, name: "groupKeyId", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "newGroupKey", kind: "message", T: () => EncryptedGroupKey }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message ContentMessage
+ */
+const ContentMessage = new ContentMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GroupKeyRequest$Type extends MessageType {
+    constructor() {
+        super("GroupKeyRequest", [
+            { no: 1, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "recipientId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "publicKey", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 4, name: "groupKeyIds", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "encryptionType", kind: "enum", T: () => ["AsymmetricEncryptionType", AsymmetricEncryptionType] }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message GroupKeyRequest
+ */
+const GroupKeyRequest = new GroupKeyRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GroupKeyResponse$Type extends MessageType {
+    constructor() {
+        super("GroupKeyResponse", [
+            { no: 1, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "recipientId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "groupKeys", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => EncryptedGroupKey },
+            { no: 4, name: "encryptionType", kind: "enum", T: () => ["AsymmetricEncryptionType", AsymmetricEncryptionType] }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message GroupKeyResponse
+ */
+const GroupKeyResponse = new GroupKeyResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EncryptedGroupKey$Type extends MessageType {
+    constructor() {
+        super("EncryptedGroupKey", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "data", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message EncryptedGroupKey
+ */
+const EncryptedGroupKey = new EncryptedGroupKey$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamPartHandshakeRequest$Type extends MessageType {
+    constructor() {
+        super("StreamPartHandshakeRequest", [
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "concurrentHandshakeNodeId", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
+            { no: 4, name: "neighborNodeIds", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ },
+            { no: 5, name: "interleaveNodeId", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message StreamPartHandshakeRequest
+ */
+const StreamPartHandshakeRequest = new StreamPartHandshakeRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamPartHandshakeResponse$Type extends MessageType {
+    constructor() {
+        super("StreamPartHandshakeResponse", [
+            { no: 1, name: "accepted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "interleaveTargetDescriptor", kind: "message", T: () => PeerDescriptor }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message StreamPartHandshakeResponse
+ */
+const StreamPartHandshakeResponse = new StreamPartHandshakeResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InterleaveRequest$Type extends MessageType {
+    constructor() {
+        super("InterleaveRequest", [
+            { no: 1, name: "interleaveTargetDescriptor", kind: "message", T: () => PeerDescriptor }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message InterleaveRequest
+ */
+const InterleaveRequest = new InterleaveRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class InterleaveResponse$Type extends MessageType {
+    constructor() {
+        super("InterleaveResponse", [
+            { no: 1, name: "accepted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message InterleaveResponse
+ */
+const InterleaveResponse = new InterleaveResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LeaveStreamPartNotice$Type extends MessageType {
+    constructor() {
+        super("LeaveStreamPartNotice", [
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "isEntryPoint", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message LeaveStreamPartNotice
+ */
+const LeaveStreamPartNotice = new LeaveStreamPartNotice$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class NeighborUpdate$Type extends MessageType {
+    constructor() {
+        super("NeighborUpdate", [
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "removeMe", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "neighborDescriptors", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message NeighborUpdate
+ */
+const NeighborUpdate = new NeighborUpdate$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ProxyConnectionRequest$Type extends MessageType {
+    constructor() {
+        super("ProxyConnectionRequest", [
+            { no: 1, name: "direction", kind: "enum", opt: true, T: () => ["ProxyDirection", ProxyDirection] },
+            { no: 2, name: "userId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message ProxyConnectionRequest
+ */
+const ProxyConnectionRequest = new ProxyConnectionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ProxyConnectionResponse$Type extends MessageType {
+    constructor() {
+        super("ProxyConnectionResponse", [
+            { no: 1, name: "accepted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message ProxyConnectionResponse
+ */
+const ProxyConnectionResponse = new ProxyConnectionResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TemporaryConnectionRequest$Type extends MessageType {
+    constructor() {
+        super("TemporaryConnectionRequest", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message TemporaryConnectionRequest
+ */
+const TemporaryConnectionRequest = new TemporaryConnectionRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TemporaryConnectionResponse$Type extends MessageType {
+    constructor() {
+        super("TemporaryConnectionResponse", [
+            { no: 1, name: "accepted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message TemporaryConnectionResponse
+ */
+const TemporaryConnectionResponse = new TemporaryConnectionResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CloseTemporaryConnection$Type extends MessageType {
+    constructor() {
+        super("CloseTemporaryConnection", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message CloseTemporaryConnection
+ */
+const CloseTemporaryConnection = new CloseTemporaryConnection$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StreamPartitionInfo$Type extends MessageType {
+    constructor() {
+        super("StreamPartitionInfo", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "controlLayerNeighbors", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor },
+            { no: 3, name: "deprecatedContentDeliveryLayerNeighbors", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor },
+            { no: 4, name: "contentDeliveryLayerNeighbors", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ContentDeliveryLayerNeighborInfo }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message StreamPartitionInfo
+ */
+const StreamPartitionInfo = new StreamPartitionInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ContentDeliveryLayerNeighborInfo$Type extends MessageType {
+    constructor() {
+        super("ContentDeliveryLayerNeighborInfo", [
+            { no: 1, name: "peerDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 2, name: "rtt", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message ContentDeliveryLayerNeighborInfo
+ */
+const ContentDeliveryLayerNeighborInfo = new ContentDeliveryLayerNeighborInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ControlLayerInfo$Type extends MessageType {
+    constructor() {
+        super("ControlLayerInfo", [
+            { no: 1, name: "neighbors", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor },
+            { no: 2, name: "connections", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => PeerDescriptor }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message ControlLayerInfo
+ */
+const ControlLayerInfo = new ControlLayerInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class NodeInfoRequest$Type extends MessageType {
+    constructor() {
+        super("NodeInfoRequest", []);
+    }
+}
+/**
+ * @generated MessageType for protobuf message NodeInfoRequest
+ */
+const NodeInfoRequest = new NodeInfoRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class NodeInfoResponse$Type extends MessageType {
+    constructor() {
+        super("NodeInfoResponse", [
+            { no: 1, name: "peerDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 2, name: "streamPartitions", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => StreamPartitionInfo },
+            { no: 3, name: "controlLayer", kind: "message", T: () => ControlLayerInfo },
+            { no: 4, name: "applicationVersion", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message NodeInfoResponse
+ */
+const NodeInfoResponse = new NodeInfoResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PauseNeighborRequest$Type extends MessageType {
+    constructor() {
+        super("PauseNeighborRequest", [
+            { no: 1, name: "messageChainId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message PauseNeighborRequest
+ */
+const PauseNeighborRequest = new PauseNeighborRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResumeNeighborRequest$Type extends MessageType {
+    constructor() {
+        super("ResumeNeighborRequest", [
+            { no: 1, name: "messageChainId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "fromTimestamp", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 2 /*LongType.NUMBER*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message ResumeNeighborRequest
+ */
+const ResumeNeighborRequest = new ResumeNeighborRequest$Type();
+/**
+ * @generated ServiceType for protobuf service ContentDeliveryRpc
+ */
+const ContentDeliveryRpc = new ServiceType("ContentDeliveryRpc", [
+    { name: "sendStreamMessage", options: {}, I: StreamMessage, O: Empty },
+    { name: "leaveStreamPartNotice", options: {}, I: LeaveStreamPartNotice, O: Empty }
+]);
+/**
+ * @generated ServiceType for protobuf service ProxyConnectionRpc
+ */
+const ProxyConnectionRpc = new ServiceType("ProxyConnectionRpc", [
+    { name: "requestConnection", options: {}, I: ProxyConnectionRequest, O: ProxyConnectionResponse }
+]);
+/**
+ * @generated ServiceType for protobuf service HandshakeRpc
+ */
+const HandshakeRpc = new ServiceType("HandshakeRpc", [
+    { name: "handshake", options: {}, I: StreamPartHandshakeRequest, O: StreamPartHandshakeResponse },
+    { name: "interleaveRequest", options: {}, I: InterleaveRequest, O: InterleaveResponse }
+]);
+/**
+ * @generated ServiceType for protobuf service NeighborUpdateRpc
+ */
+const NeighborUpdateRpc = new ServiceType("NeighborUpdateRpc", [
+    { name: "neighborUpdate", options: {}, I: NeighborUpdate, O: NeighborUpdate }
+]);
+/**
+ * @generated ServiceType for protobuf service TemporaryConnectionRpc
+ */
+const TemporaryConnectionRpc = new ServiceType("TemporaryConnectionRpc", [
+    { name: "openConnection", options: {}, I: TemporaryConnectionRequest, O: TemporaryConnectionResponse },
+    { name: "closeConnection", options: {}, I: CloseTemporaryConnection, O: Empty }
+]);
+/**
+ * @generated ServiceType for protobuf service NodeInfoRpc
+ */
+const NodeInfoRpc = new ServiceType("NodeInfoRpc", [
+    { name: "getInfo", options: {}, I: NodeInfoRequest, O: NodeInfoResponse }
+]);
+/**
+ * @generated ServiceType for protobuf service PlumtreeRpc
+ */
+const PlumtreeRpc = new ServiceType("PlumtreeRpc", [
+    { name: "pauseNeighbor", options: {}, I: PauseNeighborRequest, O: Empty },
+    { name: "resumeNeighbor", options: {}, I: ResumeNeighborRequest, O: Empty },
+    { name: "sendMetadata", options: {}, I: MessageID, O: Empty }
+]);
+
+// @generated by protobuf-ts 2.11.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated from protobuf file "packages/trackerless-network/protos/NetworkRpc.proto" (syntax proto3)
+// tslint:disable
+/**
+ * @generated from protobuf service ContentDeliveryRpc
+ */
+class ContentDeliveryRpcClient {
+    _transport;
+    typeName = ContentDeliveryRpc.typeName;
+    methods = ContentDeliveryRpc.methods;
+    options = ContentDeliveryRpc.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * @generated from protobuf rpc: sendStreamMessage
+     */
+    sendStreamMessage(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: leaveStreamPartNotice
+     */
+    leaveStreamPartNotice(input, options) {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service ProxyConnectionRpc
+ */
+class ProxyConnectionRpcClient {
+    _transport;
+    typeName = ProxyConnectionRpc.typeName;
+    methods = ProxyConnectionRpc.methods;
+    options = ProxyConnectionRpc.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * @generated from protobuf rpc: requestConnection
+     */
+    requestConnection(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service HandshakeRpc
+ */
+class HandshakeRpcClient {
+    _transport;
+    typeName = HandshakeRpc.typeName;
+    methods = HandshakeRpc.methods;
+    options = HandshakeRpc.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * @generated from protobuf rpc: handshake
+     */
+    handshake(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: interleaveRequest
+     */
+    interleaveRequest(input, options) {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service NeighborUpdateRpc
+ */
+class NeighborUpdateRpcClient {
+    _transport;
+    typeName = NeighborUpdateRpc.typeName;
+    methods = NeighborUpdateRpc.methods;
+    options = NeighborUpdateRpc.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * @generated from protobuf rpc: neighborUpdate
+     */
+    neighborUpdate(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service TemporaryConnectionRpc
+ */
+class TemporaryConnectionRpcClient {
+    _transport;
+    typeName = TemporaryConnectionRpc.typeName;
+    methods = TemporaryConnectionRpc.methods;
+    options = TemporaryConnectionRpc.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * @generated from protobuf rpc: openConnection
+     */
+    openConnection(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: closeConnection
+     */
+    closeConnection(input, options) {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service NodeInfoRpc
+ */
+class NodeInfoRpcClient {
+    _transport;
+    typeName = NodeInfoRpc.typeName;
+    methods = NodeInfoRpc.methods;
+    options = NodeInfoRpc.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * @generated from protobuf rpc: getInfo
+     */
+    getInfo(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service PlumtreeRpc
+ */
+class PlumtreeRpcClient {
+    _transport;
+    typeName = PlumtreeRpc.typeName;
+    methods = PlumtreeRpc.methods;
+    options = PlumtreeRpc.options;
+    constructor(_transport) {
+        this._transport = _transport;
+    }
+    /**
+     * @generated from protobuf rpc: pauseNeighbor
+     */
+    pauseNeighbor(input, options) {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: resumeNeighbor
+     */
+    resumeNeighbor(input, options) {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: sendMetadata
+     */
+    sendMetadata(input, options) {
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        return stackIntercept("unary", this._transport, method, opt, input);
+    }
+}
+
+const logger$f = new Logger('ContentDeliveryRpcRemote');
+class ContentDeliveryRpcRemote extends RpcRemote {
+    rtt;
+    async sendStreamMessage(msg, bufferWhileConnecting) {
+        const options = this.formDhtRpcOptions({
+            notification: true,
+            bufferWhileConnecting
+        });
+        this.getClient().sendStreamMessage(msg, options).catch(() => {
+            logger$f.trace('Failed to sendStreamMessage');
+        });
+    }
+    leaveStreamPartNotice(streamPartId, isLocalNodeEntryPoint) {
+        const notification = {
+            streamPartId,
+            isEntryPoint: isLocalNodeEntryPoint
+        };
+        const options = this.formDhtRpcOptions({
+            notification: true
+        });
+        this.getClient().leaveStreamPartNotice(notification, options).catch(() => {
+            logger$f.debug('Failed to send leaveStreamPartNotice');
+        });
+    }
+    setRtt(rtt) {
+        this.rtt = rtt;
+    }
+    getRtt() {
+        return this.rtt;
+    }
+}
+
+const logger$e = new Logger('HandshakeRpcLocal');
+class HandshakeRpcLocal {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async handshake(request, context) {
+        return this.handleRequest(request, context);
+    }
+    handleRequest(request, context) {
+        const senderDescriptor = context.incomingSourceDescriptor;
+        const getInterleaveNodeIds = () => (request.interleaveNodeId !== undefined) ? [toDhtAddress(request.interleaveNodeId)] : [];
+        const senderNodeId = toNodeId(senderDescriptor);
+        if (this.options.ongoingInterleaves.has(senderNodeId)) {
+            return this.rejectHandshake(request);
+        }
+        else if (this.options.neighbors.has(senderNodeId)
+            || this.options.ongoingHandshakes.has(senderNodeId)) {
+            return this.acceptHandshake(request, senderDescriptor);
+        }
+        else if (this.options.neighbors.size() + this.options.ongoingHandshakes.size < this.options.maxNeighborCount) {
+            return this.acceptHandshake(request, senderDescriptor);
+        }
+        else if (this.options.neighbors.size(getInterleaveNodeIds()) - this.options.ongoingInterleaves.size >= 2
+            && this.options.neighbors.size() <= this.options.maxNeighborCount) {
+            // Do not accept the handshakes requests if the target neighbor count can potentially drop below 2 
+            // due to interleaving. This ensures that a stable number of connections is kept during high churn.
+            return this.acceptHandshakeWithInterleaving(request, senderDescriptor);
+        }
+        else {
+            return this.rejectHandshake(request);
+        }
+    }
+    acceptHandshake(request, requester) {
+        const res = {
+            requestId: request.requestId,
+            accepted: true
+        };
+        this.options.neighbors.add(this.options.createContentDeliveryRpcRemote(requester));
+        return res;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    rejectHandshake(request) {
+        const res = {
+            requestId: request.requestId,
+            accepted: false
+        };
+        return res;
+    }
+    acceptHandshakeWithInterleaving(request, requester) {
+        const exclude = [];
+        request.neighborNodeIds.forEach((id) => exclude.push(toDhtAddress(id)));
+        this.options.ongoingInterleaves.forEach((id) => exclude.push(id));
+        exclude.push(toNodeId(requester));
+        if (request.interleaveNodeId !== undefined) {
+            exclude.push(toDhtAddress(request.interleaveNodeId));
+        }
+        const last = this.options.neighbors.getLast(exclude);
+        const lastPeerDescriptor = last ? last.getPeerDescriptor() : undefined;
+        if (last) {
+            const nodeId = toNodeId(last.getPeerDescriptor());
+            const remote = this.options.createRpcRemote(last.getPeerDescriptor());
+            this.options.ongoingInterleaves.add(nodeId);
+            // Run this with then catch instead of setImmediate to avoid changes in state
+            // eslint-disable-next-line promise/catch-or-return
+            remote.interleaveRequest(requester).then((response) => {
+                // If response is accepted, remove the last node from the target neighbors
+                // and unlock the connection
+                // If response is not accepted, keep the last node as a neighbor
+                if (response.accepted) {
+                    this.options.neighbors.remove(toNodeId(lastPeerDescriptor));
+                }
+            }).catch(() => {
+                // no-op: InterleaveRequest cannot reject
+            }).finally(() => {
+                this.options.ongoingInterleaves.delete(nodeId);
+            });
+        }
+        this.options.neighbors.add(this.options.createContentDeliveryRpcRemote(requester));
+        return {
+            requestId: request.requestId,
+            accepted: true,
+            interleaveTargetDescriptor: lastPeerDescriptor
+        };
+    }
+    async interleaveRequest(message, context) {
+        const senderPeerDescriptor = context.incomingSourceDescriptor;
+        const remoteNodeId = toNodeId(senderPeerDescriptor);
+        try {
+            await this.options.handshakeWithInterleaving(message.interleaveTargetDescriptor, remoteNodeId);
+            this.options.neighbors.remove(remoteNodeId);
+            return { accepted: true };
+        }
+        catch (err) {
+            logger$e.debug(`interleaveRequest to ${toNodeId(message.interleaveTargetDescriptor)} failed`, { err });
+            return { accepted: false };
+        }
+    }
+}
+
+const logger$d = new Logger('HandshakeRpcRemote');
+const INTERLEAVE_REQUEST_TIMEOUT = 10000;
+class HandshakeRpcRemote extends RpcRemote {
+    async handshake(streamPartId, neighborNodeIds, concurrentHandshakeNodeId, interleaveNodeId) {
+        const request = {
+            streamPartId,
+            requestId: v4(),
+            neighborNodeIds: neighborNodeIds.map((id) => toDhtAddressRaw(id)),
+            concurrentHandshakeNodeId: (concurrentHandshakeNodeId !== undefined) ? toDhtAddressRaw(concurrentHandshakeNodeId) : undefined,
+            interleaveNodeId: (interleaveNodeId !== undefined) ? toDhtAddressRaw(interleaveNodeId) : undefined
+        };
+        try {
+            const response = await this.getClient().handshake(request, this.formDhtRpcOptions());
+            return {
+                accepted: response.accepted,
+                interleaveTargetDescriptor: response.interleaveTargetDescriptor
+            };
+        }
+        catch (err) {
+            logger$d.debug(`handshake to ${toNodeId(this.getPeerDescriptor())} failed`, { err });
+            return {
+                accepted: false
+            };
+        }
+    }
+    async interleaveRequest(originatorDescriptor) {
+        const request = {
+            interleaveTargetDescriptor: originatorDescriptor
+        };
+        const options = this.formDhtRpcOptions({
+            connect: false,
+            timeout: INTERLEAVE_REQUEST_TIMEOUT
+        });
+        try {
+            const res = await this.getClient().interleaveRequest(request, options);
+            return {
+                accepted: res.accepted
+            };
+        }
+        catch (err) {
+            logger$d.debug(`interleaveRequest to ${toNodeId(this.getPeerDescriptor())} failed`, { err });
+            return {
+                accepted: false
+            };
+        }
+    }
+}
+
+const logger$c = new Logger('Handshaker');
+const PARALLEL_HANDSHAKE_COUNT = 2;
+class Handshaker {
+    options;
+    rpcLocal;
+    constructor(options) {
+        this.options = options;
+        this.rpcLocal = new HandshakeRpcLocal({
+            streamPartId: this.options.streamPartId,
+            neighbors: this.options.neighbors,
+            ongoingHandshakes: this.options.ongoingHandshakes,
+            ongoingInterleaves: new Set(),
+            maxNeighborCount: this.options.maxNeighborCount,
+            handshakeWithInterleaving: (target, remoteNodeId) => this.handshakeWithInterleaving(target, remoteNodeId),
+            createRpcRemote: (target) => this.createRpcRemote(target),
+            createContentDeliveryRpcRemote: (target) => this.createContentDeliveryRpcRemote(target)
+        });
+        this.options.rpcCommunicator.registerRpcMethod(InterleaveRequest, InterleaveResponse, 'interleaveRequest', (req, context) => this.rpcLocal.interleaveRequest(req, context), { timeout: INTERLEAVE_REQUEST_TIMEOUT });
+        this.options.rpcCommunicator.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', (req, context) => this.rpcLocal.handshake(req, context));
+    }
+    async attemptHandshakesOnContacts(excludedIds) {
+        // TODO use options option or named constant? or why the value 2?
+        if (this.options.neighbors.size() + this.options.ongoingHandshakes.size < this.options.maxNeighborCount - 2) {
+            logger$c.trace(`Attempting parallel handshakes with ${PARALLEL_HANDSHAKE_COUNT} targets`);
+            return this.selectParallelTargetsAndHandshake(excludedIds);
+        }
+        else if (this.options.neighbors.size() + this.options.ongoingHandshakes.size < this.options.maxNeighborCount) {
+            logger$c.trace(`Attempting handshake with new target`);
+            return this.selectNewTargetAndHandshake(excludedIds);
+        }
+        return excludedIds;
+    }
+    async selectParallelTargetsAndHandshake(excludedIds) {
+        const exclude = excludedIds.concat(this.options.neighbors.getIds());
+        const targets = this.selectParallelTargets(exclude);
+        targets.forEach((contact) => this.options.ongoingHandshakes.add(toNodeId(contact.getPeerDescriptor())));
+        return this.doParallelHandshakes(targets, exclude);
+    }
+    selectParallelTargets(excludedIds) {
+        const targets = new Map();
+        const getExcludedIds = () => [...excludedIds, ...Array.from(targets.keys())];
+        // Step 1: If no neighbors, try to find a WebSocket node first
+        if (this.options.neighbors.size() === 0) {
+            const wsNode = this.options.nearbyNodeView.getFirst(getExcludedIds(), true);
+            if (wsNode) {
+                const wsNodeId = toNodeId(wsNode.getPeerDescriptor());
+                targets.set(wsNodeId, wsNode);
+            }
+        }
+        // Step 2: Add left and right contacts from the ring
+        const left = this.options.leftNodeView.getFirst(getExcludedIds());
+        const right = this.options.rightNodeView.getFirst(getExcludedIds());
+        if (left) {
+            targets.set(toNodeId(left.getPeerDescriptor()), left);
+        }
+        if (right) {
+            targets.set(toNodeId(right.getPeerDescriptor()), right);
+        }
+        // Step 3: Add closest contact based on Kademlia metric if needed
+        if (targets.size < PARALLEL_HANDSHAKE_COUNT) {
+            const closest = this.options.nearbyNodeView.getFirst(getExcludedIds());
+            if (closest) {
+                targets.set(toNodeId(closest.getPeerDescriptor()), closest);
+            }
+        }
+        // Step 4: Fill remaining slots with random contacts
+        while (targets.size < PARALLEL_HANDSHAKE_COUNT) {
+            const random = this.options.randomNodeView.getRandom(getExcludedIds());
+            if (!random) {
+                break;
+            }
+            targets.set(toNodeId(random.getPeerDescriptor()), random);
+        }
+        return Array.from(targets.values()).map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()));
+    }
+    async doParallelHandshakes(targets, excludedIds) {
+        const results = await Promise.allSettled(Array.from(targets.values()).map(async (target, i) => {
+            const otherNode = i === 0 ? targets[1] : targets[0];
+            // TODO better check (currently this condition is always true)
+            const otherNodeId = otherNode ? toNodeId(otherNode.getPeerDescriptor()) : undefined;
+            return this.handshakeWithTarget(target, otherNodeId);
+        }));
+        results.forEach((res, i) => {
+            if (res.status !== 'fulfilled' || !res.value) {
+                excludedIds.push(toNodeId(targets[i].getPeerDescriptor()));
+            }
+        });
+        return excludedIds;
+    }
+    async selectNewTargetAndHandshake(excludedIds) {
+        const exclude = excludedIds.concat(this.options.neighbors.getIds());
+        const target = this.options.leftNodeView.getFirst(exclude)
+            ?? this.options.rightNodeView.getFirst(exclude)
+            ?? this.options.nearbyNodeView.getFirst(exclude)
+            ?? this.options.randomNodeView.getRandom(exclude);
+        if (target) {
+            const accepted = await this.handshakeWithTarget(this.createRpcRemote(target.getPeerDescriptor()));
+            if (!accepted) {
+                excludedIds.push(toNodeId(target.getPeerDescriptor()));
+            }
+        }
+        return excludedIds;
+    }
+    async handshakeWithTarget(target, concurrentNodeId) {
+        const targetNodeId = toNodeId(target.getPeerDescriptor());
+        this.options.ongoingHandshakes.add(targetNodeId);
+        const result = await target.handshake(this.options.streamPartId, this.options.neighbors.getIds(), concurrentNodeId);
+        if (result.accepted) {
+            this.options.neighbors.add(this.createContentDeliveryRpcRemote(target.getPeerDescriptor()));
+        }
+        if (result.interleaveTargetDescriptor) {
+            await this.handshakeWithInterleaving(result.interleaveTargetDescriptor, targetNodeId);
+        }
+        this.options.ongoingHandshakes.delete(targetNodeId);
+        return result.accepted;
+    }
+    async handshakeWithInterleaving(target, remoteNodeId) {
+        const remote = this.createRpcRemote(target);
+        const targetNodeId = toNodeId(remote.getPeerDescriptor());
+        this.options.ongoingHandshakes.add(targetNodeId);
+        const result = await remote.handshake(this.options.streamPartId, this.options.neighbors.getIds(), undefined, remoteNodeId);
+        if (result.accepted) {
+            this.options.neighbors.add(this.createContentDeliveryRpcRemote(remote.getPeerDescriptor()));
+        }
+        this.options.ongoingHandshakes.delete(targetNodeId);
+        return result.accepted;
+    }
+    createRpcRemote(targetPeerDescriptor) {
+        return new HandshakeRpcRemote(this.options.localPeerDescriptor, targetPeerDescriptor, this.options.rpcCommunicator, HandshakeRpcClient, this.options.rpcRequestTimeout);
+    }
+    createContentDeliveryRpcRemote(targetPeerDescriptor) {
+        return new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, targetPeerDescriptor, this.options.rpcCommunicator, ContentDeliveryRpcClient, this.options.rpcRequestTimeout);
+    }
+    getOngoingHandshakes() {
+        return this.options.ongoingHandshakes;
+    }
+}
+
+const INITIAL_WAIT = 100;
+const INTERVAL = 250;
+const logger$b = new Logger('NeighborFinder');
+class NeighborFinder {
+    abortController;
+    options;
+    running = false;
+    constructor(options) {
+        this.options = options;
+        this.abortController = new AbortController();
+    }
+    async findNeighbors(excluded) {
+        if (!this.running) {
+            return;
+        }
+        const newExcludes = await this.options.doFindNeighbors(excluded);
+        const uniqueContactCount = new Set([
+            ...this.options.nearbyNodeView.getIds(),
+            ...this.options.leftNodeView.getIds(),
+            ...this.options.rightNodeView.getIds(),
+            ...this.options.randomNodeView.getIds()
+        ]).size;
+        if (this.options.neighbors.size() < this.options.minCount && newExcludes.length < uniqueContactCount) {
+            // TODO should we catch possible promise rejection?
+            setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL, this.abortController.signal);
+        }
+        else if (this.options.neighbors.size() === 0 && uniqueContactCount > 0) {
+            logger$b.debug('No neighbors found yet contacts are available, restarting handshaking process');
+            setAbortableTimeout(() => this.findNeighbors([]), INTERVAL, this.abortController.signal);
+        }
+        else {
+            this.running = false;
+        }
+    }
+    isRunning() {
+        return this.running;
+    }
+    start(excluded = []) {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        // TODO should we catch possible promise rejection?
+        setAbortableTimeout(async () => {
+            await Promise.all([
+                this.findNeighbors(excluded),
+                this.findNeighbors(excluded)
+            ]);
+        }, INITIAL_WAIT, this.abortController.signal);
+    }
+    stop() {
+        if (!this.running) {
+            return;
+        }
+        this.running = false;
+        this.abortController.abort();
+    }
+}
+
+class NeighborUpdateRpcLocal {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    updateContacts(neighborDescriptors) {
+        const ownNodeId = toNodeId(this.options.localPeerDescriptor);
+        const newPeerDescriptors = neighborDescriptors.filter((peerDescriptor) => {
+            const nodeId = toNodeId(peerDescriptor);
+            return nodeId !== ownNodeId && !this.options.neighbors.getIds().includes(nodeId);
+        });
+        newPeerDescriptors.forEach((peerDescriptor) => this.options.nearbyNodeView.add(new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, peerDescriptor, this.options.rpcCommunicator, ContentDeliveryRpcClient)));
+    }
+    createResponse(removeMe) {
+        return {
+            streamPartId: this.options.streamPartId,
+            neighborDescriptors: this.options.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
+            removeMe
+        };
+    }
+    // INeighborUpdateRpc server method
+    async neighborUpdate(message, context) {
+        const senderPeerDescriptor = context.incomingSourceDescriptor;
+        const remoteNodeId = toNodeId(senderPeerDescriptor);
+        this.updateContacts(message.neighborDescriptors);
+        if (!this.options.neighbors.has(remoteNodeId) && !this.options.ongoingHandshakes.has(remoteNodeId)) {
+            return this.createResponse(true);
+        }
+        else {
+            const isOverNeighborCount = this.options.neighbors.size() > this.options.neighborTargetCount
+                // Motivation: We don't know the remote's neighborTargetCount setting here. We only ask to cut connections
+                // if the remote has a "sufficient" number of neighbors, where "sufficient" means our neighborTargetCount
+                // setting.
+                && message.neighborDescriptors.length > this.options.neighborTargetCount;
+            if (!isOverNeighborCount) {
+                this.options.neighborFinder.start();
+            }
+            else {
+                this.options.neighbors.remove(remoteNodeId);
+            }
+            return this.createResponse(isOverNeighborCount);
+        }
+    }
+}
+
+const logger$a = new Logger('NeighborUpdateRpcRemote');
+class NeighborUpdateRpcRemote extends RpcRemote {
+    async updateNeighbors(streamPartId, neighbors) {
+        const request = {
+            streamPartId,
+            neighborDescriptors: neighbors,
+            removeMe: false
+        };
+        try {
+            const response = await this.getClient().neighborUpdate(request, this.formDhtRpcOptions());
+            return {
+                peerDescriptors: response.neighborDescriptors,
+                removeMe: response.removeMe
+            };
+        }
+        catch (err) {
+            logger$a.debug(`updateNeighbors to ${toNodeId(this.getPeerDescriptor())} failed`, { err });
+            return {
+                peerDescriptors: [],
+                removeMe: true
+            };
+        }
+    }
+}
+
+const logger$9 = new Logger('NeighborUpdateManager');
+const DEFAULT_NEIGHBOR_UPDATE_INTERVAL = 10 * 1000;
+class NeighborUpdateManager {
+    abortController;
+    options;
+    rpcLocal;
+    constructor(options) {
+        this.abortController = new AbortController();
+        this.rpcLocal = new NeighborUpdateRpcLocal(options);
+        this.options = options;
+        this.options.rpcCommunicator.registerRpcMethod(NeighborUpdate, NeighborUpdate, 'neighborUpdate', (req, context) => this.rpcLocal.neighborUpdate(req, context));
+    }
+    async start() {
+        await scheduleAtInterval(() => this.updateNeighborInfo(), this.options.neighborUpdateInterval, false, this.abortController.signal);
+    }
+    stop() {
+        this.abortController.abort();
+    }
+    async updateNeighborInfo() {
+        logger$9.trace(`Updating neighbor info to nodes`);
+        const neighborDescriptors = this.options.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor());
+        const startTime = Date.now();
+        await Promise.allSettled(this.options.neighbors.getAll().map(async (neighbor) => {
+            const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(this.options.streamPartId, neighborDescriptors);
+            const nodeId = toNodeId(neighbor.getPeerDescriptor());
+            this.options.neighbors.get(nodeId).setRtt(Date.now() - startTime);
+            if (res.removeMe) {
+                this.options.neighbors.remove(nodeId);
+                this.options.neighborFinder.start([nodeId]);
+            }
+        }));
+    }
+    createRemote(targetPeerDescriptor) {
+        return new NeighborUpdateRpcRemote(this.options.localPeerDescriptor, targetPeerDescriptor, this.options.rpcCommunicator, NeighborUpdateRpcClient);
+    }
+}
+
+class ContentDeliveryRpcLocal {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async sendStreamMessage(message, context) {
+        const previousNode = context.incomingSourceDescriptor;
+        const previousNodeId = toNodeId(previousNode);
+        this.options.markForInspection(previousNodeId, message.messageId);
+        if (this.options.plumtreeManager === undefined) {
+            if (this.options.markAndCheckDuplicate(message.messageId, message.previousMessageRef)) {
+                this.options.broadcast(message, previousNodeId);
+            }
+        }
+        else if (this.options.markAndCheckDuplicate(message.messageId, message.previousMessageRef)) {
+            // Message is not a duplicate, so we can broadcast it over the plumtree
+            this.options.plumtreeManager.broadcast(message, previousNodeId);
+        }
+        else {
+            // Message is a duplicate, so we need to pause the neighbor
+            await this.options.plumtreeManager.pauseNeighbor(previousNode, message.messageId.messageChainId);
+        }
+        return Empty;
+    }
+    async leaveStreamPartNotice(message, context) {
+        if (message.streamPartId === this.options.streamPartId) {
+            const sourcePeerDescriptor = context.incomingSourceDescriptor;
+            const remoteNodeId = toNodeId(sourcePeerDescriptor);
+            this.options.onLeaveNotice(remoteNodeId, message.isEntryPoint);
+        }
+        return Empty;
+    }
+}
+
+/**
+ * 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.
+ */
+class NumberPair {
+    a;
+    b;
+    constructor(a, b) {
+        this.a = a;
+        this.b = b;
+    }
+    greaterThanOrEqual(otherPair) {
+        return this.greaterThan(otherPair) || this.equalTo(otherPair);
+    }
+    greaterThan(otherPair) {
+        return this.compareTo(otherPair) === 1;
+    }
+    equalTo(otherPair) {
+        return this.compareTo(otherPair) === 0;
+    }
+    compareTo(otherPair) {
+        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() {
+        return `${this.a}|${this.b}`;
+    }
+}
+class InvalidNumberingError extends Error {
+    constructor() {
+        super('pre-condition: previousNumber < number');
+    }
+}
+class GapMisMatchError extends Error {
+    constructor(state, previousNumber, number) {
+        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.
+ *
+ */
+class DuplicateMessageDetector {
+    maxGapCount;
+    gaps;
+    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, number) {
+        if (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;
+    }
+    dropLowestGapIfOverMaxGapCount() {
+        // invariant: this.gaps.length <= this.maxGapCount + 1
+        if (this.gaps.length > this.maxGapCount) {
+            this.gaps.shift();
+        }
+    }
+    toString() {
+        return this.gaps.map(([lower, upper]) => `(${lower.toString()}, ${upper.toString()}]`).join(', ');
+    }
+}
+
+const markAndCheckDuplicate = (duplicateDetectors, currentMessage, previousMessageRef) => {
+    const detectorKey = `${toUserId(currentMessage.publisherId)}-${currentMessage.messageChainId}`;
+    const previousNumberPair = previousMessageRef ?
+        new NumberPair(Number(previousMessageRef.timestamp), previousMessageRef.sequenceNumber) : null;
+    const currentNumberPair = new NumberPair(Number(currentMessage.timestamp), currentMessage.sequenceNumber);
+    if (!duplicateDetectors.has(detectorKey)) {
+        duplicateDetectors.set(detectorKey, new DuplicateMessageDetector());
+    }
+    return duplicateDetectors.get(detectorKey).markAndCheck(previousNumberPair, currentNumberPair);
+};
+
+const DEFAULT_NODE_VIEW_SIZE = 20;
+const DEFAULT_NEIGHBOR_TARGET_COUNT = 4;
+const DEFAULT_ACCEPT_PROXY_CONNECTIONS = false;
+const logger$8 = new Logger('ContentDeliveryLayerNode');
+class ContentDeliveryLayerNode extends EventEmitter {
+    started = false;
+    duplicateDetectors;
+    options;
+    contentDeliveryRpcLocal;
+    abortController = new AbortController();
+    messagesPropagated = 0;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.duplicateDetectors = new Map();
+        this.contentDeliveryRpcLocal = new ContentDeliveryRpcLocal({
+            localPeerDescriptor: this.options.localPeerDescriptor,
+            streamPartId: this.options.streamPartId,
+            rpcCommunicator: this.options.rpcCommunicator,
+            markAndCheckDuplicate: (msg, prev) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
+            broadcast: (message, previousNode) => this.broadcast(message, previousNode),
+            onLeaveNotice: (remoteNodeId, sourceIsStreamEntryPoint) => {
+                if (this.abortController.signal.aborted) {
+                    return;
+                }
+                const contact = this.options.nearbyNodeView.get(remoteNodeId)
+                    ?? this.options.randomNodeView.get(remoteNodeId)
+                    ?? this.options.neighbors.get(remoteNodeId)
+                    ?? this.options.proxyConnectionRpcLocal?.getConnection(remoteNodeId)?.remote;
+                // TODO: check integrity of notifier?
+                if (contact) {
+                    this.options.discoveryLayerNode.removeContact(remoteNodeId);
+                    this.options.neighbors.remove(remoteNodeId);
+                    this.options.nearbyNodeView.remove(remoteNodeId);
+                    this.options.randomNodeView.remove(remoteNodeId);
+                    this.options.leftNodeView.remove(remoteNodeId);
+                    this.options.rightNodeView.remove(remoteNodeId);
+                    this.options.neighborFinder.start([remoteNodeId]);
+                    this.options.proxyConnectionRpcLocal?.removeConnection(remoteNodeId);
+                }
+                if (sourceIsStreamEntryPoint) {
+                    this.emit('entryPointLeaveDetected');
+                }
+            },
+            markForInspection: (remoteNodeId, messageId) => this.options.inspector.markMessage(remoteNodeId, messageId),
+            plumtreeManager: this.options.plumtreeManager
+        });
+    }
+    async start() {
+        this.started = true;
+        this.registerDefaultServerMethods();
+        addManagedEventListener(this.options.discoveryLayerNode, 'nearbyContactAdded', () => this.onNearbyContactAdded(), this.abortController.signal);
+        addManagedEventListener(this.options.discoveryLayerNode, 'nearbyContactRemoved', () => this.onNearbyContactRemoved(), this.abortController.signal);
+        addManagedEventListener(this.options.discoveryLayerNode, 'randomContactAdded', () => this.onRandomContactAdded(), this.abortController.signal);
+        addManagedEventListener(this.options.discoveryLayerNode, 'randomContactRemoved', () => this.onRandomContactRemoved(), this.abortController.signal);
+        addManagedEventListener(this.options.discoveryLayerNode, 'ringContactAdded', () => this.onRingContactsUpdated(), this.abortController.signal);
+        addManagedEventListener(this.options.discoveryLayerNode, 'ringContactRemoved', () => this.onRingContactsUpdated(), this.abortController.signal);
+        addManagedEventListener(this.options.transport, 'disconnected', (peerDescriptor) => this.onNodeDisconnected(peerDescriptor), this.abortController.signal);
+        addManagedEventListener(this.options.neighbors, 'nodeAdded', (id, remote) => {
+            this.options.propagation.onNeighborJoined(id);
+            this.options.connectionLocker.weakLockConnection(toNodeId(remote.getPeerDescriptor()), this.options.streamPartId);
+            this.emit('neighborConnected', id);
+        }, this.abortController.signal);
+        addManagedEventListener(this.options.neighbors, 'nodeRemoved', (_id, remote) => {
+            this.options.connectionLocker.weakUnlockConnection(toNodeId(remote.getPeerDescriptor()), this.options.streamPartId);
+        }, this.abortController.signal);
+        if (this.options.proxyConnectionRpcLocal !== undefined) {
+            addManagedEventListener(this.options.proxyConnectionRpcLocal, 'newConnection', (id) => this.options.propagation.onNeighborJoined(id), this.abortController.signal);
+        }
+        if (this.options.plumtreeManager) {
+            addManagedEventListener(this.options.plumtreeManager, 'message', (msg) => this.emit('message', msg), this.abortController.signal);
+        }
+        this.options.neighborFinder.start();
+        await this.options.neighborUpdateManager.start();
+    }
+    registerDefaultServerMethods() {
+        this.options.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage', (msg, context) => this.contentDeliveryRpcLocal.sendStreamMessage(msg, context));
+        this.options.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice', (req, context) => this.contentDeliveryRpcLocal.leaveStreamPartNotice(req, context));
+        this.options.rpcCommunicator.registerRpcMethod(TemporaryConnectionRequest, TemporaryConnectionResponse, 'openConnection', (req, context) => this.options.temporaryConnectionRpcLocal.openConnection(req, context));
+        this.options.rpcCommunicator.registerRpcNotification(CloseTemporaryConnection, 'closeConnection', (req, context) => this.options.temporaryConnectionRpcLocal.closeConnection(req, context));
+    }
+    onRingContactsUpdated() {
+        logger$8.trace('onRingContactsUpdated');
+        if (this.isStopped()) {
+            return;
+        }
+        const contacts = this.options.discoveryLayerNode.getRingContacts();
+        this.options.leftNodeView.replaceAll(contacts.left.map((peer) => new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, peer, this.options.rpcCommunicator, ContentDeliveryRpcClient, this.options.rpcRequestTimeout)));
+        this.options.rightNodeView.replaceAll(contacts.right.map((peer) => new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, peer, this.options.rpcCommunicator, ContentDeliveryRpcClient, this.options.rpcRequestTimeout)));
+    }
+    onNearbyContactAdded() {
+        logger$8.trace(`New nearby contact found`);
+        if (this.isStopped()) {
+            return;
+        }
+        const closestContacts = this.options.discoveryLayerNode.getClosestContacts();
+        this.updateNearbyNodeView(closestContacts);
+        if (this.options.neighbors.size() < this.options.neighborTargetCount) {
+            this.options.neighborFinder.start();
+        }
+    }
+    onNearbyContactRemoved() {
+        logger$8.trace(`Nearby contact removed`);
+        if (this.isStopped()) {
+            return;
+        }
+        const closestContacts = this.options.discoveryLayerNode.getClosestContacts();
+        this.updateNearbyNodeView(closestContacts);
+    }
+    updateNearbyNodeView(nodes) {
+        this.options.nearbyNodeView.replaceAll(Array.from(nodes).map((descriptor) => new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, descriptor, this.options.rpcCommunicator, ContentDeliveryRpcClient, this.options.rpcRequestTimeout)));
+        for (const descriptor of this.options.discoveryLayerNode.getNeighbors()) {
+            if (this.options.nearbyNodeView.size() >= this.options.nodeViewSize) {
+                break;
+            }
+            this.options.nearbyNodeView.add(new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, descriptor, this.options.rpcCommunicator, ContentDeliveryRpcClient, this.options.rpcRequestTimeout));
+        }
+    }
+    onRandomContactAdded() {
+        if (this.isStopped()) {
+            return;
+        }
+        const randomContacts = this.options.discoveryLayerNode.getRandomContacts(this.options.nodeViewSize);
+        this.options.randomNodeView.replaceAll(randomContacts.map((descriptor) => new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, descriptor, this.options.rpcCommunicator, ContentDeliveryRpcClient, this.options.rpcRequestTimeout)));
+        if (this.options.neighbors.size() < this.options.neighborTargetCount) {
+            this.options.neighborFinder.start();
+        }
+    }
+    onRandomContactRemoved() {
+        logger$8.trace(`New random contact removed`);
+        if (this.isStopped()) {
+            return;
+        }
+        const randomContacts = this.options.discoveryLayerNode.getRandomContacts(this.options.nodeViewSize);
+        this.options.randomNodeView.replaceAll(randomContacts.map((descriptor) => new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, descriptor, this.options.rpcCommunicator, ContentDeliveryRpcClient, this.options.rpcRequestTimeout)));
+    }
+    onNodeDisconnected(peerDescriptor) {
+        const nodeId = toNodeId(peerDescriptor);
+        if (this.options.neighbors.has(nodeId)) {
+            this.options.neighbors.remove(nodeId);
+            this.options.neighborFinder.start([nodeId]);
+            this.options.temporaryConnectionRpcLocal.removeNode(nodeId);
+        }
+    }
+    hasProxyConnection(nodeId) {
+        if (this.options.proxyConnectionRpcLocal) {
+            return this.options.proxyConnectionRpcLocal.hasConnection(nodeId);
+        }
+        return false;
+    }
+    stop() {
+        if (!this.started) {
+            return;
+        }
+        this.abortController.abort();
+        this.options.proxyConnectionRpcLocal?.stop();
+        this.options.neighbors.getAll().map((remote) => {
+            remote.leaveStreamPartNotice(this.options.streamPartId, this.options.isLocalNodeEntryPoint());
+            this.options.connectionLocker.weakUnlockConnection(toNodeId(remote.getPeerDescriptor()), this.options.streamPartId);
+        });
+        this.options.rpcCommunicator.destroy();
+        this.removeAllListeners();
+        this.options.plumtreeManager?.stop();
+        this.options.nearbyNodeView.stop();
+        this.options.neighbors.stop();
+        this.options.randomNodeView.stop();
+        this.options.neighborFinder.stop();
+        this.options.neighborUpdateManager.stop();
+        this.options.inspector.stop();
+    }
+    broadcast(msg, previousNode) {
+        if (!previousNode) {
+            markAndCheckDuplicate(this.duplicateDetectors, msg.messageId, msg.previousMessageRef);
+        }
+        this.emit('message', msg);
+        const skipBackPropagation = previousNode !== undefined && !this.options.temporaryConnectionRpcLocal.hasNode(previousNode);
+        this.options.propagation.feedUnseenMessage(msg, this.getPropagationTargets(msg), skipBackPropagation ? previousNode : null);
+        this.messagesPropagated += 1;
+    }
+    inspect(peerDescriptor) {
+        return this.options.inspector.inspect(peerDescriptor);
+    }
+    getPropagationTargets(msg) {
+        let propagationTargets = this.options.neighbors.getIds();
+        if (this.options.proxyConnectionRpcLocal) {
+            propagationTargets = propagationTargets.concat(this.options.proxyConnectionRpcLocal.getPropagationTargets(msg));
+        }
+        propagationTargets = propagationTargets.concat(this.options.temporaryConnectionRpcLocal.getNodes().getIds());
+        return propagationTargets;
+    }
+    getOwnNodeId() {
+        return toNodeId(this.options.localPeerDescriptor);
+    }
+    getOutgoingHandshakeCount() {
+        return this.options.handshaker.getOngoingHandshakes().size;
+    }
+    getNeighbors() {
+        if (!this.started && this.isStopped()) {
+            return [];
+        }
+        return this.options.neighbors.getAll().map((n) => n.getPeerDescriptor());
+    }
+    getInfos() {
+        return this.options.neighbors.getAll().map((n) => {
+            return {
+                peerDescriptor: n.getPeerDescriptor(),
+                rtt: n.getRtt()
+            };
+        });
+    }
+    getNearbyNodeView() {
+        return this.options.nearbyNodeView;
+    }
+    getDiagnosticInfo() {
+        return {
+            neighborCount: this.options.neighbors.size(),
+            nearbyNodeViewCount: this.options.nearbyNodeView.size(),
+            randomNodeViewCount: this.options.randomNodeView.size(),
+            leftNodeViewCount: this.options.leftNodeView.size(),
+            rightNodeViewCount: this.options.rightNodeView.size(),
+            messagesPropagated: this.messagesPropagated
+        };
+    }
+    isStopped() {
+        return this.abortController.signal.aborted;
+    }
+}
+
+const getValuesOfIncludedKeys = (nodes, exclude, wsOnly = false) => {
+    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
+class NodeList extends EventEmitter {
+    nodes;
+    limit;
+    ownId;
+    constructor(ownId, limit) {
+        super();
+        this.nodes = new Map();
+        this.limit = limit;
+        this.ownId = ownId;
+    }
+    add(remote) {
+        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) {
+        if (this.nodes.has(nodeId)) {
+            const remote = this.nodes.get(nodeId);
+            this.nodes.delete(nodeId);
+            this.emit('nodeRemoved', nodeId, remote);
+        }
+    }
+    has(nodeId) {
+        return this.nodes.has(nodeId);
+    }
+    // Replace nodes does not emit nodeRemoved events, use with caution
+    replaceAll(neighbors) {
+        this.nodes.clear();
+        const limited = neighbors.splice(0, this.limit);
+        limited.forEach((remote) => {
+            this.add(remote);
+        });
+    }
+    getIds() {
+        return Array.from(this.nodes.keys());
+    }
+    get(id) {
+        return this.nodes.get(id);
+    }
+    size(exclude = []) {
+        return Array.from(this.nodes.keys()).filter((node) => !exclude.includes(node)).length;
+    }
+    getRandom(exclude) {
+        return sample(getValuesOfIncludedKeys(this.nodes, exclude));
+    }
+    getFirst(exclude, wsOnly = false) {
+        const included = getValuesOfIncludedKeys(this.nodes, exclude, wsOnly);
+        return included[0];
+    }
+    getFirstAndLast(exclude) {
+        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) {
+        const included = getValuesOfIncludedKeys(this.nodes, exclude);
+        return included[included.length - 1];
+    }
+    getAll() {
+        return Array.from(this.nodes.values());
+    }
+    stop() {
+        this.nodes.forEach((node) => this.remove(toNodeId(node.getPeerDescriptor())));
+        this.removeAllListeners();
+    }
+}
+
+/**
+ * A "Map" implementation with a maximum size and TTL expiration on entries.
+ *
+ * When full, room is made for new entries by dropping existing by FIFO method.
+ *
+ * Entries have a TTL after which they are considered stale. Stale items are
+ * not returned when querying.
+ *
+ */
+class FifoMapWithTTL {
+    // class invariant: the keys present in `items` and `dropQueue` are the same set.
+    items = new Map();
+    dropQueue = Yallist.create(); // queue is used to determine deletion order when full
+    ttlInMs;
+    maxSize;
+    onItemDropped;
+    timeProvider;
+    constructor({ ttlInMs, maxSize, onItemDropped = () => { }, timeProvider = Date.now }) {
+        if (ttlInMs < 0) {
+            throw new Error(`ttlInMs (${ttlInMs}) cannot be < 0`);
+        }
+        if (maxSize < 0) {
+            throw new Error(`maxSize (${maxSize}) cannot be < 0`);
+        }
+        this.ttlInMs = ttlInMs;
+        this.maxSize = maxSize;
+        this.onItemDropped = onItemDropped;
+        this.timeProvider = timeProvider;
+    }
+    set(key, value) {
+        if (this.maxSize === 0) {
+            return;
+        }
+        if (this.items.size > this.maxSize) {
+            throw new Error('assertion error: maximum size exceeded');
+        }
+        // delete an existing entry if exists
+        this.delete(key);
+        // make room for new entry
+        if (this.items.size === this.maxSize) {
+            const keyToDel = this.dropQueue.shift();
+            if (keyToDel === undefined) {
+                throw new Error('assertion error: queue empty but still have items');
+            }
+            this.items.delete(keyToDel);
+            this.onItemDropped(keyToDel);
+        }
+        // add entry
+        const dropQueueNode = new Node(key);
+        this.dropQueue.pushNode(dropQueueNode);
+        this.items.set(key, {
+            value,
+            dropQueueNode,
+            expiresAt: this.timeProvider() + this.ttlInMs
+        });
+    }
+    delete(key) {
+        const item = this.items.get(key);
+        if (item !== undefined) {
+            this.items.delete(key);
+            this.dropQueue.removeNode(item.dropQueueNode);
+            this.onItemDropped(key);
+        }
+    }
+    get(key) {
+        const item = this.items.get(key);
+        if (item === undefined) {
+            return undefined;
+        }
+        if (item.expiresAt <= this.timeProvider()) {
+            this.delete(key);
+            return undefined;
+        }
+        return item.value;
+    }
+    values() {
+        const keys = [...this.items.keys()];
+        const values = [];
+        for (const key of keys) {
+            const value = this.get(key);
+            if (value !== undefined) {
+                values.push(value);
+            }
+        }
+        return values;
+    }
+}
+
+/**
+ * Keeps track of propagation tasks for the needs of message propagation logic.
+ *
+ * Properties:
+ * - Allows fetching propagation tasks by StreamPartID
+ * - Upper bound on number of tasks stored, replacement policy if FIFO
+ * - Items have a TTL, after which they are considered stale and not returned when querying
+**/
+class PropagationTaskStore {
+    tasks;
+    constructor(ttlInMs, maxTasks) {
+        this.tasks = new FifoMapWithTTL({
+            ttlInMs,
+            maxSize: maxTasks
+        });
+    }
+    get() {
+        return this.tasks.values();
+    }
+    add(task) {
+        const messageId = task.message.messageId;
+        this.tasks.set(messageId, task);
+    }
+    delete(messageId) {
+        this.tasks.delete(messageId); // causes `onKeyDropped` to be invoked
+    }
+}
+
+const DEFAULT_PROPAGATION_BUFFER_TTL = 10 * 1000;
+const DEFAULT_MIN_PROPAGATION_TARGETS = 2;
+const DEFAULT_MAX_PROPAGATION_BUFFER_SIZE = 150;
+/**
+ * Message propagation logic of a node. Given a message, this class will actively attempt to propagate it to
+ * `minPropagationTargets` neighbors until success or TTL expiration.
+ *
+ * Setting `minPropagationTargets = 0` effectively disables any propagation reattempts. A message will then
+ * only be propagated exactly once, to neighbors that are present at that moment, in a fire-and-forget manner.
+ */
+class Propagation {
+    sendToNeighbor;
+    minPropagationTargets;
+    activeTaskStore;
+    constructor({ sendToNeighbor, minPropagationTargets, maxMessages, ttl }) {
+        this.sendToNeighbor = sendToNeighbor;
+        this.minPropagationTargets = minPropagationTargets;
+        this.activeTaskStore = new PropagationTaskStore(ttl, maxMessages);
+    }
+    /**
+     * Node should invoke this when it learns about a new message
+     */
+    feedUnseenMessage(message, targets, source) {
+        const task = {
+            message,
+            source,
+            handledNeighbors: new Set()
+        };
+        this.activeTaskStore.add(task);
+        for (const target of targets) {
+            this.sendAndAwaitThenMark(task, target);
+        }
+    }
+    /**
+     * Node should invoke this when it learns about a new node stream assignment
+     */
+    onNeighborJoined(neighborId) {
+        const tasks = this.activeTaskStore.get();
+        for (const task of tasks) {
+            this.sendAndAwaitThenMark(task, neighborId);
+        }
+    }
+    sendAndAwaitThenMark({ message, source, handledNeighbors }, neighborId) {
+        if (!handledNeighbors.has(neighborId) && neighborId !== source) {
+            (async () => {
+                try {
+                    await this.sendToNeighbor(neighborId, message);
+                }
+                catch {
+                    return;
+                }
+                // Side-note: due to asynchronicity, the task being modified at this point could already be stale and
+                // deleted from `activeTaskStore`. However, as modifying it or re-deleting it is pretty much
+                // inconsequential at this point, leaving the logic as is.
+                handledNeighbors.add(neighborId);
+                if (handledNeighbors.size >= this.minPropagationTargets) {
+                    this.activeTaskStore.delete(message.messageId);
+                }
+            })();
+        }
+    }
+}
+
+const logger$7 = new Logger('ProxyConnectionRpcLocal');
+class ProxyConnectionRpcLocal extends EventEmitter {
+    options;
+    connections = new Map();
+    constructor(options) {
+        super();
+        this.options = options;
+        this.options.rpcCommunicator.registerRpcMethod(ProxyConnectionRequest, ProxyConnectionResponse, 'requestConnection', (msg, context) => this.requestConnection(msg, context));
+    }
+    getConnection(nodeId) {
+        return this.connections.get(nodeId);
+    }
+    hasConnection(nodeId) {
+        return this.connections.has(nodeId);
+    }
+    removeConnection(nodeId) {
+        this.connections.delete(nodeId);
+    }
+    stop() {
+        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice(this.options.streamPartId, false));
+        this.connections.clear();
+        this.removeAllListeners();
+    }
+    getPropagationTargets(msg) {
+        if (msg.body.oneofKind === 'groupKeyRequest') {
+            try {
+                const recipientId = msg.body.groupKeyRequest.recipientId;
+                return this.getNodeIdsForUserId(toUserId(recipientId));
+            }
+            catch (err) {
+                logger$7.trace(`Could not parse GroupKeyRequest`, { err });
+                return [];
+            }
+        }
+        else {
+            return this.getSubscribers();
+        }
+    }
+    getNodeIdsForUserId(userId) {
+        return Array.from(this.connections.keys()).filter((nodeId) => this.connections.get(nodeId).userId === userId);
+    }
+    getSubscribers() {
+        return Array.from(this.connections.keys()).filter((key) => {
+            const direction = this.connections.get(key).direction;
+            return direction === undefined || direction === ProxyDirection.SUBSCRIBE;
+        });
+    }
+    // IProxyConnectionRpc server method
+    async requestConnection(request, context) {
+        const senderPeerDescriptor = context.incomingSourceDescriptor;
+        const remoteNodeId = toNodeId(senderPeerDescriptor);
+        this.connections.set(remoteNodeId, {
+            direction: request.direction,
+            userId: toUserId(request.userId),
+            remote: new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, senderPeerDescriptor, this.options.rpcCommunicator, ContentDeliveryRpcClient)
+        });
+        const response = {
+            accepted: true
+        };
+        logger$7.trace(`Accepted connection request from ${remoteNodeId} to ${this.options.streamPartId}`);
+        this.emit('newConnection', remoteNodeId);
+        return response;
+    }
+}
+
+const logger$6 = new Logger('TemporaryConnectionRpcRemote');
+class TemporaryConnectionRpcRemote extends RpcRemote {
+    async openConnection() {
+        try {
+            const response = await this.getClient().openConnection({}, this.formDhtRpcOptions());
+            return response.accepted;
+        }
+        catch (err) {
+            logger$6.debug(`temporaryConnection to ${toNodeId(this.getPeerDescriptor())} failed`, { err });
+            return false;
+        }
+    }
+    async closeConnection() {
+        try {
+            await this.getClient().closeConnection({}, this.formDhtRpcOptions({
+                connect: false,
+                notification: true
+            }));
+        }
+        catch (err) {
+            logger$6.trace(`closeConnection to ${toNodeId(this.getPeerDescriptor())} failed`, { err });
+        }
+    }
+}
+
+const createMessageKey = (messageId) => {
+    return `${toUserId(messageId.publisherId)}:${messageId.messageChainId}:${messageId.timestamp}:${messageId.sequenceNumber}`;
+};
+class InspectSession extends EventEmitter {
+    // Boolean indicates if the message has been received by the inspected node
+    inspectionMessages = new Map();
+    inspectedNode;
+    constructor(options) {
+        super();
+        this.inspectedNode = options.inspectedNode;
+    }
+    markMessage(remoteNodeId, messageId) {
+        const messageKey = createMessageKey(messageId);
+        if (!this.inspectionMessages.has(messageKey)) {
+            this.inspectionMessages.set(messageKey, remoteNodeId === this.inspectedNode);
+        }
+        else if (this.inspectionMessages.has(messageKey)
+            && this.inspectionMessages.get(messageKey) === false
+            && remoteNodeId === this.inspectedNode) {
+            this.emit('done');
+        }
+        else if (this.inspectionMessages.has(messageKey)
+            && this.inspectionMessages.get(messageKey) === true) {
+            this.emit('done');
+        }
+    }
+    getInspectedMessageCount() {
+        return this.inspectionMessages.size;
+    }
+    onlyMarkedByInspectedNode() {
+        return Array.from(this.inspectionMessages.values()).every((value) => value === true);
+    }
+    stop() {
+        this.emit('done');
+    }
+}
+
+const logger$5 = new Logger('Inspector');
+const DEFAULT_TIMEOUT = 60 * 1000;
+class Inspector {
+    sessions = new Map();
+    streamPartId;
+    localPeerDescriptor;
+    rpcCommunicator;
+    connectionLocker;
+    inspectionTimeout;
+    openInspectConnection;
+    closeInspectConnection;
+    constructor(options) {
+        this.streamPartId = options.streamPartId;
+        this.localPeerDescriptor = options.localPeerDescriptor;
+        this.rpcCommunicator = options.rpcCommunicator;
+        this.connectionLocker = options.connectionLocker;
+        this.inspectionTimeout = options.inspectionTimeout ?? DEFAULT_TIMEOUT;
+        this.openInspectConnection = options.openInspectConnection ?? this.defaultOpenInspectConnection;
+        this.closeInspectConnection = options.closeInspectConnection ?? this.defaultCloseInspectConnection;
+    }
+    async defaultOpenInspectConnection(peerDescriptor, lockId) {
+        const rpcRemote = new TemporaryConnectionRpcRemote(this.localPeerDescriptor, peerDescriptor, this.rpcCommunicator, TemporaryConnectionRpcClient);
+        await rpcRemote.openConnection();
+        this.connectionLocker.weakLockConnection(toNodeId(peerDescriptor), lockId);
+    }
+    async defaultCloseInspectConnection(peerDescriptor, lockId) {
+        const rpcRemote = new TemporaryConnectionRpcRemote(this.localPeerDescriptor, peerDescriptor, this.rpcCommunicator, TemporaryConnectionRpcClient);
+        await rpcRemote.closeConnection();
+        this.connectionLocker.weakUnlockConnection(toNodeId(peerDescriptor), lockId);
+    }
+    async inspect(peerDescriptor) {
+        const nodeId = toNodeId(peerDescriptor);
+        const session = new InspectSession({
+            inspectedNode: nodeId
+        });
+        const lockId = `inspector-${this.streamPartId}`;
+        this.sessions.set(nodeId, session);
+        await this.openInspectConnection(peerDescriptor, lockId);
+        let success = false;
+        try {
+            await waitForEvent(session, 'done', this.inspectionTimeout);
+            success = true;
+        }
+        catch {
+            logger$5.trace('Inspect session timed out, removing');
+        }
+        finally {
+            await this.closeInspectConnection(peerDescriptor, lockId);
+            this.sessions.delete(nodeId);
+        }
+        return success || session.getInspectedMessageCount() < 1 || session.onlyMarkedByInspectedNode();
+    }
+    markMessage(sender, messageId) {
+        this.sessions.forEach((session) => session.markMessage(sender, messageId));
+    }
+    isInspected(nodeId) {
+        return this.sessions.has(nodeId);
+    }
+    stop() {
+        this.sessions.forEach((session) => {
+            session.stop();
+        });
+        this.sessions.clear();
+    }
+}
+
+const LOCK_ID_BASE = 'system/content-delivery/temporary-connection/';
+class TemporaryConnectionRpcLocal {
+    options;
+    temporaryNodes;
+    lockId;
+    constructor(options) {
+        this.options = options;
+        // TODO use options option or named constant?
+        this.temporaryNodes = new NodeList(toNodeId(options.localPeerDescriptor), 10);
+        this.lockId = LOCK_ID_BASE + options.streamPartId;
+    }
+    getNodes() {
+        return this.temporaryNodes;
+    }
+    hasNode(node) {
+        return this.temporaryNodes.has(node);
+    }
+    removeNode(nodeId) {
+        this.temporaryNodes.remove(nodeId);
+        this.options.connectionLocker.weakUnlockConnection(nodeId, this.lockId);
+    }
+    async openConnection(_request, context) {
+        const sender = context.incomingSourceDescriptor;
+        const remote = new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, sender, this.options.rpcCommunicator, ContentDeliveryRpcClient);
+        this.temporaryNodes.add(remote);
+        this.options.connectionLocker.weakLockConnection(toNodeId(sender), this.lockId);
+        return {
+            accepted: true
+        };
+    }
+    async closeConnection(_request, context) {
+        const remoteNodeId = toNodeId(context.incomingSourceDescriptor);
+        this.removeNode(remoteNodeId);
+        return {};
+    }
+}
+
+const formStreamPartContentDeliveryServiceId = (streamPartId) => {
+    // could be "content-delivery" instead of "delivery", but that is a breaking change
+    return `stream-part-delivery-${streamPartId}`;
+};
+
+class PlumtreeRpcLocal {
+    neighbors;
+    pausedNodes;
+    onMetadataCb;
+    sendBuffer;
+    constructor(neighbors, pausedNodes, onMetaDataCb, sendBuffer) {
+        this.neighbors = neighbors;
+        this.pausedNodes = pausedNodes;
+        this.onMetadataCb = onMetaDataCb;
+        this.sendBuffer = sendBuffer;
+    }
+    async sendMetadata(message, context) {
+        const previousNode = context.incomingSourceDescriptor;
+        await this.onMetadataCb(message, previousNode);
+        return Empty;
+    }
+    async pauseNeighbor(request, context) {
+        const sender = toNodeId(context.incomingSourceDescriptor);
+        if (this.neighbors.has(sender)) {
+            this.pausedNodes.add(sender, request.messageChainId);
+        }
+        return Empty;
+    }
+    async resumeNeighbor(request, context) {
+        const sender = context.incomingSourceDescriptor;
+        this.pausedNodes.delete(toNodeId(sender), request.messageChainId);
+        await this.sendBuffer(request.fromTimestamp, request.messageChainId, sender);
+        return Empty;
+    }
+}
+
+class PlumtreeRpcRemote extends RpcRemote {
+    async sendMetadata(msg) {
+        const options = this.formDhtRpcOptions({
+            notification: true
+        });
+        await this.getClient().sendMetadata(msg, options);
+    }
+    async pauseNeighbor(messageChainId) {
+        const options = this.formDhtRpcOptions({
+            notification: true
+        });
+        await this.getClient().pauseNeighbor({ messageChainId }, options);
+    }
+    async resumeNeighbor(fromTimestamp, messageChainId) {
+        const options = this.formDhtRpcOptions({
+            notification: true
+        });
+        await this.getClient().resumeNeighbor({ fromTimestamp, messageChainId }, options);
+    }
+}
+
+class PausedNeighbors {
+    pausedNeighbors;
+    limit;
+    constructor(limit) {
+        this.pausedNeighbors = new Map();
+        this.limit = limit;
+    }
+    add(node, msgChainId) {
+        if (!this.pausedNeighbors.has(msgChainId)) {
+            this.pausedNeighbors.set(msgChainId, new Set());
+        }
+        if (this.pausedNeighbors.get(msgChainId).size >= this.limit) {
+            return;
+        }
+        this.pausedNeighbors.get(msgChainId).add(node);
+    }
+    delete(node, msgChainId) {
+        this.pausedNeighbors.get(msgChainId)?.delete(node);
+        if (this.pausedNeighbors.get(msgChainId)?.size === 0) {
+            this.pausedNeighbors.delete(msgChainId);
+        }
+    }
+    deleteAll(node) {
+        this.pausedNeighbors.forEach((neighbors, msgChainId) => {
+            neighbors.delete(node);
+            if (neighbors.size === 0) {
+                this.pausedNeighbors.delete(msgChainId);
+            }
+        });
+    }
+    isPaused(node, msgChainId) {
+        if (!this.pausedNeighbors.has(msgChainId)) {
+            return false;
+        }
+        return this.pausedNeighbors.get(msgChainId).has(node);
+    }
+    forEach(fn) {
+        this.pausedNeighbors.forEach((neighbors, msgChainId) => {
+            fn(neighbors, msgChainId);
+        });
+    }
+    size(msgChainId) {
+        return this.pausedNeighbors.get(msgChainId)?.size ?? 0;
+    }
+}
+
+const MAX_PAUSED_NEIGHBORS_DEFAULT = 3;
+const logger$4 = new Logger('PlumtreeManager');
+class PlumtreeManager extends EventEmitter {
+    neighbors;
+    localPeerDescriptor;
+    // We have paused sending real data to these neighbrs and only send metadata
+    localPausedNeighbors;
+    // We have asked these nodes to pause sending real data to us, used to limit sending of pausing and resuming requests
+    remotePausedNeighbors;
+    rpcLocal;
+    latestMessages = new Map();
+    rpcCommunicator;
+    metadataTimestampsAheadOfRealData = new Map();
+    maxPausedNeighbors;
+    constructor(options) {
+        super();
+        this.neighbors = options.neighbors;
+        this.maxPausedNeighbors = options.maxPausedNeighbors ?? MAX_PAUSED_NEIGHBORS_DEFAULT;
+        this.localPeerDescriptor = options.localPeerDescriptor;
+        this.localPausedNeighbors = new PausedNeighbors(options.maxPausedNeighbors ?? MAX_PAUSED_NEIGHBORS_DEFAULT);
+        this.remotePausedNeighbors = new PausedNeighbors(options.maxPausedNeighbors ?? MAX_PAUSED_NEIGHBORS_DEFAULT);
+        this.rpcLocal = new PlumtreeRpcLocal(this.neighbors, this.localPausedNeighbors, (metadata, previousNode) => this.onMetadata(metadata, previousNode), (fromTimestamp, msgChainId, remotePeerDescriptor) => this.sendBuffer(fromTimestamp, msgChainId, remotePeerDescriptor));
+        this.neighbors.on('nodeRemoved', (nodeId) => this.onNeighborRemoved(nodeId));
+        this.rpcCommunicator = options.rpcCommunicator;
+        this.rpcCommunicator.registerRpcNotification(MessageID, 'sendMetadata', (msg, context) => this.rpcLocal.sendMetadata(msg, context));
+        this.rpcCommunicator.registerRpcNotification(PauseNeighborRequest, 'pauseNeighbor', (msg, context) => this.rpcLocal.pauseNeighbor(msg, context));
+        this.rpcCommunicator.registerRpcNotification(ResumeNeighborRequest, 'resumeNeighbor', (msg, context) => this.rpcLocal.resumeNeighbor(msg, context));
+    }
+    async pauseNeighbor(node, msgChainId) {
+        if (this.neighbors.has(toNodeId(node))
+            && !this.remotePausedNeighbors.isPaused(toNodeId(node), msgChainId)
+            && this.remotePausedNeighbors.size(msgChainId) < this.maxPausedNeighbors) {
+            logger$4.debug(`Pausing neighbor ${toNodeId(node)}`);
+            this.remotePausedNeighbors.add(toNodeId(node), msgChainId);
+            const remote = this.createRemote(node);
+            await remote.pauseNeighbor(msgChainId);
+        }
+    }
+    async resumeNeighbor(node, msgChainId, fromTimestamp) {
+        if (this.remotePausedNeighbors.isPaused(toNodeId(node), msgChainId)) {
+            logger$4.debug(`Resuming neighbor ${toNodeId(node)}`);
+            this.remotePausedNeighbors.delete(toNodeId(node), msgChainId);
+            const remote = this.createRemote(node);
+            await remote.resumeNeighbor(fromTimestamp, msgChainId);
+        }
+    }
+    onNeighborRemoved(nodeId) {
+        this.localPausedNeighbors.deleteAll(nodeId);
+        this.remotePausedNeighbors.deleteAll(nodeId);
+        if (this.neighbors.size() > 0) {
+            this.remotePausedNeighbors.forEach((pausedNeighbors, msgChainId) => {
+                if (pausedNeighbors.size >= this.neighbors.size()) {
+                    logger$4.debug('All neighbors are paused, resuming first neighbor');
+                    const neighborToResume = this.neighbors.getFirst([]).getPeerDescriptor();
+                    setImmediate(() => this.resumeNeighbor(neighborToResume, msgChainId, this.getLatestMessageTimestamp(msgChainId)));
+                }
+            });
+        }
+    }
+    getLatestMessageTimestamp(msgChainId) {
+        if (!this.latestMessages.has(msgChainId) || this.latestMessages.get(msgChainId).length === 0) {
+            return 0;
+        }
+        return this.latestMessages.get(msgChainId)[this.latestMessages.get(msgChainId).length - 1].messageId.timestamp;
+    }
+    async sendBuffer(fromTimestamp, msgChainId, neighbor) {
+        const remote = new ContentDeliveryRpcRemote(this.localPeerDescriptor, neighbor, this.rpcCommunicator, ContentDeliveryRpcClient);
+        const messages = this.latestMessages.get(msgChainId)?.filter((msg) => msg.messageId.timestamp > fromTimestamp) ?? [];
+        await Promise.all(messages.map((msg) => remote.sendStreamMessage(msg)));
+    }
+    async onMetadata(msg, previousNode) {
+        // If we receive newer metadata than messages in the buffer, resume the sending neighbor
+        const latestMessageTimestamp = this.getLatestMessageTimestamp(msg.messageChainId);
+        if (latestMessageTimestamp < msg.timestamp) {
+            if (!this.metadataTimestampsAheadOfRealData.has(msg.messageChainId)) {
+                this.metadataTimestampsAheadOfRealData.set(msg.messageChainId, new Set());
+            }
+            this.metadataTimestampsAheadOfRealData.get(msg.messageChainId).add(msg.timestamp);
+            if (this.metadataTimestampsAheadOfRealData.get(msg.messageChainId).size > 1) {
+                await this.resumeNeighbor(previousNode, msg.messageChainId, this.getLatestMessageTimestamp(msg.messageChainId));
+                this.metadataTimestampsAheadOfRealData.get(msg.messageChainId).forEach((timestamp) => {
+                    this.metadataTimestampsAheadOfRealData.get(msg.messageChainId).delete(timestamp);
+                });
+            }
+        }
+    }
+    createRemote(neighbor) {
+        return new PlumtreeRpcRemote(this.localPeerDescriptor, neighbor, this.rpcCommunicator, PlumtreeRpcClient);
+    }
+    broadcast(msg, previousNode) {
+        const messageChainId = msg.messageId.messageChainId;
+        if (!this.latestMessages.has(messageChainId)) {
+            this.latestMessages.set(messageChainId, []);
+        }
+        if (this.latestMessages.get(messageChainId).length < 20) {
+            this.latestMessages.get(messageChainId).push(msg);
+        }
+        else {
+            this.latestMessages.get(messageChainId).shift();
+            this.latestMessages.get(messageChainId).push(msg);
+        }
+        if (this.metadataTimestampsAheadOfRealData.has(msg.messageId.messageChainId)) {
+            this.metadataTimestampsAheadOfRealData.get(msg.messageId.messageChainId).delete(msg.messageId.timestamp);
+        }
+        this.emit('message', msg);
+        const neighbors = this.neighbors.getAll().filter((neighbor) => toNodeId(neighbor.getPeerDescriptor()) !== previousNode);
+        for (const neighbor of neighbors) {
+            if (this.localPausedNeighbors.isPaused(toNodeId(neighbor.getPeerDescriptor()), msg.messageId.messageChainId)) {
+                const remote = this.createRemote(neighbor.getPeerDescriptor());
+                setImmediate(() => remote.sendMetadata(msg.messageId));
+            }
+            else {
+                setImmediate(() => neighbor.sendStreamMessage(msg));
+            }
+        }
+    }
+    isNeighborPaused(node, msgChainId) {
+        return this.localPausedNeighbors.isPaused(toNodeId(node), msgChainId)
+            || this.remotePausedNeighbors.isPaused(toNodeId(node), msgChainId);
+    }
+    stop() {
+        this.neighbors.off('nodeRemoved', this.onNeighborRemoved);
+    }
+}
+
+const createConfigWithDefaults = (options) => {
+    const ownNodeId = toNodeId(options.localPeerDescriptor);
+    const rpcCommunicator = options.rpcCommunicator ?? new ListeningRpcCommunicator(formStreamPartContentDeliveryServiceId(options.streamPartId), options.transport);
+    const neighborTargetCount = options.neighborTargetCount ?? DEFAULT_NEIGHBOR_TARGET_COUNT;
+    const maxContactCount = options.maxContactCount ?? DEFAULT_NODE_VIEW_SIZE;
+    const acceptProxyConnections = options.acceptProxyConnections ?? DEFAULT_ACCEPT_PROXY_CONNECTIONS;
+    const neighborUpdateInterval = options.neighborUpdateInterval ?? DEFAULT_NEIGHBOR_UPDATE_INTERVAL;
+    const minPropagationTargets = options.minPropagationTargets ?? DEFAULT_MIN_PROPAGATION_TARGETS;
+    const maxPropagationBufferSize = options.maxPropagationBufferSize ?? DEFAULT_MAX_PROPAGATION_BUFFER_SIZE;
+    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();
+    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 plumtreeManager = options.plumtreeOptimization ? new PlumtreeManager({
+        neighbors,
+        localPeerDescriptor: options.localPeerDescriptor,
+        rpcCommunicator,
+        maxPausedNeighbors: options.plumtreeMaxPausedNeighbors
+    }) : undefined;
+    const propagation = options.propagation ?? new Propagation({
+        minPropagationTargets,
+        maxMessages: maxPropagationBufferSize,
+        ttl: DEFAULT_PROPAGATION_BUFFER_TTL,
+        sendToNeighbor: async (neighborId, msg) => {
+            const remote = neighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId);
+            const proxyConnection = proxyConnectionRpcLocal?.getConnection(neighborId);
+            if (remote) {
+                await remote.sendStreamMessage(msg, options.bufferWhileConnecting);
+            }
+            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,
+        plumtreeManager
+    };
+};
+const createContentDeliveryLayerNode = (options) => {
+    return new ContentDeliveryLayerNode(createConfigWithDefaults(options));
+};
+
+const logger$3 = new Logger('ProxyConnectionRpcRemote');
+class ProxyConnectionRpcRemote extends RpcRemote {
+    async requestConnection(userId, direction) {
+        const request = {
+            direction,
+            userId: toUserIdRaw(userId)
+        };
+        const options = this.formDhtRpcOptions({
+            timeout: EXISTING_CONNECTION_TIMEOUT
+        });
+        try {
+            const res = await this.getClient().requestConnection(request, options);
+            return res.accepted;
+        }
+        catch (err) {
+            logger$3.debug(`ProxyConnectionRequest failed with error`, { err });
+            return false;
+        }
+    }
+}
+
+// TODO use options option or named constant?
+const retry = async (task, description, abortSignal, delay = 10000) => {
+    while (true) {
+        try {
+            const result = await task();
+            return result;
+        }
+        catch {
+            logger$2.warn(`Failed ${description} (retrying after delay)`, {
+                delayInMs: delay
+            });
+        }
+        await wait(delay, abortSignal);
+    }
+};
+const logger$2 = new Logger('ProxyClient');
+const SERVICE_ID = 'system/proxy-client';
+class ProxyClient extends EventEmitter {
+    rpcCommunicator;
+    contentDeliveryRpcLocal;
+    options;
+    duplicateDetectors = new Map();
+    definition;
+    connections = new Map();
+    propagation;
+    neighbors;
+    abortController;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartContentDeliveryServiceId(options.streamPartId), options.transport);
+        // TODO use options option or named constant?
+        this.neighbors = new NodeList(toNodeId(this.options.localPeerDescriptor), 1000);
+        this.contentDeliveryRpcLocal = new ContentDeliveryRpcLocal({
+            localPeerDescriptor: this.options.localPeerDescriptor,
+            streamPartId: this.options.streamPartId,
+            markAndCheckDuplicate: (msg, prev) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
+            broadcast: (message, previousNode) => this.broadcast(message, previousNode),
+            onLeaveNotice: (remoteNodeId) => {
+                const contact = this.neighbors.get(remoteNodeId);
+                if (contact) {
+                    // TODO should we catch possible promise rejection?
+                    setImmediate(() => this.onNodeDisconnected(contact.getPeerDescriptor()));
+                }
+            },
+            rpcCommunicator: this.rpcCommunicator,
+            markForInspection: () => { }
+        });
+        this.propagation = new Propagation({
+            minPropagationTargets: options.minPropagationTargets,
+            maxMessages: options.maxPropagationBufferSize,
+            ttl: options.propagationBufferTtl,
+            sendToNeighbor: async (neighborId, msg) => {
+                const remote = this.neighbors.get(neighborId);
+                if (remote) {
+                    await remote.sendStreamMessage(msg);
+                }
+                else {
+                    throw new Error('Propagation target not found');
+                }
+            }
+        });
+        this.abortController = new AbortController();
+    }
+    registerDefaultServerMethods() {
+        this.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage', (msg, context) => this.contentDeliveryRpcLocal.sendStreamMessage(msg, context));
+        this.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice', (req, context) => this.contentDeliveryRpcLocal.leaveStreamPartNotice(req, context));
+    }
+    async setProxies(nodes, userId, direction, connectionCount) {
+        logger$2.trace('Setting proxies', { streamPartId: this.options.streamPartId, peerDescriptors: nodes, direction, userId, connectionCount });
+        if (connectionCount !== undefined && connectionCount > nodes.length) {
+            throw new Error('Cannot set connectionCount above the size of the configured array of nodes');
+        }
+        const nodesIds = new Map();
+        nodes.forEach((peerDescriptor) => {
+            nodesIds.set(toNodeId(peerDescriptor), peerDescriptor);
+        });
+        this.definition = {
+            nodes: nodesIds,
+            userId,
+            direction,
+            connectionCount: connectionCount ?? nodes.length
+        };
+        await this.updateConnections();
+    }
+    async updateConnections() {
+        await Promise.all(this.getInvalidConnections().map(async (id) => {
+            await this.closeConnection(id);
+        }));
+        const connectionCountDiff = this.definition.connectionCount - this.connections.size;
+        if (connectionCountDiff > 0) {
+            await this.openRandomConnections(connectionCountDiff);
+        }
+        else if (connectionCountDiff < 0) {
+            await this.closeRandomConnections(-connectionCountDiff);
+        }
+    }
+    getInvalidConnections() {
+        return Array.from(this.connections.keys()).filter((id) => {
+            return !this.definition.nodes.has(id)
+                || this.definition.direction !== this.connections.get(id).direction;
+        });
+    }
+    async openRandomConnections(connectionCount) {
+        const proxiesToAttempt = sampleSize(Array.from(this.definition.nodes.keys()).filter((id) => !this.connections.has(id)), connectionCount);
+        await Promise.all(proxiesToAttempt.map((id) => this.attemptConnection(id, this.definition.userId, this.definition.direction)));
+    }
+    async attemptConnection(nodeId, userId, direction) {
+        const peerDescriptor = this.definition.nodes.get(nodeId);
+        const rpcRemote = new ProxyConnectionRpcRemote(this.options.localPeerDescriptor, peerDescriptor, this.rpcCommunicator, ProxyConnectionRpcClient);
+        const accepted = await rpcRemote.requestConnection(userId, direction);
+        if (accepted) {
+            this.options.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID);
+            this.connections.set(nodeId, { peerDescriptor, direction });
+            const remote = new ContentDeliveryRpcRemote(this.options.localPeerDescriptor, peerDescriptor, this.rpcCommunicator, ContentDeliveryRpcClient);
+            this.neighbors.add(remote);
+            this.propagation.onNeighborJoined(nodeId);
+            logger$2.info('Open proxy connection', {
+                nodeId,
+                streamPartId: this.options.streamPartId
+            });
+        }
+        else {
+            logger$2.warn('Unable to open proxy connection', {
+                nodeId,
+                streamPartId: this.options.streamPartId
+            });
+        }
+    }
+    async closeRandomConnections(connectionCount) {
+        const proxiesToDisconnect = sampleSize(Array.from(this.connections.keys()), connectionCount);
+        await Promise.allSettled(proxiesToDisconnect.map((node) => this.closeConnection(node)));
+    }
+    async closeConnection(nodeId) {
+        if (this.connections.has(nodeId)) {
+            logger$2.info('Close proxy connection', {
+                nodeId
+            });
+            const server = this.neighbors.get(nodeId);
+            server?.leaveStreamPartNotice(this.options.streamPartId, false);
+            this.removeConnection(this.connections.get(nodeId).peerDescriptor);
+        }
+    }
+    removeConnection(peerDescriptor) {
+        const nodeId = toNodeId(peerDescriptor);
+        this.connections.delete(nodeId);
+        this.neighbors.remove(nodeId);
+        this.options.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID);
+    }
+    broadcast(msg, previousNode) {
+        if (!previousNode) {
+            markAndCheckDuplicate(this.duplicateDetectors, msg.messageId, msg.previousMessageRef);
+        }
+        this.emit('message', msg);
+        this.propagation.feedUnseenMessage(msg, this.neighbors.getIds(), previousNode ?? null);
+    }
+    hasConnection(nodeId, direction) {
+        return this.connections.has(nodeId) && this.connections.get(nodeId).direction === direction;
+    }
+    getDirection() {
+        return this.definition.direction;
+    }
+    async onNodeDisconnected(peerDescriptor) {
+        const nodeId = toNodeId(peerDescriptor);
+        if (this.connections.has(nodeId)) {
+            this.options.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID);
+            this.removeConnection(peerDescriptor);
+            await retry(() => this.updateConnections(), 'updating proxy connections', this.abortController.signal);
+        }
+    }
+    async start() {
+        this.registerDefaultServerMethods();
+        addManagedEventListener(this.options.transport, 'disconnected', 
+        // TODO should we catch possible promise rejection?
+        (peerDescriptor) => this.onNodeDisconnected(peerDescriptor), this.abortController.signal);
+    }
+    getDiagnosticInfo() {
+        return {
+            neighbors: this.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
+        };
+    }
+    stop() {
+        this.neighbors.getAll().forEach((remote) => {
+            this.options.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID);
+            remote.leaveStreamPartNotice(this.options.streamPartId, false);
+        });
+        this.neighbors.stop();
+        this.rpcCommunicator.destroy();
+        this.connections.clear();
+        this.abortController.abort();
+    }
+}
+
+const logger$1 = new Logger('ContentDeliveryManager');
+const streamPartIdToDataKey = (streamPartId) => {
+    return toDhtAddress(computeSha1(streamPartId));
+};
+class ContentDeliveryManager extends EventEmitter {
+    transport;
+    connectionLocker;
+    controlLayerNode;
+    metricsContext;
+    metrics;
+    options;
+    streamParts;
+    knownStreamPartEntryPoints = new Map();
+    started = false;
+    destroyed = false;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.streamParts = new Map();
+        this.metricsContext = options.metricsContext ?? new MetricsContext();
+        this.metrics = {
+            broadcastMessagesPerSecond: new RateMetric(),
+            broadcastBytesPerSecond: new RateMetric()
+        };
+        this.metricsContext.addMetrics('node', this.metrics);
+    }
+    async start(startedAndJoinedControlLayerNode, transport, connectionLocker) {
+        if (this.started || this.destroyed) {
+            return;
+        }
+        this.started = true;
+        this.controlLayerNode = startedAndJoinedControlLayerNode;
+        this.transport = transport;
+        this.connectionLocker = connectionLocker;
+    }
+    async destroy() {
+        if (!this.started || this.destroyed) {
+            return;
+        }
+        logger$1.trace('Destroying ContentDeliveryManager');
+        this.destroyed = true;
+        await Promise.all(Array.from(this.streamParts.values()).map((streamPart) => streamPart.stop()));
+        this.streamParts.clear();
+        this.removeAllListeners();
+        this.controlLayerNode = undefined;
+        this.transport = undefined;
+        this.connectionLocker = undefined;
+    }
+    broadcast(msg, streamPartDeliveryOptions) {
+        const streamPartId = toStreamPartID(msg.messageId.streamId, msg.messageId.streamPartition);
+        logger$1.debug(`Broadcasting to stream part ${streamPartId}`);
+        this.joinStreamPart(streamPartId, streamPartDeliveryOptions);
+        this.streamParts.get(streamPartId).broadcast(msg);
+        if (msg.body.oneofKind === 'contentMessage') {
+            this.metrics.broadcastMessagesPerSecond.record(1);
+            this.metrics.broadcastBytesPerSecond.record(msg.body.contentMessage.content.length);
+        }
+    }
+    async leaveStreamPart(streamPartId) {
+        const streamPart = this.streamParts.get(streamPartId);
+        if (streamPart) {
+            await streamPart.stop();
+            this.streamParts.delete(streamPartId);
+        }
+    }
+    joinStreamPart(streamPartId, streamPartDeliveryOptions) {
+        let streamPart = this.streamParts.get(streamPartId);
+        if (streamPart !== undefined) {
+            return;
+        }
+        logger$1.debug(`Join stream part ${streamPartId}`);
+        const discoveryLayerNode = this.createDiscoveryLayerNode(streamPartId, this.knownStreamPartEntryPoints.get(streamPartId) ?? []);
+        const peerDescriptorStoreManager = new PeerDescriptorStoreManager({
+            key: streamPartIdToDataKey(streamPartId),
+            localPeerDescriptor: this.getPeerDescriptor(),
+            fetchDataFromDht: (key) => this.controlLayerNode.fetchDataFromDht(key),
+            storeDataToDht: (key, data) => this.controlLayerNode.storeDataToDht(key, data),
+            deleteDataFromDht: async (key, waitForCompletion) => this.controlLayerNode.deleteDataFromDht(key, waitForCompletion)
+        });
+        const networkSplitAvoidance = new StreamPartNetworkSplitAvoidance({
+            discoveryLayerNode,
+            discoverEntryPoints: async () => peerDescriptorStoreManager.fetchNodes()
+        });
+        const node = this.createContentDeliveryLayerNode(streamPartId, discoveryLayerNode, () => peerDescriptorStoreManager.isLocalNodeStored(), streamPartDeliveryOptions);
+        const streamPartReconnect = new StreamPartReconnect(discoveryLayerNode, peerDescriptorStoreManager);
+        streamPart = {
+            proxied: false,
+            discoveryLayerNode,
+            node,
+            networkSplitAvoidance,
+            broadcast: (msg) => node.broadcast(msg),
+            stop: async () => {
+                streamPartReconnect.destroy();
+                networkSplitAvoidance.destroy();
+                await peerDescriptorStoreManager.destroy();
+                node.stop();
+                await discoveryLayerNode.stop();
+            },
+            getDiagnosticInfo: () => node.getDiagnosticInfo()
+        };
+        this.streamParts.set(streamPartId, streamPart);
+        node.on('message', (message) => {
+            this.emit('newMessage', message);
+        });
+        const handleEntryPointLeave = async () => {
+            if (this.destroyed || peerDescriptorStoreManager.isLocalNodeStored() || this.knownStreamPartEntryPoints.has(streamPartId)) {
+                return;
+            }
+            const entryPoints = await peerDescriptorStoreManager.fetchNodes();
+            if (entryPoints.length < MAX_NODE_COUNT) {
+                await peerDescriptorStoreManager.storeAndKeepLocalNode();
+            }
+        };
+        discoveryLayerNode.on('manualRejoinRequired', async () => {
+            if (!streamPartReconnect.isRunning() && !networkSplitAvoidance.isRunning()) {
+                logger$1.debug('Manual rejoin required for stream part', { streamPartId });
+                await streamPartReconnect.reconnect();
+            }
+        });
+        node.on('entryPointLeaveDetected', () => handleEntryPointLeave());
+        setImmediate(async () => {
+            try {
+                await this.startLayersAndJoinDht(streamPartId, peerDescriptorStoreManager);
+            }
+            catch (err) {
+                logger$1.warn(`Failed to join to stream part ${streamPartId}`, { err });
+            }
+        });
+    }
+    async startLayersAndJoinDht(streamPartId, peerDescriptorStoreManager) {
+        logger$1.debug(`Start layers and join DHT for stream part ${streamPartId}`);
+        const streamPart = this.streamParts.get(streamPartId);
+        if ((streamPart === undefined) || streamPart.proxied) {
+            // leaveStreamPart has been called (or leaveStreamPart called, and then setProxies called)
+            return;
+        }
+        if (this.transport.isPrivateClientMode()) {
+            await this.transport.disablePrivateClientMode();
+        }
+        await streamPart.discoveryLayerNode.start();
+        await streamPart.node.start();
+        const knownEntryPoints = this.knownStreamPartEntryPoints.get(streamPartId);
+        if (knownEntryPoints !== undefined) {
+            await Promise.all([
+                streamPart.discoveryLayerNode.joinDht(knownEntryPoints),
+                streamPart.discoveryLayerNode.joinRing()
+            ]);
+        }
+        else {
+            const entryPoints = await peerDescriptorStoreManager.fetchNodes();
+            await Promise.all([
+                streamPart.discoveryLayerNode.joinDht(sampleSize(entryPoints, MIN_NEIGHBOR_COUNT)),
+                streamPart.discoveryLayerNode.joinRing()
+            ]);
+            if (entryPoints.length < MAX_NODE_COUNT) {
+                await peerDescriptorStoreManager.storeAndKeepLocalNode();
+                if (streamPart.discoveryLayerNode.getNeighborCount() < MIN_NEIGHBOR_COUNT) {
+                    setImmediate(() => streamPart.networkSplitAvoidance.avoidNetworkSplit());
+                }
+            }
+        }
+    }
+    createDiscoveryLayerNode(streamPartId, entryPoints) {
+        return new DhtNode({
+            transport: this.controlLayerNode,
+            connectionsView: this.controlLayerNode.getConnectionsView(),
+            serviceId: 'layer1::' + streamPartId,
+            peerDescriptor: this.controlLayerNode.getLocalPeerDescriptor(),
+            entryPoints,
+            numberOfNodesPerKBucket: 4, // TODO use options option or named constant?
+            rpcRequestTimeout: EXISTING_CONNECTION_TIMEOUT,
+            dhtJoinTimeout: 20000, // TODO use options option or named constant?
+            periodicallyPingNeighbors: true,
+            periodicallyPingRingContacts: true,
+            neighborPingLimit: 16
+        });
+    }
+    createContentDeliveryLayerNode(streamPartId, discoveryLayerNode, isLocalNodeEntryPoint, streamPartDeliveryOptions) {
+        return createContentDeliveryLayerNode({
+            streamPartId,
+            transport: this.transport,
+            discoveryLayerNode,
+            connectionLocker: this.connectionLocker,
+            localPeerDescriptor: this.controlLayerNode.getLocalPeerDescriptor(),
+            minPropagationTargets: this.options.streamPartitionMinPropagationTargets,
+            neighborTargetCount: this.options.streamPartitionNeighborTargetCount,
+            maxPropagationBufferSize: this.options.streamPartitionMaxPropagationBufferSize,
+            acceptProxyConnections: this.options.acceptProxyConnections,
+            rpcRequestTimeout: this.options.rpcRequestTimeout,
+            neighborUpdateInterval: this.options.neighborUpdateInterval,
+            isLocalNodeEntryPoint,
+            bufferWhileConnecting: this.options.bufferWhileConnecting,
+            plumtreeOptimization: streamPartDeliveryOptions?.plumtreeOptimization?.enabled,
+            plumtreeMaxPausedNeighbors: streamPartDeliveryOptions?.plumtreeOptimization?.enabled === true ?
+                streamPartDeliveryOptions?.plumtreeOptimization?.maxPausedNeighbors : undefined
+        });
+    }
+    async setProxies(streamPartId, nodes, userId, direction, connectionCount) {
+        // TODO explicit default value for "acceptProxyConnections" or make it required
+        if (this.options.acceptProxyConnections) {
+            throw new Error('cannot set proxies when acceptProxyConnections=true');
+        }
+        const enable = (nodes.length > 0) && ((connectionCount === undefined) || (connectionCount > 0));
+        if (enable) {
+            let client;
+            const alreadyProxied = this.isProxiedStreamPart(streamPartId);
+            if (alreadyProxied) {
+                client = this.streamParts.get(streamPartId).client;
+            }
+            else {
+                client = this.createProxyClient(streamPartId);
+                this.streamParts.set(streamPartId, {
+                    proxied: true,
+                    client,
+                    broadcast: (msg) => client.broadcast(msg),
+                    stop: async () => client.stop(),
+                    getDiagnosticInfo: () => client.getDiagnosticInfo()
+                });
+                client.on('message', (message) => {
+                    this.emit('newMessage', message);
+                });
+                if (Array.from(this.streamParts.values()).every((streamPart) => streamPart.proxied)) {
+                    await this.transport.enablePrivateClientMode();
+                }
+                await client.start();
+            }
+            await client.setProxies(nodes, userId, direction, connectionCount);
+        }
+        else {
+            await this.streamParts.get(streamPartId)?.stop();
+            this.streamParts.delete(streamPartId);
+        }
+    }
+    createProxyClient(streamPartId) {
+        return new ProxyClient({
+            transport: this.transport,
+            localPeerDescriptor: this.controlLayerNode.getLocalPeerDescriptor(),
+            streamPartId,
+            connectionLocker: this.connectionLocker,
+            minPropagationTargets: this.options.streamPartitionMinPropagationTargets ?? DEFAULT_MIN_PROPAGATION_TARGETS,
+            maxPropagationBufferSize: this.options.streamPartitionMaxPropagationBufferSize ?? DEFAULT_MAX_PROPAGATION_BUFFER_SIZE,
+            propagationBufferTtl: DEFAULT_PROPAGATION_BUFFER_TTL
+        });
+    }
+    async inspect(peerDescriptor, streamPartId) {
+        const streamPart = this.streamParts.get(streamPartId);
+        if ((streamPart !== undefined) && !streamPart.proxied) {
+            return streamPart.node.inspect(peerDescriptor);
+        }
+        return false;
+    }
+    // TODO inline this method?
+    getNodeInfo() {
+        const streamParts = Array.from(this.streamParts.entries()).filter(([_, node]) => node.proxied === false);
+        return streamParts.map(([streamPartId]) => {
+            const stream = this.streamParts.get(streamPartId);
+            return {
+                id: streamPartId,
+                controlLayerNeighbors: stream.discoveryLayerNode.getNeighbors(),
+                deprecatedContentDeliveryLayerNeighbors: [],
+                contentDeliveryLayerNeighbors: stream.node.getInfos()
+            };
+        });
+    }
+    setStreamPartEntryPoints(streamPartId, entryPoints) {
+        this.knownStreamPartEntryPoints.set(streamPartId, entryPoints);
+    }
+    isProxiedStreamPart(streamPartId, direction) {
+        const streamPart = this.streamParts.get(streamPartId);
+        return (streamPart !== undefined)
+            && streamPart.proxied
+            && ((direction === undefined) || (streamPart.client.getDirection() === direction));
+    }
+    getStreamPartDelivery(streamPartId) {
+        return this.streamParts.get(streamPartId);
+    }
+    hasStreamPart(streamPartId) {
+        return this.streamParts.has(streamPartId);
+    }
+    getPeerDescriptor() {
+        return this.controlLayerNode.getLocalPeerDescriptor();
+    }
+    getNodeId() {
+        return toNodeId(this.controlLayerNode.getLocalPeerDescriptor());
+    }
+    getNeighbors(streamPartId) {
+        const streamPart = this.streamParts.get(streamPartId);
+        return streamPart?.proxied === false
+            ? streamPart.node.getNeighbors().map((n) => toNodeId(n))
+            : [];
+    }
+    getStreamParts() {
+        return Array.from(this.streamParts.keys()).map((id) => StreamPartIDUtils.parse(id));
+    }
+    getDiagnosticInfo() {
+        return {
+            streamParts: this.getStreamParts().map((id) => {
+                return {
+                    id,
+                    info: this.getStreamPartDelivery(id).getDiagnosticInfo()
+                };
+            })
+        };
+    }
+}
+
+class NodeInfoRpcRemote extends RpcRemote {
+    async getInfo() {
+        return this.getClient().getInfo({}, this.formDhtRpcOptions());
+    }
+}
+
+class NodeInfoClient {
+    ownPeerDescriptor;
+    rpcCommunicator;
+    constructor(ownPeerDescriptor, rpcCommunicator) {
+        this.ownPeerDescriptor = ownPeerDescriptor;
+        this.rpcCommunicator = rpcCommunicator;
+    }
+    async getInfo(node) {
+        const remote = new NodeInfoRpcRemote(this.ownPeerDescriptor, node, this.rpcCommunicator, NodeInfoRpcClient);
+        // TODO remove casting when we validate NodeInfoResponse messages and therefore can annotate
+        // each of the field as required in the decorated type
+        return remote.getInfo();
+    }
+}
+
+const NODE_INFO_RPC_SERVICE_ID = 'system/node-info-rpc';
+class NodeInfoRpcLocal {
+    stack;
+    rpcCommunicator;
+    constructor(stack, rpcCommunicator) {
+        this.stack = stack;
+        this.rpcCommunicator = rpcCommunicator;
+        this.registerDefaultServerMethods();
+    }
+    registerDefaultServerMethods() {
+        this.rpcCommunicator.registerRpcMethod(NodeInfoRequest, NodeInfoResponse, 'getInfo', () => this.getInfo());
+    }
+    async getInfo() {
+        return this.stack.createNodeInfo();
+    }
+}
+
+const logger = new Logger('NetworkStack');
+const instances = [];
+const stopInstances = async () => {
+    // make a clone so that it is ok for each instance.stop() to remove itself from the list (at line 139)
+    // while the map function is iterating the list
+    const clonedInstances = [...instances];
+    await Promise.all(clonedInstances.map((instance) => instance.stop()));
+};
+/**
+ * @todo The following cleanup logic is currently handled inside this module for both Node.js and
+ * browser environments. Consider refactoring it into a higher-level integration layer if lifecycle
+ * management is centralized elsewhere.
+ */
+if (typeof process === 'object' && typeof process?.on === 'function') {
+    /**
+     * @todo The `exit` event shouldn't use an async handler because the event loop is already
+     * shutting down, so async work won't complete. Calling `process.exit()` inside an `exit`
+     * handler is also redundant and may cause issues. Remove `exit` from `EXIT_EVENTS`
+     * or omit it entirely, since other signal handlers already terminate the process.
+     */
+    const EXIT_EVENTS = [`exit`, `SIGINT`, `SIGUSR1`, `SIGUSR2`, `uncaughtException`, `unhandledRejection`, `SIGTERM`];
+    EXIT_EVENTS.forEach((event) => {
+        /**
+         * @todo Registering handlers at module load time can cause side effects. Use explicit
+         * or lazy initialization to improve control and testability.
+         */
+        process.on(event, async (eventArg) => {
+            const isError = (event === 'uncaughtException') || (event === 'unhandledRejection');
+            if (isError) {
+                logger.error(`exit event: ${event}`, eventArg);
+            }
+            /**
+             * @todo Async `stopInstances()` may be interrupted by `process.exit()`. Use
+             * synchronous cleanup or a timeout, and wait for cleanup on graceful signals
+             * but exit quickly on error events.
+             */
+            await stopInstances();
+            process.exit(isError ? 1 : 0);
+        });
+    });
+}
+if (typeof window === 'object') {
+    /**
+     * @todo Registering handlers at module load time can cause side effects. Use explicit
+     * or lazy initialization to improve control and testability.
+     */
+    window.addEventListener('unload', async () => {
+        await stopInstances();
+    });
+}
+class NetworkStack {
+    controlLayerNode;
+    contentDeliveryManager;
+    stopped = false;
+    metricsContext;
+    options;
+    nodeInfoRpcLocal;
+    nodeInfoClient;
+    constructor(options) {
+        this.options = options;
+        this.metricsContext = options.metricsContext ?? new MetricsContext();
+        this.controlLayerNode = new DhtNode({
+            ...options.layer0,
+            metricsContext: this.metricsContext,
+            allowIncomingPrivateConnections: options.networkNode?.acceptProxyConnections
+        });
+        this.contentDeliveryManager = new ContentDeliveryManager({
+            ...options.networkNode,
+            metricsContext: this.metricsContext
+        });
+        instances.push(this);
+    }
+    async joinStreamPart(streamPartId, neighborRequirement, streamPartDeliveryOptions) {
+        if (this.getContentDeliveryManager().isProxiedStreamPart(streamPartId)) {
+            throw new Error(`Cannot join to ${streamPartId} as proxy connections have been set`);
+        }
+        await this.ensureConnectedToControlLayer();
+        this.getContentDeliveryManager().joinStreamPart(streamPartId, streamPartDeliveryOptions);
+        if (neighborRequirement !== undefined) {
+            await until(() => {
+                return this.getContentDeliveryManager().getNeighbors(streamPartId).length >= neighborRequirement.minCount;
+            }, neighborRequirement.timeout);
+        }
+    }
+    async broadcast(msg, streamPartDeliveryOptions) {
+        const streamPartId = toStreamPartID(msg.messageId.streamId, msg.messageId.streamPartition);
+        if (this.getContentDeliveryManager().isProxiedStreamPart(streamPartId, ProxyDirection.SUBSCRIBE)
+            && (msg.body.oneofKind === 'contentMessage')) {
+            throw new Error(`Cannot broadcast to ${streamPartId} as proxy subscribe connections have been set`);
+        }
+        // TODO could combine these two calls to isProxiedStreamPart?
+        if (!this.contentDeliveryManager.isProxiedStreamPart(streamPartId)) {
+            await this.ensureConnectedToControlLayer();
+        }
+        this.getContentDeliveryManager().broadcast(msg, streamPartDeliveryOptions);
+    }
+    async start(doJoin = true) {
+        logger.info('Starting a Streamr Network Node');
+        await this.controlLayerNode.start();
+        logger.info(`Node id is ${toNodeId(this.controlLayerNode.getLocalPeerDescriptor())}`);
+        const connectionManager = this.controlLayerNode.getTransport();
+        if ((this.options.layer0?.entryPoints?.some((entryPoint) => areEqualPeerDescriptors(entryPoint, this.controlLayerNode.getLocalPeerDescriptor())))) {
+            await this.controlLayerNode?.joinDht(this.options.layer0.entryPoints);
+        }
+        else if (doJoin) {
+            // in practice there aren't be existing connections and therefore this always connects
+            await this.ensureConnectedToControlLayer();
+        }
+        // TODO: remove undefined checks here. Assume that start is approproately awaited before stop is called.
+        await this.contentDeliveryManager?.start(this.controlLayerNode, connectionManager, connectionManager);
+        if (this.contentDeliveryManager) {
+            const infoRpcCommunicator = new ListeningRpcCommunicator(NODE_INFO_RPC_SERVICE_ID, this.getConnectionManager());
+            this.nodeInfoRpcLocal = new NodeInfoRpcLocal(this, infoRpcCommunicator);
+            this.nodeInfoClient = new NodeInfoClient(this.controlLayerNode.getLocalPeerDescriptor(), infoRpcCommunicator);
+        }
+    }
+    async ensureConnectedToControlLayer() {
+        // TODO we could wrap joinDht with pOnce and call it here (no else-if needed in that case)
+        if (!this.controlLayerNode.hasJoined()) {
+            setImmediate(async () => {
+                if (this.options.layer0?.entryPoints !== undefined) {
+                    // TODO should catch possible rejection?
+                    // the question mark is there to avoid problems when stop() is called before start()
+                    // -> TODO change to exlamation mark if we don't support that (and remove NetworkStackStoppedDuringStart.test)
+                    await this.controlLayerNode?.joinDht(this.options.layer0.entryPoints);
+                }
+            });
+            await this.controlLayerNode.waitForNetworkConnectivity();
+        }
+    }
+    getContentDeliveryManager() {
+        return this.contentDeliveryManager;
+    }
+    getControlLayerNode() {
+        return this.controlLayerNode;
+    }
+    getMetricsContext() {
+        return this.metricsContext;
+    }
+    async fetchNodeInfo(node) {
+        if (!areEqualPeerDescriptors(node, this.getControlLayerNode().getLocalPeerDescriptor())) {
+            return this.nodeInfoClient.getInfo(node);
+        }
+        else {
+            return this.createNodeInfo();
+        }
+    }
+    createNodeInfo() {
+        return {
+            peerDescriptor: this.getControlLayerNode().getLocalPeerDescriptor(),
+            controlLayer: {
+                connections: this.getControlLayerNode().getConnectionsView().getConnections(),
+                neighbors: this.getControlLayerNode().getNeighbors()
+            },
+            streamPartitions: this.getContentDeliveryManager().getNodeInfo(),
+            applicationVersion: version
+        };
+    }
+    getOptions() {
+        return this.options;
+    }
+    getConnectionManager() {
+        return this.controlLayerNode.getTransport();
+    }
+    async stop() {
+        if (!this.stopped) {
+            this.stopped = true;
+            pull(instances, this);
+            await this.contentDeliveryManager.destroy();
+            await this.controlLayerNode.stop();
+            this.contentDeliveryManager = undefined;
+            this.controlLayerNode = undefined;
+        }
+    }
+}
+
+const createNetworkNode = (opts) => {
+    return new NetworkNode(new NetworkStack(opts));
+};
+/**
+ * Convenience wrapper for building client-facing functionality. Used by client.
+ */
+class NetworkNode {
+    stack;
+    stopped = false;
+    externalNetworkRpc;
+    /** @internal */
+    constructor(stack) {
+        this.stack = stack;
+    }
+    async start(doJoin) {
+        await this.stack.start(doJoin);
+        this.externalNetworkRpc = new ExternalNetworkRpc(this.stack.getControlLayerNode().getTransport());
+    }
+    async inspect(node, streamPartId) {
+        return this.stack.getContentDeliveryManager().inspect(node, streamPartId);
+    }
+    async broadcast(msg, streamPartDeliveryOptions) {
+        await this.stack.broadcast(msg, streamPartDeliveryOptions);
+    }
+    async join(streamPartId, neighborRequirement, streamPartDeliveryOptions) {
+        await this.stack.joinStreamPart(streamPartId, neighborRequirement, streamPartDeliveryOptions);
+    }
+    async setProxies(streamPartId, nodes, userId, direction, connectionCount) {
+        await this.stack.getContentDeliveryManager().setProxies(streamPartId, nodes, userId, direction, connectionCount);
+    }
+    isProxiedStreamPart(streamPartId) {
+        return this.stack.getContentDeliveryManager().isProxiedStreamPart(streamPartId);
+    }
+    addMessageListener(listener) {
+        this.stack.getContentDeliveryManager().on('newMessage', listener);
+    }
+    setStreamPartEntryPoints(streamPartId, contactPeerDescriptors) {
+        this.stack.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, contactPeerDescriptors);
+    }
+    removeMessageListener(listener) {
+        this.stack.getContentDeliveryManager().off('newMessage', listener);
+    }
+    async leave(streamPartId) {
+        if (this.stopped) {
+            return;
+        }
+        await this.stack.getContentDeliveryManager().leaveStreamPart(streamPartId);
+    }
+    getNeighbors(streamPartId) {
+        return this.stack.getContentDeliveryManager().getNeighbors(streamPartId);
+    }
+    hasStreamPart(streamPartId) {
+        return this.stack.getContentDeliveryManager().hasStreamPart(streamPartId);
+    }
+    async stop() {
+        this.stopped = true;
+        this.externalNetworkRpc.destroy();
+        await this.stack.stop();
+    }
+    getPeerDescriptor() {
+        return this.stack.getControlLayerNode().getLocalPeerDescriptor();
+    }
+    getMetricsContext() {
+        return this.stack.getMetricsContext();
+    }
+    getNodeId() {
+        return this.stack.getContentDeliveryManager().getNodeId();
+    }
+    getOptions() {
+        return this.stack.getOptions();
+    }
+    getStreamParts() {
+        return this.stack.getContentDeliveryManager().getStreamParts();
+    }
+    async fetchNodeInfo(node) {
+        return this.stack.fetchNodeInfo(node);
+    }
+    getDiagnosticInfo() {
+        return {
+            controlLayer: this.stack.getControlLayerNode().getDiagnosticInfo(),
+            contentLayer: this.stack.getContentDeliveryManager().getDiagnosticInfo()
+        };
+    }
+    registerExternalNetworkRpcMethod(request, response, name, fn) {
+        this.externalNetworkRpc.registerRpcMethod(request, response, name, fn);
+    }
+    createExternalRpcClient(clientClass) {
+        return this.externalNetworkRpc.createRpcClient(clientClass);
+    }
+}
+
+export { AsymmetricEncryptionType, ContentType, ControlLayerInfo, EncryptedGroupKey, EncryptionType, GroupKeyRequest, GroupKeyResponse, MessageID, MessageRef, NetworkNode, NetworkStack, ProxyDirection, SignatureType, StreamMessage, createNetworkNode, streamPartIdToDataKey };
+//# sourceMappingURL=exports.js.map