@bitpay-labs/bitcore-wallet-service 11.10.12 → 11.10.14

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.14",
   "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.14",
+    "@bitpay-labs/crypto-wallet-core": "^11.10.14",
     "@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": "4a71ba9f78b8104f3c0377997cb380fcf6cbcfb3"
 }

package/src/externalservices/moonpay.ts

@@ -447,7 +447,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 });
           }
         }
       );
@@ -526,7 +527,10 @@ export class MoonpayService {
           if (err) {
             return reject(err.body ?? err);
           } else {
-            return resolve(data.body ?? data);
+            if (!data.body) {
+              return reject(new ClientError('Moonpay did not return a session'));
+            }
+            return resolve(data.body);
           }
         }
       );
@@ -560,7 +564,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: []
+  };
+};
+