@bitpay-labs/bitcore-wallet-service 11.7.1 → 11.7.3

package/README.md

@@ -231,6 +231,7 @@ Optional Arguments:
 
 - skip: Records to skip from the result (defaults to 0)
 - limit: Total number of records to return (return all available records if not specified).
+- reverse: Return oldest transactions first.
 
 Returns:
 

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.7.1",
+  "version": "11.7.3",
   "license": "MIT",
   "main": "ts_build/src/index.js",
   "types": "./ts_build/src/index.d.ts",
@@ -43,8 +43,8 @@
     "cp:templates": "cp -r ./templates ./ts_build/templates"
   },
   "dependencies": {
-    "@bitpay-labs/bitcore-tss": "^11.7.0",
-    "@bitpay-labs/crypto-wallet-core": "^11.7.0",
+    "@bitpay-labs/bitcore-tss": "^11.7.3",
+    "@bitpay-labs/crypto-wallet-core": "^11.7.3",
     "@sendgrid/mail": "6.5.4",
     "abi-decoder": "2.4.0",
     "async": "0.9.2",
@@ -126,5 +126,5 @@
       "email": "kjoseph@bitpay.com"
     }
   ],
-  "gitHead": "51eda38e01a792cd8dda45db1a520ff459e2ecae"
+  "gitHead": "a1890ef287c9e5d0e966fb445d15bc59a9393761"
 }

package/src/externalservices/banxa.ts

@@ -190,6 +190,12 @@ export class BanxaService {
         return reject(new ClientError("Banxa's request missing arguments"));
       }
 
+      if (!req.body.payment_method || req.body.payment_method === 'other') {
+        // Workaround to allow older versions of the app to freely choose the payment method on the checkout page when they select "other".
+        delete req.body.payment_method_id;
+      }
+      delete req.body.payment_method;
+
       const UriPath = '/orders';
       const URL: string = API + UriPath;
       const auth = this.getBanxaSignature('post', UriPath, API_KEY, SECRET_KEY, req.body);

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

@@ -161,7 +161,7 @@ export class XrpChain implements IChain {
         ...txp,
         tag: _tag ? Number(_tag) : undefined,
         chain,
-        nonce: Number(txp.nonce) + Number(index),
+        nonce: (txp.nonce != null ? Number(txp.nonce) : 0) + Number(index),
         recipients: [recepient]
       });
       unsignedTxs.push(rawTx);

package/src/lib/expressapp.ts

@@ -1180,12 +1180,14 @@ export class ExpressApp {
         const opts: {
           skip?: number;
           limit?: number;
+          reverse?: boolean;
           includeExtendedInfo?: boolean;
           tokenAddress?: string;
           multisigContractAddress?: string;
         } = {};
         if (req.query.skip) opts.skip = +req.query.skip;
         if (req.query.limit) opts.limit = +req.query.limit;
+        if (req.query.reverse == '1') opts.reverse = true;
         if (req.query.tokenAddress) opts.tokenAddress = req.query.tokenAddress as string;
         if (req.query.multisigContractAddress)
           opts.multisigContractAddress = req.query.multisigContractAddress as string;

package/src/lib/server.ts

@@ -3412,7 +3412,7 @@ export class WalletService implements IWalletService {
             return cb(null, txp);
           }
 
-          if (!Constants.EVM_CHAINS[wallet.chain.toUpperCase()]) {
+          if (!Constants.EVM_CHAINS[wallet.chain.toUpperCase()] && wallet.chain.toUpperCase() !== 'XRP') {
             return cb(null, txp);
           }
 
@@ -4487,6 +4487,13 @@ export class WalletService implements IWalletService {
         next => {
           if (streamData) {
             lastTxs = streamData;
+            if (cacheStatus.tipTxId) {
+              // Stream data can outlive cache promotion, so trim any entries that
+              // are now part of the durable cache before paging.
+              lastTxs = _.takeWhile(lastTxs, (tx: any) => {
+                return tx.txid != cacheStatus.tipTxId;
+              });
+            }
             return next();
           }
 
@@ -4519,6 +4526,24 @@ export class WalletService implements IWalletService {
           });
         },
         next => {
+          if (opts.reverse) {
+            const cachedTxs = _.isNumber(cacheStatus.tipIndex) ? cacheStatus.tipIndex + 1 : 0;
+            const totalTxs = cachedTxs + lastTxs.length;
+            const oldestFirstSkip = skip;
+
+            // Keep the existing newest-first cache math by translating the requested
+            // oldest-first cursor into the equivalent newest-first slice.
+            limit = Math.max(0, Math.min(limit, totalTxs - oldestFirstSkip));
+            skip = Math.max(0, totalTxs - oldestFirstSkip - limit);
+          }
+
+          if (limit === 0) {
+            resultTxs = [];
+            fromCache = false;
+            fromBc = false;
+            return next();
+          }
+
           // Case 1.
           //            t -->
           //  | Old TXS    | ======= LAST TXS ========== \
@@ -4603,6 +4628,9 @@ export class WalletService implements IWalletService {
       ],
       err => {
         if (err) return cb(err);
+        if (opts.reverse) {
+          resultTxs.reverse();
+        }
         return cb(null, {
           items: resultTxs,
           fromCache,
@@ -4620,10 +4648,11 @@ export class WalletService implements IWalletService {
    * @param {Object} opts
    * @param {Number} opts.skip (defaults to 0)
    * @param {Number} opts.limit
+   * @param {Boolean} opts.reverse[=false] - Return oldest transactions first.
    * @param {String} opts.tokenAddress ERC20 Token Contract Address
    * @param {String} opts.multisigContractAddress MULTISIG ETH Contract Address
    * @param {Number} opts.includeExtendedInfo[=false] - Include all inputs/outputs for every tx.
-   * @returns {TxProposal[]} Transaction proposals, first newer
+   * @returns {TxProposal[]} Transaction proposals, newer first unless opts.reverse is set
    */
   getTxHistory(opts, cb) {
     opts = opts || {};
@@ -5521,4 +5550,4 @@ export const UPGRADES = {
   bwc_$lt_1_2: 'bwc<1.2',
 } as const;
 
-type Upgrade = typeof UPGRADES[keyof typeof UPGRADES];
+type Upgrade = typeof UPGRADES[keyof typeof UPGRADES];

package/test/integration/helpers.ts

@@ -559,6 +559,7 @@ class Helpers {
         // For eth => account, 0, change = 0
         const priv = xpriv.derive('m/0/0').privateKey;
         const privKey = priv.toString('hex');
+        const pubKey = priv.publicKey.toString('hex');
         let tx = ChainService.getBitcoreTx(txp).uncheckedSerialize();
         const isERC20 = txp.tokenAddress && !txp.payProUrl;
         const chain = isERC20 ? Utils.getChain(txp.coin) + 'ERC20' : Utils.getChain(txp.coin);
@@ -568,7 +569,7 @@ class Helpers {
           const signed = Transactions.getSignature({
             chain: chain.toUpperCase(),
             tx: rawTx,
-            key: { privKey: privKey.toString('hex') },
+            key: { privKey: privKey.toString('hex'), pubKey },
           });
           signatures.push(signed);
         }

package/test/integration/history.test.ts

@@ -85,6 +85,158 @@ describe('History', function() {
       });
     });
 
+    it('should page from oldest first with reverse and keep skip stable if new txs arrive', async function() {
+      const _cache = Defaults.CONFIRMATIONS_TO_START_CACHING;
+      (Defaults.CONFIRMATIONS_TO_START_CACHING as any) = 1;
+
+      try {
+        const baseTxs = helpers.createTxsV8(5, BCHEIGHT);
+        helpers.stubHistory(null, null, baseTxs);
+
+        const firstPage = await new Promise<any[]>((resolve, reject) => {
+          server.getTxHistory({ limit: 2, reverse: true }, function(err, txs) {
+            if (err) return reject(err);
+            resolve(txs);
+          });
+        });
+
+        firstPage.map(tx => tx.id).should.deep.equal(['id4', 'id3']);
+
+        const txTemplate = baseTxs[0];
+        const updatedTxs = [
+          {
+            ...txTemplate,
+            id: 'newid0',
+            txid: 'newtxid0',
+            height: -1,
+            blockTime: '2018-09-21T18:08:33.000Z'
+          },
+          {
+            ...txTemplate,
+            id: 'newid1',
+            txid: 'newtxid1',
+            height: -1,
+            blockTime: '2018-09-21T18:08:32.000Z'
+          },
+          ...baseTxs
+        ];
+        helpers.stubHistory(null, null, updatedTxs);
+
+        const secondPage = await new Promise<any[]>((resolve, reject) => {
+          server.getTxHistory({ skip: 2, limit: 2, reverse: true }, function(err, txs) {
+            if (err) return reject(err);
+            resolve(txs);
+          });
+        });
+
+        secondPage.map(tx => tx.id).should.deep.equal(['id2', 'id1']);
+      } finally {
+        (Defaults.CONFIRMATIONS_TO_START_CACHING as any) = _cache;
+      }
+    });
+
+    it('should trim reused stream data against the current cache tip in reverse mode', async function() {
+      const _cache = Defaults.CONFIRMATIONS_TO_START_CACHING;
+      (Defaults.CONFIRMATIONS_TO_START_CACHING as any) = 1;
+
+      try {
+        const baseTxs = helpers.createTxsV8(4, BCHEIGHT);
+        helpers.stubHistory(null, null, baseTxs);
+
+        await new Promise<void>((resolve, reject) => {
+          server.storage.storeTxHistoryCacheV8(
+            wallet.id,
+            null,
+            [
+              {
+                id: baseTxs[3].id,
+                txid: baseTxs[3].txid,
+                blockheight: baseTxs[3].height
+              }
+            ],
+            0,
+            err => {
+              if (err) return reject(err);
+              resolve();
+            }
+          );
+        });
+
+        const firstPage = await new Promise<{ txs: any[]; useStream: boolean }>((resolve, reject) => {
+          server.getTxHistory({ limit: 2, reverse: true }, function(err, txs, _fromCache, useStream) {
+            if (err) return reject(err);
+            resolve({ txs, useStream });
+          });
+        });
+
+        firstPage.useStream.should.equal(false);
+        firstPage.txs.map(tx => tx.id).should.deep.equal(['id3', 'id2']);
+
+        const secondPage = await new Promise<{ txs: any[]; useStream: boolean }>((resolve, reject) => {
+          server.getTxHistory({ skip: 2, limit: 2, reverse: true }, function(err, txs, _fromCache, useStream) {
+            if (err) return reject(err);
+            resolve({ txs, useStream });
+          });
+        });
+
+        secondPage.useStream.should.equal(true);
+        secondPage.txs.map(tx => tx.id).should.deep.equal(['id1', 'id0']);
+      } finally {
+        (Defaults.CONFIRMATIONS_TO_START_CACHING as any) = _cache;
+      }
+    });
+
+    it('should trim reused stream data against the current cache tip in newest-first mode', async function() {
+      const _cache = Defaults.CONFIRMATIONS_TO_START_CACHING;
+      (Defaults.CONFIRMATIONS_TO_START_CACHING as any) = 1;
+
+      try {
+        const baseTxs = helpers.createTxsV8(4, BCHEIGHT);
+        helpers.stubHistory(null, null, baseTxs);
+
+        await new Promise<void>((resolve, reject) => {
+          server.storage.storeTxHistoryCacheV8(
+            wallet.id,
+            null,
+            [
+              {
+                id: baseTxs[3].id,
+                txid: baseTxs[3].txid,
+                blockheight: baseTxs[3].height
+              }
+            ],
+            0,
+            err => {
+              if (err) return reject(err);
+              resolve();
+            }
+          );
+        });
+
+        const firstPage = await new Promise<{ txs: any[]; useStream: boolean }>((resolve, reject) => {
+          server.getTxHistory({ limit: 2 }, function(err, txs, _fromCache, useStream) {
+            if (err) return reject(err);
+            resolve({ txs, useStream });
+          });
+        });
+
+        firstPage.useStream.should.equal(false);
+        firstPage.txs.map(tx => tx.id).should.deep.equal(['id0', 'id1']);
+
+        const secondPage = await new Promise<{ txs: any[]; useStream: boolean }>((resolve, reject) => {
+          server.getTxHistory({ skip: 2, limit: 2 }, function(err, txs, _fromCache, useStream) {
+            if (err) return reject(err);
+            resolve({ txs, useStream });
+          });
+        });
+
+        secondPage.useStream.should.equal(true);
+        secondPage.txs.map(tx => tx.id).should.deep.equal(['id2', 'id3']);
+      } finally {
+        (Defaults.CONFIRMATIONS_TO_START_CACHING as any) = _cache;
+      }
+    });
+
     it('should filter out DUST amount', function(done) {
       const txs= helpers.createTxsV8(50, BCHEIGHT);
       txs[5].satoshis=100;
@@ -1139,4 +1291,3 @@ describe('History', function() {
     });
   });
 });
-

package/test/integration/server.test.ts

@@ -8134,6 +8134,97 @@ describe('Wallet service', function() {
     });
   });
 
+  describe('#prepareTx XRP (deferred nonce)', function() {
+    const XRP_ADDR = 'rDzTZxa7NwD9vmNf5dvTbW4FQDNSRsfPv6';
+    let server, wallet, fromAddr;
+
+    beforeEach(async function() {
+      ({ server, wallet } = await helpers.createAndJoinWallet(1, 1, { coin: 'xrp' }));
+      const address = await util.promisify(server.createAddress).call(server, {});
+      fromAddr = address.address;
+      await helpers.stubUtxos(server, wallet, [1, 2], { coin: 'xrp' });
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '5');
+    });
+
+    it('should create XRP txp with nonce=null when deferNonce is true', async function() {
+      const txp = await util.promisify(server.createTx).call(server, {
+        outputs: [{ toAddress: XRP_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      });
+      should.exist(txp);
+      txp.deferNonce.should.be.true;
+      should.not.exist(txp.nonce);
+    });
+
+    it('should assign nonce to a deferred XRP txp via prepareTx', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '10');
+
+      const txp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: XRP_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      }, TestData.copayers[0].privKey_1H_0);
+
+      should.not.exist(txp.nonce);
+
+      const result = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: txp.id
+      });
+      result.nonce.should.equal(10);
+    });
+
+    it('should calculate gap-free nonce for XRP skipping pending nonces', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '5');
+
+      const normalTxp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: XRP_ADDR, amount: 1000 }],
+        feePerKb: 123e2,
+        from: fromAddr
+      }, TestData.copayers[0].privKey_1H_0);
+      normalTxp.nonce.should.equal('5');
+
+      const deferred = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: XRP_ADDR, amount: 2000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      }, TestData.copayers[0].privKey_1H_0);
+
+      const result = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: deferred.id
+      });
+      result.nonce.should.equal(6);
+    });
+
+    it('should sign XRP txp after prepareTx assigns nonce', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '7');
+      helpers.stubBroadcast('txid123');
+
+      const txp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: XRP_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      }, TestData.copayers[0].privKey_1H_0);
+
+      const withNonce = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: txp.id
+      });
+      withNonce.nonce.should.equal(7);
+
+      const fetched = await util.promisify(server.getTx).call(server, { txProposalId: txp.id });
+      const signatures = helpers.clientSign(fetched, TestData.copayers[0].xPrivKey_44H_0H_0H);
+      const signed = await util.promisify(server.signTx).call(server, {
+        txProposalId: txp.id,
+        signatures
+      });
+      signed.status.should.equal('accepted');
+    });
+  });
+
   describe('#signTx nonce override', function() {
     const ETH_ADDR = '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A';
     let server, wallet, fromAddr;

package/test/txhistory.paging.test.ts

@@ -0,0 +1,166 @@
+'use strict';
+
+import * as chai from 'chai';
+import 'chai/register-should';
+import { WalletService } from '../src/lib/server';
+
+chai.should();
+
+type TxItem = {
+  id: string;
+  txid: string;
+  confirmations: number;
+  blockheight: number;
+};
+
+function makeTx(id: number): TxItem {
+  return {
+    id: `id${id}`,
+    txid: `txid${id}`,
+    confirmations: 100 - id,
+    blockheight: 1000 - id
+  };
+}
+
+function callGetTxHistoryV8(service: WalletService, bc, wallet, opts, skip: number, limit: number) {
+  return new Promise<any>((resolve, reject) => {
+    service.getTxHistoryV8(bc, wallet, opts, skip, limit, (err, res) => {
+      if (err) return reject(err);
+      resolve(res);
+    });
+  });
+}
+
+describe('TxHistory Paging', function() {
+  function buildService(initialCacheNewest: TxItem[], getBcNewest: () => TxItem[]) {
+    let cacheNewest = initialCacheNewest.slice();
+    let streamKey: string | null = null;
+    let streamItems: TxItem[] | null = null;
+
+    const service = Object.create(WalletService.prototype) as WalletService & {
+      storage: any;
+      syncWallet: any;
+      _getBlockchainHeight: any;
+      _normalizeTxHistory: any;
+      userAgent: string;
+    };
+
+    service.userAgent = 'txhistory-test-agent';
+    service.syncWallet = (_wallet, next) => next();
+    service._getBlockchainHeight = (_chain, _network, cb) => cb(null, 1000, 'test-hash');
+    service._normalizeTxHistory = (_walletCacheKey, _txs, _dustThreshold, _bcHeight, cb) => cb(null, getBcNewest());
+    service.storage = {
+      getTxHistoryCacheStatusV8: (_walletCacheKey, cb) =>
+        cb(null, {
+          updatedHeight: 0,
+          tipIndex: cacheNewest.length ? cacheNewest.length - 1 : null,
+          tipTxId: cacheNewest.length ? cacheNewest[0].txid : null,
+          tipHeight: cacheNewest.length ? cacheNewest[0].blockheight : null
+        }),
+      getTxHistoryStreamV8: (_walletCacheKey, cb) =>
+        cb(null, streamKey && streamItems ? { streamKey, items: streamItems.slice() } : null),
+      clearTxHistoryStreamV8: (_walletCacheKey, cb) => {
+        streamKey = null;
+        streamItems = null;
+        cb();
+      },
+      storeTxHistoryStreamV8: (_walletCacheKey, inStreamKey, items, cb) => {
+        streamKey = inStreamKey;
+        streamItems = items.slice();
+        cb();
+      },
+      getTxHistoryCacheV8: (_walletCacheKey, skip, limit, cb) => cb(null, cacheNewest.slice(skip, skip + limit)),
+      storeTxHistoryCacheV8: (_walletCacheKey, _tipIndex, items, _updateHeight, cb) => {
+        cacheNewest = items.concat(cacheNewest);
+        cb();
+      }
+    };
+
+    const bc = {
+      getTransactions: (_wallet, _startBlock, cb) => cb(null, [])
+    };
+    const wallet = {
+      id: 'wallet1',
+      chain: 'btc',
+      network: 'livenet'
+    };
+
+    return { service, bc, wallet };
+  }
+
+  it('should preserve newest-first skip behavior by default', async function() {
+    const cacheNewest = [makeTx(5), makeTx(6), makeTx(7)];
+    const bcNewest = [makeTx(0), makeTx(1), makeTx(2), makeTx(3), makeTx(4)];
+    const { service, bc, wallet } = buildService(cacheNewest, () => bcNewest);
+
+    const result = await callGetTxHistoryV8(service, bc, wallet, {}, 2, 2);
+
+    result.items.map(tx => tx.id).should.deep.equal(['id2', 'id3']);
+  });
+
+  it('should return oldest-first pages when reverse is set', async function() {
+    const cacheNewest = [makeTx(5), makeTx(6), makeTx(7)];
+    const bcNewest = [makeTx(0), makeTx(1), makeTx(2), makeTx(3), makeTx(4)];
+    const { service, bc, wallet } = buildService(cacheNewest, () => bcNewest);
+
+    const result = await callGetTxHistoryV8(service, bc, wallet, { reverse: true }, 0, 2);
+
+    result.items.map(tx => tx.id).should.deep.equal(['id7', 'id6']);
+  });
+
+  it('should keep reverse skip stable when new transactions arrive at the tip', async function() {
+    const cacheNewest = [makeTx(5), makeTx(6), makeTx(7)];
+    let bcNewest = [makeTx(0), makeTx(1), makeTx(2), makeTx(3), makeTx(4)];
+    const { service, bc, wallet } = buildService(cacheNewest, () => bcNewest);
+
+    const firstPage = await callGetTxHistoryV8(service, bc, wallet, { reverse: true }, 0, 2);
+    firstPage.items.map(tx => tx.id).should.deep.equal(['id7', 'id6']);
+
+    bcNewest = [
+      {
+        id: 'newid0',
+        txid: 'newtxid0',
+        confirmations: 0,
+        blockheight: -1
+      },
+      {
+        id: 'newid1',
+        txid: 'newtxid1',
+        confirmations: 0,
+        blockheight: -1
+      },
+      ...bcNewest
+    ];
+
+    const secondPage = await callGetTxHistoryV8(service, bc, wallet, { reverse: true }, 2, 2);
+    secondPage.items.map(tx => tx.id).should.deep.equal(['id5', 'id4']);
+  });
+
+  it('should trim streamed txs that were promoted into cache before reverse paging', async function() {
+    const cacheNewest = [makeTx(3)];
+    const bcNewest = [makeTx(0), makeTx(1), makeTx(2), makeTx(3)];
+    const { service, bc, wallet } = buildService(cacheNewest, () => bcNewest);
+
+    const firstPage = await callGetTxHistoryV8(service, bc, wallet, { reverse: true }, 0, 2);
+    firstPage.useStream.should.equal(false);
+    firstPage.items.map(tx => tx.id).should.deep.equal(['id3', 'id2']);
+
+    const secondPage = await callGetTxHistoryV8(service, bc, wallet, { reverse: true }, 2, 2);
+    secondPage.useStream.should.equal(true);
+    secondPage.items.map(tx => tx.id).should.deep.equal(['id1', 'id0']);
+  });
+
+  it('should trim streamed txs that were promoted into cache before newest-first paging', async function() {
+    const cacheNewest = [makeTx(3)];
+    const bcNewest = [makeTx(0), makeTx(1), makeTx(2), makeTx(3)];
+    const { service, bc, wallet } = buildService(cacheNewest, () => bcNewest);
+
+    const firstPage = await callGetTxHistoryV8(service, bc, wallet, {}, 0, 2);
+    firstPage.useStream.should.equal(false);
+    firstPage.items.map(tx => tx.id).should.deep.equal(['id0', 'id1']);
+
+    const secondPage = await callGetTxHistoryV8(service, bc, wallet, {}, 2, 2);
+    secondPage.useStream.should.equal(true);
+    secondPage.items.map(tx => tx.id).should.deep.equal(['id2', 'id3']);
+  });
+});

package/ts_build/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.7.0",
+    "version": "11.7.2",
     "license": "MIT",
     "main": "ts_build/src/index.js",
     "types": "./ts_build/src/index.d.ts",
@@ -43,8 +43,8 @@
         "cp:templates": "cp -r ./templates ./ts_build/templates"
     },
     "dependencies": {
-        "@bitpay-labs/bitcore-tss": "^11.7.0",
-        "@bitpay-labs/crypto-wallet-core": "^11.7.0",
+        "@bitpay-labs/bitcore-tss": "^11.7.2",
+        "@bitpay-labs/crypto-wallet-core": "^11.7.2",
         "@sendgrid/mail": "6.5.4",
         "abi-decoder": "2.4.0",
         "async": "0.9.2",
@@ -126,5 +126,5 @@
             "email": "kjoseph@bitpay.com"
         }
     ],
-    "gitHead": "6c5a1566aa725431db579f3c89a5c9f186bf5a30"
+    "gitHead": "a1890ef287c9e5d0e966fb445d15bc59a9393761"
 }

package/ts_build/src/externalservices/banxa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"banxa.d.ts","sourceRoot":"","sources":["../../../src/externalservices/banxa.ts"],"names":[],"mappings":"AAOA,qBAAa,YAAY;IACvB,OAAO,EAAE,GAAG,CAAW;IAEvB,OAAO,CAAC,YAAY;IAyBpB,OAAO,CAAC,iBAAiB;IAsBzB,aAAa,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IAwChC,sBAAsB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IAqCzC,aAAa,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA+ChC,gBAAgB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IAsCnC,aAAa,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;CAuCjC"}
+{"version":3,"file":"banxa.d.ts","sourceRoot":"","sources":["../../../src/externalservices/banxa.ts"],"names":[],"mappings":"AAOA,qBAAa,YAAY;IACvB,OAAO,EAAE,GAAG,CAAW;IAEvB,OAAO,CAAC,YAAY;IAyBpB,OAAO,CAAC,iBAAiB;IAsBzB,aAAa,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IAwChC,sBAAsB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IAqCzC,aAAa,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA+ChC,gBAAgB,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;IA4CnC,aAAa,CAAC,GAAG,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC;CAuCjC"}

package/ts_build/src/externalservices/banxa.js

@@ -195,6 +195,10 @@ class BanxaService {
             if (!(0, server_1.checkRequired)(req.body, ['account_reference', 'source', 'target', 'wallet_address', 'return_url_on_success'])) {
                 return reject(new clienterror_1.ClientError("Banxa's request missing arguments"));
             }
+            if (!req.body.payment_method || req.body.payment_method === 'other') {
+                delete req.body.payment_method_id;
+            }
+            delete req.body.payment_method;
             const UriPath = '/orders';
             const URL = API + UriPath;
             const auth = this.getBanxaSignature('post', UriPath, API_KEY, SECRET_KEY, req.body);