@bitpay-labs/bitcore-wallet-service 11.10.12 → 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.12",
+  "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.12",
-    "@bitpay-labs/crypto-wallet-core": "^11.10.12",
+    "@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": "d1992fd744501a1b69b8cb97f07b0896df7223fd"
+  "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/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;
       }
@@ -401,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();
@@ -568,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

@@ -468,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/sol/index.ts

@@ -4,6 +4,7 @@ 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';
@@ -95,11 +96,27 @@ 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);
   }
@@ -233,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

@@ -223,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/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/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) => {

package/src/lib/server.ts

@@ -3032,8 +3032,8 @@ export class WalletService implements IWalletService {
                     spenderAddress: txp.multiSendContractAddress
                   }, (err, allowance) => {
                     if (err) { return next(err); }
-                    if (BigInt(allowance) < BigInt(txp.getTotalAmount())) {
-                      return next(new Error(`Insufficient token allowance. Allowed: ${BigInt(allowance)}, Want: ${BigInt(txp.getTotalAmount())}`));
+                    if (BigInt(allowance) < txp.getTotalAmountBigInt()) {
+                      return next(new Error(`Insufficient token allowance. Allowed: ${BigInt(allowance)}, Want: ${txp.getTotalAmountBigInt()}`));
                     }
                     return next();
                   });
@@ -3108,6 +3108,9 @@ export class WalletService implements IWalletService {
           if (err) return cb(err);
           if (!txp) return cb(Errors.TX_NOT_FOUND);
           if (!txp.isTemporary() && !txp.hasMutableTxData()) return cb(null, txp);
+          // Broadcasted proposals should not be published again. Only temporary or pending proposals can be published.
+          if (txp.isBroadcasted()) return cb(Errors.TX_ALREADY_BROADCASTED);
+          if (!txp.isTemporary() && txp.status !== 'pending') return cb(Errors.TX_NOT_PENDING);
 
           const copayer = wallet.getCopayer(this.copayerId);
 

package/src/types/expressapp.d.ts

@@ -13,4 +13,4 @@ export type ServerCallback = (server: WalletService, err?: Error) => void;
 export type GetServerWithAuthFn = (req: express.Request, res: express.Response, opts?: ServerOpts | ServerCallback, cb?: ServerCallback) => Promise<WalletService | void>;
 export type GetServerWithMultiAuthFn = (req: express.Request, res: express.Response, opts?: ServerOpts) => Array<Promise<WalletService | void>>;
 export type CreateWalletLimiterFn = (req: express.Request, res: express.Response, next: express.NextFunction) => void;
-export type CheckNumberFormatFn = (numberFormat: string | undefined, res: express.Response) => void;
+export type CheckNumberFormatFn = (numberFormat: string | undefined, res: express.Response) => boolean;

package/test/chain/btc.test.ts

@@ -15,6 +15,26 @@ const { Constants } = Common;
 const segWitToAddress = 'BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4'; // 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq';
 
 describe('Chain BTC', function() { 
+  describe('#getEstimatedFee', function() {
+    const btcChain = ChainService.get('btc') as BtcChain;
+    const readyTxp = (satoshis, amounts) => ({
+      inputs: satoshis.map(s => ({ satoshis: s })),
+      outputs: amounts.map(amount => ({ amount })),
+      changeAddress: null,
+      feePerKb: 10000
+    });
+    const feeOf = txp => btcChain.getEstimatedFee(txp as any, { conservativeEstimation: false });
+
+    it('should derive the same fee from string and number amounts', function() {
+      const fromNumbers = feeOf(readyTxp([2000, 1000], [1000, 1000]));
+
+      fromNumbers.should.equal(1000);
+      feeOf(readyTxp([2000, 1000], ['1000', '1000'])).should.equal(fromNumbers);
+      feeOf(readyTxp(['2000', '1000'], [1000, 1000])).should.equal(fromNumbers);
+      feeOf(readyTxp(['2000', '1000'], ['1000', '1000'])).should.equal(fromNumbers);
+    });
+  });
+
   describe('#getBitcoreTx', function() {
     it('should create a valid bitcore TX', function() {
       const txp = TxProposal.fromObj(aTXP()) as TxProposal;
@@ -22,6 +42,18 @@ describe('Chain BTC', function() {
       should.exist(t);
     });
 
+    it('should build the same tx from string and number amounts without mutating the proposal', function() {
+      const asStrings: any = aTXP();
+      asStrings.outputs = asStrings.outputs.map(o => ({ ...o, amount: String(o.amount) }));
+      const fromStrings = TxProposal.fromObj(asStrings) as TxProposal;
+      const fromNumbers = TxProposal.fromObj(aTXP()) as TxProposal;
+
+      const built = ChainService.getBitcoreTx(fromStrings);
+
+      built.uncheckedSerialize().should.equal(ChainService.getBitcoreTx(fromNumbers).uncheckedSerialize());
+      fromStrings.outputs[0].amount.should.equal(String(aTXP().outputs[0].amount));
+    });
+
     it('should order outputs as specified by outputOrder', function() {
       const txp = TxProposal.fromObj(aTXP()) as TxProposal;
 

package/test/chain/eth.test.ts

@@ -2,6 +2,7 @@
 
 import * as chai from 'chai';
 import { ChainService } from '../../src/lib/chain';
+import { TxProposal } from '../../src/lib/model/txproposal';
 
 const should = chai.should();
 
@@ -17,5 +18,47 @@ describe('Chain ETH', function() {
     ChainService.addressFromStorageTransform('eth', 'dfg', x);
     x.address.should.equal('0x01');
   });
+
+  describe('#selectTxInputs', function() {
+    it('should reject a total that a number rounds down to the balance', function(done) {
+      const server = {
+        getBalance: (_opts, cb) => cb(null, { totalAmount: 9007199254740992, availableAmount: 9007199254740992 })
+      };
+      const txp = TxProposal.fromObj({
+        ...aTXP(),
+        outputs: [
+          { ...aTXP().outputs[0], amount: '9007199254740992' },
+          { ...aTXP().outputs[0], amount: '1' }
+        ]
+      } as any);
+
+      ChainService.get('eth').selectTxInputs(server as any, txp, {} as any, {}, err => {
+        should.exist(err);
+        err.code.should.equal('INSUFFICIENT_FUNDS');
+        done();
+      });
+    });
+  });
 });
 
+const aTXP = function() {
+  return {
+    version: 3,
+    createdOn: 1423146231,
+    id: '75c34f49-1ed6-255f-e9fd-0c71ae75ed1e',
+    walletId: '1',
+    creatorId: '1',
+    coin: 'eth',
+    chain: 'eth',
+    network: 'livenet',
+    from: '0x9858EfFD232B4033E47d90003D41EC34EcaEda94',
+    nonce: 5,
+    gasPrice: 25000000000,
+    gasLimit: 60000,
+    fee: 1500000000000000,
+    outputs: [{ toAddress: '0xc27eD3DF0DE776246cdAD5a052A9982473FceaB8', amount: 1000, gasLimit: 60000 }],
+    status: 'pending' as const,
+    actions: []
+  };
+};
+

package/test/chain/sol.test.ts

@@ -1,8 +1,11 @@
 'use strict';
 
 import * as chai from 'chai';
+import sinon from 'sinon';
 import { ChainService } from '../../src/lib/chain';
 import { Defaults } from '../../src/lib/common/defaults';
+import { ClientError } from '../../src/lib/errors/clienterror';
+import { TxProposal } from '../../src/lib/model/txproposal';
 
 const should = chai.should();
 
@@ -45,4 +48,182 @@ describe('Chain SOL', function() {
       });
     }
   });
+
+  describe('#getFee', function() {
+    const sol = ChainService.get('sol');
+    const getFee = async opts => (await sol.getFee(null, null, opts)).fee;
+    const outputs = n => Array.from({ length: n }, () => ({ toAddress: 'addr', amount: 1 }));
+
+    it('should be the signature fee when no priority fee is set', async function() {
+      (await getFee({ outputs: outputs(1) })).should.equal(5000);
+      (await getFee({ outputs: outputs(1), numSignatures: 2 })).should.equal(10000);
+      (await getFee({ outputs: outputs(1), computeUnits: 300000 })).should.equal(5000);
+    });
+
+    it('should add the priority fee for the given compute unit limit', async function() {
+      // 50,000 micro-lamports/CU * 300,000 CU = 15,000 lamports
+      (await getFee({ outputs: outputs(1), priorityFee: 50000, computeUnits: 300000 })).should.equal(5000 + 15000);
+    });
+
+    it('should round the priority fee up to a whole lamport', async function() {
+      // 1,001 micro-lamports/CU * 1,000 CU = 1,001,000 micro-lamports = 1.001 lamports
+      (await getFee({ outputs: outputs(1), priorityFee: 1001, computeUnits: 1000 })).should.equal(5000 + 2);
+    });
+
+    it('should raise the priority fee to the minimum CWC applies', async function() {
+      // 1 micro-lamport/CU is raised to 1,000; 1,000 * 200,000 CU = 200 lamports
+      (await getFee({ outputs: outputs(1), priorityFee: 1, computeUnits: 200000 })).should.equal(5000 + 200);
+    });
+
+    it('should use the default compute unit limit per instruction without computeUnits', async function() {
+      // 200,000 CU per transfer instruction
+      (await getFee({ outputs: outputs(1), priorityFee: 10000 })).should.equal(5000 + 2000);
+      (await getFee({ outputs: outputs(3), priorityFee: 10000 })).should.equal(5000 + 6000);
+      // the memo is one more instruction
+      (await getFee({ outputs: outputs(1), memo: 'refund', priorityFee: 10000 })).should.equal(5000 + 4000);
+    });
+
+    it('should cap the default compute unit limit at the per-transaction maximum', async function() {
+      // 12 transfers would be 2.4M CU, capped at 1.4M
+      (await getFee({ outputs: outputs(12), priorityFee: 10000 })).should.equal(5000 + 14000);
+    });
+  });
+
+  describe('#selectTxInputs', function() {
+    const sol = ChainService.get('sol');
+    const wallet = { chain: 'sol', network: 'livenet' };
+    const fee = 5000;
+    let checkTxCalled;
+
+    beforeEach(function() {
+      checkTxCalled = false;
+      sinon.stub(sol, 'checkTx').callsFake(() => {
+        checkTxCalled = true;
+        return null;
+      });
+    });
+
+    afterEach(function() {
+      sinon.restore();
+    });
+
+    it('should reject a total that a number rounds down to the balance', function(done) {
+      const balance = 9007199254740992 + Defaults.MIN_SOL_BALANCE;
+      const server = {
+        getBalance: (_opts, cb) => cb(null, { totalAmount: balance, availableAmount: balance })
+      };
+      const txp = TxProposal.fromObj({
+        version: 3,
+        id: '75c34f49-1ed6-255f-e9fd-0c71ae75ed1e',
+        walletId: '1',
+        creatorId: '1',
+        coin: 'sol',
+        chain: 'sol',
+        network: 'livenet',
+        from: '8WyoNvKsmfdG6zrbzNBVN8DETyLra3ond61saU9C52YR',
+        fee: 5000,
+        status: 'pending',
+        actions: [],
+        outputs: [
+          { toAddress: 'F7FknkRckx4yvA3Gexnx1H3nwPxndMxVt58BwAzEQhcY', amount: '9007199254740992' },
+          { toAddress: 'F7FknkRckx4yvA3Gexnx1H3nwPxndMxVt58BwAzEQhcY', amount: '1' }
+        ]
+      } as any);
+
+      ChainService.get('sol').selectTxInputs(server as any, txp, {} as any, {}, err => {
+        should.exist(err);
+        err.code.should.equal('INSUFFICIENT_FUNDS');
+        done();
+      });
+    });
+
+    // Token balance is returned when tokenAddress is passed, native SOL balance otherwise
+    const makeServer = ({ native, token }: { native: any; token?: any }) => ({
+      getBalance: (opts, cb) => cb(null, opts.tokenAddress ? token : native)
+    });
+    const balance = (total, available) => ({ totalAmount: total, availableAmount: available });
+    const makeTxp = amount => ({ fee, getTotalAmount: () => amount, getTotalAmountBigInt: () => BigInt(amount) });
+
+    describe('SPL token', function() {
+      const opts = { tokenAddress: 'mint' };
+
+      it('should fail with INSUFFICIENT_SOL_FEE if the wallet has no SOL for the fee', function(done) {
+        const server = makeServer({ token: balance(1e6, 1e6), native: balance(0, 0) });
+        sol.selectTxInputs(server as any, makeTxp(5e5) as any, wallet as any, opts, err => {
+          should.exist(err);
+          err.should.be.instanceof(ClientError);
+          err.code.should.equal('INSUFFICIENT_SOL_FEE');
+          err.message.should.equal('Your linked SOL wallet does not have enough SOL for fee. RequiredFee: 5000');
+          err.messageData.should.deep.equal({ requiredFee: fee });
+          checkTxCalled.should.equal(false);
+          done();
+        });
+      });
+
+      it('should fail with LOCKED_SOL_FEE if the SOL for the fee is locked', function(done) {
+        const server = makeServer({ token: balance(1e6, 1e6), native: balance(1e7, 1000) });
+        sol.selectTxInputs(server as any, makeTxp(5e5) as any, wallet as any, opts, err => {
+          should.exist(err);
+          err.should.be.instanceof(ClientError);
+          err.code.should.equal('LOCKED_SOL_FEE');
+          err.messageData.should.deep.equal({ requiredFee: fee });
+          checkTxCalled.should.equal(false);
+          done();
+        });
+      });
+
+      it('should still fail with INSUFFICIENT_FUNDS when the token balance is short', function(done) {
+        const server = makeServer({ token: balance(1e5, 1e5), native: balance(1e9, 1e9) });
+        sol.selectTxInputs(server as any, makeTxp(5e5) as any, wallet as any, opts, err => {
+          should.exist(err);
+          err.code.should.equal('INSUFFICIENT_FUNDS');
+          done();
+        });
+      });
+
+      it('should pass when both the token and the SOL fee are covered', function(done) {
+        const server = makeServer({ token: balance(1e6, 1e6), native: balance(1e9, 1e9) });
+        sol.selectTxInputs(server as any, makeTxp(5e5) as any, wallet as any, opts, err => {
+          should.not.exist(err);
+          checkTxCalled.should.equal(true);
+          done();
+        });
+      });
+    });
+
+    describe('native SOL', function() {
+      it('should fail with INSUFFICIENT_FUNDS_FOR_FEE if the amount fits but the fee does not', function(done) {
+        const amount = 1e9;
+        const server = makeServer({ native: balance(amount + Defaults.MIN_SOL_BALANCE, amount) });
+        sol.selectTxInputs(server as any, makeTxp(amount) as any, wallet as any, {}, err => {
+          should.exist(err);
+          err.should.be.instanceof(ClientError);
+          err.code.should.equal('INSUFFICIENT_FUNDS_FOR_FEE');
+          err.message.should.equal('Insufficient funds for fee. RequiredFee: 5000');
+          err.messageData.should.deep.equal({ requiredFee: fee });
+          checkTxCalled.should.equal(false);
+          done();
+        });
+      });
+
+      it('should still fail with INSUFFICIENT_FUNDS when the amount does not fit', function(done) {
+        const server = makeServer({ native: balance(1e9, 1e9) });
+        sol.selectTxInputs(server as any, makeTxp(2e9) as any, wallet as any, {}, err => {
+          should.exist(err);
+          err.code.should.equal('INSUFFICIENT_FUNDS');
+          done();
+        });
+      });
+
+      it('should pass when the amount and fee are covered', function(done) {
+        const amount = 1e9;
+        const server = makeServer({ native: balance(2e9, amount + fee) });
+        sol.selectTxInputs(server as any, makeTxp(amount) as any, wallet as any, {}, err => {
+          should.not.exist(err);
+          checkTxCalled.should.equal(true);
+          done();
+        });
+      });
+    });
+  });
 });

package/test/chain/xrp.test.ts

@@ -4,6 +4,7 @@ import * as chai from 'chai';
 import 'chai/register-should';
 import { ChainService } from '../../src/lib/chain';
 import { ITxProposal, TxProposal } from '../../src/lib/model/txproposal';
+import { Defaults } from '../../src/lib/common/defaults';
 
 const should = chai.should();
 
@@ -61,6 +62,26 @@ describe('Chain XRP', function() {
     });
   });
 
+  describe('#selectTxInputs', function() {
+    const balanceOf = amount => ({
+      getBalance: (_opts, cb) => cb(null, { totalAmount: amount, availableAmount: amount })
+    });
+    const txpOf = amounts => TxProposal.fromObj({
+      ...aTXP(),
+      outputs: amounts.map(amount => ({ ...aTXP().outputs[0], amount }))
+    } as any);
+
+    it('should reject a total that a number rounds down to the balance', function(done) {
+      const balance = 9007199254740992 + Defaults.MIN_XRP_BALANCE;
+
+      ChainService.get('xrp').selectTxInputs(balanceOf(balance) as any, txpOf(['9007199254740992', '1']), {} as any, {}, err => {
+        should.exist(err);
+        err.code.should.equal('INSUFFICIENT_FUNDS');
+        done();
+      });
+    });
+  });
+
   describe('#getBitcoreTx', function() {
     it('should create a valid bitcore TX', function() {
       const txp = TxProposal.fromObj(aTXP()) as TxProposal;

package/test/integration/externalservices/moonpay.test.ts

@@ -723,6 +723,35 @@ describe('Moonpay integration', () => {
       await server.externalServices.moonpay.moonpayRevokeActiveSession(req);
     });
 
+    it('should return the response body if there is one', async () => {
+      const data = await server.externalServices.moonpay.moonpayRevokeActiveSession(req);
+      data.should.equal('data');
+    });
+
+    it('should return success true without leaking the response if there is no body', async () => {
+      const fakeRequest2 = {
+        delete: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 204, body: undefined, headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      const data = await server.externalServices.moonpay.moonpayRevokeActiveSession(req);
+      data.should.deep.equal({ success: true });
+    });
+
+    it('should return success false if there is no body and status is not 2xx', async () => {
+      const fakeRequest2 = {
+        delete: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 404, body: '', headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      const data = await server.externalServices.moonpay.moonpayRevokeActiveSession(req);
+      data.should.deep.equal({ success: false });
+    });
+
     it('should return error if delete returns error', async () => {
       const fakeRequest2 = {
         delete: (_url, _opts, _cb) => { return _cb(new Error('Error'), null); },

package/test/integration/server.test.ts

@@ -3935,6 +3935,45 @@ describe('Wallet service', function() {
     });
   });
 
+  describe('#createTx token allowance', function() {
+    let server: WalletService;
+    let wallet: Model.Wallet;
+
+    beforeEach(async function() {
+      ({ server, wallet } = await helpers.createAndJoinWallet(1, 1, { coin: 'eth' }));
+      await util.promisify(server.createAddress).call(server, {});
+    });
+
+    it('should reject a total that a number rounds down to the allowance', async function() {
+      const be = helpers.getBlockchainExplorer();
+      be.getBalance = sinon.stub().callsArgWith(1, null, { unconfirmed: 0, confirmed: '1' + '0'.repeat(20), balance: '1' + '0'.repeat(20) });
+      be.getTokenAllowance = sinon.stub().callsArgWith(1, null, '9007199254740992');
+
+      const opts = {
+        outputs: [
+          { toAddress: '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A', amount: '9007199254740992' },
+          { toAddress: '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A', amount: '1' }
+        ],
+        from: '0xE299d49C2cf9BfaFb7C6E861E80bb8c83f961622',
+        tokenAddress: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+        multiSendContractAddress: '0x30e5bfa1e83c9c6f0a4c4bd4a1f0e0d7d0c4d3a2',
+        feePerKb: 25000000000,
+        nonce: 5
+      };
+
+      let error;
+      try {
+        await util.promisify(server.createTx).call(server, opts);
+      } catch (e) {
+        error = e;
+      }
+
+      should.exist(error);
+      error.message.should.contain('Insufficient token allowance');
+      error.message.should.contain('Want: 9007199254740993');
+    });
+  });
+
   const testSet = [
     {
       coin: 'btc',
@@ -8390,6 +8429,66 @@ describe('Wallet service', function() {
       txp.nonce.should.equal('5');
     });
 
+    describe('republishing a txp with mutable tx data', function() {
+      let txp, publishOpts;
+
+      beforeEach(async function() {
+        txp = await util.promisify(server.createTx).call(server, {
+          outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+          feePerKb: 123e2,
+          from: fromAddr,
+          deferNonce: true
+        });
+        publishOpts = helpers.getProposalSignatureOpts(txp, TestData.copayers[0].privKey_1H_0);
+        await util.promisify(server.publishTx).call(server, publishOpts);
+      });
+
+      const setStatus = async status => {
+        const stored = await util.promisify(server.storage.fetchTx).call(server.storage, wallet.id, txp.id);
+        stored.status = status;
+        await util.promisify(server.storage.storeTx).call(server.storage, wallet.id, stored);
+      };
+
+      const republishError = async () => {
+        try {
+          await util.promisify(server.publishTx).call(server, publishOpts);
+        } catch (err) {
+          return err;
+        }
+      };
+
+      it('should republish a pending txp', async function() {
+        should.not.exist(await republishError());
+        const stored = await util.promisify(server.storage.fetchTx).call(server.storage, wallet.id, txp.id);
+        stored.status.should.equal('pending');
+      });
+
+      it('should not republish a broadcasted txp back to pending', async function() {
+        await setStatus('broadcasted');
+        const err = await republishError();
+        should.exist(err);
+        err.code.should.equal('TX_ALREADY_BROADCASTED');
+        const stored = await util.promisify(server.storage.fetchTx).call(server.storage, wallet.id, txp.id);
+        stored.status.should.equal('broadcasted');
+      });
+
+      it('should not republish an accepted txp back to pending', async function() {
+        await setStatus('accepted');
+        const err = await republishError();
+        should.exist(err);
+        err.code.should.equal('TX_NOT_PENDING');
+        const stored = await util.promisify(server.storage.fetchTx).call(server.storage, wallet.id, txp.id);
+        stored.status.should.equal('accepted');
+      });
+
+      it('should not republish a rejected txp back to pending', async function() {
+        await setStatus('rejected');
+        const err = await republishError();
+        should.exist(err);
+        err.code.should.equal('TX_NOT_PENDING');
+      });
+    });
+
     it('should publish a deferred-nonce txp and save prePublishRaw', async function() {
       const txOpts = {
         outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],

package/test/model/txproposal.test.ts

@@ -53,6 +53,28 @@ describe('TxProposal', function() {
     });
   });
 
+  describe('#fromObj', function() {
+    it('should keep the stored output amount type untouched', function() {
+      const stored: any = { ...aTXP(), outputs: [{ ...aTXP().outputs[0], amount: 70000000000000010 }] };
+
+      const txp = TxProposal.fromObj(stored);
+
+      txp.outputs[0].amount.should.equal(70000000000000010);
+    });
+  });
+
+  describe('#getTotalAmountBigInt', function() {
+    it('should keep a total that a number cannot represent', function() {
+      const txp = TxProposal.fromObj({
+        ...aTXP(),
+        outputs: [{ ...aTXP().outputs[0], amount: '9007199254740992' }, { ...aTXP().outputs[1], amount: '1' }]
+      } as any);
+
+      txp.getTotalAmountBigInt().should.equal(9007199254740993n);
+      txp.getTotalAmount().should.equal(9007199254740992);
+    });
+  });
+
   describe('#getTotalAmount', function() {
     it('should compute total amount', function() {
       const x = TxProposal.fromObj(aTXP());
@@ -81,6 +103,21 @@ describe('TxProposal', function() {
     });
   });
 
+  describe('#sign with a number format', function() {
+    it('should keep the signatures in the persisted raw tx', function() {
+      const plain = TxProposal.fromObj(aTXP());
+      plain.sign('1', theSignatures, theXPub);
+      plain.sign('2', theSignatures, theXPub);
+
+      const formatted = TxProposal.fromObj(aTXP());
+      formatted.sign('1', theSignatures, theXPub, 'number');
+      formatted.sign('2', theSignatures, theXPub, 'number');
+
+      formatted.raw.should.deep.equal(plain.raw);
+      formatted.txid.should.equal(plain.txid);
+    });
+  });
+
   describe('#reject', function() {
     it('should reject 2-2', function() {
       const txp = TxProposal.fromObj(aTXP());
@@ -142,6 +179,13 @@ describe('TxProposal', function() {
       txp.outputs[0].amount.should.be.a('number');
     });
 
+    it('should keep a base-unit amount that a number cannot represent exactly', function() {
+      const amount = '70000000000000010';
+      const t = TxProposal.fromObj({ ...aTXP(), amount, outputs: [{ ...aTXP().outputs[0], amount }] } as any);
+      const txp = TxProposal.formatNumbers(t, 'number');
+      txp.outputs[0].amount.should.equal(amount);
+    });
+
     it('should format string numbers as hex', function() {
       const t1 = TxProposal.fromObj(aTXP());
       const t2 = TxProposal.formatNumbers(t1, 'string');
@@ -156,6 +200,80 @@ describe('TxProposal', function() {
       txp.outputs[0].amount.should.be.a('string');
       CWCUtils.isHexString(txp.outputs[0].amount).should.equal(true);
     });
+
+
+    describe('legacy format contracts', function() {
+      const cases: Array<[string, any, any]> = [
+        ['safe integer boundary', '9007199254740991', 9007199254740991],
+        ['first representable unsafe integer', '9007199254740992', 9007199254740992],
+        ['first unrepresentable integer', '9007199254740993', '9007199254740993'],
+        ['representable amount', '70000000000000008', Number('70000000000000008')],
+        ['inexact amount', '70000000000000010', '70000000000000010'],
+        ['representable hex', '0x20000000000000', 9007199254740992],
+        ['unrepresentable hex', '0x20000000000001', '0x20000000000001'],
+        ['exponential string', '1e+21', '1e+21'],
+        ['exponential number', 1e21, 1e21],
+        ['overflow string', '9'.repeat(400), '9'.repeat(400)],
+        ['empty string', '', ''],
+        ['nonnumeric string', 'abc', 'abc'],
+        ['null', null, null],
+        ['undefined', undefined, undefined],
+        ['NaN', NaN, NaN],
+        ['Infinity', Infinity, Infinity],
+        ['small bigint', 5n, 5],
+        ['inexact bigint', 9007199254740993n, 9007199254740993n],
+        ['positive sign', '+5', 5],
+        ['negative zero', '-0', -0],
+        ['leading zeros', '007', 7],
+        ['whitespace', ' 42 ', 42],
+        ['fractional prefix', '1.5', 1],
+        ['malformed prefix', '12xyz', 12],
+        ['SOL nonce prefix', '2' + 'A'.repeat(43), 2]
+      ];
+
+      for (const [label, value, expected] of cases) {
+        it(`should leave the legacy number behavior unchanged for ${label}`, function() {
+          const source: any = TxProposal.fromObj(aTXP());
+          source.amount = value;
+          source.outputs[0].amount = value;
+          const formatted = TxProposal.formatNumbers(source, 'number');
+
+          chai.expect(Object.is(formatted.amount, expected)).to.equal(true);
+          chai.expect(Object.is(formatted.outputs[0].amount, expected)).to.equal(true);
+          chai.expect(Object.is(source.outputs[0].amount, value)).to.equal(true);
+        });
+      }
+
+      for (const format of ['string', 'hex', 'bigint'] as const) {
+        it(`should leave the legacy ${format} behavior unchanged`, function() {
+          const source: any = TxProposal.fromObj(aTXP());
+          source.amount = 42;
+          source.outputs[0].amount = '70000000000000010';
+          const formatted = TxProposal.formatNumbers(source, format as 'string') as any;
+          const expected = {
+            string: ['42', '70000000000000010'],
+            hex: ['0x2a', '0xf8b0a10e47000a'],
+            bigint: [42n, 70000000000000010n]
+          }[format];
+
+          formatted.amount.should.equal(expected[0]);
+          formatted.outputs[0].amount.should.equal(expected[1]);
+          source.amount.should.equal(42);
+          source.outputs[0].amount.should.equal('70000000000000010');
+        });
+      }
+
+      it('should expand large integers and keep existing hex strings in string mode', function() {
+        const source: any = TxProposal.fromObj(aTXP());
+        source.amount = 1e21;
+        source.outputs[0].amount = '0x2a';
+        const formatted = TxProposal.formatNumbers(source, 'string');
+
+        formatted.amount.should.equal('1000000000000000000000');
+        BigInt(formatted.amount).should.equal(1000000000000000000000n);
+        formatted.outputs[0].amount.should.equal('0x2a');
+      });
+    });
   });
 });
 

package/test/numberformat-routes.test.ts

@@ -0,0 +1,88 @@
+'use strict';
+
+import * as chai from 'chai';
+import 'chai/register-should';
+import express from 'express';
+import sinon from 'sinon';
+import { Errors } from '../src/lib/errors/errordefinitions';
+import { createRouteHelpers } from '../src/lib/routes/context';
+import { ApiErrorHelper } from '../src/lib/routes/helpers/error';
+import { registerTransactionRoutes } from '../src/lib/routes/transactions';
+import { registerWalletRoutes } from '../src/lib/routes/wallets';
+
+const should = chai.should();
+
+describe('Transaction number format routes', function() {
+  const routes = [
+    ['get', '/v2/txproposals/', 'getPendingTxs'],
+    ['post', '/v3/txproposals/', 'createTx'],
+    ['post', '/v2/txproposals/:id/signatures/', 'signTx'],
+    ['post', '/v1/txproposals/:id/prepare/', 'prepareTx'],
+    ['post', '/v2/txproposals/:id/publish/', 'publishTx'],
+    ['get', '/v3/wallets/', 'getStatus'],
+    ['get', '/v1/wallets/all/', 'getStatus']
+  ];
+
+  function setup() {
+    const router = express.Router();
+    const error = new ApiErrorHelper();
+    const returnError = error.returnError.bind(error);
+    const helpers = createRouteHelpers(returnError);
+    const server: any = { copayerId: 'copayer', walletId: 'wallet' };
+    for (const method of new Set(routes.map(route => route[2]))) {
+      server[method] = sinon.stub().callsArgWith(1, null, { outputs: [{ amount: '70000000000000010' }] });
+    }
+    const context = {
+      ...helpers,
+      returnError,
+      getServerWithAuth: sinon.stub().callsFake((_req, _res, cb) => cb(server)),
+      getServerWithMultiAuth: sinon.stub().returns([Promise.resolve(server)]),
+      createWalletLimiter: sinon.stub().callsArg(2)
+    };
+    registerTransactionRoutes(router, context);
+    registerWalletRoutes(router, context);
+    const response: any = {
+      status: sinon.stub().returnsThis(),
+      json: sinon.stub().returnsThis(),
+      end: sinon.stub().returnsThis()
+    };
+    return { router, server, response, context };
+  }
+
+  for (const [method, path, serverMethod] of routes) {
+    for (const format of ['number', 'string', 'hex', undefined]) {
+      it(`should accept ${format ?? 'unspecified'} on ${method.toUpperCase()} ${path}`, async function() {
+        const { router, server, response } = setup();
+        const route = router.stack.find(layer => layer.route?.path === path && layer.route.methods[method]);
+        const request: any = { query: { numberFormat: format }, body: {}, params: { id: 'proposal' }, headers: {} };
+
+        await route.route.stack[0].handle(request, response);
+
+        server[serverMethod].callCount.should.equal(1);
+        chai.expect(server[serverMethod].firstCall.args[0].numberFormat).to.equal(format);
+        response.status.called.should.equal(false);
+        response.json.callCount.should.equal(1);
+      });
+    }
+
+    for (const format of ['invalid', 'bigint', 'raw']) {
+      it(`should return 400 without executing ${method.toUpperCase()} ${path} for ${format}`, async function() {
+        const { router, server, response, context } = setup();
+        const route = router.stack.find(layer => layer.route?.path === path && layer.route.methods[method]);
+        const request: any = { query: { numberFormat: format }, body: {}, params: { id: 'proposal' }, headers: {} };
+
+        await route.route.stack[0].handle(request, response);
+
+        response.status.calledOnceWithExactly(400).should.equal(true);
+        response.json.callCount.should.equal(1);
+        response.json.firstCall.args[0].code.should.equal('INVALID_NUMBER_FORMAT');
+        server[serverMethod].called.should.equal(false);
+        if (path === '/v1/wallets/all/') context.getServerWithMultiAuth.called.should.equal(false);
+      });
+    }
+  }
+
+  it('should list the supported formats in the validation error', function() {
+    Errors.INVALID_NUMBER_FORMAT.message.should.include('number, string, hex');
+  });
+});