@epfml/discojs 0.1.0 → 2.0.0

package/dist/core/client/event_connection.js

@@ -0,0 +1,158 @@
+"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

@@ -0,0 +1,37 @@
+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>;
+}

package/dist/core/client/federated/client.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+var tslib_1 = require("tslib");
+var uuid_1 = require("uuid");
+var __1 = require("../..");
+var base_1 = require("../base");
+var messages = (0, tslib_1.__importStar)(require("./messages"));
+var messages_1 = require("../messages");
+var nodeUrl = (0, tslib_1.__importStar)(require("url"));
+var event_connection_1 = require("../event_connection");
+var utils_1 = require("../utils");
+/**
+ * Class that deals with communication with the centralized server when training
+ * a specific task in the federated setting.
+ */
+var Client = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(Client, _super);
+    function Client() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.clientID = (0, uuid_1.v4)();
+        _this.round = 0;
+        return _this;
+    }
+    Object.defineProperty(Client.prototype, "server", {
+        get: function () {
+            if (this._server === undefined) {
+                throw new Error('server undefined, not connected');
+            }
+            return this._server;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    // It opens a new WebSocket connection and listens to new messages over the channel
+    Client.prototype.connectServer = function (url) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var server;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, event_connection_1.WebSocketServer.connect(url, messages.isMessageFederated, messages.isMessageFederated)];
+                    case 1:
+                        server = _a.sent();
+                        return [2 /*return*/, server];
+                }
+            });
+        });
+    };
+    /**
+     * Initialize the connection to the server. TODO: In the case of FeAI,
+     * should return the current server-side round for the task.
+     */
+    Client.prototype.connect = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var URL, serverURL, _a, msg;
+            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 += "feai/" + this.task.taskID + "/" + this.clientID;
+                        _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.waitMessageWithTimeout)(this.server, messages_1.type.clientConnected, utils_1.MAX_WAIT_PER_ROUND)];
+                    case 2:
+                        _b.sent();
+                        this.connected = true;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnection process when user quits the task.
+     */
+    Client.prototype.disconnect = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                this.server.disconnect();
+                this._server = undefined;
+                this.connected = false;
+                return [2 /*return*/];
+            });
+        });
+    };
+    // It sends a message to the server
+    Client.prototype.sendMessage = function (msg) {
+        var _a;
+        (_a = this.server) === null || _a === void 0 ? void 0 : _a.send(msg);
+    };
+    // It sends weights to the server
+    Client.prototype.postWeightsToServer = function (weights) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var msg;
+            var _a;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = {
+                            type: messages_1.type.postWeightsToServer
+                        };
+                        return [4 /*yield*/, __1.serialization.weights.encode(weights)];
+                    case 1:
+                        msg = (_a.weights = _b.sent(),
+                            _a.round = this.round,
+                            _a);
+                        this.sendMessage(msg);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // It retrieves the last server round and weights, but return only the server round
+    Client.prototype.getLatestServerRound = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var msg, received;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.serverRound = undefined;
+                        this.serverWeights = undefined;
+                        msg = {
+                            type: messages_1.type.latestServerRound
+                        };
+                        this.sendMessage(msg);
+                        return [4 /*yield*/, (0, event_connection_1.waitMessageWithTimeout)(this.server, messages_1.type.latestServerRound, utils_1.MAX_WAIT_PER_ROUND)];
+                    case 1:
+                        received = _a.sent();
+                        this.serverRound = received.round;
+                        this.serverWeights = __1.serialization.weights.decode(received.weights);
+                        return [2 /*return*/, this.serverRound];
+                }
+            });
+        });
+    };
+    // It retrieves the last server round and weights, but return only the server weights
+    Client.prototype.pullRoundAndFetchWeights = function () {
+        var _a;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0: 
+                    // get server round of latest model
+                    return [4 /*yield*/, this.getLatestServerRound()];
+                    case 1:
+                        // get server round of latest model
+                        _b.sent();
+                        if (this.round < ((_a = this.serverRound) !== null && _a !== void 0 ? _a : 0)) {
+                            // Update the local round to match the server's
+                            this.round = this.serverRound;
+                            return [2 /*return*/, this.serverWeights];
+                        }
+                        else {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // It pulls statistics from the server
+    Client.prototype.pullServerStatistics = function (trainingInformant) {
+        var _a;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var msg, received;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.receivedStatistics = undefined;
+                        msg = {
+                            type: messages_1.type.pullServerStatistics
+                        };
+                        this.sendMessage(msg);
+                        return [4 /*yield*/, (0, event_connection_1.waitMessageWithTimeout)(this.server, messages_1.type.pullServerStatistics, utils_1.MAX_WAIT_PER_ROUND)];
+                    case 1:
+                        received = _b.sent();
+                        this.receivedStatistics = received.statistics;
+                        trainingInformant.update((_a = this.receivedStatistics) !== null && _a !== void 0 ? _a : {});
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // It posts a new metadata value to the server
+    Client.prototype.postMetadata = function (metadataID, metadata) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var msg;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                msg = {
+                    type: messages_1.type.postMetadata,
+                    taskId: this.task.taskID,
+                    clientId: this.clientID,
+                    round: this.round,
+                    metadataId: metadataID,
+                    metadata: metadata
+                };
+                this.sendMessage(msg);
+                return [2 /*return*/];
+            });
+        });
+    };
+    // It gets a metadata map from the server
+    Client.prototype.getMetadataMap = function (metadataId) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var msg, received;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.metadataMap = undefined;
+                        msg = {
+                            type: messages_1.type.getMetadataMap,
+                            taskId: this.task.taskID,
+                            clientId: this.clientID,
+                            round: this.round,
+                            metadataId: metadataId
+                        };
+                        this.sendMessage(msg);
+                        return [4 /*yield*/, (0, event_connection_1.waitMessageWithTimeout)(this.server, messages_1.type.getMetadataMap, utils_1.MAX_WAIT_PER_ROUND)];
+                    case 1:
+                        received = _a.sent();
+                        if (received.metadataMap !== undefined) {
+                            this.metadataMap = new Map(received.metadataMap);
+                        }
+                        return [2 /*return*/, this.metadataMap];
+                }
+            });
+        });
+    };
+    Client.prototype.onRoundEndCommunication = function (updatedWeights, staleWeights, _, trainingInformant) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var noisyWeights, serverWeights;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        noisyWeights = __1.privacy.addDifferentialPrivacy(updatedWeights, staleWeights, this.task);
+                        return [4 /*yield*/, this.postWeightsToServer(noisyWeights)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.pullServerStatistics(trainingInformant)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.pullRoundAndFetchWeights()];
+                    case 3:
+                        serverWeights = _a.sent();
+                        return [2 /*return*/, serverWeights !== null && serverWeights !== void 0 ? serverWeights : staleWeights];
+                }
+            });
+        });
+    };
+    Client.prototype.onTrainEndCommunication = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+            return [2 /*return*/];
+        }); });
+    };
+    return Client;
+}(base_1.Base));
+exports.Client = Client;

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

@@ -0,0 +1,2 @@
+export { Client } from './client';
+export * as messages from './messages';

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messages = exports.Client = void 0;
+var tslib_1 = require("tslib");
+var client_1 = require("./client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+exports.messages = (0, tslib_1.__importStar)(require("./messages"));

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

@@ -0,0 +1,38 @@
+import { MetadataID } from '../..';
+import { weights } from '../../serialization';
+import { type } from '../messages';
+export declare type MessageFederated = postWeightsToServer | latestServerRound | pullServerStatistics | postMetadata | getMetadataMap | messageGeneral;
+export interface messageGeneral {
+    type: type;
+}
+export interface postWeightsToServer {
+    type: type.postWeightsToServer;
+    weights: weights.Encoded;
+    round: number;
+}
+export interface latestServerRound {
+    type: type.latestServerRound;
+    weights: weights.Encoded;
+    round: number;
+}
+export interface pullServerStatistics {
+    type: type.pullServerStatistics;
+    statistics: Record<string, number>;
+}
+export interface postMetadata {
+    type: type.postMetadata;
+    clientId: string;
+    taskId: string;
+    round: number;
+    metadataId: string;
+    metadata: string;
+}
+export interface getMetadataMap {
+    type: type.getMetadataMap;
+    clientId: string;
+    taskId: string;
+    round: number;
+    metadataId: MetadataID;
+    metadataMap?: Array<[string, string | undefined]>;
+}
+export declare function isMessageFederated(o: unknown): o is MessageFederated;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMessageFederated = void 0;
+var messages_1 = require("../messages");
+function isMessageFederated(o) {
+    if (!(0, messages_1.hasMessageType)(o)) {
+        return false;
+    }
+    switch (o.type) {
+        case messages_1.type.clientConnected:
+            return true;
+        case messages_1.type.postWeightsToServer:
+            return true;
+        case messages_1.type.latestServerRound:
+            return true;
+        case messages_1.type.pullServerStatistics:
+            return true;
+        case messages_1.type.postMetadata:
+            return true;
+        case messages_1.type.getMetadataMap:
+            return true;
+    }
+    return false;
+}
+exports.isMessageFederated = isMessageFederated;

package/dist/{client → core/client}/index.d.ts

@@ -1,4 +1,5 @@
 export { Base } from './base';
 export * as decentralized from './decentralized';
-export { Federated } from './federated';
+export * as federated from './federated';
+export * as messages from './messages';
 export { Local } from './local';

package/dist/{client → core/client}/index.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Local = exports.Federated = exports.decentralized = exports.Base = void 0;
+exports.Local = exports.messages = exports.federated = exports.decentralized = exports.Base = void 0;
 var tslib_1 = require("tslib");
 var base_1 = require("./base");
 Object.defineProperty(exports, "Base", { enumerable: true, get: function () { return base_1.Base; } });
 exports.decentralized = (0, tslib_1.__importStar)(require("./decentralized"));
-var federated_1 = require("./federated");
-Object.defineProperty(exports, "Federated", { enumerable: true, get: function () { return federated_1.Federated; } });
+exports.federated = (0, tslib_1.__importStar)(require("./federated"));
+exports.messages = (0, tslib_1.__importStar)(require("./messages"));
 var local_1 = require("./local");
 Object.defineProperty(exports, "Local", { enumerable: true, get: function () { return local_1.Local; } });

package/dist/{client → core/client}/local.d.ts

@@ -1,8 +1,8 @@
-import { Weights } from '../types';
+import { WeightsContainer } from '..';
 import { Base } from './base';
 export declare class Local extends Base {
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    onRoundEndCommunication(_: Weights): Promise<Weights>;
+    onRoundEndCommunication(_: WeightsContainer): Promise<WeightsContainer>;
     onTrainEndCommunication(): Promise<void>;
 }

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

@@ -0,0 +1,28 @@
+import * as decentralized from './decentralized/messages';
+import * as federated from './federated/messages';
+export declare enum type {
+    clientConnected = 0,
+    PeerID = 1,
+    SignalForPeer = 2,
+    PeerIsReady = 3,
+    PeersForRound = 4,
+    Weights = 5,
+    Shares = 6,
+    PartialSums = 7,
+    postWeightsToServer = 8,
+    postMetadata = 9,
+    getMetadataMap = 10,
+    latestServerRound = 11,
+    pullRoundAndFetchWeights = 12,
+    pullServerStatistics = 13
+}
+export interface clientConnected {
+    type: type.clientConnected;
+}
+export declare type Message = decentralized.MessageFromServer | decentralized.MessageToServer | decentralized.PeerMessage | federated.MessageFederated;
+export declare type NarrowMessage<D> = Extract<Message, {
+    type: D;
+}>;
+export declare function hasMessageType(raw: unknown): raw is {
+    type: type;
+} & Record<string, unknown>;

package/dist/core/client/messages.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasMessageType = exports.type = void 0;
+var type;
+(function (type) {
+    type[type["clientConnected"] = 0] = "clientConnected";
+    // decentralized
+    type[type["PeerID"] = 1] = "PeerID";
+    type[type["SignalForPeer"] = 2] = "SignalForPeer";
+    type[type["PeerIsReady"] = 3] = "PeerIsReady";
+    type[type["PeersForRound"] = 4] = "PeersForRound";
+    type[type["Weights"] = 5] = "Weights";
+    type[type["Shares"] = 6] = "Shares";
+    type[type["PartialSums"] = 7] = "PartialSums";
+    // federated
+    type[type["postWeightsToServer"] = 8] = "postWeightsToServer";
+    type[type["postMetadata"] = 9] = "postMetadata";
+    type[type["getMetadataMap"] = 10] = "getMetadataMap";
+    type[type["latestServerRound"] = 11] = "latestServerRound";
+    type[type["pullRoundAndFetchWeights"] = 12] = "pullRoundAndFetchWeights";
+    type[type["pullServerStatistics"] = 13] = "pullServerStatistics";
+})(type = exports.type || (exports.type = {}));
+function hasMessageType(raw) {
+    if (typeof raw !== 'object' || raw === null) {
+        return false;
+    }
+    var o = raw;
+    if (!('type' in o && typeof o.type === 'number' && o.type in type)) {
+        return false;
+    }
+    return true;
+}
+exports.hasMessageType = hasMessageType;

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

@@ -0,0 +1,2 @@
+export declare const MAX_WAIT_PER_ROUND = 10000;
+export declare function timeout(ms: number): Promise<never>;

package/dist/core/client/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeout = exports.MAX_WAIT_PER_ROUND = void 0;
+var tslib_1 = require("tslib");
+// Time to wait for the others in milliseconds.
+exports.MAX_WAIT_PER_ROUND = 10000;
+function timeout(ms) {
+    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, reject) {
+                        setTimeout(function () { return reject(new Error('timeout')); }, ms);
+                    })];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+exports.timeout = timeout;