@bitpay-labs/bitcore-wallet-service 11.11.0 → 11.11.2

package/test/integration/externalservices/banxa.test.ts

@@ -1,20 +1,24 @@
 'use strict';
 
 import * as chai from 'chai';
+import * as sinon from 'sinon';
 import 'chai/register-should';
 import util from 'util';
 import { WalletService } from '../../../src/lib/server';
 import * as TestData from '../../testdata';
 import helpers from '../helpers';
 import config from '../../../src/config';
+import logger from '../../../src/lib/logger';
 
 const should = chai.should();
 
 describe('Banxa integration', () => {
+  const sandbox = sinon.createSandbox();
   let server;
   let wallet;
   let fakeRequest;
   let req;
+  let loggerError: sinon.SinonStub;
 
   before(async function() {
     await helpers.before();
@@ -63,6 +67,12 @@ describe('Banxa integration', () => {
       walletId: '123',
     });
     server = s;
+    sandbox.stub(logger, 'warn');
+    loggerError = sandbox.stub(logger, 'error');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
   });
 
   after(async function() {
@@ -101,7 +111,23 @@ describe('Banxa integration', () => {
         await server.externalServices.banxa.banxaGetPaymentMethods(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Banxa request failed with error (');
+        err.message.should.equal('Failed to fetch Banxa payment methods');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.banxa.request = fakeRequest2;
+      try {
+        await server.externalServices.banxa.banxaGetPaymentMethods(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Banxa did not return payment methods');
       }
     });
 
@@ -155,7 +181,23 @@ describe('Banxa integration', () => {
         await server.externalServices.banxa.banxaGetCoins(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Banxa request failed with error (');
+        err.message.should.equal('Failed to fetch Banxa coins');
+      };
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.banxa.request = fakeRequest2;
+      try {
+        await server.externalServices.banxa.banxaGetCoins(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Banxa did not return coins');
       };
     });
 
@@ -224,7 +266,23 @@ describe('Banxa integration', () => {
         await server.externalServices.banxa.banxaGetQuote(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Banxa request failed with error (');
+        err.message.should.equal('Failed to fetch Banxa quote');
+      };
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.banxa.request = fakeRequest2;
+      try {
+        await server.externalServices.banxa.banxaGetQuote(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Banxa did not return quote');
       };
     });
 
@@ -287,7 +345,23 @@ describe('Banxa integration', () => {
         await server.externalServices.banxa.banxaCreateOrder(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Banxa request failed with error (');
+        err.message.should.equal('Failed to create Banxa order');
+      };
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        post: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.banxa.request = fakeRequest2;
+      try {
+        await server.externalServices.banxa.banxaCreateOrder(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Banxa did not return order');
       };
     });
 
@@ -345,7 +419,23 @@ describe('Banxa integration', () => {
         await server.externalServices.banxa.banxaGetOrder(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Banxa request failed with error (');
+        err.message.should.equal('Failed to get Banxa order');
+      };
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.banxa.request = fakeRequest2;
+      try {
+        await server.externalServices.banxa.banxaGetOrder(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Banxa did not return order');
       };
     });
 

package/test/integration/externalservices/changelly.test.ts

@@ -1,6 +1,7 @@
 'use strict';
 
 import * as chai from 'chai';
+import * as sinon from 'sinon';
 import 'chai/register-should';
 import crypto from 'crypto';
 import util from 'util';
@@ -8,6 +9,7 @@ import { WalletService } from '../../../src/lib/server';
 import * as TestData from '../../testdata';
 import helpers from '../helpers';
 import config from '../../../src/config';
+import logger from '../../../src/lib/logger';
 
 const should = chai.should();
 
@@ -24,10 +26,12 @@ const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
 });
 
 describe('Changelly integration', () => {
+  const sandbox = sinon.createSandbox();
   let server;
   let wallet;
   let fakeRequest;
   let req;
+  let loggerError: sinon.SinonStub;
 
   before(async () => {
     await helpers.before();
@@ -65,6 +69,12 @@ describe('Changelly integration', () => {
       clientVersion: 'bwc-2.0.0',
       walletId: '123',
     }));
+    sandbox.stub(logger, 'warn');
+    loggerError = sandbox.stub(logger, 'error');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
   });
 
   after(async () => {
@@ -140,7 +150,24 @@ describe('Changelly integration', () => {
         await server.externalServices.changelly.changellyGetCurrencies(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Changelly request failed with error (');
+        err.message.should.equal('Failed to fetch Changelly currencies');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      req.body.id = 'test';
+      const fakeRequest2 = {
+        post: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.changelly.request = fakeRequest2;
+      try {
+        await server.externalServices.changelly.changellyGetCurrencies(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Changelly did not return currencies');
       }
     });
 
@@ -212,7 +239,24 @@ describe('Changelly integration', () => {
         await server.externalServices.changelly.changellyGetPairsParams(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Changelly request failed with error (');
+        err.message.should.equal('Failed to fetch Changelly pairs params');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      req.body.coinFrom = 'btc';
+      const fakeRequest2 = {
+        post: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.changelly.request = fakeRequest2;
+      try {
+        await server.externalServices.changelly.changellyGetPairsParams(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Changelly did not return pairs params');
       }
     });
 
@@ -284,7 +328,24 @@ describe('Changelly integration', () => {
         await server.externalServices.changelly.changellyGetFixRateForAmount(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Changelly request failed with error (');
+        err.message.should.equal('Failed to fetch Changelly fix rate for amount');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      req.body.coinFrom = 'btc';
+      const fakeRequest2 = {
+        post: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.changelly.request = fakeRequest2;
+      try {
+        await server.externalServices.changelly.changellyGetFixRateForAmount(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Changelly did not return fix rate for amount');
       }
     });
 
@@ -355,7 +416,24 @@ describe('Changelly integration', () => {
         await server.externalServices.changelly.changellyCreateFixTransaction(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Changelly request failed with error (');
+        err.message.should.equal('Failed to create Changelly fix transaction');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      req.body.coinFrom = 'btc';
+      const fakeRequest2 = {
+        post: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.changelly.request = fakeRequest2;
+      try {
+        await server.externalServices.changelly.changellyCreateFixTransaction(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Changelly did not return fix transaction');
       }
     });
 
@@ -421,7 +499,24 @@ describe('Changelly integration', () => {
         await server.externalServices.changelly.changellyGetTransactions(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Changelly request failed with error (');
+        err.message.should.equal('Failed to get Changelly transactions');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async() => {
+      req.body.exchangeTxId = 'exchangeTxId';
+      const fakeRequest2 = {
+        post: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+      server.externalServices.changelly.request = fakeRequest2;
+
+      try {
+        await server.externalServices.changelly.changellyGetTransactions(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Changelly did not return transactions');
       }
     });
 
@@ -487,7 +582,24 @@ describe('Changelly integration', () => {
         await server.externalServices.changelly.changellyGetStatus(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Changelly request failed with error (');
+        err.message.should.equal('Failed to get Changelly status');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      req.body.exchangeTxId = 'exchangeTxId';
+      const fakeRequest2 = {
+        post: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.changelly.request = fakeRequest2;
+      try {
+        await server.externalServices.changelly.changellyGetStatus(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Changelly did not return status');
       }
     });
 

package/test/integration/externalservices/coinGecko.test.ts

@@ -139,6 +139,7 @@ describe('CoinGecko integration', function() {
   let server;
   let wallet;
   let fakeRequest;
+  let loggerError: sinon.SinonStub;
 
   const cg = () => server.externalServices.coinGecko;
   const getMarketStats = (query: any, code = 'USD') => cg().coinGeckoGetMarketStats({ params: { code }, query });
@@ -188,6 +189,7 @@ describe('CoinGecko integration', function() {
       clientVersion: 'bwc-2.0.0',
       walletId: '123'
     });
+    loggerError = sandbox.stub(logger, 'error');
   });
 
   after(async () => {
@@ -486,6 +488,8 @@ describe('CoinGecko integration', function() {
         await getMarketStats({ coin: 'USDC.e', chain: 'arb', tokenAddress });
         should.fail('should have thrown');
       } catch (err) {
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('CoinGecko request failed');
         err.message.should.equal('Unsupported tokenAddress');
       }
     });

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

@@ -1,20 +1,24 @@
 'use strict';
 
 import * as chai from 'chai';
+import * as sinon from 'sinon';
 import 'chai/register-should';
 import util from 'util';
 import { WalletService } from '../../../src/lib/server';
 import * as TestData from '../../testdata';
 import helpers from '../helpers';
 import config from '../../../src/config';
+import logger from '../../../src/lib/logger';
 
 const should = chai.should();
 
 describe('Moonpay integration', () => {
+  const sandbox = sinon.createSandbox();
   let server;
   let wallet;
   let fakeRequest;
   let req;
+  let loggerError: sinon.SinonStub;
 
   before(async () => {
     await helpers.before();
@@ -71,12 +75,75 @@ describe('Moonpay integration', () => {
       clientVersion: 'bwc-2.0.0',
       walletId: '123',
     }));
+    sandbox.stub(logger, 'warn');
+    loggerError = sandbox.stub(logger, 'error');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
   });
 
   after(async () => {
     await helpers.after();
   });
 
+  describe('#moonpayGetCurrencies', () => {
+    beforeEach(() => {
+      req = {
+        headers: {},
+        body: {
+          env: 'sandbox'
+        }
+      };
+      server.externalServices.moonpay.request = fakeRequest;
+    });
+
+    it('should work properly if req is OK', async () => {
+      const data = await server.externalServices.moonpay.moonpayGetCurrencies(req);
+      should.exist(data);
+    });
+
+    it('should return error if get returns error', async () => {
+      const fakeRequest2 = {
+        get: (_url, _opts, _cb) => { return _cb(new Error('Error'), null); },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayGetCurrencies(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to get Moonpay currencies');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayGetCurrencies(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay did not return currencies');
+      }
+    });
+
+    it('should return error if moonpay is commented in config', async () => {
+      config.moonpay = undefined;
+      try {
+        await server.externalServices.moonpay.moonpayGetCurrencies(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay missing credentials');
+      }
+    });
+  });
+
   describe('#moonpayGetQuote', () => {
     beforeEach(() => {
       req = {
@@ -113,7 +180,23 @@ describe('Moonpay integration', () => {
         await server.externalServices.moonpay.moonpayGetQuote(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to get Moonpay buy quote');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayGetQuote(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay did not return buy quote');
       }
     });
 
@@ -173,7 +256,23 @@ describe('Moonpay integration', () => {
         await server.externalServices.moonpay.moonpayGetSellQuote(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to get Moonpay sell quote');
+      };
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayGetSellQuote(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay did not return sell quote');
       };
     });
 
@@ -232,7 +331,23 @@ describe('Moonpay integration', () => {
         await server.externalServices.moonpay.moonpayGetCurrencyLimits(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to get Moonpay currency limits');
+      };
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayGetCurrencyLimits(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay did not return currency limits');
       };
     });
 
@@ -422,7 +537,23 @@ describe('Moonpay integration', () => {
         await server.externalServices.moonpay.moonpayGetTransactionDetails(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to get Moonpay transaction details');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayGetTransactionDetails(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay did not return transaction details');
       }
     });
 
@@ -482,7 +613,23 @@ describe('Moonpay integration', () => {
         await server.externalServices.moonpay.moonpayGetSellTransactionDetails(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to get Moonpay sell transaction details');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayGetSellTransactionDetails(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay did not return sell transaction details');
       }
     });
 
@@ -534,7 +681,23 @@ describe('Moonpay integration', () => {
         await server.externalServices.moonpay.moonpayGetAccountDetails(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to get Moonpay account details');
+      }
+    });
+
+    it('should return error and not leak the response if body is empty', async () => {
+      const fakeRequest2 = {
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayGetAccountDetails(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay did not return account details');
       }
     });
 
@@ -612,7 +775,9 @@ describe('Moonpay integration', () => {
         await server.externalServices.moonpay.moonpayCancelSellTransaction(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to cancel Moonpay sell transaction');
       }
     });
 
@@ -701,7 +866,9 @@ describe('Moonpay integration', () => {
         await server.externalServices.moonpay.moonpayCreateSession(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to create Moonpay session');
       }
     });
 
@@ -812,7 +979,9 @@ describe('Moonpay integration', () => {
         await server.externalServices.moonpay.moonpayRevokeActiveSession(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Moonpay request failed with error (');
+        err.message.should.equal('Failed to revoke Moonpay session');
       }
     });