@epfml/discojs 2.2.2-p20240703101552.0 → 3.0.0

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

@@ -1,7 +1,5 @@
-import { type WeightsContainer } from '../../index.js';
+import type { WeightsContainer } from "../../index.js";
 import { Client } from '../index.js';
-import { type PeerConnection } from '../event_connection.js';
-import * as messages from './messages.js';
 /**
  * Represents a decentralized client in a network of peers. Peers coordinate each other with the
  * help of the network's server, yet only exchange payloads between each other. Communication
@@ -14,19 +12,38 @@ export declare class Base extends Client {
      */
     private pool?;
     private connections?;
+    private get isDisconnected();
     /**
-     * Send message to server that this client is ready for the next training round.
+     * Public method called by disco.ts when starting training. This method sends
+     * a message to the server asking to join the task and be assigned a client ID.
+     *
+     * The peer also establishes a WebSocket connection with the server to then
+     * create peer-to-peer WebRTC connections with peers. The server is used to exchange
+     * peers network information.
      */
-    private waitForPeers;
-    protected sendMessagetoPeer(peer: PeerConnection, msg: messages.PeerMessage): void;
+    connect(): Promise<void>;
     /**
-     * Creation of the WebSocket for the server, connection of client to that WebSocket,
-     * deals with message reception from the decentralized client's perspective (messages received by client).
+     * Create a WebSocket connection with the server
+     * The client then waits for the server to forward it other client's network information.
+     * Upon receiving other peer's information, the clients establish a peer-to-peer WebRTC connection.
      */
     private connectServer;
-    connect(): Promise<void>;
     disconnect(): Promise<void>;
+    /**
+     * At the beginning of a round, each peer tells the server it is ready to proceed
+     * The server answers with the list of all peers connected for the round
+     * Given the list, the peers then create peer-to-peer connections with each other.
+     * When connected, one peer creates a promise for every other peer's weight update
+     * and waits for it to resolve.
+     *
+     */
     onRoundBeginCommunication(_: WeightsContainer, round: number): Promise<void>;
-    onRoundEndCommunication(weights: WeightsContainer, round: number): Promise<void>;
+    /**
+     * At each communication rounds, awaits peers contributions and add them to the client's aggregator.
+     * This method is used as callback by getPeers when connecting to the rounds' peers
+     * @param connections
+     * @param round
+     */
     private receivePayloads;
+    onRoundEndCommunication(weights: WeightsContainer, round: number): Promise<WeightsContainer>;
 }

package/dist/client/decentralized/base.js

@@ -1,5 +1,5 @@
 import { Map, Set } from 'immutable';
-import { serialization } from '../../index.js';
+import { serialization } from "../../index.js";
 import { Client } from '../index.js';
 import { type } from '../messages.js';
 import { timeout } from '../utils.js';
@@ -18,63 +18,18 @@ export class Base extends Client {
      */
     pool;
     connections;
-    /**
-     * Send message to server that this client is ready for the next training round.
-     */
-    async waitForPeers(round) {
-        console.info(`[${this.ownId}] is ready for round`, round);
-        // Broadcast our readiness
-        const readyMessage = { type: type.PeerIsReady };
-        if (this.server === undefined) {
-            throw new Error('server undefined, could not connect peers');
-        }
-        this.server.send(readyMessage);
-        // Wait for peers to be connected before sending any update information
-        try {
-            const receivedMessage = await waitMessageWithTimeout(this.server, type.PeersForRound);
-            if (this.nodes.size > 0) {
-                throw new Error('got new peer list from server but was already received for this round');
-            }
-            const peers = Set(receivedMessage.peers);
-            console.info(`[${this.ownId}] received peers for round:`, peers.toJS());
-            if (this.ownId !== undefined && peers.has(this.ownId)) {
-                throw new Error('received peer list contains our own id');
-            }
-            this.aggregator.setNodes(peers.add(this.ownId));
-            if (this.pool === undefined) {
-                throw new Error('waiting for peers but peer pool is undefined');
-            }
-            const connections = await this.pool.getPeers(peers, this.server, 
-            // Init receipt of peers weights
-            (conn) => { this.receivePayloads(conn, round); });
-            console.info(`[${this.ownId}] received peers for round ${round}:`, connections.keySeq().toJS());
-            return connections;
-        }
-        catch (e) {
-            console.error(e);
-            this.aggregator.setNodes(Set(this.ownId));
-            return Map();
-        }
-    }
-    sendMessagetoPeer(peer, msg) {
-        console.info(`[${this.ownId}] send message to peer`, msg.peer, msg);
-        peer.send(msg);
+    // Used to handle timeouts and promise resolving after calling disconnect
+    get isDisconnected() {
+        return this._server === undefined;
     }
     /**
-     * Creation of the WebSocket for the server, connection of client to that WebSocket,
-     * deals with message reception from the decentralized client's perspective (messages received by client).
+     * Public method called by disco.ts when starting training. This method sends
+     * a message to the server asking to join the task and be assigned a client ID.
+     *
+     * The peer also establishes a WebSocket connection with the server to then
+     * create peer-to-peer WebRTC connections with peers. The server is used to exchange
+     * peers network information.
      */
-    async connectServer(url) {
-        const server = await WebSocketServer.connect(url, messages.isMessageFromServer, messages.isMessageToServer);
-        server.on(type.SignalForPeer, (event) => {
-            console.info(`[${this.ownId}] received signal from`, event.peer);
-            if (this.pool === undefined) {
-                throw new Error('received signal but peer pool is undefined');
-            }
-            this.pool.signal(event.peer, event.signal);
-        });
-        return server;
-    }
     async connect() {
         const serverURL = new URL('', this.url.href);
         switch (this.url.protocol) {
@@ -94,13 +49,29 @@ export class Base extends Client {
         };
         this.server.send(msg);
         const peerIdMsg = await waitMessage(this.server, type.AssignNodeID);
-        console.info(`[${peerIdMsg.id}] assigned id generated by server`);
+        console.log(`[${peerIdMsg.id}] assigned id generated by server`);
         if (this._ownId !== undefined) {
             throw new Error('received id from server but was already received');
         }
         this._ownId = peerIdMsg.id;
         this.pool = new PeerPool(peerIdMsg.id);
     }
+    /**
+     * Create a WebSocket connection with the server
+     * The client then waits for the server to forward it other client's network information.
+     * Upon receiving other peer's information, the clients establish a peer-to-peer WebRTC connection.
+     */
+    async connectServer(url) {
+        const server = await WebSocketServer.connect(url, messages.isMessageFromServer, messages.isMessageToServer);
+        server.on(type.SignalForPeer, (event) => {
+            if (this.pool === undefined) {
+                throw new Error('received signal but peer pool is undefined');
+            }
+            // Create a WebRTC connection with the peer
+            this.pool.signal(event.peer, event.signal);
+        });
+        return server;
+    }
     async disconnect() {
         // Disconnect from peers
         await this.pool?.shutdown();
@@ -115,20 +86,92 @@ export class Base extends Client {
         this._ownId = undefined;
         return Promise.resolve();
     }
+    /**
+     * At the beginning of a round, each peer tells the server it is ready to proceed
+     * The server answers with the list of all peers connected for the round
+     * Given the list, the peers then create peer-to-peer connections with each other.
+     * When connected, one peer creates a promise for every other peer's weight update
+     * and waits for it to resolve.
+     *
+     */
     async onRoundBeginCommunication(_, round) {
+        if (this.server === undefined) {
+            throw new Error("peer's server is undefined, make sure to call `client.connect()` first");
+        }
+        if (this.pool === undefined) {
+            throw new Error('peer pool is undefined, make sure to call `client.connect()` first');
+        }
         // Reset peers list at each round of training to make sure client works with an updated peers
         // list, maintained by the server. Adds any received weights to the aggregator.
-        this.connections = await this.waitForPeers(round);
+        // this.connections = await this.waitForPeers(round)
+        // Tell the server we are ready for the next round
+        const readyMessage = { type: type.PeerIsReady };
+        this.server.send(readyMessage);
+        // Wait for the server to answer with the list of peers for the round
+        try {
+            const receivedMessage = await waitMessageWithTimeout(this.server, type.PeersForRound, undefined, "Timeout waiting for the round's peer list");
+            const peers = Set(receivedMessage.peers);
+            if (this.ownId !== undefined && peers.has(this.ownId)) {
+                throw new Error('received peer list contains our own id');
+            }
+            // Store the list of peers for the current round including ourselves
+            this.aggregator.setNodes(peers.add(this.ownId));
+            // Initiate peer to peer connections with each peer
+            // When connected, create a promise waiting for each peer's round contribution
+            const connections = await this.pool.getPeers(peers, this.server, 
+            // Init receipt of peers weights
+            // this awaits the peer's weight update and adds it to 
+            // our aggregator upon reception
+            (conn) => { this.receivePayloads(conn, round); });
+            console.log(`[${this.ownId}] received peers for round ${round}:`, connections.keySeq().toJS());
+            this.connections = connections;
+        }
+        catch (e) {
+            console.error(e);
+            this.aggregator.setNodes(Set(this.ownId));
+            this.connections = Map();
+        }
         // Store the promise for the current round's aggregation result.
-        this.aggregationResult = this.aggregator.receiveResult();
+        // We will await for it to resolve at the end of the round when exchanging weight updates.
+        this.aggregationResult = new Promise((resolve) => this.aggregator.once('aggregation', resolve));
+    }
+    /**
+     * At each communication rounds, awaits peers contributions and add them to the client's aggregator.
+     * This method is used as callback by getPeers when connecting to the rounds' peers
+     * @param connections
+     * @param round
+     */
+    receivePayloads(connections, round) {
+        connections.forEach(async (connection, peerId) => {
+            let currentCommunicationRounds = 0;
+            console.log(`waiting for peer ${peerId}`);
+            do {
+                try {
+                    const message = await waitMessageWithTimeout(connection, type.Payload, 60_000, "Timeout waiting for a contribution from peer " + peerId);
+                    const decoded = serialization.weights.decode(message.payload);
+                    if (!this.aggregator.add(peerId, decoded, round, message.round)) {
+                        console.warn(`[${this.ownId}] Failed to add contribution from peer ${peerId}`);
+                    }
+                }
+                catch (e) {
+                    if (this.isDisconnected) {
+                        return;
+                    }
+                    console.error(e instanceof Error ? e.message : e);
+                }
+            } while (++currentCommunicationRounds < this.aggregator.communicationRounds);
+        });
     }
     async onRoundEndCommunication(weights, round) {
-        let result = weights;
+        if (this.aggregationResult === undefined) {
+            throw new TypeError('aggregation result promise is undefined');
+        }
         // Perform the required communication rounds. Each communication round consists in sending our local payload,
         // followed by an aggregation step triggered by the receipt of other payloads, and handled by the aggregator.
         // A communication round's payload is the aggregation result of the previous communication round. The first
         // communication round simply sends our training result, i.e. model weights updates. This scheme allows for
         // the aggregator to define any complex multi-round aggregation mechanism.
+        let result = weights;
         for (let r = 0; r < this.aggregator.communicationRounds; r++) {
             // Generate our payloads for this communication round and send them to all ready connected peers
             if (this.connections !== undefined) {
@@ -139,15 +182,17 @@ export class Base extends Client {
                             this.aggregator.add(this.ownId, payload, round, r);
                         }
                         else {
-                            const connection = this.connections?.get(id);
-                            if (connection !== undefined) {
+                            const peer = this.connections?.get(id);
+                            if (peer !== undefined) {
                                 const encoded = await serialization.weights.encode(payload);
-                                this.sendMessagetoPeer(connection, {
+                                const msg = {
                                     type: type.Payload,
                                     peer: id,
                                     round: r,
                                     payload: encoded
-                                });
+                                };
+                                peer.send(msg);
+                                console.log(`[${this.ownId}] send weight update to peer`, msg.peer, msg);
                             }
                         }
                     }));
@@ -156,37 +201,29 @@ export class Base extends Client {
                     throw new Error('error while sending weights');
                 }
             }
-            if (this.aggregationResult === undefined) {
-                throw new TypeError('aggregation result promise is undefined');
-            }
             // Wait for aggregation before proceeding to the next communication round.
             // The current result will be used as payload for the eventual next communication round.
-            result = await Promise.race([this.aggregationResult, timeout()]);
+            try {
+                result = await Promise.race([
+                    this.aggregationResult,
+                    timeout(undefined, "Timeout waiting on the aggregation result promise to resolve")
+                ]);
+            }
+            catch (e) {
+                if (this.isDisconnected) {
+                    return weights;
+                }
+                console.error(e);
+                break;
+            }
             // There is at least one communication round remaining
             if (r < this.aggregator.communicationRounds - 1) {
                 // Reuse the aggregation result
-                this.aggregationResult = this.aggregator.receiveResult();
+                this.aggregationResult = new Promise((resolve) => this.aggregator.once('aggregation', resolve));
             }
         }
         // Reset the peers list for the next round
         this.aggregator.resetNodes();
-    }
-    receivePayloads(connections, round) {
-        console.info(`[${this.ownId}] Accepting new contributions for round ${round}`);
-        connections.forEach(async (connection, peerId) => {
-            let receivedPayloads = 0;
-            do {
-                try {
-                    const message = await waitMessageWithTimeout(connection, type.Payload);
-                    const decoded = serialization.weights.decode(message.payload);
-                    if (!this.aggregator.add(peerId, decoded, round, message.round)) {
-                        console.warn(`[${this.ownId}] Failed to add contribution from peer ${peerId}`);
-                    }
-                }
-                catch (e) {
-                    console.warn(e instanceof Error ? e.message : e);
-                }
-            } while (++receivedPayloads < this.aggregator.communicationRounds);
-        });
+        return await this.aggregationResult;
     }
 }

package/dist/client/decentralized/peer.js

@@ -58,13 +58,7 @@ export class Peer {
         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);
+        return this.bufferSize;
     }
     chunk(b) {
         const messageID = this.sendCounter;
@@ -79,7 +73,8 @@ export class Peer {
         }
         const totalChunkCount = 1 + tail.count();
         if (totalChunkCount > 0xFF) {
-            throw new Error('too big message to even chunk it');
+            throw new Error(`The payload is too big: ${totalChunkCount * this.maxChunkSize} bytes > 255,` +
+                ' consider reducing the model size or increasing the chunk size');
         }
         const firstChunk = Buffer.alloc((b.length > this.maxChunkSize - FIRST_HEADER_SIZE)
             ? this.maxChunkSize
@@ -106,7 +101,7 @@ export class Peer {
         });
     }
     signal(signal) {
-        // extract max buffer size
+        // extract max buffer size from the signal
         if (signal.type === 'offer' || signal.type === 'answer') {
             if (signal.sdp === undefined) {
                 throw new Error('signal answer|offer without session description');
@@ -138,8 +133,8 @@ export class Peer {
             if (!Buffer.isBuffer(data) || data.length < HEADER_SIZE) {
                 throw new Error('received invalid message type');
             }
-            const messageID = data.readUint16BE();
-            const chunkID = data.readUint8(2);
+            const messageID = data.readUInt16BE(); //readUint16BE (case sensitive) fails at runtime
+            const chunkID = data.readUInt8(2); // same for readUint8
             const received = this.receiving.get(messageID, {
                 total: undefined,
                 chunks: Map()
@@ -161,7 +156,7 @@ export class Peer {
                 if (total !== undefined) {
                     throw new Error('first header received twice');
                 }
-                const readTotal = data.readUint8(3);
+                const readTotal = data.readUInt8(3);
                 total = readTotal;
                 chunk = Buffer.alloc(data.length - FIRST_HEADER_SIZE);
                 data.copy(chunk, 0, FIRST_HEADER_SIZE);

package/dist/client/decentralized/peer_pool.js

@@ -9,8 +9,12 @@ export class PeerPool {
         this.id = id;
     }
     async shutdown() {
-        console.info(`[${this.id}] shutdown their peers`);
-        await Promise.all(this.peers.valueSeq().map((peer) => peer.disconnect()));
+        console.info(`[${this.id}] is shutting down all its connections`);
+        // Add a timeout o.w. the promise hangs forever if the other peer is already disconnected
+        await Promise.race([
+            Promise.all(this.peers.valueSeq().map((peer) => peer.disconnect())),
+            new Promise((res, _) => setTimeout(res, 1000)) // Wait for other peers to finish
+        ]);
         this.peers = Map();
     }
     signal(peerId, signal) {

package/dist/client/event_connection.d.ts

@@ -9,7 +9,7 @@ export interface EventConnection {
     disconnect: () => Promise<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 function waitMessageWithTimeout<T extends type>(connection: EventConnection, type: T, timeoutMs?: number, errorMsg?: string): Promise<NarrowMessage<T>>;
 export declare class PeerConnection extends EventEmitter<{
     [K in type]: NarrowMessage<K>;
 }> implements EventConnection {

package/dist/client/event_connection.js

@@ -12,8 +12,8 @@ export async function waitMessage(connection, type) {
         });
     });
 }
-export async function waitMessageWithTimeout(connection, type, timeoutMs) {
-    return await Promise.race([waitMessage(connection, type), timeout(timeoutMs)]);
+export async function waitMessageWithTimeout(connection, type, timeoutMs, errorMsg = 'timeout') {
+    return await Promise.race([waitMessage(connection, type), timeout(timeoutMs, errorMsg)]);
 }
 export class PeerConnection extends EventEmitter {
     _ownId;
@@ -41,7 +41,7 @@ export class PeerConnection extends EventEmitter {
             }
             this.emit(msg.type, msg);
         });
-        this.peer.on('close', () => { console.warn('peer', this.peer.id, 'closed connection'); });
+        this.peer.on('close', () => { console.warn('From', this._ownId, ': peer', this.peer.id, 'closed connection'); });
         await new Promise((resolve) => {
             this.peer.on('connect', resolve);
         });

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

@@ -1,22 +1,18 @@
-import { Map } from "immutable";
-import { type MetadataKey, type MetadataValue, type WeightsContainer } from "../../index.js";
-import { type NodeID } from "../types.js";
+import { type WeightsContainer } from "../../index.js";
 import { Base as Client } from "../base.js";
 /**
  * Client class that communicates with a centralized, federated server, when training
  * a specific task in the federated setting.
  */
 export declare class Base extends Client {
+    #private;
     /**
      * Arbitrary node id assigned to the federated server which we are communicating with.
      * Indeed, the server acts as a node within the network. In the federated setting described
      * by this client class, the server is the only node which we are communicating with.
      */
     static readonly SERVER_NODE_ID = "federated-server-node-id";
-    /**
-     * Map of metadata values for each node id.
-     */
-    private metadataMap?;
+    get nbOfParticipants(): number;
     /**
      * Opens a new WebSocket connection with the server and listens to new messages over the channel
      */
@@ -31,24 +27,12 @@ export declare class Base extends Client {
      * Disconnection process when user quits the task.
      */
     disconnect(): Promise<void>;
+    onRoundBeginCommunication(): Promise<void>;
+    onRoundEndCommunication(weights: WeightsContainer, round: number): Promise<WeightsContainer>;
     /**
      * Send a message containing our local weight updates to the federated server.
      * And waits for the server to reply with the most recent aggregated weights
      * @param payload The weight updates to send
      */
     private sendPayloadAndReceiveResult;
-    /**
-     * Waits for the server's result for its current (most recent) round and add it to our aggregator.
-     * Updates the aggregator's round if it's behind the server's.
-     */
-    private receiveResult;
-    /**
-     * Fetch the metadata values maintained by the federated server, for a given metadata key.
-     * The values are indexed by node id.
-     * @param key The metadata key
-     * @returns The map of node id to metadata value
-     */
-    receiveMetadataMap(key: MetadataKey): Promise<Map<NodeID, MetadataValue> | undefined>;
-    onRoundBeginCommunication(): Promise<void>;
-    onRoundEndCommunication(weights: WeightsContainer, round: number): Promise<void>;
 }

package/dist/client/federated/base.js

@@ -1,4 +1,3 @@
-import { Map } from "immutable";
 import { serialization, } from "../../index.js";
 import { Base as Client } from "../base.js";
 import { type } from "../messages.js";
@@ -15,10 +14,13 @@ export class Base extends Client {
      * by this client class, the server is the only node which we are communicating with.
      */
     static SERVER_NODE_ID = "federated-server-node-id";
-    /**
-     * Map of metadata values for each node id.
-     */
-    metadataMap;
+    // Total number of other federated contributors, including this client, excluding the server
+    // E.g., if 3 users are training a federated model, nbOfParticipants is 3
+    #nbOfParticipants = 1;
+    // the number of participants excluding the server
+    get nbOfParticipants() {
+        return this.#nbOfParticipants;
+    }
     /**
      * Opens a new WebSocket connection with the server and listens to new messages over the channel
      */
@@ -64,6 +66,32 @@ export class Base extends Client {
         this.aggregator.setNodes(this.aggregator.nodes.delete(Base.SERVER_NODE_ID));
         return Promise.resolve();
     }
+    onRoundBeginCommunication() {
+        // Prepare the result promise for the incoming round
+        this.aggregationResult = new Promise((resolve) => this.aggregator.once('aggregation', resolve));
+        return Promise.resolve();
+    }
+    async onRoundEndCommunication(weights, round) {
+        // NB: For now, we suppose a fully-federated setting.
+        if (this.aggregationResult === undefined) {
+            throw new Error("local aggregation result was not set");
+        }
+        // Send our local contribution to the server
+        // and receive the most recent weights as an answer to our contribution
+        const serverResult = await this.sendPayloadAndReceiveResult(this.aggregator.makePayloads(weights).first());
+        if (serverResult !== undefined &&
+            this.aggregator.add(Base.SERVER_NODE_ID, serverResult, round, 0)) {
+            // Regular case: the server sends us its aggregation result which will serve our
+            // own aggregation result.
+        }
+        else {
+            // Unexpected case: for some reason, the server result is stale.
+            // We proceed to the next round without its result.
+            console.info(`[${this.ownId}] Server result is either stale or not received`);
+            this.aggregator.nextRound();
+        }
+        return await this.aggregationResult;
+    }
     /**
      * Send a message containing our local weight updates to the federated server.
      * And waits for the server to reply with the most recent aggregated weights
@@ -76,17 +104,13 @@ export class Base extends Client {
             round: this.aggregator.round,
         };
         this.server.send(msg);
-        // It is important than the client immediately awaits the server result or it may miss it
-        return await this.receiveResult();
-    }
-    /**
-     * Waits for the server's result for its current (most recent) round and add it to our aggregator.
-     * Updates the aggregator's round if it's behind the server's.
-     */
-    async receiveResult() {
+        // Waits for the server's result for its current (most recent) round and add it to our aggregator.
+        // Updates the aggregator's round if it's behind the server's.
         try {
-            const { payload, round } = await waitMessageWithTimeout(this.server, type.ReceiveServerPayload);
+            // It is important than the client immediately awaits the server result or it may miss it
+            const { payload, round, nbOfParticipants } = await waitMessageWithTimeout(this.server, type.ReceiveServerPayload);
             const serverRound = round;
+            this.#nbOfParticipants = nbOfParticipants; // Save the current participants
             // Store the server result only if it is not stale
             if (this.aggregator.round <= round) {
                 const serverResult = serialization.weights.decode(payload);
@@ -101,51 +125,4 @@ export class Base extends Client {
             console.error(e);
         }
     }
-    /**
-     * Fetch the metadata values maintained by the federated server, for a given metadata key.
-     * The values are indexed by node id.
-     * @param key The metadata key
-     * @returns The map of node id to metadata value
-     */
-    async receiveMetadataMap(key) {
-        this.metadataMap = undefined;
-        const msg = {
-            type: type.ReceiveServerMetadata,
-            taskId: this.task.id,
-            nodeId: this.ownId,
-            round: this.aggregator.round,
-            key,
-        };
-        this.server.send(msg);
-        const received = await waitMessageWithTimeout(this.server, type.ReceiveServerMetadata);
-        if (received.metadataMap !== undefined) {
-            this.metadataMap = Map(received.metadataMap.filter(([_, v]) => v !== undefined));
-        }
-        return this.metadataMap;
-    }
-    onRoundBeginCommunication() {
-        // Prepare the result promise for the incoming round
-        this.aggregationResult = this.aggregator.receiveResult();
-        return Promise.resolve();
-    }
-    async onRoundEndCommunication(weights, round) {
-        // NB: For now, we suppose a fully-federated setting.
-        if (this.aggregationResult === undefined) {
-            throw new Error("local aggregation result was not set");
-        }
-        // Send our local contribution to the server
-        // and receive the most recent weights as an answer to our contribution
-        const serverResult = await this.sendPayloadAndReceiveResult(this.aggregator.makePayloads(weights).first());
-        if (serverResult !== undefined &&
-            this.aggregator.add(Base.SERVER_NODE_ID, serverResult, round, 0)) {
-            // Regular case: the server sends us its aggregation result which will serve our
-            // own aggregation result.
-        }
-        else {
-            // Unexpected case: for some reason, the server result is stale.
-            // We proceed to the next round without its result.
-            console.info(`[${this.ownId}] Server result is either stale or not received`);
-            this.aggregator.nextRound();
-        }
-    }
 }

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

@@ -1,7 +1,6 @@
-import { type client, type MetadataKey, type MetadataValue } from '../../index.js';
 import { type weights } from '../../serialization/index.js';
 import { type, type AssignNodeID, type ClientConnected } from '../messages.js';
-export type MessageFederated = ClientConnected | SendPayload | ReceiveServerPayload | ReceiveServerMetadata | AssignNodeID;
+export type MessageFederated = ClientConnected | SendPayload | ReceiveServerPayload | AssignNodeID;
 export interface SendPayload {
     type: type.SendPayload;
     payload: weights.Encoded;
@@ -11,13 +10,6 @@ export interface ReceiveServerPayload {
     type: type.ReceiveServerPayload;
     payload: weights.Encoded;
     round: number;
-}
-export interface ReceiveServerMetadata {
-    type: type.ReceiveServerMetadata;
-    nodeId: client.NodeID;
-    taskId: string;
-    round: number;
-    key: MetadataKey;
-    metadataMap?: Array<[client.NodeID, MetadataValue | undefined]>;
+    nbOfParticipants: number;
 }
 export declare function isMessageFederated(raw: unknown): raw is MessageFederated;

package/dist/client/federated/messages.js

@@ -7,7 +7,6 @@ export function isMessageFederated(raw) {
         case type.ClientConnected:
         case type.SendPayload:
         case type.ReceiveServerPayload:
-        case type.ReceiveServerMetadata:
         case type.AssignNodeID:
             return true;
     }

package/dist/client/index.d.ts

@@ -4,5 +4,5 @@ export * as aggregator from '../aggregator/index.js';
 export * as decentralized from './decentralized/index.js';
 export * as federated from './federated/index.js';
 export * as messages from './messages.js';
-export * as utils from './utils.js';
+export { getClient, timeout } from './utils.js';
 export { Local } from './local.js';