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

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,466 @@ 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('#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;