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

package/ts_build/test/integration/server.test.js

@@ -57,6 +57,7 @@ const TestData = __importStar(require("../testdata"));
 const helpers_1 = __importDefault(require("./helpers"));
 const clienterror_1 = require("../../src/lib/errors/clienterror");
 const expressapp_1 = require("../../src/lib/expressapp");
+const abi_erc20_1 = require("../../src/lib/chain/eth/abi-erc20");
 const should = chai.should();
 config_1.default.moralis = config_1.default.moralis ?? {
     apiKey: 'apiKey',
@@ -1629,6 +1630,53 @@ 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 server_1.WalletService();
+                const copayerIds = [0, 1].map(i => Model.Copayer.xPubToCopayerId('btc', TestData.copayers[i].xPubKey_44H_0H_0H));
+                const session = tsskeygen_1.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_1.default.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_1.default.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_1.default.promisify(server.joinWallet).call(server, creatorOpts);
+                const creatorServer = await helpers_1.default.getAuthServer(copayerId);
+                creatorServer.checkWalletSync = function (a, b, simple, cb) {
+                    if (simple)
+                        return cb(null, false);
+                    return cb(null, true);
+                };
+                blockchainExplorer.register = sinon_1.default.stub().callsFake((wallet, cb) => server.joinWallet(joinerOpts, cb));
+                await util_1.default.promisify(creatorServer.getStatus).call(creatorServer, { includeExtendedInfo: true });
+                blockchainExplorer.register.calledOnce.should.equal(true);
+                const registeredWallet = blockchainExplorer.register.firstCall.args[0];
+                const wallet = await util_1.default.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 () {
         let server;
@@ -2452,6 +2500,28 @@ describe('Wallet service', function () {
         beforeEach(async function () {
             ({ server, wallet } = await helpers_1.default.createAndJoinWallet(1, 1, { coin: 'eth' }));
         });
+        it('should save and merge Arc token preferences without linking native USDC', async function () {
+            ({ server } = await helpers_1.default.createAndJoinWallet(1, 1, { coin: 'arc', network: 'livenet' }));
+            await util_1.default.promisify(server.savePreferences).call(server, { arcTokenAddresses: [TOKENS[0]], language: 'es' });
+            await util_1.default.promisify(server.savePreferences).call(server, {
+                arcTokenAddresses: [TOKENS[1], CWC.ethers.getAddress(TOKENS[0])],
+            });
+            let preferences = await util_1.default.promisify(server.getPreferences).call(server, {});
+            preferences.arcTokenAddresses.should.deep.equal(TOKENS);
+            preferences.language.should.equal('es');
+            try {
+                await util_1.default.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_1.default.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',
@@ -2638,7 +2708,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 {
                     await util_1.default.promisify(server.savePreferences).call(server, item.preferences);
@@ -5690,6 +5761,111 @@ describe('Wallet service', function () {
             });
         });
     });
+    for (const [network, chainId] of [['livenet', 5042n], ['testnet', 5042002n]]) {
+        describe(`#createTX ARC ${network}`, () => {
+            let server;
+            let from;
+            const destination = '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A';
+            const usdc = new CWC.ethers.Interface(abi_erc20_1.ERC20Abi);
+            const contractOpts = (data) => 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_1.default.createAndJoinWallet(1, 1, { coin: 'arc', network }));
+                from = (await util_1.default.promisify(server.createAddress).call(server, {})).address;
+                blockchainExplorer.getBalance = sinon_1.default.stub().callsArgWith(1, null, { balance: 2e18, confirmed: 2e18, unconfirmed: 0 });
+                helpers_1.default.stubFeeLevels({ 1: 25000000000, 2: 25000000000, 3: 25000000000, 4: 25000000000 }, true, 'arc');
+            });
+            for (const [txType, sendMax] of [[0, false], [2, false], [2, true]]) {
+                it(`should publish, sign and submit a type ${txType} native USDC ${sendMax ? 'send-max ' : ''}proposal`, async () => {
+                    const maxGasFee = sendMax ? 31000000000 : 30000000000;
+                    sinon_1.default.stub(server, 'estimateFee').resolves(maxGasFee).onFirstCall().resolves(30000000000);
+                    sinon_1.default.stub(server, 'estimatePriorityFee').resolves(0);
+                    const fee = (txType === 2 ? maxGasFee : 25000000000) * 21000;
+                    const amount = sendMax ? 2e18 - fee : 1e18;
+                    const txp = await util_1.default.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_1.default.promisify(server.publishTx).call(server, helpers_1.default.getProposalSignatureOpts(txp, TestData.copayers[0].privKey_1H_0));
+                    await util_1.default.promisify(server.signTx).call(server, { txProposalId: txp.id, signatures: helpers_1.default.clientSign(txp, TestData.copayers[0].xPrivKey_44H_0H_0H) });
+                    const accepted = await util_1.default.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_1.default.stubBroadcast(accepted.txid);
+                    await util_1.default.promisify(server.broadcastTx).call(server, { txProposalId: txp.id });
+                    blockchainExplorer.broadcast.firstCall.args[0].should.deep.equal([raw]);
+                    (await util_1.default.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])]
+                ]) {
+                    const data = usdc.encodeFunctionData(method, args);
+                    const txp = await util_1.default.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_1.default.promisify(server.publishTx).call(server, helpers_1.default.getProposalSignatureOpts(txp, TestData.copayers[0].privKey_1H_0));
+                    const balance = await util_1.default.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_1.default.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_1.default.promisify(server.removePendingTx).call(server, { txProposalId: txp.id });
+                    (await util_1.default.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_1.default.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']
+                ]) {
+                    try {
+                        await util_1.default.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;
         let wallet;
@@ -5872,8 +6048,8 @@ describe('Wallet service', function () {
             sinon_1.default.stub(server, 'estimatePriorityFee').resolves(1000000000);
             const txp = await util_1.default.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();
@@ -5926,6 +6102,9 @@ describe('Wallet service', function () {
                 await helpers_1.default.stubUtxos(server, wallet, [0.0002]);
                 const defaultTxp = await util_1.default.promisify(server.createTx).call(server, makeOpts({ tokenAddress }));
                 defaultTxp.fee.should.equal(100000000000000);
+                sinon_1.default.stub(server, 'estimateFee').resolves(3000000000);
+                sinon_1.default.stub(server, 'estimatePriorityFee').resolves(1000000000);
+                await assert_1.default.rejects(util_1.default.promisify(server.createTx).call(server, makeOpts({ txType: 2, tokenAddress })), { code: tokenAddress ? 'INSUFFICIENT_ETH_FEE' : 'INSUFFICIENT_FUNDS_FOR_FEE' });
                 await assert_1.default.rejects(util_1.default.promisify(server.createTx).call(server, makeOpts({
                     txType: 2, maxGasFee: 3000000000, priorityGasFee: 1000000000, tokenAddress
                 })), { code: tokenAddress ? 'INSUFFICIENT_ETH_FEE' : 'INSUFFICIENT_FUNDS_FOR_FEE' });