@epfml/discojs 1.0.0 → 2.1.1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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