Merge branch 'feat/tss-copayer-ready' of github.com:gabrielbazan7/bitcore

Author: kajoseph

packages/bitcore-wallet-client/src/lib/tsssign.ts

@@ -42,6 +42,7 @@ export class TssSign extends EventEmitter {
   #credentials: Credentials;
   #subscriptionId: ReturnType<typeof setInterval>;
   #subscriptionRunning: boolean;
+  #emittedParticipants: Set<string>;
   id: string;
 
 
@@ -136,6 +137,8 @@ export class TssSign extends EventEmitter {
     const msg = await this.#sign.initJoin();
     const m = this.#tssKey.metadata.m;
     await this.#request.post('/v1/tss/sign/' + this.id, { message: msg, m });
+    this.#emittedParticipants = new Set([this.#credentials.copayerId]);
+    this.emit('copayerReady', this.#credentials.copayerId);
     return this;
   }
 
@@ -180,6 +183,7 @@ export class TssSign extends EventEmitter {
    * - `signature` => ISignature: The signature is ready. Emits the signature object
    * - `complete` => void: The signature generation process is complete
    * - `error` => Error: An error occurred during the process. Emits the error. Note that this will not stop the subscription.
+   * - `copayerReady` => string: A copayer has joined the session. Emits the copayer ID.
    * @returns {NodeJS.Timeout} Subscription ID
    */
   subscribe(params: {
@@ -203,6 +207,16 @@ export class TssSign extends EventEmitter {
         const prevRound = thisRound - 1; // Get previous round's messages
         const { body } = await this.#request.get(`/v1/tss/sign/${this.id}/${prevRound}`) as RequestResponse;
 
+        if (body.participants?.length) {
+          for (const copayerId of body.participants as string[]) {
+            if (!this.#emittedParticipants?.has(copayerId)) {
+              this.#emittedParticipants ??= new Set();
+              this.#emittedParticipants.add(copayerId);
+              this.emit('copayerReady', copayerId);
+            }
+          }
+        }
+
         const hasEveryoneSubmitted = body.messages?.length === this.#tssKey.metadata.m - 1; // subtract yourself
         if (hasEveryoneSubmitted && !this.#sign.isSignatureReady()) {
           this.emit('roundready', thisRound);
@@ -270,6 +284,7 @@ export class TssSign extends EventEmitter {
     }
     this.#subscriptionId = null;
     this.#subscriptionRunning = false;
+    this.#emittedParticipants = null;
   }
 
   /**

packages/bitcore-wallet-client/test/tss.test.ts

@@ -634,6 +634,22 @@ describe('TSS', function() {
       sig0.id.should.equal(sig1.id);
     });
 
+    it(happyPath('should emit copayerReady for self on start() and for remote on subscribe()'), async function() {
+      const copayerReadyIds: string[] = [];
+      const sigA = new TssSign({ baseUrl: '/bws/api', request: request(app), credentials: party0Creds, tssKey: party0TssKey });
+      const sigB = new TssSign({ baseUrl: '/bws/api', request: request(app), credentials: party1Creds, tssKey: party1TssKey });
+      sigA.on('copayerReady', (id) => copayerReadyIds.push(id));
+      await sigA.start({ id: 'copayer-ready-test', messageHash, derivationPath });
+      copayerReadyIds.should.deep.equal([party0Creds.copayerId]);
+      await sigB.start({ id: 'copayer-ready-test', messageHash, derivationPath });
+      sigA.on('error', (e) => { should.not.exist(e?.message ?? e); });
+      const roundsubmitted = new Promise(r => sigA.once('roundsubmitted', r));
+      sigA.subscribe({ timeout: 10, iterHandler: () => sigA.unsubscribe() });
+      await roundsubmitted;
+      copayerReadyIds.should.include(party0Creds.copayerId);
+      copayerReadyIds.should.include(party1Creds.copayerId);
+    });
+
     it('should reject too many participants', async function() {
       const sig2 = new TssSign({
         baseUrl: '/bws/api',
@@ -715,11 +731,12 @@ describe('TSS', function() {
       const error = new Promise<Error>(r => sig0.on('error', r));
       sig0.subscribe({ timeout: 10, iterHandler: () => sig0.unsubscribe() });
       const e = await error;
-      emitSpy.callCount.should.equal(3);
-      emitSpy.args[0][0].should.equal('roundready');
-      emitSpy.args[1][0].should.equal('roundprocessed');
-      emitSpy.args[2][0].should.equal('error');
-      emitSpy.args[2][1].should.equal(e);
+      emitSpy.callCount.should.equal(4);
+      emitSpy.args[0][0].should.equal('copayerReady');
+      emitSpy.args[1][0].should.equal('roundready');
+      emitSpy.args[2][0].should.equal('roundprocessed');
+      emitSpy.args[3][0].should.equal('error');
+      emitSpy.args[3][1].should.equal(e);
       e.message.should.include('TSS_ROUND_ALREADY_DONE');
     });
 

packages/bitcore-wallet-service/src/lib/routes/tss.ts

@@ -100,8 +100,8 @@ export class TssRouter {
       try {
         const { id, round } = req.params as { [key: string]: string };
         const copayerId = req.headers['x-identity'];
-        const { messages, signature } = await TssSign.getMessagesForParty({ id, round: parseInt(round), copayerId });
-        return res.json({ messages, signature });
+        const { messages, signature, participants } = await TssSign.getMessagesForParty({ id, round: parseInt(round), copayerId });
+        return res.json({ messages, signature, participants });
       } catch (err) {
         return returnError(err ?? 'unknown', res, req);
       }

packages/bitcore-wallet-service/src/lib/tss.ts

@@ -279,9 +279,9 @@ class TssKeyGenClass {
 export const TssKeyGen = new TssKeyGenClass();
 
 class TssSignClass {
-  async getMessagesForParty(params: { id: string; round: number; copayerId: string }): Promise<{ messages?: ITssSigMessageObject[]; signature?: ITssSigMessageObject['signature'] }> {
+  async getMessagesForParty(params: { id: string; round: number; copayerId: string }): Promise<{ messages?: ITssSigMessageObject[]; signature?: ITssSigMessageObject['signature']; participants?: string[] }> {
     const { id, round, copayerId } = params;
-    
+
     const storage = WalletService.getStorage();
     const session = await storage.fetchTssSigSession({ id });
     if (!session) {
@@ -297,14 +297,19 @@ class TssSignClass {
     }
 
     const otherPartyMsgs = session.rounds[round].filter(m => m.fromPartyId != party.partyId);
+    const participants = otherPartyMsgs.map(m => {
+      const p = session.participants.find(p => p.partyId === m.fromPartyId);
+      return p?.copayerId;
+    }).filter(Boolean) as string[];
+
     if (otherPartyMsgs.length === session.m - 1) {
       const messages = otherPartyMsgs.map(m => m.messages);
       for (const m of messages) {
         m.p2pMessages = m.p2pMessages.filter(m => m.to == party.partyId);
       }
-      return { messages, signature: session.signature };
+      return { messages, signature: session.signature, participants };
     }
-    return {};
+    return { participants };
   }
 
   async processMessage(params: { id: string; message: ITssSigMessageObject; m?: string | number; copayerId: string }) {