@bitpay-labs/bitcore-wallet-service 11.8.2 → 11.10.0

package/src/lib/model/txproposal.ts

@@ -1,11 +1,13 @@
+import { Utils as CWCUtils } from '@bitpay-labs/crypto-wallet-core';
 import _ from 'lodash';
 import { singleton } from 'preconditions';
 import Uuid from 'uuid';
 import { ChainService } from '../chain/index';
 import { Common } from '../common';
 import logger from '../logger';
-import { IAddress } from './address';
-import { TxProposalLegacy } from './txproposal_legacy';
+import { type IAddress } from './address';
+import { type ITxNote, TxNote } from './txnote';
+import { type ITxProposalLegacy, TxProposalLegacy } from './txproposal_legacy';
 import { TxProposalAction } from './txproposalaction';
 
 const $ = singleton();
@@ -13,9 +15,9 @@ const { Constants, Defaults, Utils } = Common;
 
 type TxProposalStatus = 'temporary' | 'pending' | 'accepted' | 'rejected' | 'broadcasted';
 
-export interface ITxProposal {
+export interface ITxProposal<NumberType = number> {
+  version: number;
   type?: string;
-  creatorName: string;
   createdOn: number;
   txid: string;
   txids?: Array<string>;
@@ -28,19 +30,20 @@ export interface ITxProposal {
   message: string;
   payProUrl?: string;
   from: string;
-  changeAddress?: IAddress;
-  escrowAddress?: IAddress;
+  sendMax?: boolean;
+  changeAddress?: Partial<IAddress>;
+  escrowAddress?: Partial<IAddress>;
   inputs: any[];
   outputs: Array<{
-    amount: number;
-    address: string;
+    amount: NumberType;
+    address?: string;
     toAddress?: string;
     sourceAddress?: string;
     message?: string;
     data?: string;
-    gasLimit?: number;
+    gasLimit?: NumberType;
     script?: string;
-    satoshis?: number;
+    satoshis?: NumberType;
     tag?: number;
   }>;
   outputOrder: number[];
@@ -51,13 +54,12 @@ export interface ITxProposal {
   status: TxProposalStatus;
   actions: any[];
   feeLevel: string;
-  feePerKb: number;
+  feePerKb: NumberType;
   excludeUnconfirmedUtxos: boolean;
   addressType: string;
   customData: any;
-  amount: string;
-  fee: number;
-  version: number;
+  amount: NumberType;
+  fee: NumberType;
   broadcastedOn: number;
   inputPaths: string | any[];
   proposalSignature: string;
@@ -65,41 +67,51 @@ export interface ITxProposal {
   proposalSignaturePubKeySig: string;
   signingMethod: string;
   lowFees?: boolean;
-  nonce?: number | string;
+  raw?: Array<string> | string;
+  nonce?: NumberType | string;
   deferNonce?: boolean;
-  gasPrice?: number;
-  maxGasFee?: number;
-  priorityGasFee?: number;
+  gasPrice?: NumberType;
+  maxGasFee?: NumberType;
+  priorityGasFee?: NumberType;
   txType?: number | string;
-  gasLimit?: number; // Backward compatibility for BWC <= 8.9.0
+  gasLimit?: NumberType; // Backward compatibility for BWC <= 8.9.0
   data?: string; // Backward compatibility for BWC <= 8.9.0
   tokenAddress?: string;
   multisigContractAddress?: string;
+  multisigTxId?: string;
   destinationTag?: string;
   invoiceID?: string;
-  lockUntilBlockHeight?: number;
-  instantAcceptanceEscrow?: number;
+  lockUntilBlockHeight?: NumberType;
+  instantAcceptanceEscrow?: NumberType;
   isTokenSwap?: boolean;
+  multiSendContractAddress?: string;
   enableRBF?: boolean;
   replaceTxByFee?: boolean;
   multiTx?: boolean; // proposal contains multiple transactions
-  space?: number;
+  space?: NumberType;
   nonceAddress?: string;
   blockHash?: string;
-  blockHeight?: number;
+  blockHeight?: NumberType;
   category?: string;
-  priorityFee?: number;
-  computeUnits?: number;
+  priorityFee?: NumberType;
+  computeUnits?: NumberType;
   memo?: string;
   fromAta?: string;
   decimals?: number;
   refreshOnPublish?: boolean;
   prePublishRaw?: string;
+  
+  // Non-persistent fields - populated on fetch
+  creatorName: string;
+  derivationStrategy?: string;
+  note?: ITxNote;
 }
 
-export class TxProposal implements ITxProposal {
+export type NumberFormat = 'hex' | 'number' | 'string' | 'bigint';
+
+export class TxProposal<NumberType = number> implements ITxProposal<NumberType> {
+  version: number;
   type?: string;
-  creatorName: string;
   createdOn: number;
   id: string;
   txid: string;
@@ -112,19 +124,20 @@ export class TxProposal implements ITxProposal {
   message: string;
   payProUrl?: string;
   from: string;
-  changeAddress?: IAddress;
-  escrowAddress?: IAddress;
+  sendMax?: boolean;
+  changeAddress?: Partial<IAddress>;
+  escrowAddress?: Partial<IAddress>;
   inputs: any[];
   outputs: Array<{
-    amount: number;
-    address: string;
+    amount: NumberType;
+    address?: string;
     toAddress?: string;
     sourceAddress?: string;
     message?: string;
     data?: string;
-    gasLimit?: number;
+    gasLimit?: NumberType;
     script?: string;
-    satoshis?: number;
+    satoshis?: NumberType;
     tag?: number;
   }>;
   outputOrder: number[];
@@ -135,13 +148,12 @@ export class TxProposal implements ITxProposal {
   status: TxProposalStatus;
   actions: any[] = [];
   feeLevel: string;
-  feePerKb: number;
+  feePerKb: NumberType;
   excludeUnconfirmedUtxos: boolean;
   addressType: string;
   customData: any;
-  amount: string;
-  fee: number;
-  version: number;
+  amount: NumberType;
+  fee: NumberType;
   broadcastedOn: number;
   inputPaths: string | any[];
   proposalSignature: string;
@@ -150,38 +162,43 @@ export class TxProposal implements ITxProposal {
   signingMethod: string;
   lowFees?: boolean;
   raw?: Array<string> | string;
-  nonce?: number | string;
+  nonce?: NumberType;
   deferNonce?: boolean;
-  gasPrice?: number;
-  maxGasFee?: number;
-  priorityGasFee?: number;
+  gasPrice?: NumberType;
+  maxGasFee?: NumberType;
+  priorityGasFee?: NumberType;
   txType?: number | string;
-  gasLimit?: number; // Backward compatibility for BWC <= 8.9.0
+  gasLimit?: NumberType; // Backward compatibility for BWC <= 8.9.0
   data?: string; // Backward compatibility for BWC <= 8.9.0
   tokenAddress?: string;
   multisigContractAddress?: string;
   multisigTxId?: string;
   destinationTag?: string;
   invoiceID?: string;
-  lockUntilBlockHeight?: number;
-  instantAcceptanceEscrow?: number;
+  lockUntilBlockHeight?: NumberType;
+  instantAcceptanceEscrow?: NumberType;
   isTokenSwap?: boolean;
   multiSendContractAddress?: string;
   enableRBF?: boolean;
   replaceTxByFee?: boolean;
   multiTx?: boolean;
-  space?: number;
+  space?: NumberType;
   nonceAddress?: string;
   blockHash?: string;
-  blockHeight?: number;
+  blockHeight?: NumberType;
   category?: string;
-  priorityFee?: number;
-  computeUnits?: number;
+  priorityFee?: NumberType;
+  computeUnits?: NumberType;
   memo?: string;
   fromAta?: string;
   decimals?: number;
   refreshOnPublish?: boolean;
   prePublishRaw?: string;
+  
+  // Non-persistent fields - populated on fetch
+  creatorName: string;
+  derivationStrategy?: string;
+  note?: TxNote;
 
   static create(opts) {
     opts = opts || {};
@@ -211,6 +228,7 @@ export class TxProposal implements ITxProposal {
     x.signingMethod = opts.signingMethod;
     x.message = opts.message;
     x.payProUrl = opts.payProUrl;
+    x.sendMax = opts.sendMax;
     x.changeAddress = opts.changeAddress;
     x.escrowAddress = opts.escrowAddress;
     x.instantAcceptanceEscrow = opts.instantAcceptanceEscrow;
@@ -305,6 +323,8 @@ export class TxProposal implements ITxProposal {
     return x;
   }
 
+  static fromObj(obj: Partial<ITxProposal>): TxProposal;
+  static fromObj(obj: Partial<ITxProposalLegacy>): TxProposalLegacy;
   static fromObj(obj) {
     if (!(obj.version >= 3)) {
       return TxProposalLegacy.fromObj(obj);
@@ -317,6 +337,7 @@ export class TxProposal implements ITxProposal {
     x.id = obj.id;
     x.walletId = obj.walletId;
     x.creatorId = obj.creatorId;
+    x.creatorName = obj.creatorName;
     x.coin = obj.coin || Defaults.COIN;
     x.chain = obj.chain?.toLowerCase() || Utils.getChain(x.coin); // getChain -> backwards compatibility
     x.network = obj.network;
@@ -324,6 +345,8 @@ export class TxProposal implements ITxProposal {
     x.amount = obj.amount;
     x.message = obj.message;
     x.payProUrl = obj.payProUrl;
+    x.derivationStrategy = obj.derivationStrategy;
+    x.sendMax = obj.sendMax;
     x.changeAddress = obj.changeAddress;
     x.escrowAddress = obj.escrowAddress;
     x.instantAcceptanceEscrow = obj.instantAcceptanceEscrow;
@@ -337,9 +360,7 @@ export class TxProposal implements ITxProposal {
     x.txids = obj.txids;
     x.broadcastedOn = obj.broadcastedOn;
     x.inputPaths = obj.inputPaths;
-    x.actions = _.map(obj.actions, action => {
-      return TxProposalAction.fromObj(action);
-    });
+    x.actions = (obj.actions || []).map(action => TxProposalAction.fromObj(action));
     x.outputOrder = obj.outputOrder;
     x.fee = obj.fee;
     x.feeLevel = obj.feeLevel;
@@ -410,7 +431,7 @@ export class TxProposal implements ITxProposal {
 
   setInputs(inputs) {
     this.inputs = inputs || [];
-    this.inputPaths = _.map(inputs, 'path') || [];
+    this.inputPaths = this.inputs.map(input => input.path);
   }
 
   _updateStatus() {
@@ -440,8 +461,10 @@ export class TxProposal implements ITxProposal {
     return signatures;
   }
 
-  getRawTx() {
-    const t = ChainService.getBitcoreTx(this);
+  getRawTx(numberFormat?: NumberFormat) {
+    // Casting numberFormat to '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 t = ChainService.getBitcoreTx(txp);
     return t.uncheckedSerialize();
   }
 
@@ -451,7 +474,7 @@ export class TxProposal implements ITxProposal {
    * @return {Number} total amount of all outputs excluding change output
    */
   getTotalAmount() {
-    return Number((this.outputs || []).reduce((total, o) => total += BigInt(o.amount), 0n));
+    return Number(((this as TxProposal<number>).outputs || []).reduce((total, o) => total += BigInt(o.amount), 0n));
   }
 
   /**
@@ -460,7 +483,7 @@ export class TxProposal implements ITxProposal {
    * @return {String[]} copayerIds that performed actions in this proposal (accept / reject)
    */
   getActors() {
-    return _.map(this.actions, 'copayerId');
+    return (this.actions || []).map(a => a.copayerId);
   }
 
   /**
@@ -469,12 +492,9 @@ export class TxProposal implements ITxProposal {
    * @return {String[]} copayerIds that approved the tx proposal (accept)
    */
   getApprovers() {
-    return _.map(
-      _.filter(this.actions, a => {
-        return a.type == 'accept';
-      }),
-      'copayerId'
-    );
+    return (this.actions || [])
+      .filter(a => a.type == 'accept')
+      .map(a => a.copayerId);
   }
 
   /**
@@ -484,9 +504,7 @@ export class TxProposal implements ITxProposal {
    * @return {Object} type / createdOn
    */
   getActionBy(copayerId) {
-    return _.find(this.actions, {
-      copayerId
-    });
+    return (this.actions || []).find(a => a.copayerId == copayerId);
   }
 
   addAction(copayerId, type, comment, signatures?, xpub?) {
@@ -501,10 +519,11 @@ export class TxProposal implements ITxProposal {
     this._updateStatus();
   }
 
-  sign(copayerId, signatures, xpub) {
+  sign(copayerId, signatures, xpub, numberFormat?: NumberFormat) {
     try {
-      // Tests signatures are OK
-      const tx = ChainService.getBitcoreTx(this);
+      // 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);
       ChainService.addSignaturesToBitcoreTx(
         this.chain,
         tx,
@@ -570,4 +589,70 @@ export class TxProposal implements ITxProposal {
     this.status = 'broadcasted';
     this.broadcastedOn = Math.floor(Date.now() / 1000);
   }
+
+  
+  /**
+   * Replaces tx-building number values with the specified number format.
+   * This is to ensure consistency across BWC and BWS when handling large numbers, especially for chains like ETH and SOL.
+   * @param {TxProposal|ITxProposal} txp Transaction Proposal
+   * @param {'number'|'string'|'bigint'|'hex'} numberFormat The desired number format for the tx-building values. Can be 'number', 'string', 'bigint', or 'hex'.
+   */
+  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: 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: TxProposal<T> | ITxProposal<T>, numberFormat: NumberFormat = 'number') {
+    let convertFn;
+    switch (numberFormat) {
+      case 'number':
+        convertFn = parseInt;
+        break;
+      case 'string':
+        convertFn = (n) => typeof n === 'string' && n.startsWith('0x') ? BigInt(n).toString() : n.toString();
+        break;
+      case 'hex':
+        convertFn = (n) => CWCUtils.toHex(n);
+        break;
+      case 'bigint':
+        convertFn = (n) => BigInt(n);
+        break;
+      default:
+        logger.warn(`Invalid numberFormat: ${numberFormat}, no conversion will be applied to tx proposal ${txp.id}`);
+        return txp;
+    }
+
+    const primitiveTypes = new Set(['number', 'string', 'bigint']);
+    const convert = (key, value) => {
+      if ((numberFormat === 'hex' || typeof value !== numberFormat) && primitiveTypes.has(typeof value)) {
+        try {
+          value = convertFn(value);
+        } catch (e) {
+          logger.warn(`Failed to convert ${txp.id} > ${key} with value ${value} to ${numberFormat}: ${e.message}`);
+        }
+      }
+      return value;
+    };
+
+    const _txp = txp instanceof TxProposal ? TxProposal.fromObj(txp.toObject()) : TxProposal.fromObj(txp as ITxProposal<number>).toObject();
+
+    const topKeys = ['amount', 'feePerKb', 'fee', 'nonce', 'gasPrice', 'maxGasFee', 'priorityGasFee', 'gasLimit', 'lockUntilBlockHeight', 'instantAcceptanceEscrow', 'space', 'blockHeight', 'computeUnits', 'decimals'];
+    for (const key of topKeys) {
+      const value = _txp[key];
+      _txp[key] = convert(key, value);
+    }
+
+    const outputKeys = ['amount', 'gasLimit', 'satoshis'];
+    for (let i = 0; i < _txp.outputs.length; i++) {
+      for (const key of outputKeys) {
+        const value = _txp.outputs[i][key];
+        _txp.outputs[i][key] = convert(`output.${i}.${key}`, value);
+      }
+    }
+
+    return _txp;
+  }
 }

package/src/lib/model/txproposal_legacy.ts

@@ -15,7 +15,7 @@ function throwUnsupportedError() {
   throw new Error(msg);
 }
 
-export interface ITxProposal {
+export interface ITxProposalLegacy {
   version: string;
   type: string;
   createdOn: number;
@@ -35,7 +35,7 @@ export interface ITxProposal {
   walletN: number;
   status: string;
   txid: string;
-  broadcastedOn: string;
+  broadcastedOn: number;
   inputPaths: string;
   actions: any[];
   outputOrder: number;
@@ -49,8 +49,9 @@ export interface ITxProposal {
   addressType: string;
   derivationStrategy: string;
   customData: any;
-}
-export class TxProposalLegacy {
+};
+
+export class TxProposalLegacy implements ITxProposalLegacy {
   version: string;
   type: string;
   createdOn: number;

package/src/lib/model/txproposalaction.ts

@@ -6,6 +6,9 @@ export interface ITxProposalAction {
   signatures: string[];
   xpub: string;
   comment: string;
+
+  // Non-persistent fields
+  copayerName?: string;
 }
 export class TxProposalAction {
   version: string;
@@ -16,6 +19,9 @@ export class TxProposalAction {
   xpub: string;
   comment: string;
 
+  // Non-persistent fields
+  copayerName?: string;
+
   static create(opts) {
     opts = opts || {};
 
@@ -43,6 +49,9 @@ export class TxProposalAction {
     x.xpub = obj.xpub;
     x.comment = obj.comment;
 
+    // copayerName is not stored in the actions collection, but it is returned by the server on fetchTxProposal, so we need to set it here.
+    x.copayerName = obj.copayerName; 
+
     return x;
   }
 }

package/src/lib/routes/blockchain.ts

@@ -1,5 +1,4 @@
 import express from 'express';
-import * as _ from 'lodash';
 import type * as Types from '../../types/expressapp';
 import type { WalletService } from '../server';
 
@@ -74,10 +73,10 @@ export function registerBlockchainRoutes(router: express.Router, context: RouteC
         if (req.query.network) opts.network = req.query.network as string;
         server.getFeeLevels(opts, resolve);
       }).then((feeLevels: any[]) => {
-        _.each(feeLevels, feeLevel => {
+        for (const feeLevel of feeLevels) {
           feeLevel.feePerKB = feeLevel.feePerKb;
           delete feeLevel.feePerKb;
-        });
+        }
         return feeLevels;
       })
     );

package/src/lib/routes/context.ts

@@ -10,6 +10,7 @@ interface RouteHelpers {
   getServerWithMultiAuth: Types.GetServerWithMultiAuthFn;
   logDeprecated: Types.LogDeprecatedFn;
   setPublicCache: (res: express.Response, seconds: number) => void;
+  checkNumberFormat: Types.CheckNumberFormatFn;
 }
 
 export function createRouteHelpers(returnError: Types.ReturnErrorFn): RouteHelpers {
@@ -139,11 +140,19 @@ export function createRouteHelpers(returnError: Types.ReturnErrorFn): RouteHelpe
     res.setHeader('Cache-Control', `public, max-age=${seconds}, stale-if-error=${10 * seconds}`);
   };
 
+  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);
+    }
+  };
+
   return {
     getServer,
     getServerWithAuth,
     getServerWithMultiAuth,
     logDeprecated,
-    setPublicCache
+    setPublicCache,
+    checkNumberFormat
   };
 }

package/src/lib/routes/maintenance.ts

@@ -1,5 +1,4 @@
 import express from 'express';
-import * as _ from 'lodash';
 import { WalletService } from '../server';
 import { Stats } from '../stats';
 import type * as Types from '../../types/expressapp';
@@ -84,8 +83,12 @@ export function registerMaintenanceRoutes(router: express.Router, context: Route
   router.get('/v1/txnotes/', (req, res) => {
     getServerWithAuth(req, res, server => {
       const opts: { minTs?: number } = {};
-      if (req.query.minTs && _.isNumber(+req.query.minTs)) {
-        opts.minTs = +req.query.minTs;
+      const rawMinTs = req.query.minTs;
+      if (typeof rawMinTs === 'string' && rawMinTs.trim() !== '') {
+        const minTs = Number(rawMinTs);
+        if (Number.isFinite(minTs)) {
+          opts.minTs = minTs;
+        }
       }
       server.getTxNotes(opts, (err, notes) => {
         if (err) return returnError(err, res, req);

package/src/lib/routes/services.ts

@@ -281,6 +281,18 @@ export function registerServiceRoutes(router: express.Router, context: RouteCont
     });
   });
 
+  router.post('/v1/service/moonpay/createSession', (req, res) => {
+    respondWithAuthServer(req, res, context, server => {
+      return server.externalServices.moonpay.moonpayCreateSession(req);
+    });
+  });
+
+  router.post('/v1/service/moonpay/revokeActiveSession', (req, res) => {
+    respondWithAuthServer(req, res, context, server => {
+      return server.externalServices.moonpay.moonpayRevokeActiveSession(req);
+    });
+  });
+
   router.post('/v1/service/ramp/quote', (req, res) => {
     respondWithAuthServer(req, res, context, server => {
       return server.externalServices.ramp.rampGetQuote(req);

package/src/lib/routes/transactions.ts

@@ -5,10 +5,11 @@ import type * as Types from '../../types/expressapp';
 interface RouteContext {
   getServerWithAuth: Types.GetServerWithAuthFn;
   returnError: Types.ReturnErrorFn;
+  checkNumberFormat: Types.CheckNumberFormatFn;
 }
 
 export function registerTransactionRoutes(router: express.Router, context: RouteContext) {
-  const { getServerWithAuth, returnError } = context;
+  const { getServerWithAuth, returnError, checkNumberFormat } = context;
 
   router.get('/v1/txproposals/', (req, res) => {
     getServerWithAuth(req, res, server => {
@@ -21,7 +22,13 @@ export function registerTransactionRoutes(router: express.Router, context: Route
 
   router.get('/v2/txproposals/', (req, res) => {
     getServerWithAuth(req, res, server => {
-      server.getPendingTxs({}, (err, pendings) => {
+      checkNumberFormat(req.query.numberFormat, res);
+
+      const opts = {
+        numberFormat: req.query.numberFormat,
+      };
+
+      server.getPendingTxs(opts, (err, pendings) => {
         if (err) return returnError(err, res, req);
         res.json(pendings);
       });
@@ -45,7 +52,9 @@ export function registerTransactionRoutes(router: express.Router, context: Route
 
   router.post('/v3/txproposals/', (req, res) => {
     getServerWithAuth(req, res, server => {
+      checkNumberFormat(req.query.numberFormat, res);
       req.body.txpVersion = 3;
+      req.body.numberFormat = req.query.numberFormat;
       server.createTx(req.body, (err, txp) => {
         if (err) return returnError(err, res, req);
         res.json(txp);
@@ -67,9 +76,11 @@ 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);
       req.body.txProposalId = req.params['id'];
       req.body.maxTxpVersion = 3;
       req.body.supportBchSchnorr = true;
+      req.body.numberFormat = req.query.numberFormat;
       server.signTx(req.body, (err, txp) => {
         if (err) return returnError(err, res, req);
         res.json(txp);
@@ -80,7 +91,9 @@ 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);
       req.body.txProposalId = req.params['id'];
+      req.body.numberFormat = req.query.numberFormat;
       server.prepareTx(req.body, (err, txp) => {
         if (err) return returnError(err, res, req);
         res.json(txp);
@@ -103,7 +116,9 @@ 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);
       req.body.txProposalId = req.params['id'];
+      req.body.numberFormat = req.query.numberFormat;
       server.publishTx(req.body, (err, txp) => {
         if (err) return returnError(err, res, req);
         res.json(txp);

package/src/lib/routes/walletdata.ts

@@ -1,5 +1,4 @@
 import express from 'express';
-import * as _ from 'lodash';
 import { Common } from '../common';
 import type * as Types from '../../types/expressapp';
 import type { GetAddressesOpts } from '../../types/server';
@@ -133,7 +132,7 @@ export function registerWalletDataRoutes(router: express.Router, context: RouteC
   router.get('/v1/utxos/', (req, res) => {
     const opts: { addresses?: string[] } = {};
     const addresses = req.query.addresses;
-    if (addresses && _.isString(addresses)) {
+    if (addresses && typeof addresses === 'string') {
       opts.addresses = (req.query.addresses as string).split(',');
     }