@bitpay-labs/bitcore-wallet-service 11.7.0 → 11.7.2

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.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": "d7f26cd2fae506cba9bb8965c5a196b13d8f0586"
 }

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

@@ -3314,6 +3314,11 @@ export class WalletService implements IWalletService {
           if (action) return cb(Errors.COPAYER_VOTED);
           if (!txp.isPending()) return cb(Errors.TX_NOT_PENDING);
 
+          // Client-supplied nonce override
+          if (opts.nonce != null && [...Object.keys(Constants.EVM_CHAINS), 'XRP'].includes(wallet.chain.toUpperCase())) {
+            txp.nonce = Number(opts.nonce);
+          }
+
           if (this._upgradeNeeded(UPGRADES.BCH_schnorr, { signingMethod: txp.signingMethod, supportBchSchnorr: opts.supportBchSchnorr })) {
             return cb(Errors.UPGRADE_NEEDED);
           }
@@ -3407,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);
           }
 
@@ -4482,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();
           }
 
@@ -4514,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 ========== \
@@ -4598,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,
@@ -4615,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 || {};
@@ -5516,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,224 @@ 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;
+
+    beforeEach(async function() {
+      ({ server, wallet } = await helpers.createAndJoinWallet(1, 1, { coin: 'eth' }));
+      const address = await util.promisify(server.createAddress).call(server, {});
+      fromAddr = address.address;
+      await helpers.stubUtxos(server, wallet, [1, 2], { coin: 'eth' });
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '5');
+    });
+
+    it('should accept nonce passthrough in signTx', async function() {
+      const txp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr
+      }, TestData.copayers[0].privKey_1H_0);
+      txp.nonce.should.equal('5');
+
+      const signatures = helpers.clientSign(txp, TestData.copayers[0].xPrivKey_44H_0H_0H);
+      const signed = await util.promisify(server.signTx).call(server, {
+        txProposalId: txp.id,
+        signatures,
+        nonce: Number(txp.nonce)
+      });
+      signed.status.should.equal('accepted');
+      signed.nonce.should.equal(5);
+    });
+
+    it('should accept nonce override in signTx', async function() {
+      const txp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr
+      }, TestData.copayers[0].privKey_1H_0);
+      txp.nonce.should.equal('5');
+
+      const overrideNonce = 99;
+      const fetched = await util.promisify(server.getTx).call(server, { txProposalId: txp.id });
+      fetched.nonce = overrideNonce;
+
+      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,
+        nonce: overrideNonce
+      });
+      signed.status.should.equal('accepted');
+      signed.nonce.should.equal(overrideNonce);
+    });
+
+    it('should reject nonce override that conflicts with pending txp', async function() {
+      const txp1 = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 1000 }],
+        feePerKb: 123e2,
+        from: fromAddr
+      }, TestData.copayers[0].privKey_1H_0);
+      txp1.nonce.should.equal('5');
+
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '6');
+      const txp2 = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 2000 }],
+        feePerKb: 123e2,
+        from: fromAddr
+      }, TestData.copayers[0].privKey_1H_0);
+      txp2.nonce.should.equal('6');
+
+      // sign txp2 with nonce 5 (conflicts with txp1)
+      const fetched = await util.promisify(server.getTx).call(server, { txProposalId: txp2.id });
+      fetched.nonce = 5;
+      const signatures = helpers.clientSign(fetched, TestData.copayers[0].xPrivKey_44H_0H_0H);
+
+      try {
+        await util.promisify(server.signTx).call(server, {
+          txProposalId: txp2.id,
+          signatures,
+          nonce: 5
+        });
+        throw new Error('should have thrown');
+      } catch (err) {
+        err.code.should.equal('TX_NONCE_CONFLICT');
+      }
+    });
+
+    it('should not crash on nonce conflict check when nonce is null', async function() {
+      const txp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      }, TestData.copayers[0].privKey_1H_0);
+      should.not.exist(txp.nonce);
+
+      // null nonce on other txps should not throw in conflict check
+      const fetched = await util.promisify(server.getTx).call(server, { txProposalId: txp.id });
+      fetched.nonce = 99;
+      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,
+        nonce: 99
+      });
+      signed.status.should.equal('accepted');
+      signed.nonce.should.equal(99);
+    });
+
+    it('should ignore nonce override for non-EVM chains', async function() {
+      const { server: btcServer, wallet: btcWallet } = await helpers.createAndJoinWallet(1, 1);
+      await helpers.stubUtxos(btcServer, btcWallet, [1, 2]);
+
+      const txp = await helpers.createAndPublishTx(btcServer, {
+        outputs: [{ toAddress: '18PzpUFkFZE8zKWUPvfykkTxmB9oMR8qP7', amount: 8000 }],
+        feePerKb: 100e2,
+      }, TestData.copayers[0].privKey_1H_0);
+
+      const signatures = helpers.clientSign(txp, TestData.copayers[0].xPrivKey_44H_0H_0H);
+      const signed = await util.promisify(btcServer.signTx).call(btcServer, {
+        txProposalId: txp.id,
+        signatures,
+        nonce: 99
+      });
+      signed.status.should.equal('accepted');
+      should.not.exist(signed.nonce);
+    });
+  });
+
   describe('#broadcastTx & #broadcastRawTx', function() {
     let server: WalletService;
     let wallet: Model.Wallet;