@bitpay-labs/bitcore-wallet-service 11.11.2 → 11.11.4

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

@@ -0,0 +1,95 @@
+import util from 'util';
+import { Constants, ethers } from '@bitpay-labs/crypto-wallet-core';
+import { ClientError } from '../../errors/clienterror';
+import { Errors } from '../../errors/errordefinitions';
+import { EthChain } from '../eth';
+import { ERC20Abi } from '../eth/abi-erc20';
+import type { TxProposal } from '../../model/txproposal';
+
+const usdcInterface = new ethers.Interface(ERC20Abi);
+
+export class ArcChain extends EthChain {
+  constructor() {
+    super();
+    this.chain = 'ARC';
+  }
+
+  private isUsdcTokenView(opts) {
+    return opts.tokenAddress?.toLowerCase() === Constants.ARC.USDC_CONTRACT_ADDRESS;
+  }
+
+  protected getAdditionalNativeAmount(txp: TxProposal): bigint {
+    if (txp.tokenAddress || txp.multisigContractAddress || txp.multiSendContractAddress) return 0n;
+
+    try {
+      return (txp.outputs || []).reduce((total, output, index) => {
+        if (output.toAddress?.toLowerCase() !== Constants.ARC.USDC_CONTRACT_ADDRESS) return total;
+        const data = index === 0 && txp.data ? txp.data : output.data;
+        if (!data || data === '0x') return total;
+        const call = usdcInterface.parseTransaction({ data });
+        let amount = 0n;
+        if (call?.name === 'transfer') {
+          amount = call.args[1];
+        } else if (call?.name === 'transferFrom' && call.args[0].toLowerCase() === txp.from?.toLowerCase()) {
+          amount = call.args[2];
+        }
+        // The ERC20 interface uses 6 decimals; the same native balance uses 18.
+        return total + amount * 10n ** 12n;
+      }, 0n);
+    } catch {
+      throw new ClientError('Invalid Arc USDC contract call data');
+    }
+  }
+
+  getWalletBalance(server, wallet, opts, cb) {
+    // Native USDC and its ERC-20 view share funds. A separate token balance would
+    // use different units and omit the native spend locked by pending proposals.
+    if (this.isUsdcTokenView(opts)) {
+      return cb(new ClientError('USDC is the native Arc balance; omit tokenAddress'));
+    }
+    return super.getWalletBalance(server, wallet, opts, cb);
+  }
+
+  getWalletSendMaxInfo(server, wallet, opts, cb) {
+    const onFee = (err, feePerKb?) => {
+      if (err) return cb(err);
+      feePerKb = Number(feePerKb);
+      if (!Number.isFinite(feePerKb) || feePerKb < Constants.ARC.MIN_GAS_PRICE) {
+        return cb(new ClientError('Arc gas price must be at least 20 gwei'));
+      }
+      return super.getWalletSendMaxInfo(server, wallet, { ...opts, feePerKb }, cb);
+    };
+    // Match the type-2 cap reserved when creating the proposal.
+    if (Number(opts.txType) === 2) {
+      return server.estimateFee({ network: wallet.network, chain: wallet.chain, txType: 2 })
+        .then(feePerKb => onFee(null, feePerKb), onFee);
+    }
+    return server._getFeePerKb(wallet, opts, onFee);
+  }
+
+  async getFee(server, wallet, opts) {
+    if (this.isUsdcTokenView(opts)) {
+      throw new ClientError('USDC is the native Arc asset; omit tokenAddress');
+    }
+    const fees = await super.getFee(server, wallet, opts);
+    const gasPrice = Number(Number(opts.txType) === 2 ? fees.maxGasFee : fees.gasPrice);
+    if (!Number.isFinite(gasPrice) || gasPrice < Constants.ARC.MIN_GAS_PRICE) {
+      throw new ClientError('Arc gas price must be at least 20 gwei');
+    }
+    // Reserve the fee actually encoded in the transaction, including type-2 caps.
+    const fee = gasPrice * fees.gasLimit;
+    if (opts.sendMax && Number(opts.txType) === 2) {
+      const balance = await util.promisify(server.getBalance).call(server, {});
+      if (balance.availableAmount <= fee) throw Errors.INSUFFICIENT_FUNDS_FOR_FEE;
+      opts.outputs[0].amount = balance.availableAmount - fee;
+    }
+    return { ...fees, fee };
+  }
+
+  checkDust(output, opts) {
+    if (!opts.tokenAddress && output.amount > 0 &&
+        output.toAddress.toLowerCase() === '0x0000000000000000000000000000000000000000') {
+      return new ClientError('Native USDC cannot be sent to the zero address on Arc');
+    }
+  }
+}

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

@@ -84,6 +84,10 @@ export class EthChain implements IChain {
     return true;
   }
 
+  protected getAdditionalNativeAmount(_txp: TxProposal): bigint {
+    return 0n;
+  }
+
   getWalletBalance(server, wallet, opts, cb) {
     const bc = server._getBlockchainExplorer(wallet.chain || wallet.coin, wallet.network);
 
@@ -106,18 +110,22 @@ export class EthChain implements IChain {
         let fees = 0n;
         let amounts = 0n;
 
-        txps.filter(txp => {
-          // Add gas used for tokens when getting native balance
-          if (!opts.tokenAddress) {
-            fees += txp.fee ? BigInt(txp.fee) : 0n;
-          }
-          // Filter tokens when getting native balance
-          if (txp.tokenAddress && !opts.tokenAddress) {
-            return false;
-          }
-          amounts += txp.amount ? BigInt(txp.amount) : 0n;
-          return true;
-        });
+        try {
+          txps.filter(txp => {
+            // Add gas used for tokens when getting native balance
+            if (!opts.tokenAddress) {
+              fees += txp.fee ? BigInt(txp.fee) : 0n;
+            }
+            // Filter tokens when getting native balance
+            if (txp.tokenAddress && !opts.tokenAddress) {
+              return false;
+            }
+            amounts += BigInt(txp.amount || 0) + this.getAdditionalNativeAmount(txp);
+            return true;
+          });
+        } catch (err) {
+          return cb(err);
+        }
 
         // TODO support big int
         const lockedSum = Number(amounts + fees) || 0;  // previously set to 0 if opts.multisigContractAddress
@@ -175,8 +183,15 @@ export class EthChain implements IChain {
   checkScriptOutput(_output) { }
 
   async getFee(server, wallet, opts) {
+    const { from, txType, priorityFeePercentile, gasLimitBuffer } = opts;
+    const { coin, network, chain } = wallet;
     const hasType2FeeOverride = opts.maxGasFee != null || opts.priorityGasFee != null;
     let { maxGasFee, priorityGasFee } = opts;
+    if (Number(txType) === 2 && !hasType2FeeOverride) {
+      maxGasFee = await server.estimateFee({ network, chain: chain || coin, txType: 2 });
+      priorityGasFee = await server.estimatePriorityFee({ network, chain: chain || coin, percentile: priorityFeePercentile || 15 });
+      maxGasFee = Math.max(maxGasFee, priorityGasFee);
+    }
     if (hasType2FeeOverride) {
       const chain = wallet.chain || wallet.coin;
       // Keep overrides consistent with CWC's chain-specific minimum priority fee.
@@ -185,8 +200,8 @@ export class EthChain implements IChain {
         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
+    // Reserve the same rate used for construction, including the automatic type-2 fee cap.
+    const feeOpts = opts.gasPrice != null || maxGasFee != null
       ? { ...opts, feePerKb: opts.gasPrice ?? maxGasFee }
       : opts;
     // Fixed fees are converted to a gas price below, once the gas limits are known.
@@ -196,8 +211,6 @@ export class EthChain implements IChain {
       : 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;
@@ -297,9 +310,9 @@ export class EthChain implements IChain {
       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 });
+    // BWC verifies an explicit feePerKb against the request, separately from the type-2 fee cap.
+    if (Number(txType) === 2 && Common.Utils.isNumber(opts.feePerKb)) {
+      feePerKb = opts.feePerKb;
     }
     return { feePerKb, gasPrice, gasLimit, maxGasFee, priorityGasFee, fee };
   }
@@ -482,10 +495,15 @@ export class EthChain implements IChain {
             "gasLimit":200000
         }]
         */
-        const txpTotalAmount =
-          (opts.multisigContractAddress || opts.tokenAddress) && txp.payProUrl
-            ? getInvoiceValue(txp)
-            : txp.getTotalAmountBigInt();
+        let txpTotalAmount;
+        try {
+          txpTotalAmount =
+            (opts.multisigContractAddress || opts.tokenAddress) && txp.payProUrl
+              ? getInvoiceValue(txp)
+              : txp.getTotalAmountBigInt() + this.getAdditionalNativeAmount(txp);
+        } catch (err) {
+          return cb(err);
+        }
 
         if (totalAmount < txpTotalAmount) {
           return cb(Errors.INSUFFICIENT_FUNDS);

package/src/lib/chain/index.ts

@@ -4,6 +4,7 @@ import { IWallet, TxProposal } from '../model';
 import { WalletService } from '../server';
 import logger from './../logger';
 import { ArbChain } from './arb';
+import { ArcChain } from './arc';
 import { BaseChain } from './base';
 import { BchChain } from './bch';
 import { BtcChain } from './btc';
@@ -24,6 +25,7 @@ const chains: { [chain: string]: IChain } = {
   ETH: new EthChain(),
   MATIC: new MaticChain(),
   ARB: new ArbChain(),
+  ARC: new ArcChain(),
   BASE: new BaseChain(),
   OP: new OpChain(),
   XRP: new XrpChain(),

package/src/lib/common/constants.ts

@@ -10,6 +10,7 @@ export const Constants = {
     ARB: 'arb',
     BASE: 'base',
     OP: 'op',
+    ARC: 'arc',
     XRP: 'xrp',
     DOGE: 'doge',
     LTC: 'ltc',
@@ -38,7 +39,8 @@ export const Constants = {
     EUROC: 'euroc',
     USDT: 'usdt',
     WETH: 'weth',
-    SOL: 'sol'
+    SOL: 'sol',
+    ARC: 'arc'
   },
 
   BITPAY_SUPPORTED_ETH_ERC20: {
@@ -60,6 +62,7 @@ export const Constants = {
 
   BITPAY_USD_STABLECOINS: {
     // used for rates
+    ARC: 'arc',
     USDC: 'usdc',
     PYUSD: 'pyusd',
     USDP: 'usdp',
@@ -88,6 +91,7 @@ export const Constants = {
     ARB: 'arb',
     BASE: 'base',
     OP: 'op',
+    ARC: 'arc',
   },
 
   EVM_CHAINS_WITH_ETH_GAS: {
@@ -112,6 +116,7 @@ export const Constants = {
     arb: ['livenet', 'sepolia', 'holesky', 'regtest'],
     base: ['livenet', 'sepolia', 'holesky', 'regtest'],
     op: ['livenet', 'sepolia', 'holesky', 'regtest'],
+    arc: ['livenet', 'testnet'],
     sol: ['livenet', 'testnet', 'devnet', 'regtest']
   } as { [chain: string]: Array<string> },
 
@@ -156,6 +161,9 @@ export const Constants = {
       mainnet: 'livenet',
       testnet: 'sepolia'
     },
+    arc: {
+      mainnet: 'livenet'
+    },
     sol: {
       mainnet: 'livenet',
       testnet: 'devnet'
@@ -200,6 +208,8 @@ export const Constants = {
   ARB_TOKEN_OPTS: CWC.Constants.ARB_TOKEN_OPTS,
   OP_TOKEN_OPTS: CWC.Constants.OP_TOKEN_OPTS,
   BASE_TOKEN_OPTS: CWC.Constants.BASE_TOKEN_OPTS,
+  ARC_TOKEN_OPTS: CWC.Constants.ARC_TOKEN_OPTS,
+  ARC: CWC.Constants.ARC,
   SOL_TOKEN_OPTS: CWC.Constants.SOL_TOKEN_OPTS,
 
   BITPAY_CONTRACTS: {
@@ -219,6 +229,7 @@ export const Constants = {
     bch: { testnet: 300, livenet: 0 },
     eth: { testnet: 300, livenet: 0 },
     matic: { testnet: 300, livenet: 12 }, // MATIC set to 12 because blocks normally occur every 1-2 seconds
+    arc: { testnet: 0, livenet: 0 },
     xrp: { testnet: 300, livenet: 0 },
     doge: { testnet: 300, livenet: 0 },
     ltc: { testnet: 300, livenet: 0 }
@@ -226,7 +237,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/defaults.ts

@@ -194,6 +194,34 @@ export const Defaults = {
         defaultValue: 2000000000
       }
     ],
+    // Fallbacks must meet Arc's testnet gas-price floor. Live estimates still take precedence.
+    arc: [
+      {
+        name: 'urgent',
+        nbBlocks: 1,
+        defaultValue: 20000000000
+      },
+      {
+        name: 'priority',
+        nbBlocks: 2,
+        defaultValue: 20000000000
+      },
+      {
+        name: 'normal',
+        nbBlocks: 3,
+        defaultValue: 20000000000
+      },
+      {
+        name: 'economy',
+        nbBlocks: 4,
+        defaultValue: 20000000000
+      },
+      {
+        name: 'superEconomy',
+        nbBlocks: 4,
+        defaultValue: 20000000000
+      }
+    ],
     xrp: [
       {
         name: 'normal',
@@ -362,6 +390,7 @@ export const Defaults = {
     arb: 1000000000000, // 50 Gwei,
     base: 1000000000000, // 50 Gwei,
     op: 1000000000000, // 50 Gwei,
+    arc: 1000000000000,
     xrp: 1000000000000,
     doge: 100000000 * 100,
     ltc: 10000 * 1000, // 10k sat/b
@@ -376,6 +405,7 @@ export const Defaults = {
     arb: 0,
     base: 0,
     op: 0,
+    arc: 0,
     xrp: 0,
     doge: 0,
     ltc: 0,
@@ -390,6 +420,7 @@ export const Defaults = {
     arb: 1 * 1e18, // 1 eth
     base: 1 * 1e18, // 1 eth
     op: 1 * 1e18, // 1 eth
+    arc: 1 * 1e18, // 1 USDC
     xrp: 1 * 1e6, // 1 xrp
     doge: 400 * 1e8,
     ltc: 0.05 * 1e8

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/emailservice.ts

@@ -337,6 +337,7 @@ export class EmailService {
       bch: 'BCH',
       eth: 'ETH',
       matic: 'MATIC',
+      arc: 'USDC',
       xrp: 'XRP',
       doge: 'DOGE',
       ltc: 'LTC',
@@ -685,6 +686,7 @@ export class EmailService {
           arb: 'arbitrum-one',
           base: 'base',
           op: 'optimistic-ethereum',
+          arc: 'arc',
           sol: 'solana',
         };
 
@@ -739,4 +741,4 @@ export class EmailService {
       });
     });
   }
-}
+}

package/src/lib/errors/errordefinitions.ts

@@ -37,6 +37,8 @@ interface Errors<T> {
   // Solana Errors
   INSUFFICIENT_SOL_FEE: T;
   LOCKED_SOL_FEE: T;
+  INSUFFICIENT_ARC_FEE: T;
+  LOCKED_ARC_FEE: T;
   HISTORY_LIMIT_EXCEEDED: T;
   MAIN_ADDRESS_GAP_REACHED: T;
   MULTI_TX_UNSUPPORTED: T;
@@ -114,6 +116,8 @@ const errors: Errors<string> = {
   LOCKED_OP_FEE: 'Your linked OP wallet does not have enough ETH for fee',
   INSUFFICIENT_SOL_FEE: 'Your linked SOL wallet does not have enough SOL for fee',
   LOCKED_SOL_FEE: 'Your linked SOL wallet does not have enough SOL for fee',
+  INSUFFICIENT_ARC_FEE: 'Your linked ARC wallet does not have enough USDC for fee',
+  LOCKED_ARC_FEE: 'Your linked ARC wallet USDC is locked by pending spend proposals',
   INVALID_ADDRESS: 'Invalid address',
   INVALID_CHANGE_ADDRESS: 'Invalid change address',
   KEY_IN_COPAYER: 'Key already registered',

package/src/lib/model/preferences.ts

@@ -12,6 +12,7 @@ export interface IPreferences {
   opTokenAddresses?: string[];
   baseTokenAddresses?: string[];
   arbTokenAddresses?: string[];
+  arcTokenAddresses?: string[];
   solTokenAddresses?: string[];
   multisigMaticInfo: object[];
 }
@@ -29,6 +30,7 @@ export class Preferences {
   opTokenAddresses: string[];
   baseTokenAddresses: string[];
   arbTokenAddresses: string[];
+  arcTokenAddresses: string[];
   solTokenAddresses: string[];
   multisigMaticInfo: object[];
 
@@ -50,6 +52,7 @@ export class Preferences {
     x.opTokenAddresses = opts.opTokenAddresses;
     x.baseTokenAddresses = opts.baseTokenAddresses;
     x.arbTokenAddresses = opts.arbTokenAddresses;
+    x.arcTokenAddresses = opts.arcTokenAddresses;
     x.solTokenAddresses = opts.solTokenAddresses;
     x.multisigMaticInfo = opts.multisigMaticInfo;
     // you can't put useDust here since this is copayer's specific.
@@ -72,6 +75,7 @@ export class Preferences {
     x.opTokenAddresses = obj.opTokenAddresses;
     x.baseTokenAddresses = obj.baseTokenAddresses;
     x.arbTokenAddresses = obj.arbTokenAddresses;
+    x.arcTokenAddresses = obj.arcTokenAddresses;
     x.solTokenAddresses = obj.solTokenAddresses;
     x.multisigMaticInfo = obj.multisigMaticInfo;
     return x;

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/model/wallet.ts

@@ -24,6 +24,7 @@ const Bitcore = {
   arb: BitcoreLib,
   base: BitcoreLib,
   op: BitcoreLib,
+  arc: BitcoreLib,
   xrp: BitcoreLib,
   doge: BitcoreLibDoge,
   ltc: BitcoreLibLtc,

package/src/lib/pushnotificationsservice.ts

@@ -474,6 +474,7 @@ export class PushNotificationsService {
       bch: 'BCH',
       eth: 'ETH',
       matic: 'MATIC',
+      arc: 'USDC',
       xrp: 'XRP',
       doge: 'DOGE',
       ltc: 'LTC',
@@ -748,6 +749,7 @@ export class PushNotificationsService {
           arb: 'arbitrum-one',
           base: 'base',
           op: 'optimistic-ethereum',
+          arc: 'arc',
           sol: 'solana',
         };
 

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) {