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

package/test/chain/sol.test.ts

@@ -1,8 +1,11 @@
 'use strict';
 
 import * as chai from 'chai';
+import sinon from 'sinon';
 import { ChainService } from '../../src/lib/chain';
 import { Defaults } from '../../src/lib/common/defaults';
+import { ClientError } from '../../src/lib/errors/clienterror';
+import { TxProposal } from '../../src/lib/model/txproposal';
 
 const should = chai.should();
 
@@ -45,4 +48,182 @@ describe('Chain SOL', function() {
       });
     }
   });
+
+  describe('#getFee', function() {
+    const sol = ChainService.get('sol');
+    const getFee = async opts => (await sol.getFee(null, null, opts)).fee;
+    const outputs = n => Array.from({ length: n }, () => ({ toAddress: 'addr', amount: 1 }));
+
+    it('should be the signature fee when no priority fee is set', async function() {
+      (await getFee({ outputs: outputs(1) })).should.equal(5000);
+      (await getFee({ outputs: outputs(1), numSignatures: 2 })).should.equal(10000);
+      (await getFee({ outputs: outputs(1), computeUnits: 300000 })).should.equal(5000);
+    });
+
+    it('should add the priority fee for the given compute unit limit', async function() {
+      // 50,000 micro-lamports/CU * 300,000 CU = 15,000 lamports
+      (await getFee({ outputs: outputs(1), priorityFee: 50000, computeUnits: 300000 })).should.equal(5000 + 15000);
+    });
+
+    it('should round the priority fee up to a whole lamport', async function() {
+      // 1,001 micro-lamports/CU * 1,000 CU = 1,001,000 micro-lamports = 1.001 lamports
+      (await getFee({ outputs: outputs(1), priorityFee: 1001, computeUnits: 1000 })).should.equal(5000 + 2);
+    });
+
+    it('should raise the priority fee to the minimum CWC applies', async function() {
+      // 1 micro-lamport/CU is raised to 1,000; 1,000 * 200,000 CU = 200 lamports
+      (await getFee({ outputs: outputs(1), priorityFee: 1, computeUnits: 200000 })).should.equal(5000 + 200);
+    });
+
+    it('should use the default compute unit limit per instruction without computeUnits', async function() {
+      // 200,000 CU per transfer instruction
+      (await getFee({ outputs: outputs(1), priorityFee: 10000 })).should.equal(5000 + 2000);
+      (await getFee({ outputs: outputs(3), priorityFee: 10000 })).should.equal(5000 + 6000);
+      // the memo is one more instruction
+      (await getFee({ outputs: outputs(1), memo: 'refund', priorityFee: 10000 })).should.equal(5000 + 4000);
+    });
+
+    it('should cap the default compute unit limit at the per-transaction maximum', async function() {
+      // 12 transfers would be 2.4M CU, capped at 1.4M
+      (await getFee({ outputs: outputs(12), priorityFee: 10000 })).should.equal(5000 + 14000);
+    });
+  });
+
+  describe('#selectTxInputs', function() {
+    const sol = ChainService.get('sol');
+    const wallet = { chain: 'sol', network: 'livenet' };
+    const fee = 5000;
+    let checkTxCalled;
+
+    beforeEach(function() {
+      checkTxCalled = false;
+      sinon.stub(sol, 'checkTx').callsFake(() => {
+        checkTxCalled = true;
+        return null;
+      });
+    });
+
+    afterEach(function() {
+      sinon.restore();
+    });
+
+    it('should reject a total that a number rounds down to the balance', function(done) {
+      const balance = 9007199254740992 + Defaults.MIN_SOL_BALANCE;
+      const server = {
+        getBalance: (_opts, cb) => cb(null, { totalAmount: balance, availableAmount: balance })
+      };
+      const txp = TxProposal.fromObj({
+        version: 3,
+        id: '75c34f49-1ed6-255f-e9fd-0c71ae75ed1e',
+        walletId: '1',
+        creatorId: '1',
+        coin: 'sol',
+        chain: 'sol',
+        network: 'livenet',
+        from: '8WyoNvKsmfdG6zrbzNBVN8DETyLra3ond61saU9C52YR',
+        fee: 5000,
+        status: 'pending',
+        actions: [],
+        outputs: [
+          { toAddress: 'F7FknkRckx4yvA3Gexnx1H3nwPxndMxVt58BwAzEQhcY', amount: '9007199254740992' },
+          { toAddress: 'F7FknkRckx4yvA3Gexnx1H3nwPxndMxVt58BwAzEQhcY', amount: '1' }
+        ]
+      } as any);
+
+      ChainService.get('sol').selectTxInputs(server as any, txp, {} as any, {}, err => {
+        should.exist(err);
+        err.code.should.equal('INSUFFICIENT_FUNDS');
+        done();
+      });
+    });
+
+    // Token balance is returned when tokenAddress is passed, native SOL balance otherwise
+    const makeServer = ({ native, token }: { native: any; token?: any }) => ({
+      getBalance: (opts, cb) => cb(null, opts.tokenAddress ? token : native)
+    });
+    const balance = (total, available) => ({ totalAmount: total, availableAmount: available });
+    const makeTxp = amount => ({ fee, getTotalAmount: () => amount, getTotalAmountBigInt: () => BigInt(amount) });
+
+    describe('SPL token', function() {
+      const opts = { tokenAddress: 'mint' };
+
+      it('should fail with INSUFFICIENT_SOL_FEE if the wallet has no SOL for the fee', function(done) {
+        const server = makeServer({ token: balance(1e6, 1e6), native: balance(0, 0) });
+        sol.selectTxInputs(server as any, makeTxp(5e5) as any, wallet as any, opts, err => {
+          should.exist(err);
+          err.should.be.instanceof(ClientError);
+          err.code.should.equal('INSUFFICIENT_SOL_FEE');
+          err.message.should.equal('Your linked SOL wallet does not have enough SOL for fee. RequiredFee: 5000');
+          err.messageData.should.deep.equal({ requiredFee: fee });
+          checkTxCalled.should.equal(false);
+          done();
+        });
+      });
+
+      it('should fail with LOCKED_SOL_FEE if the SOL for the fee is locked', function(done) {
+        const server = makeServer({ token: balance(1e6, 1e6), native: balance(1e7, 1000) });
+        sol.selectTxInputs(server as any, makeTxp(5e5) as any, wallet as any, opts, err => {
+          should.exist(err);
+          err.should.be.instanceof(ClientError);
+          err.code.should.equal('LOCKED_SOL_FEE');
+          err.messageData.should.deep.equal({ requiredFee: fee });
+          checkTxCalled.should.equal(false);
+          done();
+        });
+      });
+
+      it('should still fail with INSUFFICIENT_FUNDS when the token balance is short', function(done) {
+        const server = makeServer({ token: balance(1e5, 1e5), native: balance(1e9, 1e9) });
+        sol.selectTxInputs(server as any, makeTxp(5e5) as any, wallet as any, opts, err => {
+          should.exist(err);
+          err.code.should.equal('INSUFFICIENT_FUNDS');
+          done();
+        });
+      });
+
+      it('should pass when both the token and the SOL fee are covered', function(done) {
+        const server = makeServer({ token: balance(1e6, 1e6), native: balance(1e9, 1e9) });
+        sol.selectTxInputs(server as any, makeTxp(5e5) as any, wallet as any, opts, err => {
+          should.not.exist(err);
+          checkTxCalled.should.equal(true);
+          done();
+        });
+      });
+    });
+
+    describe('native SOL', function() {
+      it('should fail with INSUFFICIENT_FUNDS_FOR_FEE if the amount fits but the fee does not', function(done) {
+        const amount = 1e9;
+        const server = makeServer({ native: balance(amount + Defaults.MIN_SOL_BALANCE, amount) });
+        sol.selectTxInputs(server as any, makeTxp(amount) as any, wallet as any, {}, err => {
+          should.exist(err);
+          err.should.be.instanceof(ClientError);
+          err.code.should.equal('INSUFFICIENT_FUNDS_FOR_FEE');
+          err.message.should.equal('Insufficient funds for fee. RequiredFee: 5000');
+          err.messageData.should.deep.equal({ requiredFee: fee });
+          checkTxCalled.should.equal(false);
+          done();
+        });
+      });
+
+      it('should still fail with INSUFFICIENT_FUNDS when the amount does not fit', function(done) {
+        const server = makeServer({ native: balance(1e9, 1e9) });
+        sol.selectTxInputs(server as any, makeTxp(2e9) as any, wallet as any, {}, err => {
+          should.exist(err);
+          err.code.should.equal('INSUFFICIENT_FUNDS');
+          done();
+        });
+      });
+
+      it('should pass when the amount and fee are covered', function(done) {
+        const amount = 1e9;
+        const server = makeServer({ native: balance(2e9, amount + fee) });
+        sol.selectTxInputs(server as any, makeTxp(amount) as any, wallet as any, {}, err => {
+          should.not.exist(err);
+          checkTxCalled.should.equal(true);
+          done();
+        });
+      });
+    });
+  });
 });

package/test/chain/xrp.test.ts

@@ -4,6 +4,7 @@ import * as chai from 'chai';
 import 'chai/register-should';
 import { ChainService } from '../../src/lib/chain';
 import { ITxProposal, TxProposal } from '../../src/lib/model/txproposal';
+import { Defaults } from '../../src/lib/common/defaults';
 
 const should = chai.should();
 
@@ -61,6 +62,26 @@ describe('Chain XRP', function() {
     });
   });
 
+  describe('#selectTxInputs', function() {
+    const balanceOf = amount => ({
+      getBalance: (_opts, cb) => cb(null, { totalAmount: amount, availableAmount: amount })
+    });
+    const txpOf = amounts => TxProposal.fromObj({
+      ...aTXP(),
+      outputs: amounts.map(amount => ({ ...aTXP().outputs[0], amount }))
+    } as any);
+
+    it('should reject a total that a number rounds down to the balance', function(done) {
+      const balance = 9007199254740992 + Defaults.MIN_XRP_BALANCE;
+
+      ChainService.get('xrp').selectTxInputs(balanceOf(balance) as any, txpOf(['9007199254740992', '1']), {} as any, {}, err => {
+        should.exist(err);
+        err.code.should.equal('INSUFFICIENT_FUNDS');
+        done();
+      });
+    });
+  });
+
   describe('#getBitcoreTx', function() {
     it('should create a valid bitcore TX', function() {
       const txp = TxProposal.fromObj(aTXP()) as TxProposal;

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

@@ -573,6 +573,35 @@ describe('Moonpay integration', () => {
       should.exist(data);
     });
 
+    it('should return the response body if there is one', async () => {
+      const data = await server.externalServices.moonpay.moonpayCancelSellTransaction(req);
+      data.should.equal('data');
+    });
+
+    it('should return success true without leaking the response if there is no body', async () => {
+      const fakeRequest2 = {
+        delete: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 204, body: undefined, headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      const data = await server.externalServices.moonpay.moonpayCancelSellTransaction(req);
+      data.should.deep.equal({ success: true });
+    });
+
+    it('should return success false if there is no body and status is not 2xx', async () => {
+      const fakeRequest2 = {
+        delete: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 404, body: '', headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      const data = await server.externalServices.moonpay.moonpayCancelSellTransaction(req);
+      data.should.deep.equal({ success: false });
+    });
+
     it('should return error if delete returns error', async () => {
       const fakeRequest2 = {
         delete: (_url, _opts, _cb) => { return _cb(new Error('Error'), null); },
@@ -641,6 +670,27 @@ describe('Moonpay integration', () => {
       should.exist(data);
     });
 
+    it('should return the response body if there is one', async () => {
+      const data = await server.externalServices.moonpay.moonpayCreateSession(req);
+      data.should.equal('data');
+    });
+
+    it('should throw without leaking the response if there is no session body', async () => {
+      const fakeRequest2 = {
+        post: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 200, body: undefined, headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      try {
+        await server.externalServices.moonpay.moonpayCreateSession(req);
+        should.fail('should have thrown');
+      } catch (err) {
+        err.message.should.equal('Moonpay did not return a session');
+      }
+    });
+
     it('should return error if post returns error', async () => {
       const fakeRequest2 = {
         post: (_url, _opts, _cb) => { return _cb(new Error('Error'), null); },
@@ -723,6 +773,35 @@ describe('Moonpay integration', () => {
       await server.externalServices.moonpay.moonpayRevokeActiveSession(req);
     });
 
+    it('should return the response body if there is one', async () => {
+      const data = await server.externalServices.moonpay.moonpayRevokeActiveSession(req);
+      data.should.equal('data');
+    });
+
+    it('should return success true without leaking the response if there is no body', async () => {
+      const fakeRequest2 = {
+        delete: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 204, body: undefined, headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      const data = await server.externalServices.moonpay.moonpayRevokeActiveSession(req);
+      data.should.deep.equal({ success: true });
+    });
+
+    it('should return success false if there is no body and status is not 2xx', async () => {
+      const fakeRequest2 = {
+        delete: (_url, opts, _cb) => {
+          return _cb(null, { statusCode: 404, body: '', headers: {}, request: { headers: opts.headers } });
+        },
+      };
+
+      server.externalServices.moonpay.request = fakeRequest2;
+      const data = await server.externalServices.moonpay.moonpayRevokeActiveSession(req);
+      data.should.deep.equal({ success: false });
+    });
+
     it('should return error if delete returns error', async () => {
       const fakeRequest2 = {
         delete: (_url, _opts, _cb) => { return _cb(new Error('Error'), null); },

package/test/integration/server.test.ts

@@ -3935,6 +3935,45 @@ describe('Wallet service', function() {
     });
   });
 
+  describe('#createTx token allowance', function() {
+    let server: WalletService;
+    let wallet: Model.Wallet;
+
+    beforeEach(async function() {
+      ({ server, wallet } = await helpers.createAndJoinWallet(1, 1, { coin: 'eth' }));
+      await util.promisify(server.createAddress).call(server, {});
+    });
+
+    it('should reject a total that a number rounds down to the allowance', async function() {
+      const be = helpers.getBlockchainExplorer();
+      be.getBalance = sinon.stub().callsArgWith(1, null, { unconfirmed: 0, confirmed: '1' + '0'.repeat(20), balance: '1' + '0'.repeat(20) });
+      be.getTokenAllowance = sinon.stub().callsArgWith(1, null, '9007199254740992');
+
+      const opts = {
+        outputs: [
+          { toAddress: '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A', amount: '9007199254740992' },
+          { toAddress: '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A', amount: '1' }
+        ],
+        from: '0xE299d49C2cf9BfaFb7C6E861E80bb8c83f961622',
+        tokenAddress: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+        multiSendContractAddress: '0x30e5bfa1e83c9c6f0a4c4bd4a1f0e0d7d0c4d3a2',
+        feePerKb: 25000000000,
+        nonce: 5
+      };
+
+      let error;
+      try {
+        await util.promisify(server.createTx).call(server, opts);
+      } catch (e) {
+        error = e;
+      }
+
+      should.exist(error);
+      error.message.should.contain('Insufficient token allowance');
+      error.message.should.contain('Want: 9007199254740993');
+    });
+  });
+
   const testSet = [
     {
       coin: 'btc',
@@ -8390,6 +8429,66 @@ describe('Wallet service', function() {
       txp.nonce.should.equal('5');
     });
 
+    describe('republishing a txp with mutable tx data', function() {
+      let txp, publishOpts;
+
+      beforeEach(async function() {
+        txp = await util.promisify(server.createTx).call(server, {
+          outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+          feePerKb: 123e2,
+          from: fromAddr,
+          deferNonce: true
+        });
+        publishOpts = helpers.getProposalSignatureOpts(txp, TestData.copayers[0].privKey_1H_0);
+        await util.promisify(server.publishTx).call(server, publishOpts);
+      });
+
+      const setStatus = async status => {
+        const stored = await util.promisify(server.storage.fetchTx).call(server.storage, wallet.id, txp.id);
+        stored.status = status;
+        await util.promisify(server.storage.storeTx).call(server.storage, wallet.id, stored);
+      };
+
+      const republishError = async () => {
+        try {
+          await util.promisify(server.publishTx).call(server, publishOpts);
+        } catch (err) {
+          return err;
+        }
+      };
+
+      it('should republish a pending txp', async function() {
+        should.not.exist(await republishError());
+        const stored = await util.promisify(server.storage.fetchTx).call(server.storage, wallet.id, txp.id);
+        stored.status.should.equal('pending');
+      });
+
+      it('should not republish a broadcasted txp back to pending', async function() {
+        await setStatus('broadcasted');
+        const err = await republishError();
+        should.exist(err);
+        err.code.should.equal('TX_ALREADY_BROADCASTED');
+        const stored = await util.promisify(server.storage.fetchTx).call(server.storage, wallet.id, txp.id);
+        stored.status.should.equal('broadcasted');
+      });
+
+      it('should not republish an accepted txp back to pending', async function() {
+        await setStatus('accepted');
+        const err = await republishError();
+        should.exist(err);
+        err.code.should.equal('TX_NOT_PENDING');
+        const stored = await util.promisify(server.storage.fetchTx).call(server.storage, wallet.id, txp.id);
+        stored.status.should.equal('accepted');
+      });
+
+      it('should not republish a rejected txp back to pending', async function() {
+        await setStatus('rejected');
+        const err = await republishError();
+        should.exist(err);
+        err.code.should.equal('TX_NOT_PENDING');
+      });
+    });
+
     it('should publish a deferred-nonce txp and save prePublishRaw', async function() {
       const txOpts = {
         outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],

package/test/model/txproposal.test.ts

@@ -53,6 +53,28 @@ describe('TxProposal', function() {
     });
   });
 
+  describe('#fromObj', function() {
+    it('should keep the stored output amount type untouched', function() {
+      const stored: any = { ...aTXP(), outputs: [{ ...aTXP().outputs[0], amount: 70000000000000010 }] };
+
+      const txp = TxProposal.fromObj(stored);
+
+      txp.outputs[0].amount.should.equal(70000000000000010);
+    });
+  });
+
+  describe('#getTotalAmountBigInt', function() {
+    it('should keep a total that a number cannot represent', function() {
+      const txp = TxProposal.fromObj({
+        ...aTXP(),
+        outputs: [{ ...aTXP().outputs[0], amount: '9007199254740992' }, { ...aTXP().outputs[1], amount: '1' }]
+      } as any);
+
+      txp.getTotalAmountBigInt().should.equal(9007199254740993n);
+      txp.getTotalAmount().should.equal(9007199254740992);
+    });
+  });
+
   describe('#getTotalAmount', function() {
     it('should compute total amount', function() {
       const x = TxProposal.fromObj(aTXP());
@@ -81,6 +103,21 @@ describe('TxProposal', function() {
     });
   });
 
+  describe('#sign with a number format', function() {
+    it('should keep the signatures in the persisted raw tx', function() {
+      const plain = TxProposal.fromObj(aTXP());
+      plain.sign('1', theSignatures, theXPub);
+      plain.sign('2', theSignatures, theXPub);
+
+      const formatted = TxProposal.fromObj(aTXP());
+      formatted.sign('1', theSignatures, theXPub, 'number');
+      formatted.sign('2', theSignatures, theXPub, 'number');
+
+      formatted.raw.should.deep.equal(plain.raw);
+      formatted.txid.should.equal(plain.txid);
+    });
+  });
+
   describe('#reject', function() {
     it('should reject 2-2', function() {
       const txp = TxProposal.fromObj(aTXP());
@@ -142,6 +179,13 @@ describe('TxProposal', function() {
       txp.outputs[0].amount.should.be.a('number');
     });
 
+    it('should keep a base-unit amount that a number cannot represent exactly', function() {
+      const amount = '70000000000000010';
+      const t = TxProposal.fromObj({ ...aTXP(), amount, outputs: [{ ...aTXP().outputs[0], amount }] } as any);
+      const txp = TxProposal.formatNumbers(t, 'number');
+      txp.outputs[0].amount.should.equal(amount);
+    });
+
     it('should format string numbers as hex', function() {
       const t1 = TxProposal.fromObj(aTXP());
       const t2 = TxProposal.formatNumbers(t1, 'string');
@@ -156,6 +200,80 @@ describe('TxProposal', function() {
       txp.outputs[0].amount.should.be.a('string');
       CWCUtils.isHexString(txp.outputs[0].amount).should.equal(true);
     });
+
+
+    describe('legacy format contracts', function() {
+      const cases: Array<[string, any, any]> = [
+        ['safe integer boundary', '9007199254740991', 9007199254740991],
+        ['first representable unsafe integer', '9007199254740992', 9007199254740992],
+        ['first unrepresentable integer', '9007199254740993', '9007199254740993'],
+        ['representable amount', '70000000000000008', Number('70000000000000008')],
+        ['inexact amount', '70000000000000010', '70000000000000010'],
+        ['representable hex', '0x20000000000000', 9007199254740992],
+        ['unrepresentable hex', '0x20000000000001', '0x20000000000001'],
+        ['exponential string', '1e+21', '1e+21'],
+        ['exponential number', 1e21, 1e21],
+        ['overflow string', '9'.repeat(400), '9'.repeat(400)],
+        ['empty string', '', ''],
+        ['nonnumeric string', 'abc', 'abc'],
+        ['null', null, null],
+        ['undefined', undefined, undefined],
+        ['NaN', NaN, NaN],
+        ['Infinity', Infinity, Infinity],
+        ['small bigint', 5n, 5],
+        ['inexact bigint', 9007199254740993n, 9007199254740993n],
+        ['positive sign', '+5', 5],
+        ['negative zero', '-0', -0],
+        ['leading zeros', '007', 7],
+        ['whitespace', ' 42 ', 42],
+        ['fractional prefix', '1.5', 1],
+        ['malformed prefix', '12xyz', 12],
+        ['SOL nonce prefix', '2' + 'A'.repeat(43), 2]
+      ];
+
+      for (const [label, value, expected] of cases) {
+        it(`should leave the legacy number behavior unchanged for ${label}`, function() {
+          const source: any = TxProposal.fromObj(aTXP());
+          source.amount = value;
+          source.outputs[0].amount = value;
+          const formatted = TxProposal.formatNumbers(source, 'number');
+
+          chai.expect(Object.is(formatted.amount, expected)).to.equal(true);
+          chai.expect(Object.is(formatted.outputs[0].amount, expected)).to.equal(true);
+          chai.expect(Object.is(source.outputs[0].amount, value)).to.equal(true);
+        });
+      }
+
+      for (const format of ['string', 'hex', 'bigint'] as const) {
+        it(`should leave the legacy ${format} behavior unchanged`, function() {
+          const source: any = TxProposal.fromObj(aTXP());
+          source.amount = 42;
+          source.outputs[0].amount = '70000000000000010';
+          const formatted = TxProposal.formatNumbers(source, format as 'string') as any;
+          const expected = {
+            string: ['42', '70000000000000010'],
+            hex: ['0x2a', '0xf8b0a10e47000a'],
+            bigint: [42n, 70000000000000010n]
+          }[format];
+
+          formatted.amount.should.equal(expected[0]);
+          formatted.outputs[0].amount.should.equal(expected[1]);
+          source.amount.should.equal(42);
+          source.outputs[0].amount.should.equal('70000000000000010');
+        });
+      }
+
+      it('should expand large integers and keep existing hex strings in string mode', function() {
+        const source: any = TxProposal.fromObj(aTXP());
+        source.amount = 1e21;
+        source.outputs[0].amount = '0x2a';
+        const formatted = TxProposal.formatNumbers(source, 'string');
+
+        formatted.amount.should.equal('1000000000000000000000');
+        BigInt(formatted.amount).should.equal(1000000000000000000000n);
+        formatted.outputs[0].amount.should.equal('0x2a');
+      });
+    });
   });
 });
 

package/test/numberformat-routes.test.ts

@@ -0,0 +1,88 @@
+'use strict';
+
+import * as chai from 'chai';
+import 'chai/register-should';
+import express from 'express';
+import sinon from 'sinon';
+import { Errors } from '../src/lib/errors/errordefinitions';
+import { createRouteHelpers } from '../src/lib/routes/context';
+import { ApiErrorHelper } from '../src/lib/routes/helpers/error';
+import { registerTransactionRoutes } from '../src/lib/routes/transactions';
+import { registerWalletRoutes } from '../src/lib/routes/wallets';
+
+const should = chai.should();
+
+describe('Transaction number format routes', function() {
+  const routes = [
+    ['get', '/v2/txproposals/', 'getPendingTxs'],
+    ['post', '/v3/txproposals/', 'createTx'],
+    ['post', '/v2/txproposals/:id/signatures/', 'signTx'],
+    ['post', '/v1/txproposals/:id/prepare/', 'prepareTx'],
+    ['post', '/v2/txproposals/:id/publish/', 'publishTx'],
+    ['get', '/v3/wallets/', 'getStatus'],
+    ['get', '/v1/wallets/all/', 'getStatus']
+  ];
+
+  function setup() {
+    const router = express.Router();
+    const error = new ApiErrorHelper();
+    const returnError = error.returnError.bind(error);
+    const helpers = createRouteHelpers(returnError);
+    const server: any = { copayerId: 'copayer', walletId: 'wallet' };
+    for (const method of new Set(routes.map(route => route[2]))) {
+      server[method] = sinon.stub().callsArgWith(1, null, { outputs: [{ amount: '70000000000000010' }] });
+    }
+    const context = {
+      ...helpers,
+      returnError,
+      getServerWithAuth: sinon.stub().callsFake((_req, _res, cb) => cb(server)),
+      getServerWithMultiAuth: sinon.stub().returns([Promise.resolve(server)]),
+      createWalletLimiter: sinon.stub().callsArg(2)
+    };
+    registerTransactionRoutes(router, context);
+    registerWalletRoutes(router, context);
+    const response: any = {
+      status: sinon.stub().returnsThis(),
+      json: sinon.stub().returnsThis(),
+      end: sinon.stub().returnsThis()
+    };
+    return { router, server, response, context };
+  }
+
+  for (const [method, path, serverMethod] of routes) {
+    for (const format of ['number', 'string', 'hex', undefined]) {
+      it(`should accept ${format ?? 'unspecified'} on ${method.toUpperCase()} ${path}`, async function() {
+        const { router, server, response } = setup();
+        const route = router.stack.find(layer => layer.route?.path === path && layer.route.methods[method]);
+        const request: any = { query: { numberFormat: format }, body: {}, params: { id: 'proposal' }, headers: {} };
+
+        await route.route.stack[0].handle(request, response);
+
+        server[serverMethod].callCount.should.equal(1);
+        chai.expect(server[serverMethod].firstCall.args[0].numberFormat).to.equal(format);
+        response.status.called.should.equal(false);
+        response.json.callCount.should.equal(1);
+      });
+    }
+
+    for (const format of ['invalid', 'bigint', 'raw']) {
+      it(`should return 400 without executing ${method.toUpperCase()} ${path} for ${format}`, async function() {
+        const { router, server, response, context } = setup();
+        const route = router.stack.find(layer => layer.route?.path === path && layer.route.methods[method]);
+        const request: any = { query: { numberFormat: format }, body: {}, params: { id: 'proposal' }, headers: {} };
+
+        await route.route.stack[0].handle(request, response);
+
+        response.status.calledOnceWithExactly(400).should.equal(true);
+        response.json.callCount.should.equal(1);
+        response.json.firstCall.args[0].code.should.equal('INVALID_NUMBER_FORMAT');
+        server[serverMethod].called.should.equal(false);
+        if (path === '/v1/wallets/all/') context.getServerWithMultiAuth.called.should.equal(false);
+      });
+    }
+  }
+
+  it('should list the supported formats in the validation error', function() {
+    Errors.INVALID_NUMBER_FORMAT.message.should.include('number, string, hex');
+  });
+});