@bitpay-labs/bitcore-wallet-service 11.5.2

package/ts_build/test/integration/emailnotifications.test.js

@@ -0,0 +1,805 @@
+'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 logger_1 = require("../../src/lib/logger");
+const emailservice_1 = require("../../src/lib/emailservice");
+const common_1 = require("../../src/lib/common");
+const TestData = __importStar(require("../testdata"));
+const helpers_1 = __importDefault(require("./helpers"));
+const should = chai.should();
+for (const transport of logger_1.transports) {
+    transport.level = 'error';
+}
+const { Utils } = common_1.Common;
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const TOKENS = [
+    '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+    '0x8E870D67F660D95d5be530380D0eC0bd388289E1'
+];
+const CUSTOM_TOKENS = [
+    '0x0d8775f648430679a709e98d2b0cb6250d2887ef'
+];
+describe('Email notifications', function () {
+    this.timeout(5000);
+    let storage;
+    let server;
+    let wallet;
+    let mailerStub;
+    let getTokenDataStub;
+    let emailService;
+    function sendEmailInterceptor(testCallback) {
+        const sendEmailIdx = emailService.messageBroker._events.msg.findIndex(fn => fn.name === 'bound sendEmail');
+        const sendEmail = emailService.messageBroker._events.msg[sendEmailIdx];
+        emailService.messageBroker._events.msg[sendEmailIdx] = sinon_1.default.stub().callsFake(function (notification, cb) {
+            sendEmail(notification, function (err) {
+                cb && cb(err);
+                testCallback();
+            });
+        });
+    }
+    ;
+    before(async function () {
+        const res = await helpers_1.default.before();
+        storage = res.storage;
+    });
+    after(async function () {
+        await helpers_1.default.after();
+    });
+    beforeEach(async function () {
+        await helpers_1.default.beforeEach();
+    });
+    afterEach(function () {
+        sinon_1.default.restore();
+    });
+    describe('Shared wallet', function () {
+        beforeEach(async function () {
+            ({ server, wallet } = 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 util_1.default.promisify(s.savePreferences).call(s, {
+                    email: 'copayer' + (i + 1) + '@domain.com',
+                    unit: 'bit',
+                });
+            }
+            mailerStub = sinon_1.default.stub();
+            mailerStub.send = sinon_1.default.stub();
+            mailerStub.send.returns(Promise.resolve('ok'));
+            emailService = new emailservice_1.EmailService();
+            await util_1.default.promisify(emailService.start).call(emailService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: storage,
+                mailer: mailerStub,
+                emailOpts: {
+                    mailer: 'sendgrid',
+                    sendGridApiKey: 'asdf',
+                    from: 'bws@dummy.net',
+                    subjectPrefix: '[test wallet]',
+                    publicTxUrlTemplate: {
+                        btc: {
+                            livenet: 'https://insight.bitpay.com/tx/{{txid}}',
+                            testnet: 'https://test-insight.bitpay.com/tx/{{txid}}',
+                        },
+                        bch: {
+                            livenet: 'https://bch-insight.bitpay.com/#/tx/{{txid}}',
+                            testnet: 'https://test-bch-insight.bitpay.com/#/tx/{{txid}}',
+                        }
+                    },
+                },
+            });
+            emailService.mailer = mailerStub;
+            emailService.sendMail = mailerStub.send;
+        });
+        it('should notify copayers a new tx proposal has been created', async function () {
+            const _readTemplateFile_old = emailService._readTemplateFile;
+            emailService._readTemplateFile = function (language, filename, cb) {
+                if (filename.endsWith('.html')) {
+                    return cb(null, '<html><body>{{walletName}}</body></html>');
+                }
+                else {
+                    _readTemplateFile_old.call(emailService, language, filename, cb);
+                }
+            };
+            await helpers_1.default.stubUtxos(server, wallet, [1, 1]);
+            const txOpts = {
+                outputs: [{
+                        toAddress: '18PzpUFkFZE8zKWUPvfykkTxmB9oMR8qP7',
+                        amount: 0.8e8
+                    }],
+                feePerKb: 100e2
+            };
+            await helpers_1.default.createAndPublishTx(server, txOpts, TestData.copayers[0].privKey_1H_0);
+            await sleep(100);
+            const calls = mailerStub.send.getCalls();
+            calls.length.should.equal(2);
+            const emails = calls.map(c => c.args[0]);
+            Utils.difference(['copayer2@domain.com', 'copayer3@domain.com'], emails.map(e => e.to)).should.be.empty;
+            const one = emails[0];
+            one.from.should.equal('bws@dummy.net');
+            one.subject.should.contain('New payment proposal');
+            should.exist(one.html);
+            one.html.indexOf('<!DOCTYPE html').should.equal(0);
+            const unsent = await util_1.default.promisify(server.storage.fetchUnsentEmails).call(server.storage);
+            unsent.should.be.empty;
+            emailService._readTemplateFile = _readTemplateFile_old;
+        });
+        it('should not send email if unable to apply template to notification', async function () {
+            const _applyTemplate_old = emailService._applyTemplate;
+            emailService._applyTemplate = function (template, data, cb) {
+                _applyTemplate_old.call(emailService, template, undefined, cb);
+            };
+            await helpers_1.default.stubUtxos(server, wallet, [1, 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);
+            await sleep(100);
+            const calls = mailerStub.send.getCalls();
+            calls.length.should.equal(0);
+            const unsent = await util_1.default.promisify(server.storage.fetchUnsentEmails).call(server.storage);
+            unsent.should.be.empty;
+            emailService._applyTemplate = _applyTemplate_old;
+        });
+        it('should notify copayers a new outgoing tx has been created', async function () {
+            const _readTemplateFile_old = emailService._readTemplateFile;
+            emailService._readTemplateFile = function (language, filename, cb) {
+                if (filename.endsWith('.html')) {
+                    return cb(null, '<html>{{&urlForTx}}<html>');
+                }
+                else {
+                    _readTemplateFile_old.call(emailService, language, filename, cb);
+                }
+            };
+            await helpers_1.default.stubUtxos(server, wallet, [1, 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 = 0; i < 2; i++) {
+                const copayer = TestData.copayers[i];
+                const s = 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(s.signTx).call(s, {
+                    txProposalId: txp.id,
+                    signatures: signatures,
+                });
+            }
+            helpers_1.default.stubBroadcast(txp.txid);
+            await sleep(100);
+            await util_1.default.promisify(server.broadcastTx).call(server, {
+                txProposalId: txp.id,
+            });
+            await sleep(100);
+            const calls = mailerStub.send.getCalls();
+            const emails = calls.slice(-3).map(c => c.args[0]);
+            Utils.difference(['copayer1@domain.com', 'copayer2@domain.com', 'copayer3@domain.com'], emails.map(e => e.to)).should.be.empty;
+            const one = emails[0];
+            one.from.should.equal('bws@dummy.net');
+            one.subject.should.contain('Payment sent');
+            one.text.should.contain('800,000');
+            should.exist(one.html);
+            one.html.should.contain('https://insight.bitpay.com/tx/' + txp.txid);
+            const unsent = await util_1.default.promisify(server.storage.fetchUnsentEmails).call(server.storage);
+            unsent.should.be.empty;
+            emailService._readTemplateFile = _readTemplateFile_old;
+        });
+        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);
+            const txpId = txp.id;
+            for (let i = 1; i <= 2; i++) {
+                const copayer = TestData.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id44btc);
+                await util_1.default.promisify(s.rejectTx).call(s, {
+                    txProposalId: txp.id,
+                });
+            }
+            await sleep(100);
+            const calls = mailerStub.send.getCalls();
+            const emails = calls.slice(-2).map(c => c.args[0]);
+            Utils.difference(['copayer1@domain.com', 'copayer2@domain.com'], emails.map(e => e.to)).should.be.empty;
+            const one = emails[0];
+            one.from.should.equal('bws@dummy.net');
+            one.subject.should.contain('Payment proposal rejected');
+            const unsent = await util_1.default.promisify(server.storage.fetchUnsentEmails).call(server.storage);
+            unsent.should.be.empty;
+        });
+        it('should handle small incomming payments (btc)', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                server._notify('NewIncomingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 13000,
+                }, function (err) {
+                    setTimeout(function () {
+                        const calls = mailerStub.send.getCalls();
+                        calls.length.should.equal(3);
+                        const emails = calls.map(c => c.args[0]);
+                        Utils.difference(['copayer1@domain.com', 'copayer2@domain.com', 'copayer3@domain.com'], emails.map(e => e.to)).should.be.empty;
+                        const one = emails[0];
+                        one.from.should.equal('bws@dummy.net');
+                        one.subject.should.contain('New payment received');
+                        one.text.should.contain('130 bits');
+                        server.storage.fetchUnsentEmails(function (err, unsent) {
+                            should.not.exist(err);
+                            unsent.should.be.empty;
+                            done();
+                        });
+                    }, 100);
+                });
+            });
+        });
+        it('should notify copayers of incoming txs', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                sendEmailInterceptor(function () {
+                    const calls = mailerStub.send.getCalls();
+                    calls.length.should.equal(3);
+                    const emails = calls.map(c => c.args[0]);
+                    Utils.difference(['copayer1@domain.com', 'copayer2@domain.com', 'copayer3@domain.com'], emails.map(e => e.to)).should.be.empty;
+                    const one = emails[0];
+                    one.from.should.equal('bws@dummy.net');
+                    one.subject.should.contain('New payment received');
+                    one.text.should.contain('123,000');
+                    server.storage.fetchUnsentEmails(function (err, unsent) {
+                        should.not.exist(err);
+                        unsent.should.be.empty;
+                        done();
+                    });
+                });
+                server._notify('NewIncomingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 12300000,
+                }, function (err) {
+                    should.not.exist(err);
+                });
+            });
+        });
+        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);
+                    sendEmailInterceptor(function () {
+                        const calls = mailerStub.send.getCalls();
+                        calls.length.should.equal(1);
+                        const email = calls[0].args[0];
+                        email.to.should.equal('copayer1@domain.com');
+                        email.from.should.equal('bws@dummy.net');
+                        email.subject.should.contain('Transaction confirmed');
+                        server.storage.fetchUnsentEmails(function (err, unsent) {
+                            should.not.exist(err);
+                            unsent.should.be.empty;
+                            done();
+                        });
+                    });
+                    server._notify('TxConfirmation', {
+                        txid: '123',
+                    }, function (err) {
+                        should.not.exist(err);
+                    });
+                });
+            });
+        });
+        it('should notify each email address only once', function (done) {
+            server.savePreferences({
+                email: 'copayer2@domain.com',
+            }, function (err) {
+                server.createAddress({}, function (err, address) {
+                    should.not.exist(err);
+                    sendEmailInterceptor(function () {
+                        const calls = mailerStub.send.getCalls();
+                        calls.length.should.equal(2);
+                        const emails = calls.map(c => c.args[0]);
+                        Utils.difference(['copayer2@domain.com', 'copayer3@domain.com'], emails.map(e => e.to)).should.be.empty;
+                        const one = emails[0];
+                        one.from.should.equal('bws@dummy.net');
+                        one.subject.should.contain('New payment received');
+                        one.text.should.contain('123,000');
+                        server.storage.fetchUnsentEmails(function (err, unsent) {
+                            should.not.exist(err);
+                            unsent.should.be.empty;
+                            done();
+                        });
+                    });
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 12300000,
+                    }, function (err) {
+                        should.not.exist(err);
+                    });
+                });
+            });
+        });
+        it('should build each email 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);
+                    sendEmailInterceptor(function () {
+                        const calls = mailerStub.send.getCalls();
+                        calls.length.should.equal(3);
+                        const emails = calls.map(c => c.args[0]);
+                        const spanish = emails.find(email => email.to === 'copayer1@domain.com');
+                        spanish.from.should.equal('bws@dummy.net');
+                        spanish.subject.should.contain('Nuevo pago recibido');
+                        spanish.text.should.contain('0.123 BTC');
+                        const english = emails.find(email => email.to === 'copayer2@domain.com');
+                        english.from.should.equal('bws@dummy.net');
+                        english.subject.should.contain('New payment received');
+                        english.text.should.contain('123,000 bits');
+                        done();
+                    });
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 12300000,
+                    }, function (err) {
+                        should.not.exist(err);
+                    });
+                });
+            });
+        });
+        it('should support multiple emailservice instances running concurrently', function (done) {
+            const emailService2 = new emailservice_1.EmailService();
+            emailService2.start({
+                lock: emailService.lock,
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                mailer: mailerStub,
+                emailOpts: {
+                    mailer: 'nodemailer',
+                    from: 'bws2@dummy.net',
+                    subjectPrefix: '[test wallet 2]',
+                },
+            }, function (err) {
+                emailService2.mailer = mailerStub;
+                emailService2.sendMail = mailerStub.send;
+                helpers_1.default.stubUtxos(server, wallet, 1).then(() => {
+                    const txOpts = {
+                        outputs: [{
+                                toAddress: '18PzpUFkFZE8zKWUPvfykkTxmB9oMR8qP7',
+                                amount: 0.8e8
+                            }],
+                        feePerKb: 100e2
+                    };
+                    helpers_1.default.createAndPublishTx(server, txOpts, TestData.copayers[0].privKey_1H_0).then((tx) => {
+                        setTimeout(function () {
+                            const calls = mailerStub.send.getCalls();
+                            calls.length.should.equal(2);
+                            server.storage.fetchUnsentEmails(function (err, unsent) {
+                                should.not.exist(err);
+                                unsent.should.be.empty;
+                                done();
+                            });
+                        }, 200);
+                    });
+                });
+            });
+        });
+        it('should handler mailer errors ', function (done) {
+            mailerStub.send.rejects('err');
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                sendEmailInterceptor(function () {
+                    const calls = mailerStub.send.getCalls();
+                    calls.length.should.equal(3);
+                    const emails = calls.map(c => c.args[0]);
+                    Utils.difference(['copayer1@domain.com', 'copayer2@domain.com', 'copayer3@domain.com'], emails.map(e => e.to)).should.be.empty;
+                    const one = emails[0];
+                    one.from.should.equal('bws@dummy.net');
+                    one.subject.should.contain('New payment received');
+                    one.text.should.contain('123,000');
+                    server.storage.fetchUnsentEmails(function (err, unsent) {
+                        should.not.exist(err);
+                        unsent.length.should.equal(3);
+                        unsent[0].from.should.equal('bws@dummy.net');
+                        unsent[1].from.should.equal('bws@dummy.net');
+                        unsent[2].from.should.equal('bws@dummy.net');
+                        done();
+                    });
+                });
+                server._notify('NewIncomingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 12300000,
+                }, function (err) {
+                    should.not.exist(err);
+                });
+            });
+        });
+    });
+    describe('1-of-N wallet', function () {
+        beforeEach(async function () {
+            ({ server, wallet } = await helpers_1.default.createAndJoinWallet(1, 2));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await util_1.default.promisify(s.savePreferences).call(s, {
+                    email: 'copayer' + (i + 1) + '@domain.com',
+                    unit: 'bit',
+                });
+            }
+            mailerStub = sinon_1.default.stub();
+            mailerStub.send = sinon_1.default.stub();
+            mailerStub.send.resolves('ok');
+            emailService = new emailservice_1.EmailService();
+            await util_1.default.promisify(emailService.start).call(emailService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                mailer: mailerStub,
+                emailOpts: {
+                    mailer: 'sendgrid',
+                    sendGridApiKey: 'asdf',
+                    from: 'bws@dummy.net',
+                    subjectPrefix: '[test wallet]',
+                    publicTxUrlTemplate: {
+                        btc: {
+                            livenet: 'https://insight.bitpay.com/tx/{{txid}}',
+                            testnet: 'https://test-insight.bitpay.com/tx/{{txid}}',
+                        },
+                        bch: {
+                            livenet: 'https://bch-insight.bitpay.com/#/tx/{{txid}}',
+                            testnet: 'https://test-bch-insight.bitpay.com/#/tx/{{txid}}',
+                        }
+                    },
+                },
+            });
+            emailService.mailer = mailerStub;
+            emailService.sendMail = mailerStub.send;
+        });
+        it('should NOT notify copayers a new tx proposal has been created', async function () {
+            await helpers_1.default.stubUtxos(server, wallet, [1, 1]);
+            const txOpts = {
+                outputs: [{
+                        toAddress: '18PzpUFkFZE8zKWUPvfykkTxmB9oMR8qP7',
+                        amount: 0.8e8
+                    }],
+                feePerKb: 100e2
+            };
+            await helpers_1.default.createAndPublishTx(server, txOpts, TestData.copayers[0].privKey_1H_0);
+            await sleep(100);
+            const calls = mailerStub.send.getCalls();
+            calls.length.should.equal(0);
+        });
+    });
+    describe('1-1 wallet', function () {
+        beforeEach(async function () {
+            ({ server, wallet } = await helpers_1.default.createAndJoinWallet(1, 1, { coin: 'bch' }));
+            for (let i = 0; i < wallet.copayers.length; i++) {
+                const copayer = wallet.copayers[i];
+                const s = await helpers_1.default.getAuthServer(copayer.id);
+                await util_1.default.promisify(s.savePreferences).call(s, {
+                    email: 'copayer' + (i + 1) + '@domain.com',
+                    unit: 'bit',
+                });
+            }
+            mailerStub = sinon_1.default.stub();
+            mailerStub.send = sinon_1.default.stub();
+            mailerStub.send.returns(Promise.resolve('ok'));
+            emailService = new emailservice_1.EmailService();
+            await util_1.default.promisify(emailService.start).call(emailService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                mailer: mailerStub,
+                emailOpts: {
+                    mailer: 'sendgrid',
+                    sendGridApiKey: 'asdf',
+                    from: 'bws@dummy.net',
+                    subjectPrefix: '[test wallet]',
+                    publicTxUrlTemplate: {
+                        btc: {
+                            livenet: 'https://insight.bitpay.com/tx/{{txid}}',
+                            testnet: 'https://test-insight.bitpay.com/tx/{{txid}}',
+                        },
+                        bch: {
+                            livenet: 'https://bch-insight.bitpay.com/#/tx/{{txid}}',
+                            testnet: 'https://test-bch-insight.bitpay.com/#/tx/{{txid}}',
+                        }
+                    },
+                },
+            });
+            emailService.mailer = mailerStub;
+            emailService.sendMail = mailerStub.send;
+        });
+        it('should handle small incomming payments (bch)', function (done) {
+            server.createAddress({}, function (err, address) {
+                should.not.exist(err);
+                sendEmailInterceptor(function () {
+                    const calls = mailerStub.send.getCalls();
+                    calls.length.should.equal(1);
+                    const emails = calls.map(c => c.args[0]);
+                    Utils.difference(['copayer1@domain.com'], emails.map(e => e.to)).should.be.empty;
+                    const one = emails[0];
+                    one.from.should.equal('bws@dummy.net');
+                    one.subject.should.contain('New payment received');
+                    one.text.should.contain('0.002213 BCH');
+                    server.storage.fetchUnsentEmails(function (err, unsent) {
+                        should.not.exist(err);
+                        unsent.should.be.empty;
+                        done();
+                    });
+                });
+                server._notify('NewIncomingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 221340,
+                }, function (err) {
+                    should.not.exist(err);
+                });
+            });
+        });
+    });
+    describe('custom ERC20 wallet', () => {
+        beforeEach(async () => {
+            ({ server, wallet } = 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 util_1.default.promisify(s.savePreferences).call(s, {
+                    email: 'copayer' + (i + 1) + '@domain.com',
+                    unit: 'bit',
+                });
+            }
+            mailerStub = sinon_1.default.stub();
+            mailerStub.send = sinon_1.default.stub();
+            mailerStub.send.returns(Promise.resolve('ok'));
+            emailService = new emailservice_1.EmailService();
+            getTokenDataStub = sinon_1.default.stub(emailService, 'getTokenData').callsFake(() => TestData.CoinGecko_ETH_Tokens.tokens);
+            await util_1.default.promisify(emailService.start).call(emailService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                mailer: mailerStub,
+                emailOpts: {
+                    mailer: 'sendgrid',
+                    sendGridApiKey: 'asdf',
+                    from: 'bws@dummy.net',
+                    subjectPrefix: '[test wallet]',
+                    publicTxUrlTemplate: {
+                        btc: {
+                            livenet: 'https://insight.bitpay.com/tx/{{txid}}',
+                            testnet: 'https://test-insight.bitpay.com/tx/{{txid}}',
+                        },
+                        bch: {
+                            livenet: 'https://bch-insight.bitpay.com/#/tx/{{txid}}',
+                            testnet: 'https://test-bch-insight.bitpay.com/#/tx/{{txid}}',
+                        },
+                        eth: {
+                            livenet: 'https://etherscan.io/tx/{{txid}}',
+                            testnet: 'https://kovan.etherscan.io/tx/{{txid}}',
+                        },
+                    },
+                },
+            });
+            emailService.mailer = mailerStub;
+            emailService.sendMail = mailerStub.send;
+        });
+        it('should send notification if the tx is custom token', (done) => {
+            server.createAddress({}, (err, address) => {
+                should.not.exist(err);
+                sendEmailInterceptor(function () {
+                    const calls = mailerStub.send.getCalls();
+                    calls.length.should.equal(1);
+                    const emails = calls.map(c => c.args[0]);
+                    Utils.difference(['copayer1@domain.com'], emails.map(e => e.to)).should.be.empty;
+                    const one = emails[0];
+                    one.from.should.equal('bws@dummy.net');
+                    one.subject.should.contain('New payment received');
+                    one.text.should.contain('4.00 BAT');
+                    server.storage.fetchUnsentEmails(function (err, unsent) {
+                        should.not.exist(err);
+                        unsent.should.be.empty;
+                        done();
+                    });
+                });
+                server._notify('NewIncomingTx', {
+                    txid: '999',
+                    address: address,
+                    amount: 4e18,
+                    tokenAddress: CUSTOM_TOKENS[0]
+                }, {
+                    isGlobal: true
+                }, (err) => {
+                    should.not.exist(err);
+                });
+            });
+        });
+    });
+    describe('ERC20 wallet', () => {
+        beforeEach(async () => {
+            ({ server, wallet } = 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 util_1.default.promisify(s.savePreferences).call(s, {
+                    email: 'copayer' + (i + 1) + '@domain.com',
+                    unit: 'bit',
+                });
+            }
+            mailerStub = sinon_1.default.stub();
+            mailerStub.send = sinon_1.default.stub();
+            mailerStub.send.returns(Promise.resolve('ok'));
+            emailService = new emailservice_1.EmailService();
+            await util_1.default.promisify(emailService.start).call(emailService, {
+                lockOpts: {},
+                messageBroker: server.messageBroker,
+                storage: helpers_1.default.getStorage(),
+                mailer: mailerStub,
+                emailOpts: {
+                    mailer: 'sendgrid',
+                    sendGridApiKey: 'asdf',
+                    from: 'bws@dummy.net',
+                    subjectPrefix: '[test wallet]',
+                    publicTxUrlTemplate: {
+                        btc: {
+                            livenet: 'https://insight.bitpay.com/tx/{{txid}}',
+                            testnet: 'https://test-insight.bitpay.com/tx/{{txid}}',
+                        },
+                        bch: {
+                            livenet: 'https://bch-insight.bitpay.com/#/tx/{{txid}}',
+                            testnet: 'https://test-bch-insight.bitpay.com/#/tx/{{txid}}',
+                        },
+                        eth: {
+                            livenet: 'https://etherscan.io/tx/{{txid}}',
+                            testnet: 'https://kovan.etherscan.io/tx/{{txid}}',
+                        },
+                    },
+                },
+            });
+            emailService.mailer = mailerStub;
+            emailService.sendMail = mailerStub.send;
+        });
+        it('should send notification if the tx is USDC', (done) => {
+            server.createAddress({}, (err, address) => {
+                should.not.exist(err);
+                sendEmailInterceptor(function () {
+                    const calls = mailerStub.send.getCalls();
+                    calls.length.should.equal(1);
+                    const emails = calls.map(c => c.args[0]);
+                    Utils.difference(['copayer1@domain.com'], emails.map(e => e.to)).should.be.empty;
+                    const one = emails[0];
+                    one.from.should.equal('bws@dummy.net');
+                    one.subject.should.contain('New payment received');
+                    one.text.should.contain('4.00 USDC');
+                    server.storage.fetchUnsentEmails(function (err, unsent) {
+                        should.not.exist(err);
+                        unsent.should.be.empty;
+                        done();
+                    });
+                });
+                server._notify('NewIncomingTx', {
+                    txid: '997',
+                    address: address,
+                    amount: 4e6,
+                    tokenAddress: TOKENS[0]
+                }, {
+                    isGlobal: true
+                }, (err) => {
+                    should.not.exist(err);
+                });
+            });
+        });
+        it('should send notification if the tx is USDP', (done) => {
+            server.createAddress({}, (err, address) => {
+                should.not.exist(err);
+                sendEmailInterceptor(function () {
+                    const calls = mailerStub.send.getCalls();
+                    calls.length.should.equal(1);
+                    const emails = calls.map(c => c.args[0]);
+                    Utils.difference(['copayer1@domain.com'], emails.map(e => e.to)).should.be.empty;
+                    const one = emails[0];
+                    one.from.should.equal('bws@dummy.net');
+                    one.subject.should.contain('New payment received');
+                    one.text.should.contain('4.00 USDP');
+                    server.storage.fetchUnsentEmails(function (err, unsent) {
+                        should.not.exist(err);
+                        unsent.should.be.empty;
+                        done();
+                    });
+                });
+                server._notify('NewIncomingTx', {
+                    txid: '997',
+                    address: address,
+                    amount: 4e18,
+                    tokenAddress: TOKENS[1]
+                }, {
+                    isGlobal: true
+                }, (err) => {
+                    should.not.exist(err);
+                });
+            });
+        });
+        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);
+                    sendEmailInterceptor(function () {
+                        const calls = mailerStub.send.getCalls();
+                        calls.length.should.equal(0);
+                        done();
+                    });
+                    server._notify('NewIncomingTx', {
+                        txid: '999',
+                        address: address,
+                        amount: 1230000000,
+                        tokenAddress: 'notSupportedTokenAddress'
+                    }, {
+                        isGlobal: true
+                    }, (err) => {
+                        should.not.exist(err);
+                    });
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=emailnotifications.test.js.map