@bitpay-labs/bitcore-wallet-service 11.11.1 → 11.11.3

package/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:22
+FROM node:24
 RUN set -x && node -v && npm -v
 WORKDIR /bitcore
 

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.11.1",
+  "version": "11.11.3",
   "license": "MIT",
   "main": "ts_build/src/index.js",
   "types": "./ts_build/src/index.d.ts",
@@ -41,9 +41,9 @@
     "cp:templates": "cp -r ./templates ./ts_build/templates"
   },
   "dependencies": {
-    "@bitpay-labs/bitcore-logging": "^11.10.9",
-    "@bitpay-labs/bitcore-tss": "^11.11.1",
-    "@bitpay-labs/crypto-wallet-core": "^11.11.1",
+    "@bitpay-labs/bitcore-logging": "^11.11.2",
+    "@bitpay-labs/bitcore-tss": "^11.11.2",
+    "@bitpay-labs/crypto-wallet-core": "^11.11.2",
     "@sendgrid/mail": "6.5.4",
     "abi-decoder": "2.4.0",
     "async": "0.9.2",
@@ -107,5 +107,5 @@
       "email": "kjoseph@bitpay.com"
     }
   ],
-  "gitHead": "2d26cb6cfc59aab5415c9ce32863a9b9d832e5bb"
+  "gitHead": "154120b032bb0cd42bad2559c0ef81873a8c7e8c"
 }

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

@@ -41,7 +41,8 @@ export class BtcChain implements IChain {
     server.getUtxosForCurrentWallet(
       {
         coin: opts.coin,
-        addresses: opts.addresses
+        addresses: opts.addresses,
+        wallet
       },
       (err, utxos) => {
         if (err) return cb(err);
@@ -173,7 +174,7 @@ export class BtcChain implements IChain {
     return new Promise((resolve, reject) => {
       const getChangeAddress = (wallet, cb) => {
         if (wallet.singleAddress) {
-          server.storage.fetchAddresses(server.walletId, (err, addresses) => {
+          server.storage.fetchAddressesPage(server.walletId, { limit: 1 }, (err, addresses) => {
             if (err) return cb(err);
             if (!addresses?.length) return cb(new ClientError('The wallet has no addresses'));
             return cb(null, addresses[0]);

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

@@ -1,4 +1,5 @@
-import { Transactions, Utils, Validation, Web3 } from '@bitpay-labs/crypto-wallet-core';
+import util from 'util';
+import { Constants as CWCConstants, Transactions, Utils, Validation, Web3 } from '@bitpay-labs/crypto-wallet-core';
 import _ from 'lodash';
 import { IWallet } from 'src/lib/model';
 import { IAddress } from 'src/lib/model/address';
@@ -23,6 +24,9 @@ function requireUncached(module) {
   return require(module);
 }
 
+// the effect type bitcore-node gives ERC20 transfers in tx events
+const ERC20_TRANSFER_EFFECT = 'ERC20:transfer';
+
 const Erc20Decoder = requireUncached('abi-decoder');
 Erc20Decoder.addABI(ERC20Abi);
 
@@ -118,7 +122,7 @@ export class EthChain implements IChain {
         // TODO support big int
         const lockedSum = Number(amounts + fees) || 0;  // previously set to 0 if opts.multisigContractAddress
         const convertedBalance = this.convertBitcoreBalance(balance, lockedSum);
-        server.storage.fetchAddresses(server.walletId, (err, addresses: IAddress[]) => {
+        server.storage.fetchAddressesPage(server.walletId, { limit: 1 }, (err, addresses: IAddress[]) => {
           if (err) return cb(err);
           if (addresses.length > 0) {
             const byAddress = [
@@ -170,121 +174,134 @@ export class EthChain implements IChain {
 
   checkScriptOutput(_output) { }
 
-  getFee(server, wallet, opts) {
-    return new Promise(resolve => {
-      server._getFeePerKb(wallet, opts, async (err, inFeePerKb) => {
-        let feePerKb = inFeePerKb;
-        let gasPrice = inFeePerKb;
-        let maxGasFee;
-        let priorityGasFee;
-        const { from, txType, priorityFeePercentile, gasLimitBuffer } = opts;
-        const { coin, network, chain } = wallet;
-        let inGasLimit = 0; // Per recepient gas limit
-        let gasLimit = 0; // Gas limit for all recepients. used for contract interactions that rollup recepients
-        let fee = 0;
-        const defaultGasLimit = this.getDefaultGasLimit(opts);
-        const outputAddresses = []; // Parameter for MuliSend contract
-        const outputAmounts: bigint[] = []; // Parameter for MuliSend contract
-        let totalValue = 0n; // Parameter for MuliSend contract
-        logger.info(`getFee for address ${from} on network ${network} and chain ${chain}`);
-        logger.info('getFee.opts: %o', { from, txType, priorityFeePercentile, gasLimitBuffer });
-        logger.info(`[${from}] Add gas limit buffer?: ${!!gasLimitBuffer}`);
-        for (const output of opts.outputs) {
-          // Multisend txs build contract fn parameters (addresses, amounts) and bypass output level gas estimations
-          if (opts.multiSendContractAddress) {
-            outputAddresses.push(output.toAddress);
-            outputAmounts.push(BigInt(output.amount));
-            if (!opts.tokenAddress) {
-              totalValue += BigInt(output.amount);
-            }
-            // Used as a fallback value if estimateGas fails for multisend
-            inGasLimit += output.gasLimit ? output.gasLimit : defaultGasLimit;
-            continue;
-          }
-          // Estimate a standard transfer
-          if (!output.gasLimit) {
-            try {
-              const to = opts.payProUrl
-                ? output.toAddress
-                : opts.tokenAddress
-                  ? opts.tokenAddress
-                  : opts.multisigContractAddress
-                    ? opts.multisigContractAddress
-                    : output.toAddress;
-              const value = opts.tokenAddress || opts.multisigContractAddress ? 0 : output.amount;
-              // output.gasLimit used as the gasLimit in getBitcoreTx for non multisend transactions
-              const gasLimitEstimate = await server.estimateGas({
-                coin,
-                chain: this.chain,
-                network,
-                from,
-                to,
-                value,
-                data: output.data,
-                gasPrice
-              });
-              output.gasLimit = gasLimitEstimate || defaultGasLimit;
-            } catch {
-              output.gasLimit = defaultGasLimit;
-            }
-          }
-          inGasLimit += output.gasLimit;
-          logger.info(`[${from}][${output?.toAddress || opts?.tokenAddress}] Output level gas limit: ${output.gasLimit}`);
-          // Add gas Limit buffer to output level gasLimit
-          if (gasLimitBuffer) {
-            const gasBuffer = Math.ceil(output.gasLimit * (gasLimitBuffer / 100));
-            output.gasLimit += gasBuffer;
-            inGasLimit += gasBuffer;
-            logger.info(`[${from}][${output?.toAddress || opts?.tokenAddress}] Output gas limit with buffer: ${output.gasLimit}`);
-          }
-          if (_.isNumber(opts.fee)) {
-            // This is used for sendmax
-            gasPrice = feePerKb = Number((opts.fee / (inGasLimit || defaultGasLimit)).toFixed());
-          }
-          fee += feePerKb * output.gasLimit;
-        }
-        // gasLimit == sum of internal gasLimits (for non Multisend)
-        gasLimit = inGasLimit;
-        logger.info(`[${from}] Current top level gas limit: ${gasLimit}`);
-        if (opts.multiSendContractAddress) {
-          // Calculate gas limit for top level of txp based on multisend tx
-          let _gasLimit;
-          try {
-            const data = this.encodeContractParameters(
-              Constants.BITPAY_CONTRACTS.MULTISEND,
-              { addresses: outputAddresses, amounts: outputAmounts },
-              opts
-            );
-
-            _gasLimit = await server.estimateGas({
-              coin,
-              chain: this.chain,
-              network,
-              from,
-              to: opts.multiSendContractAddress,
-              value: totalValue.toString(),
-              data,
-              gasPrice
-            });
-            logger.info(`[${from}] Estimated multisend gas limit: ${_gasLimit}`);
-          } catch (error) {
-            logger.error('Error estimating gas for MultiSend contract: %o', error);
-          }
-          // Add gas limit buffer to top level gas limit
-          const buffer = gasLimitBuffer ? gasLimitBuffer / 100 : Defaults.MS_GAS_LIMIT_BUFFER_PERCENT;
-          // If gas estimation fails, fallback to sum of internal gasLimits
-          gasLimit = _gasLimit || gasLimit;
-          gasLimit += Math.ceil(gasLimit * buffer); // add gas limit buffer 
-          fee += feePerKb * gasLimit;
-          logger.info(`[${from}] Top level gas limit with buffer: ${gasLimit}`);
+  async getFee(server, wallet, opts) {
+    const hasType2FeeOverride = opts.maxGasFee != null || opts.priorityGasFee != null;
+    let { maxGasFee, priorityGasFee } = opts;
+    if (hasType2FeeOverride) {
+      const chain = wallet.chain || wallet.coin;
+      // Keep overrides consistent with CWC's chain-specific minimum priority fee.
+      const minimum = CWCConstants.FEE_MINIMUMS[chain.toUpperCase()]?.priority ?? 0;
+      if (priorityGasFee < minimum) {
+        throw new ClientError(`priorityGasFee must be at least ${minimum} wei for ${chain}`);
+      }
+    }
+    // Use the explicit rate for both construction and the fee reserved from the wallet balance.
+    const feeOpts = opts.gasPrice != null || hasType2FeeOverride
+      ? { ...opts, feePerKb: opts.gasPrice ?? maxGasFee }
+      : opts;
+    // Fixed fees are converted to a gas price below, once the gas limits are known.
+    const fixedFee = Common.Utils.isNumber(opts.fee) ? Number(opts.fee) : undefined;
+    const inFeePerKb = fixedFee != null
+      ? undefined
+      : await util.promisify(server._getFeePerKb).call(server, wallet, feeOpts);
+    let feePerKb = inFeePerKb;
+    let gasPrice = inFeePerKb;
+    const { from, txType, priorityFeePercentile, gasLimitBuffer } = opts;
+    const { coin, network, chain } = wallet;
+    let inGasLimit = 0; // Per recepient gas limit
+    let gasLimit = 0; // Gas limit for all recepients. used for contract interactions that rollup recepients
+    let fee = 0;
+    const defaultGasLimit = this.getDefaultGasLimit(opts);
+    const outputAddresses = []; // Parameter for MuliSend contract
+    const outputAmounts: bigint[] = []; // Parameter for MuliSend contract
+    let totalValue = 0n; // Parameter for MuliSend contract
+    logger.info(`getFee for address ${from} on network ${network} and chain ${chain}`);
+    logger.info('getFee.opts: %o', { from, txType, priorityFeePercentile, gasLimitBuffer });
+    logger.info(`[${from}] Add gas limit buffer?: ${!!gasLimitBuffer}`);
+    for (const output of opts.outputs) {
+      // Multisend txs build contract fn parameters (addresses, amounts) and bypass output level gas estimations
+      if (opts.multiSendContractAddress) {
+        outputAddresses.push(output.toAddress);
+        outputAmounts.push(BigInt(output.amount));
+        if (!opts.tokenAddress) {
+          totalValue += BigInt(output.amount);
         }
-        if (Number(txType) === 2) {
-          maxGasFee = await server.estimateFee({ network, chain: wallet.chain || coin, txType: 2 });
-          priorityGasFee = await server.estimatePriorityFee({ network, chain: wallet.chain || coin, percentile: priorityFeePercentile || 15 });
+        // Used as a fallback value if estimateGas fails for multisend
+        inGasLimit += output.gasLimit ? output.gasLimit : defaultGasLimit;
+        continue;
+      }
+      // Estimate a standard transfer
+      if (!output.gasLimit) {
+        try {
+          const to = opts.payProUrl
+            ? output.toAddress
+            : opts.tokenAddress
+              ? opts.tokenAddress
+              : opts.multisigContractAddress
+                ? opts.multisigContractAddress
+                : output.toAddress;
+          const value = opts.tokenAddress || opts.multisigContractAddress ? 0 : output.amount;
+          // output.gasLimit used as the gasLimit in getBitcoreTx for non multisend transactions
+          const gasLimitEstimate = await server.estimateGas({
+            coin,
+            chain: this.chain,
+            network,
+            from,
+            to,
+            value,
+            data: output.data,
+            gasPrice
+          });
+          output.gasLimit = gasLimitEstimate || defaultGasLimit;
+        } catch {
+          output.gasLimit = defaultGasLimit;
         }
-        return resolve({ feePerKb, gasPrice, gasLimit, maxGasFee, priorityGasFee, fee });
-      });
-    });
+      }
+      inGasLimit += output.gasLimit;
+      logger.info(`[${from}][${output?.toAddress || opts?.tokenAddress}] Output level gas limit: ${output.gasLimit}`);
+      // Add gas Limit buffer to output level gasLimit
+      if (gasLimitBuffer) {
+        const gasBuffer = Math.ceil(output.gasLimit * (gasLimitBuffer / 100));
+        output.gasLimit += gasBuffer;
+        inGasLimit += gasBuffer;
+        logger.info(`[${from}][${output?.toAddress || opts?.tokenAddress}] Output gas limit with buffer: ${output.gasLimit}`);
+      }
+      if (fixedFee != null) {
+        // This is used for sendmax
+        gasPrice = feePerKb = Number((fixedFee / (inGasLimit || defaultGasLimit)).toFixed());
+      }
+      fee += feePerKb * output.gasLimit;
+    }
+    // gasLimit == sum of internal gasLimits (for non Multisend)
+    gasLimit = inGasLimit;
+    logger.info(`[${from}] Current top level gas limit: ${gasLimit}`);
+    if (opts.multiSendContractAddress) {
+      // Calculate gas limit for top level of txp based on multisend tx
+      let _gasLimit;
+      try {
+        const data = this.encodeContractParameters(
+          Constants.BITPAY_CONTRACTS.MULTISEND,
+          { addresses: outputAddresses, amounts: outputAmounts },
+          opts
+        );
+
+        _gasLimit = await server.estimateGas({
+          coin,
+          chain: this.chain,
+          network,
+          from,
+          to: opts.multiSendContractAddress,
+          value: totalValue.toString(),
+          data,
+          gasPrice
+        });
+        logger.info(`[${from}] Estimated multisend gas limit: ${_gasLimit}`);
+      } catch (error) {
+        logger.error('Error estimating gas for MultiSend contract: %o', error);
+      }
+      // Add gas limit buffer to top level gas limit
+      const buffer = gasLimitBuffer ? gasLimitBuffer / 100 : Defaults.MS_GAS_LIMIT_BUFFER_PERCENT;
+      // If gas estimation fails, fallback to sum of internal gasLimits
+      gasLimit = _gasLimit || gasLimit;
+      gasLimit += Math.ceil(gasLimit * buffer); // add gas limit buffer
+      fee += feePerKb * gasLimit;
+      logger.info(`[${from}] Top level gas limit with buffer: ${gasLimit}`);
+    }
+    if (Number(txType) === 2 && !hasType2FeeOverride) {
+      maxGasFee = await server.estimateFee({ network, chain: wallet.chain || coin, txType: 2 });
+      priorityGasFee = await server.estimatePriorityFee({ network, chain: wallet.chain || coin, percentile: priorityFeePercentile || 15 });
+    }
+    return { feePerKb, gasPrice, gasLimit, maxGasFee, priorityGasFee, fee };
   }
 
   isPrePublishRawBound(txp: TxProposal) {
@@ -613,7 +630,7 @@ export class EthChain implements IChain {
     if (tx.effects && tx.effects.length) {
       const multisigConfirm = tx.effects.findIndex(e => e.type === 'MULTISIG:confirmTransaction');
       const multisigSubmit = tx.effects.findIndex(e => e.type === 'MULTISIG:submitTransaction');
-      const erc20Transfer = tx.effects.findIndex(e => e.type === 'ERC20:transer');
+      const erc20Transfer = tx.effects.findIndex(e => e.type === ERC20_TRANSFER_EFFECT);
       const internalTransfer = tx.effects.findIndex(e => !e.type && !e.contractAddress);
 
       const exists = [multisigConfirm, multisigSubmit, erc20Transfer, internalTransfer].filter(i => i > -1);
@@ -625,7 +642,7 @@ export class EthChain implements IChain {
           multisigContractAddress = best.contractAddress;
           address = best.to;
           amount = best.amount;
-        } else if (best.type == 'ERC20:transfer') {
+        } else if (best.type == ERC20_TRANSFER_EFFECT) {
           tokenAddress = best.contractAddress;
           address = best.to;
           amount = best.amount;

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

@@ -73,7 +73,7 @@ export class SolChain implements IChain {
           const lockedSum = Number(amounts + fees) || 0;  // previously set to 0 if opts.multisigContractAddress
           const reserveAmount = opts.tokenAddress ? 0 : reserve;
           const convertedBalance = this.convertBitcoreBalance(balance, lockedSum, reserveAmount);
-          server.storage.fetchAddresses(server.walletId, (err, addresses: IAddress[]) => {
+          server.storage.fetchAddressesPage(server.walletId, { limit: 1 }, (err, addresses: IAddress[]) => {
             if (err) return cb(err);
             if (addresses.length > 0) {
               const byAddress = [

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

@@ -69,7 +69,7 @@ export class XrpChain implements IChain {
             return sum + BigInt(txp.amount || 0) + BigInt(txp.fee || 0);
           }, 0n) || 0n;
           const convertedBalance = this.convertBitcoreBalance(balance, Number(lockedSum), reserve);
-          server.storage.fetchAddresses(server.walletId, (err, addresses: IAddress[]) => {
+          server.storage.fetchAddressesPage(server.walletId, { limit: 1 }, (err, addresses: IAddress[]) => {
             if (err) return cb(err);
             if (addresses.length > 0) {
               const byAddress = [

package/src/lib/common/constants.ts

@@ -226,7 +226,7 @@ export const Constants = {
 
   // May be different from the defaults if we rollback
   // or want to beta test new versions.
-  TSS_KEYGEN_SCHEME_VERSION_MAX: 1.2,
+  TSS_KEYGEN_SCHEME_VERSION_MAX: 1.3,
   TSS_SIGGEN_SCHEME_VERSION_MAX: 1.1,
   
   TSS_KEYGEN_SCHEME_VERSION_MIN: 1,

package/src/lib/common/utils.ts

@@ -571,5 +571,22 @@ export const Utils = {
     return retval;
   },
 
-  sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  },
+
+  convertXPubKeyForNetwork(xPubKey: string, chain: string, network: string) {
+    // Convert named network for non-UTXO chains to generic name (e.g. sepolia -> testnet)
+    network = !Bitcore_[chain] ? Utils.getGenericName(network) : network;
+    const lib = Bitcore_[chain] || BitcoreLib;
+    $.checkArgument(xPubKey, 'xPubKey is required at <convertXPubKeyForNetwork()>');
+    $.checkArgument(chain, 'chain is required at <convertXPubKeyForNetwork()>');
+    $.checkArgument(lib.Networks.get(network), 'invalid network at <convertXPubKeyForNetwork()>: ' + network);
+    const hdPubKeyObj = new lib.HDPublicKey(xPubKey).toObject();
+    hdPubKeyObj.network = network;
+    delete hdPubKeyObj.checksum;
+    delete hdPubKeyObj.xpubkey;
+    const newHdPubKey = lib.HDPublicKey.fromObject(hdPubKeyObj);
+    return newHdPubKey.toString();
+  }
 };

package/src/lib/model/tsskeygen.ts

@@ -80,9 +80,18 @@ export interface ITssKeyGenModel {
    */
   timeLimit?: number;
   /**
+   * @deprecated Use bwsJoinSecrets instead.
    * The BWC-generated secret for joining a BWS wallet
    */
   bwsJoinSecret?: string;
+  /**
+   * The BWC-generated secrets for joining a BWS wallet
+   */
+  bwsJoinSecrets?: {
+    [chainNetwork: string]: {
+      [partyId: number]: string;
+    };
+  };
   /**
    * The mongo doc version
    */
@@ -105,6 +114,11 @@ export class TssKeyGenModel implements ITssKeyGenModel {
   createdOn: number;
   timeLimit?: number;
   bwsJoinSecret?: string;
+  bwsJoinSecrets?: {
+    [chainNetwork: string]: {
+      [partyId: number]: string;
+    };
+  };
   __v: number;
 
 
@@ -151,6 +165,7 @@ export class TssKeyGenModel implements ITssKeyGenModel {
     x.keyShares = new Array(n);
     x.createdOn = Date.now();
     x.timeLimit = Math.min(timeLimit || Defaults.TSS_KEYGEN_TIME_LIMIT, 60) * ONE_MINUTE; // capped at 60 minutes
+    x.bwsJoinSecrets = {};
     x.__v = 0;
     return x;
   }
@@ -169,6 +184,7 @@ export class TssKeyGenModel implements ITssKeyGenModel {
     x.createdOn = obj.createdOn;
     x.timeLimit = obj.timeLimit;
     x.bwsJoinSecret = obj.bwsJoinSecret;
+    x.bwsJoinSecrets = obj.bwsJoinSecrets;
     x.__v = obj.__v;
     return x;
   }

package/src/lib/routes/maintenance.ts

@@ -1,4 +1,5 @@
 import express from 'express';
+import { ClientError } from '../errors/clienterror';
 import { WalletService } from '../server';
 import { Stats } from '../stats';
 import type * as Types from '../../types/expressapp';
@@ -27,6 +28,14 @@ export function registerMaintenanceRoutes(router: express.Router, context: Route
   });
 
   router.get('/v1/stats/', (req, res) => {
+    const { network, coin } = req.query;
+    if (network !== undefined && typeof network !== 'string') {
+      return returnError(new ClientError('Invalid network'), res, req);
+    }
+    if (coin !== undefined && typeof coin !== 'string') {
+      return returnError(new ClientError('Invalid coin'), res, req);
+    }
+
     setPublicCache(res, 1 * ONE_MINUTE);
     const opts: {
       network?: string;
@@ -35,8 +44,8 @@ export function registerMaintenanceRoutes(router: express.Router, context: Route
       to?: string;
     } = {};
 
-    if (req.query.network) opts.network = req.query.network as string;
-    if (req.query.coin) opts.coin = req.query.coin as string;
+    if (network) opts.network = network;
+    if (coin) opts.coin = coin;
     if (req.query.from) opts.from = req.query.from as string;
     if (req.query.to) opts.to = req.query.to as string;
 

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

@@ -11,9 +11,7 @@ import type { ITssSigMessageObject, TssSigGenModel } from '../../model/tsssign';
 function verifyMessage(req: express.Request, signature: string, pubKey: string) {
   const message = getMessage(req);
   const isValid = !!Utils.verifyMessage(message, signature, pubKey);
-  if (!isValid) {
-    throw Errors.NOT_AUTHORIZED.withMessage('Invalid signature');
-  }
+  return isValid;
 }
 
 /**
@@ -21,7 +19,8 @@ function verifyMessage(req: express.Request, signature: string, pubKey: string)
  * It checks if the request has valid credentials, verifies the signature,
  * and retrieves the TSS session based on the request path.
  */
-export function authTssKeyGenRequest(): express.RequestHandler {
+export function authTssKeyGenRequest(params: { bypassExpired?: boolean } = {}): express.RequestHandler {
+  const { bypassExpired } = params;
   return async function(req, res, next) {
     try {
       const storage = WalletService.getStorage();
@@ -46,7 +45,10 @@ export function authTssKeyGenRequest(): express.RequestHandler {
         // This is a brand new session. Caller should be party 0 with the initial round message.
         if (body?.message?.round === 0 && body?.message?.partyId === 0) {
           const pubKey = body?.message?.publicKey;
-          verifyMessage(req, signature, pubKey); // Self verification, but at least ensures that the caller owns the message's private key
+          if (!verifyMessage(req, signature, pubKey)) {
+            // Self verification, but at least ensures that the caller owns the message's private key
+            throw Errors.NOT_AUTHORIZED.withMessage('Invalid signature');
+          }
           return next();
         } else {
           // Session should have been initialized by the client already in BWC > TssKeyGen.newKey()
@@ -54,7 +56,7 @@ export function authTssKeyGenRequest(): express.RequestHandler {
         }
       }
 
-      if (session.isExpired()) {
+      if (!bypassExpired && session.isExpired()) {
         throw Errors.TSS_SESSION_EXPIRED;
       }
 
@@ -103,7 +105,9 @@ export function authTssKeyGenRequest(): express.RequestHandler {
         throw Errors.NOT_AUTHORIZED.withMessage('Copayer not found in session');
       }
 
-      verifyMessage(req, signature, pubKey);
+      if (!verifyMessage(req, signature, pubKey)) {
+        throw Errors.NOT_AUTHORIZED.withMessage('Invalid signature');
+      }
     
       req.session = session;
       return next();
@@ -116,7 +120,8 @@ export function authTssKeyGenRequest(): express.RequestHandler {
   };
 };
 
-export function authTssSignRequest(): express.RequestHandler {
+export function authTssSignRequest(params: { joinable?: boolean } = {}): express.RequestHandler {
+  const { joinable } = params;
   return async function(req, res, next) {
     try {
       const storage = WalletService.getStorage();
@@ -132,16 +137,22 @@ export function authTssSignRequest(): express.RequestHandler {
       
       const { id } = req.params as { [key: string]: string };
       const body = req.body as { message: ITssSigMessageObject | undefined };
-      // Only some requests carry a body.message (e.g. POST /store only sends the final signature).
-      //  Omitting it is safe since routes that don't receive a message don't consume one.
-      const verifyMsg = !!body?.message;
 
       const copayer = await storage.fetchCopayerLookup(copayerId);
       if (!copayer) {
         throw Errors.NOT_AUTHORIZED.withMessage('Copayer not found');
       }
-      const pubKey = copayer.requestPubKeys[0].key;
-      if (verifyMsg && pubKey !== body?.message?.publicKey) {
+      // I'm not aware of an instance where copayer.requestPubKeys.length > 1, but we iterate over them to find the key for the given signature.
+      const pubKey = copayer.requestPubKeys.find(pubKey => verifyMessage(req, signature, pubKey.key))?.key;
+      if (!pubKey) {
+        throw Errors.NOT_AUTHORIZED.withMessage('Invalid signature');
+      }
+
+      // Only some requests carry a body.message (e.g. POST /store only sends the final signature).
+      // Omitting it is safe since routes that don't receive a message don't change state.
+      // `verifyMsgFields` just indicates whether to check the message's fields for expected values (e.g. publicKey, partyId).
+      const verifyMsgFields = !!body?.message;
+      if (verifyMsgFields && pubKey !== body?.message?.publicKey) {
         throw Errors.NOT_AUTHORIZED.withMessage('Invalid public key');
       }
 
@@ -152,10 +163,12 @@ export function authTssSignRequest(): express.RequestHandler {
           throw Errors.TSS_SESSION_EXPIRED;
         }
         const party = session.participants.find(p => p.copayerId === copayerId);
-        if (!party) {
+        // A copayer joins an existing session by sending its round 0 message (participant is added in TssSign.processMessage)
+        const isJoining = !party && body?.message?.round === 0;
+        if (!party && !(joinable && isJoining)) {
           throw Errors.NOT_AUTHORIZED.withMessage('Copayer not found in session');
         }
-        if (verifyMsg && party.partyId !== body?.message?.partyId) {
+        if (verifyMsgFields && party && party.partyId !== body?.message?.partyId) {
           throw Errors.NOT_AUTHORIZED.withMessage('Copayer not found in session');
         }
 
@@ -164,7 +177,6 @@ export function authTssSignRequest(): express.RequestHandler {
         throw Errors.TSS_SESSION_NOT_FOUND;
       }
       
-      verifyMessage(req, signature, pubKey);
       return next();
     } catch (err) {
       if (err instanceof ClientError) {

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

@@ -14,7 +14,10 @@ export async function verifyTssMessage(req, res, next) {
       throw Errors.TSS_PUBKEY_MISSING;
     }
 
-    if (!message.broadcastMessages?.length && !message.p2pMessages?.length) {
+    // 1-of-N signing sessions won't have messages for other recipients.
+    //  req.session is unset for a new session, and keygen sessions have no `m`.
+    const isSoloSigner = req.session?.m === 1;
+    if (!isSoloSigner && !message.broadcastMessages?.length && !message.p2pMessages?.length) {
       throw Errors.TSS_INVALID_MESSAGE;
     }
 

package/src/lib/routes/services.ts

@@ -3,6 +3,7 @@ import express from 'express';
 import rp from 'request-promise-native';
 import config from '../../config';
 import { Common } from '../common';
+import { ClientError } from '../errors/clienterror';
 import type * as Types from '../../types/expressapp';
 import type { WalletService } from '../server';
 
@@ -125,13 +126,18 @@ export function registerServiceRoutes(router: express.Router, context: RouteCont
   });
 
   router.get('/v1/fiatrates/:code/', (req, res) => {
+    const { coin } = req.query;
+    if (coin !== undefined && typeof coin !== 'string') {
+      return context.returnError(new ClientError('Invalid coin'), res, req);
+    }
+
     setPublicCache(res, 5 * ONE_MINUTE);
     respondWithPublicServer(req, res, context, server =>
       callbackResult(resolve => {
         server.getFiatRate(
           {
             code: req.params['code'],
-            coin: req.query.coin || 'btc',
+            coin: coin || 'btc',
             ts: req.query.ts ? +req.query.ts : null
           },
           resolve