@epfml/discojs 2.1.1 → 2.1.2-p20240506085037.0

package/dist/core/client/decentralized/base.js

@@ -1,212 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Base = void 0;
-var tslib_1 = require("tslib");
-var immutable_1 = require("immutable");
-var nodeUrl = (0, tslib_1.__importStar)(require("url"));
-var __1 = require("../..");
-var base_1 = require("../base");
-var peer_pool_1 = require("./peer_pool");
-var messages = (0, tslib_1.__importStar)(require("./messages"));
-var messages_1 = require("../messages");
-var event_connection_1 = require("../event_connection");
-var utils_1 = require("../utils");
-/**
- * Abstract class for decentralized clients, executes onRoundEndCommunication as well as connecting
- * to the signaling server
- */
-var Base = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(Base, _super);
-    function Base(url, task) {
-        var _a, _b;
-        var _this = _super.call(this, url, task) || this;
-        _this.url = url;
-        _this.task = task;
-        _this.minimumReadyPeers = (_b = (_a = _this.task.trainingInformation) === null || _a === void 0 ? void 0 : _a.minimumReadyPeers) !== null && _b !== void 0 ? _b : 3;
-        return _this;
-    }
-    // send message to server that client is ready
-    Base.prototype.waitForPeers = function (round) {
-        var _a;
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var msg, receivedMessage, peers, ret;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        console.debug(this.ID, 'is ready for round', round);
-                        // clean old round
-                        this.peers = undefined;
-                        msg = { type: messages_1.type.PeerIsReady };
-                        if (this.server === undefined) {
-                            throw new Error('server undefined, could not connect peers');
-                        }
-                        this.server.send(msg);
-                        return [4 /*yield*/, (0, event_connection_1.waitMessageWithTimeout)(this.server, messages_1.type.PeersForRound, utils_1.MAX_WAIT_PER_ROUND)];
-                    case 1:
-                        receivedMessage = _b.sent();
-                        peers = (0, immutable_1.Set)(receivedMessage.peers);
-                        if (this.ID !== undefined && peers.has(this.ID)) {
-                            throw new Error('received peer list contains our own id');
-                        }
-                        if (this.peers !== undefined) {
-                            throw new Error('got new peer list from server but was already received for this round');
-                        }
-                        if (peers.size + 1 < this.minimumReadyPeers) {
-                            throw new Error('new peer list do not contain enough ready peers');
-                        }
-                        this.peers = peers;
-                        console.debug(this.ID, 'got peers for round:', peers.toJS());
-                        if (this.pool === undefined) {
-                            throw new Error('waiting for peers but peer pool is undefined');
-                        }
-                        return [4 /*yield*/, this.pool];
-                    case 2: return [4 /*yield*/, (_b.sent()).getPeers((0, immutable_1.Set)((_a = this.peers) !== null && _a !== void 0 ? _a : []), this.server, function (p) { return _this.clientHandle(p); })];
-                    case 3:
-                        ret = _b.sent();
-                        console.debug(this.ID, "got peers for round " + round + ":", ret.keySeq().toJS());
-                        return [2 /*return*/, ret];
-                }
-            });
-        });
-    };
-    // TODO inline? have a serialization mod
-    Base.prototype.sendMessagetoPeer = function (peer, msg) {
-        console.debug(this.ID, 'sends message to peer', msg.peer, msg);
-        peer.send(msg);
-    };
-    /*
-    creation of the websocket for the server, connection of client to that webSocket,
-    deals with message reception from decentralized client perspective (messages received by client)
-     */
-    Base.prototype.connectServer = function (url) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var server;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, event_connection_1.WebSocketServer.connect(url, messages.isMessageFromServer, messages.isMessageToServer)];
-                    case 1:
-                        server = _a.sent();
-                        server.on(messages_1.type.SignalForPeer, function (event) {
-                            console.debug(_this.ID, 'got signal from', event.peer);
-                            if (_this.pool === undefined) {
-                                throw new Error('got signal but peer pool is undefined');
-                            }
-                            void _this.pool.then(function (pool) { return pool.signal(event.peer, event.signal); });
-                        });
-                        return [2 /*return*/, server];
-                }
-            });
-        });
-    };
-    /**
-     * Initialize the connection to the peers and to the other nodes.
-     */
-    Base.prototype.connect = function () {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var URL, serverURL, _a, msg, peerIdMsg;
-            return (0, tslib_1.__generator)(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        URL = typeof window !== 'undefined' ? window.URL : nodeUrl.URL;
-                        serverURL = new URL('', this.url.href);
-                        switch (this.url.protocol) {
-                            case 'http:':
-                                serverURL.protocol = 'ws:';
-                                break;
-                            case 'https:':
-                                serverURL.protocol = 'wss:';
-                                break;
-                            default:
-                                throw new Error("unknown protocol: " + this.url.protocol);
-                        }
-                        serverURL.pathname += "deai/" + this.task.taskID;
-                        _a = this;
-                        return [4 /*yield*/, this.connectServer(serverURL)];
-                    case 1:
-                        _a.server = _b.sent();
-                        msg = {
-                            type: messages_1.type.clientConnected
-                        };
-                        this.server.send(msg);
-                        return [4 /*yield*/, (0, event_connection_1.waitMessage)(this.server, messages_1.type.PeerID)];
-                    case 2:
-                        peerIdMsg = _b.sent();
-                        console.debug(peerIdMsg.id, 'got own id from server');
-                        if (this.ID !== undefined) {
-                            throw new Error('got ID from server but was already received');
-                        }
-                        this.ID = peerIdMsg.id;
-                        this.pool = peer_pool_1.PeerPool.init(peerIdMsg.id);
-                        this.connected = true; // Is this still needed?
-                        console.debug(this.ID, 'client connected to server');
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    // disconnect from server & peers
-    Base.prototype.disconnect = function () {
-        var _a, _b;
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            return (0, tslib_1.__generator)(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        console.debug(this.ID, 'disconnect');
-                        return [4 /*yield*/, this.pool];
-                    case 1:
-                        (_a = (_c.sent())) === null || _a === void 0 ? void 0 : _a.shutdown();
-                        this.pool = undefined;
-                        (_b = this.server) === null || _b === void 0 ? void 0 : _b.disconnect();
-                        this.server = undefined;
-                        this.connected = false;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Base.prototype.onTrainEndCommunication = function (_, trainingInformant) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            return (0, tslib_1.__generator)(this, function (_a) {
-                // TODO: enter seeding mode?
-                trainingInformant.addMessage('Training finished.');
-                return [2 /*return*/];
-            });
-        });
-    };
-    Base.prototype.onRoundEndCommunication = function (updatedWeights, staleWeights, round, trainingInformant) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var peers, noisyWeights, finalWeights, e_1, msg;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, this.waitForPeers(round)
-                            // centralized phase of communication --> client tells server that they have finished a local round and are ready to aggregate
-                            // Apply clipping and DP to updates that will be sent
-                        ];
-                    case 1:
-                        peers = _a.sent();
-                        noisyWeights = __1.privacy.addDifferentialPrivacy(updatedWeights, staleWeights, this.task);
-                        return [4 /*yield*/, this.sendAndReceiveWeights(peers, noisyWeights, round, trainingInformant)];
-                    case 2:
-                        finalWeights = _a.sent();
-                        console.debug(this.ID, 'sent and received', finalWeights.size, 'weights at round', round);
-                        return [2 /*return*/, __1.aggregation.avg(finalWeights)];
-                    case 3:
-                        e_1 = _a.sent();
-                        msg = "errored on round " + round;
-                        if (e_1 instanceof Error) {
-                            msg += ": " + e_1.message;
-                        }
-                        console.warn(this.ID, msg);
-                        return [2 /*return*/, updatedWeights];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return Base;
-}(base_1.Base));
-exports.Base = Base;

package/dist/core/client/decentralized/clear_text.d.ts

@@ -1,14 +0,0 @@
-import { List, Map } from 'immutable';
-import { TrainingInformant, WeightsContainer } from '../..';
-import { Base } from './base';
-import { PeerID } from './types';
-import { PeerConnection } from '../event_connection';
-/**
- * Decentralized client that does not utilize secure aggregation, but sends model updates in clear text
- */
-export declare class ClearText extends Base {
-    private receivedWeights?;
-    sendAndReceiveWeights(peers: Map<PeerID, PeerConnection>, noisyWeights: WeightsContainer, round: number, trainingInformant: TrainingInformant): Promise<List<WeightsContainer>>;
-    private receiveWeights;
-    clientHandle(peers: Map<PeerID, PeerConnection>): void;
-}

package/dist/core/client/decentralized/clear_text.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClearText = void 0;
-var tslib_1 = require("tslib");
-var immutable_1 = require("immutable");
-var __1 = require("../..");
-var base_1 = require("./base");
-var messages_1 = require("../messages");
-var event_connection_1 = require("../event_connection");
-/**
- * Decentralized client that does not utilize secure aggregation, but sends model updates in clear text
- */
-var ClearText = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(ClearText, _super);
-    function ClearText() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    ClearText.prototype.sendAndReceiveWeights = function (peers, noisyWeights, round, trainingInformant) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var weights, ret;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.receivedWeights) {
-                            throw new Error('no promise setup for receiving weights');
-                        }
-                        // PHASE 1 COMMUNICATION --> create weights message and send to all peers (only one phase of communication for clear_text)
-                        // send weights asynchronously
-                        __1.serialization.weights.encode(noisyWeights).then(function (encodedWeights) {
-                            // create weights message and send to all peers
-                            peers.forEach(function (peer, id) {
-                                return _this.sendMessagetoPeer(peer, {
-                                    type: messages_1.type.Weights,
-                                    peer: id,
-                                    weights: encodedWeights
-                                });
-                            });
-                        }).catch(function () {
-                            throw new Error('error while sending weights');
-                        });
-                        return [4 /*yield*/, this.receivedWeights];
-                    case 1:
-                        weights = _a.sent();
-                        trainingInformant.update({
-                            currentNumberOfParticipants: weights.size + 1
-                        });
-                        ret = weights.push(noisyWeights);
-                        this.receivedWeights = undefined;
-                        return [2 /*return*/, ret];
-                }
-            });
-        });
-    };
-    ClearText.prototype.receiveWeights = function (peers) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var waitWeights, receivedWeights;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        console.debug('beginning of receiveWeights');
-                        waitWeights = Array.from(peers.values()).map(function (peer) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
-                            return (0, tslib_1.__generator)(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, (0, event_connection_1.waitMessage)(peer, messages_1.type.Weights)];
-                                    case 1: return [2 /*return*/, _a.sent()];
-                                }
-                            });
-                        }); });
-                        receivedWeights = (0, immutable_1.List)();
-                        return [4 /*yield*/, Promise.allSettled(waitWeights)];
-                    case 1: return [4 /*yield*/, (_a.sent()).forEach(function (message) {
-                            if (message.status === 'fulfilled') {
-                                receivedWeights = receivedWeights.push(__1.serialization.weights.decode(message.value.weights));
-                            }
-                        })];
-                    case 2:
-                        _a.sent();
-                        if (receivedWeights.size < peers.size) {
-                            throw new Error('not enough peer weights received');
-                        }
-                        return [2 /*return*/, receivedWeights];
-                }
-            });
-        });
-    };
-    /*
-      handles received messages from signaling server
-   */
-    ClearText.prototype.clientHandle = function (peers) {
-        this.receivedWeights = this.receiveWeights(peers);
-    };
-    return ClearText;
-}(base_1.Base));
-exports.ClearText = ClearText;

package/dist/core/client/decentralized/index.d.ts

@@ -1,4 +0,0 @@
-export { ClearText } from './clear_text';
-export { SecAgg } from './sec_agg';
-export * as messages from './messages';
-export { PeerID } from './types';

package/dist/core/client/decentralized/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.messages = exports.SecAgg = exports.ClearText = void 0;
-var tslib_1 = require("tslib");
-var clear_text_1 = require("./clear_text");
-Object.defineProperty(exports, "ClearText", { enumerable: true, get: function () { return clear_text_1.ClearText; } });
-var sec_agg_1 = require("./sec_agg");
-Object.defineProperty(exports, "SecAgg", { enumerable: true, get: function () { return sec_agg_1.SecAgg; } });
-exports.messages = (0, tslib_1.__importStar)(require("./messages"));

package/dist/core/client/decentralized/messages.d.ts

@@ -1,41 +0,0 @@
-import { SignalData } from 'simple-peer';
-import { weights } from '../../serialization';
-import { PeerID as PeerIDType } from './types';
-import { type, clientConnected } from '../messages';
-export interface PeerID {
-    type: type.PeerID;
-    id: PeerIDType;
-}
-export interface SignalForPeer {
-    type: type.SignalForPeer;
-    peer: PeerIDType;
-    signal: SignalData;
-}
-export interface PeerIsReady {
-    type: type.PeerIsReady;
-}
-export interface PeersForRound {
-    type: type.PeersForRound;
-    peers: PeerIDType[];
-}
-export interface Weights {
-    type: type.Weights;
-    peer: PeerIDType;
-    weights: weights.Encoded;
-}
-export interface Shares {
-    type: type.Shares;
-    peer: PeerIDType;
-    weights: weights.Encoded;
-}
-export interface PartialSums {
-    type: type.PartialSums;
-    peer: PeerIDType;
-    partials: weights.Encoded;
-}
-export declare type MessageFromServer = PeerID | SignalForPeer | PeersForRound;
-export declare type MessageToServer = clientConnected | SignalForPeer | PeerIsReady;
-export declare type PeerMessage = Weights | Shares | PartialSums;
-export declare function isMessageFromServer(o: unknown): o is MessageFromServer;
-export declare function isMessageToServer(o: unknown): o is MessageToServer;
-export declare function isPeerMessage(o: unknown): o is PeerMessage;

package/dist/core/client/decentralized/messages.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPeerMessage = exports.isMessageToServer = exports.isMessageFromServer = void 0;
-var serialization_1 = require("../../serialization");
-var types_1 = require("./types");
-var messages_1 = require("../messages");
-function isMessageFromServer(o) {
-    if (!(0, messages_1.hasMessageType)(o)) {
-        return false;
-    }
-    switch (o.type) {
-        case messages_1.type.PeerID:
-            return 'id' in o && (0, types_1.isPeerID)(o.id);
-        case messages_1.type.SignalForPeer:
-            return 'peer' in o && (0, types_1.isPeerID)(o.peer) &&
-                'signal' in o; // TODO check signal content?
-        case messages_1.type.PeersForRound:
-            return 'peers' in o && Array.isArray(o.peers) && o.peers.every(types_1.isPeerID);
-    }
-    return false;
-}
-exports.isMessageFromServer = isMessageFromServer;
-function isMessageToServer(o) {
-    if (!(0, messages_1.hasMessageType)(o)) {
-        return false;
-    }
-    switch (o.type) {
-        case messages_1.type.clientConnected:
-            return true;
-        case messages_1.type.SignalForPeer:
-            return 'peer' in o && (0, types_1.isPeerID)(o.peer) &&
-                'signal' in o; // TODO check signal content?
-        case messages_1.type.PeerIsReady:
-            return true;
-    }
-    return false;
-}
-exports.isMessageToServer = isMessageToServer;
-function isPeerMessage(o) {
-    if (!(0, messages_1.hasMessageType)(o)) {
-        return false;
-    }
-    switch (o.type) {
-        case messages_1.type.Weights:
-        case messages_1.type.Shares:
-            return 'peer' in o && (0, types_1.isPeerID)(o.peer) &&
-                'weights' in o && serialization_1.weights.isEncoded(o.weights);
-        case messages_1.type.PartialSums:
-            return 'peer' in o && (0, types_1.isPeerID)(o.peer) &&
-                'partials' in o && serialization_1.weights.isEncoded(o.partials);
-    }
-    return false;
-}
-exports.isPeerMessage = isPeerMessage;

package/dist/core/client/decentralized/peer.d.ts

@@ -1,26 +0,0 @@
-/// <reference types="node" />
-import SimplePeer, { SignalData } from 'simple-peer';
-import { PeerID } from './types';
-interface Events {
-    'close': () => void;
-    'connect': () => void;
-    'signal': (signal: SignalData) => void;
-    'data': (data: Buffer) => void;
-}
-export declare class Peer {
-    readonly id: PeerID;
-    private readonly peer;
-    private bufferSize?;
-    private sendCounter;
-    private sendQueue;
-    private receiving;
-    constructor(id: PeerID, opts?: SimplePeer.Options);
-    send(msg: Buffer): void;
-    private flush;
-    get maxChunkSize(): number;
-    private chunk;
-    destroy(): void;
-    signal(signal: SimplePeer.SignalData): void;
-    on<K extends keyof Events>(event: K, listener: Events[K]): void;
-}
-export {};

package/dist/core/client/decentralized/peer.js

@@ -1,210 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Peer = void 0;
-var tslib_1 = require("tslib");
-var immutable_1 = require("immutable");
-var simple_peer_1 = (0, tslib_1.__importDefault)(require("simple-peer"));
-// message id + (chunk counter == 0) + chunk count
-var FIRST_HEADER_SIZE = 2 + 1 + 1;
-// message id + chunk counter
-var HEADER_SIZE = 2 + 1;
-// at which interval to poll
-var TICK = 10;
-// Peer wraps a SimplePeer, adding message fragmentation
-//
-// WebRTC implementations have various maximum message size
-// but with huge models, our messages might be bigger.
-// We split messages by chunks and reconstruct theses
-// on the other side.
-//
-// As the WebRTC's DataChannel is not a stream, we need
-// reorder messages, so we use a header on each chunk
-// with a message id and chunk counter. The first chunk
-// (chunk counter == 0), also add the total number of chunk.
-//
-// see feross/simple-peer#393 for more info
-var Peer = /** @class */ (function () {
-    function Peer(id, opts) {
-        this.sendCounter = 0;
-        this.sendQueue = (0, immutable_1.List)();
-        this.receiving = (0, immutable_1.Map)();
-        this.id = id;
-        this.peer = new simple_peer_1.default(opts);
-    }
-    Peer.prototype.send = function (msg) {
-        console.debug('sending message of size', msg.length);
-        var chunks = this.chunk(msg);
-        this.sendQueue = this.sendQueue.concat(chunks);
-        this.flush();
-    };
-    Peer.prototype.flush = function () {
-        var _this = this;
-        if (this.bufferSize === undefined) {
-            throw new Error('flush without known buffer size');
-        }
-        var chunk = this.sendQueue.first();
-        if (chunk === undefined) {
-            return; // nothing to flush
-        }
-        var remainingBufferSize = this.bufferSize - this.peer.bufferSize;
-        if (chunk.length > remainingBufferSize) {
-            setTimeout(function () { return _this.flush(); }, TICK);
-            return;
-        }
-        console.debug('sending chunk of size', chunk.length);
-        this.sendQueue = this.sendQueue.shift();
-        this.peer.send(chunk);
-        // and loop
-        this.flush();
-    };
-    Object.defineProperty(Peer.prototype, "maxChunkSize", {
-        get: function () {
-            if (this.bufferSize === undefined) {
-                throw new Error('chunk without known buffer size');
-            }
-            // in the perfect world of bug-free implementations
-            // we would return this.bufferSize
-            // sadly, we are not there yet
-            //
-            // based on MDN, taking 16K seems to be a pretty safe
-            // and widely supported buffer size
-            return 16 * (1 << 10);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Peer.prototype.chunk = function (b) {
-        var _this = this;
-        var messageID = this.sendCounter;
-        this.sendCounter++;
-        if (this.sendCounter > 0xFFFF) {
-            throw new Error('too much messages sent to this peer');
-        }
-        // special case as Range(1, 0) yields a value
-        var tail = immutable_1.Seq.Indexed([]);
-        if (b.length > this.maxChunkSize) {
-            tail = (0, immutable_1.Range)(this.maxChunkSize - FIRST_HEADER_SIZE, b.length, this.maxChunkSize - HEADER_SIZE).map(function (offset) { return b.subarray(offset, offset + _this.maxChunkSize - HEADER_SIZE); });
-        }
-        var totalChunkCount = 1 + tail.count();
-        if (totalChunkCount > 0xFF) {
-            throw new Error('too big message to even chunk it');
-        }
-        var firstChunk = Buffer.alloc((b.length > this.maxChunkSize - FIRST_HEADER_SIZE)
-            ? this.maxChunkSize
-            : FIRST_HEADER_SIZE + b.length);
-        firstChunk.writeUint16BE(messageID);
-        firstChunk.writeUint8(0, 2);
-        firstChunk.writeUint8(totalChunkCount, 3);
-        b.copy(firstChunk, FIRST_HEADER_SIZE, 0, this.maxChunkSize - FIRST_HEADER_SIZE);
-        return immutable_1.Seq.Indexed([firstChunk])
-            .concat((0, immutable_1.Range)(1).zip(tail)
-            .map(function (_a) {
-            var _b = (0, tslib_1.__read)(_a, 2), id = _b[0], raw = _b[1];
-            var chunk = Buffer.alloc(HEADER_SIZE + raw.length);
-            chunk.writeUint16BE(messageID);
-            chunk.writeUint8(id, 2);
-            raw.copy(chunk, HEADER_SIZE, 0);
-            return chunk;
-        }));
-    };
-    Peer.prototype.destroy = function () {
-        this.peer.destroy();
-    };
-    Peer.prototype.signal = function (signal) {
-        // extract max buffer size
-        if (signal.type === 'offer' || signal.type === 'answer') {
-            if (signal.sdp === undefined) {
-                throw new Error('signal answer|offer without session description');
-            }
-            if (this.bufferSize !== undefined) {
-                throw new Error('buffer size set twice');
-            }
-            var match = signal.sdp.match(/a=max-message-size:(\d+)/);
-            if (match === null) {
-                // TODO default value instead?
-                throw new Error('no max-message-size found in signal');
-            }
-            var max = parseInt(match[1], 10);
-            if (isNaN(max)) {
-                throw new Error("unable to parse max-message-size as int: " + match[1]);
-            }
-            this.bufferSize = max;
-        }
-        this.peer.signal(signal);
-    };
-    Peer.prototype.on = function (event, listener) {
-        var _this = this;
-        if (event !== 'data') {
-            this.peer.on(event, listener);
-            return;
-        }
-        this.peer.on('data', function (data) {
-            if (!Buffer.isBuffer(data) || data.length < HEADER_SIZE) {
-                throw new Error('received invalid message type');
-            }
-            var messageID = data.readUint16BE();
-            var chunkID = data.readUint8(2);
-            var received = _this.receiving.get(messageID, {
-                total: undefined,
-                chunks: (0, immutable_1.Map)()
-            });
-            var total = received.total;
-            var chunks = received.chunks;
-            if (chunks.has(chunkID)) {
-                throw new Error("chunk " + messageID + ":" + chunkID + " already received");
-            }
-            var chunk;
-            if (chunkID !== 0) {
-                chunk = Buffer.alloc(data.length - HEADER_SIZE);
-                data.copy(chunk, 0, HEADER_SIZE);
-            }
-            else {
-                if (data.length < FIRST_HEADER_SIZE) {
-                    throw new Error('received invalid message type');
-                }
-                if (total !== undefined) {
-                    throw new Error('first header received twice');
-                }
-                var readTotal_1 = data.readUint8(3);
-                total = readTotal_1;
-                chunk = Buffer.alloc(data.length - FIRST_HEADER_SIZE);
-                data.copy(chunk, 0, FIRST_HEADER_SIZE);
-                if (chunks.keySeq().some(function (id) { return id > readTotal_1; })) {
-                    throw new Error('received total of chunk but got now-out-of-bound chunks');
-                }
-            }
-            _this.receiving = _this.receiving.set(messageID, {
-                total: total,
-                chunks: chunks.set(chunkID, chunk)
-            });
-            console.debug("got chunk " + messageID + ":" + chunkID + "/" + (total !== null && total !== void 0 ? total : 'unknown') + " of size " + chunk.length);
-            var readyMessages = _this.receiving
-                .filter(function (_a) {
-                var total = _a.total, chunks = _a.chunks;
-                return total !== undefined && chunks.size === total;
-            })
-                .sort()
-                .map(function (_a) {
-                var chunks = _a.chunks;
-                return chunks.entrySeq().toList().sortBy(function (_a) {
-                    var _b = (0, tslib_1.__read)(_a, 2), id = _b[0], _ = _b[1];
-                    return id;
-                });
-            })
-                .map(function (chunks) { return Buffer.concat(chunks.map(function (_a) {
-                var _b = (0, tslib_1.__read)(_a, 2), _ = _b[0], b = _b[1];
-                return b;
-            }).toArray()); });
-            _this.receiving = _this.receiving.deleteAll(readyMessages.keys());
-            readyMessages
-                .forEach(function (message) {
-                console.debug(_this.peer.address().port, 'recved message of size', message.length);
-                // TODO debug
-                // @ts-expect-error
-                listener(message);
-            });
-        });
-    };
-    return Peer;
-}());
-exports.Peer = Peer;