@epfml/discojs 2.0.0 → 2.1.2-p20240506085037.0

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

@@ -1,14 +0,0 @@
-import { Map, Set } from 'immutable';
-import { SignalData } from 'simple-peer';
-import { PeerID } from './types';
-import { PeerConnection, EventConnection } from '../event_connection';
-export declare class PeerPool {
-    private readonly id;
-    private readonly wrtc?;
-    private peers;
-    private constructor();
-    static init(id: PeerID): Promise<PeerPool>;
-    shutdown(): void;
-    signal(peerID: PeerID, signal: SignalData): void;
-    getPeers(peersToConnect: Set<PeerID>, signallingServer: EventConnection, clientHandle: (connections: Map<PeerID, PeerConnection>) => void): Promise<Map<PeerID, PeerConnection>>;
-}

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

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PeerPool = void 0;
-var tslib_1 = require("tslib");
-var immutable_1 = require("immutable");
-var peer_1 = require("./peer");
-var event_connection_1 = require("../event_connection");
-// TODO cleanup old peers
-var PeerPool = /** @class */ (function () {
-    function PeerPool(id, wrtc) {
-        this.id = id;
-        this.wrtc = wrtc;
-        this.peers = (0, immutable_1.Map)();
-    }
-    PeerPool.init = function (id) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var wrtc, path, e_1;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        path = require.resolve('@koush/wrtc', { paths: ['.'] });
-                        return [4 /*yield*/, Promise.resolve().then(function () { return (0, tslib_1.__importStar)(require(path)); })];
-                    case 1:
-                        wrtc = _a.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        e_1 = _a.sent();
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/, new PeerPool(id, wrtc)];
-                }
-            });
-        });
-    };
-    PeerPool.prototype.shutdown = function () {
-        console.debug(this.id, 'shutdown their peers');
-        this.peers.forEach(function (peer) { return peer.disconnect(); });
-        this.peers = (0, immutable_1.Map)();
-    };
-    PeerPool.prototype.signal = function (peerID, signal) {
-        console.debug(this.id, 'signals for', peerID);
-        var peer = this.peers.get(peerID);
-        if (peer === undefined) {
-            throw new Error("received signal for unknown peer: " + peerID);
-        }
-        peer.signal(signal);
-    };
-    PeerPool.prototype.getPeers = function (peersToConnect, signallingServer, 
-    // TODO as event?
-    clientHandle) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var newPeers, newPeersConnections;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (peersToConnect.contains(this.id)) {
-                            throw new Error('peers to connect contains our id');
-                        }
-                        console.debug(this.id, 'is connecting peers:', peersToConnect.toJS());
-                        newPeers = (0, immutable_1.Map)(peersToConnect
-                            .filter(function (id) { return !_this.peers.has(id); })
-                            .map(function (id) { return [id, id < _this.id]; })
-                            .map(function (_a) {
-                            var _b = (0, tslib_1.__read)(_a, 2), id = _b[0], initiator = _b[1];
-                            var p = new peer_1.Peer(id, { initiator: initiator, wrtc: _this.wrtc });
-                            // onNewPeer(id, p)
-                            return [id, p];
-                        }));
-                        console.debug(this.id, 'asked to connect new peers:', newPeers.keySeq().toJS());
-                        newPeersConnections = newPeers.map(function (peer, id) { return new event_connection_1.PeerConnection(_this.id, peer, signallingServer); });
-                        // adding peers to pool before connecting them because they must be set to call signal on them
-                        this.peers = this.peers.merge(newPeersConnections);
-                        clientHandle(this.peers);
-                        return [4 /*yield*/, Promise.all(Array.from(newPeersConnections.values()).map(function (connection) { 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*/, connection.connect()];
-                                    case 1: return [2 /*return*/, _a.sent()];
-                                }
-                            }); }); }))];
-                    case 1:
-                        _a.sent();
-                        console.debug(this.id, 'knowns connected peers:', this.peers.keySeq().toJS());
-                        return [2 /*return*/, this.peers
-                                .filter(function (_, id) { return peersToConnect.has(id); })];
-                }
-            });
-        });
-    };
-    return PeerPool;
-}());
-exports.PeerPool = PeerPool;

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

@@ -1,22 +0,0 @@
-import { List, Map } from 'immutable';
-import { Task, TrainingInformant, WeightsContainer } from '../..';
-import { Base } from './base';
-import { PeerID } from './types';
-import { PeerConnection } from '../event_connection';
-/**
- * Decentralized client that utilizes secure aggregation so client updates remain private
- */
-export declare class SecAgg extends Base {
-    readonly url: URL;
-    readonly task: Task;
-    private readonly maxShareValue;
-    private receivedShares?;
-    private receivedPartialSums?;
-    constructor(url: URL, task: Task);
-    private sendShares;
-    private sendPartialSums;
-    sendAndReceiveWeights(peers: Map<PeerID, PeerConnection>, noisyWeights: WeightsContainer, round: number, trainingInformant: TrainingInformant): Promise<List<WeightsContainer>>;
-    private receiveShares;
-    private receivePartials;
-    clientHandle(peers: Map<PeerID, PeerConnection>): void;
-}

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

@@ -1,190 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SecAgg = 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 secret_shares = (0, tslib_1.__importStar)(require("./secret_shares"));
-var event_connection_1 = require("../event_connection");
-/**
- * Decentralized client that utilizes secure aggregation so client updates remain private
- */
-var SecAgg = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(SecAgg, _super);
-    function SecAgg(url, task) {
-        var _a, _b;
-        var _this = _super.call(this, url, task) || this;
-        _this.url = url;
-        _this.task = task;
-        _this.maxShareValue = (_b = (_a = _this.task.trainingInformation) === null || _a === void 0 ? void 0 : _a.maxShareValue) !== null && _b !== void 0 ? _b : 100;
-        return _this;
-    }
-    /*
-    generates shares and sends to all ready peers adds differential privacy
-     */
-    SecAgg.prototype.sendShares = function (peers, weightShares, round, trainingInformant) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var encodedWeightShares, _a;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = immutable_1.List;
-                        return [4 /*yield*/, Promise.all(weightShares.rest().map(function (weights) { 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*/, __1.serialization.weights.encode(weights)];
-                                    case 1: return [2 /*return*/, _a.sent()];
-                                }
-                            }); }); }))];
-                    case 1:
-                        encodedWeightShares = _a.apply(void 0, [_b.sent()]);
-                        // Broadcast our weights to ith peer in the SERVER LIST OF PEERS (seen in signaling_server.ts)
-                        peers
-                            .entrySeq()
-                            .toSeq()
-                            .zip(encodedWeightShares)
-                            .forEach(function (_a) {
-                            var _b = (0, tslib_1.__read)(_a, 2), _c = (0, tslib_1.__read)(_b[0], 2), id = _c[0], peer = _c[1], weights = _b[1];
-                            return _this.sendMessagetoPeer(peer, {
-                                type: messages_1.type.Shares,
-                                peer: id,
-                                weights: weights
-                            });
-                        });
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /*
-  sends partial sums to connected peers so final update can be calculated
-   */
-    SecAgg.prototype.sendPartialSums = function (partial, peers) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var myEncodedSum;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, __1.serialization.weights.encode(partial)
-                        // calculate, encode, and send sum
-                    ];
-                    case 1:
-                        myEncodedSum = _a.sent();
-                        // calculate, encode, and send sum
-                        peers.forEach(function (peer, id) {
-                            return _this.sendMessagetoPeer(peer, {
-                                type: messages_1.type.PartialSums,
-                                peer: id,
-                                partials: myEncodedSum
-                            });
-                        });
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SecAgg.prototype.sendAndReceiveWeights = function (peers, noisyWeights, round, trainingInformant) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var weightShares, shares, mySum, partials;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.receivedShares || !this.receivedPartialSums) {
-                            throw new Error('no promise setup for receiving weights');
-                        }
-                        weightShares = secret_shares.generateAllShares(noisyWeights, peers.size + 1, this.maxShareValue);
-                        return [4 /*yield*/, this.sendShares(peers, weightShares, round, trainingInformant)];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.receivedShares
-                            // add own share to list
-                        ];
-                    case 2:
-                        shares = _a.sent();
-                        // add own share to list
-                        shares = shares.insert(0, weightShares.first());
-                        mySum = __1.aggregation.sum(shares);
-                        void this.sendPartialSums(mySum, peers);
-                        return [4 /*yield*/, this.receivedPartialSums];
-                    case 3:
-                        partials = _a.sent();
-                        partials = partials.insert(0, mySum);
-                        trainingInformant.update({
-                            currentNumberOfParticipants: partials.size
-                        });
-                        // resets state
-                        this.receivedPartialSums = undefined;
-                        this.receivedShares = undefined;
-                        return [2 /*return*/, partials];
-                }
-            });
-        });
-    };
-    SecAgg.prototype.receiveShares = function (peers) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var sharesPromises, receivedShares, sharesMessages;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        sharesPromises = 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.Shares)];
-                                case 1: return [2 /*return*/, _a.sent()];
-                            }
-                        }); }); });
-                        receivedShares = (0, immutable_1.List)();
-                        return [4 /*yield*/, Promise.all(sharesPromises)];
-                    case 1:
-                        sharesMessages = _a.sent();
-                        sharesMessages.forEach(function (message) {
-                            receivedShares = receivedShares.push(__1.serialization.weights.decode(message.weights));
-                        });
-                        if (receivedShares.size < peers.size) {
-                            throw new Error('Not enough shares received');
-                        }
-                        return [2 /*return*/, receivedShares];
-                }
-            });
-        });
-    };
-    SecAgg.prototype.receivePartials = function (peers) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var partialsPromises, receivedPartials, partialMessages;
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        partialsPromises = 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.PartialSums)];
-                                case 1: return [2 /*return*/, _a.sent()];
-                            }
-                        }); }); });
-                        receivedPartials = (0, immutable_1.List)();
-                        return [4 /*yield*/, Promise.all(partialsPromises)];
-                    case 1:
-                        partialMessages = _a.sent();
-                        partialMessages.forEach(function (message) {
-                            receivedPartials = receivedPartials.push(__1.serialization.weights.decode(message.partials));
-                        });
-                        if (receivedPartials.size < peers.size) {
-                            throw new Error('Not enough partials received');
-                        }
-                        return [2 /*return*/, receivedPartials];
-                }
-            });
-        });
-    };
-    /*
-      handles received messages from signaling server
-   */
-    SecAgg.prototype.clientHandle = function (peers) {
-        this.receivedShares = this.receiveShares(peers);
-        this.receivedPartialSums = this.receivePartials(peers);
-    };
-    return SecAgg;
-}(base_1.Base));
-exports.SecAgg = SecAgg;

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

@@ -1,3 +0,0 @@
-import { List } from 'immutable';
-import { WeightsContainer } from '../..';
-export declare function generateAllShares(secret: WeightsContainer, nParticipants: number, maxShareValue: number): List<WeightsContainer>;

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

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateAllShares = void 0;
-var tslib_1 = require("tslib");
-var immutable_1 = require("immutable");
-var crypto = (0, tslib_1.__importStar)(require("crypto"));
-var __1 = require("../..");
-var maxSeed = Math.pow(2, 47);
-/*
-Return Weights in the remaining share once N-1 shares have been constructed (where N is number of ready clients)
- */
-function lastShare(currentShares, secret) {
-    if (currentShares.size === 0) {
-        throw new Error('Need at least one current share to be able to subtract secret from');
-    }
-    return secret.sub(__1.aggregation.sum(currentShares));
-}
-/*
-Generate N additive shares that aggregate to the secret weights array (where N is number of ready clients)
- */
-function generateAllShares(secret, nParticipants, maxShareValue) {
-    if (nParticipants < 1) {
-        throw new Error('too few participants to genreate shares');
-    }
-    var randomShares = (0, immutable_1.Range)(0, nParticipants - 1)
-        .map(function () { return generateRandomShare(secret, maxShareValue); })
-        .toList();
-    return randomShares
-        .push(lastShare(randomShares, secret));
-}
-exports.generateAllShares = generateAllShares;
-/*
-generates one share in the same shape as the secret that is populated with values randomly chosend from
-a uniform distribution between (-maxShareValue, maxShareValue).
- */
-function generateRandomShare(secret, maxShareValue) {
-    var seed = crypto.randomInt(maxSeed);
-    return secret.map(function (t) { return __1.tf.randomUniform(t.shape, -maxShareValue, maxShareValue, 'float32', seed); });
-}

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

@@ -1,2 +0,0 @@
-export declare type PeerID = number;
-export declare function isPeerID(raw: unknown): raw is PeerID;

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

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPeerID = void 0;
-function isPeerID(raw) {
-    return typeof raw === 'number';
-}
-exports.isPeerID = isPeerID;

package/dist/core/client/event_connection.d.ts

@@ -1,37 +0,0 @@
-import { Peer } from './decentralized/peer';
-import { PeerID } from './decentralized/types';
-import { type, NarrowMessage, Message } from './messages';
-import { SignalData } from 'simple-peer';
-export interface EventConnection {
-    on: <K extends type>(type: K, handler: (event: NarrowMessage<K>) => void) => void;
-    once: <K extends type>(type: K, handler: (event: NarrowMessage<K>) => void) => void;
-    send: <T extends Message>(msg: T) => void;
-    disconnect: () => void;
-}
-export declare function waitMessage<T extends type>(connection: EventConnection, type: T): Promise<NarrowMessage<T>>;
-export declare function waitMessageWithTimeout<T extends type>(connection: EventConnection, type: T, timeoutMs: number): Promise<NarrowMessage<T>>;
-export declare class PeerConnection implements EventConnection {
-    private readonly selfId;
-    private readonly peer;
-    private readonly signallingServer;
-    private readonly eventEmitter;
-    constructor(selfId: PeerID, peer: Peer, signallingServer: EventConnection);
-    connect(): Promise<void>;
-    signal(signal: SignalData): void;
-    on<K extends type>(type: K, handler: (event: NarrowMessage<K>) => void): void;
-    once<K extends type>(type: K, handler: (event: NarrowMessage<K>) => void): void;
-    send<T extends Message>(msg: T): void;
-    disconnect(): void;
-}
-export declare class WebSocketServer implements EventConnection {
-    private readonly socket;
-    private readonly eventEmitter;
-    private readonly validateReceived?;
-    private readonly validateSent?;
-    private constructor();
-    static connect(url: URL, validateReceived?: (msg: any) => boolean, validateSent?: (msg: any) => boolean): Promise<WebSocketServer>;
-    disconnect(): void;
-    on<K extends type>(type: K, handler: (event: NarrowMessage<K>) => void): void;
-    once<K extends type>(type: K, handler: (event: NarrowMessage<K>) => void): void;
-    send(msg: Message): void;
-}

package/dist/core/client/event_connection.js

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketServer = exports.PeerConnection = exports.waitMessageWithTimeout = exports.waitMessage = void 0;
-var tslib_1 = require("tslib");
-var isomorphic_ws_1 = (0, tslib_1.__importDefault)(require("isomorphic-ws"));
-var events_1 = require("events");
-var msgpack_lite_1 = (0, tslib_1.__importDefault)(require("msgpack-lite"));
-var decentralizedMessages = (0, tslib_1.__importStar)(require("./decentralized/messages"));
-var messages_1 = require("./messages");
-var utils_1 = require("./utils");
-function waitMessage(connection, type) {
-    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*/, new Promise(function (resolve) {
-                        // "once" is important because we can't resolve the same promise multiple time
-                        connection.once(type, function (event) {
-                            resolve(event);
-                        });
-                    })];
-                case 1: return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
-}
-exports.waitMessage = waitMessage;
-function waitMessageWithTimeout(connection, type, timeoutMs) {
-    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*/, Promise.race([waitMessage(connection, type), (0, utils_1.timeout)(timeoutMs)])];
-                case 1: return [2 /*return*/, _a.sent()];
-            }
-        });
-    });
-}
-exports.waitMessageWithTimeout = waitMessageWithTimeout;
-var PeerConnection = /** @class */ (function () {
-    function PeerConnection(selfId, peer, signallingServer) {
-        this.eventEmitter = new events_1.EventEmitter();
-        this.selfId = selfId;
-        this.peer = peer;
-        this.signallingServer = signallingServer;
-    }
-    PeerConnection.prototype.connect = function () {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var _this = this;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.peer.on('signal', function (signal) {
-                            console.debug(_this.selfId, 'generates signal for', _this.peer.id);
-                            var msg = {
-                                type: messages_1.type.SignalForPeer,
-                                peer: _this.peer.id,
-                                signal: signal
-                            };
-                            _this.signallingServer.send(msg);
-                        });
-                        this.peer.on('data', function (data) {
-                            var msg = msgpack_lite_1.default.decode(data);
-                            if (!decentralizedMessages.isPeerMessage(msg)) {
-                                throw new Error("invalid message received: " + JSON.stringify(msg));
-                            }
-                            _this.eventEmitter.emit(msg.type.toString(), msg);
-                        });
-                        this.peer.on('close', function () { return console.warn('peer', _this.peer.id, 'closed connection'); });
-                        return [4 /*yield*/, new Promise(function (resolve) {
-                                _this.peer.on('connect', function () {
-                                    console.debug('connected new peer', _this.peer.id);
-                                    resolve();
-                                });
-                            })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    PeerConnection.prototype.signal = function (signal) {
-        this.peer.signal(signal);
-    };
-    PeerConnection.prototype.on = function (type, handler) {
-        this.eventEmitter.on(type.toString(), handler);
-    };
-    PeerConnection.prototype.once = function (type, handler) {
-        this.eventEmitter.once(type.toString(), handler);
-    };
-    PeerConnection.prototype.send = function (msg) {
-        if (!decentralizedMessages.isPeerMessage(msg)) {
-            throw new Error("can't send this type of message: " + JSON.stringify(msg));
-        }
-        this.peer.send(msgpack_lite_1.default.encode(msg));
-    };
-    PeerConnection.prototype.disconnect = function () {
-        this.peer.destroy();
-    };
-    return PeerConnection;
-}());
-exports.PeerConnection = PeerConnection;
-var WebSocketServer = /** @class */ (function () {
-    function WebSocketServer(socket, eventEmitter, validateReceived, validateSent) {
-        this.socket = socket;
-        this.eventEmitter = eventEmitter;
-        this.validateReceived = validateReceived;
-        this.validateSent = validateSent;
-    }
-    WebSocketServer.connect = function (url, validateReceived, validateSent) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var WS, ws, emitter, server;
-            return (0, tslib_1.__generator)(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        WS = typeof window !== 'undefined' ? window.WebSocket : isomorphic_ws_1.default.WebSocket;
-                        ws = new WS(url);
-                        ws.binaryType = 'arraybuffer';
-                        emitter = new events_1.EventEmitter();
-                        server = new WebSocketServer(ws, emitter, validateReceived, validateSent);
-                        ws.onmessage = function (event) {
-                            if (!(event.data instanceof ArrayBuffer)) {
-                                throw new Error('server did not send an ArrayBuffer');
-                            }
-                            var msg = msgpack_lite_1.default.decode(new Uint8Array(event.data));
-                            // Validate message format
-                            if (validateReceived && !validateReceived(msg)) {
-                                throw new Error("invalid message received: " + JSON.stringify(msg));
-                            }
-                            emitter.emit(msg.type.toString(), msg);
-                        };
-                        return [4 /*yield*/, new Promise(function (resolve, reject) {
-                                ws.onerror = function (err) {
-                                    return reject(new Error("connecting server: " + err.message));
-                                }; // eslint-disable-line @typescript-eslint/restrict-template-expressions
-                                ws.onopen = function () { return resolve(server); };
-                            })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    WebSocketServer.prototype.disconnect = function () {
-        this.socket.close();
-    };
-    // Not straigtforward way of making sure the handler take the correct message type as a parameter, for typesafety
-    WebSocketServer.prototype.on = function (type, handler) {
-        this.eventEmitter.on(type.toString(), handler);
-    };
-    WebSocketServer.prototype.once = function (type, handler) {
-        this.eventEmitter.once(type.toString(), handler);
-    };
-    WebSocketServer.prototype.send = function (msg) {
-        if (this.validateSent && !this.validateSent(msg)) {
-            throw new Error("can't send this type of message: " + JSON.stringify(msg));
-        }
-        this.socket.send(msgpack_lite_1.default.encode(msg));
-    };
-    return WebSocketServer;
-}());
-exports.WebSocketServer = WebSocketServer;

package/dist/core/client/federated/client.d.ts

@@ -1,37 +0,0 @@
-import { informant, MetadataID, WeightsContainer } from '../..';
-import { Base } from '../base';
-import { EventConnection } from '../event_connection';
-/**
- * Class that deals with communication with the centralized server when training
- * a specific task in the federated setting.
- */
-export declare class Client extends Base {
-    private readonly clientID;
-    private readonly peer;
-    private round;
-    protected _server?: EventConnection;
-    private serverRound?;
-    private serverWeights?;
-    private receivedStatistics?;
-    private metadataMap?;
-    get server(): EventConnection;
-    private connectServer;
-    /**
-     * Initialize the connection to the server. TODO: In the case of FeAI,
-     * should return the current server-side round for the task.
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnection process when user quits the task.
-     */
-    disconnect(): Promise<void>;
-    private sendMessage;
-    postWeightsToServer(weights: WeightsContainer): Promise<void>;
-    getLatestServerRound(): Promise<number | undefined>;
-    pullRoundAndFetchWeights(): Promise<WeightsContainer | undefined>;
-    pullServerStatistics(trainingInformant: informant.FederatedInformant): Promise<void>;
-    postMetadata(metadataID: MetadataID, metadata: string): Promise<void>;
-    getMetadataMap(metadataId: MetadataID): Promise<Map<string, unknown> | undefined>;
-    onRoundEndCommunication(updatedWeights: WeightsContainer, staleWeights: WeightsContainer, _: number, trainingInformant: informant.FederatedInformant): Promise<WeightsContainer>;
-    onTrainEndCommunication(): Promise<void>;
-}