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

package/test/expressapp.test.ts

@@ -10,6 +10,7 @@ import config from '../src/config';
 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';
 
 const Defaults = Common.Defaults;
 const should = chai.should();
@@ -483,6 +484,175 @@ describe('ExpressApp', function() {
         });
         
       });
+      describe('Aave service routes', function() {
+        it('/v1/service/aave/userAccountData', function(done) {
+          const server = {
+            getAaveUserAccountData: sinon.stub().resolves({ totalCollateralBase: '1000', healthFactor: '2.0' }),
+          };
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getInstance').returns(server);
+          start(ExpressApp, function() {
+            const requestOptions = {
+              url: testHost + ':' + testPort + config.basePath + '/v1/service/aave/userAccountData',
+              method: 'post',
+              json: { chain: 'eth', network: 'mainnet', address: '0x123', version: 'v3' }
+            };
+            request(requestOptions, function(err, res, body) {
+              should.not.exist(err);
+              res.statusCode.should.equal(200);
+              body.totalCollateralBase.should.equal('1000');
+              body.healthFactor.should.equal('2.0');
+              done();
+            });
+          });
+        });
+
+        it('/v1/service/aave/userAccountData should fail with missing arguments', function(done) {
+          const server = {
+            getAaveUserAccountData: sinon.stub().rejects(new ClientError('getAaveUserAccountData request missing arguments')),
+          };
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getInstance').returns(server);
+          start(ExpressApp, function() {
+            const requestOptions = {
+              url: testHost + ':' + testPort + config.basePath + '/v1/service/aave/userAccountData',
+              method: 'post',
+              json: { version: 'v3' }
+            };
+            request(requestOptions, function(err, res) {
+              should.not.exist(err);
+              res.statusCode.should.equal(400);
+              done();
+            });
+          });
+        });
+
+        it('/v1/service/aave/reserveData', function(done) {
+          const server = {
+            getAaveReserveData: sinon.stub().resolves({ currentVariableBorrowRate: '35000000' }),
+          };
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getInstance').returns(server);
+          start(ExpressApp, function() {
+            const requestOptions = {
+              url: testHost + ':' + testPort + config.basePath + '/v1/service/aave/reserveData',
+              method: 'post',
+              json: { chain: 'eth', network: 'mainnet', asset: '0xabc', version: 'v3' }
+            };
+            request(requestOptions, function(err, res, body) {
+              should.not.exist(err);
+              res.statusCode.should.equal(200);
+              body.currentVariableBorrowRate.should.equal('35000000');
+              done();
+            });
+          });
+        });
+
+        it('/v1/service/aave/reserveData should fail with missing arguments', function(done) {
+          const server = {
+            getAaveReserveData: sinon.stub().rejects(new ClientError('getAaveReserveData request missing arguments')),
+          };
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getInstance').returns(server);
+          start(ExpressApp, function() {
+            const requestOptions = {
+              url: testHost + ':' + testPort + config.basePath + '/v1/service/aave/reserveData',
+              method: 'post',
+              json: { version: 'v3' }
+            };
+            request(requestOptions, function(err, res) {
+              should.not.exist(err);
+              res.statusCode.should.equal(400);
+              done();
+            });
+          });
+        });
+
+        it('/v1/service/aave/reserveTokensAddresses', function(done) {
+          const server = {
+            getAaveReserveTokensAddresses: sinon.stub().resolves({ variableDebtTokenAddress: '0xdef' }),
+          };
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getInstance').returns(server);
+          start(ExpressApp, function() {
+            const requestOptions = {
+              url: testHost + ':' + testPort + config.basePath + '/v1/service/aave/reserveTokensAddresses',
+              method: 'post',
+              json: { chain: 'eth', network: 'mainnet', asset: '0xabc', version: 'v3' }
+            };
+            request(requestOptions, function(err, res, body) {
+              should.not.exist(err);
+              res.statusCode.should.equal(200);
+              body.variableDebtTokenAddress.should.equal('0xdef');
+              done();
+            });
+          });
+        });
+
+        it('/v1/service/aave/reserveTokensAddresses should fail with missing arguments', function(done) {
+          const server = {
+            getAaveReserveTokensAddresses: sinon.stub().rejects(new ClientError('getAaveReserveTokensAddresses request missing arguments')),
+          };
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getInstance').returns(server);
+          start(ExpressApp, function() {
+            const requestOptions = {
+              url: testHost + ':' + testPort + config.basePath + '/v1/service/aave/reserveTokensAddresses',
+              method: 'post',
+              json: { version: 'v3' }
+            };
+            request(requestOptions, function(err, res) {
+              should.not.exist(err);
+              res.statusCode.should.equal(400);
+              done();
+            });
+          });
+        });
+      });
+
+      describe('Token allowance', function() {
+        it('/v1/token/allowance', function(done) {
+          const server = {
+            getTokenAllowance: sinon.stub().resolves(5000000),
+          };
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getInstance').returns(server);
+          start(ExpressApp, function() {
+            const requestOptions = {
+              url: testHost + ':' + testPort + config.basePath + '/v1/token/allowance',
+              method: 'post',
+              json: { chain: 'eth', network: 'mainnet', tokenAddress: '0xtoken', ownerAddress: '0xowner', spenderAddress: '0xspender' }
+            };
+            request(requestOptions, function(err, res, body) {
+              should.not.exist(err);
+              res.statusCode.should.equal(200);
+              body.should.equal(5000000);
+              done();
+            });
+          });
+        });
+
+        it('/v1/token/allowance should fail with missing arguments', function(done) {
+          const server = {
+            getTokenAllowance: sinon.stub().rejects(new ClientError('getTokenAllowance request missing arguments')),
+          };
+          sandbox.stub(WalletService, 'initialize').callsArg(1);
+          sandbox.stub(WalletService, 'getInstance').returns(server);
+          start(ExpressApp, function() {
+            const requestOptions = {
+              url: testHost + ':' + testPort + config.basePath + '/v1/token/allowance',
+              method: 'post',
+              json: {}
+            };
+            request(requestOptions, function(err, res) {
+              should.not.exist(err);
+              res.statusCode.should.equal(400);
+              done();
+            });
+          });
+        });
+      });
+
       describe('Clear cache', function() {
         it('/v1/clearcache/', function(done) {
           const resolveStub = sinon.stub().callsFake( () => { return Promise.resolve(true);});

package/test/integration/server.test.ts

@@ -7801,6 +7801,339 @@ describe('Wallet service', function() {
     });
   });
 
+  describe('#prepareTx (deferred nonce)', 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 create txp with nonce=null when deferNonce is true', async function() {
+      const txOpts = {
+        outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      };
+      const txp = await util.promisify(server.createTx).call(server, txOpts);
+      should.exist(txp);
+      txp.deferNonce.should.be.true;
+      should.not.exist(txp.nonce);
+    });
+
+    it('should create txp with nonce when deferNonce is absent', async function() {
+      const txOpts = {
+        outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr
+      };
+      const txp = await util.promisify(server.createTx).call(server, txOpts);
+      should.exist(txp);
+      should.not.exist(txp.deferNonce);
+      txp.nonce.should.equal('5');
+    });
+
+    it('should publish a deferred-nonce txp and save prePublishRaw', async function() {
+      const txOpts = {
+        outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      };
+      const txp = await util.promisify(server.createTx).call(server, txOpts);
+      should.not.exist(txp.nonce);
+
+      const publishOpts = helpers.getProposalSignatureOpts(txp, TestData.copayers[0].privKey_1H_0);
+      const published = await util.promisify(server.publishTx).call(server, publishOpts);
+      should.exist(published);
+      published.status.should.equal('pending');
+      published.deferNonce.should.be.true;
+      should.exist(published.prePublishRaw);
+    });
+
+    it('should assign nonce to a deferred-nonce txp', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '10');
+
+      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);
+
+      const result = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: txp.id
+      });
+      should.exist(result);
+      result.nonce.should.equal(10);
+    });
+
+    it('should return txp as-is if deferNonce is not set', 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 result = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: txp.id
+      });
+      result.nonce.should.equal('5');
+    });
+
+    it('should fail for non-existent txp', function(done) {
+      server.prepareTx({ txProposalId: 'nonexistent' }, function(err) {
+        should.exist(err);
+        err.message.should.contain('not found');
+        done();
+      });
+    });
+
+    it('should calculate gap-free nonce skipping pending txp nonces', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '5');
+
+      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');
+
+      const txp2 = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 2000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      }, TestData.copayers[0].privKey_1H_0);
+      should.not.exist(txp2.nonce);
+
+      const result = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: txp2.id
+      });
+      result.nonce.should.equal(6);
+    });
+
+    it('should assign sequential nonces for multiple deferred txps', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '0');
+
+      const txps = [];
+      for (let i = 0; i < 3; i++) {
+        const txp = await helpers.createAndPublishTx(server, {
+          outputs: [{ toAddress: ETH_ADDR, amount: 1000 * (i + 1) }],
+          feePerKb: 123e2,
+          from: fromAddr,
+          deferNonce: true
+        }, TestData.copayers[0].privKey_1H_0);
+        txps.push(txp);
+      }
+
+      const results = [];
+      for (const txp of txps) {
+        const result = await util.promisify(server.prepareTx).call(server, {
+          txProposalId: txp.id
+        });
+        results.push(result);
+      }
+
+      results[0].nonce.should.equal(0);
+      results[1].nonce.should.equal(1);
+      results[2].nonce.should.equal(2);
+    });
+
+    it('should handle mix of normal and deferred-nonce txps', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '3');
+
+      const normalTxp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 1000 }],
+        feePerKb: 123e2,
+        from: fromAddr
+      }, TestData.copayers[0].privKey_1H_0);
+      normalTxp.nonce.should.equal('3');
+
+      const deferred1 = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 2000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      }, TestData.copayers[0].privKey_1H_0);
+
+      const deferred2 = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 3000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      }, TestData.copayers[0].privKey_1H_0);
+
+      const result1 = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: deferred1.id
+      });
+      result1.nonce.should.equal(4);
+
+      const result2 = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: deferred2.id
+      });
+      result2.nonce.should.equal(5);
+    });
+
+    it('should sign a deferred-nonce txp after assignNonce', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '7');
+      helpers.stubBroadcast('txid123');
+
+      const txp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_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');
+    });
+
+    it('should not trigger nonce conflict for deferred txps with null nonce', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '5');
+
+      const normalTxp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 1000 }],
+        feePerKb: 123e2,
+        from: fromAddr
+      }, TestData.copayers[0].privKey_1H_0);
+      normalTxp.nonce.should.equal('5');
+
+      const deferredTxp = await helpers.createAndPublishTx(server, {
+        outputs: [{ toAddress: ETH_ADDR, amount: 2000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      }, TestData.copayers[0].privKey_1H_0);
+
+      const withNonce = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: deferredTxp.id
+      });
+      withNonce.nonce.should.equal(6);
+
+      const sigs1 = helpers.clientSign(normalTxp, TestData.copayers[0].xPrivKey_44H_0H_0H);
+      const signed1 = await util.promisify(server.signTx).call(server, {
+        txProposalId: normalTxp.id,
+        signatures: sigs1
+      });
+      signed1.status.should.equal('accepted');
+      helpers.stubBroadcast(signed1.txid);
+      await util.promisify(server.broadcastTx).call(server, { txProposalId: normalTxp.id });
+
+      const fetchedDeferred = await util.promisify(server.getTx).call(server, { txProposalId: deferredTxp.id });
+      const sigs2 = helpers.clientSign(fetchedDeferred, TestData.copayers[0].xPrivKey_44H_0H_0H);
+      const signed2 = await util.promisify(server.signTx).call(server, {
+        txProposalId: deferredTxp.id,
+        signatures: sigs2
+      });
+      signed2.status.should.equal('accepted');
+    });
+
+    it('should complete full lifecycle for a deferred-nonce txp', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '42');
+
+      const txOpts = {
+        outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+        feePerKb: 123e2,
+        from: fromAddr,
+        deferNonce: true
+      };
+      const created = await util.promisify(server.createTx).call(server, txOpts);
+      created.isTemporary().should.be.true;
+      created.deferNonce.should.be.true;
+      should.not.exist(created.nonce);
+
+      const publishOpts = helpers.getProposalSignatureOpts(created, TestData.copayers[0].privKey_1H_0);
+      const published = await util.promisify(server.publishTx).call(server, publishOpts);
+      published.status.should.equal('pending');
+      should.exist(published.prePublishRaw);
+
+      const withNonce = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: created.id
+      });
+      withNonce.nonce.should.equal(42);
+
+      const fetched = await util.promisify(server.getTx).call(server, { txProposalId: created.id });
+      const signatures = helpers.clientSign(fetched, TestData.copayers[0].xPrivKey_44H_0H_0H);
+      const signed = await util.promisify(server.signTx).call(server, {
+        txProposalId: created.id,
+        signatures
+      });
+      signed.status.should.equal('accepted');
+
+      helpers.stubBroadcast(signed.txid);
+      const broadcasted = await util.promisify(server.broadcastTx).call(server, {
+        txProposalId: created.id
+      });
+      broadcasted.status.should.equal('broadcasted');
+      should.exist(broadcasted.txid);
+    });
+
+    it('should handle bulk sign scenario (3 deferred txps signed sequentially)', async function() {
+      blockchainExplorer.getTransactionCount = sinon.stub().callsArgWith(1, null, '10');
+
+      const txps = [];
+      for (let i = 0; i < 3; i++) {
+        const txp = await helpers.createAndPublishTx(server, {
+          outputs: [{ toAddress: ETH_ADDR, amount: 1000 * (i + 1) }],
+          feePerKb: 123e2,
+          from: fromAddr,
+          deferNonce: true
+        }, TestData.copayers[0].privKey_1H_0);
+        txps.push(txp);
+      }
+
+      const assignedNonces = [];
+      for (let i = 0; i < txps.length; i++) {
+        const withNonce = await util.promisify(server.prepareTx).call(server, {
+          txProposalId: txps[i].id
+        });
+        withNonce.nonce.should.equal(10 + i);
+        assignedNonces.push(withNonce.nonce);
+      }
+
+      assignedNonces.should.deep.equal([10, 11, 12]);
+    });
+
+    it('should return txp with nonce set (extensibility baseline)', 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);
+
+      const result = await util.promisify(server.prepareTx).call(server, {
+        txProposalId: txp.id
+      });
+      result.nonce.should.be.a('number');
+      result.nonce.should.equal(5);
+      // future: result.gasPrice, result.maxFee would also be set here
+    });
+  });
+
   describe('#broadcastTx & #broadcastRawTx', function() {
     let server: WalletService;
     let wallet: Model.Wallet;

package/test/v8.test.ts

@@ -247,6 +247,109 @@ describe('V8', () => {
 
   });
 
+  describe('#getAaveUserAccountData', () => {
+    it('should get aave user account data', (done) => {
+      const fakeRequest = {
+        get: sinon.stub().resolves('{"totalCollateralBase":"1000","totalDebtBase":"500","availableBorrowsBase":"200","currentLiquidationThreshold":"8000","ltv":"7500","healthFactor":"2.0"}'),
+      };
+
+      const be = new V8({
+        chain: 'eth',
+        network: 'livenet',
+        url: 'http://dummy/',
+        apiPrefix: 'dummyPath',
+        userAgent: 'testAgent',
+        request: fakeRequest,
+      });
+
+      be.getAaveUserAccountData({ address: '0x123', version: 'v3' }, (err, accountData) => {
+        should.not.exist(err);
+        should.exist(accountData);
+        accountData.totalCollateralBase.should.equal('1000');
+        accountData.totalDebtBase.should.equal('500');
+        accountData.availableBorrowsBase.should.equal('200');
+        accountData.currentLiquidationThreshold.should.equal('8000');
+        accountData.ltv.should.equal('7500');
+        accountData.healthFactor.should.equal('2.0');
+        return done();
+      });
+    });
+  });
+
+  describe('#getAaveReserveData', () => {
+    it('should get aave reserve data', (done) => {
+      const fakeRequest = {
+        get: sinon.stub().resolves('{"currentVariableBorrowRate":"35000000000000000000000000"}'),
+      };
+
+      const be = new V8({
+        chain: 'eth',
+        network: 'livenet',
+        url: 'http://dummy/',
+        apiPrefix: 'dummyPath',
+        userAgent: 'testAgent',
+        request: fakeRequest,
+      });
+
+      be.getAaveReserveData({ asset: '0xabc', version: 'v3' }, (err, reserveData) => {
+        should.not.exist(err);
+        should.exist(reserveData);
+        reserveData.currentVariableBorrowRate.should.equal('35000000000000000000000000');
+        return done();
+      });
+    });
+  });
+
+  describe('#getAaveReserveTokensAddresses', () => {
+    it('should get aave reserve tokens addresses', (done) => {
+      const fakeRequest = {
+        get: sinon.stub().resolves('{"variableDebtTokenAddress":"0xdef456"}'),
+      };
+
+      const be = new V8({
+        chain: 'eth',
+        network: 'livenet',
+        url: 'http://dummy/',
+        apiPrefix: 'dummyPath',
+        userAgent: 'testAgent',
+        request: fakeRequest,
+      });
+
+      be.getAaveReserveTokensAddresses({ asset: '0xabc', version: 'v3' }, (err, tokensAddresses) => {
+        should.not.exist(err);
+        should.exist(tokensAddresses);
+        tokensAddresses.variableDebtTokenAddress.should.equal('0xdef456');
+        return done();
+      });
+    });
+  });
+
+  describe('#getTokenAllowance', () => {
+    it('should get token allowance', (done) => {
+      const fakeRequest = {
+        get: sinon.stub().resolves('5000000'),
+      };
+
+      const be = new V8({
+        chain: 'eth',
+        network: 'livenet',
+        url: 'http://dummy/',
+        apiPrefix: 'dummyPath',
+        userAgent: 'testAgent',
+        request: fakeRequest,
+      });
+
+      be.getTokenAllowance(
+        { tokenAddress: '0xtoken', ownerAddress: '0xowner', spenderAddress: '0xspender' },
+        (err, allowance) => {
+          should.not.exist(err);
+          should.exist(allowance);
+          allowance.should.equal(5000000);
+          return done();
+        }
+      );
+    });
+  });
 
   describe('#broadcast', () => {
     it('should broadcast a TX', (done) => {