@bitpay-labs/bitcore-wallet-service 11.10.13 → 11.11.0

package/src/lib/storage.ts

@@ -288,27 +288,19 @@ export class Storage {
     );
   }
 
-  fetchCopayerLookup(copayerId: string, cb: (err?: any, copayer?: Copayer) => void) {
-    this.db.collection(collections.COPAYERS_LOOKUP).findOne(
-      {
-        copayerId
-      },
-      (err, result) => {
-        if (err) return cb(err);
-        if (!result) return cb();
-
-        if (!result.requestPubKeys) {
-          result.requestPubKeys = [
-            {
-              key: result.requestPubKey,
-              signature: result.signature
-            }
-          ];
+  async fetchCopayerLookup(copayerId: string): Promise<Copayer | undefined> {
+    const result = await this.db.collection(collections.COPAYERS_LOOKUP).findOne({ copayerId });
+    if (!result) return;
+    if (!result.requestPubKeys) {
+      result.requestPubKeys = [
+        {
+          key: result.requestPubKey,
+          signature: result.signature
         }
+      ];
+    }
 
-        return cb(null, Copayer.fromObj(result));
-      }
-    );
+    return Copayer.fromObj(result);
   }
 
   // TODO: should be done client-side
@@ -1806,16 +1798,48 @@ export class Storage {
     return this.db.collection(collections.TSS_KEYGEN).insertOne(doc);
   }
 
-  async storeTssKeyGenParticipant({ id, partyId, copayerId }: { id: string; partyId: number; copayerId: string }) {
-    return this.db.collection(collections.TSS_KEYGEN).updateOne(
-      { id },
+  async storeTssKeyGenAuthPublicKey({ id, partyId, authPublicKey, __v }: { id: string; partyId: number; authPublicKey: string; __v: number }) {
+    const result = await this.db.collection(collections.TSS_KEYGEN).updateOne(
+      { id, __v },
+      {
+        $set: {
+          [`authPublicKeys.${partyId}`]: authPublicKey
+        },
+        $inc: {
+          __v: 1
+        }
+      },
+      { upsert: false }
+    );
+    if (!result.matchedCount) {
+      if ((await this.db.collection(collections.TSS_KEYGEN).countDocuments({ id })) === 0) {
+        throw new Error('MONGO_DOC_NOT_FOUND: No document found for id ' + id);
+      }
+      throw new Error('MONGO_DOC_OUTDATED: No document found for version ' + __v);
+    }
+    return result;
+  }
+
+  async storeTssKeyGenParticipant({ id, partyId, copayerId, __v }: { id: string; partyId: number; copayerId: string; __v: number }) {
+    const result = await this.db.collection(collections.TSS_KEYGEN).updateOne(
+      { id, __v },
       {
         $set: {
           [`participants.${partyId}`]: copayerId
+        },
+        $inc: {
+          __v: 1
         }
       },
       { upsert: false }
     );
+    if (!result.matchedCount) {
+      if ((await this.db.collection(collections.TSS_KEYGEN).countDocuments({ id })) === 0) {
+        throw new Error('MONGO_DOC_NOT_FOUND: No document found for id ' + id);
+      }
+      throw new Error('MONGO_DOC_OUTDATED: No document found for version ' + __v);
+    }
+    return result;
   }
 
   async storeTssKeyGenMessage({ id, message, __v }: { id: string; message: ITssKeyMessageObject; __v: number }) {
@@ -1835,6 +1859,9 @@ export class Storage {
       { upsert: false }
     );
     if (!result.matchedCount) {
+      if ((await this.db.collection(collections.TSS_KEYGEN).countDocuments({ id })) === 0) {
+        throw new Error('MONGO_DOC_NOT_FOUND: No document found for id ' + id);
+      }
       throw new Error('MONGO_DOC_OUTDATED: No document found for version ' + __v);
     }
     return result;
@@ -1902,6 +1929,9 @@ export class Storage {
       { upsert: false }
     );
     if (!result.matchedCount) {
+      if ((await this.db.collection(collections.TSS_SIGN).countDocuments({ id })) === 0) {
+        throw new Error('MONGO_DOC_NOT_FOUND: No document found for id ' + id);
+      }
       throw new Error('MONGO_DOC_OUTDATED: No document found for version ' + __v);
     }
     return result;
@@ -1924,6 +1954,9 @@ export class Storage {
       { upsert: false }
     );
     if (!result.matchedCount) {
+      if ((await this.db.collection(collections.TSS_SIGN).countDocuments({ id })) === 0) {
+        throw new Error('MONGO_DOC_NOT_FOUND: No document found for id ' + id);
+      }
       throw new Error('MONGO_DOC_OUTDATED: No document found for version ' + __v);
     }
     return result;

package/src/lib/tss.ts

@@ -155,6 +155,57 @@ class TssKeyGenClass {
     return session;
   }
 
+  async registerParty(params: {
+    /** Session ID */
+    id: string;
+    /** Copayer ID of the requesting party */
+    copayerId: string;
+    /* Copayer data to register */
+    data: {
+      /** Party ID */
+      partyId: string | number;
+      /** Public key/Copayer ID of the party */
+      partyPubKey: string;
+    };
+  }) {
+    const { id, copayerId, data } = params;
+
+    const session = await this.getSessionForCopayer({ id, copayerId });
+    const reqPartyId = session.participants.indexOf(copayerId);
+    if (reqPartyId !== 0) {
+      throw Errors.TSS_NON_PARTICIPANT.withMessage('Only the first participant can register a party');
+    }
+
+    if (data.partyId == null || isNaN(data.partyId as number)) {
+      throw Errors.TSS_INVALID_PARTY_DATA.withMessage(`Invalid partyId: ${data.partyId}`);
+    }
+
+    const partyId = parseInt(data.partyId as string);
+    const pubKey = data.partyPubKey?.trim();
+
+    if (!(partyId > 0) || !pubKey || pubKey === copayerId || partyId >= session.n) {
+      throw Errors.TSS_INVALID_PARTY_DATA.withMessage(`Invalid data for party ${partyId} registration`);
+    }
+
+    if (session.authPublicKeys.includes(pubKey)) {
+      if (session.authPublicKeys.indexOf(pubKey) === partyId) {
+        // Already registered at partyId -> return idempotently
+        return;
+      } else {
+        // Trying to re-register a party that is already registered under a different party ID
+        throw Errors.TSS_PARTY_ALREADY_REGISTERED;
+      }
+    }
+    
+    // Has party already submitted initial rounds message? (case when this is a re-register)
+    if (session.rounds?.[0]?.some(round => round.fromPartyId === partyId)) {
+      throw Errors.TSS_ROUNDS_ALREADY_STARTED.withMessage(`Party ${partyId} has already submitted an initial message. Cannot register a new party ${partyId}`);
+    }
+
+    const storage = WalletService.getStorage();
+    await storage.storeTssKeyGenAuthPublicKey({ id, partyId, authPublicKey: pubKey, __v: session.__v });
+  }
+
   /**
    * Get messages for a given party in a TSS keygen session.
    * Only returns messages if all other parties have sent their messages for the round.
@@ -279,10 +330,29 @@ class TssKeyGenClass {
 
 
       if (!session.participants[message.partyId]) {
+        if (session.participants.includes(copayerId)) {
+          throw Errors.TSS_PARTY_ALREADY_REGISTERED;
+        }
         if (!this._checkPassword({ session, password })) {
           throw Errors.TSS_INVALID_PASSWORD;
         }
-        await storage.storeTssKeyGenParticipant({ id, partyId: message.partyId, copayerId });
+        // Sanity check for the public key of the participant in the session
+        // session.authPublicKeys was not added until version 1.2
+        if (session.schemeVersion >= 1.2 && session.authPublicKeys[message.partyId] !== message.publicKey) {
+          throw Errors.NOT_AUTHORIZED;
+        }
+        try {
+          await storage.storeTssKeyGenParticipant({ id, partyId: message.partyId, copayerId, __v: session.__v });
+        } catch (e) {
+          if (e?.message?.startsWith('MONGO_DOC_OUTDATED')) {
+            return this.processMessage(params);
+          } else if (e?.message?.startsWith('MONGO_DOC_NOT_FOUND')) {
+            throw Errors.TSS_SESSION_NOT_FOUND;
+          }
+          throw e;
+        }
+      } else if (session.participants[message.partyId] !== copayerId) {
+        throw Errors.TSS_NON_PARTICIPANT.withMessage('Incorrect copayerId for this partyId');
       }
 
       let result = false;
@@ -427,6 +497,8 @@ class TssKeyGenClass {
     } catch (e) {
       if (e?.message?.startsWith('MONGO_DOC_OUTDATED')) {
         return false;
+      } else if (e?.message?.startsWith('MONGO_DOC_NOT_FOUND')) {
+        throw Errors.TSS_SESSION_NOT_FOUND;
       }
       throw e;
     }
@@ -694,6 +766,8 @@ class TssSignClass {
         } catch (e) {
           if (e?.message?.startsWith('MONGO_DOC_OUTDATED')) {
             return this.processMessage(params);
+          } else if (e?.message?.startsWith('MONGO_DOC_NOT_FOUND')) {
+            throw Errors.TSS_SESSION_NOT_FOUND;
           }
           throw e;
         }
@@ -814,6 +888,8 @@ class TssSignClass {
     } catch (e) {
       if (e?.message?.startsWith('MONGO_DOC_OUTDATED')) {
         return false;
+      } else if (e?.message?.startsWith('MONGO_DOC_NOT_FOUND')) {
+        throw Errors.TSS_SESSION_NOT_FOUND;
       }
       throw e;
     }

package/test/integration/externalservices/moonpay.test.ts

@@ -573,6 +573,35 @@ describe('Moonpay integration', () => {
       should.exist(data);
     });
 
+    it('should return the response body if there is one', async () => {
+      const data = await server.externalServices.moonpay.moonpayCancelSellTransaction(req);
+      data.should.equal('data');
+    });
+
+    it('should return success true without leaking the response if there is no body', async () => {
+      const fakeRequest2 = {
+        delete: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 204, body: undefined, headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      const data = await server.externalServices.moonpay.moonpayCancelSellTransaction(req);
+      data.should.deep.equal({ success: true });
+    });
+
+    it('should return success false if there is no body and status is not 2xx', async () => {
+      const fakeRequest2 = {
+        delete: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 404, body: '', headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      const data = await server.externalServices.moonpay.moonpayCancelSellTransaction(req);
+      data.should.deep.equal({ success: false });
+    });
+
     it('should return error if delete returns error', async () => {
       const fakeRequest2 = {
         delete: (_url, _opts, _cb) => { return _cb(new Error('Error'), null); },
@@ -641,6 +670,27 @@ describe('Moonpay integration', () => {
       should.exist(data);
     });
 
+    it('should return the response body if there is one', async () => {
+      const data = await server.externalServices.moonpay.moonpayCreateSession(req);
+      data.should.equal('data');
+    });
+
+    it('should throw without leaking the response if there is no session body', async () => {
+      const fakeRequest2 = {
+        post: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 200, body: undefined, headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayCreateSession(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay did not return a session');
+      }
+    });
+
     it('should return error if post returns error', async () => {
       const fakeRequest2 = {
         post: (_url, _opts, _cb) => { return _cb(new Error('Error'), null); },