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

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

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const chai = __importStar(require("chai"));
 require("chai/register-should");
 const util_1 = __importDefault(require("util"));
+const assert_1 = __importDefault(require("assert"));
 const sinon_1 = __importDefault(require("sinon"));
 const http_1 = __importDefault(require("http"));
 const request_1 = __importDefault(require("request"));
@@ -2669,28 +2670,21 @@ describe('Wallet service', function () {
                         should.exist(address);
                         utxo.path.should.equal(address.path);
                         utxo.publicKeys.should.deep.equal(address.publicKeys);
+                        utxo.isChange.should.equal(false);
                         done();
                     });
                 });
             });
         });
-        it('should get UTXOs for wallet addresses', function (done) {
-            helpers_1.default.stubUtxos(server, wallet, [1, 2]).then(function () {
-                server.getUtxos({}, function (err, utxos) {
-                    should.not.exist(err);
-                    should.exist(utxos);
-                    utxos.length.should.equal(2);
-                    utxos.reduce((sum, u) => sum += u.satoshis, 0).should.equal(3 * 1e8);
-                    server.getAddresses({ noChange: true }, function (err, addresses) {
-                        const utxo = utxos[0];
-                        const address = addresses.find(a => a.address === utxo.address);
-                        should.exist(address);
-                        utxo.path.should.equal(address.path);
-                        utxo.publicKeys.should.deep.equal(address.publicKeys);
-                        done();
-                    });
-                });
-            });
+        it('should identify UTXOs for change addresses', async function () {
+            const address = await util_1.default.promisify(server.createAddress).call(server, { isChange: true });
+            await helpers_1.default.stubUtxos(server, wallet, [1], { addresses: [address] });
+            const utxos = await util_1.default.promisify(server.getUtxos).call(server, {});
+            utxos.length.should.equal(1);
+            utxos[0].address.should.equal(address.address);
+            utxos[0].path.should.equal(address.path);
+            utxos[0].publicKeys.should.deep.equal(address.publicKeys);
+            utxos[0].isChange.should.equal(true);
         });
         it('should return empty UTXOs for specific addresses if network mismatch', function (done) {
             helpers_1.default.stubUtxos(server, wallet, [1, 2, 3]).then(function (utxos) {
@@ -4542,7 +4536,6 @@ describe('Wallet service', function () {
                                         toAddress: addressStr,
                                         amount: ts,
                                     }],
-                                gasPrice: 1,
                                 feeLevel: level,
                                 from: fromAddr,
                             }, flags);
@@ -5705,36 +5698,35 @@ describe('Wallet service', function () {
                 coin: 'eth',
             }));
         });
-        it('should allow to create a TX with fee and no inputs', function (done) {
-            helpers_1.default.stubFeeLevels({});
-            server.createAddress({}, from => {
-                helpers_1.default.stubUtxos(server, wallet, [1, 2]).then(function () {
-                    const amount = 0.8 * 1e8;
-                    const txOpts = {
-                        outputs: [{
-                                toAddress: '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A',
-                                amount: amount,
-                            }],
-                        from,
-                        message: 'some message',
-                        customData: 'some custom data',
-                        fee: 252000000000000,
-                    };
-                    server.createTx(txOpts, function (err, tx) {
-                        should.not.exist(err);
-                        should.exist(tx);
-                        tx.outputs.should.deep.equal([{
-                                toAddress: '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A',
-                                gasLimit: 21000,
-                                amount: amount,
-                            }]);
-                        tx.gasPrice.should.equal(12000000000);
-                        tx.outputs[0].gasLimit.should.equal(21000);
-                        (tx.gasPrice * tx.outputs[0].gasLimit).should.equal(txOpts.fee);
-                        done();
-                    });
-                });
-            });
+        it('should allow to create a TX with fee and no inputs', async function () {
+            const feeLevels = sinon_1.default.stub(server, 'getFeeLevels').callsArgWith(1, new Error('Unexpected fee estimation'));
+            await util_1.default.promisify(server.createAddress).call(server, {});
+            await helpers_1.default.stubUtxos(server, wallet, [1, 2]);
+            const amount = 0.8 * 1e8;
+            for (const fee of [252000000000000, '252000000000000']) {
+                const txOpts = {
+                    outputs: [{
+                            toAddress: '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A',
+                            amount: amount,
+                        }],
+                    message: 'some message',
+                    customData: 'some custom data',
+                    fee,
+                };
+                const tx = await util_1.default.promisify(server.createTx).call(server, txOpts);
+                should.exist(tx);
+                tx.outputs.should.deep.equal([{
+                        toAddress: '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A',
+                        gasLimit: 21000,
+                        amount: amount,
+                    }]);
+                tx.fee.should.equal(Number(fee));
+                tx.gasPrice.should.equal(12000000000);
+                (tx.gasPrice * tx.outputs[0].gasLimit).should.equal(Number(fee));
+                const [raw] = tx.getRawTx();
+                CWC.ethers.Transaction.from(raw).gasPrice.should.equal(12000000000n);
+            }
+            feeLevels.called.should.be.false;
         });
         it('should allow to create a TX with multiple outputs and set the correct fee', function (done) {
             helpers_1.default.stubFeeLevels({});
@@ -5799,6 +5791,147 @@ describe('Wallet service', function () {
             });
         });
     });
+    describe('#createTX EVM gas overrides', function () {
+        let server;
+        let wallet;
+        const destination = '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A';
+        const makeOpts = (overrides = {}) => ({
+            outputs: [{ toAddress: destination, amount: 1000000, gasLimit: 100000 }],
+            nonce: 1,
+            ...overrides
+        });
+        beforeEach(async function () {
+            ({ server, wallet } = await helpers_1.default.createAndJoinWallet(1, 1, { coin: 'eth' }));
+            await util_1.default.promisify(server.createAddress).call(server, {});
+            await helpers_1.default.stubUtxos(server, wallet, [1]);
+        });
+        for (const scenario of [
+            { name: 'type 0', fees: { gasPrice: 3000000000 }, tokenAddress: undefined },
+            { name: 'type 0 token', fees: { gasPrice: 3000000000 }, tokenAddress: TOKENS[0] },
+            { name: 'type 2 native', fees: { txType: 2, maxGasFee: 3000000000, priorityGasFee: 1000000000 }, tokenAddress: undefined },
+            { name: 'type 2 token', fees: { txType: 2, maxGasFee: 3000000000, priorityGasFee: 1000000000 }, tokenAddress: TOKENS[0] }
+        ]) {
+            it(`should preserve ${scenario.name} overrides through publication, signing and broadcast`, async function () {
+                const feeLevels = sinon_1.default.stub(server, 'getFeeLevels').callsArgWith(1, new Error('Unexpected fee estimation'));
+                const maxFee = sinon_1.default.stub(server, 'estimateFee').rejects(new Error('Unexpected fee estimation'));
+                const priorityFee = sinon_1.default.stub(server, 'estimatePriorityFee').rejects(new Error('Unexpected fee estimation'));
+                const txp = await util_1.default.promisify(server.createTx).call(server, makeOpts({
+                    ...scenario.fees, tokenAddress: scenario.tokenAddress, feeLevel: 'economy'
+                }));
+                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 signedRaw = accepted.getRawTx();
+                helpers_1.default.stubBroadcast(accepted.txid);
+                await util_1.default.promisify(server.broadcastTx).call(server, { txProposalId: txp.id });
+                blockchainExplorer.broadcast.calledOnce.should.be.true;
+                blockchainExplorer.broadcast.firstCall.args[0].should.deep.equal(signedRaw);
+                const stored = await util_1.default.promisify(server.getTx).call(server, { txProposalId: txp.id });
+                stored.status.should.equal('broadcasted');
+                stored.txid.should.equal(accepted.txid);
+                should.not.exist(stored.feeLevel);
+                stored.fee.should.equal(300000000000000);
+                for (const [key, value] of Object.entries(scenario.fees)) {
+                    stored[key].should.equal(value);
+                }
+                const [raw] = stored.getRawTx();
+                const tx = CWC.ethers.Transaction.from(raw);
+                tx.isSigned().should.be.true;
+                tx.type.should.equal(scenario.fees.txType || 0);
+                if (scenario.fees.txType === 2) {
+                    tx.maxFeePerGas.should.equal(3000000000n);
+                    tx.maxPriorityFeePerGas.should.equal(1000000000n);
+                }
+                else {
+                    tx.gasPrice.should.equal(3000000000n);
+                }
+                feeLevels.called.should.be.false;
+                maxFee.called.should.be.false;
+                priorityFee.called.should.be.false;
+            });
+        }
+        it('should preserve a zero priority fee estimated for ARB', async function () {
+            ({ server, wallet } = await helpers_1.default.createAndJoinWallet(1, 1, { coin: 'arb' }));
+            await util_1.default.promisify(server.createAddress).call(server, {});
+            sinon_1.default.replace(blockchainExplorer, 'getBalance', sinon_1.default.stub().callsArgWith(1, null, { confirmed: 1e18, unconfirmed: 0, balance: 1e18 }));
+            helpers_1.default.stubFeeLevels({});
+            sinon_1.default.stub(server, 'estimateFee').resolves(3000000000);
+            sinon_1.default.stub(server, 'estimatePriorityFee').resolves(0);
+            const txp = await util_1.default.promisify(server.createTx).call(server, makeOpts({ txType: 2 }));
+            txp.priorityGasFee.should.equal(0);
+            const [raw] = txp.getRawTx();
+            CWC.ethers.Transaction.from(raw).maxPriorityFeePerGas.should.equal(0n);
+        });
+        it('should preserve automatic type 2 fee estimation without overrides', async function () {
+            helpers_1.default.stubFeeLevels({});
+            sinon_1.default.stub(server, 'estimateFee').resolves(4500000000);
+            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.maxGasFee.should.equal(4500000000);
+            txp.priorityGasFee.should.equal(1000000000);
+            const [raw] = txp.getRawTx();
+            const tx = CWC.ethers.Transaction.from(raw);
+            tx.maxFeePerGas.should.equal(4500000000n);
+            tx.maxPriorityFeePerGas.should.equal(1000000000n);
+        });
+        it('should enforce the existing MATIC minimum for explicit priority fees', async function () {
+            ({ server, wallet } = await helpers_1.default.createAndJoinWallet(1, 1, { coin: 'matic' }));
+            await util_1.default.promisify(server.createAddress).call(server, {});
+            sinon_1.default.replace(blockchainExplorer, 'getBalance', sinon_1.default.stub().callsArgWith(1, null, { confirmed: 1e18, unconfirmed: 0, balance: 1e18 }));
+            const fees = { txType: 2, maxGasFee: 40000000000, priorityGasFee: 30000000000 };
+            await assert_1.default.rejects(util_1.default.promisify(server.createTx).call(server, makeOpts({ ...fees, priorityGasFee: fees.priorityGasFee - 1 })), {
+                message: 'priorityGasFee must be at least 30000000000 wei for matic'
+            });
+            const txp = await util_1.default.promisify(server.createTx).call(server, makeOpts(fees));
+            const [raw] = txp.getRawTx();
+            CWC.ethers.Transaction.from(raw).maxPriorityFeePerGas.should.equal(30000000000n);
+            txp.fee.should.equal(fees.maxGasFee * 100000);
+        });
+        it('should reject invalid or conflicting gas overrides', async function () {
+            const requests = [
+                ...[
+                    { key: 'gasPrice', values: [0, 1.5, '1000', Number.MAX_SAFE_INTEGER + 1] },
+                    { key: 'maxGasFee', values: [0] },
+                    { key: 'priorityGasFee', values: [0] }
+                ].flatMap(({ key, values }) => values.map(value => ({
+                    params: { [key]: value }, message: `${key} must be a positive safe integer in wei`
+                }))),
+                { params: { gasPrice: 1000, txType: 2 }, message: 'gasPrice requires a type 0 transaction' },
+                { params: { maxGasFee: 1000 }, message: 'maxGasFee and priorityGasFee require a type 2 transaction' },
+                { params: { priorityGasFee: 1000, txType: 0 }, message: 'maxGasFee and priorityGasFee require a type 2 transaction' },
+                { params: { maxGasFee: 1000, txType: 2 }, message: 'maxGasFee and priorityGasFee must be supplied together' },
+                { params: { priorityGasFee: 1000, txType: 2 }, message: 'maxGasFee and priorityGasFee must be supplied together' },
+                { params: { gasPrice: 1000, feePerKb: 1000 }, message: 'Gas fee overrides cannot be combined with feePerKb or fee' },
+                { params: { gasPrice: 1000, fee: 1000 }, message: 'Gas fee overrides cannot be combined with feePerKb or fee' },
+                { params: { gasPrice: 1000, sendMax: true }, message: 'Gas fee overrides are not supported with sendMax' },
+                { params: { txType: 2, maxGasFee: 1000, priorityGasFee: 2000 }, message: 'priorityGasFee must not exceed maxGasFee' }
+            ];
+            for (const { params, message } of requests) {
+                await assert_1.default.rejects(util_1.default.promisify(server.createTx).call(server, makeOpts(params)), { message });
+            }
+            await assert_1.default.rejects(util_1.default.promisify(server._validateAndSanitizeTxOpts).call(server, { ...wallet, chain: 'btc' }, makeOpts({ gasPrice: 1000 })), {
+                message: 'Gas fee overrides are only supported for EVM chains'
+            });
+        });
+        for (const tokenAddress of [undefined, TOKENS[0]]) {
+            it(`should reserve the overridden fee for ${tokenAddress ? 'token' : 'native'} proposals`, async function () {
+                helpers_1.default.stubFeeLevels({});
+                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);
+                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' });
+            });
+        }
+    });
     describe('cashAddr backwards compat', function () {
         it('should create a BCH tx proposal with cashaddr outputs (w/o prefix) and return Copay addr', function (done) {
             const copayAddr = 'CPrtPWbp8cCftTQu5fzuLG5zPJNDHMMf8X';
@@ -7154,39 +7287,27 @@ describe('Wallet service', function () {
                     }],
             },
         ];
-        function checkTx(txOpts, x, cb) {
-            function sign(copayerM, tx, cb) {
-                helpers_1.default.getAuthServer(wallet.copayers[copayerM].id).then(function (server) {
-                    const signatures = helpers_1.default.clientSign(tx, TestData.copayers[copayerM].xPrivKey_44H_0H_0H);
-                    server.signTx({
-                        txProposalId: tx.id,
-                        signatures: signatures,
-                    }, function (err, txp) {
-                        should.not.exist(err, err);
-                        if (++copayerM == x.m) {
-                            return cb(txp);
-                        }
-                        else {
-                            return sign(copayerM, tx, cb);
-                        }
-                    });
+        async function checkTx(txOpts, x) {
+            const tx = await helpers_1.default.createAndPublishTx(server, txOpts, TestData.copayers[0].privKey_1H_0);
+            let txp;
+            for (let copayerM = 0; copayerM < x.m; copayerM++) {
+                const authServer = await helpers_1.default.getAuthServer(wallet.copayers[copayerM].id);
+                const signatures = helpers_1.default.clientSign(tx, TestData.copayers[copayerM].xPrivKey_44H_0H_0H);
+                txp = await util_1.default.promisify(authServer.signTx).call(authServer, {
+                    txProposalId: tx.id,
+                    signatures: signatures,
                 });
             }
-            helpers_1.default.createAndPublishTx(server, txOpts, TestData.copayers[0].privKey_1H_0).then(function (tx) {
-                sign(0, tx, (txp) => {
-                    should.exist(txp.raw);
-                    txp.status.should.equal('accepted');
-                    const t = index_1.ChainService.getBitcoreTx(txp);
-                    (txp.raw.length / 2).should.equal(t.size);
-                    const feeRate = t.getFee() / (x.fromSegwit ? t.vsize : t.size) * 1000;
-                    console.log(`Wire Size: ${t.size} vSize: ${t.vsize} (Segwit: ${x.fromSegwit}, SegwitVersion: ${x.segwitVersion || 0})  Fee:${t.getFee()} ActualRate:${Math.round(feeRate)} RequiredRate:${x.requiredFeeRate}`);
-                    feeRate.should.not.be.below(x.requiredFeeRate);
-                    feeRate.should.be.below(x.requiredFeeRate * 1.5);
-                    return cb(feeRate);
-                });
-            });
+            should.exist(txp.raw);
+            txp.status.should.equal('accepted');
+            const t = index_1.ChainService.getBitcoreTx(txp);
+            (txp.raw.length / 2).should.equal(t.size);
+            const feeRate = t.getFee() / (x.fromSegwit ? t.vsize : t.size) * 1000;
+            console.log(`Wire Size: ${t.size} vSize: ${t.vsize} (Segwit: ${x.fromSegwit}, SegwitVersion: ${x.segwitVersion || 0})  Fee:${t.getFee()} ActualRate:${Math.round(feeRate)} RequiredRate:${x.requiredFeeRate}`);
+            feeRate.should.not.be.below(x.requiredFeeRate);
+            feeRate.should.be.below(x.requiredFeeRate * 1.5);
+            return feeRate;
         }
-        ;
         for (let i = 0; i < cases.length; i++) {
             const x = cases[i];
             x.i = i;
@@ -7214,7 +7335,7 @@ describe('Wallet service', function () {
                 else {
                     Object.assign(txOpts, { feePerKb: x.requiredFeeRate });
                 }
-                const fee1 = await new Promise(r => checkTx(txOpts, x, r));
+                const fee1 = await checkTx(txOpts, x);
                 should.exist(fee1);
                 if (x.i == 8) {
                     await helpers_1.default.beforeEach();
@@ -7222,7 +7343,7 @@ describe('Wallet service', function () {
                     ({ server, wallet } = await helpers_1.default.createAndJoinWallet(x.m, x.n, { useNativeSegwit: x.fromSegwit }));
                     await helpers_1.default.stubUtxos(server, wallet, x.utxos);
                     txOpts.payProUrl = null;
-                    const fee2 = await new Promise(r => checkTx(txOpts, x, r));
+                    const fee2 = await checkTx(txOpts, x);
                     console.log(`## Fee PayPro: ${fee1} vs ${fee2}`);
                     fee1.should.be.above(fee2);
                 }
@@ -7291,43 +7412,31 @@ describe('Wallet service', function () {
                     }]
             },
         ];
-        function checkTx(txOpts, x, cb) {
-            function sign(copayerM, tx, cb) {
-                helpers_1.default.getAuthServer(wallet.copayers[copayerM].id).then(function (server) {
-                    const signatures = helpers_1.default.clientSign(tx, TestData.copayers[copayerM].xPrivKey_44H_0H_0H);
-                    server.signTx({
-                        txProposalId: tx.id,
-                        signatures: signatures,
-                    }, function (err, txp) {
-                        should.not.exist(err, err);
-                        if (++copayerM == x.m) {
-                            return cb(txp);
-                        }
-                        else {
-                            return sign(copayerM, tx, cb);
-                        }
-                    });
+        async function checkTx(txOpts, x) {
+            const tx = await helpers_1.default.createAndPublishTx(server, txOpts, TestData.copayers[0].privKey_1H_0);
+            let txp;
+            for (let copayerM = 0; copayerM < x.m; copayerM++) {
+                const authServer = await helpers_1.default.getAuthServer(wallet.copayers[copayerM].id);
+                const signatures = helpers_1.default.clientSign(tx, TestData.copayers[copayerM].xPrivKey_44H_0H_0H);
+                txp = await util_1.default.promisify(authServer.signTx).call(authServer, {
+                    txProposalId: tx.id,
+                    signatures: signatures,
                 });
             }
-            helpers_1.default.createAndPublishTx(server, txOpts, TestData.copayers[0].privKey_1H_0).then(function (tx) {
-                sign(0, tx, (txp) => {
-                    should.exist(txp.raw);
-                    txp.status.should.equal('accepted');
-                    const t = index_1.ChainService.getBitcoreTx(txp);
-                    const vSize = x.vSize || t._estimateSize();
-                    const actualSize = txp.raw.length / 2;
-                    const actualFeeRate = t.getFee() / (x.fromSegwit ? vSize : actualSize) * 1000;
-                    console.log(`Wire Size:${actualSize} vSize: ${vSize} (Segwit: ${x.fromSegwit})  Fee: ${t.getFee()} ActualRate:${Math.round(actualFeeRate)} RequiredRate:${x.requiredFeeRate}`);
-                    t.getFee().should.be.gte(CWC.BitcoreLibDoge.Transaction.DUST_AMOUNT);
-                    if (t.getFee() > CWC.BitcoreLibDoge.Transaction.DUST_AMOUNT) {
-                        actualFeeRate.should.not.be.below(x.requiredFeeRate);
-                        actualFeeRate.should.be.below(x.requiredFeeRate * 1.5);
-                    }
-                    return cb(actualFeeRate);
-                });
-            });
+            should.exist(txp.raw);
+            txp.status.should.equal('accepted');
+            const t = index_1.ChainService.getBitcoreTx(txp);
+            const vSize = x.vSize || t._estimateSize();
+            const actualSize = txp.raw.length / 2;
+            const actualFeeRate = t.getFee() / (x.fromSegwit ? vSize : actualSize) * 1000;
+            console.log(`Wire Size:${actualSize} vSize: ${vSize} (Segwit: ${x.fromSegwit})  Fee: ${t.getFee()} ActualRate:${Math.round(actualFeeRate)} RequiredRate:${x.requiredFeeRate}`);
+            t.getFee().should.be.gte(CWC.BitcoreLibDoge.Transaction.DUST_AMOUNT);
+            if (t.getFee() > CWC.BitcoreLibDoge.Transaction.DUST_AMOUNT) {
+                actualFeeRate.should.not.be.below(x.requiredFeeRate);
+                actualFeeRate.should.be.below(x.requiredFeeRate * 1.5);
+            }
+            return actualFeeRate;
         }
-        ;
         for (let i = 0; i < cases.length; i++) {
             const x = cases[i];
             x.i = i;
@@ -7355,7 +7464,7 @@ describe('Wallet service', function () {
                 else {
                     Object.assign(txOpts, { feePerKb: x.requiredFeeRate });
                 }
-                const fee1 = await new Promise(r => checkTx(txOpts, x, r));
+                const fee1 = await checkTx(txOpts, x);
                 should.exist(fee1);
                 if (x.i == 8) {
                     await helpers_1.default.beforeEach();
@@ -7363,7 +7472,7 @@ describe('Wallet service', function () {
                     ({ server, wallet } = await helpers_1.default.createAndJoinWallet(x.m, x.n, { useNativeSegwit: x.fromSegwit }));
                     await helpers_1.default.stubUtxos(server, wallet, x.utxos);
                     txOpts.payProUrl = null;
-                    const fee2 = await new Promise(r => checkTx(txOpts, x, r));
+                    const fee2 = await checkTx(txOpts, x);
                     console.log(`## Fee PayPro: ${fee1} vs ${fee2}`);
                     fee1.should.be.above(fee2);
                 }
@@ -10661,10 +10770,6 @@ describe('Wallet service', function () {
                         simplex: {
                             disabled: false,
                             removed: false
-                        },
-                        wyre: {
-                            disabled: false,
-                            removed: false
                         }
                     },
                     sellCrypto: {
@@ -10750,10 +10855,6 @@ describe('Wallet service', function () {
                         transak: {
                             disabled: false,
                             removed: false
-                        },
-                        wyre: {
-                            disabled: false,
-                            removed: false
                         }
                     },
                     sellCrypto: {