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

package/test/chain/eth.test.ts

@@ -19,6 +19,76 @@ describe('Chain ETH', function() {
     x.address.should.equal('0x01');
   });
 
+  describe('#onTx', function() {
+    const token = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
+    const sender = '0xC877cBCF020A8AA259A1Efab1559B2A3A7259086';
+    const recipient = '0x37D3bCDA9d7d5Dc41e32DAd77a5BA89a77aA8BD0';
+    const multisig = '0x9527a556f0D9AA753dE0D1f9Ad024a17dd281B1D';
+    // a tx event as bitcore-node emits it to the wallets room
+    const tx = (fields = {}) => ({ chain: 'ETH', network: 'mainnet', txid: '0x01', to: token, from: sender, value: 0, ...fields });
+    // effects as bitcore-node builds them
+    const erc20 = { type: 'ERC20:transfer', to: recipient, from: sender, amount: '1000000', contractAddress: token, callStack: '' };
+    const internal = { to: recipient, from: sender, amount: '2000', callStack: '0' };
+    const multisigEffect = type => ({ type, to: recipient, from: sender, amount: '3000', contractAddress: multisig, callStack: '' });
+
+    it('notifies the tx recipient and value for a tx without effects', function() {
+      ChainService.onTx('eth', tx({ to: recipient, value: 5000 })).should.deep.equal({
+        txid: '0x01',
+        out: { address: recipient, amount: 5000, tokenAddress: undefined, multisigContractAddress: undefined }
+      });
+      ChainService.onTx('eth', tx({ to: recipient, value: 5000, effects: [] })).out.should.deep.equal({
+        address: recipient, amount: 5000, tokenAddress: undefined, multisigContractAddress: undefined
+      });
+    });
+
+    it('notifies the recipient of an internal value transfer', function() {
+      ChainService.onTx('eth', tx({ effects: [internal] })).out.should.deep.equal({
+        address: recipient, amount: '2000', tokenAddress: undefined, multisigContractAddress: undefined
+      });
+    });
+
+    for (const type of ['MULTISIG:confirmTransaction', 'MULTISIG:submitTransaction']) {
+      it(`notifies the recipient of a ${type} with its multisig contract`, function() {
+        ChainService.onTx('eth', tx({ effects: [internal, multisigEffect(type)] })).out.should.deep.equal({
+          address: recipient, amount: '3000', tokenAddress: undefined, multisigContractAddress: multisig
+        });
+      });
+    }
+
+    it('prefers a multisig effect to an ERC20 transfer', function() {
+      ChainService.onTx('eth', tx({ effects: [erc20, multisigEffect('MULTISIG:submitTransaction')] })).out.should.deep.equal({
+        address: recipient, amount: '3000', tokenAddress: undefined, multisigContractAddress: multisig
+      });
+    });
+
+    it('falls back to the tx recipient for effects it does not know', function() {
+      const other = { type: 'OTHER:call', to: recipient, from: sender, amount: '1', contractAddress: token, callStack: '' };
+      ChainService.onTx('eth', tx({ effects: [other] })).out.should.deep.equal({
+        address: token, amount: 0, tokenAddress: undefined, multisigContractAddress: undefined
+      });
+    });
+
+    it('handles MATIC txs the same way', function() {
+      ChainService.onTx('matic', tx({ chain: 'MATIC', to: recipient, value: 5000 })).out.should.deep.equal({
+        address: recipient, amount: 5000, tokenAddress: undefined, multisigContractAddress: undefined
+      });
+    });
+
+    it('notifies the token recipient, amount and token of an ERC20 transfer', function() {
+      ChainService.onTx('eth', tx({ effects: [erc20] })).should.deep.equal({
+        txid: '0x01',
+        out: { address: recipient, amount: '1000000', tokenAddress: token, multisigContractAddress: undefined }
+      });
+      ChainService.onTx('matic', tx({ chain: 'MATIC', effects: [erc20] })).out.tokenAddress.should.equal(token);
+    });
+
+    it('prefers an ERC20 transfer to an internal value transfer', function() {
+      ChainService.onTx('eth', tx({ effects: [internal, erc20] })).out.should.deep.equal({
+        address: recipient, amount: '1000000', tokenAddress: token, multisigContractAddress: undefined
+      });
+    });
+  });
+
   describe('#selectTxInputs', function() {
     it('should reject a total that a number rounds down to the balance', function(done) {
       const server = {

package/test/chain/sol.test.ts

@@ -27,7 +27,7 @@ describe('Chain SOL', function() {
             getRentMinimum: (_space, cb) => cb(null, Defaults.MIN_SOL_BALANCE)
           }),
           getPendingTxs: (_opts, cb) => cb(null, c.txps),
-          storage: { fetchAddresses: (_walletId, cb) => cb(null, []) }
+          storage: { fetchAddressesPage: (_walletId, _opts, cb) => cb(null, []) }
         };
         const wallet = { chain: 'sol', network: 'livenet' };
 

package/test/chain/xrp.test.ts

@@ -20,7 +20,7 @@ describe('Chain XRP', function() {
           getReserve: cb => cb(null, 1000000)
         }),
         getPendingTxs: (_opts, cb) => cb(null, [{ amount: '3000000', fee: '12' }]),
-        storage: { fetchAddresses: (_walletId, cb) => cb(null, []) }
+        storage: { fetchAddressesPage: (_walletId, _opts, cb) => cb(null, []) }
       };
       const wallet = { chain: 'xrp', network: 'livenet' };
 

package/test/expressapp.test.ts

@@ -11,6 +11,8 @@ import { Common } from '../src/lib/common';
 import { WalletService } from '../src/lib/server';
 import { ExpressApp } from '../src/lib/expressapp';
 import { ClientError } from '../src/lib/errors/clienterror';
+import { BitcoreLib } from '@bitpay-labs/crypto-wallet-core';
+import * as TestData from './testdata';
 
 const Defaults = Common.Defaults;
 const should = chai.should();
@@ -762,6 +764,148 @@ describe('ExpressApp', function() {
         });
       });
 
+      describe('/v1/wallets/exist', function() {
+        const idA = 'a'.repeat(64);
+        const idB = 'b'.repeat(64);
+        const idC = 'c'.repeat(64);
+        let storage;
+
+        function sign(message) {
+          const hash = Common.Utils.hashMessage(message, false);
+          return BitcoreLib.crypto.ECDSA.sign(hash, new BitcoreLib.PrivateKey(TestData.keyPair.priv), { endian: 'little' }).toString();
+        }
+
+        // posts each body in turn, and calls back with each response's status and body
+        function postEach(bodies, cb) {
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getStorage').returns(storage);
+          start(ExpressApp, function() {
+            const results = [];
+            (function next() {
+              if (results.length === bodies.length) {
+                return cb(null, results);
+              }
+              request({
+                url: testHost + ':' + testPort + config.basePath + '/v1/wallets/exist',
+                method: 'post',
+                json: true,
+                body: bodies[results.length]
+              }, function(err, res, body) {
+                if (err) {
+                  return cb(err);
+                }
+                results.push({ status: res.statusCode, body });
+                next();
+              });
+            })();
+          });
+        }
+
+        function post(body, cb) {
+          postEach([body], (err, results) => (err ? cb(err) : cb(null, { statusCode: results[0].status }, results[0].body)));
+        }
+
+        beforeEach(function() {
+          const copayer = { requestPubKeys: [{ key: TestData.keyPair.pub }] };
+          storage = {
+            fetchCopayerLookup: sinon.stub().callsFake(async id => (id === idA || id === idB ? copayer : undefined))
+          };
+        });
+
+        it('returns the copayers whose signature verifies against their request key', function(done) {
+          post({
+            copayers: [
+              { copayerId: idA, signature: sign(idA) },
+              { copayerId: idB, signature: sign(idA) },
+              { copayerId: idC, signature: sign(idC) }
+            ]
+          }, function(err, res, body) {
+            should.not.exist(err);
+            res.statusCode.should.equal(200);
+            body.should.deep.equal([idA]);
+            storage.fetchCopayerLookup.args.should.deep.equal([[idA], [idB], [idC]]);
+            done();
+          });
+        });
+
+        it('returns no copayers when given none to check', function(done) {
+          postEach([
+            {},
+            { copayers: null },
+            { copayers: idA },
+            { copayers: { copayerId: idA, signature: sign(idA) } },
+            { copayers: [] }
+          ], function(err, results) {
+            should.not.exist(err);
+            results.should.deep.equal(Array(5).fill({ status: 200, body: [] }));
+            storage.fetchCopayerLookup.callCount.should.equal(0);
+            done();
+          });
+        });
+
+        it('does not verify a copayer whose signature is not a string', function(done) {
+          post({
+            copayers: [
+              { copayerId: idA, signature: 1 },
+              { copayerId: idA, signature: [sign(idA)] },
+              { copayerId: idB, signature: {} },
+              { copayerId: idB }
+            ]
+          }, function(err, res, body) {
+            should.not.exist(err);
+            res.statusCode.should.equal(200);
+            body.should.deep.equal([]);
+            storage.fetchCopayerLookup.callCount.should.equal(4);
+            done();
+          });
+        });
+
+        it('treats a copayer that fails to load as not found', function(done) {
+          storage.fetchCopayerLookup.withArgs(idB).rejects(new Error('lookup failed'));
+          post({
+            copayers: [
+              { copayerId: idA, signature: sign(idA) },
+              { copayerId: idB, signature: sign(idB) }
+            ]
+          }, function(err, res, body) {
+            should.not.exist(err);
+            res.statusCode.should.equal(200);
+            body.should.deep.equal([idA]);
+            done();
+          });
+        });
+
+        it('looks up only copayer ids that are strings', function(done) {
+          post({
+            copayers: [
+              { copayerId: { id: idB }, signature: sign(idB) },
+              { copayerId: [idB], signature: sign(idB) },
+              { copayerId: 1, signature: sign(idB) },
+              { signature: sign(idB) },
+              { copayerId: idA, signature: sign(idA) }
+            ]
+          }, function(err, res, body) {
+            should.not.exist(err);
+            res.statusCode.should.equal(200);
+            body.should.deep.equal([idA]);
+            storage.fetchCopayerLookup.args.should.deep.equal([[idA]]);
+            done();
+          });
+        });
+
+        it('skips copayers that are not objects', function(done) {
+          post({
+            copayers: [null, idB, { copayerId: idA, signature: sign(idA) }]
+          }, function(err, res, body) {
+            should.not.exist(err);
+            res.statusCode.should.equal(200);
+            body.should.deep.equal([idA]);
+            storage.fetchCopayerLookup.args.should.deep.equal([[idA]]);
+            done();
+          });
+        });
+      });
+
       describe('Clear cache', function() {
         it('/v1/clearcache/', function(done) {
           const resolveStub = sinon.stub().callsFake( () => { return Promise.resolve(true);});