@bitpay-labs/bitcore-wallet-service 11.10.11 → 11.10.12

package/package.json

@@ -2,7 +2,7 @@
   "name": "@bitpay-labs/bitcore-wallet-service",
   "description": "A service for Mutisig HD Bitcoin Wallets",
   "author": "BitPay Inc",
-  "version": "11.10.11",
+  "version": "11.10.12",
   "license": "MIT",
   "main": "ts_build/src/index.js",
   "types": "./ts_build/src/index.d.ts",
@@ -42,8 +42,8 @@
   },
   "dependencies": {
     "@bitpay-labs/bitcore-logging": "^11.10.9",
-    "@bitpay-labs/bitcore-tss": "^11.10.11",
-    "@bitpay-labs/crypto-wallet-core": "^11.10.11",
+    "@bitpay-labs/bitcore-tss": "^11.10.12",
+    "@bitpay-labs/crypto-wallet-core": "^11.10.12",
     "@sendgrid/mail": "6.5.4",
     "abi-decoder": "2.4.0",
     "async": "0.9.2",
@@ -107,5 +107,5 @@
       "email": "kjoseph@bitpay.com"
     }
   ],
-  "gitHead": "10bcfcf7cc6953e2af65d707b35d3e65e1254583"
+  "gitHead": "d1992fd744501a1b69b8cb97f07b0896df7223fd"
 }

package/src/externalservices/simplex.ts

@@ -260,34 +260,4 @@ export class SimplexService {
       );
     });
   }
-
-  simplexGetEvents(req): Promise<any> {
-    return new Promise((resolve, reject) => {
-      if (!config.simplex) return reject(new Error('Simplex missing credentials'));
-      if (!req.env || (req.env != 'sandbox' && req.env != 'production'))
-        return reject(new Error("Simplex's request wrong environment"));
-
-      const API = config.simplex[req.env].api;
-      const API_KEY = config.simplex[req.env].apiKey;
-      const headers = {
-        'Content-Type': 'application/json',
-        Authorization: 'ApiKey ' + API_KEY
-      };
-
-      this.request.get(
-        API + '/wallet/merchant/v2/events',
-        {
-          headers,
-          json: true
-        },
-        (err, data) => {
-          if (err) {
-            return reject(err.body ? err.body : null);
-          } else {
-            return resolve(data.body ? data.body : null);
-          }
-        }
-      );
-    });
-  }
 }

package/src/lib/chain/btc/index.ts

@@ -349,6 +349,11 @@ export class BtcChain implements IChain {
     });
   }
 
+  isPrePublishRawBound(_txp: TxProposal) {
+    // UTXO chains never mutate tx data at publish, so they never legitimately carry prePublishRaw.
+    return false;
+  }
+
   getBitcoreTx(txp, opts = { signed: true }) {
     const t = new this.bitcoreLib.Transaction();
 

package/src/lib/chain/eth/index.ts

@@ -287,6 +287,10 @@ export class EthChain implements IChain {
     });
   }
 
+  isPrePublishRawBound(txp: TxProposal) {
+    return Common.Utils.isPrePublishRawBound(this, txp);
+  }
+
   getBitcoreTx(txp: TxProposal, opts = { signed: true }) {
     const {
       data,

package/src/lib/chain/index.ts

@@ -98,6 +98,10 @@ class ChainProxy {
     return this.get(txp.chain).getBitcoreTx(txp, { signed: opts.signed });
   }
 
+  isPrePublishRawBound(txp: TxProposal<any>) {
+    return this.get(txp.chain).isPrePublishRawBound(txp);
+  }
+
   convertFeePerKb(chain, p, feePerKb) {
     return this.get(chain).convertFeePerKb(p, feePerKb);
   }

package/src/lib/chain/sol/index.ts

@@ -2,6 +2,7 @@ import { Transactions, Utils, Validation } from '@bitpay-labs/crypto-wallet-core
 import _ from 'lodash';
 import { IChain } from '../../../types/chain';
 import { WalletWithOpts } from '../../blockchainexplorers/v8';
+import { Common } from '../../common';
 import { Defaults } from '../../common/defaults';
 import { Errors } from '../../errors/errordefinitions';
 import logger from '../../logger';
@@ -28,6 +29,7 @@ export class SolChain implements IChain {
       totalConfirmedAmount: confirmed,
       lockedAmount: activatedLocked,
       lockedConfirmedAmount: activatedLocked,
+      reserve: balance > 0 ? minRent : 0,
       availableAmount: balance - activatedLocked,
       availableConfirmedAmount: confirmed - activatedLocked,
       byAddress: []
@@ -98,6 +100,10 @@ export class SolChain implements IChain {
     });
   }
 
+  isPrePublishRawBound(txp) {
+    return Common.Utils.isPrePublishRawBound(this, txp);
+  }
+
   getBitcoreTx(txp, opts = { signed: true }) {
     const {
       data,

package/src/lib/chain/xrp/index.ts

@@ -29,6 +29,7 @@ export class XrpChain implements IChain {
       totalConfirmedAmount: confirmed,
       lockedAmount: activatedLocked,
       lockedConfirmedAmount: activatedLocked,
+      reserve: balance > 0 ? reserve : 0,
       availableAmount: balance - activatedLocked,
       availableConfirmedAmount: confirmed - activatedLocked,
       byAddress: []
@@ -143,6 +144,10 @@ export class XrpChain implements IChain {
     });
   }
 
+  isPrePublishRawBound(txp) {
+    return Common.Utils.isPrePublishRawBound(this, txp);
+  }
+
   getBitcoreTx(txp, opts = { signed: true }) {
     const { destinationTag, outputs, outputOrder, multiTx } = txp;
     const chain = 'XRP';

package/src/lib/common/utils.ts

@@ -3,7 +3,8 @@ import {
   BitcoreLibCash,
   BitcoreLibDoge,
   BitcoreLibLtc,
-  Constants as CWConstants
+  Constants as CWConstants,
+  Transactions
 } from '@bitpay-labs/crypto-wallet-core';
 import _ from 'lodash';
 import { singleton } from 'preconditions';
@@ -12,6 +13,8 @@ import Config from '../../config';
 import { logger } from '../logger';
 import { Constants } from './constants';
 import { Defaults } from './defaults';
+import type { IChain } from '../../types/chain';
+import type { TxProposal } from '../model/txproposal';
 
 const $ = singleton();
 const Bitcore_ = {
@@ -23,6 +26,54 @@ const Bitcore_ = {
 
 export const Utils = {
 
+  /**
+   * txp.prePublishRaw as a list of raw transactions, or null when it isn't one. An empty list is truthy and
+   * hashes to nothing, so without this the value reaches the tx provider and fails as a thrown error rather
+   * than a refused check. Mirrors the client-side Verifier helper so both ends agree on a usable fallback.
+   *
+   * @param txp - the transaction proposal
+   */
+  prePublishRawParts(txp: TxProposal<any>): string[] | null {
+    if (!txp?.prePublishRaw) {
+      return null;
+    }
+    const parts = Array.isArray(txp.prePublishRaw) ? txp.prePublishRaw : [txp.prePublishRaw];
+    if (!parts.length || parts.some(raw => !raw || typeof raw !== 'string')) {
+      return null;
+    }
+    return parts;
+  },
+
+  /**
+   * Shared implementation of IChain.isPrePublishRawBound for account-based chains (SVM/EVM/XRP). True only if
+   * txp.prePublishRaw is the same transaction as the current proposal, differing solely in the field BWS
+   * mutates at publish (blockhash on SVM, nonce on EVM/XRP). Recovers that field from prePublishRaw, rebuilds
+   * the proposal via the chain's own getBitcoreTx, and requires byte-for-byte equality, so a tampered stored
+   * proposal cannot reuse an old, still-valid proposalSignature. Fails closed on any error.
+   *
+   * @param chain - the IChain implementation (provides chain + getBitcoreTx)
+   * @param txp - the transaction proposal (must carry prePublishRaw)
+   */
+  isPrePublishRawBound(chain: IChain, txp: TxProposal<any>): boolean {
+    try {
+      const prePublishRaw = Utils.prePublishRawParts(txp);
+      if (!prePublishRaw) return false;
+      const provider = Transactions.get({ chain: txp.chain }) as any;
+      if (typeof provider?.getMutableFields !== 'function') return false;
+      const mutableFields = provider.getMutableFields(prePublishRaw[0]);
+      if (!mutableFields || Object.values(mutableFields).every(v => v == null)) return false;
+      const cloned = Object.assign(Object.create(Object.getPrototypeOf(txp)), txp, mutableFields);
+      // signed: false to match prePublishRaw, which is captured before any copayer signature exists.
+      const rebuilt = chain.getBitcoreTx(cloned, { signed: false }).uncheckedSerialize();
+      const rebuiltArr = Array.isArray(rebuilt) ? rebuilt : [rebuilt];
+      if (rebuiltArr.length !== prePublishRaw.length) return false;
+      return rebuiltArr.every((raw, i) => raw === prePublishRaw[i]);
+    } catch (err) {
+      logger.warn('prePublishRaw binding check failed for txp %s on %s: %o', txp?.id, txp?.chain, err.stack || err.message || err);
+      return false;
+    }
+  },
+
   /**
    * @deprecated
    * Moved from ChainService to prevent circular dependency

package/src/lib/routes/middleware/authTssRequest.ts

@@ -35,7 +35,7 @@ export function authTssRequest(): express.RequestHandler {
       if (req.path.includes('/tss/keygen/')) {
         session = await storage.fetchTssKeyGenSession({ id });
         partyId = session?.participants.indexOf(copayerId);
-        pubKey = partyId > -1 ? session.rounds[0][partyId].messages.publicKey : null;
+        pubKey = partyId > -1 ? session.rounds[0].find(r => r.fromPartyId === partyId)?.messages.publicKey : null;
       } else if (req.path.includes('/tss/sign/')) {
         session = await storage.fetchTssSigSession({ id });
         partyId = session?.participants.find(p => p.copayerId === copayerId)?.partyId;

package/src/lib/routes/services.ts

@@ -65,7 +65,7 @@ function respondWithAuthServer(req, res, context: RouteContext, handler: RouteHa
 }
 
 export function registerServiceRoutes(router: express.Router, context: RouteContext) {
-  const { getServerWithAuth, setPublicCache, returnError } = context;
+  const { setPublicCache } = context;
 
   const transakCorsOptions = {
     origin: (origin, cb) => {
@@ -399,19 +399,6 @@ export function registerServiceRoutes(router: express.Router, context: RouteCont
     });
   });
 
-  router.get('/v1/service/simplex/events', (req, res) => {
-    getServerWithAuth(req, res, server => {
-      Promise.resolve()
-        .then(() => server.externalServices.simplex.simplexGetEvents({ env: req.query.env }))
-        .then(response => {
-          res.json(response);
-        })
-        .catch(err => {
-          returnError(err ?? 'unknown', res, req);
-        });
-    });
-  });
-
   router.post('/v1/service/thorswap/supportedChains', (req, res) => {
     respondWithPublicServer(req, res, context, server => {
       return server.externalServices.thorswap.thorswapGetSupportedChains(req);

package/src/lib/server.ts

@@ -3120,8 +3120,12 @@ export class WalletService implements IWalletService {
 
           let signingKey = this._getSigningKey(raw, opts.proposalSignature, copayer.requestPubKeys);
           if (!signingKey) {
-            // If the txp has been published previously, we will verify the signature against the previously published raw tx
-            if (txp.hasMutableTxData() && txp.prePublishRaw) {
+            // The signature didn't match the current (refreshed) raw tx. Fall back to the previously-published
+            // raw tx -- but only if it is bound to THIS proposal (differs from the current tx solely in the
+            // field BWS mutates at publish: blockhash/nonce). Without that check a tampered stored proposal
+            // could reuse an old, still-valid proposalSignature over prePublishRaw. Mirrors the client
+            // Verifier.checkPrePublishRaw guard.
+            if (txp.hasMutableTxData() && txp.prePublishRaw && ChainService.isPrePublishRawBound(txp)) {
               raw = txp.prePublishRaw;
               signingKey = this._getSigningKey(raw, opts.proposalSignature, copayer.requestPubKeys);
             }

package/src/types/chain.d.ts

@@ -33,6 +33,7 @@ export interface IChain {
   checkScriptOutput(output: { script: string; amount: number });
   getFee(server: WalletService, wallet: IWallet, opts: { fee: number; feePerKb: number; signatures?: number } & any);
   getBitcoreTx(txp: TxProposal, opts: { signed: boolean });
+  isPrePublishRawBound(txp: TxProposal): boolean;
   convertFeePerKb(p: number, feePerKb: number);
   checkTx(server: WalletService, txp: ITxProposal);
   checkTxUTXOs(server: WalletService, txp: ITxProposal, opts: { noCashAddr: boolean } & any, cb);

package/test/chain/sol.test.ts

@@ -0,0 +1,48 @@
+'use strict';
+
+import * as chai from 'chai';
+import { ChainService } from '../../src/lib/chain';
+import { Defaults } from '../../src/lib/common/defaults';
+
+const should = chai.should();
+
+describe('Chain SOL', function() {
+  describe('#getWalletBalance', function() {
+    const cases = [
+      { name: 'pending amounts and fees', amount: 1000000000, txps: [{ amount: '2000000000', fee: '5000' }], reserve: 1002240, locked: 2001007240, available: -1001007240 },
+      { name: 'dust below rent', amount: 10000, txps: [], reserve: 1002240, locked: 1002240, available: -992240 },
+      { name: 'an empty account with a pending proposal', amount: 0, txps: [{ amount: '2000000000', fee: '5000' }], reserve: 0, locked: 2000005000, available: -2000005000 },
+      { name: 'an SPL balance', amount: 1000000, txps: [{ tokenAddress: 'mint', amount: '500000', fee: '5000' }], tokenAddress: 'mint', reserve: 0, locked: 500000, available: 500000 }
+    ];
+
+    for (const c of cases) {
+      it('should expose the reserve separately for ' + c.name, function(done) {
+        const server = {
+          walletId: '1',
+          _getBlockchainExplorer: () => ({
+            getBalance: (_wallet, cb) => cb(null, { balance: c.amount, confirmed: c.amount }),
+            getRentMinimum: (_space, cb) => cb(null, Defaults.MIN_SOL_BALANCE)
+          }),
+          getPendingTxs: (_opts, cb) => cb(null, c.txps),
+          storage: { fetchAddresses: (_walletId, cb) => cb(null, []) }
+        };
+        const wallet = { chain: 'sol', network: 'livenet' };
+
+        ChainService.get('sol').getWalletBalance(server as any, wallet as any, { tokenAddress: (c as { tokenAddress?: string }).tokenAddress }, (err, balance) => {
+          should.not.exist(err);
+          balance.should.deep.equal({
+            totalAmount: c.amount,
+            totalConfirmedAmount: c.amount,
+            lockedAmount: c.locked,
+            lockedConfirmedAmount: c.locked,
+            reserve: c.reserve,
+            availableAmount: c.available,
+            availableConfirmedAmount: c.available,
+            byAddress: []
+          });
+          done();
+        });
+      });
+    }
+  });
+});

package/test/chain/xrp.test.ts

@@ -10,6 +10,36 @@ const should = chai.should();
 const xpub = 'tpubDD7tYYerLNNm65Ez7pRjxQ2NpRHDoyRWoLWudnQ8agXjr7qs9BsPsRXk8Z6spPPJodnaY158YqeCKT5oXuZvbuNLfm1R4kXGJ2vPd9pUxDT';
 
 describe('Chain XRP', function() { 
+  describe('#getWalletBalance', function() {
+    it('should expose the reserve separately from pending amounts and fees', function(done) {
+      const server = {
+        walletId: '1',
+        _getBlockchainExplorer: () => ({
+          getBalance: (_wallet, cb) => cb(null, { balance: 2000000, confirmed: 2000000 }),
+          getReserve: cb => cb(null, 1000000)
+        }),
+        getPendingTxs: (_opts, cb) => cb(null, [{ amount: '3000000', fee: '12' }]),
+        storage: { fetchAddresses: (_walletId, cb) => cb(null, []) }
+      };
+      const wallet = { chain: 'xrp', network: 'livenet' };
+
+      ChainService.get('xrp').getWalletBalance(server as any, wallet as any, {}, (err, balance) => {
+        should.not.exist(err);
+        balance.should.deep.equal({
+          totalAmount: 2000000,
+          totalConfirmedAmount: 2000000,
+          lockedAmount: 4000012,
+          lockedConfirmedAmount: 4000012,
+          reserve: 1000000,
+          availableAmount: -2000012,
+          availableConfirmedAmount: -2000012,
+          byAddress: []
+        });
+        done();
+      });
+    });
+  });
+
   describe('#getWalletSendMaxInfo', function() {
     it('should resolve fee level before calculating sendMax amount', function(done) {
       const server = {

package/test/integration/externalservices/simplex.test.ts

@@ -503,22 +503,4 @@ describe('Simplex integration', () => {
       }
     });
   });
-
-  describe('#simplexGetEvents', () => {
-    beforeEach(() => {
-      req = {
-        env: 'production'
-      };
-
-      fakeRequest = {
-        get: (_url, _opts, _cb) => { return _cb(null, { body: {} }); },
-      };
-      server.externalServices.simplex.request = fakeRequest;
-    });
-
-    it('should work properly if req is OK', async () => {
-      const data = await server.externalServices.simplex.simplexGetEvents(req);
-      should.exist(data);
-    });
-  });
 });

package/test/integration/server.test.ts

@@ -12,6 +12,7 @@ import config from '../../src/config';
 import { WalletService, UPGRADES } from '../../src/lib/server';
 import { Storage } from '../../src/lib/storage';
 import { Common } from '../../src/lib/common';
+import logger from '../../src/lib/logger';
 import * as Model from '../../src/lib/model';
 import { TssKeyGenModel } from '../../src/lib/model/tsskeygen';
 import { BCHAddressTranslator } from '../../src/lib/bchaddresstranslator';
@@ -8821,6 +8822,85 @@ describe('Wallet service', function() {
       result.nonce.should.equal(5);
       // future: result.gasPrice, result.maxFee would also be set here
     });
+
+    describe('prePublishRaw binding (isPrePublishRawBound)', function() {
+      const ATTACKER_ADDR = '0x1111111111111111111111111111111111111111';
+
+      it('accepts prePublishRaw when only the mutable field (nonce) changed', async function() {
+        blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '42');
+        const created = await helpers.createAndPublishTx(server, {
+          outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+          feePerKb: 123e2, from: fromAddr, deferNonce: true
+        }, TestData.copayers[0].privKey_1H_0);
+
+        // Server assigns the JIT nonce -> the stored tx now differs from prePublishRaw only in the nonce.
+        await util.promisify(server.prepareTx).call(server, { txProposalId: created.id });
+        const withNonce = await util.promisify(server.getTx).call(server, { txProposalId: created.id });
+        should.exist(withNonce.prePublishRaw);
+        withNonce.nonce.should.equal(42);
+
+        ChainService.isPrePublishRawBound(withNonce).should.equal(true);
+      });
+
+      it('rejects prePublishRaw when the destination was tampered', async function() {
+        const created = await helpers.createAndPublishTx(server, {
+          outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+          feePerKb: 123e2, from: fromAddr, deferNonce: true
+        }, TestData.copayers[0].privKey_1H_0);
+
+        const txp = await util.promisify(server.getTx).call(server, { txProposalId: created.id });
+        should.exist(txp.prePublishRaw);
+        ChainService.isPrePublishRawBound(txp).should.equal(true); // bound before tampering
+        txp.outputs[0].toAddress = ATTACKER_ADDR; // swap payee, keep prePublishRaw + proposalSignature
+        ChainService.isPrePublishRawBound(txp).should.equal(false);
+      });
+
+      it('rejects a prePublishRaw that holds no usable raw tx', async function() {
+        const created = await helpers.createAndPublishTx(server, {
+          outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+          feePerKb: 123e2, from: fromAddr, deferNonce: true
+        }, TestData.copayers[0].privKey_1H_0);
+
+        const txp = await util.promisify(server.getTx).call(server, { txProposalId: created.id });
+        const warn = sinon.spy(logger, 'warn');
+        try {
+          // an empty list is truthy, so it has to be refused up front rather than handed to the tx
+          // provider, which would fail the same check by throwing
+          for (const prePublishRaw of [[], [''], ['', '']]) {
+            txp.prePublishRaw = prePublishRaw;
+            ChainService.isPrePublishRawBound(txp).should.equal(false);
+          }
+          warn.called.should.equal(false);
+        } finally {
+          warn.restore();
+        }
+      });
+
+      it('rejects the publishTx fallback when the stored proposal was tampered', async function() {
+        blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '7');
+        const created = await util.promisify(server.createTx).call(server, {
+          outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+          feePerKb: 123e2, from: fromAddr, deferNonce: true
+        });
+        const publishOpts = helpers.getProposalSignatureOpts(created, TestData.copayers[0].privKey_1H_0);
+        await util.promisify(server.publishTx).call(server, publishOpts);
+
+        // Assign the nonce so a re-publish must fall back to prePublishRaw...
+        await util.promisify(server.prepareTx).call(server, { txProposalId: created.id });
+        // ...then tamper the stored destination and replay the original (still-valid) proposalSignature.
+        const stored = await util.promisify(server.storage.fetchTx).call(server.storage, wallet.id, created.id);
+        should.exist(stored.prePublishRaw);
+        stored.outputs[0].toAddress = ATTACKER_ADDR;
+        await util.promisify(server.storage.storeTx).call(server.storage, wallet.id, stored);
+
+        let err;
+        try {
+          await util.promisify(server.publishTx).call(server, publishOpts);
+        } catch (e) { err = e; }
+        should.exist(err);
+        err.message.should.contain('Invalid proposal signature');
+      });
+    });
   });
 
   describe('#prepareTx XRP (deferred nonce)', function() {
@@ -8912,6 +8992,20 @@ describe('Wallet service', function() {
       });
       signed.status.should.equal('accepted');
     });
+
+    it('rejects prePublishRaw binding when an XRP destination was tampered', async function() {
+      const ATTACKER_XRP = 'rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe';
+      const created = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: XRP_ADDR, amount: 8000 }],
+        feePerKb: 123e2, from: fromAddr, deferNonce: true
+      }, TestData.copayers[0].privKey_1H_0);
+
+      const txp = await util.promisify(server.getTx).call(server, { txProposalId: created.id });
+      should.exist(txp.prePublishRaw);
+      ChainService.isPrePublishRawBound(txp).should.equal(true); // untampered baseline
+      txp.outputs[0].toAddress = ATTACKER_XRP;
+      ChainService.isPrePublishRawBound(txp).should.equal(false);
+    });
   });
 
   describe('#signTx nonce override', function() {

package/test/integration/tss.test.ts

@@ -379,6 +379,73 @@ describe('TSS', function() {
     });
   });
 
+  describe('GET /v1/tss/keygen/:id/:round', function() {
+    const roundUrl = '/v1/tss/keygen/test/0?maxWaitTime=0';
+    const parties = [vector.party0, vector.party1, vector.party2];
+    const round0Messages = [vector.keygen.messages.round0.party0, vector.keygen.messages.round0.party1, vector.keygen.messages.round0.party2];
+
+    const joinRound0 = async (partyId: number) => {
+      const publicKey = parties[partyId].authKey.publicKey.toString();
+      const message = { ...round0Messages[partyId], partyId, round: 0, publicKey };
+      await app.post(`${urlPrefix}/v1/tss/keygen/test`)
+        .set('x-identity', publicKey)
+        .send({ message, n: 3, version: 1.1 })
+        .expect(200);
+    };
+
+    const getRound0 = (partyId: number) => {
+      const { authKey } = parties[partyId];
+      const hash = Utils.hashMessage(`get|${roundUrl}|{}`, false);
+      const xSignature = BitcoreLib.crypto.ECDSA.sign(hash, authKey, { endian: 'little' }).toString();
+      return app.get(urlPrefix + roundUrl)
+        .set('x-identity', authKey.publicKey.toString())
+        .set('x-signature', xSignature);
+    };
+
+    beforeEach(async function() {
+      const storage = helpers.getStorage();
+      await storage.db.collection(BWS.Storage.collections.TSS_KEYGEN).deleteMany({});
+    });
+
+    it('should authenticate every party when round 0 messages arrive in partyId order', async function() {
+      await joinRound0(0);
+      await joinRound0(1);
+      await joinRound0(2);
+
+      for (const partyId of [0, 1, 2]) {
+        const res = await getRound0(partyId);
+        res.status.should.equal(200);
+        JSON.parse(res.text).messages.length.should.equal(2);
+      }
+    });
+
+    it('should authenticate every party when round 0 messages arrive out of partyId order', async function() {
+      await joinRound0(0);
+      await joinRound0(2);
+      await joinRound0(1);
+
+      for (const partyId of [0, 1, 2]) {
+        const res = await getRound0(partyId);
+        res.status.should.equal(200);
+        JSON.parse(res.text).messages.length.should.equal(2);
+      }
+    });
+
+    it('should reject another party identity when round 0 messages arrive out of partyId order', async function() {
+      await joinRound0(0);
+      await joinRound0(2);
+      await joinRound0(1);
+
+      for (const [partyId, otherPartyId] of [[1, 2], [2, 1]]) {
+        const res = await getRound0(partyId)
+          .set('x-identity', parties[otherPartyId].authKey.publicKey.toString());
+        res.status.should.equal(401);
+        res.body.code.should.equal('NOT_AUTHORIZED');
+        res.body.message.should.equal('Invalid signature');
+      }
+    });
+  });
+
   describe('POST /v1/tss/sign/:id', function() {
     const url = id => `${urlPrefix}/v1/tss/sign/${id}`;
     const signRequest = body => {

package/ts_build/package.json

@@ -2,7 +2,7 @@
     "name": "@bitpay-labs/bitcore-wallet-service",
     "description": "A service for Mutisig HD Bitcoin Wallets",
     "author": "BitPay Inc",
-    "version": "11.10.10",
+    "version": "11.10.11",
     "license": "MIT",
     "main": "ts_build/src/index.js",
     "types": "./ts_build/src/index.d.ts",
@@ -42,8 +42,8 @@
     },
     "dependencies": {
         "@bitpay-labs/bitcore-logging": "^11.10.9",
-        "@bitpay-labs/bitcore-tss": "^11.10.9",
-        "@bitpay-labs/crypto-wallet-core": "^11.10.9",
+        "@bitpay-labs/bitcore-tss": "^11.10.11",
+        "@bitpay-labs/crypto-wallet-core": "^11.10.11",
         "@sendgrid/mail": "6.5.4",
         "abi-decoder": "2.4.0",
         "async": "0.9.2",

package/ts_build/src/externalservices/simplex.d.ts

@@ -7,6 +7,5 @@ export declare class SimplexService {
     simplexGetSellQuote(req: any): Promise<any>;
     simplexPaymentRequest(req: any): Promise<any>;
     simplexSellPaymentRequest(req: any): Promise<any>;
-    simplexGetEvents(req: any): Promise<any>;
 }
 //# sourceMappingURL=simplex.d.ts.map

package/ts_build/src/externalservices/simplex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simplex.d.ts","sourceRoot":"","sources":["../../../src/externalservices/simplex.ts"],"names":[],"mappings":"AAOA,qBAAa,cAAc;IACzB,OAAO,EAAE,GAAG,CAAW;IAEvB,OAAO,CAAC,cAAc;IAwBtB,OAAO,CAAC,gBAAgB;IAYxB,oBAAoB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA6BvC,eAAe,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IAuClC,mBAAmB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA6CtC,qBAAqB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA6DxC,yBAAyB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA2C5C,gBAAgB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;CA6BpC"}
+{"version":3,"file":"simplex.d.ts","sourceRoot":"","sources":["../../../src/externalservices/simplex.ts"],"names":[],"mappings":"AAOA,qBAAa,cAAc;IACzB,OAAO,EAAE,GAAG,CAAW;IAEvB,OAAO,CAAC,cAAc;IAwBtB,OAAO,CAAC,gBAAgB;IAYxB,oBAAoB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA6BvC,eAAe,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IAuClC,mBAAmB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA6CtC,qBAAqB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA6DxC,yBAAyB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;CA0C7C"}

package/ts_build/src/externalservices/simplex.js

@@ -240,31 +240,6 @@ class SimplexService {
             });
         });
     }
-    simplexGetEvents(req) {
-        return new Promise((resolve, reject) => {
-            if (!config_1.default.simplex)
-                return reject(new Error('Simplex missing credentials'));
-            if (!req.env || (req.env != 'sandbox' && req.env != 'production'))
-                return reject(new Error("Simplex's request wrong environment"));
-            const API = config_1.default.simplex[req.env].api;
-            const API_KEY = config_1.default.simplex[req.env].apiKey;
-            const headers = {
-                'Content-Type': 'application/json',
-                Authorization: 'ApiKey ' + API_KEY
-            };
-            this.request.get(API + '/wallet/merchant/v2/events', {
-                headers,
-                json: true
-            }, (err, data) => {
-                if (err) {
-                    return reject(err.body ? err.body : null);
-                }
-                else {
-                    return resolve(data.body ? data.body : null);
-                }
-            });
-        });
-    }
 }
 exports.SimplexService = SimplexService;
 //# sourceMappingURL=simplex.js.map