@bitpay-labs/bitcore-wallet-service 11.5.2

package/ts_build/test/integration/pushNotifications.test.js

@@ -0,0 +1,1379 @@
+'use strict';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai = __importStar(require("chai"));
+require("chai/register-should");
+const util_1 = __importDefault(require("util"));
+const sinon_1 = __importDefault(require("sinon"));
+const npmlog_1 = __importDefault(require("npmlog"));
+const sjcl_1 = __importDefault(require("sjcl"));
+const server_1 = require("../../src/lib/server");
+const pushnotificationsservice_1 = require("../../src/lib/pushnotificationsservice");
+const storage_1 = require("../../src/lib/storage");
+const mongodb_1 = require("mongodb");
+const TestData = __importStar(require("../testdata"));
+const helpers_1 = __importDefault(require("./helpers"));
+const common_1 = require("../../src/lib/common");
+npmlog_1.default.debug = npmlog_1.default.verbose;
+npmlog_1.default.level = 'info';
+const should = chai.should();
+const { Utils } = common_1.Common;
+const TOKENS = [
+    '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    '0x8E870D67F660D95d5be530380D0eC0bd388289E1',
+    '0x056Fd409E1d7A124BD7017459dFEa2F387b6d5Cd',
+    '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
+];
+const CUSTOM_TOKENS = ['0x0d8775f648430679a709e98d2b0cb6250d2887ef'];
+describe('Push notifications', function () {
+    this.timeout(5000);
+    let server;
+    let wallet;
+    let requestStub;
+    let getTokenDataStub;
+    let pushNotificationsService;
+    let walletId;
+    before(async function () {
+        await helpers_1.default.before();
+    });
+    after(async function () {
+        await helpers_1.default.after();
+    });
+    describe('Single wallet', function () {
+        beforeEach(async function () {
+            await helpers_1.default.beforeEach();
+            ({ wallet, server } = await helpers_1.default.createAndJoinWallet(1, 1));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await Promise.all([
+                    util_1.default.promisify(s.savePreferences).call(s, {
+                        email: 'copayer' + (i + 1) + '@domain.com',
+                        language: 'en',
+                        unit: 'bit',
+                    }),
+                    util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                        token: '1234',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    })
+                ]);
+            }
+            requestStub = sinon_1.default.stub();
+            requestStub.yields();
+            pushNotificationsService = new pushnotificationsservice_1.PushNotificationsService();
+            await util_1.default.promisify(pushNotificationsService.start).call(pushNotificationsService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                request: requestStub,
+                pushNotificationsOpts: {
+                    templatePath: 'templates',
+                    defaultLanguage: 'en',
+                    defaultUnit: 'btc',
+                    subjectPrefix: '',
+                    pushServerUrl: 'http://localhost:8000',
+                    authorizationKey: 'secret',
+                },
+            });
+        });
+        it('should build each notifications using preferences of the copayers', function (done) {
+            server.savePreferences({
+                language: 'en',
+                unit: 'bit',
+            }, function (err) {
+                server.createAddress({}, function (err, address) {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 12300000,
+                    }, {
+                        isGlobal: true
+                    }, function (err) {
+                        setTimeout(function () {
+                            const calls = requestStub.getCalls();
+                            const args = calls.map(c => c.args[0]);
+                            calls.length.should.equal(2);
+                            should.not.exist(args[0].body.notification);
+                            args[1].body.notification.title.should.contain('New payment received');
+                            args[1].body.notification.body.should.contain('123,000');
+                            args[1].body.notification.body.should.contain('bits');
+                            done();
+                        }, 100);
+                    });
+                });
+            });
+        });
+        it('should notify auto-payments to creator', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('NewIncomingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 12300000,
+                }, {
+                    isGlobal: false
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        should.not.exist(args[0].body.notification);
+                        done();
+                    }, 100);
+                });
+            });
+        });
+        it('should show the correct template for zero amount outgoin transactions', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('NewOutgoingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 0,
+                }, {
+                    isGlobal: false
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        args[1].body.notification.title.should.contain('Payment sent');
+                        args[1].body.notification.body.should.contain('A Payment has been sent from your wallet.');
+                        should.not.exist(args[0].body.notification);
+                        done();
+                    }, 100);
+                });
+            });
+        });
+        it('should show the correct template for non zero amount outgoing transactions', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('NewOutgoingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 12345
+                }, {
+                    isGlobal: false
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        args[1].body.notification.title.should.contain('Payment sent');
+                        args[1].body.notification.body.should.contain('A Payment of 123 bits has been sent from your wallet');
+                        should.not.exist(args[0].body.notification);
+                        done();
+                    }, 100);
+                });
+            });
+        });
+        it('should notify copayers when payment is received', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('NewIncomingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 12300000,
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        should.not.exist(args[0].body.notification);
+                        done();
+                    }, 100);
+                });
+            });
+        });
+        it('should notify copayers when tx is confirmed if they are subscribed', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server.txConfirmationSubscribe({
+                    txid: '123'
+                }, function (err) {
+                    should.not.exist(err);
+                    server._notify('TxConfirmation', {
+                        txid: '123',
+                    }, function (err) {
+                        setTimeout(function () {
+                            const calls = requestStub.getCalls();
+                            const args = calls.map(c => c.args[0]);
+                            calls.length.should.equal(2);
+                            should.not.exist(args[0].body.notification);
+                            done();
+                        }, 100);
+                    });
+                });
+            });
+        });
+        it('should notify creator when txp is accepted by himself and the app is open', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('TxProposalAcceptedBy', {
+                    txid: '123'
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        should.not.exist(args[0].body.notification);
+                        should.exist(args[0].body.data);
+                        should.not.exist(args[1].body.notification);
+                        should.exist(args[1].body.data);
+                        done();
+                    }, 100);
+                });
+            });
+        });
+        it('should notify creator when txp is finally accepeted by himself and the app is open', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('TxProposalFinallyAccepted', {
+                    txid: '123'
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        should.not.exist(args[0].body.notification);
+                        should.exist(args[0].body.data);
+                        should.not.exist(args[1].body.notification);
+                        should.exist(args[1].body.data);
+                        done();
+                    }, 100);
+                });
+            });
+        });
+        it('should notify creator when txp is rejected by himself and the app is open', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('TxProposalRejectedBy', {
+                    txid: '1234'
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        should.not.exist(args[0].body.notification);
+                        should.exist(args[0].body.data);
+                        should.not.exist(args[1].body.notification);
+                        should.exist(args[1].body.data);
+                        done();
+                    }, 100);
+                });
+            });
+        });
+        it('should notify creator when txp is removed and the app is open', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('TxProposalRemoved', {
+                    txid: '1234'
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        should.not.exist(args[0].body.notification);
+                        should.exist(args[0].body.data);
+                        should.not.exist(args[1].body.notification);
+                        should.exist(args[1].body.data);
+                        done();
+                    }, 100);
+                });
+            });
+            it('should use different template for new incoming tx if network is testnet', function (done) {
+                server.createAddress({}, (err, address) => {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 12300000,
+                        network: 'testnet3'
+                    }, (err) => {
+                        should.not.exist(err);
+                        setTimeout(function () {
+                            const calls = requestStub.getCalls();
+                            calls.length.should.equal(2);
+                            const args = calls.map(c => c.args[0]);
+                            args[1].body.notification.title.should.contain('New payment received');
+                            args[1].body.notification.body.should.contain('TESTNET');
+                            done();
+                        }, 100);
+                    });
+                });
+            });
+        });
+    });
+    describe('Shared wallet', function () {
+        beforeEach(async function () {
+            await helpers_1.default.beforeEach();
+            ({ wallet, server } = await helpers_1.default.createAndJoinWallet(2, 3));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await Promise.all([
+                    util_1.default.promisify(s.savePreferences).call(s, {
+                        email: 'copayer' + (i + 1) + '@domain.com',
+                        language: 'en',
+                        unit: 'bit'
+                    }),
+                    util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                        token: '1234',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    })
+                ]);
+            }
+            requestStub = sinon_1.default.stub();
+            requestStub.yields();
+            pushNotificationsService = new pushnotificationsservice_1.PushNotificationsService();
+            await util_1.default.promisify(pushNotificationsService.start).call(pushNotificationsService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                request: requestStub,
+                pushNotificationsOpts: {
+                    templatePath: 'templates',
+                    defaultLanguage: 'en',
+                    defaultUnit: 'btc',
+                    subjectPrefix: '',
+                    pushServerUrl: 'http://localhost:8000',
+                    authorizationKey: 'secret',
+                },
+            });
+        });
+        it('should build each notifications using preferences of the copayers', function (done) {
+            server.savePreferences({
+                email: 'copayer1@domain.com',
+                language: 'es',
+                unit: 'btc',
+            }, function (err) {
+                server.createAddress({}, function (err, address) {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 12300000,
+                    }, {
+                        isGlobal: true
+                    }, function (err) {
+                        setTimeout(function () {
+                            const calls = requestStub.getCalls();
+                            const args = calls.map(c => c.args[0]);
+                            calls.length.should.equal(6);
+                            args[3].body.notification.title.should.contain('Nuevo pago recibido');
+                            args[3].body.notification.body.should.contain('0.123');
+                            args[4].body.notification.title.should.contain('New payment received');
+                            args[4].body.notification.body.should.contain('123,000');
+                            args[5].body.notification.title.should.contain('New payment received');
+                            args[5].body.notification.body.should.contain('123,000');
+                            done();
+                        }, 100);
+                    });
+                });
+            });
+        });
+        it('should notify copayers when payment is received', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('NewIncomingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 12300000,
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        calls.length.should.equal(6);
+                        done();
+                    }, 100);
+                });
+            });
+        });
+        it('should notify auto-payments to creator', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('NewIncomingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 12300000,
+                }, {
+                    isGlobal: false
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = requestStub.getCalls();
+                        calls.length.should.equal(6);
+                        done();
+                    }, 100);
+                });
+            });
+        });
+        it('should notify copayers a new tx proposal has been created', function (done) {
+            helpers_1.default.stubUtxos(server, wallet, [1, 1]).then(function () {
+                server.createAddress({}, function (err, address) {
+                    should.not.exist(err);
+                    server._notify('NewTxProposal', {
+                        txid: '999',
+                        address: address,
+                        amount: 12300000,
+                    }, {
+                        isGlobal: false
+                    }, function (err) {
+                        setTimeout(function () {
+                            const calls = requestStub.getCalls();
+                            calls.length.should.equal(8);
+                            done();
+                        }, 100);
+                    });
+                });
+            });
+        });
+        it('should notify copayers a tx has been finally rejected', async function () {
+            await helpers_1.default.stubUtxos(server, wallet, 1);
+            const txOpts = {
+                outputs: [{
+                        toAddress: '18PzpUFkFZE8zKWUPvfykkTxmB9oMR8qP7',
+                        amount: 0.8e8
+                    }],
+                feePerKb: 100e2
+            };
+            const txp = await helpers_1.default.createAndPublishTx(server, txOpts, TestData.copayers[0].privKey_1H_0);
+            for (let i = 1; i < 3; i++) {
+                const copayer = TestData.copayers[i];
+                const server = await helpers_1.default.getAuthServer(copayer.id44btc);
+                await util_1.default.promisify(server.rejectTx).call(server, { txProposalId: txp.id });
+            }
+            await Utils.sleep(100);
+            const calls = requestStub.getCalls();
+            const args = calls.slice(-2).map(c => c.args[0]);
+            args[0].body.notification.title.should.contain('Payment proposal rejected');
+        });
+        it('should notify copayers a new outgoing tx has been created', async function () {
+            await helpers_1.default.stubUtxos(server, wallet, 1);
+            const txOpts = {
+                outputs: [{
+                        toAddress: '18PzpUFkFZE8zKWUPvfykkTxmB9oMR8qP7',
+                        amount: 0.8e8
+                    }],
+                feePerKb: 100e2
+            };
+            let txp = await helpers_1.default.createAndPublishTx(server, txOpts, TestData.copayers[0].privKey_1H_0);
+            for (let i = 1; i < 3; i++) {
+                const copayer = TestData.copayers[i];
+                server = await helpers_1.default.getAuthServer(copayer.id44btc);
+                const signatures = helpers_1.default.clientSign(txp, copayer.xPrivKey_44H_0H_0H);
+                txp = await util_1.default.promisify(server.signTx).call(server, {
+                    txProposalId: txp.id,
+                    signatures: signatures,
+                });
+            }
+            helpers_1.default.stubBroadcast(txp.txid);
+            await util_1.default.promisify(server.broadcastTx).call(server, { txProposalId: txp.id });
+            await Utils.sleep(100);
+            const calls = requestStub.getCalls();
+            const args = calls.slice(-3).map(c => c.args[0]);
+            args[0].body.notification.title.should.contain('Payment sent');
+            args[1].body.notification.title.should.contain('Payment sent');
+            args[2].body.notification.title.should.contain('Payment sent');
+            sjcl_1.default.codec.hex.fromBits(sjcl_1.default.hash.sha256.hash(server.copayerId)).should.not.equal(args[0].body.data.copayerId);
+            sjcl_1.default.codec.hex.fromBits(sjcl_1.default.hash.sha256.hash(server.copayerId)).should.not.equal(args[1].body.data.copayerId);
+            sjcl_1.default.codec.hex.fromBits(sjcl_1.default.hash.sha256.hash(server.copayerId)).should.equal(args[2].body.data.copayerId);
+        });
+    });
+    describe('joinWallet', function () {
+        beforeEach(async function () {
+            await helpers_1.default.beforeEach();
+            server = new server_1.WalletService();
+            const walletOpts = {
+                name: 'my wallet',
+                m: 1,
+                n: 3,
+                pubKey: TestData.keyPair.pub,
+            };
+            walletId = await util_1.default.promisify(server.createWallet).call(server, walletOpts);
+            should.exist(walletId);
+            requestStub = sinon_1.default.stub();
+            requestStub.yields();
+            pushNotificationsService = new pushnotificationsservice_1.PushNotificationsService();
+            await util_1.default.promisify(pushNotificationsService.start).call(pushNotificationsService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                request: requestStub,
+                pushNotificationsOpts: {
+                    templatePath: 'templates',
+                    defaultLanguage: 'en',
+                    defaultUnit: 'btc',
+                    subjectPrefix: '',
+                    pushServerUrl: 'http://localhost:8000',
+                    authorizationKey: 'secret',
+                },
+            });
+        });
+        it('should notify copayers when a new copayer just joined into your wallet except the one who joined', async function () {
+            for (let i = 0; i < 3; i++) {
+                const copayerOpts = helpers_1.default.getSignedCopayerOpts({
+                    walletId: walletId,
+                    name: 'copayer ' + (i + 1),
+                    xPubKey: TestData.copayers[i].xPubKey_44H_0H_0H,
+                    requestPubKey: TestData.copayers[i].pubKey_1H_0,
+                    customData: 'custom data ' + (i + 1),
+                });
+                const res = await util_1.default.promisify(server.joinWallet).call(server, copayerOpts);
+                const s = await helpers_1.default.getAuthServer(res.copayerId);
+                await util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                    token: 'token:' + copayerOpts.name,
+                    packageName: 'com.wallet',
+                    platform: 'Android',
+                    walletId: '123'
+                });
+            }
+            await Utils.sleep(100);
+            const calls = requestStub.getCalls();
+            const args = calls.map(c => c.args[0]).filter(arg => arg.body.notification.title === 'New copayer');
+            const wallet = await util_1.default.promisify(server.getWallet).call(server, null);
+            const hashedCopayerIds = wallet.copayers.map(c => sjcl_1.default.codec.hex.fromBits(sjcl_1.default.hash.sha256.hash(c.id)));
+            hashedCopayerIds[0].should.equal((args[0].body.data.copayerId));
+            hashedCopayerIds[1].should.not.equal((args[0].body.data.copayerId));
+            hashedCopayerIds[0].should.equal((args[1].body.data.copayerId));
+            hashedCopayerIds[1].should.equal((args[2].body.data.copayerId));
+            hashedCopayerIds[2].should.not.equal((args[1].body.data.copayerId));
+            hashedCopayerIds[2].should.not.equal((args[2].body.data.copayerId));
+        });
+    });
+    describe('custom ERC20 wallet', () => {
+        beforeEach(async () => {
+            await helpers_1.default.beforeEach();
+            ({ wallet, server } = await helpers_1.default.createAndJoinWallet(1, 1, { coin: 'eth' }));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await Promise.all([
+                    util_1.default.promisify(s.savePreferences).call(s, {
+                        email: 'copayer' + (i + 1) + '@domain.com',
+                        language: 'en',
+                        unit: 'bit',
+                        tokenAddresses: CUSTOM_TOKENS,
+                    }),
+                    util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                        token: '1234',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    })
+                ]);
+            }
+            pushNotificationsService = new pushnotificationsservice_1.PushNotificationsService();
+            requestStub = sinon_1.default.stub(pushNotificationsService, '_makeRequest').callsFake(() => { });
+            requestStub.yields();
+            getTokenDataStub = sinon_1.default.stub(pushNotificationsService, 'getTokenData').callsFake(() => TestData.CoinGecko_ETH_Tokens.tokens);
+            await util_1.default.promisify(pushNotificationsService.start).call(pushNotificationsService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                request: null,
+                pushNotificationsOpts: {
+                    templatePath: 'templates',
+                    defaultLanguage: 'en',
+                    defaultUnit: 'eth',
+                    subjectPrefix: '',
+                    pushServerUrl: 'http://localhost:8000',
+                    authorizationKey: 'secret',
+                },
+            });
+        });
+        it('should send notification if the tx is custom token', (done) => {
+            server.savePreferences({
+                language: 'en',
+                unit: 'bit',
+            }, function (err) {
+                server.createAddress({}, (err, address) => {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '997',
+                        address: address,
+                        amount: 4e18,
+                        tokenAddress: CUSTOM_TOKENS[0]
+                    }, {
+                        isGlobal: true
+                    }, (err) => {
+                        Utils.sleep(1000).then(function () {
+                            const calls = requestStub.getCalls();
+                            calls.length.should.equal(2);
+                            const args = calls.slice(-2).map(c => c.args[0]);
+                            args[1].notification.title.should.contain('New payment received');
+                            args[1].notification.body.should.contain('4.00');
+                            args[1].data.tokenAddress.should.equal('0x0d8775f648430679a709e98d2b0cb6250d2887ef');
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+    });
+    describe('ERC20 wallet', () => {
+        beforeEach(async () => {
+            await helpers_1.default.beforeEach();
+            ({ wallet, server } = await helpers_1.default.createAndJoinWallet(1, 1, { coin: 'eth' }));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await Promise.all([
+                    util_1.default.promisify(s.savePreferences).call(s, {
+                        email: 'copayer' + (i + 1) + '@domain.com',
+                        language: 'en',
+                        unit: 'bit',
+                        tokenAddresses: TOKENS,
+                    }),
+                    util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                        token: '1234',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    })
+                ]);
+            }
+            requestStub = sinon_1.default.stub();
+            requestStub.yields();
+            pushNotificationsService = new pushnotificationsservice_1.PushNotificationsService();
+            getTokenDataStub = sinon_1.default.stub(pushNotificationsService, 'getTokenData').callsFake(() => TestData.CoinGecko_ETH_Tokens.tokens);
+            await util_1.default.promisify(pushNotificationsService.start).call(pushNotificationsService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                request: requestStub,
+                pushNotificationsOpts: {
+                    templatePath: 'templates',
+                    defaultLanguage: 'en',
+                    defaultUnit: 'eth',
+                    subjectPrefix: '',
+                    pushServerUrl: 'http://localhost:8000',
+                    authorizationKey: 'secret',
+                },
+            });
+        });
+        it('should send notification if the tx is USDC.e', (done) => {
+            server.savePreferences({
+                language: 'en',
+                unit: 'bit',
+            }, function (err) {
+                server.createAddress({}, (err, address) => {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '996',
+                        address: address,
+                        amount: 4e6,
+                        tokenAddress: TOKENS[3]
+                    }, {
+                        isGlobal: true
+                    }, (err) => {
+                        Utils.sleep(100).then(function () {
+                            const calls = requestStub.getCalls();
+                            calls.length.should.equal(2);
+                            const args = calls.slice(-2).map(c => c.args[0]);
+                            args[1].body.notification.title.should.contain('New payment received');
+                            args[1].body.notification.title.should.contain('New payment received');
+                            args[1].body.notification.body.should.contain('4.00');
+                            args[1].body.data.tokenAddress.should.equal('0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174');
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+        it('should send notification if the tx is USDC', (done) => {
+            server.savePreferences({
+                language: 'en',
+                unit: 'bit',
+            }, function (err) {
+                server.createAddress({}, (err, address) => {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '997',
+                        address: address,
+                        amount: 4e6,
+                        tokenAddress: TOKENS[0]
+                    }, {
+                        isGlobal: true
+                    }, (err) => {
+                        Utils.sleep(100).then(function () {
+                            const calls = requestStub.getCalls();
+                            calls.length.should.equal(2);
+                            const args = calls.slice(-2).map(c => c.args[0]);
+                            args[1].body.notification.title.should.contain('New payment received');
+                            args[1].body.notification.title.should.contain('New payment received');
+                            args[1].body.notification.body.should.contain('4.00');
+                            args[1].body.data.tokenAddress.should.equal('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48');
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+        it('should send notification if the tx is USDP', (done) => {
+            server.savePreferences({
+                language: 'es',
+                unit: 'bit',
+            }, function (err) {
+                server.createAddress({}, (err, address) => {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '998',
+                        address: address,
+                        amount: 4e18,
+                        tokenAddress: TOKENS[1]
+                    }, {
+                        isGlobal: true
+                    }, (err) => {
+                        Utils.sleep(100).then(function () {
+                            const calls = requestStub.getCalls();
+                            calls.length.should.equal(2);
+                            const args = calls.slice(-2).map(c => c.args[0]);
+                            args[1].body.notification.title.should.contain('Nuevo pago recibido');
+                            args[1].body.notification.body.should.contain('4.00');
+                            args[1].body.data.tokenAddress.should.equal('0x8E870D67F660D95d5be530380D0eC0bd388289E1');
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+        it('should send notification if the tx is GUSD', (done) => {
+            server.savePreferences({
+                language: 'en',
+                unit: 'bit',
+            }, function (err) {
+                server.createAddress({}, (err, address) => {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 4e2,
+                        tokenAddress: TOKENS[2]
+                    }, {
+                        isGlobal: true
+                    }, (err) => {
+                        Utils.sleep(100).then(function () {
+                            const calls = requestStub.getCalls();
+                            calls.length.should.equal(2);
+                            const args = calls.slice(-2).map(c => c.args[0]);
+                            args[1].body.notification.title.should.contain('New payment received');
+                            args[1].body.notification.body.should.contain('4.00');
+                            args[1].body.data.tokenAddress.should.equal('0x056Fd409E1d7A124BD7017459dFEa2F387b6d5Cd');
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+        it('should not send notification if the tokenAddress is not supported', (done) => {
+            server.savePreferences({
+                language: 'en',
+                unit: 'bit',
+            }, function (err) {
+                server.createAddress({}, (err, address) => {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 1230000000,
+                        tokenAddress: 'notSupportedTokenAddress'
+                    }, {
+                        isGlobal: true
+                    }, (err) => {
+                        Utils.sleep(100).then(function () {
+                            const calls = requestStub.getCalls();
+                            calls.length.should.equal(1);
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+    });
+    describe('Any wallet', function () {
+        beforeEach(async function () {
+            await helpers_1.default.beforeEach();
+            ({ wallet, server } = await helpers_1.default.createAndJoinWallet(1, 1));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await Promise.all([
+                    util_1.default.promisify(s.savePreferences).call(s, {
+                        email: 'copayer' + (i + 1) + '@domain.com',
+                        language: 'en',
+                        unit: 'bit',
+                    }),
+                    util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                        token: 'DEVICE_TOKEN',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    }),
+                    util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                        token: 'DEVICE_TOKEN2',
+                        packageName: 'com.my-other-wallet',
+                        platform: 'iOS',
+                        walletId: '123'
+                    })
+                ]);
+            }
+            requestStub = sinon_1.default.stub();
+            requestStub.yields();
+            pushNotificationsService = new pushnotificationsservice_1.PushNotificationsService();
+            await util_1.default.promisify(pushNotificationsService.start).call(pushNotificationsService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                request: requestStub,
+                pushNotificationsOpts: {
+                    templatePath: 'templates',
+                    defaultLanguage: 'en',
+                    defaultUnit: 'btc',
+                    subjectPrefix: '',
+                    pushServerUrl: 'http://localhost:8000',
+                    authorizationKey: 'secret',
+                },
+            });
+        });
+        it('should notify NewBlock to all devices subscribed in the last 10 minutes', function (done) {
+            const collections = storage_1.Storage.collections;
+            const oldSubscription = {
+                _id: new mongodb_1.ObjectID('5fb57ecde3de1d285042a551'),
+                version: '1.0.0',
+                createdOn: 1605729997,
+                copayerId: wallet.copayers[0].id,
+                token: 'DEVICE_TOKEN3',
+                packageName: 'com.my-other-wallet2',
+                platform: 'any',
+                walletId: '123'
+            };
+            server.storage.db.collection(collections.PUSH_NOTIFICATION_SUBS).insertOne(oldSubscription, function (err) {
+                should.not.exist(err);
+                server._notify('NewBlock', {
+                    hash: 'dummy hash',
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    should.not.exist(err);
+                    Utils.sleep(100).then(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        should.not.exist(args[0].body.notification);
+                        should.exist(args[0].body.data);
+                        should.not.exist(args[1].body.notification);
+                        should.exist(args[1].body.data);
+                        done();
+                    });
+                });
+            });
+        });
+        it('should notify only one NewBlock push notification for each device', function (done) {
+            const collections = storage_1.Storage.collections;
+            const subs = [{
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    token: 'DEVICE_TOKEN',
+                    packageName: 'com.my-other-wallet',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    token: 'DEVICE_TOKEN2',
+                    packageName: 'com.my-other-wallet2',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    token: 'DEVICE_TOKEN2',
+                    packageName: 'com.my-other-wallet2',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    token: 'DEVICE_TOKEN3',
+                    packageName: 'com.my-other-wallet3',
+                    platform: 'any',
+                    walletId: '123'
+                }];
+            server.storage.db.collection(collections.PUSH_NOTIFICATION_SUBS).insertMany(subs, function (err) {
+                should.not.exist(err);
+                server._notify('NewBlock', {
+                    hash: 'dummy hash',
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    should.not.exist(err);
+                    Utils.sleep(100).then(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(3);
+                        should.not.exist(args[0].body.notification);
+                        should.exist(args[0].body.data);
+                        should.not.exist(args[1].body.notification);
+                        should.exist(args[1].body.data);
+                        should.not.exist(args[2].body.notification);
+                        should.exist(args[2].body.data);
+                        done();
+                    });
+                });
+            });
+        });
+    });
+    describe('Single wallet - Braze', function () {
+        beforeEach(async function () {
+            await helpers_1.default.beforeEach();
+            ({ wallet, server } = await helpers_1.default.createAndJoinWallet(1, 1));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await Promise.all([
+                    util_1.default.promisify(s.savePreferences).call(s, {
+                        email: 'copayer' + (i + 1) + '@domain.com',
+                        language: 'en',
+                        unit: 'bit',
+                    }),
+                    util_1.default.promisify(s.pushNotificationsBrazeSubscribe).call(s, {
+                        externalUserId: '1234',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    })
+                ]);
+            }
+            requestStub = sinon_1.default.stub();
+            requestStub.yields();
+            pushNotificationsService = new pushnotificationsservice_1.PushNotificationsService();
+            await util_1.default.promisify(pushNotificationsService.start).call(pushNotificationsService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                request: requestStub,
+                pushNotificationsOpts: {
+                    templatePath: 'templates',
+                    defaultLanguage: 'en',
+                    defaultUnit: 'btc',
+                    subjectPrefix: '',
+                    pushServerUrlBraze: 'http://localhost:8000',
+                    authorizationKeyBraze: 'secret',
+                },
+            });
+        });
+        it('should build each notifications using preferences of the copayers', function (done) {
+            server.savePreferences({
+                language: 'en',
+                unit: 'bit',
+            }, function (err) {
+                server.createAddress({}, function (err, address) {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 12300000,
+                    }, {
+                        isGlobal: true
+                    }, function (err) {
+                        Utils.sleep(100).then(function () {
+                            const calls = requestStub.getCalls();
+                            const args = calls.map(c => c.args[0]);
+                            calls.length.should.equal(2);
+                            should.not.exist(args[0].body.messages.apple_push.alert.title);
+                            should.not.exist(args[0].body.messages.apple_push.alert.body);
+                            should.not.exist(args[0].body.messages.android_push.alert);
+                            should.not.exist(args[0].body.messages.android_push.title);
+                            should.exist(args[0].body.messages.android_push.send_to_sync);
+                            should.exist(args[0].body.messages.apple_push['content-available']);
+                            args[1].body.messages.apple_push.alert.title.should.contain('New payment received');
+                            args[1].body.messages.apple_push.alert.body.should.contain('123,000');
+                            args[1].body.messages.apple_push.alert.body.should.contain('bits');
+                            args[1].body.messages.android_push.title.should.contain('New payment received');
+                            args[1].body.messages.android_push.alert.should.contain('123,000');
+                            args[1].body.messages.android_push.alert.should.contain('bits');
+                            should.not.exist(args[1].body.messages.android_push.send_to_sync);
+                            should.not.exist(args[1].body.messages.apple_push['content-available']);
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+    });
+    describe('Single wallet - Should use braze subscription if both set', function () {
+        beforeEach(async function () {
+            await helpers_1.default.beforeEach();
+            ({ wallet, server } = await helpers_1.default.createAndJoinWallet(1, 1));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await Promise.all([
+                    util_1.default.promisify(s.savePreferences).call(s, {
+                        email: 'copayer' + (i + 1) + '@domain.com',
+                        language: 'en',
+                        unit: 'bit',
+                    }),
+                    util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                        token: '1234',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    }),
+                    util_1.default.promisify(s.pushNotificationsBrazeSubscribe).call(s, {
+                        externalUserId: '1234',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    })
+                ]);
+            }
+            requestStub = sinon_1.default.stub();
+            requestStub.yields();
+            pushNotificationsService = new pushnotificationsservice_1.PushNotificationsService();
+            await util_1.default.promisify(pushNotificationsService.start).call(pushNotificationsService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                request: requestStub,
+                pushNotificationsOpts: {
+                    templatePath: 'templates',
+                    defaultLanguage: 'en',
+                    defaultUnit: 'btc',
+                    subjectPrefix: '',
+                    pushServerUrl: 'http://localhost:8000',
+                    pushServerUrlBraze: 'http://localhost:8000',
+                    authorizationKey: 'secret',
+                    authorizationKeyBraze: 'secret',
+                }
+            });
+        });
+        it('should build each notifications using preferences of the copayers', function (done) {
+            server.savePreferences({
+                language: 'en',
+                unit: 'bit',
+            }, function (err) {
+                server.createAddress({}, function (err, address) {
+                    should.not.exist(err);
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 12300000,
+                    }, {
+                        isGlobal: true
+                    }, function (err) {
+                        Utils.sleep(100).then(function () {
+                            const calls = requestStub.getCalls();
+                            const args = calls.map(c => c.args[0]);
+                            calls.length.should.equal(2);
+                            should.not.exist(args[0].body.messages.apple_push.alert.title);
+                            should.not.exist(args[0].body.messages.apple_push.alert.body);
+                            should.not.exist(args[0].body.messages.android_push.alert);
+                            should.not.exist(args[0].body.messages.android_push.title);
+                            should.exist(args[0].body.messages.android_push.send_to_sync);
+                            should.exist(args[0].body.messages.apple_push['content-available']);
+                            args[1].body.messages.apple_push.alert.title.should.contain('New payment received');
+                            args[1].body.messages.apple_push.alert.body.should.contain('123,000');
+                            args[1].body.messages.apple_push.alert.body.should.contain('bits');
+                            args[1].body.messages.android_push.title.should.contain('New payment received');
+                            args[1].body.messages.android_push.alert.should.contain('123,000');
+                            args[1].body.messages.android_push.alert.should.contain('bits');
+                            should.not.exist(args[1].body.messages.android_push.send_to_sync);
+                            should.not.exist(args[1].body.messages.apple_push['content-available']);
+                            done();
+                        });
+                    });
+                });
+            });
+        });
+    });
+    describe('Any wallet - Should use braze subscription if both set', function () {
+        beforeEach(async function () {
+            await helpers_1.default.beforeEach();
+            ({ wallet, server } = await helpers_1.default.createAndJoinWallet(1, 1));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await Promise.all([
+                    util_1.default.promisify(s.savePreferences).call(s, {
+                        email: 'copayer' + (i + 1) + '@domain.com',
+                        language: 'en',
+                        unit: 'bit',
+                    }),
+                    util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                        token: 'DEVICE_TOKEN',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    }),
+                    util_1.default.promisify(s.pushNotificationsSubscribe).call(s, {
+                        token: 'DEVICE_TOKEN2',
+                        packageName: 'com.my-other-wallet',
+                        platform: 'iOS',
+                        walletId: '123'
+                    }),
+                    util_1.default.promisify(s.pushNotificationsBrazeSubscribe).call(s, {
+                        externalUserId: 'DEVICE_EXTERNAL_USER_ID',
+                        packageName: 'com.wallet',
+                        platform: 'Android',
+                        walletId: '123'
+                    }),
+                    util_1.default.promisify(s.pushNotificationsBrazeSubscribe).call(s, {
+                        externalUserId: 'DEVICE_EXTERNAL_USER_ID2',
+                        packageName: 'com.my-other-wallet',
+                        platform: 'iOS',
+                        walletId: '123'
+                    })
+                ]);
+            }
+            requestStub = sinon_1.default.stub();
+            requestStub.yields();
+            pushNotificationsService = new pushnotificationsservice_1.PushNotificationsService();
+            await util_1.default.promisify(pushNotificationsService.start).call(pushNotificationsService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                request: requestStub,
+                pushNotificationsOpts: {
+                    templatePath: 'templates',
+                    defaultLanguage: 'en',
+                    defaultUnit: 'btc',
+                    subjectPrefix: '',
+                    pushServerUrl: 'http://localhost:8000',
+                    pushServerUrlBraze: 'http://localhost:8000',
+                    authorizationKey: 'secret',
+                    authorizationKeyBraze: 'secret',
+                }
+            });
+        });
+        it('should notify NewBlock to all devices subscribed in the last 10 minutes', function (done) {
+            const collections = storage_1.Storage.collections;
+            const oldSubscription = {
+                _id: new mongodb_1.ObjectID('5fb57ecde3de1d285042a551'),
+                version: '1.0.0',
+                createdOn: 1605729997,
+                copayerId: wallet.copayers[0].id,
+                externalUserId: 'DEVICE_EXTERNAL_USER_ID3',
+                packageName: 'com.my-other-wallet2',
+                platform: 'any',
+                walletId: '123'
+            };
+            server.storage.db.collection(collections.PUSH_NOTIFICATION_SUBS).insertOne(oldSubscription, function (err) {
+                should.not.exist(err);
+                server._notify('NewBlock', {
+                    hash: 'dummy hash',
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    should.not.exist(err);
+                    Utils.sleep(100).then(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(2);
+                        should.not.exist(args[0].body.messages.apple_push.alert.title);
+                        should.not.exist(args[0].body.messages.apple_push.alert.body);
+                        should.not.exist(args[0].body.messages.android_push.alert);
+                        should.not.exist(args[0].body.messages.android_push.title);
+                        should.not.exist(args[1].body.messages.apple_push.alert.title);
+                        should.not.exist(args[1].body.messages.apple_push.alert.body);
+                        should.not.exist(args[1].body.messages.android_push.alert);
+                        should.not.exist(args[1].body.messages.android_push.title);
+                        should.exist(args[0].body.messages.apple_push.extra);
+                        should.exist(args[0].body.messages.apple_push.custom_uri);
+                        should.exist(args[0].body.messages.android_push.extra);
+                        should.exist(args[0].body.messages.android_push.custom_uri);
+                        should.exist(args[0].body.messages.android_push.send_to_sync);
+                        should.exist(args[0].body.messages.apple_push['content-available']);
+                        should.exist(args[1].body.messages.apple_push.extra);
+                        should.exist(args[1].body.messages.apple_push.custom_uri);
+                        should.exist(args[1].body.messages.android_push.extra);
+                        should.exist(args[1].body.messages.android_push.custom_uri);
+                        should.exist(args[1].body.messages.android_push.send_to_sync);
+                        should.exist(args[1].body.messages.apple_push['content-available']);
+                        done();
+                    });
+                });
+            });
+        });
+        it('should notify only one NewBlock push notification for each device', function (done) {
+            const collections = storage_1.Storage.collections;
+            const subs = [{
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    token: 'DEVICE_TOKEN',
+                    packageName: 'com.my-other-wallet',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    token: 'DEVICE_TOKEN2',
+                    packageName: 'com.my-other-wallet2',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    token: 'DEVICE_TOKEN2',
+                    packageName: 'com.my-other-wallet2',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    token: 'DEVICE_TOKEN3',
+                    packageName: 'com.my-other-wallet3',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    externalUserId: 'DEVICE_EXTERNAL_USER_ID',
+                    packageName: 'com.my-other-wallet',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    externalUserId: 'DEVICE_EXTERNAL_USER_ID2',
+                    packageName: 'com.my-other-wallet2',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    externalUserId: 'DEVICE_EXTERNAL_USER_ID2',
+                    packageName: 'com.my-other-wallet2',
+                    platform: 'any',
+                    walletId: '123'
+                },
+                {
+                    version: '1.0.0',
+                    createdOn: Math.floor(Date.now() / 1000),
+                    copayerId: wallet.copayers[0].id,
+                    externalUserId: 'DEVICE_EXTERNAL_USER_ID3',
+                    packageName: 'com.my-other-wallet3',
+                    platform: 'any',
+                    walletId: '123'
+                }];
+            server.storage.db.collection(collections.PUSH_NOTIFICATION_SUBS).insertMany(subs, function (err) {
+                should.not.exist(err);
+                server._notify('NewBlock', {
+                    hash: 'dummy hash',
+                }, {
+                    isGlobal: true
+                }, function (err) {
+                    should.not.exist(err);
+                    Utils.sleep(100).then(function () {
+                        const calls = requestStub.getCalls();
+                        const args = calls.map(c => c.args[0]);
+                        calls.length.should.equal(3);
+                        should.not.exist(args[0].body.messages.apple_push.alert.title);
+                        should.not.exist(args[0].body.messages.apple_push.alert.body);
+                        should.not.exist(args[0].body.messages.android_push.alert);
+                        should.not.exist(args[0].body.messages.android_push.title);
+                        should.not.exist(args[1].body.messages.apple_push.alert.title);
+                        should.not.exist(args[1].body.messages.apple_push.alert.body);
+                        should.not.exist(args[1].body.messages.android_push.alert);
+                        should.not.exist(args[1].body.messages.android_push.title);
+                        should.not.exist(args[2].body.messages.apple_push.alert.title);
+                        should.not.exist(args[2].body.messages.apple_push.alert.body);
+                        should.not.exist(args[2].body.messages.android_push.alert);
+                        should.not.exist(args[2].body.messages.android_push.title);
+                        should.exist(args[0].body.messages.android_push.send_to_sync);
+                        should.exist(args[0].body.messages.apple_push['content-available']);
+                        should.exist(args[1].body.messages.android_push.send_to_sync);
+                        should.exist(args[1].body.messages.apple_push['content-available']);
+                        should.exist(args[2].body.messages.android_push.send_to_sync);
+                        should.exist(args[2].body.messages.apple_push['content-available']);
+                        should.exist(args[0].body.messages.apple_push.extra);
+                        should.exist(args[0].body.messages.apple_push.custom_uri);
+                        should.exist(args[0].body.messages.android_push.extra);
+                        should.exist(args[0].body.messages.android_push.custom_uri);
+                        should.exist(args[1].body.messages.apple_push.extra);
+                        should.exist(args[1].body.messages.apple_push.custom_uri);
+                        should.exist(args[1].body.messages.android_push.extra);
+                        should.exist(args[1].body.messages.android_push.custom_uri);
+                        should.exist(args[2].body.messages.apple_push.extra);
+                        should.exist(args[2].body.messages.apple_push.custom_uri);
+                        should.exist(args[2].body.messages.android_push.extra);
+                        should.exist(args[2].body.messages.android_push.custom_uri);
+                        done();
+                    });
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=pushNotifications.test.js.map