@epfml/discojs 0.1.0 → 2.0.0

package/README.md

@@ -1,33 +1,53 @@
-# discojs
+# Disco.js Web Module
 
-discojs contains the core code of disco.
+`discojs-web` contains the browser-only code of Disco.js, based off and extending `discojs-core`.
 
 ## Installation
 
-The app is running under Node.js v16. NPM is a package manager for the JavaScript runtime environment Node.js.
+The `discojs-web` project is available as the `@epfml/discojs` NPM package, which can be installed with
+`npm i @epfml/discojs`.
+
+### Development Environment
+
+The dev tools run on Node.js and require `npm`, a package manager for the Node.js runtime environment.
 We recommend using [nvm](https://github.com/nvm-sh/nvm) for installing both Node.js and NPM.
 
-To install the application's dependencies, run the following command:
+To install the project's dependencies, run:
 
 ```
+cd ..
 npm ci
 ```
 
+Since the dependencies of `discojs-core`, `discojs-web` and `discojs-node` are the same, they are specified in a top-level `package.json` file, to ease installation and building.
+
 > **⚠ WARNING: Apple Silicon.**
-> `TensorFlow.js` since version `3.13.0` and newer do support M1 processors for macs. To do so, make sure you have an `arm` node executable installed (not `x86`). It can be checked using:
+> `TensorFlow.js` version `3` do support M1 processors for macs. To do so, make sure you have an `arm` Node.js executable installed (not `x86_64`). It can be checked using:
 
 ```
 node -p "process.arch"
 ```
 
-which should return `arm64`.
+which should return something similar to `arm64`.
 
 ## Build
 
-In order to enable the browser and server modules to use the `discojs` package, we must build discojs:
+The server and CLI modules, as well as all unit tests (except Cypress) use the `discojs-web` interface, i.e. they all run on Node.js. This Disco.js Node module is build on top of and extends `discojs-core`, whose code is [symlinked](https://en.wikipedia.org/wiki/Symbolic_link) into `discojs-web/src/core`. To build this project:
 
 ```
 npm run build
 ```
 
-This invokes the TypeScript compiler (`tsc`). To recompile from stratch, simply `rm -rf dist/` before running `npm run build` again.
+This invokes the TypeScript compiler (`tsc`). It will output the compilation files of `discojs-web` in a `dist/` directory. To recompile from stratch, simply `rm -rf dist/` before running `npm run build` again.
+
+## Development
+
+### Contributing
+
+Contributions to `discojs-web` must only include browser-specific code. Code common to both the browser and Node.js must be added to `discojs-core` instead.
+
+As a rule of thumb, the `src/core/` directory must never be modified when modifying `discojs-web`, since it is [symlinked](https://en.wikipedia.org/wiki/Symbolic_link) to `discojs-core`.
+
+If you wish to add a new file or submodule to the project, please do so in a similar way as `src/core/` is structured. That is, [adding a new task](../../docs/TASK.md) to `discojs-web` would mean adding a new file to `src/tasks/` and modifying `src/tasks/index.ts` (NOT `src/core/tasks/...`).
+
+Note that, if you end up making calls to the Tensorflow.js API, you must import it from the root index. This is to ensure the Node version of TF.js is loaded, and only once.

package/dist/{async_buffer.d.ts → core/async_buffer.d.ts}

@@ -1,5 +1,5 @@
-import { AsyncInformant } from './async_informant';
-import { TaskID } from './task';
+import { Map } from 'immutable';
+import { TaskID, AsyncInformant } from '.';
 /**
  * The AsyncWeightsBuffer class holds and manipulates information about the
  * async weights buffer. It works as follows:
@@ -25,7 +25,7 @@ export declare class AsyncBuffer<T> {
     buffer: Map<string, T>;
     round: number;
     private observer;
-    constructor(taskID: TaskID, bufferCapacity: number, aggregateAndStoreWeights: (weights: T[]) => Promise<void>, roundCutoff?: number);
+    constructor(taskID: TaskID, bufferCapacity: number, aggregateAndStoreWeights: (weights: Iterable<T>) => Promise<void>, roundCutoff?: number);
     registerObserver(observer: AsyncInformant<T>): void;
     bufferIsFull(): boolean;
     private updateWeightsIfBufferIsFull;

package/dist/{async_buffer.js → core/async_buffer.js}

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncBuffer = void 0;
 var tslib_1 = require("tslib");
+var immutable_1 = require("immutable");
 /**
  * The AsyncWeightsBuffer class holds and manipulates information about the
  * async weights buffer. It works as follows:
@@ -26,7 +27,7 @@ var AsyncBuffer = /** @class */ (function () {
         this.bufferCapacity = bufferCapacity;
         this.aggregateAndStoreWeights = aggregateAndStoreWeights;
         this.roundCutoff = roundCutoff;
-        this.buffer = new Map();
+        this.buffer = (0, immutable_1.Map)();
         this.round = 0;
     }
     AsyncBuffer.prototype.registerObserver = function (observer) {
@@ -39,18 +40,16 @@ var AsyncBuffer = /** @class */ (function () {
     AsyncBuffer.prototype.updateWeightsIfBufferIsFull = function () {
         var _a;
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
-            var allWeights;
             return (0, tslib_1.__generator)(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         if (!this.bufferIsFull()) return [3 /*break*/, 2];
-                        allWeights = Array.from(this.buffer.values());
-                        return [4 /*yield*/, this.aggregateAndStoreWeights(allWeights)];
+                        return [4 /*yield*/, this.aggregateAndStoreWeights(this.buffer.values())];
                     case 1:
                         _b.sent();
                         this.round += 1;
                         (_a = this.observer) === null || _a === void 0 ? void 0 : _a.update();
-                        this.buffer.clear();
+                        this.buffer = (0, immutable_1.Map)();
                         console.log('\n************************************************************');
                         console.log("Buffer is full; Aggregating weights and starting round: " + this.round + "\n");
                         _b.label = 2;
@@ -84,7 +83,7 @@ var AsyncBuffer = /** @class */ (function () {
                         weightsUpdatedByUser = this.buffer.has(id);
                         msg = weightsUpdatedByUser ? '\tUpdating' : '-> Adding new';
                         console.log(msg + " weights of " + id + " to buffer.");
-                        this.buffer.set(id, weights);
+                        this.buffer = this.buffer.set(id, weights);
                         return [4 /*yield*/, this.updateWeightsIfBufferIsFull()];
                     case 1:
                         _a.sent();

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

@@ -1,11 +1,8 @@
-/// <reference types="node" />
-import * as tf from '@tensorflow/tfjs';
-import { Task } from '@/task';
-import { TrainingInformant } from '@/informant';
-import { Weights } from '@/types';
+import { tf, WeightsContainer, Task, TrainingInformant } from '..';
 export declare abstract class Base {
     readonly url: URL;
     readonly task: Task;
+    protected connected: boolean;
     constructor(url: URL, task: Task);
     /**
      * Handles the connection process from the client to any sort of
@@ -23,7 +20,7 @@ export declare abstract class Base {
      * onTrainEnd callback when training a TFJS model object. See the
      * training manager for more details.
      */
-    abstract onTrainEndCommunication(weights: Weights, trainingInformant: TrainingInformant): Promise<void>;
+    abstract onTrainEndCommunication(weights: WeightsContainer, trainingInformant: TrainingInformant): Promise<void>;
     /**
      * This function will be called whenever a local round has ended.
      *
@@ -32,5 +29,5 @@ export declare abstract class Base {
      * @param round
      * @param trainingInformant
      */
-    abstract onRoundEndCommunication(updatedWeights: Weights, staleWeights: Weights, round: number, trainingInformant: TrainingInformant): Promise<Weights>;
+    abstract onRoundEndCommunication(updatedWeights: WeightsContainer, staleWeights: WeightsContainer, round: number, trainingInformant: TrainingInformant): Promise<WeightsContainer>;
 }

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

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Base = void 0;
 var tslib_1 = require("tslib");
 var axios_1 = (0, tslib_1.__importDefault)(require("axios"));
-var serialization = (0, tslib_1.__importStar)(require("../serialization"));
+var __1 = require("..");
 var Base = /** @class */ (function () {
     function Base(url, task) {
         this.url = url;
         this.task = task;
+        this.connected = false;
     }
     Base.prototype.getLatestModel = function () {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
@@ -23,7 +24,7 @@ var Base = /** @class */ (function () {
                         return [4 /*yield*/, axios_1.default.get(url.href)];
                     case 1:
                         response = _a.sent();
-                        return [4 /*yield*/, serialization.model.decode(response.data)];
+                        return [4 /*yield*/, __1.serialization.model.decode(response.data)];
                     case 2: return [2 /*return*/, _a.sent()];
                 }
             });

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

@@ -0,0 +1,32 @@
+import { List, Map } from 'immutable';
+import { TrainingInformant, WeightsContainer, Task } from '../..';
+import { Base as ClientBase } from '../base';
+import { PeerID } from './types';
+import * as messages from './messages';
+import { PeerConnection } from '../event_connection';
+/**
+ * Abstract class for decentralized clients, executes onRoundEndCommunication as well as connecting
+ * to the signaling server
+ */
+export declare abstract class Base extends ClientBase {
+    readonly url: URL;
+    readonly task: Task;
+    protected readonly minimumReadyPeers: number;
+    private server?;
+    private peers?;
+    private ID?;
+    private pool?;
+    constructor(url: URL, task: Task);
+    private waitForPeers;
+    protected sendMessagetoPeer(peer: PeerConnection, msg: messages.PeerMessage): void;
+    private connectServer;
+    /**
+     * Initialize the connection to the peers and to the other nodes.
+     */
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    onTrainEndCommunication(_: WeightsContainer, trainingInformant: TrainingInformant): Promise<void>;
+    onRoundEndCommunication(updatedWeights: WeightsContainer, staleWeights: WeightsContainer, round: number, trainingInformant: TrainingInformant): Promise<WeightsContainer>;
+    abstract sendAndReceiveWeights(peers: Map<PeerID, PeerConnection>, noisyWeights: WeightsContainer, round: number, trainingInformant: TrainingInformant): Promise<List<WeightsContainer>>;
+    abstract clientHandle(peers: Map<PeerID, PeerConnection>): void;
+}

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

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

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

@@ -0,0 +1,96 @@
+"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/messages.d.ts

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

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