@epfml/discojs 3.0.1-p20241007204240.0 → 3.0.1-p20241014092014.0

package/dist/aggregator/{base.d.ts → aggregator.d.ts}

@@ -1,5 +1,5 @@
 import { Map, Set } from 'immutable';
-import type { client } from '../index.js';
+import type { client, WeightsContainer } from '../index.js';
 import { EventEmitter } from '../utils/event_emitter.js';
 export declare enum AggregationStep {
     ADD = 0,
@@ -10,11 +10,11 @@ export declare enum AggregationStep {
  * Main, abstract, aggregator class whose role is to buffer contributions and to produce
  * a result based off their aggregation, whenever some defined condition is met.
  *
- * Emits an event whenever an aggregation step is performed.
- * Users wait for this event to fetch the aggregation result.
+ * Emits an event whenever an aggregation step is performed with the counrd's aggregated weights.
+ * Users subscribes to this event to get the aggregation result.
  */
-export declare abstract class Base<T> extends EventEmitter<{
-    'aggregation': T;
+export declare abstract class Aggregator extends EventEmitter<{
+    'aggregation': WeightsContainer;
 }> {
     /**
      * The round cut-off for contributions.
@@ -34,7 +34,7 @@ export declare abstract class Base<T> extends EventEmitter<{
      * It defines the effective aggregation group, which is possibly a subset
      * of all active nodes, depending on the aggregation scheme.
      */
-    protected contributions: Map<number, Map<client.NodeID, T>>;
+    protected contributions: Map<number, Map<client.NodeID, WeightsContainer>>;
     /**
      * The current aggregation round, used for assessing whether a node contribution is recent enough
      * or not.
@@ -56,36 +56,45 @@ export declare abstract class Base<T> extends EventEmitter<{
      * The number of communication rounds occurring during any given aggregation round.
      */
     communicationRounds?: number);
+    /**
+     * Convenience method to subscribe to the 'aggregation' event.
+     * Await this promise returns the aggregated weights for the current round.
+     *
+     * @returns a promise for the aggregated weights
+     */
+    getPromiseForAggregation(): Promise<WeightsContainer>;
     /**
      * Adds a node's contribution to the aggregator for the given aggregation and communication rounds.
      * The aggregation round is increased whenever a new global model is obtained and local models are updated.
      * Within one aggregation round there may be multiple communication rounds (such as for the decentralized secure aggregation
-     *  which requires multiple steps to obtain a global model)
-     * The contribution will be aggregated during the next aggregation step.
+     * which requires multiple steps to obtain a global model)
+     * The contribution is aggregated during the next aggregation step.
+     *
      * @param nodeId The node's id
      * @param contribution The node's contribution
-     * @param round aggregation round of the contribution was made
-     * @param communicationRound communication round the contribution was made within the aggregation round
-     * @returns boolean, true if the contribution has been successfully taken into account or False if it has been rejected
      */
-    abstract add(nodeId: client.NodeID, contribution: T, round: number, communicationRound?: number): boolean;
+    add(nodeId: client.NodeID, contribution: WeightsContainer, aggregationRound: number, communicationRound?: number): void;
+    protected abstract _add(nodeId: client.NodeID, contribution: WeightsContainer, communicationRound?: number): void;
     /**
      * Evaluates whether a given participant contribution can be used in the current aggregation round
      * the boolean returned by `this.add` is obtained via `this.isValidContribution`
+     *
+     * @param nodeId the node id of the contribution to be added
+     * @param round the aggregation round of the contribution to be added
      */
     isValidContribution(nodeId: client.NodeID, round: number): boolean;
     /**
      * Performs an aggregation step over the received node contributions.
      * Must store the aggregation's result in the aggregator's result promise.
      */
-    abstract aggregate(): void;
+    protected abstract aggregate(): WeightsContainer;
     /**
      * Returns whether the given round is recent enough, dependent on the
      * aggregator's round cutoff.
      * @param round The round
      * @returns True if the round is recent enough, false otherwise
      */
-    isWithinRoundCutoff(round: number): boolean;
+    private isWithinRoundCutoff;
     /**
      * Logs useful messages during the various aggregation steps.
      * @param step The aggregation step
@@ -112,28 +121,17 @@ export declare abstract class Base<T> extends EventEmitter<{
      * @param nodeIds The new set of nodes
      */
     setNodes(nodeIds: Set<client.NodeID>): void;
-    /**
-     * Empties the current set of "nodes". Usually called at the end of an aggregation round,
-     * if the set of nodes is meant to change or to be actualized.
-     */
-    resetNodes(): void;
     /**
      * Sets the aggregator's round number. To be used whenever the aggregator is out of sync
      * with the network's round.
      * @param round The new round
      */
     setRound(round: number): void;
-    /**
-     * Updates the aggregator's state to proceed to the next communication round.
-     * If all communication rounds were performed, proceeds to the next aggregation round
-     * and empties the collection of stored contributions.
-     */
-    nextRound(): void;
     /**
      * Constructs the payloads sent to other nodes as contribution.
      * @param base Object from which the payload is computed
      */
-    abstract makePayloads(base: T): Map<client.NodeID, T>;
+    abstract makePayloads(base: WeightsContainer): Map<client.NodeID, WeightsContainer>;
     abstract isFull(): boolean;
     /**
      * The set of node ids, representing our neighbors within the network.
@@ -143,11 +141,6 @@ export declare abstract class Base<T> extends EventEmitter<{
      * The aggregation round.
      */
     get round(): number;
-    /**
-     * The aggregator's current size, defined by its number of contributions. The size is bounded by
-     * the amount of all active nodes times the number of communication rounds.
-     */
-    get size(): number;
     /**
      * The current communication round.
      */

package/dist/aggregator/{base.js → aggregator.js}

@@ -12,10 +12,10 @@ export var AggregationStep;
  * Main, abstract, aggregator class whose role is to buffer contributions and to produce
  * a result based off their aggregation, whenever some defined condition is met.
  *
- * Emits an event whenever an aggregation step is performed.
- * Users wait for this event to fetch the aggregation result.
+ * Emits an event whenever an aggregation step is performed with the counrd's aggregated weights.
+ * Users subscribes to this event to get the aggregation result.
  */
-export class Base extends EventEmitter {
+export class Aggregator extends EventEmitter {
     roundCutoff;
     communicationRounds;
     /**
@@ -28,7 +28,7 @@ export class Base extends EventEmitter {
      * It defines the effective aggregation group, which is possibly a subset
      * of all active nodes, depending on the aggregation scheme.
      */
-    // communication round -> NodeID -> T
+    // communication round -> NodeID -> WeightsContainer
     contributions;
     /**
      * The current aggregation round, used for assessing whether a node contribution is recent enough
@@ -56,13 +56,54 @@ export class Base extends EventEmitter {
         this.communicationRounds = communicationRounds;
         this.contributions = Map();
         this._nodes = Set();
-        // On every aggregation, update the object's state to match the current aggregation
-        // and communication rounds.
-        this.on('aggregation', () => this.nextRound());
+    }
+    /**
+     * Convenience method to subscribe to the 'aggregation' event.
+     * Await this promise returns the aggregated weights for the current round.
+     *
+     * @returns a promise for the aggregated weights
+     */
+    getPromiseForAggregation() {
+        return new Promise((resolve) => this.once('aggregation', resolve));
+    }
+    /**
+     * Adds a node's contribution to the aggregator for the given aggregation and communication rounds.
+     * The aggregation round is increased whenever a new global model is obtained and local models are updated.
+     * Within one aggregation round there may be multiple communication rounds (such as for the decentralized secure aggregation
+     * which requires multiple steps to obtain a global model)
+     * The contribution is aggregated during the next aggregation step.
+     *
+     * @param nodeId The node's id
+     * @param contribution The node's contribution
+     */
+    add(nodeId, contribution, aggregationRound, communicationRound) {
+        if (!this.isValidContribution(nodeId, aggregationRound))
+            throw new Error("Tried adding an invalid contribution. Handle this case before calling add.");
+        // call the abstract method _add, implemented by subclasses
+        this._add(nodeId, contribution, communicationRound);
+        // If the aggregator has enough contributions then aggregate the weights
+        // and emit the 'aggregation' event
+        if (this.isFull()) {
+            const aggregatedWeights = this.aggregate();
+            // On each aggregation, increment the communication round
+            // If all communication rounds were performed, proceed to the next aggregation round
+            // and empty the past contributions.
+            this._communicationRound++;
+            if (this.communicationRound === this.communicationRounds) {
+                this._communicationRound = 0;
+                this._round++;
+                this.contributions = Map();
+            }
+            // Emitting the 'aggregation' communicates the weights to subscribers
+            this.emit('aggregation', aggregatedWeights);
+        }
     }
     /**
      * Evaluates whether a given participant contribution can be used in the current aggregation round
      * the boolean returned by `this.add` is obtained via `this.isValidContribution`
+     *
+     * @param nodeId the node id of the contribution to be added
+     * @param round the aggregation round of the contribution to be added
      */
     isValidContribution(nodeId, round) {
         if (!this.nodes.has(nodeId)) {
@@ -139,13 +180,6 @@ export class Base extends EventEmitter {
     setNodes(nodeIds) {
         this._nodes = nodeIds;
     }
-    /**
-     * Empties the current set of "nodes". Usually called at the end of an aggregation round,
-     * if the set of nodes is meant to change or to be actualized.
-     */
-    resetNodes() {
-        this._nodes = Set();
-    }
     /**
      * Sets the aggregator's round number. To be used whenever the aggregator is out of sync
      * with the network's round.
@@ -156,18 +190,6 @@ export class Base extends EventEmitter {
             this._round = round;
         }
     }
-    /**
-     * Updates the aggregator's state to proceed to the next communication round.
-     * If all communication rounds were performed, proceeds to the next aggregation round
-     * and empties the collection of stored contributions.
-     */
-    nextRound() {
-        if (++this._communicationRound === this.communicationRounds) {
-            this._communicationRound = 0;
-            this._round++;
-            this.contributions = Map();
-        }
-    }
     /**
      * The set of node ids, representing our neighbors within the network.
      */
@@ -180,16 +202,6 @@ export class Base extends EventEmitter {
     get round() {
         return this._round;
     }
-    /**
-     * The aggregator's current size, defined by its number of contributions. The size is bounded by
-     * the amount of all active nodes times the number of communication rounds.
-     */
-    get size() {
-        return this.contributions
-            .valueSeq()
-            .map((m) => m.size)
-            .reduce((totalSize, size) => totalSize + size) ?? 0;
-    }
     /**
      * The current communication round.
      */

package/dist/aggregator/get.d.ts

@@ -9,9 +9,9 @@ type AggregatorOptions = Partial<{
 /**
  * Initializes an aggregator according to the task definition, the training scheme and the aggregator parameters.
  * Here is the ordered list of parameters used to define the aggregator and its default behavior:
- * task.trainingInformation.aggregator > options.scheme > task.trainingInformation.scheme
+ * task.trainingInformation.aggregationStrategy > options.scheme > task.trainingInformation.scheme
  *
- * If `task.trainingInformation.aggregator` is defined, we initialize the chosen aggregator with `options` parameter values.
+ * If `task.trainingInformation.aggregationStrategy` is defined, we initialize the chosen aggregator with `options` parameter values.
  * Otherwise, we default to a MeanAggregator for both training schemes.
  *
  * For the MeanAggregator we rely on `options.scheme` and fallback on `task.trainingInformation.scheme` to infer default values.

package/dist/aggregator/get.js

@@ -2,9 +2,9 @@ import { aggregator } from '../index.js';
 /**
  * Initializes an aggregator according to the task definition, the training scheme and the aggregator parameters.
  * Here is the ordered list of parameters used to define the aggregator and its default behavior:
- * task.trainingInformation.aggregator > options.scheme > task.trainingInformation.scheme
+ * task.trainingInformation.aggregationStrategy > options.scheme > task.trainingInformation.scheme
  *
- * If `task.trainingInformation.aggregator` is defined, we initialize the chosen aggregator with `options` parameter values.
+ * If `task.trainingInformation.aggregationStrategy` is defined, we initialize the chosen aggregator with `options` parameter values.
  * Otherwise, we default to a MeanAggregator for both training schemes.
  *
  * For the MeanAggregator we rely on `options.scheme` and fallback on `task.trainingInformation.scheme` to infer default values.
@@ -18,9 +18,9 @@ import { aggregator } from '../index.js';
  * @returns The aggregator
  */
 export function getAggregator(task, options = {}) {
-    const aggregatorType = task.trainingInformation.aggregator ?? 'mean';
+    const aggregationStrategy = task.trainingInformation.aggregationStrategy ?? 'mean';
     const scheme = options.scheme ?? task.trainingInformation.scheme;
-    switch (aggregatorType) {
+    switch (aggregationStrategy) {
         case 'mean':
             if (scheme === 'decentralized') {
                 // If options are not specified, we default to expecting a contribution from all peers, so we set the threshold to 100%

package/dist/aggregator/index.d.ts

@@ -1,7 +1,4 @@
-import type { WeightsContainer } from '../weights/index.js';
-import type { Base } from './base.js';
-export { Base as AggregatorBase, AggregationStep } from './base.js';
+export { Aggregator, AggregationStep } from './aggregator.js';
 export { MeanAggregator } from './mean.js';
 export { SecureAggregator } from './secure.js';
 export { getAggregator } from './get.js';
-export type Aggregator = Base<WeightsContainer>;

package/dist/aggregator/index.js

@@ -1,4 +1,4 @@
-export { Base as AggregatorBase, AggregationStep } from './base.js';
+export { Aggregator, AggregationStep } from './aggregator.js';
 export { MeanAggregator } from './mean.js';
 export { SecureAggregator } from './secure.js';
 export { getAggregator } from './get.js';

package/dist/aggregator/mean.d.ts

@@ -1,12 +1,12 @@
 import type { Map } from "immutable";
-import { Base as Aggregator } from "./base.js";
+import { Aggregator } from "./aggregator.js";
 import type { WeightsContainer, client } from "../index.js";
 type ThresholdType = 'relative' | 'absolute';
 /**
  * Mean aggregator whose aggregation step consists in computing the mean of the received weights.
  *
  */
-export declare class MeanAggregator extends Aggregator<WeightsContainer> {
+export declare class MeanAggregator extends Aggregator {
     #private;
     /**
      * Create a mean aggregator that averages all weight updates received when a specified threshold is met.
@@ -31,8 +31,8 @@ export declare class MeanAggregator extends Aggregator<WeightsContainer> {
     /** Checks whether the contributions buffer is full. */
     isFull(): boolean;
     set minNbOfParticipants(minNbOfParticipants: number);
-    add(nodeId: client.NodeID, contribution: WeightsContainer, round: number, currentContributions?: number): boolean;
-    aggregate(): void;
+    _add(nodeId: client.NodeID, contribution: WeightsContainer): void;
+    aggregate(): WeightsContainer;
     makePayloads(weights: WeightsContainer): Map<client.NodeID, WeightsContainer>;
 }
 export {};

package/dist/aggregator/mean.js

@@ -1,5 +1,5 @@
 import createDebug from "debug";
-import { AggregationStep, Base as Aggregator } from "./base.js";
+import { AggregationStep, Aggregator } from "./aggregator.js";
 import { aggregation } from "../index.js";
 const debug = createDebug("discojs:aggregator:mean");
 /**
@@ -54,7 +54,7 @@ export class MeanAggregator extends Aggregator {
         else {
             // Print a warning regarding the default behavior when thresholdType is not specified
             if (thresholdType === undefined) {
-                // TODO enforce validity by splitting features instead of warning
+                // TODO enforce validity by splitting the different threshold types into separate classes instead of warning
                 debug("[WARN] Setting the aggregator's threshold to 100% of the nodes' contributions by default. " +
                     "To instead wait for a single contribution, set thresholdType = 'absolute'");
                 this.#thresholdType = 'relative';
@@ -79,18 +79,9 @@ export class MeanAggregator extends Aggregator {
     set minNbOfParticipants(minNbOfParticipants) {
         this.#minNbOfParticipants = minNbOfParticipants;
     }
-    add(nodeId, contribution, round, currentContributions = 0) {
-        if (currentContributions !== 0)
-            throw new Error("only a single communication round");
-        if (!this.isValidContribution(nodeId, round))
-            return false;
-        this.log(this.contributions.hasIn([0, nodeId])
-            ? AggregationStep.UPDATE
-            : AggregationStep.ADD, nodeId);
+    _add(nodeId, contribution) {
+        this.log(this.contributions.hasIn([0, nodeId]) ? AggregationStep.UPDATE : AggregationStep.ADD, nodeId);
         this.contributions = this.contributions.setIn([0, nodeId], contribution);
-        if (this.isFull())
-            this.aggregate();
-        return true;
     }
     aggregate() {
         const currentContributions = this.contributions.get(0);
@@ -98,8 +89,7 @@ export class MeanAggregator extends Aggregator {
             throw new Error("aggregating without any contribution");
         this.log(AggregationStep.AGGREGATE);
         const result = aggregation.avg(currentContributions.values());
-        // Emitting the event runs the superclass' callback to increment the round
-        this.emit('aggregation', result);
+        return result;
     }
     makePayloads(weights) {
         // Communicate our local weights to every other node, be it a peer or a server

package/dist/aggregator/secure.d.ts

@@ -1,5 +1,5 @@
 import { Map, List } from "immutable";
-import { Base as Aggregator } from "./base.js";
+import { Aggregator } from "./aggregator.js";
 import type { WeightsContainer, client } from "../index.js";
 /**
  * Aggregator implementing secure multi-party computation for decentralized learning.
@@ -8,11 +8,11 @@ import type { WeightsContainer, client } from "../index.js";
  * - then, they sum their received shares and communicate the result.
  * Finally, nodes are able to average the received partial sums to establish the aggregation result.
  */
-export declare class SecureAggregator extends Aggregator<WeightsContainer> {
+export declare class SecureAggregator extends Aggregator {
     private readonly maxShareValue;
     constructor(maxShareValue?: number);
-    aggregate(): void;
-    add(nodeId: client.NodeID, contribution: WeightsContainer, round: number, communicationRound?: number): boolean;
+    aggregate(): WeightsContainer;
+    _add(nodeId: client.NodeID, contribution: WeightsContainer, communicationRound: number): void;
     isFull(): boolean;
     makePayloads(weights: WeightsContainer): Map<client.NodeID, WeightsContainer>;
     /** Generate N additive shares that aggregate to the secret weights array, where N is the number of peers. */

package/dist/aggregator/secure.js

@@ -1,6 +1,6 @@
 import { Map, List, Range } from "immutable";
 import * as tf from "@tensorflow/tfjs";
-import { AggregationStep, Base as Aggregator } from "./base.js";
+import { AggregationStep, Aggregator } from "./aggregator.js";
 import { aggregation } from "../index.js";
 /**
  * Aggregator implementing secure multi-party computation for decentralized learning.
@@ -23,24 +23,20 @@ export class SecureAggregator extends Aggregator {
                 const currentContributions = this.contributions.get(0);
                 if (currentContributions === undefined)
                     throw new Error("aggregating without any contribution");
-                const result = aggregation.sum(currentContributions.values());
-                this.emit('aggregation', result);
-                break;
+                return aggregation.sum(currentContributions.values());
             }
             // Average the received partial sums
             case 1: {
                 const currentContributions = this.contributions.get(1);
                 if (currentContributions === undefined)
                     throw new Error("aggregating without any contribution");
-                const result = aggregation.avg(currentContributions.values());
-                this.emit('aggregation', result);
-                break;
+                return aggregation.avg(currentContributions.values());
             }
             default:
                 throw new Error("communication round is out of bounds");
         }
     }
-    add(nodeId, contribution, round, communicationRound) {
+    _add(nodeId, contribution, communicationRound) {
         switch (communicationRound) {
             case 0:
             case 1:
@@ -48,15 +44,9 @@ export class SecureAggregator extends Aggregator {
             default:
                 throw new Error("requires communication round to be 0 or 1");
         }
-        if (!this.isValidContribution(nodeId, round))
-            return false;
-        this.log(this.contributions.hasIn([communicationRound, nodeId])
-            ? AggregationStep.UPDATE
-            : AggregationStep.ADD, nodeId);
+        this.log(this.contributions.hasIn([communicationRound, nodeId]) ?
+            AggregationStep.UPDATE : AggregationStep.ADD, nodeId.slice(0, 4));
         this.contributions = this.contributions.setIn([communicationRound, nodeId], contribution);
-        if (this.isFull())
-            this.aggregate();
-        return true;
     }
     isFull() {
         return ((this.contributions.get(this.communicationRound)?.size ?? 0) ===
@@ -66,7 +56,7 @@ export class SecureAggregator extends Aggregator {
         switch (this.communicationRound) {
             case 0: {
                 const shares = this.generateAllShares(weights);
-                // Abitrarily assign our shares to the available nodes
+                // Arbitrarily assign our shares to the available nodes
                 return Map(List(this.nodes).zip(shares));
             }
             // Send our partial sum to every other nodes

package/dist/client/client.d.ts

@@ -13,21 +13,35 @@ export declare abstract class Client extends EventEmitter<{
     readonly url: URL;
     readonly task: Task;
     readonly aggregator: Aggregator;
-    /**
-     * Own ID provided by the network's server.
-     */
     protected _ownId?: NodeID;
+    protected _server?: EventConnection;
+    protected aggregationResult?: Promise<WeightsContainer>;
     /**
-     * The network's server.
+     * When the server notifies clients to pause and wait until more
+     * participants join, we rely on this promise to wait
+     * until the server signals that the training can resume
      */
-    protected _server?: EventConnection;
+    protected promiseForMoreParticipants: Promise<void> | undefined;
     /**
-     * The aggregator's result produced after aggregation.
+     * When the server notifies the client that they can resume training
+     * after waiting for more participants, we want to be able to display what
+     * we were doing before waiting (training locally or updating our model).
+     * We use this attribute to store the status to rollback to when we stop waiting
      */
-    protected aggregationResult?: Promise<WeightsContainer>;
+    private previousStatus;
     constructor(url: URL, // The network server's URL to connect to
     task: Task, // The client's corresponding task
     aggregator: Aggregator);
+    /**
+     * Communication callback called at the beginning of every training round.
+     */
+    abstract onRoundBeginCommunication(): Promise<void>;
+    /**
+     * Communication callback called the end of every training round.
+     * @param weights The local weight update resulting for the current local training round
+     * @returns aggregated weights or the local weights upon error
+     */
+    abstract onRoundEndCommunication(weights: WeightsContainer): Promise<WeightsContainer>;
     /**
      * Handles the connection process from the client to any sort of network server.
      * This method is overriden by the federated and decentralized clients
@@ -39,21 +53,61 @@ export declare abstract class Client extends EventEmitter<{
      */
     disconnect(): Promise<void>;
     /**
-     * Fetches the latest model available on the network's server, for the adequate task.
-     * @returns The latest model
+     * Emits the round status specified. It also stores the status emitted such that
+     * if the server tells the client to wait for more participants, it can display
+     * the waiting status and once enough participants join, it can display the previous status again
      */
-    getLatestModel(): Promise<Model>;
+    protected saveAndEmit(status: RoundStatus): void;
     /**
-     * Communication callback called at the beginning of every training round.
+     * For both federated and decentralized clients, we listen to the server to tell
+     * us whether there are enough participants to train. If not, we pause until further notice.
+     * When a client connects to the server, the server answers with the session information (id,
+     * number of participants) and whether there are enough participants.
+     * When there are the server sends a new EnoughParticipant message to update the client.
+     *
+     * `setMessageInversionFlag` is used to address the following scenario:
+     * 1. Client 1 connect to the server
+     * 2. Server answers with message A containing "not enough participants"
+     * 3. Before A arrives a new client joins. There are enough participants now.
+     * 4. Server updates client 1 with message B saying "there are enough participants"
+     * 5. Due to network and message sizes message B can arrive before A.
+     * i.e. "there are enough participants" arrives before "not enough participants"
+     * ending up with client 1 thinking it needs to wait for more participants.
+     *
+     * To keep track of this message inversion, `setMessageInversionFlag`
+     * tells us whether a message inversion occurred (by setting a boolean to true)
+     *
+     * @param setMessageInversionFlag function flagging whether a message inversion occurred
+     * between a NewNodeInfo message and an EnoughParticipant message.
      */
-    abstract onRoundBeginCommunication(): Promise<void>;
+    protected setupServerCallbacks(setMessageInversionFlag: () => void): void;
     /**
-     * Communication callback called the end of every training round.
-     * @param weights The local weight update resulting for the current local training round
-     * @returns aggregated weights or the local weights upon error
+     * Method called when the server notifies the client that there aren't enough
+     * participants (anymore) to start/continue training
+     * The method creates a promise that will resolve once the server notifies
+     * the client that the training can resume via a subsequent EnoughParticipants message
+     * @returns a promise which resolves when enough participants joined the session
      */
-    abstract onRoundEndCommunication(weights: WeightsContainer): Promise<WeightsContainer>;
-    get nbOfParticipants(): number;
+    protected createPromiseForMoreParticipants(): Promise<void>;
+    protected waitForParticipantsIfNeeded(): Promise<void>;
+    /**
+     * Fetches the latest model available on the network's server, for the adequate task.
+     * @returns The latest model
+     */
+    getLatestModel(): Promise<Model>;
+    /**
+    * Number of contributors to a collaborative session
+    * If decentralized, it should be the number of peers
+    * If federated, it should the number of participants excluding the server
+    * If local it should be 1
+    */
+    abstract getNbOfParticipants(): number;
     get ownId(): NodeID;
     get server(): EventConnection;
+    /**
+     * Whether the client should wait until more
+     * participants join the session, i.e. a promise has been created
+     */
+    get waitingForMoreParticipants(): boolean;
 }
+export declare function shortenId(id: string): string;