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

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.13",
   "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.13",
+    "@bitpay-labs/crypto-wallet-core": "^11.10.13",
     "@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": "c51c900f0009f1237ef30dca2c35922381864491"
 }

package/src/externalservices/moonpay.ts

@@ -560,7 +560,8 @@ export class MoonpayService {
           if (err) {
             return reject(err.body ? err.body : err);
           } else {
-            return resolve(data.body ? data.body : data);
+            const success = data.statusCode >= 200 && data.statusCode < 300;
+            return resolve(data.body ? data.body : { success });
           }
         }
       );

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

@@ -327,8 +327,8 @@ export class BtcChain implements IChain {
 
     // if TX is ready? no estimation is needed.
     if (txp.inputs.length && !txp.changeAddress && txp.outputs.length) {
-      const totalInputs = txp.inputs.reduce((sum, x) => sum + x.satoshis, 0);
-      const totalOutputs = txp.outputs.reduce((sum, x) => sum + x.amount, 0);
+      const totalInputs = txp.inputs.reduce((sum, x) => sum + Number(x.satoshis), 0);
+      const totalOutputs = txp.outputs.reduce((sum, x) => sum + Number(x.amount), 0);
       if (totalInputs && totalOutputs) {
         fee = totalInputs - totalOutputs;
       }
@@ -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();
 
@@ -396,24 +401,24 @@ export class BtcChain implements IChain {
     }
 
     for (const o of txp.outputs || []) {
-      o.amount = parseInt(o.amount);
+      const amount = parseInt(o.amount);
       $.checkState(o.script || o.toAddress, 'Failed state: Output should have either toAddress or script specified at <getBitcoreTx()>');
       if (o.script) {
         t.addOutput(
           new this.bitcoreLib.Transaction.Output({
             script: o.script,
-            satoshis: o.amount
+            satoshis: amount
           })
         );
       } else {
-        t.to(o.toAddress, o.amount);
+        t.to(o.toAddress, amount);
       }
     }
 
     t.fee(parseInt(txp.fee));
 
     if (txp.instantAcceptanceEscrow && txp.escrowAddress) {
-      t.escrow(txp.escrowAddress.address, txp.instantAcceptanceEscrow + txp.fee);
+      t.escrow(txp.escrowAddress.address, Number(txp.instantAcceptanceEscrow) + Number(txp.fee));
     }
 
     if (txp.enableRBF) t.enableRBF();
@@ -563,7 +568,7 @@ export class BtcChain implements IChain {
       conservativeEstimation: opts.payProUrl ? true : false,
       instantAcceptanceEscrow: opts.instantAcceptanceEscrow
     };
-    const escrowAmount = opts.instantAcceptanceEscrow || 0;
+    const escrowAmount = Number(opts.instantAcceptanceEscrow) || 0;
     const txpAmount = txp.getTotalAmount() + escrowAmount;
     const baseTxpSize = this.getEstimatedSize(txp, feeOpts);
     const baseTxpFee = (baseTxpSize * txp.feePerKb) / 1000;

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,
@@ -464,7 +468,7 @@ export class EthChain implements IChain {
         const txpTotalAmount =
           (opts.multisigContractAddress || opts.tokenAddress) && txp.payProUrl
             ? getInvoiceValue(txp)
-            : txp.getTotalAmount();
+            : txp.getTotalAmountBigInt();
 
         if (totalAmount < txpTotalAmount) {
           return cb(Errors.INSUFFICIENT_FUNDS);

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,7 +2,9 @@ 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 { ClientError } from '../../errors/clienterror';
 import { Errors } from '../../errors/errordefinitions';
 import logger from '../../logger';
 import { IWallet, TxProposal, Wallet } from '../../model';
@@ -28,6 +30,7 @@ export class SolChain implements IChain {
       totalConfirmedAmount: confirmed,
       lockedAmount: activatedLocked,
       lockedConfirmedAmount: activatedLocked,
+      reserve: balance > 0 ? minRent : 0,
       availableAmount: balance - activatedLocked,
       availableConfirmedAmount: confirmed - activatedLocked,
       byAddress: []
@@ -93,11 +96,31 @@ export class SolChain implements IChain {
     return new Promise(resolve => {
       const numSignatures = opts.numSignatures || 1;
       const feePerKb = Defaults.SOL_BASE_FEE; // Fee per signature in lamports
-      const fee = feePerKb * numSignatures;
+      let fee = feePerKb * numSignatures;
+      if (opts.priorityFee) {
+        fee += this.getPriorityFee(opts);
+      }
       return resolve({ fee, feePerKb });
     });
   }
 
+  /**
+   * Lamports charged on top of the signature fee when a priority fee is set:
+   * ceil(micro-lamports per compute unit * compute unit limit / 1e6).
+   * Without computeUnits the runtime reserves a fixed limit per instruction, so count the
+   * instructions CWC builds for a transfer: one per recipient, plus one for a memo.
+   */
+  private getPriorityFee({ priorityFee, computeUnits, outputs = [], memo }) {
+    const microLamportsPerUnit = Math.max(Defaults.SOL_MIN_PRIORITY_FEE, priorityFee);
+    const instructions = Math.max(outputs.length, 1) + (memo ? 1 : 0);
+    const units = computeUnits || Math.min(Defaults.SOL_MAX_COMPUTE_UNITS, Defaults.SOL_COMPUTE_UNITS_PER_INSTRUCTION * instructions);
+    return Math.ceil(microLamportsPerUnit * units / 1e6);
+  }
+
+  isPrePublishRawBound(txp) {
+    return Common.Utils.isPrePublishRawBound(this, txp);
+  }
+
   getBitcoreTx(txp, opts = { signed: true }) {
     const {
       data,
@@ -227,16 +250,41 @@ export class SolChain implements IChain {
       const { totalAmount, availableAmount } = balance;
       // calculate how much space is needed to find rent amount
       const minRentException = opts.tokenAddress ? 0 : Defaults.MIN_SOL_BALANCE;
-      if (totalAmount - minRentException < txp.getTotalAmount()) {
+      if (totalAmount - minRentException < txp.getTotalAmountBigInt()) {
         return cb(Errors.INSUFFICIENT_FUNDS);
-      } else if (availableAmount < txp.getTotalAmount()) {
+      } else if (availableAmount < txp.getTotalAmountBigInt()) {
         return cb(Errors.LOCKED_FUNDS);
+      } else if (opts.tokenAddress) {
+        // SPL fees are paid in SOL. Fetch the native balance without opts.wallet,
+        // since getWalletBalance leaves tokenAddress set on that object.
+        server.getBalance({}, (err, solBalance) => {
+          if (err) return cb(err);
+          if (solBalance.totalAmount < txp.fee) {
+            return cb(this.getFeeError('INSUFFICIENT_SOL_FEE', txp));
+          } else if (solBalance.availableAmount < txp.fee) {
+            return cb(this.getFeeError('LOCKED_SOL_FEE', txp));
+          } else {
+            return cb(this.checkTx(txp));
+          }
+        });
+      } else if (availableAmount - txp.fee < txp.getTotalAmountBigInt()) {
+        return cb(this.getFeeError('INSUFFICIENT_FUNDS_FOR_FEE', txp));
       } else {
         return cb(this.checkTx(txp));
       }
     });
   }
 
+  private getFeeError(code: 'INSUFFICIENT_SOL_FEE' | 'LOCKED_SOL_FEE' | 'INSUFFICIENT_FUNDS_FOR_FEE', txp: TxProposal) {
+    return new ClientError(
+      Errors.codes[code],
+      `${Errors[code].message}. RequiredFee: ${txp.fee}`,
+      {
+        requiredFee: txp.fee
+      }
+    );
+  }
+
   validateAddress(wallet, inaddr, opts) {
     const chain = this.chain.toLowerCase();
     const isValidTo = Validation.validateAddress(chain, wallet.network, inaddr);

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';
@@ -218,9 +223,9 @@ export class XrpChain implements IChain {
       if (err) return cb(err);
       const { totalAmount, availableAmount } = balance;
       const minXrpBalance = Defaults.MIN_XRP_BALANCE;
-      if (totalAmount - minXrpBalance < txp.getTotalAmount()) {
+      if (totalAmount - minXrpBalance < txp.getTotalAmountBigInt()) {
         return cb(Errors.INSUFFICIENT_FUNDS);
-      } else if (availableAmount < txp.getTotalAmount()) {
+      } else if (availableAmount < txp.getTotalAmountBigInt()) {
         return cb(Errors.LOCKED_FUNDS);
       } else {
         return cb(this.checkTx(txp));

package/src/lib/common/defaults.ts

@@ -414,6 +414,12 @@ export const Defaults = {
 
   SOL_BASE_FEE: 5000,
 
+  // SOL prioritization fee: CWC raises any priority fee to at least this many micro-lamports per compute unit
+  SOL_MIN_PRIORITY_FEE: 1000,
+  // Compute unit limit the runtime reserves per instruction when no limit is set, and the per-tx maximum
+  SOL_COMPUTE_UNITS_PER_INSTRUCTION: 200000,
+  SOL_MAX_COMPUTE_UNITS: 1400000,
+
   // Time to get the latest push notification subscriptions. In ms.
   PUSH_NOTIFICATION_SUBS_TIME: 10 * 60 * 1000, // 10 min.
 

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/errors/errordefinitions.ts

@@ -34,6 +34,9 @@ interface Errors<T> {
   // Optimisim Errors
   INSUFFICIENT_OP_FEE: T;
   LOCKED_OP_FEE: T;
+  // Solana Errors
+  INSUFFICIENT_SOL_FEE: T;
+  LOCKED_SOL_FEE: T;
   HISTORY_LIMIT_EXCEEDED: T;
   MAIN_ADDRESS_GAP_REACHED: T;
   MULTI_TX_UNSUPPORTED: T;
@@ -105,6 +108,8 @@ const errors: Errors<string> = {
   LOCKED_BASE_FEE: 'Your linked BASE wallet does not have enough ETH for fee',
   INSUFFICIENT_OP_FEE: 'Your linked OP wallet does not have enough ETH for fee',
   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',
   INVALID_ADDRESS: 'Invalid address',
   INVALID_CHANGE_ADDRESS: 'Invalid change address',
   KEY_IN_COPAYER: 'Key already registered',

package/src/lib/model/txproposal.ts

@@ -478,7 +478,11 @@ export class TxProposal<NumberType = number> implements ITxProposal<NumberType>
    * @return {Number} total amount of all outputs excluding change output
    */
   getTotalAmount() {
-    return Number(((this as TxProposal<number>).outputs || []).reduce((total, o) => total += BigInt(o.amount), 0n));
+    return Number(this.getTotalAmountBigInt());
+  }
+
+  getTotalAmountBigInt() {
+    return ((this as TxProposal<number>).outputs || []).reduce((total, o) => total += BigInt(o.amount), 0n);
   }
 
   /**
@@ -526,11 +530,19 @@ export class TxProposal<NumberType = number> implements ITxProposal<NumberType>
   sign(copayerId, signatures, xpub, numberFormat?: NumberFormat) {
     try {
       // numberFormat as 'number' is to sidestep TS errors, but is not necessarily true.
-      const txp = numberFormat ? TxProposal.formatNumbers(this, numberFormat as 'number') : this as TxProposal<number>;
-      const tx = ChainService.getBitcoreTx(txp);
+      const clientTxp = numberFormat ? TxProposal.formatNumbers(this, numberFormat as 'number') : this as TxProposal<number>;
+      const clientTx = ChainService.getBitcoreTx(clientTxp);
+      if (numberFormat) {
+        // Signatures only bind the bytes the copayer signed, and every later rebuild starts from
+        // the stored values, so a format that rebuilds other bytes signs a different transaction.
+        const storedTx = ChainService.getBitcoreTx(this as TxProposal<number>);
+        if (JSON.stringify(clientTx.uncheckedSerialize()) !== JSON.stringify(storedTx.uncheckedSerialize())) {
+          throw new Error(`numberFormat ${numberFormat} rebuilds a different tx for proposal ${this.id}`);
+        }
+      }
       ChainService.addSignaturesToBitcoreTx(
         this.chain,
-        tx,
+        clientTx,
         this.inputs,
         this.inputPaths,
         signatures,
@@ -540,10 +552,10 @@ export class TxProposal<NumberType = number> implements ITxProposal<NumberType>
       this.addAction(copayerId, 'accept', null, signatures, xpub);
 
       if (this.status == 'accepted') {
-        this.raw = tx.uncheckedSerialize();
-        this.txid = tx.id;
+        this.raw = clientTx.uncheckedSerialize();
+        this.txid = clientTx.id;
         if (this.multiTx) {
-          this.txids = tx?.txids && tx.txids() || [tx.id];
+          this.txids = clientTx?.txids && clientTx.txids() || [clientTx.id];
         }
       }
 
@@ -604,19 +616,35 @@ export class TxProposal<NumberType = number> implements ITxProposal<NumberType>
   static formatNumbers<T>(txp: TxProposal<T>, numberFormat: 'string'): TxProposal<string>;
   static formatNumbers<T>(txp: TxProposal<T>, numberFormat: 'hex'): TxProposal<string>;
   static formatNumbers<T>(txp: TxProposal<T>, numberFormat: 'bigint'): TxProposal<bigint>;
-  static formatNumbers<T>(txp: TxProposal<T>, numberFormat: 'number'): TxProposal<number>;
+  static formatNumbers<T>(txp: TxProposal<T>, numberFormat: 'number'): TxProposal<number | T>;
   static formatNumbers<T>(txp: ITxProposal<T>, numberFormat: 'string'): ITxProposal<string>;
   static formatNumbers<T>(txp: ITxProposal<T>, numberFormat: 'hex'): ITxProposal<string>;
   static formatNumbers<T>(txp: ITxProposal<T>, numberFormat: 'bigint'): ITxProposal<bigint>;
-  static formatNumbers<T>(txp: ITxProposal<T>, numberFormat: 'number'): ITxProposal<number>;
+  static formatNumbers<T>(txp: ITxProposal<T>, numberFormat: 'number'): ITxProposal<number | T>;
   static formatNumbers<T>(txp: TxProposal<T> | ITxProposal<T>, numberFormat: NumberFormat = 'number') {
     let convertFn;
     switch (numberFormat) {
       case 'number':
-        convertFn = parseInt;
+        // Clients rebuild the raw tx from these values to check the proposal signature, so a value
+        // parseInt cannot round-trip must be returned as stored rather than rounded.
+        convertFn = (n) => {
+          const parsed = parseInt(n);
+          const value = typeof n === 'string' ? n.trim() : n;
+          try {
+            return BigInt(parsed) === BigInt(value) ? parsed : n;
+          } catch {
+            return Number.isSafeInteger(parsed) && !/e/i.test(String(value)) ? parsed : n;
+          }
+        };
         break;
       case 'string':
-        convertFn = (n) => typeof n === 'string' && n.startsWith('0x') ? BigInt(n).toString() : n.toString();
+        // toString() renders large integers in exponential notation, which no tx builder can parse.
+        convertFn = (n) => {
+          if (typeof n === 'string') return n.startsWith('0x') ? BigInt(n).toString() : n;
+          return typeof n === 'number' && Number.isInteger(n)
+            ? n.toLocaleString('fullwide', { useGrouping: false, maximumFractionDigits: 0 })
+            : n.toString();
+        };
         break;
       case 'hex':
         convertFn = (n) => CWCUtils.toHex(n);

package/src/lib/routes/context.ts

@@ -143,8 +143,10 @@ export function createRouteHelpers(returnError: Types.ReturnErrorFn): RouteHelpe
   const checkNumberFormat = (numberFormat: string | undefined, res: express.Response) => {
     const validFormats = ['hex', 'string', 'number']; // bigint cannot be serialized to JSON, so it's not supported in the API response
     if (numberFormat && !validFormats.includes(numberFormat)) {
-      return returnError(Errors.INVALID_NUMBER_FORMAT, res, null);
+      returnError(Errors.INVALID_NUMBER_FORMAT, res, null);
+      return false;
     }
+    return true;
   };
 
   return {

package/src/lib/routes/helpers/error.ts

@@ -18,7 +18,7 @@ export class ApiErrorHelper {
     }
     if (err instanceof ClientError) {
       const status = err.code == 'NOT_AUTHORIZED' ? 401 : 400;
-      if (!this.disableLogs) logger.info('Client Err: ' + status + ' ' + req.url + ' ' + JSON.stringify(err));
+      if (!this.disableLogs) logger.info('Client Err: ' + status + ' ' + req?.url + ' ' + JSON.stringify(err));
 
       const clientError: { code: string; message: string; messageData?: object } = {
         code: err.code,
@@ -39,7 +39,7 @@ export class ApiErrorHelper {
 
       const m = message || err.toString();
 
-      if (!this.disableLogs) logger.error(req.url + ' :' + code + ':' + m);
+      if (!this.disableLogs) logger.error(req?.url + ' :' + code + ':' + m);
 
       res
         .status(code || 500)

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/routes/transactions.ts

@@ -22,7 +22,7 @@ export function registerTransactionRoutes(router: express.Router, context: Route
 
   router.get('/v2/txproposals/', (req, res) => {
     getServerWithAuth(req, res, server => {
-      checkNumberFormat(req.query.numberFormat, res);
+      if (!checkNumberFormat(req.query.numberFormat, res)) return;
 
       const opts = {
         numberFormat: req.query.numberFormat,
@@ -52,7 +52,7 @@ export function registerTransactionRoutes(router: express.Router, context: Route
 
   router.post('/v3/txproposals/', (req, res) => {
     getServerWithAuth(req, res, server => {
-      checkNumberFormat(req.query.numberFormat, res);
+      if (!checkNumberFormat(req.query.numberFormat, res)) return;
       req.body.txpVersion = 3;
       req.body.numberFormat = req.query.numberFormat;
       server.createTx(req.body, (err, txp) => {
@@ -76,7 +76,7 @@ export function registerTransactionRoutes(router: express.Router, context: Route
 
   router.post('/v2/txproposals/:id/signatures/', (req, res) => {
     getServerWithAuth(req, res, server => {
-      checkNumberFormat(req.query.numberFormat, res);
+      if (!checkNumberFormat(req.query.numberFormat, res)) return;
       req.body.txProposalId = req.params['id'];
       req.body.maxTxpVersion = 3;
       req.body.supportBchSchnorr = true;
@@ -91,7 +91,7 @@ export function registerTransactionRoutes(router: express.Router, context: Route
 
   router.post('/v1/txproposals/:id/prepare/', (req, res) => {
     getServerWithAuth(req, res, server => {
-      checkNumberFormat(req.query.numberFormat, res);
+      if (!checkNumberFormat(req.query.numberFormat, res)) return;
       req.body.txProposalId = req.params['id'];
       req.body.numberFormat = req.query.numberFormat;
       server.prepareTx(req.body, (err, txp) => {
@@ -116,7 +116,7 @@ export function registerTransactionRoutes(router: express.Router, context: Route
 
   router.post('/v2/txproposals/:id/publish/', (req, res) => {
     getServerWithAuth(req, res, server => {
-      checkNumberFormat(req.query.numberFormat, res);
+      if (!checkNumberFormat(req.query.numberFormat, res)) return;
       req.body.txProposalId = req.params['id'];
       req.body.numberFormat = req.query.numberFormat;
       server.publishTx(req.body, (err, txp) => {

package/src/lib/routes/wallets.ts

@@ -97,7 +97,7 @@ export function registerWalletRoutes(router: express.Router, context: RouteConte
 
   router.get('/v3/wallets/', (req, res) => {
     getServerWithAuth(req, res, server => {
-      checkNumberFormat(req.query.numberFormat, res);
+      if (!checkNumberFormat(req.query.numberFormat, res)) return;
       const opts = {
         includeExtendedInfo: false,
         twoStep: false,
@@ -125,7 +125,7 @@ export function registerWalletRoutes(router: express.Router, context: RouteConte
     const silentFailure = req.query.silentFailure == '1';
     const includeServerMessages = req.query.serverMessageArray == '1';
     const numberFormat = req.query.numberFormat;
-    checkNumberFormat(numberFormat, res);
+    if (!checkNumberFormat(numberFormat, res)) return;
 
     const buildOpts = (request, copayerId) => {
       const getParam = (param, returnArray = false) => {