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

package/test/integration/externalservices/oneInch.test.ts

@@ -1,21 +1,25 @@
 '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('OneInch integration', function() {
   this.timeout(5000);
+  const sandbox = sinon.createSandbox();
   let server;
   let wallet;
   let fakeRequest;
   let req;
+  let loggerError: sinon.SinonStub;
   
   before(async () => {
     await helpers.before();
@@ -47,6 +51,12 @@ describe('OneInch integration', function() {
       clientVersion: 'bwc-2.0.0',
       walletId: '123',
     }));
+    sandbox.stub(logger, 'warn');
+    loggerError = sandbox.stub(logger, 'error');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
   });
 
   after(async () => {
@@ -119,7 +129,24 @@ describe('OneInch integration', function() {
         await server.externalServices.oneInch.oneInchGetSwap(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('1Inch request failed with error (');
+        err.message.should.equal('Failed to get 1Inch swap data');
+      }
+    });
+
+    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 } }); },
+        get: (_url, opts, cb) => { return cb(null, { statusCode: 200, body: undefined, request: { headers: opts.headers } }); }
+      };
+
+      server.externalServices.oneInch.request = fakeRequest2;
+      try {
+        await server.externalServices.oneInch.oneInchGetSwap(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('1Inch did not return swap data');
       }
     });
 

package/test/integration/externalservices/ramp.test.ts

@@ -1,6 +1,7 @@
 'use strict';
 
 import * as chai from 'chai';
+import * as sinon from 'sinon';
 import crypto from 'crypto';
 import 'chai/register-should';
 import util from 'util';
@@ -8,6 +9,8 @@ import { WalletService } from '../../../src/lib/server';
 import * as TestData from '../../testdata';
 import helpers from '../helpers';
 import config from '../../../src/config';
+import { ClientError } from '../../../src/lib/errors/clienterror';
+import logger from '../../../src/lib/logger';
 
 const should = chai.should();
 const { privateKey: privDer } = crypto.generateKeyPairSync('ed25519', {
@@ -22,10 +25,13 @@ const { privateKey: privDer } = crypto.generateKeyPairSync('ed25519', {
 });
 
 describe('Ramp integration', () => {
+  const sandbox = sinon.createSandbox();
   let server;
   let wallet;
   let fakeRequest;
   let req;
+  let loggerError: sinon.SinonStub;
+  let loggerWarn: sinon.SinonStub;
 
   before(async () => {
     await helpers.before();
@@ -77,6 +83,12 @@ describe('Ramp integration', () => {
       clientVersion: 'bwc-2.0.0',
       walletId: '123',
     }));
+    loggerWarn = sandbox.stub(logger, 'warn');
+    loggerError = sandbox.stub(logger, 'error');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
   });
 
   after(async () => {
@@ -118,7 +130,23 @@ describe('Ramp integration', () => {
         await server.externalServices.ramp.rampGetQuote(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Ramp request failed with error (');
+        err.message.should.equal('Failed to get Ramp quote');
+      }
+    });
+
+    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.ramp.request = fakeRequest2;
+      try {
+        await server.externalServices.ramp.rampGetQuote(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Ramp did not return quote data');
       }
     });
 
@@ -178,7 +206,23 @@ describe('Ramp integration', () => {
         await server.externalServices.ramp.rampGetSellQuote(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Ramp request failed with error (');
+        err.message.should.equal('Failed to get Ramp sell quote');
+      }
+    });
+
+    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.ramp.request = fakeRequest2;
+      try {
+        await server.externalServices.ramp.rampGetSellQuote(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Ramp did not return sell quote data');
       }
     });
 
@@ -541,7 +585,23 @@ describe('Ramp integration', () => {
         await server.externalServices.ramp.rampGetAssets(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Ramp request failed with error (');
+        err.message.should.equal('Failed to get Ramp assets');
+      }
+    });
+
+    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.ramp.request = fakeRequest2;
+      try {
+        await server.externalServices.ramp.rampGetAssets(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Ramp did not return assets data');
       }
     });
 
@@ -584,7 +644,69 @@ describe('Ramp integration', () => {
         await server.externalServices.ramp.rampGetSellTransactionDetails(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Ramp request failed with error (');
+        err.message.should.equal('Failed to get Ramp 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.ramp.request = fakeRequest2;
+      try {
+        await server.externalServices.ramp.rampGetSellTransactionDetails(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Ramp did not return sell transaction details');
+      }
+    });
+
+    it('should log the redacted URL and not leak the saleViewToken if get returns error', async () => {
+      let requestedUrl;
+      const fakeRequest2 = {
+        get: (url, _opts, cb) => { requestedUrl = url; return cb(new Error('Error'), null); },
+      };
+
+      server.externalServices.ramp.request = fakeRequest2;
+      try {
+        await server.externalServices.ramp.rampGetSellTransactionDetails(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        // the real request must still carry the token
+        requestedUrl.should.equal('api2/host-api/v3/offramp/sale/id1?secret=saleViewToken1');
+
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('(api2/host-api/v3/offramp/sale/id1?secret=***)');
+        loggerError.args[0][0].should.not.contain('saleViewToken1');
+
+        err.should.be.instanceOf(ClientError);
+        err.message.should.equal('Failed to get Ramp sell transaction details');
+        JSON.stringify(err).should.not.contain('saleViewToken1');
+        err.toString().should.not.contain('saleViewToken1');
+      }
+    });
+
+    it('should log the redacted URL and not leak the saleViewToken on non-2xx status', async () => {
+      const fakeRequest2 = {
+        get: (_url, _opts, cb) => { return cb(null, { statusCode: 401, body: undefined }); },
+      };
+
+      server.externalServices.ramp.request = fakeRequest2;
+      try {
+        await server.externalServices.ramp.rampGetSellTransactionDetails(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        loggerWarn.callCount.should.equal(1);
+        loggerWarn.args[0][0].should.equal('Ramp request failed with status code 401: api2/host-api/v3/offramp/sale/id1?secret=***');
+        loggerWarn.args[0][0].should.not.contain('saleViewToken1');
+
+        err.should.be.instanceOf(ClientError);
+        err.message.should.equal('Ramp did not return sell transaction details');
+        JSON.stringify(err).should.not.contain('saleViewToken1');
+        err.toString().should.not.contain('saleViewToken1');
       }
     });
 

package/test/integration/externalservices/sardine.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('Sardine integration', () => {
+  const sandbox = sinon.createSandbox();
   let server;
   let wallet;
   let fakeRequest;
   let req;
+  let loggerError: sinon.SinonStub;
 
   before(async () => {
     await helpers.before();
@@ -62,6 +66,12 @@ describe('Sardine integration', () => {
       clientVersion: 'bwc-2.0.0',
       walletId: '123',
     }));
+    sandbox.stub(logger, 'warn');
+    loggerError = sandbox.stub(logger, 'error');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
   });
 
   after(async () => {
@@ -106,7 +116,23 @@ describe('Sardine integration', () => {
         await server.externalServices.sardine.sardineGetQuote(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Sardine request failed with error (');
+        err.message.should.equal('Failed to get Sardine 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.sardine.request = fakeRequest2;
+      try {
+        await server.externalServices.sardine.sardineGetQuote(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Sardine did not return a quote');
       };
     });
 
@@ -163,7 +189,23 @@ describe('Sardine integration', () => {
         await server.externalServices.sardine.sardineGetCurrencyLimits(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Sardine request failed with error (');
+        err.message.should.equal('Failed to get Sardine 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.sardine.request = fakeRequest2;
+      try {
+        await server.externalServices.sardine.sardineGetCurrencyLimits(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Sardine did not return currency limits');
       };
     });
 
@@ -213,7 +255,23 @@ describe('Sardine integration', () => {
         await server.externalServices.sardine.sardineGetToken(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Sardine request failed with error (');
+        err.message.should.equal('Failed to get Sardine token');
+      };
+    });
+
+    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.sardine.request = fakeRequest2;
+      try {
+        await server.externalServices.sardine.sardineGetToken(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Sardine did not return a token');
       };
     });
 
@@ -270,7 +328,23 @@ describe('Sardine integration', () => {
         await server.externalServices.sardine.sardineGetSupportedTokens(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Sardine request failed with error (');
+        err.message.should.equal('Failed to get Sardine supported tokens');
+      };
+    });
+
+    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.sardine.request = fakeRequest2;
+      try {
+        await server.externalServices.sardine.sardineGetSupportedTokens(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Sardine did not return supported tokens');
       };
     });
 
@@ -318,7 +392,23 @@ describe('Sardine integration', () => {
         await server.externalServices.sardine.sardineGetOrdersDetails(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Sardine request failed with error (');
+        err.message.should.equal('Failed to get Sardine order 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.sardine.request = fakeRequest2;
+      try {
+        await server.externalServices.sardine.sardineGetOrdersDetails(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Sardine did not return order details');
       };
     });
 

package/test/integration/externalservices/simplex.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('Simplex integration', () => {
+  const sandbox = sinon.createSandbox();
   let server;
   let wallet;
   let fakeRequest;
   let req;
+  let loggerError: sinon.SinonStub;
 
   before(async () => {
     await helpers.before();
@@ -74,6 +78,12 @@ describe('Simplex integration', () => {
       clientVersion: 'bwc-2.0.0',
       walletId: '123',
     }));
+    sandbox.stub(logger, 'warn');
+    loggerError = sandbox.stub(logger, 'error');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
   });
 
   after(async () => {
@@ -112,7 +122,23 @@ describe('Simplex integration', () => {
         await server.externalServices.simplex.simplexGetCurrencies(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Simplex request failed with error (');
+        err.message.should.equal('Failed to get Simplex supported 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.simplex.request = fakeRequest2;
+      try {
+        await server.externalServices.simplex.simplexGetCurrencies(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Simplex did not return supported currencies');
       }
     });
 
@@ -230,7 +256,23 @@ describe('Simplex integration', () => {
         await server.externalServices.simplex.simplexGetQuote(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Simplex request failed with error (');
+        err.message.should.equal('Failed to get Simplex quote');
+      }
+    });
+
+    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.simplex.request = fakeRequest2;
+      try {
+        await server.externalServices.simplex.simplexGetQuote(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Simplex did not return a quote');
       }
     });
 
@@ -284,7 +326,23 @@ describe('Simplex integration', () => {
         await server.externalServices.simplex.simplexGetSellQuote(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Simplex request failed with error (');
+        err.message.should.equal('Failed to get Simplex 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.simplex.request = fakeRequest2;
+      try {
+        await server.externalServices.simplex.simplexGetSellQuote(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Simplex did not return a sell quote');
       }
     });
 
@@ -416,7 +474,23 @@ describe('Simplex integration', () => {
         await server.externalServices.simplex.simplexPaymentRequest(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Simplex request failed with error (');
+        err.message.should.equal('Failed to get Simplex payment data');
+      }
+    });
+
+    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.simplex.request = fakeRequest2;
+      try {
+        await server.externalServices.simplex.simplexPaymentRequest(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Simplex did not return payment data');
       }
     });
 
@@ -477,7 +551,23 @@ describe('Simplex integration', () => {
         await server.externalServices.simplex.simplexSellPaymentRequest(req);
         should.fail('should have thrown');
       } catch (err) {
-        err.message.should.equal('Error');
+        loggerError.callCount.should.equal(1);
+        loggerError.args[0][0].should.contain('Simplex request failed with error (');
+        err.message.should.equal('Failed to initiate Simplex sell payment');
+      }
+    });
+
+    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.simplex.request = fakeRequest2;
+      try {
+        await server.externalServices.simplex.simplexSellPaymentRequest(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Simplex did not return sell data');
       }
     });