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

package/test/integration/fiatrateservice.test.ts

@@ -931,6 +931,19 @@ describe('Fiat rate service', function() {
         });
       });
     });
+    it('should fetch and store USD-pegged rates for native USDC on Arc', async function() {
+      await util.promisify(service.storage.storeFiatRate).call(service.storage, 'btc', btcRates);
+      request.get.yields(null, null, btcRates.map(({ code, value }) => ({ code, rate: value })));
+
+      await util.promisify(service._fetch).call(service);
+
+      const storedRate = await util.promisify(service.getRate).call(service, { coin: 'arc', code: 'USD' });
+      storedRate.rate.should.equal(1);
+      const rates = await util.promisify(service.getRatesByCoin).call(service, { coin: 'arc' });
+      rates.find(rate => rate.code === 'USD').rate.should.equal(1);
+      rates.find(rate => rate.code === 'EUR').rate.should.equal(0.87);
+      request.get.calledWith(sinon.match({ url: sinon.match(/\/rates\/ARC\?/) })).should.equal(false);
+    });
     it('should get rate for specific ts', function(done) {
       const clock = sinon.useFakeTimers({ toFake: ['Date'] });
       clock.tick(20);

package/test/integration/helpers.ts

@@ -555,6 +555,7 @@ class Helpers {
 
     switch (txp.coin) {
       case 'eth':
+      case 'arc':
       case 'xrp':
         // For eth => account, 0, change = 0
         const priv = xpriv.derive('m/0/0').privateKey;

package/test/integration/server.test.ts

@@ -21,6 +21,8 @@ import * as TestData from '../testdata';
 import helpers from './helpers';
 import { ClientError } from '../../src/lib/errors/clienterror';
 import { ExpressApp } from '../../src/lib/expressapp';
+import { ERC20Abi } from '../../src/lib/chain/eth/abi-erc20';
+import { type JoinWalletOpts } from '../../src/lib/server';
 
 const should = chai.should();
 config.moralis = config.moralis ?? {
@@ -1120,7 +1122,7 @@ describe('Wallet service', function() {
           xPubKey: TestData.copayers[0].xPubKey_44H_0H_0H,
           requestPubKey: TestData.copayers[0].pubKey_1H_0,
         };
-        server.joinWallet(copayerOpts, function(err) {
+        server.joinWallet(copayerOpts as JoinWalletOpts, function(err) {
           should.exist(err);
           err.message.should.contain('argument: copayerSignature missing');
           done();
@@ -1774,6 +1776,57 @@ describe('Wallet service', function() {
         wallet.copayers.length.should.equal(0);
       });
     });
+
+    describe('TSS wallets (concurrent join)', function() {
+      it('should keep a copayer that joins while the wallet is being registered', async function() {
+        const server = new WalletService();
+        const copayerIds = [0, 1].map(i => Model.Copayer.xPubToCopayerId('btc', TestData.copayers[i].xPubKey_44H_0H_0H));
+
+        const session = TssKeyGenModel.create({
+          id: 'tss-join-during-register-test-session',
+          message: { partyId: 0, broadcastMessages: [], p2pMessages: [], publicKey: 'dummy', round: 0 },
+          n: 2,
+          copayerId: copayerIds[0],
+          version: Defaults.TSS_KEYGEN_SCHEME_VERSION
+        });
+        session.participants[1] = copayerIds[1];
+        session.sharedPublicKey = 'dummy-shared-public-key';
+        await server.storage.db.collection('tss_keygen').deleteMany({ id: session.id });
+        await server.storage.storeTssKeyGenSession({ doc: session });
+
+        const walletId = await util.promisify(server.createWallet).call(server, {
+          name: 'tss wallet',
+          m: 1,
+          n: 1,
+          pubKey: TestData.keyPair.pub,
+          coin: 'btc',
+          tssKeyId: session.id,
+        });
+        const [creatorOpts, joinerOpts] = [0, 1].map(i => helpers.getSignedCopayerOpts({
+          walletId,
+          name: 'copayer ' + (i + 1),
+          xPubKey: TestData.copayers[i].xPubKey_44H_0H_0H,
+          requestPubKey: TestData.copayers[i].pubKey_1H_0,
+        }));
+        const { copayerId } = await util.promisify(server.joinWallet).call(server, creatorOpts);
+        const creatorServer = await helpers.getAuthServer(copayerId);
+        creatorServer.checkWalletSync = function(a, b, simple, cb) {
+          if (simple) return cb(null, false);
+          return cb(null, true);
+        };
+
+        blockchainExplorer.register = sinon.stub().callsFake((wallet, cb) => server.joinWallet(joinerOpts, cb));
+        await util.promisify(creatorServer.getStatus).call(creatorServer, { includeExtendedInfo: true });
+
+        blockchainExplorer.register.calledOnce.should.equal(true);
+        const registeredWallet = blockchainExplorer.register.firstCall.args[0];
+        const wallet = await util.promisify(server.storage.fetchWallet).call(server.storage, walletId);
+        wallet.copayers.length.should.equal(2);
+        wallet.beRegistered.should.equal(true);
+        wallet.beAuthPrivateKey2.should.equal(registeredWallet.beAuthPrivateKey2);
+        wallet.beAuthPublicKey2.should.equal(registeredWallet.beAuthPublicKey2);
+      });
+    });
   });
 
   describe('#removeWallet', function() {
@@ -2697,6 +2750,29 @@ describe('Wallet service', function() {
       ({ server, wallet } = await helpers.createAndJoinWallet(1, 1, { coin: 'eth' }));
     });
 
+    it('should save and merge Arc token preferences without linking native USDC', async function() {
+      ({ server } = await helpers.createAndJoinWallet(1, 1, { coin: 'arc', network: 'livenet' }));
+      await util.promisify(server.savePreferences).call(server, { arcTokenAddresses: [TOKENS[0]], language: 'es' });
+      await util.promisify(server.savePreferences).call(server, {
+        arcTokenAddresses: [TOKENS[1], CWC.ethers.getAddress(TOKENS[0])],
+      });
+      let preferences = await util.promisify(server.getPreferences).call(server, {});
+      preferences.arcTokenAddresses.should.deep.equal(TOKENS);
+      preferences.language.should.equal('es');
+
+      try {
+        await util.promisify(server.savePreferences).call(server, {
+          arcTokenAddresses: [TOKENS[0], CWC.Constants.ARC.USDC_CONTRACT_ADDRESS], language: 'en',
+        });
+        should.fail('Expected native USDC token preference rejection');
+      } catch (err) {
+        err.message.toString().should.contain('arcTokenAddresses');
+      }
+      preferences = await util.promisify(server.getPreferences).call(server, {});
+      preferences.arcTokenAddresses.should.deep.equal(TOKENS);
+      preferences.language.should.equal('es');
+    });
+
     it('should save & retrieve preferences', function(done) {
       server.savePreferences({
         email: 'dummy@dummy.com',
@@ -2896,7 +2972,8 @@ describe('Wallet service', function() {
           unit: 'xxxxx',
         },
         expected: 'unit'
-      },];
+      }, ...['not-an-array', ['invalid']]
+        .map(arcTokenAddresses => ({ preferences: { arcTokenAddresses }, expected: 'arcTokenAddresses' }))];
 
       for (const item of invalid) {
         try {
@@ -6169,6 +6246,113 @@ describe('Wallet service', function() {
     });
   });
 
+  for (const [network, chainId] of [['livenet', 5042n], ['testnet', 5042002n]] as const) {
+    describe(`#createTX ARC ${network}`, () => {
+      let server: WalletService;
+      let from: string;
+      const destination = '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A';
+      const usdc = new CWC.ethers.Interface(ERC20Abi);
+      const contractOpts = (data: string) => makeOpts({
+        outputs: [{ toAddress: CWC.Constants.ARC.USDC_CONTRACT_ADDRESS, amount: 0, gasLimit: 100000, data }]
+      });
+      const makeOpts = (overrides = {}) => ({
+        outputs: [{ toAddress: destination, amount: 1e18, gasLimit: 21000 }],
+        nonce: 0, feeLevel: 'normal', ...overrides
+      });
+
+      beforeEach(async () => {
+        ({ server } = await helpers.createAndJoinWallet(1, 1, { coin: 'arc', network }));
+        from = (await util.promisify(server.createAddress).call(server, {})).address;
+        blockchainExplorer.getBalance = sinon.stub().callsArgWith(1, null, { balance: 2e18, confirmed: 2e18, unconfirmed: 0 });
+        helpers.stubFeeLevels({ 1: 25000000000, 2: 25000000000, 3: 25000000000, 4: 25000000000 }, true, 'arc');
+      });
+
+      for (const [txType, sendMax] of [[0, false], [2, false], [2, true]] as const) {
+        it(`should publish, sign and submit a type ${txType} native USDC ${sendMax ? 'send-max ' : ''}proposal`, async () => {
+          const maxGasFee = sendMax ? 31000000000 : 30000000000;
+          sinon.stub(server, 'estimateFee').resolves(maxGasFee).onFirstCall().resolves(30000000000);
+          sinon.stub(server, 'estimatePriorityFee').resolves(0);
+          const fee = (txType === 2 ? maxGasFee : 25000000000) * 21000;
+          const amount = sendMax ? 2e18 - fee : 1e18;
+          const txp = await util.promisify(server.createTx).call(server, makeOpts({ txType, sendMax,
+            outputs: [{ toAddress: destination, amount: sendMax ? null : amount, gasLimit: 21000 }] }));
+          txp.fee.should.equal(fee);
+          txp.amount.should.equal(amount);
+          await util.promisify(server.publishTx).call(server, helpers.getProposalSignatureOpts(txp, TestData.copayers[0].privKey_1H_0));
+          await util.promisify(server.signTx).call(server, { txProposalId: txp.id, signatures: helpers.clientSign(txp, TestData.copayers[0].xPrivKey_44H_0H_0H) });
+          const accepted = await util.promisify(server.getTx).call(server, { txProposalId: txp.id });
+          accepted.status.should.equal('accepted');
+          const [raw] = accepted.getRawTx();
+          const signed = CWC.ethers.Transaction.from(raw);
+          signed.chainId.should.equal(chainId);
+          signed.value.should.equal(BigInt(amount));
+          BigInt(txp.fee).should.equal((signed.maxFeePerGas ?? signed.gasPrice) * signed.gasLimit);
+          signed.isSigned().should.equal(true);
+          helpers.stubBroadcast(accepted.txid);
+          await util.promisify(server.broadcastTx).call(server, { txProposalId: txp.id });
+          blockchainExplorer.broadcast.firstCall.args[0].should.deep.equal([raw]);
+          (await util.promisify(server.getTx).call(server, { txProposalId: txp.id })).status.should.equal('broadcasted');
+        });
+      }
+
+      it('should reserve wallet-owned USDC contract debits and release them when removed', async () => {
+        for (const [method, args, debit, legacyData] of [
+          ['transfer', [destination, 1000000n], 1e18],
+          ['transferFrom', [from, destination, 1000000n], 1e18],
+          ['transferFrom', [destination, from, 1000000n], 0],
+          ['approve', [destination, 1000000n], 0],
+          ['approve', [destination, 1000000n], 1e18, usdc.encodeFunctionData('transfer', [destination, 1000000n])]
+        ] as Array<[string, any[], number, string?]>) {
+          const data = usdc.encodeFunctionData(method, args);
+          const txp = await util.promisify(server.createTx).call(server, { ...contractOpts(data), data: legacyData });
+          txp.amount.should.equal(0);
+          txp.outputs[0].amount.should.equal(0);
+          txp.outputs[0].data.should.equal(data);
+          CWC.ethers.Transaction.from(txp.getRawTx()[0]).data.should.equal(legacyData || data);
+          await util.promisify(server.publishTx).call(server, helpers.getProposalSignatureOpts(txp, TestData.copayers[0].privKey_1H_0));
+          const balance = await util.promisify(server.getBalance).call(server, {});
+          balance.lockedAmount.should.equal(debit + txp.fee);
+          balance.availableAmount.should.equal(2e18 - debit - txp.fee);
+          if (debit) {
+            try {
+              await util.promisify(server.createTx).call(server, makeOpts({ nonce: 1,
+                outputs: [{ toAddress: destination, amount: 1.5e18, gasLimit: 21000 }] }));
+              should.fail('Expected pending USDC funds to be unavailable');
+            } catch (err) {
+              err.code.should.equal('LOCKED_FUNDS');
+            }
+          }
+          await util.promisify(server.removePendingTx).call(server, { txProposalId: txp.id });
+          (await util.promisify(server.getBalance).call(server, {})).lockedAmount.should.equal(0);
+        }
+      });
+
+      it('should reject underpriced proposals, duplicate USDC token views and zero-address transfers', async () => {
+        try {
+          await util.promisify(server.getBalance).call(server, { tokenAddress: CWC.Constants.ARC.USDC_CONTRACT_ADDRESS });
+          throw new Error('Expected duplicate token balance rejection');
+        } catch (err) {
+          err.message.should.contain('omit tokenAddress');
+        }
+        for (const [opts, message] of [
+          [makeOpts({ feeLevel: undefined, feePerKb: 10000000000 }), 'at least 20 gwei'],
+          [makeOpts({ tokenAddress: CWC.Constants.ARC.USDC_CONTRACT_ADDRESS }), 'omit tokenAddress'],
+          [contractOpts(usdc.encodeFunctionData('transfer', [destination, 3000000n])), 'Insufficient funds'],
+          [contractOpts(usdc.encodeFunctionData('transfer', [destination, 2000000n])), 'Insufficient funds for fee'],
+          [contractOpts(usdc.getFunction('transfer').selector), 'Invalid Arc USDC contract call data'],
+          [makeOpts({ outputs: [{ toAddress: '0x0000000000000000000000000000000000000000', amount: 1e18 }] }), 'zero address']
+        ] as Array<[any, string]>) {
+          try {
+            await util.promisify(server.createTx).call(server, opts);
+            throw new Error('Expected proposal rejection');
+          } catch (err) {
+            err.message.should.contain(message);
+          }
+        }
+      });
+    });
+  }
+
   describe('#createTX ETH Only tests', () => {
     let server: WalletService;
     let wallet: Model.Wallet;
@@ -6362,8 +6546,8 @@ describe('Wallet service', function() {
       sinon.stub(server, 'estimatePriorityFee').resolves(1000000000);
       const txp = await util.promisify(server.createTx).call(server, makeOpts({ txType: 2 }));
       txp.feeLevel.should.equal('normal');
-      txp.gasPrice.should.equal(1000000000);
-      txp.fee.should.equal(100000000000000);
+      txp.gasPrice.should.equal(4500000000);
+      txp.fee.should.equal(450000000000000);
       txp.maxGasFee.should.equal(4500000000);
       txp.priorityGasFee.should.equal(1000000000);
       const [raw] = txp.getRawTx();
@@ -6425,6 +6609,10 @@ describe('Wallet service', function() {
         await helpers.stubUtxos(server, wallet, [0.0002]);
         const defaultTxp = await util.promisify(server.createTx).call(server, makeOpts({ tokenAddress }));
         defaultTxp.fee.should.equal(100000000000000);
+        sinon.stub(server, 'estimateFee').resolves(3000000000);
+        sinon.stub(server, 'estimatePriorityFee').resolves(1000000000);
+        await assert.rejects(util.promisify(server.createTx).call(server, makeOpts({ txType: 2, tokenAddress })),
+          { code: tokenAddress ? 'INSUFFICIENT_ETH_FEE' : 'INSUFFICIENT_FUNDS_FOR_FEE' });
         await assert.rejects(util.promisify(server.createTx).call(server, makeOpts({
           txType: 2, maxGasFee: 3000000000, priorityGasFee: 1000000000, tokenAddress
         })), { code: tokenAddress ? 'INSUFFICIENT_ETH_FEE' : 'INSUFFICIENT_FUNDS_FOR_FEE' });