@bitpay-labs/bitcore-wallet-service 11.6.5 → 11.7.0

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.6.5",
+  "version": "11.7.0",
   "license": "MIT",
   "main": "ts_build/src/index.js",
   "types": "./ts_build/src/index.d.ts",
@@ -24,10 +24,9 @@
   "scripts": {
     "start": "npm run clean && npm run build && ./start.sh",
     "stop": "./stop.sh",
-    "coverage": "npm run compile && ./node_modules/.bin/istanbul cover ./node_modules/.bin/_mocha -- --reporter spec test",
-    "test": "npm run compile && mocha --exit -r tsx 'test/**/*.test.ts'",
+    "coverage": "npm run compile && nyc mocha 'ts_build/test/**/*.test.js'",
+    "test": "npm run compile && mocha --exit 'ts_build/test/**/*.test.js'",
     "test:ci": "BWS_LOG_LEVEL=none npm run test",
-    "coveralls": "./node_modules/.bin/istanbul cover ./node_modules/mocha/bin/_mocha --report lcovonly -- -R spec && cat ./coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js && rm -rf ./coverage",
     "build": "tsc && npm run cp:templates",
     "build:prod": "tsc -p tsconfig.prod.json && npm run cp:templates",
     "build:docker": "docker build -t bitpay/bitcore-wallet-service:latest -f ./Dockerfile ../..",
@@ -44,8 +43,8 @@
     "cp:templates": "cp -r ./templates ./ts_build/templates"
   },
   "dependencies": {
-    "@bitpay-labs/bitcore-tss": "^11.6.4",
-    "@bitpay-labs/crypto-wallet-core": "^11.6.4",
+    "@bitpay-labs/bitcore-tss": "^11.7.0",
+    "@bitpay-labs/crypto-wallet-core": "^11.7.0",
     "@sendgrid/mail": "6.5.4",
     "abi-decoder": "2.4.0",
     "async": "0.9.2",
@@ -55,7 +54,6 @@
     "express": "4.19.2",
     "express-rate-limit": "2.14.2",
     "inherits": "2.0.4",
-    "istanbul": "0.4.5",
     "json-stable-stringify": "1.0.1",
     "juice": "^11.0.1",
     "lodash": "4.17.19",
@@ -87,15 +85,28 @@
     "@types/nodemailer": "^4.6.6",
     "@types/request": "^2.48.1",
     "chai": "^5.2.0",
-    "coveralls": "^3.0.2",
     "memdown": "^1.0.0",
     "mocha": "^5.2.0",
-    "mocha-lcov-reporter": "^1.3.0",
+    "nyc": "^17.1.0",
     "sinon": "^7.1.1",
     "supertest": "*",
-    "tsx": "^4.21.0",
     "typescript": "^5.7.3"
   },
+  "nyc": {
+    "include": [
+      "ts_build/src",
+      "src"
+    ],
+    "reporter": [
+      "html",
+      "text-summary"
+    ],
+    "check-coverage": true,
+    "lines": 60,
+    "functions": 60,
+    "branches": 60,
+    "statements": 60
+  },
   "bitcoreNode": "./bitcorenode",
   "contributors": [
     {
@@ -115,5 +126,5 @@
       "email": "kjoseph@bitpay.com"
     }
   ],
-  "gitHead": "a1890ef287c9e5d0e966fb445d15bc59a9393761"
+  "gitHead": "6c5a1566aa725431db579f3c89a5c9f186bf5a30"
 }

package/src/externalservices/moonpay.ts

@@ -214,6 +214,9 @@ export class MoonpayService {
     qs.push('externalTransactionId=' + encodeURIComponent(req.body.externalTransactionId));
     qs.push('redirectURL=' + encodeURIComponent(req.body.redirectURL));
     if (req.body.lockAmount) qs.push('lockAmount=' + encodeURIComponent(req.body.lockAmount));
+    if (req.body.colorCode) qs.push('colorCode=' + encodeURIComponent(req.body.colorCode));
+    if (req.body.theme) qs.push('theme=' + encodeURIComponent(req.body.theme));
+    if (req.body.language) qs.push('language=' + encodeURIComponent(req.body.language));
     if (req.body.showWalletAddressForm)
       qs.push('showWalletAddressForm=' + encodeURIComponent(req.body.showWalletAddressForm));
     if (req.body.paymentMethod) qs.push('paymentMethod=' + encodeURIComponent(req.body.paymentMethod));

package/src/lib/blockchainexplorers/v8.ts

@@ -486,6 +486,48 @@ export class V8 {
       });
   }
 
+  getAaveUserAccountData(opts: { address: string; version?: string }, cb) {
+    const url = this.baseUrl + '/aave/account/' + opts.address + '?version=' + (opts.version || 'v3');
+    logger.debug('[v8.js] GETTING AAVE USER ACCOUNT DATA %o', url);
+    this.request
+      .get(url, {})
+      .then(accountData => {
+        accountData = JSON.parse(accountData);
+        return cb(null, accountData);
+      })
+      .catch(err => {
+        return cb(err);
+      });
+  }
+
+  getAaveReserveData(opts: { asset: string; version?: string }, cb) {
+    const url = this.baseUrl + '/aave/reserve/' + opts.asset + '?version=' + (opts.version || 'v3');
+    logger.debug('[v8.js] GETTING AAVE RESERVE DATA %o', url);
+    this.request
+      .get(url, {})
+      .then(reserveData => {
+        reserveData = JSON.parse(reserveData);
+        return cb(null, reserveData);
+      })
+      .catch(err => {
+        return cb(err);
+      });
+  }
+
+  getAaveReserveTokensAddresses(opts: { asset: string; version?: string }, cb) {
+    const url = this.baseUrl + '/aave/reserve-tokens/' + opts.asset + '?version=' + (opts.version || 'v3');
+    logger.debug('[v8.js] GETTING AAVE RESERVE TOKENS ADDRESSES %o', url);
+    this.request
+      .get(url, {})
+      .then(tokensAddresses => {
+        tokensAddresses = JSON.parse(tokensAddresses);
+        return cb(null, tokensAddresses);
+      })
+      .catch(err => {
+        return cb(err);
+      });
+  }
+
   getMultisigTxpsInfo(opts: { multisigContractAddress: string }, cb) {
     const url = this.baseUrl + '/ethmultisig/txps/' + opts.multisigContractAddress;
     logger.debug('[v8.js] CHECKING CONTRACT TXPS INFO %o', url);

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

@@ -317,9 +317,10 @@ export class EthChain implements IChain {
     }
     const unsignedTxs = [];
 
+    const nonceNum = txp.nonce != null ? Number(txp.nonce) : 0;
     if (multiSendContractAddress) {
       const multiSendParams = {
-        nonce: Number(txp.nonce),
+        nonce: nonceNum,
         recipients,
         contractAddress: multiSendContractAddress
       };
@@ -330,7 +331,7 @@ export class EthChain implements IChain {
         // Uses gas limit from the txp output level
         const params = {
           ...recipients[index],
-          nonce: Number(txp.nonce) + Number(index),
+          nonce: nonceNum + Number(index),
           recipients: [recipients[index]]
         };
         unsignedTxs.push(Transactions.create({ ...txp, chain, ...params }));

package/src/lib/expressapp.ts

@@ -13,6 +13,7 @@ import { Common } from './common';
 import { ClientError } from './errors/clienterror';
 import { Errors } from './errors/errordefinitions';
 import { logger, transports } from './logger';
+import { AaveRouter } from './routes/aave';
 import { error } from './routes/helpers';
 import { createWalletLimiter } from './routes/middleware/createWalletLimiter';
 import { LogMiddleware } from './routes/middleware/log';
@@ -973,6 +974,16 @@ export class ExpressApp {
       });
     });
 
+    router.post('/v1/token/allowance', async (req, res) => {
+      try {
+        const server = getServer(req, res);
+        const allowance = await server.getTokenAllowance(req.body);
+        res.json(allowance);
+      } catch (err) {
+        returnError(err, res, req);
+      }
+    });
+
     router.get('/v1/sendmaxinfo/', (req, res) => {
       getServerWithAuth(req, res, server => {
         const q = req.query;
@@ -1069,6 +1080,19 @@ export class ExpressApp {
     });
     */
 
+    router.post('/v1/txproposals/:id/prepare/', (req, res) => {
+      getServerWithAuth(req, res, server => {
+        req.body.txProposalId = req.params['id'];
+        server.prepareTx(req.body, (err, txp) => {
+          if (err) return returnError(err, res, req);
+          res.json(txp);
+          res.end();
+        });
+      });
+    });
+
+
+
     //
     router.post('/v1/txproposals/:id/publish/', (req, res) => {
       getServerWithAuth(req, res, server => {
@@ -2391,6 +2415,7 @@ export class ExpressApp {
     });
 
     /** Imported routes */
+    router.use(new AaveRouter({ returnError, getServer }).router);
     router.use(new TssRouter({ returnError, opts }).router);
 
 

package/src/lib/model/txproposal.ts

@@ -66,6 +66,7 @@ export interface ITxProposal {
   signingMethod: string;
   lowFees?: boolean;
   nonce?: number | string;
+  deferNonce?: boolean;
   gasPrice?: number;
   maxGasFee?: number;
   priorityGasFee?: number;
@@ -150,6 +151,7 @@ export class TxProposal implements ITxProposal {
   lowFees?: boolean;
   raw?: Array<string> | string;
   nonce?: number | string;
+  deferNonce?: boolean;
   gasPrice?: number;
   maxGasFee?: number;
   priorityGasFee?: number;
@@ -273,6 +275,7 @@ export class TxProposal implements ITxProposal {
     x.txType = opts.txType;
     x.from = opts.from;
     x.nonce = opts.nonce;
+    x.deferNonce = opts.deferNonce;
     x.gasLimit = opts.gasLimit; // Backward compatibility for BWC <= 8.9.0
     x.data = opts.data; // Backward compatibility for BWC <= 8.9.0
     x.tokenAddress = opts.tokenAddress;
@@ -363,6 +366,7 @@ export class TxProposal implements ITxProposal {
     x.txType = obj.txType;
     x.from = obj.from;
     x.nonce = obj.nonce;
+    x.deferNonce = obj.deferNonce;
     x.gasLimit = obj.gasLimit; // Backward compatibility for BWC <= 8.9.0
     x.data = obj.data; // Backward compatibility for BWC <= 8.9.0
     x.tokenAddress = obj.tokenAddress;
@@ -531,6 +535,10 @@ export class TxProposal implements ITxProposal {
     return !!this.refreshOnPublish;
   }
 
+  hasMutableTxData() {
+    return this.isRepublishEnabled() || !!this.deferNonce;
+  }
+
   isTemporary() {
     return this.status === 'temporary';
   }

package/src/lib/routes/aave.ts

@@ -0,0 +1,48 @@
+import express from 'express';
+import * as Types from '../../types/expressapp';
+
+interface AaveRouterOpts {
+  returnError: Types.ReturnErrorFn;
+  getServer: Types.GetServerFn;
+}
+
+export class AaveRouter {
+  router: express.Router;
+
+  constructor(params: AaveRouterOpts) {
+    const { returnError, getServer } = params;
+    const router = express.Router();
+
+    router.post('/v1/service/aave/userAccountData', async (req, res) => {
+      try {
+        const server = getServer(req, res);
+        const accountData = await server.getAaveUserAccountData(req.body);
+        res.json(accountData);
+      } catch (err) {
+        returnError(err, res, req);
+      }
+    });
+
+    router.post('/v1/service/aave/reserveData', async (req, res) => {
+      try {
+        const server = getServer(req, res);
+        const reserveData = await server.getAaveReserveData(req.body);
+        res.json(reserveData);
+      } catch (err) {
+        returnError(err, res, req);
+      }
+    });
+
+    router.post('/v1/service/aave/reserveTokensAddresses', async (req, res) => {
+      try {
+        const server = getServer(req, res);
+        const tokensAddresses = await server.getAaveReserveTokensAddresses(req.body);
+        res.json(tokensAddresses);
+      } catch (err) {
+        returnError(err, res, req);
+      }
+    });
+
+    this.router = router;
+  }
+}

package/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);
       }

package/src/lib/server.ts

@@ -2559,6 +2559,120 @@ export class WalletService implements IWalletService {
     });
   }
 
+  /**
+   * Get ERC20 token allowance for a given owner/spender pair.
+   * @param {Object} opts
+   * @param {string} opts.chain - EVM chain name (e.g. 'eth', 'matic')
+   * @param {string} opts.network - Network name (e.g. 'mainnet', 'sepolia')
+   * @param {string} opts.tokenAddress - Token contract address
+   * @param {string} opts.ownerAddress - Token owner address
+   * @param {string} opts.spenderAddress - Spender contract address
+   * @returns {Promise<number>} Token allowance amount
+   */
+  getTokenAllowance(opts) {
+    if (!checkRequired(opts, ['chain', 'network', 'tokenAddress', 'ownerAddress', 'spenderAddress'])) {
+      return Promise.reject(new ClientError('getTokenAllowance request missing arguments'));
+    }
+    const bc = this._getBlockchainExplorer(opts.chain, opts.network);
+    return new Promise((resolve, reject) => {
+      if (!bc) return reject(new Error('Could not get blockchain explorer instance'));
+      bc.getTokenAllowance(opts, (err, allowance) => {
+        if (err) {
+          this.logw('Error getting token allowance:', err);
+          return reject(err);
+        }
+        return resolve(allowance);
+      });
+    });
+  }
+
+  /**
+   * Get Aave user account data (health factor, collateral, debt, etc.).
+   * @param {Object} opts
+   * @param {string} opts.chain - EVM chain name (e.g. 'eth', 'matic')
+   * @param {string} opts.network - Network name (e.g. 'mainnet', 'sepolia')
+   * @param {string} opts.address - User wallet address
+   * @param {string} [opts.version='v3'] - Aave protocol version ('v2' or 'v3')
+   * @returns {Promise<Object>} Aave account data (totalCollateralBase, totalDebtBase, healthFactor, etc.)
+   */
+  getAaveUserAccountData(opts) {
+    if (!checkRequired(opts, ['chain', 'network', 'address'])) {
+      return Promise.reject(new ClientError('getAaveUserAccountData request missing arguments'));
+    }
+    if (opts.version && !['v2', 'v3'].includes(opts.version)) {
+      return Promise.reject(new ClientError('Invalid Aave version. Supported: v2, v3'));
+    }
+    const bc = this._getBlockchainExplorer(opts.chain, opts.network);
+    return new Promise((resolve, reject) => {
+      if (!bc) return reject(new Error('Could not get blockchain explorer instance'));
+      bc.getAaveUserAccountData(opts, (err, accountData) => {
+        if (err) {
+          this.logw('Error getting Aave user account data:', err);
+          return reject(err);
+        }
+        return resolve(accountData);
+      });
+    });
+  }
+
+  /**
+   * Get Aave reserve data (variable borrow rate, etc.).
+   * @param {Object} opts
+   * @param {string} opts.chain - EVM chain name (e.g. 'eth', 'matic')
+   * @param {string} opts.network - Network name (e.g. 'mainnet', 'sepolia')
+   * @param {string} opts.asset - Reserve asset token address
+   * @param {string} [opts.version='v3'] - Aave protocol version ('v2' or 'v3')
+   * @returns {Promise<Object>} Aave reserve data (currentVariableBorrowRate, etc.)
+   */
+  getAaveReserveData(opts) {
+    if (!checkRequired(opts, ['chain', 'network', 'asset'])) {
+      return Promise.reject(new ClientError('getAaveReserveData request missing arguments'));
+    }
+    if (opts.version && !['v2', 'v3'].includes(opts.version)) {
+      return Promise.reject(new ClientError('Invalid Aave version. Supported: v2, v3'));
+    }
+    const bc = this._getBlockchainExplorer(opts.chain, opts.network);
+    return new Promise((resolve, reject) => {
+      if (!bc) return reject(new Error('Could not get blockchain explorer instance'));
+      bc.getAaveReserveData(opts, (err, reserveData) => {
+        if (err) {
+          this.logw('Error getting Aave reserve data:', err);
+          return reject(err);
+        }
+        return resolve(reserveData);
+      });
+    });
+  }
+
+  /**
+   * Get Aave reserve token addresses (aToken, variableDebtToken, etc.).
+   * @param {Object} opts
+   * @param {string} opts.chain - EVM chain name (e.g. 'eth', 'matic')
+   * @param {string} opts.network - Network name (e.g. 'mainnet', 'sepolia')
+   * @param {string} opts.asset - Reserve asset token address
+   * @param {string} [opts.version='v3'] - Aave protocol version ('v2' or 'v3')
+   * @returns {Promise<Object>} Aave reserve token addresses (variableDebtTokenAddress, etc.)
+   */
+  getAaveReserveTokensAddresses(opts) {
+    if (!checkRequired(opts, ['chain', 'network', 'asset'])) {
+      return Promise.reject(new ClientError('getAaveReserveTokensAddresses request missing arguments'));
+    }
+    if (opts.version && !['v2', 'v3'].includes(opts.version)) {
+      return Promise.reject(new ClientError('Invalid Aave version. Supported: v2, v3'));
+    }
+    const bc = this._getBlockchainExplorer(opts.chain, opts.network);
+    return new Promise((resolve, reject) => {
+      if (!bc) return reject(new Error('Could not get blockchain explorer instance'));
+      bc.getAaveReserveTokensAddresses(opts, (err, tokensAddresses) => {
+        if (err) {
+          this.logw('Error getting Aave reserve tokens addresses:', err);
+          return reject(err);
+        }
+        return resolve(tokensAddresses);
+      });
+    });
+  }
+
   getMultisigTxpsInfo(opts) {
     const bc = this._getBlockchainExplorer(opts.chain || Defaults.EVM_CHAIN, opts.network);
     return new Promise((resolve, reject) => {
@@ -2694,7 +2808,7 @@ export class WalletService implements IWalletService {
                 },
                 async next => {
                   // SOL is skipped since its a non necessary field that is expected to be provided by the client.
-                  if (!opts.nonce && !Constants.SVM_CHAINS[wallet.chain.toUpperCase()]) { 
+                  if (!opts.nonce && !Constants.SVM_CHAINS[wallet.chain.toUpperCase()] && !opts.deferNonce) {
                     try {
                       opts.nonce = await ChainService.getTransactionCount(this, wallet, opts.from);
                     } catch (error) {
@@ -2794,7 +2908,8 @@ export class WalletService implements IWalletService {
                       memo: opts.memo,
                       fromAta: opts.fromAta,
                       decimals: opts.decimals,
-                      refreshOnPublish: opts.refreshOnPublish
+                      refreshOnPublish: opts.refreshOnPublish,
+                      deferNonce: opts.deferNonce
                     };
                     txp = TxProposal.create(txOpts);
                     next();
@@ -2906,7 +3021,7 @@ export class WalletService implements IWalletService {
         this.storage.fetchTx(this.walletId, opts.txProposalId, (err, txp) => {
           if (err) return cb(err);
           if (!txp) return cb(Errors.TX_NOT_FOUND);
-          if (!txp.isTemporary() && !txp.isRepublishEnabled()) return cb(null, txp);
+          if (!txp.isTemporary() && !txp.hasMutableTxData()) return cb(null, txp);
 
           const copayer = wallet.getCopayer(this.copayerId);
 
@@ -2920,7 +3035,7 @@ 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.isRepublishEnabled() && txp.prePublishRaw) {
+            if (txp.hasMutableTxData() && txp.prePublishRaw) {
               raw = txp.prePublishRaw;
               signingKey = this._getSigningKey(raw, opts.proposalSignature, copayer.requestPubKeys);
             }
@@ -2943,7 +3058,7 @@ export class WalletService implements IWalletService {
             txp.status = 'pending';
             ChainService.refreshTxData(this, txp, opts, (err, txp) => {
               if (err) return cb(err);
-              if (txp.isRepublishEnabled() && !txp.prePublishRaw) {
+              if (txp.hasMutableTxData() && !txp.prePublishRaw) {
                 // We save the original raw transaction for verification on republish
                 txp.prePublishRaw = raw;
               }
@@ -3207,7 +3322,7 @@ export class WalletService implements IWalletService {
             try {
               const txps = await this.getPendingTxsPromise({});
               for (const t of txps) {
-                if (t.id !== txp.id && t.nonce <= txp.nonce && t.status !== 'rejected') {
+                if (t.id !== txp.id && t.nonce != null && txp.nonce != null && t.nonce <= txp.nonce && t.status !== 'rejected') {
                   return cb(Errors.TX_NONCE_CONFLICT);
                 }
               }
@@ -3268,6 +3383,68 @@ export class WalletService implements IWalletService {
     });
   }
 
+  /**
+   * Prepare a transaction proposal for signing.
+   * Assigns JIT values (nonce, and in the future: fee, gas) to a deferred txp.
+   * Called by the client just before signing.
+   * @param {Object} opts
+   * @param {string} opts.txProposalId - The identifier of the transaction.
+   */
+  prepareTx(opts, cb) {
+    if (!checkRequired(opts, ['txProposalId'], cb)) return;
+
+    this._runLocked(cb, cb => {
+      this.getWallet({}, (err, wallet) => {
+        if (err) return cb(err);
+
+        this.storage.fetchTx(this.walletId, opts.txProposalId, async (err, txp) => {
+          if (err) return cb(err);
+          if (!txp) return cb(Errors.TX_NOT_FOUND);
+          if (!txp.isPending()) return cb(Errors.TX_NOT_PENDING);
+
+          if (!txp.deferNonce) {
+            // Not a deferred-nonce txp. Return it as-is
+            return cb(null, txp);
+          }
+
+          if (!Constants.EVM_CHAINS[wallet.chain.toUpperCase()]) {
+            return cb(null, txp);
+          }
+
+          try {
+            // 1. Get confirmed nonce from blockchain
+            const confirmedNonce = await ChainService.getTransactionCount(this, wallet, txp.from);
+
+            // 2. Get pending TXP nonces from BWS's own database
+            const pendingTxps = await this.getPendingTxsPromise({});
+            const pendingNonces = pendingTxps
+              .filter(t => t.id !== txp.id && t.nonce != null && t.status !== 'rejected')
+              .map(t => Number(t.nonce));
+
+            // 3. Calculate gap-free nonce
+            let suggestedNonce = Number(confirmedNonce);
+            const allNonces = pendingNonces.sort((a, b) => a - b);
+            for (const n of allNonces) {
+              if (n === suggestedNonce) {
+                suggestedNonce++;
+              }
+            }
+
+            txp.nonce = suggestedNonce;
+
+            // 4. Store the updated txp
+            this.storage.storeTx(this.walletId, txp, err => {
+              if (err) return cb(err);
+              return cb(null, txp);
+            });
+          } catch (err) {
+            return cb(err);
+          }
+        });
+      });
+    });
+  }
+
   _processBroadcast(txp, opts, cb) {
     $.checkState(txp.txid, 'Failed state: txp.txid undefined at <_processBroadcast()>');
     opts = opts || {};

package/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 }) {